From 3aebbcbbb86aae2ca27d19e7a08924a72853927d Mon Sep 17 00:00:00 2001
From: archipelago <archipelago@localhost>
Date: Thu, 16 Jul 2026 21:49:09 -0400
Subject: [PATCH] =?UTF-8?q?feat(setup):=20Zeus=20lightning=20journey=20?=
 =?UTF-8?q?=E2=80=94=20fund-wallet=20step,=20IBD=20timer=20+=20finish-setu?=
 =?UTF-8?q?p=20toast,=20channel=20suggestions?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Every Lightning setup (Open a Shop, Accept Payments, Run a Lightning Node)
gains a guided path to a working channel:

- New "Fund Your Bitcoin Wallet" step, gated on the blockchain finishing
  its initial sync: while syncing it shows a live progress bar with a
  counting-down time-remaining estimate; once synced it shows the on-chain
  balance and a "Fund Wallet" button that opens the receive modal with a
  fresh address, QR, and the Zeus channel limits (min 150,000 / max
  1,500,000 sats) noted.
- When the sync finishes while a Lightning setup is mid-flight, a toast
  pops with a "Finish setup" link straight back to the wizard (toasts now
  support action links). If several setups are in flight, one is chosen —
  the shared steps complete the lightning part of any of them.
- Channel steps are Zeus-branded (logo + copy) and land on the Lightning
  Channels screen, which now carries an "Open a channel with Zeus" card
  that prefills the open-channel modal with the Olympus peer URI, 150k
  sats, and private-channel checked. "Get Zeus" links to zeusln.com.
- Setup completion now actually requires walking the manual steps (fund,
  open channel, configure) — previously any step whose app was installed
  was silently auto-ticked and running apps marked the whole goal done.
- Completion CTAs now go to the app you just set up ("Go to my shop
  (BTCPay)" etc.) instead of the generic services list; iframe apps open
  in the on-top app overlay.
- On-chain send modal gains a "Send all funds" sweep toggle, backed by
  LND's send_all on the backend (amount no longer required when sweeping).
- Demo/mock: bitcoin.getinfo now returns the block_height/sync_progress
  contract the UI reads and simulates a ~90s IBD ramp per visitor so the
  timer, toast, and fund flow can all be demoed live; channel list data
  fixed (status/channel_point/liquidity totals — the panel previously
  crashed on the missing status field); sendcoins supports send_all.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 core/archipelago/src/api/rpc/lnd/wallet.rs    |  57 ++++--
 neode-ui/mock-backend.js                      |  42 +++--
 .../public/assets/img/app-icons/zeus.webp     | Bin 0 -> 5196 bytes
 .../src/components/LightningChannelsPanel.vue |  72 +++++++-
 .../src/components/ReceiveBitcoinModal.vue    |  19 +-
 neode-ui/src/components/SendBitcoinModal.vue  |  54 +++++-
 neode-ui/src/components/ToastStack.vue        |  16 +-
 neode-ui/src/composables/useBitcoinSync.ts    | 109 ++++++++++++
 .../src/composables/useIbdFinishWatcher.ts    |  90 ++++++++++
 neode-ui/src/composables/useToast.ts          |  13 +-
 neode-ui/src/data/goals.ts                    |  50 +++++-
 neode-ui/src/stores/goals.ts                  |  11 +-
 neode-ui/src/types/goals.ts                   |  10 +-
 neode-ui/src/views/Dashboard.vue              |   4 +
 neode-ui/src/views/GoalDetail.vue             | 165 +++++++++++++++++-
 neode-ui/src/views/goals/goalStepActions.ts   |   9 +-
 16 files changed, 658 insertions(+), 63 deletions(-)
 create mode 100644 neode-ui/public/assets/img/app-icons/zeus.webp
 create mode 100644 neode-ui/src/composables/useBitcoinSync.ts
 create mode 100644 neode-ui/src/composables/useIbdFinishWatcher.ts

diff --git a/core/archipelago/src/api/rpc/lnd/wallet.rs b/core/archipelago/src/api/rpc/lnd/wallet.rs
index 71650834..286f84b5 100644
--- a/core/archipelago/src/api/rpc/lnd/wallet.rs
+++ b/core/archipelago/src/api/rpc/lnd/wallet.rs
@@ -95,33 +95,54 @@ impl RpcHandler {
             .get("addr")
             .and_then(|v| v.as_str())
             .ok_or_else(|| anyhow::anyhow!("Missing 'addr' parameter"))?;
-        let amount = params
-            .get("amount")
-            .and_then(|v| v.as_i64())
-            .ok_or_else(|| anyhow::anyhow!("Missing 'amount' parameter (sats)"))?;
-
-        if amount < 546 {
-            return Err(anyhow::anyhow!(
-                "Amount must be at least 546 sats (dust limit)"
-            ));
-        }
-        if amount > 21_000_000 * 100_000_000 {
-            return Err(anyhow::anyhow!("Amount exceeds maximum Bitcoin supply"));
-        }
+        // send_all sweeps the entire confirmed on-chain balance (LND computes
+        // the amount after fees); amount is required otherwise.
+        let send_all = params
+            .get("send_all")
+            .and_then(|v| v.as_bool())
+            .unwrap_or(false);
+        let amount = if send_all {
+            None
+        } else {
+            let amount = params
+                .get("amount")
+                .and_then(|v| v.as_i64())
+                .ok_or_else(|| anyhow::anyhow!("Missing 'amount' parameter (sats)"))?;
+            if amount < 546 {
+                return Err(anyhow::anyhow!(
+                    "Amount must be at least 546 sats (dust limit)"
+                ));
+            }
+            if amount > 21_000_000 * 100_000_000 {
+                return Err(anyhow::anyhow!("Amount exceeds maximum Bitcoin supply"));
+            }
+            Some(amount)
+        };
 
         // Validate Bitcoin address format (basic: length and allowed chars)
         if addr.len() < 14 || addr.len() > 90 || !addr.chars().all(|c| c.is_ascii_alphanumeric()) {
             return Err(anyhow::anyhow!("Invalid Bitcoin address format"));
         }
 
-        info!(addr = addr, amount = amount, "Sending on-chain Bitcoin");
+        info!(
+            addr = addr,
+            amount = amount,
+            send_all = send_all,
+            "Sending on-chain Bitcoin"
+        );
 
         let (client, macaroon_hex) = self.lnd_client().await?;
 
-        let send_body = serde_json::json!({
-            "addr": addr,
-            "amount": amount.to_string(),
-        });
+        let send_body = match amount {
+            Some(amount) => serde_json::json!({
+                "addr": addr,
+                "amount": amount.to_string(),
+            }),
+            None => serde_json::json!({
+                "addr": addr,
+                "send_all": true,
+            }),
+        };
 
         let resp = client
             .post(format!("{LND_REST_BASE_URL}/v1/transactions"))
diff --git a/neode-ui/mock-backend.js b/neode-ui/mock-backend.js
index 36b476c0..75eaf731 100755
--- a/neode-ui/mock-backend.js
+++ b/neode-ui/mock-backend.js
@@ -3394,14 +3394,19 @@ app.post('/rpc/v1', (req, res) => {
       }
 
       case 'lnd.listchannels': {
+        // Shape matches the real backend: status + channel_point are required
+        // by the channels panel; totals feed the liquidity summary tiles.
+        const channels = [
+          { chan_id: '840921088114688', remote_pubkey: '031b301307574bbe9b9ac7b79cbe1700e31e544513eae0b5d7497483083f99e581', capacity: 1500000, local_balance: 950000, remote_balance: 550000, active: true, status: 'active', channel_point: randomHex(32) + ':0', peer_alias: 'Olympus by ZEUS' },
+          { chan_id: '840921088114689', remote_pubkey: '03abcdef12345678901234567890123456789012345678901234567890abcdef12', capacity: 2000000, local_balance: 1200000, remote_balance: 800000, active: true, status: 'active', channel_point: randomHex(32) + ':1', peer_alias: 'WalletOfSatoshi' },
+          { chan_id: '840921088114690', remote_pubkey: '02fedcba98765432109876543210987654321098765432109876543210fedcba98', capacity: 10000000, local_balance: 4500000, remote_balance: 5500000, active: true, status: 'active', channel_point: randomHex(32) + ':0', peer_alias: 'Voltage' },
+          { chan_id: '840921088114691', remote_pubkey: '03456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123', capacity: 3000000, local_balance: 100000, remote_balance: 2900000, active: false, status: 'inactive', channel_point: randomHex(32) + ':0', peer_alias: 'Kraken' },
+        ]
         return res.json({
           result: {
-            channels: [
-              { chan_id: '840921088114688', remote_pubkey: '02778f4a', capacity: 5000000, local_balance: 2450000, remote_balance: 2550000, active: true, peer_alias: 'ACINQ Signet' },
-              { chan_id: '840921088114689', remote_pubkey: '03abcdef', capacity: 2000000, local_balance: 1200000, remote_balance: 800000, active: true, peer_alias: 'WalletOfSatoshi' },
-              { chan_id: '840921088114690', remote_pubkey: '02fedcba', capacity: 10000000, local_balance: 4500000, remote_balance: 5500000, active: true, peer_alias: 'Voltage' },
-              { chan_id: '840921088114691', remote_pubkey: '03456789', capacity: 3000000, local_balance: 100000, remote_balance: 2900000, active: true, peer_alias: 'Kraken' },
-            ],
+            channels,
+            total_outbound: channels.reduce((s, c) => s + c.local_balance, 0),
+            total_inbound: channels.reduce((s, c) => s + c.remote_balance, 0),
           },
         })
       }
@@ -3445,7 +3450,10 @@ app.post('/rpc/v1', (req, res) => {
       }
 
       case 'lnd.sendcoins': {
-        const amt = params?.amount || params?.amt || 50000
+        // send_all sweeps the entire on-chain balance (minus a mock fee)
+        const amt = params?.send_all
+          ? Math.max(0, walletState.onchain_sats - 250)
+          : (params?.amount || params?.amt || 50000)
         walletState.onchain_sats = Math.max(0, walletState.onchain_sats - amt)
         const txid = randomHex(32)
         walletState.transactions.unshift({
@@ -3607,15 +3615,29 @@ app.post('/rpc/v1', (req, res) => {
       }
 
       case 'bitcoin.getinfo': {
+        // Demo IBD simulation: the first call of a session arms a ~90s ramp
+        // from 98.2% → 100% so the setup wizard can demo the live sync timer
+        // and the "finish setup" toast that fires when IBD completes.
+        // (The real backend returns { block_height, sync_progress } — a 0–1
+        // fraction — which is what the frontend reads; the bitcoin-core-style
+        // fields are kept for any legacy consumers.)
+        if (!walletState.ibd_started_at) walletState.ibd_started_at = Date.now()
+        const IBD_RAMP_MS = 90_000
+        const elapsed = Date.now() - walletState.ibd_started_at
+        const syncProgress = Math.min(1, 0.982 + 0.018 * (elapsed / IBD_RAMP_MS))
+        const tipHeight = 892451
+        const height = Math.round(tipHeight * syncProgress)
         return res.json({
           result: {
             chain: 'signet',
-            blocks: 892451,
-            headers: 892451,
+            block_height: height,
+            sync_progress: syncProgress,
+            blocks: height,
+            headers: tipHeight,
             bestblockhash: 'a1b2c3d4e5f6' + '0'.repeat(58),
             difficulty: 0.001126515290698186,
             mediantime: Math.floor(Date.now() / 1000) - 300,
-            verificationprogress: 1.0,
+            verificationprogress: syncProgress,
             chainwork: '000000000000000000000000000000000000000000000000000000000001a2b3',
             size_on_disk: 210_000_000,
             pruned: false,
diff --git a/neode-ui/public/assets/img/app-icons/zeus.webp b/neode-ui/public/assets/img/app-icons/zeus.webp
new file mode 100644
index 0000000000000000000000000000000000000000..5ea10aff9d4c1ee1e468f0a7408c1d13cae11e90
GIT binary patch
literal 5196
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
G0000i0zUo#

literal 0
HcmV?d00001

diff --git a/neode-ui/src/components/LightningChannelsPanel.vue b/neode-ui/src/components/LightningChannelsPanel.vue
index 93129af7..92f0435a 100644
--- a/neode-ui/src/components/LightningChannelsPanel.vue
+++ b/neode-ui/src/components/LightningChannelsPanel.vue
@@ -16,6 +16,39 @@
       </div>
     </div>
 
+    <!-- Zeus channel suggestion -->
+    <div class="glass-card p-4 mb-4 border border-orange-500/25">
+      <div class="flex flex-col sm:flex-row sm:items-center gap-4">
+        <img
+          src="/assets/img/app-icons/zeus.webp"
+          alt="Zeus"
+          class="w-12 h-12 rounded-xl shrink-0 border border-white/10"
+        />
+        <div class="flex-1 min-w-0">
+          <p class="text-white/90 text-sm font-semibold mb-0.5">Open a channel with Zeus</p>
+          <p class="text-white/55 text-xs leading-relaxed">
+            Pair your node with the Zeus mobile wallet — open a channel to their Olympus node and
+            start sending and receiving Lightning payments from your phone.
+            Minimum 150,000 · maximum 1,500,000 sats.
+          </p>
+        </div>
+        <div class="flex sm:flex-col items-center gap-2 shrink-0">
+          <button
+            @click="openZeusChannel"
+            class="glass-button glass-button-warning px-4 py-2 rounded-lg text-sm font-medium whitespace-nowrap"
+          >
+            Open Channel
+          </button>
+          <a
+            href="https://zeusln.com"
+            target="_blank"
+            rel="noopener noreferrer"
+            class="text-xs text-orange-400/80 hover:text-orange-300 whitespace-nowrap"
+          >Get Zeus →</a>
+        </div>
+      </div>
+    </div>
+
     <!-- Open Channel Button -->
     <div class="flex justify-end mb-4">
       <button @click="showOpenModal = true" class="glass-button px-4 py-2 rounded-lg text-sm font-medium flex items-center gap-2">
@@ -74,15 +107,15 @@
             <span
               class="w-2 h-2 rounded-full"
               :class="{
-                'bg-green-400': ch.status === 'active',
-                'bg-yellow-400': ch.status === 'pending_open',
-                'bg-red-400': ch.status === 'inactive',
+                'bg-green-400': channelStatus(ch) === 'active',
+                'bg-yellow-400': channelStatus(ch) === 'pending_open',
+                'bg-red-400': channelStatus(ch) === 'inactive',
               }"
             ></span>
-            <span class="text-white/80 text-sm font-medium capitalize">{{ ch.status.replace('_', ' ') }}</span>
+            <span class="text-white/80 text-sm font-medium capitalize">{{ channelStatus(ch).replace('_', ' ') }}</span>
           </div>
           <button
-            v-if="ch.status !== 'pending_open'"
+            v-if="channelStatus(ch) !== 'pending_open'"
             @click="confirmClose(ch)"
             class="text-red-400/70 hover:text-red-400 text-xs transition-colors"
           >
@@ -270,8 +303,13 @@ interface Channel {
   local_balance: number
   remote_balance: number
   active: boolean
-  status: string
-  channel_point: string
+  status?: string
+  channel_point?: string
+}
+
+/** Status with a fallback derived from `active` for backends that omit it */
+function channelStatus(ch: Channel): string {
+  return ch.status ?? (ch.active ? 'active' : 'inactive')
 }
 
 type FeePreset = 'standard' | 'medium' | 'fast' | 'custom'
@@ -288,6 +326,11 @@ const error = ref<string | null>(null)
 const channels = ref<Channel[]>([])
 const summary = ref({ total_inbound: 0, total_outbound: 0 })
 
+// Olympus by ZEUS — the LSP node behind the Zeus mobile wallet.
+// Channel limits: min 150,000 / max 1,500,000 sats.
+const OLYMPUS_PEER_URI =
+  '031b301307574bbe9b9ac7b79cbe1700e31e544513eae0b5d7497483083f99e581@45.79.192.236:9735'
+
 const showOpenModal = ref(false)
 const defaultOpenForm = () => ({
   peerUri: '',
@@ -297,6 +340,19 @@ const defaultOpenForm = () => ({
   customConfTarget: null as number | null,
   customSatPerVbyte: null as number | null,
 })
+
+/** Prefill the open-channel modal for a Zeus (Olympus) channel */
+function openZeusChannel() {
+  openForm.value = {
+    ...defaultOpenForm(),
+    peerUri: OLYMPUS_PEER_URI,
+    amount: 150000,
+    // Olympus only accepts unannounced channels
+    private: true,
+  }
+  openError.value = null
+  showOpenModal.value = true
+}
 const openForm = ref(defaultOpenForm())
 const openingChannel = ref(false)
 const openError = ref<string | null>(null)
@@ -313,7 +369,7 @@ function formatSats(sats: number): string {
 }
 
 function fundingTxid(ch: Channel): string {
-  const txid = ch.channel_point.split(':')[0] || ''
+  const txid = ch.channel_point?.split(':')[0] || ''
   return /^[0-9a-fA-F]{64}$/.test(txid) ? txid : ''
 }
 
diff --git a/neode-ui/src/components/ReceiveBitcoinModal.vue b/neode-ui/src/components/ReceiveBitcoinModal.vue
index a120a1c7..dabafda8 100644
--- a/neode-ui/src/components/ReceiveBitcoinModal.vue
+++ b/neode-ui/src/components/ReceiveBitcoinModal.vue
@@ -31,6 +31,9 @@
 
         <!-- On-chain -->
         <div v-if="receiveMethod === 'onchain'">
+          <div v-if="note" class="mb-3 p-3 rounded-lg bg-orange-500/10 border border-orange-500/20 text-sm text-white/80 leading-relaxed">
+            {{ note }}
+          </div>
           <div v-if="onchainAddress" class="mb-3 p-3 bg-white/5 rounded-lg text-center">
             <canvas ref="onchainQrCanvas" class="mx-auto mb-3 rounded-lg" style="image-rendering: pixelated;"></canvas>
             <p class="text-white/50 text-xs mb-2">{{ t('receiveBitcoin.yourBitcoinAddress') }}</p>
@@ -77,7 +80,7 @@
 </template>
 
 <script setup lang="ts">
-import { ref, nextTick } from 'vue'
+import { ref, nextTick, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { rpcClient } from '@/api/rpc-client'
 import BaseModal from '@/components/BaseModal.vue'
@@ -85,9 +88,21 @@ import { explainReceiveAddressFailure } from '@/utils/bitcoinReceive'
 
 const { t } = useI18n()
 
-defineProps<{ show: boolean }>()
+const props = defineProps<{
+  show: boolean
+  /** Optional info banner shown on the on-chain tab (e.g. Zeus channel limits) */
+  note?: string
+  /** Generate an on-chain address immediately when the modal opens */
+  autoGenerate?: boolean
+}>()
 const emit = defineEmits<{ close: []; received: [] }>()
 
+watch(() => props.show, (open) => {
+  if (open && props.autoGenerate && receiveMethod.value === 'onchain' && !onchainAddress.value) {
+    void receive()
+  }
+})
+
 const receiveMethod = ref<'lightning' | 'onchain' | 'ecash' | 'ark'>('onchain')
 const invoiceAmount = ref<number>(0)
 const invoiceMemo = ref('')
diff --git a/neode-ui/src/components/SendBitcoinModal.vue b/neode-ui/src/components/SendBitcoinModal.vue
index ceb3ada7..8730187d 100644
--- a/neode-ui/src/components/SendBitcoinModal.vue
+++ b/neode-ui/src/components/SendBitcoinModal.vue
@@ -16,8 +16,30 @@
         </div>
 
         <div class="mb-3">
-          <label class="text-white/60 text-sm block mb-1">{{ t('sendBitcoin.amountSats') }}</label>
-          <input v-model.number="amount" type="number" min="1" placeholder="1000" class="w-full input-glass" />
+          <div class="flex items-center justify-between mb-1">
+            <label class="text-white/60 text-sm">{{ t('sendBitcoin.amountSats') }}</label>
+            <button
+              v-if="sendMethod === 'onchain'"
+              @click="toggleSendAll"
+              class="text-xs px-2 py-0.5 rounded border transition-colors"
+              :class="sendAll
+                ? 'bg-orange-500/20 border-orange-500/40 text-orange-300'
+                : 'bg-white/5 border-white/15 text-white/60 hover:text-white/90'"
+            >
+              Send all funds
+            </button>
+          </div>
+          <input
+            v-model.number="amount"
+            type="number"
+            min="1"
+            :placeholder="sendAll ? '' : '1000'"
+            :disabled="sendAll"
+            class="w-full input-glass disabled:opacity-50"
+          />
+          <p v-if="sendAll" class="text-xs text-white/50 mt-1">
+            Sweeps your entire on-chain balance{{ onchainBalance !== null ? ` (~${onchainBalance.toLocaleString()} sats)` : '' }} minus network fees.
+          </p>
         </div>
 
         <div v-if="effectiveMethod !== 'ecash'" class="mb-3">
@@ -47,7 +69,7 @@
 
         <div class="flex gap-3">
           <button @click="close" class="flex-1 glass-button px-4 py-2 rounded-lg text-sm">{{ t('common.close') }}</button>
-          <button @click="send" :disabled="processing || !amount" class="flex-1 glass-button glass-button-warning px-4 py-2 rounded-lg text-sm font-medium disabled:opacity-50">
+          <button @click="send" :disabled="processing || (!amount && !isSweep)" class="flex-1 glass-button glass-button-warning px-4 py-2 rounded-lg text-sm font-medium disabled:opacity-50">
             {{ processing ? t('common.sending') : t('common.send') }}
           </button>
         </div>
@@ -55,7 +77,7 @@
 </template>
 
 <script setup lang="ts">
-import { ref, computed } from 'vue'
+import { ref, computed, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { rpcClient } from '@/api/rpc-client'
 import BaseModal from '@/components/BaseModal.vue'
@@ -75,6 +97,23 @@ const resultHash = ref('')
 const resultArk = ref('')
 const ecashToken = ref('')
 
+// "Send all funds" — sweeps the whole on-chain balance (explicit on-chain tab only)
+const sendAll = ref(false)
+const onchainBalance = ref<number | null>(null)
+const isSweep = computed(() => sendMethod.value === 'onchain' && sendAll.value)
+
+function toggleSendAll() {
+  sendAll.value = !sendAll.value
+  if (sendAll.value && onchainBalance.value === null) {
+    rpcClient.call<{ balance_sats: number }>({ method: 'lnd.getinfo', timeout: 5000 })
+      .then((res) => { onchainBalance.value = res.balance_sats || 0 })
+      .catch(() => { /* balance hint is best-effort */ })
+  }
+}
+
+// Leaving the on-chain tab disarms the sweep so it can never apply elsewhere
+watch(sendMethod, (m) => { if (m !== 'onchain') sendAll.value = false })
+
 const effectiveMethod = computed(() => {
   if (sendMethod.value !== 'auto') return sendMethod.value
   const amt = amount.value || 0
@@ -98,7 +137,8 @@ function copyText(text: string) {
 }
 
 async function send() {
-  if (!amount.value || processing.value) return
+  if (processing.value) return
+  if (!amount.value && !isSweep.value) return
   processing.value = true
   error.value = ''
   ecashToken.value = ''
@@ -134,7 +174,9 @@ async function send() {
       if (!dest.value.trim()) { error.value = t('web5.enterBitcoinAddress'); return }
       const res = await rpcClient.call<{ txid: string }>({
         method: 'lnd.sendcoins',
-        params: { addr: dest.value.trim(), amount: amount.value },
+        params: isSweep.value
+          ? { addr: dest.value.trim(), send_all: true }
+          : { addr: dest.value.trim(), amount: amount.value },
       })
       resultTxid.value = res.txid
     }
diff --git a/neode-ui/src/components/ToastStack.vue b/neode-ui/src/components/ToastStack.vue
index b35ca4b8..6bb5bb88 100644
--- a/neode-ui/src/components/ToastStack.vue
+++ b/neode-ui/src/components/ToastStack.vue
@@ -23,7 +23,14 @@
               <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
             </svg>
           </div>
-          <span class="text-sm text-white/90 flex-1">{{ toast.message }}</span>
+          <div class="flex-1 min-w-0">
+            <span class="text-sm text-white/90">{{ toast.message }}</span>
+            <button
+              v-if="toast.action"
+              @click.stop="runAction(toast)"
+              class="block mt-1 text-sm font-semibold text-orange-400 hover:text-orange-300 transition-colors"
+            >{{ toast.action.label }} →</button>
+          </div>
         </div>
       </TransitionGroup>
     </div>
@@ -32,10 +39,15 @@
 
 <script setup lang="ts">
 import { useToast } from '@/composables/useToast'
-import type { ToastVariant } from '@/composables/useToast'
+import type { ToastItem, ToastVariant } from '@/composables/useToast'
 
 const { toasts, dismiss } = useToast()
 
+function runAction(toast: ToastItem | Readonly<ToastItem>) {
+  toast.action?.onClick()
+  dismiss(toast.id)
+}
+
 function variantClass(variant: ToastVariant): string {
   switch (variant) {
     case 'success': return 'bg-black/70 border-green-500/30 backdrop-blur-md'
diff --git a/neode-ui/src/composables/useBitcoinSync.ts b/neode-ui/src/composables/useBitcoinSync.ts
new file mode 100644
index 00000000..b02b33a2
--- /dev/null
+++ b/neode-ui/src/composables/useBitcoinSync.ts
@@ -0,0 +1,109 @@
+import { ref, computed } from 'vue'
+import { rpcClient } from '@/api/rpc-client'
+
+/**
+ * Shared bitcoin sync (IBD) tracker with a live time-remaining estimate.
+ *
+ * Polls `bitcoin.getinfo` while at least one consumer holds an acquire()
+ * lease, samples the sync rate, and exposes a ticking countdown so setup
+ * screens can show "~2h 14m remaining" that visibly counts down between
+ * polls. Module-level singleton — every consumer sees the same state.
+ */
+
+/** Sync fraction (as percent) at which we consider IBD done, matching the Home tile */
+export const IBD_SYNCED_AT = 99.9
+
+const POLL_MS = 15_000
+const TICK_MS = 1_000
+/** Ignore rate samples older than this when estimating */
+const SAMPLE_WINDOW_MS = 10 * 60_000
+
+export const bitcoinSyncPercent = ref(0)
+export const bitcoinBlockHeight = ref(0)
+export const bitcoinSyncAvailable = ref(false)
+export const bitcoinSyncLoaded = ref(false)
+export const bitcoinSynced = computed(() => bitcoinSyncLoaded.value && bitcoinSyncPercent.value >= IBD_SYNCED_AT)
+
+const etaSeconds = ref<number | null>(null)
+
+/** Human countdown like "2h 14m" / "5m 12s" / "less than a minute", or '' while estimating */
+export const bitcoinSyncEtaText = computed(() => {
+  const s = etaSeconds.value
+  if (s === null) return ''
+  if (s < 60) return 'less than a minute'
+  const h = Math.floor(s / 3600)
+  const m = Math.floor((s % 3600) / 60)
+  if (h > 0) return `${h}h ${m}m`
+  const sec = Math.floor(s % 60)
+  return `${m}m ${sec}s`
+})
+
+let samples: { t: number; p: number }[] = []
+let etaBase: { at: number; secs: number } | null = null
+let pollTimer: ReturnType<typeof setInterval> | null = null
+let tickTimer: ReturnType<typeof setInterval> | null = null
+let leases = 0
+
+async function poll() {
+  try {
+    const btc = await rpcClient.call<{ block_height: number; sync_progress: number }>({
+      method: 'bitcoin.getinfo',
+      timeout: 8000,
+    })
+    const pct = (btc.sync_progress ?? 0) * 100
+    bitcoinSyncPercent.value = pct
+    bitcoinBlockHeight.value = btc.block_height ?? 0
+    bitcoinSyncAvailable.value = true
+    bitcoinSyncLoaded.value = true
+
+    const now = Date.now()
+    samples.push({ t: now, p: pct })
+    samples = samples.filter((s) => now - s.t <= SAMPLE_WINDOW_MS).slice(-50)
+
+    if (pct >= IBD_SYNCED_AT) {
+      etaBase = null
+      etaSeconds.value = 0
+      return
+    }
+    const first = samples[0]
+    if (first && now - first.t >= 10_000 && pct > first.p) {
+      const ratePerSec = (pct - first.p) / ((now - first.t) / 1000)
+      etaBase = { at: now, secs: (IBD_SYNCED_AT - pct) / ratePerSec }
+    }
+  } catch {
+    bitcoinSyncAvailable.value = false
+  }
+}
+
+function tick() {
+  if (!etaBase) {
+    if (!bitcoinSynced.value) etaSeconds.value = null
+    return
+  }
+  etaSeconds.value = Math.max(0, etaBase.secs - (Date.now() - etaBase.at) / 1000)
+}
+
+/**
+ * Hold a polling lease. Returns a release function — call it on unmount.
+ * Polling only runs while at least one lease is held.
+ */
+export function acquireBitcoinSync(): () => void {
+  leases++
+  if (leases === 1) {
+    void poll()
+    pollTimer = setInterval(() => void poll(), POLL_MS)
+    tickTimer = setInterval(tick, TICK_MS)
+  }
+  let released = false
+  return () => {
+    if (released) return
+    released = true
+    leases = Math.max(0, leases - 1)
+    if (leases === 0) {
+      if (pollTimer) clearInterval(pollTimer)
+      if (tickTimer) clearInterval(tickTimer)
+      pollTimer = null
+      tickTimer = null
+    }
+  }
+}
diff --git a/neode-ui/src/composables/useIbdFinishWatcher.ts b/neode-ui/src/composables/useIbdFinishWatcher.ts
new file mode 100644
index 00000000..4344b1d0
--- /dev/null
+++ b/neode-ui/src/composables/useIbdFinishWatcher.ts
@@ -0,0 +1,90 @@
+import { computed, watch, watchEffect, onUnmounted } from 'vue'
+import { useRouter } from 'vue-router'
+import { GOALS } from '@/data/goals'
+import { useGoalStore } from '@/stores/goals'
+import { useToast } from '@/composables/useToast'
+import {
+  acquireBitcoinSync,
+  bitcoinSynced,
+  bitcoinSyncLoaded,
+} from '@/composables/useBitcoinSync'
+
+// Session-level guard: the "finish setup" toast fires at most once per page load.
+let firedThisSession = false
+
+/**
+ * Watches for Bitcoin IBD completing while a Lightning setup goal is mid-flight
+ * and pops a "Finish setup" toast linking back to that goal's wizard (which is
+ * sitting on the fund-wallet / open-channel steps). Mount once in the
+ * dashboard layout.
+ */
+export function useIbdFinishWatcher() {
+  const goalStore = useGoalStore()
+  const router = useRouter()
+  const toast = useToast()
+
+  // A goal qualifies while it's in progress and its manual fund/channel steps
+  // aren't done yet. If several qualify, the first wins — finishing the shared
+  // fund + channel steps completes the lightning part of any of them.
+  const pendingLightningGoalId = computed<string | null>(() => {
+    if (firedThisSession) return null
+    for (const goal of GOALS) {
+      const hasFundStep = goal.steps.some((s) => s.action === 'fund')
+      if (!hasFundStep) continue
+      if (goalStore.getGoalStatus(goal.id) !== 'in-progress') continue
+      const done = goalStore.progress[goal.id]?.completedSteps ?? []
+      const manualPending = goal.steps.some(
+        (s) => s.action !== 'install' && !done.includes(s.id),
+      )
+      if (manualPending) return goal.id
+    }
+    return null
+  })
+
+  // Only poll the chain while there's actually a goal waiting on it.
+  let release: (() => void) | null = null
+  watchEffect(() => {
+    const shouldWatch = pendingLightningGoalId.value !== null && !bitcoinSynced.value
+    if (shouldWatch && !release) {
+      release = acquireBitcoinSync()
+    } else if (!shouldWatch && release) {
+      // Goal finished/reset or the chain synced — stop polling.
+      release()
+      release = null
+    }
+  })
+
+  // Fire only on a REAL transition: we must have observed the chain unsynced
+  // at least once this session, so a node that's already synced at page load
+  // doesn't toast.
+  let sawUnsynced = false
+  watch([bitcoinSynced, bitcoinSyncLoaded], ([synced, loaded]) => {
+    if (!loaded) return
+    if (!synced) {
+      sawUnsynced = true
+      return
+    }
+    if (!sawUnsynced || firedThisSession) return
+    const goalId = pendingLightningGoalId.value
+    if (!goalId) return
+    firedThisSession = true
+    toast.action(
+      'Bitcoin is fully synced — you can now fund your wallet and open your Lightning channel.',
+      {
+        label: 'Finish setup',
+        onClick: () => { router.push(`/dashboard/goals/${goalId}`) },
+      },
+    )
+    if (release) {
+      release()
+      release = null
+    }
+  })
+
+  onUnmounted(() => {
+    if (release) {
+      release()
+      release = null
+    }
+  })
+}
diff --git a/neode-ui/src/composables/useToast.ts b/neode-ui/src/composables/useToast.ts
index d78de6bf..85462bcb 100644
--- a/neode-ui/src/composables/useToast.ts
+++ b/neode-ui/src/composables/useToast.ts
@@ -2,19 +2,25 @@ import { ref, readonly } from 'vue'
 
 export type ToastVariant = 'success' | 'error' | 'info'
 
+export interface ToastAction {
+  label: string
+  onClick: () => void
+}
+
 export interface ToastItem {
   id: number
   message: string
   variant: ToastVariant
   dismissing: boolean
+  action?: ToastAction
 }
 
 const toasts = ref<ToastItem[]>([])
 let nextId = 0
 
-function addToast(message: string, variant: ToastVariant = 'info', duration = 3000) {
+function addToast(message: string, variant: ToastVariant = 'info', duration = 3000, action?: ToastAction) {
   const id = nextId++
-  toasts.value.push({ id, message, variant, dismissing: false })
+  toasts.value.push({ id, message, variant, dismissing: false, action })
 
   // Auto-dismiss
   if (duration > 0) {
@@ -42,6 +48,9 @@ export function useToast() {
     success: (msg: string) => addToast(msg, 'success'),
     error: (msg: string) => addToast(msg, 'error'),
     info: (msg: string) => addToast(msg, 'info'),
+    /** Toast with an action link (e.g. "Finish setup"). Sticks around longer. */
+    action: (msg: string, action: ToastAction, opts?: { variant?: ToastVariant; duration?: number }) =>
+      addToast(msg, opts?.variant ?? 'success', opts?.duration ?? 15000, action),
     dismiss: dismissToast,
   }
 }
diff --git a/neode-ui/src/data/goals.ts b/neode-ui/src/data/goals.ts
index 908ff33c..7235b2ff 100644
--- a/neode-ui/src/data/goals.ts
+++ b/neode-ui/src/data/goals.ts
@@ -1,4 +1,25 @@
-import type { GoalDefinition } from '@/types/goals'
+import type { GoalDefinition, GoalStep } from '@/types/goals'
+
+/** Zeus (Olympus LSP) channel size limits, in sats */
+export const ZEUS_CHANNEL_MIN_SATS = 150_000
+export const ZEUS_CHANNEL_MAX_SATS = 1_500_000
+
+export const ZEUS_ICON = '/assets/img/app-icons/zeus.webp'
+
+/**
+ * Shared "fund the bitcoin wallet" step used by every Lightning goal. Gated on
+ * the blockchain being fully synced (IBD) — the wizard shows a live sync timer
+ * until then, and a "Fund Wallet" receive flow after.
+ */
+const FUND_WALLET_STEP: GoalStep = {
+  id: 'fund-wallet',
+  title: 'Fund Your Bitcoin Wallet',
+  description:
+    "Send bitcoin to your node's on-chain wallet so it can open a Lightning channel. Zeus channels need between 150,000 and 1,500,000 sats. Funding unlocks once your node finishes syncing the blockchain.",
+  action: 'fund',
+  isAutomatic: false,
+  icon: '/assets/img/app-icons/bitcoin-knots.webp',
+}
 
 export const GOALS: GoalDefinition[] = [
   {
@@ -25,6 +46,17 @@ export const GOALS: GoalDefinition[] = [
         action: 'install',
         isAutomatic: true,
       },
+      { ...FUND_WALLET_STEP },
+      {
+        id: 'open-zeus-channel',
+        title: 'Open a Channel with Zeus',
+        description:
+          'Open a Lightning channel to Zeus, the mobile wallet that pairs perfectly with your node. Fund it with 150,000–1,500,000 sats and your shop can accept instant Lightning payments.',
+        action: 'configure',
+        isAutomatic: false,
+        icon: ZEUS_ICON,
+        ctaLabel: 'Open a channel',
+      },
       {
         id: 'install-btcpay',
         title: 'Install BTCPay Server',
@@ -69,13 +101,16 @@ export const GOALS: GoalDefinition[] = [
         action: 'install',
         isAutomatic: true,
       },
+      { ...FUND_WALLET_STEP },
       {
         id: 'open-channel',
-        title: 'Open a Lightning Channel',
-        description: 'Open your first payment channel to start sending and receiving Lightning payments. LND will guide you through it.',
-        appId: 'lnd',
+        title: 'Open a Channel with Zeus',
+        description:
+          'Open your first payment channel to Zeus, the mobile wallet built for nodes like yours (150,000–1,500,000 sats). You can then send and receive Lightning payments from your phone.',
         action: 'configure',
         isAutomatic: false,
+        icon: ZEUS_ICON,
+        ctaLabel: 'Open a channel',
       },
     ],
     estimatedTime: '~30 min + sync time',
@@ -168,13 +203,16 @@ export const GOALS: GoalDefinition[] = [
         action: 'install',
         isAutomatic: true,
       },
+      { ...FUND_WALLET_STEP },
       {
         id: 'open-channels',
         title: 'Open Payment Channels',
-        description: 'Open channels with well-connected nodes to start routing payments. More channels means more routing opportunities.',
-        appId: 'lnd',
+        description:
+          'Open channels with well-connected nodes to start routing payments. A great first channel is Zeus (150,000–1,500,000 sats) — it also puts your node in your pocket. More channels means more routing opportunities.',
         action: 'configure',
         isAutomatic: false,
+        icon: ZEUS_ICON,
+        ctaLabel: 'Open a channel',
       },
       {
         id: 'verify-routing',
diff --git a/neode-ui/src/stores/goals.ts b/neode-ui/src/stores/goals.ts
index b15179f6..66fe34f3 100644
--- a/neode-ui/src/stores/goals.ts
+++ b/neode-ui/src/stores/goals.ts
@@ -88,12 +88,19 @@ export const useGoalStore = defineStore('goals', () => {
         ([pkgId, pkg]) => matchesAppId(pkgId, appId) && pkg.state === 'running',
       ),
     )
-    if (allRunning) return 'completed'
+
+    // Manual steps (fund the wallet, open a channel, configure the store…)
+    // must be walked through too — running apps alone don't finish a goal.
+    const done = progress.value[goalId]?.completedSteps ?? []
+    const allManualDone = goal.steps
+      .filter((s) => s.action !== 'install')
+      .every((s) => done.includes(s.id))
+    if (allRunning && allManualDone) return 'completed'
 
     const anyInstalled = goal.requiredApps.some((appId) =>
       Object.keys(packages).some((pkgId) => matchesAppId(pkgId, appId)),
     )
-    if (anyInstalled || progress.value[goalId]) return 'in-progress'
+    if (allRunning || anyInstalled || progress.value[goalId]) return 'in-progress'
 
     return 'not-started'
   }
diff --git a/neode-ui/src/types/goals.ts b/neode-ui/src/types/goals.ts
index 2b69bf09..e1e6f701 100644
--- a/neode-ui/src/types/goals.ts
+++ b/neode-ui/src/types/goals.ts
@@ -17,8 +17,16 @@ export interface GoalStep {
   title: string
   description: string
   appId?: string
-  action: 'install' | 'configure' | 'verify' | 'info'
+  /**
+   * 'fund' renders the bitcoin-wallet funding UI: gated on IBD completion
+   * (with a live sync timer), then a "Fund Wallet" receive flow.
+   */
+  action: 'install' | 'configure' | 'verify' | 'info' | 'fund'
   isAutomatic: boolean
+  /** Custom step icon (e.g. the Zeus logo) — overrides the appId-derived icon */
+  icon?: string
+  /** Custom label for the step's CTA button (configure steps) */
+  ctaLabel?: string
 }
 
 export type GoalStatus = 'not-started' | 'in-progress' | 'completed' | 'error'
diff --git a/neode-ui/src/views/Dashboard.vue b/neode-ui/src/views/Dashboard.vue
index 77ba6832..7d4c7887 100644
--- a/neode-ui/src/views/Dashboard.vue
+++ b/neode-ui/src/views/Dashboard.vue
@@ -155,8 +155,12 @@ import ConnectionBanner from '@/views/dashboard/ConnectionBanner.vue'
 import HealthNotifications from '@/views/dashboard/HealthNotifications.vue'
 import CompanionIntroOverlay from '@/components/CompanionIntroOverlay.vue'
 import { useRouteTransitions, isDetailRoute, ROUTE_BACKGROUNDS } from '@/views/dashboard/useRouteTransitions'
+import { useIbdFinishWatcher } from '@/composables/useIbdFinishWatcher'
 import '@/views/dashboard/dashboard-styles.css'
 
+// Pops a "Finish setup" toast when Bitcoin IBD completes mid-Lightning-setup.
+useIbdFinishWatcher()
+
 const router = useRouter()
 const route = useRoute()
 const store = useAppStore()
diff --git a/neode-ui/src/views/GoalDetail.vue b/neode-ui/src/views/GoalDetail.vue
index 1fbe1216..f824f067 100644
--- a/neode-ui/src/views/GoalDetail.vue
+++ b/neode-ui/src/views/GoalDetail.vue
@@ -98,12 +98,59 @@
                   >
                     {{ isInstalling ? t('common.installing') : t('goalDetail.installApp', { name: step.title.replace('Install ', '') }) }}
                   </button>
+
+                  <!-- Fund the bitcoin wallet: IBD-gated, with live sync timer -->
+                  <div v-else-if="step.action === 'fund'" class="space-y-3">
+                    <div v-if="!bitcoinSynced" class="p-3 rounded-lg bg-orange-500/10 border border-orange-500/20">
+                      <div class="flex items-center justify-between gap-3 mb-1.5">
+                        <span class="text-xs text-white/75">Bitcoin is syncing — funding unlocks when it finishes</span>
+                        <span class="text-xs font-mono text-orange-300 shrink-0">{{ bitcoinSyncLoaded ? bitcoinSyncPercent.toFixed(1) + '%' : '…' }}</span>
+                      </div>
+                      <div class="h-1.5 bg-white/10 rounded-full overflow-hidden mb-1.5">
+                        <div class="h-full bg-orange-400 rounded-full transition-all duration-700" :style="{ width: `${Math.min(100, bitcoinSyncPercent)}%` }" />
+                      </div>
+                      <p class="text-xs text-white/50">
+                        <span v-if="bitcoinSyncEtaText" class="text-white/70 font-medium">~{{ bitcoinSyncEtaText }} remaining</span>
+                        <span v-else>Estimating time remaining…</span>
+                        <span v-if="bitcoinBlockHeight"> · Block {{ bitcoinBlockHeight.toLocaleString() }}</span>
+                      </p>
+                      <p class="text-xs text-white/45 mt-1.5">We'll pop a notification here the moment it's done.</p>
+                    </div>
+
+                    <template v-else>
+                      <div class="p-3 rounded-lg bg-white/5 border border-white/10">
+                        <div class="flex items-center justify-between gap-3">
+                          <span class="text-xs text-white/60">On-chain wallet balance</span>
+                          <span class="text-sm font-mono" :class="walletOnchainSats >= ZEUS_CHANNEL_MIN_SATS ? 'text-green-400' : 'text-white/85'">
+                            {{ walletOnchainSats.toLocaleString() }} sats
+                          </span>
+                        </div>
+                        <p class="text-xs text-white/45 mt-1">Zeus channels need 150,000–1,500,000 sats.</p>
+                      </div>
+                      <div class="flex flex-wrap gap-2">
+                        <button
+                          @click="showFundModal = true"
+                          class="glass-button glass-button-warning glass-button-sm rounded-lg px-5 py-2 text-sm font-medium"
+                        >
+                          Fund Wallet
+                        </button>
+                        <button
+                          @click="completeFundStep(step)"
+                          :disabled="walletOnchainSats <= 0"
+                          class="glass-button glass-button-sm rounded-lg px-5 py-2 text-sm font-medium disabled:opacity-40"
+                        >
+                          {{ walletOnchainSats > 0 ? 'Continue' : 'Waiting for funds…' }}
+                        </button>
+                      </div>
+                    </template>
+                  </div>
+
                   <button
                     v-else-if="step.action === 'configure'"
                     @click="openConfigureStep(step)"
                     class="glass-button glass-button-sm rounded-lg px-5 py-2 text-sm font-medium"
                   >
-                    {{ t('goalDetail.openAndConfigure') }}
+                    {{ step.ctaLabel ?? t('goalDetail.openAndConfigure') }}
                   </button>
                   <button
                     v-else-if="step.action === 'verify'"
@@ -142,12 +189,27 @@
         </div>
         <h2 class="text-xl font-semibold text-white mb-2">{{ t('goalDetail.allSet') }}</h2>
         <p class="text-white/60 mb-6">{{ t('goalDetail.goalReady', { title: goal.title }) }}</p>
-        <RouterLink to="/dashboard/apps" class="glass-button rounded-lg px-6 py-3 font-medium">
+        <button
+          v-if="completionCta"
+          @click="openCompletionTarget"
+          class="glass-button rounded-lg px-6 py-3 font-medium"
+        >
+          {{ completionCta.label }}
+        </button>
+        <RouterLink v-else to="/dashboard/apps" class="glass-button rounded-lg px-6 py-3 font-medium">
           {{ t('goalDetail.viewMyServices') }}
         </RouterLink>
       </div>
     </template>
 
+    <!-- Fund-wallet receive modal (on-chain address + QR, Zeus limits noted) -->
+    <ReceiveBitcoinModal
+      :show="showFundModal"
+      note="Fund your Lightning channel: Zeus channels need a minimum of 150,000 and a maximum of 1,500,000 sats."
+      auto-generate
+      @close="showFundModal = false"
+    />
+
     <!-- Action error toast -->
     <Transition name="fade">
       <div v-if="actionError" class="fixed bottom-20 left-1/2 -translate-x-1/2 z-50 max-w-md w-full px-4" role="alert" aria-live="assertive">
@@ -161,15 +223,26 @@
 </template>
 
 <script setup lang="ts">
-import { computed, ref } from 'vue'
+import { computed, onUnmounted, ref, watch } from 'vue'
 import { useRoute, useRouter, RouterLink } from 'vue-router'
 import { useI18n } from 'vue-i18n'
 import { useAppStore } from '@/stores/app'
 import { useGoalStore } from '@/stores/goals'
-import { getGoalById } from '@/data/goals'
+import { useAppLauncherStore } from '@/stores/appLauncher'
+import { getGoalById, ZEUS_CHANNEL_MIN_SATS } from '@/data/goals'
 import type { GoalStep } from '@/types/goals'
 import { goalStepTargetPath } from './goals/goalStepActions'
 import BackButton from '@/components/BackButton.vue'
+import ReceiveBitcoinModal from '@/components/ReceiveBitcoinModal.vue'
+import { rpcClient } from '@/api/rpc-client'
+import {
+  acquireBitcoinSync,
+  bitcoinSynced,
+  bitcoinSyncLoaded,
+  bitcoinSyncPercent,
+  bitcoinBlockHeight,
+  bitcoinSyncEtaText,
+} from '@/composables/useBitcoinSync'
 
 /** Map appId to its icon file path under /assets/img/app-icons/ */
 const APP_ICON_MAP: Record<string, string> = {
@@ -185,10 +258,27 @@ const APP_ICON_MAP: Record<string, string> = {
 }
 
 function stepIconUrl(step: GoalStep): string | undefined {
+  if (step.icon) return step.icon
   if (!step.appId) return undefined
   return APP_ICON_MAP[step.appId]
 }
 
+/**
+ * Where the completion card sends the user: the app they just set up, not the
+ * generic services list. `launchAppId` opens via the app launcher (iframe apps
+ * overlay on top of the current screen; X-Frame-Options apps open a tab).
+ */
+const GOAL_COMPLETION_CTA: Record<string, { label: string; route?: string; launchAppId?: string }> = {
+  'open-a-shop': { label: 'Go to my shop (BTCPay)', launchAppId: 'btcpay-server' },
+  'accept-payments': { label: 'Go to Lightning (LND)', route: '/dashboard/apps/lnd' },
+  'run-lightning-node': { label: 'View my channels', route: '/dashboard/apps/lnd/channels' },
+  'setup-fedimint': { label: 'Open Fedimint', launchAppId: 'fedimint' },
+  'file-browser': { label: 'Open File Browser', launchAppId: 'filebrowser' },
+  'store-files': { label: 'Open my cloud (Nextcloud)', launchAppId: 'nextcloud' },
+  'create-identity': { label: 'Go to my identity', route: '/dashboard/web5' },
+  'back-up-everything': { label: 'Go to backups', route: '/dashboard/settings' },
+}
+
 const { t } = useI18n()
 const route = useRoute()
 const router = useRouter()
@@ -214,7 +304,9 @@ const completedSteps = computed(() => {
   if (!goal.value) return new Set<string>()
   const completed = new Set<string>()
   for (const step of goal.value.steps) {
-    if (step.appId && isAppInstalled(step.appId)) {
+    // Only install steps auto-tick from package state — manual steps (fund the
+    // wallet, open a channel, configure) must be walked through.
+    if (step.action === 'install' && step.appId && isAppInstalled(step.appId)) {
       completed.add(step.id)
     }
     if (goalStore.progress[goalId.value]?.completedSteps.includes(step.id)) {
@@ -331,6 +423,69 @@ function ensureGoalStarted() {
 function goBack() {
   router.push('/dashboard')
 }
+
+// ── Fund-wallet step: live sync status + on-chain balance ───────────────────
+
+const showFundModal = ref(false)
+const walletOnchainSats = ref(0)
+
+const hasFundStep = computed(() => goal.value?.steps.some((s) => s.action === 'fund') ?? false)
+const fundStepActive = computed(() => {
+  if (!goal.value || !hasFundStep.value) return false
+  const active = goal.value.steps[activeStepIndex.value]
+  return active?.action === 'fund' && overallStatus.value !== 'completed'
+})
+
+let releaseSync: (() => void) | null = null
+let balanceTimer: ReturnType<typeof setInterval> | null = null
+
+async function refreshWalletBalance() {
+  try {
+    const res = await rpcClient.call<{ balance_sats: number }>({ method: 'lnd.getinfo', timeout: 8000 })
+    walletOnchainSats.value = res.balance_sats || 0
+  } catch { /* LND not up yet — balance stays at last known value */ }
+}
+
+watch(fundStepActive, (active) => {
+  if (active) {
+    if (!releaseSync) releaseSync = acquireBitcoinSync()
+    void refreshWalletBalance()
+    if (!balanceTimer) balanceTimer = setInterval(() => void refreshWalletBalance(), 15000)
+  } else {
+    if (releaseSync) { releaseSync(); releaseSync = null }
+    if (balanceTimer) { clearInterval(balanceTimer); balanceTimer = null }
+  }
+}, { immediate: true })
+
+// Refresh the balance right after the receive modal closes — the user may
+// have just sent funds.
+watch(showFundModal, (open) => { if (!open) void refreshWalletBalance() })
+
+onUnmounted(() => {
+  if (releaseSync) { releaseSync(); releaseSync = null }
+  if (balanceTimer) { clearInterval(balanceTimer); balanceTimer = null }
+})
+
+function completeFundStep(step: GoalStep) {
+  ensureGoalStarted()
+  goalStore.completeStep(goalId.value, step.id)
+}
+
+// ── Completion CTA: go to the app you just set up ────────────────────────────
+
+const completionCta = computed(() => (goal.value ? GOAL_COMPLETION_CTA[goal.value.id] : undefined))
+
+function openCompletionTarget() {
+  const cta = completionCta.value
+  if (!cta) return
+  if (cta.launchAppId) {
+    // Iframe apps overlay on top of the current screen; X-Frame-Options apps
+    // (BTCPay, Nextcloud…) open in a new tab.
+    useAppLauncherStore().openSession(cta.launchAppId)
+  } else if (cta.route) {
+    router.push(cta.route)
+  }
+}
 </script>
 
 <style scoped>
diff --git a/neode-ui/src/views/goals/goalStepActions.ts b/neode-ui/src/views/goals/goalStepActions.ts
index b167d110..136e6bb4 100644
--- a/neode-ui/src/views/goals/goalStepActions.ts
+++ b/neode-ui/src/views/goals/goalStepActions.ts
@@ -6,9 +6,16 @@ const STEP_ROUTE_OVERRIDES: Record<string, string> = {
   'create-passphrase': '/dashboard/settings',
   'create-backup': '/dashboard/settings',
   'save-backup': '/dashboard/settings',
+  // Channel steps land directly on the Lightning channels screen (which
+  // carries the "open a channel with Zeus" suggestion).
+  'open-channel': '/dashboard/apps/lnd/channels',
+  'open-channels': '/dashboard/apps/lnd/channels',
+  'open-zeus-channel': '/dashboard/apps/lnd/channels',
 }
 
 export function goalStepTargetPath(step: GoalStep): string | null {
+  const override = STEP_ROUTE_OVERRIDES[step.id]
+  if (override) return override
   if (step.appId) return `/dashboard/apps/${step.appId}`
-  return STEP_ROUTE_OVERRIDES[step.id] ?? null
+  return null
 }