@moda-ai/cli 1.17.2 → 1.18.1

package/dist/init/index.js

@@ -1,7 +1,13 @@
-// src/init/index.ts — Full moda init wizard orchestrator
+// src/init/index.ts. Full moda init wizard orchestrator.
+//
+// Five visible steps: Sign in, Workspace, Plan, Set up, Verify. Every prompt
+// lives in Step 3 (Plan); Step 4 then runs unattended, firing the hosted
+// harness analysis first and overlapping it with the fast local tasks and the
+// SDK integration agent while a live progress board (progress-board.ts)
+// renders each lane.
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { confirm, select } from '@inquirer/prompts';
+import { checkbox, confirm, select } from '@inquirer/prompts';
 import { login, loadToken } from '../auth.js';
 import { selectTenantAndCreateKey } from './tenant.js';
 import { detectAgents } from './mcp.js';
@@ -10,12 +16,18 @@ import { initPrompts, runPromptSync } from '../prompts.js';
 import { runSkillSync } from '../skills.js';
 import { SDK_GUIDE_PATH, writeSdkIntegrationGuide } from './sdk-guide.js';
 import { runSdkIntegration } from './sdk-integration.js';
+import { InitProgressBoard } from './progress-board.js';
 import { createCommandContext } from '../command-context.js';
-import { VERSION } from '../config.js';
+import { resolveModaBaseUrl, VERSION } from '../config.js';
 import { CliAuthError, CliInputError } from '../errors.js';
-import { isDeterministicLocalAnalyst, runHarnessCommand } from '../harness.js';
+import { detectAvailableCodingAgents, isDeterministicLocalAnalyst, runHarnessCommand, } from '../harness.js';
+import { pollRemoteAnalyzeUntilDone, startRemoteAnalyze, } from '../harness-remote.js';
 import { buildDoctorReport } from '../doctor.js';
 import { renderInitBanner, renderInitComplete, renderInitNote, renderInitSetupPlan, renderInitStep, } from '../tui.js';
+/** Recovery command printed whenever init detaches from a hosted analysis run. */
+const HARNESS_PULL_RECOVERY = 'moda harness pull --sync';
+/** Minimum gap between board-driven progress events per lane in machine modes. */
+const LANE_EVENT_THROTTLE_MS = 2_000;
 export async function runInit(flags, options = {}) {
     const explicitYes = flags.yes === true ||
         flags.yes === 'true' ||
@@ -37,17 +49,29 @@ export async function runInit(flags, options = {}) {
     const emit = (phase, message, status) => {
         options.onEvent?.({ phase, message, status });
     };
+    // Board-driven lane updates arrive as fast as the underlying stream; machine
+    // modes get them as progress events throttled to one per lane per 2s so
+    // agent NDJSON stays readable (the human board repaints at 150ms instead).
+    const laneEventAt = new Map();
+    const emitLaneProgress = (phase, laneId, message) => {
+        if (!options.onEvent || human)
+            return;
+        const now = Date.now();
+        if (now - (laneEventAt.get(laneId) ?? 0) < LANE_EVENT_THROTTLE_MS)
+            return;
+        laneEventAt.set(laneId, now);
+        emit(phase, message);
+    };
     log(renderInitBanner());
-    log(renderInitStep(1, 7, 'Welcome', 'No environment variable files are written. File changes are listed before completion.'));
     emit('welcome', 'Onboarding this project as a Moda agent harness.', 'completed');
     phases.push({ id: 'welcome', title: 'Welcome', status: 'completed' });
-    // Step 2: Authentication
+    // Step 1: Sign in.
     // Every auth touchpoint below (cached-token check, browser login, tenant
     // setup) must share the same --profile context, or `moda init --profile X`
     // logs in / stores under the default profile while the rest of init reads
-    // from X — the session then looks unauthenticated or uses the wrong key.
+    // from X, and the session then looks unauthenticated or uses the wrong key.
     const profile = stringFlag(flags.profile);
-    log(renderInitStep(2, 7, 'Authentication'));
+    log(renderInitStep(1, 5, 'Sign in', 'No environment variable files are written. File changes are listed before completion.'));
     let token = loadToken({ profile });
     if (!token) {
         if (json || agent) {
@@ -76,9 +100,9 @@ export async function runInit(flags, options = {}) {
         log(renderInitNote('Already authenticated (cached token)'));
     }
     emit('auth', 'Authentication complete.', 'completed');
-    phases.push({ id: 'auth', title: 'Authentication', status: 'completed' });
-    // Step 3: Tenant + API Key
-    log(renderInitStep(3, 7, 'Workspace & Profile'));
+    phases.push({ id: 'auth', title: 'Sign in', status: 'completed' });
+    // Step 2: Workspace (tenant + API key).
+    log(renderInitStep(2, 5, 'Workspace'));
     emit('workspace', 'Selecting workspace and creating API key.');
     // --tenant-id flag wins over MODA_TENANT_ID; the source drives the
     // env-shadow warning so we don't warn when the env var was the selection.
@@ -86,7 +110,7 @@ export async function runInit(flags, options = {}) {
     // Normalize the env var the same way as the flag: an empty/whitespace
     // MODA_TENANT_ID (e.g. `export MODA_TENANT_ID=`, or a harness that blanks it
     // to clear an inherited value) means "unset", not an explicit empty-id
-    // selection — otherwise the exact-id match below fails with
+    // selection; otherwise the exact-id match below fails with
     // "No organization with id ''" instead of auto-selecting a sole org.
     const tenantIdEnv = stringFlag(process.env.MODA_TENANT_ID);
     const { apiKey, tenantName } = await selectTenantAndCreateKey({
@@ -99,211 +123,431 @@ export async function runInit(flags, options = {}) {
     });
     log(renderInitNote(`Active workspace: ${tenantName}`));
     emit('workspace', `Active workspace: ${tenantName}`, 'completed');
-    phases.push({ id: 'workspace', title: 'Workspace & Profile', status: 'completed', details: tenantName });
-    // Step 4: Harness analyst report. Onboarding runs the analyst SERVER-SIDE by
-    // default (Moda uploads a safe source snapshot and runs the agent on its own
-    // infra) so the customer needs no local coding agent. Opt out with `--local`
-    // (or `--remote=false`) to run a local coding-agent analyst instead. If the
-    // remote run fails (service/network), we fall back to the local analyst so
-    // onboarding never hard-fails.
-    const remote = resolveHarnessRemote(flags);
+    phases.push({ id: 'workspace', title: 'Workspace', status: 'completed', details: tenantName });
+    // Step 3: Plan. Every remaining decision lives in this single prompt beat;
+    // Step 4 then runs unattended with zero prompts. Explicit flags keep
+    // overriding exactly as before, and --yes/--json/--agent never prompt
+    // (optional items default off, snapshot consent implied).
+    log(renderInitStep(3, 5, 'Plan', 'One confirmation covers everything below; setup then runs unattended.'));
+    let remote = resolveHarnessRemote(flags);
+    const remotePinned = hasExplicitRemoteChoice(flags);
+    const sdkFlag = resolveSdkIntegrateFlag(flags);
+    const ciCdFlag = resolveCiCdFlag(flags);
+    const autosyncFlag = resolveAutosyncFlag(flags);
+    // SDK integration installs packages and edits source via a coding agent, so
+    // it defaults ON only when an agent CLI is installed to do the work; it
+    // never runs unattended without an explicit --sdk-integrate.
+    const codingAgentAvailable = detectAvailableCodingAgents().length > 0;
+    let integrateSdk = sdkFlag !== undefined ? sdkFlag : yes ? false : codingAgentAvailable;
+    let configureCiCd = ciCdFlag ?? false;
+    let configureAutosync = autosyncFlag ?? false;
+    let setupPlan = [];
+    const renderPlan = () => {
+        setupPlan = buildSetupPlan({
+            installHooks: false,
+            integrateSdk,
+            configureCiCd,
+            configureAutosync,
+            remote,
+        });
+        log(renderInitSetupPlan(setupPlan, { snapshotConsent: remote }));
+    };
+    renderPlan();
+    if (!yes) {
+        const proceed = await confirm({ message: 'Proceed with this plan?', default: true });
+        if (!proceed) {
+            const choices = [];
+            if (sdkFlag === undefined) {
+                choices.push({
+                    name: 'SDK integration via your coding agent (installs packages, edits source)',
+                    value: 'sdk',
+                    checked: integrateSdk,
+                });
+            }
+            if (!remotePinned) {
+                choices.push({
+                    name: "Harness analysis on Moda's servers (uncheck to run a local coding agent analyst)",
+                    value: 'remote',
+                    checked: remote,
+                });
+            }
+            if (ciCdFlag === undefined) {
+                choices.push({
+                    name: 'CI/CD validation workflow (.github/workflows/moda-validation.yml)',
+                    value: 'ci-cd',
+                    checked: configureCiCd,
+                });
+            }
+            if (autosyncFlag === undefined) {
+                choices.push({
+                    name: 'Autosync prompts and skills on push to main (.github/workflows/moda-autosync.yml)',
+                    value: 'autosync',
+                    checked: configureAutosync,
+                });
+            }
+            if (choices.length > 0) {
+                const selected = await checkbox({
+                    message: 'Choose what runs (space toggles, enter confirms)',
+                    choices,
+                });
+                if (sdkFlag === undefined)
+                    integrateSdk = selected.includes('sdk');
+                if (!remotePinned)
+                    remote = selected.includes('remote');
+                if (ciCdFlag === undefined)
+                    configureCiCd = selected.includes('ci-cd');
+                if (autosyncFlag === undefined)
+                    configureAutosync = selected.includes('autosync');
+                renderPlan();
+            }
+        }
+    }
+    if (json || agent) {
+        const skipped = setupPlan
+            .filter((action) => (action.category === 'sdk' || action.category === 'ci-cd' || action.category === 'autosync') &&
+            action.approved === false)
+            .map((action) => `${action.category}: ${action.command ?? 'explicit flag required'}`);
+        if (skipped.length > 0) {
+            emit('plan', `Non-interactive init skipped optional actions (${skipped.join('; ')}).`, 'warning');
+        }
+    }
+    emit('plan', 'Setup plan ready.', 'completed');
+    phases.push({ id: 'plan', title: 'Plan', status: 'completed' });
+    // Step 4: Set up. Zero prompts from here on. The hosted harness analysis is
+    // fired FIRST and polled concurrently while the fast local tasks and the SDK
+    // integration agent run; a live progress board renders each lane in human
+    // mode. Local-analyst mode stays sequential (AnalystTui provides its own
+    // live progress).
+    log(renderInitStep(4, 5, 'Set up', remote
+        ? 'Harness analysis runs on Moda while local setup continues. No further input is needed.'
+        : 'Runs unattended. No further input is needed.'));
+    const rootDir = process.cwd();
+    // An explicit --remote pin means "never fall back to a local coding agent".
+    const allowLocalFallback = !isTruthyFlag(flagValue(flags, 'remote'));
+    const nestedHarnessFlags = (extra) => commandFlags({
+        summary: true,
+        // The Step 3 plan confirm covers the broad local read and (for remote)
+        // the snapshot upload, so nested harness commands must never re-prompt.
+        yes: true,
+        json: json || agent,
+        agent,
+        quiet: true,
+        'no-telemetry': true,
+        profile,
+        ...extra,
+    });
     const runAnalyze = (useRemote) => runHarnessCommand(createCommandContext({
         command: 'harness',
         positional: 'analyze',
         positionals: ['analyze'],
-        flags: commandFlags({
-            summary: true,
-            // In machine mode the nested harness scan must not emit its own
-            // `needs_input` with a `moda harness analyze --yes` resume command — an
-            // orchestrator obeying it would resume the scan and silently skip the
-            // rest of init. The broad local read is part of the init flow the caller
-            // already opted into, so auto-approve it here; human init still confirms.
-            yes: yes || json || agent,
-            json: json || agent,
-            agent,
+        flags: nestedHarnessFlags({
             analyst: stringFlag(flags.analyst) ?? 'auto',
             // Pass the remote/local decision EXPLICITLY. `commandFlags` drops
             // `remote: false`, so a bare `remote: useRemote` would leave the child
             // with no signal and it would re-derive remoteness from
-            // `MODA_HARNESS_REMOTE` — silently overriding `--local` and the
-            // remote-failure fallback below. `--no-remote` survives (it's `true`)
-            // and takes precedence over the env in `isRemoteHarnessAnalyze`.
+            // `MODA_HARNESS_REMOTE`, silently overriding `--local` and the
+            // remote-failure fallback. `--no-remote` survives (it's `true`).
             remote: useRemote ? true : undefined,
             'no-remote': useRemote ? undefined : true,
-            quiet: true,
             progress: true,
-            'no-telemetry': true,
         }),
     }));
-    log(renderInitStep(4, 7, 'Harness Discovery', remote
-        ? 'Moda runs the harness analyst server-side and writes cited local artifacts.'
-        : 'Moda Analyst investigates the harness and writes cited local artifacts.'));
-    emit('harness', remote
-        ? 'Running Moda-hosted harness discovery.'
-        : 'Running Moda Analyst harness discovery.');
-    let harnessResult;
-    try {
-        harnessResult = await runAnalyze(remote);
-    }
-    catch (error) {
-        // A remote failure (service down, upload error) must not sink onboarding —
-        // fall back to the local analyst path. If the caller pinned `--remote`
-        // explicitly, respect that and surface the failure.
-        if (remote && !isTruthyFlag(flagValue(flags, 'remote'))) {
+    let board;
+    const startBoard = () => {
+        if (!human)
+            return undefined;
+        board ??= new InitProgressBoard();
+        return board;
+    };
+    const validationFailure = () => new CliInputError('Moda Analyst produced a harness report that did not pass validation.', 'Review .moda/harness-report-validation.json, then rerun `moda init --local --analyst=claude|cursor|codex` or `moda harness analyze --analyst=local-scan --summary`.');
+    let harnessPhase = { id: 'harness', title: 'Harness discovery', status: 'completed' };
+    let harnessDeferred = false;
+    // Upload the cited harness graph so Moda's backend has the understanding,
+    // not just local artifacts. `harness sync --from-report` refuses an
+    // unapproved report, so approve it first. Best-effort: a network blip on
+    // either call must not abort onboarding.
+    const approveAndSyncHarness = async () => {
+        try {
+            await runHarnessCommand(createCommandContext({
+                command: 'harness',
+                positional: 'approve',
+                positionals: ['approve'],
+                flags: nestedHarnessFlags({}),
+            }));
+            await runHarnessCommand(createCommandContext({
+                command: 'harness',
+                positional: 'sync',
+                positionals: ['sync'],
+                flags: nestedHarnessFlags({ 'from-report': true }),
+            }));
+            log(renderInitNote('Synced harness graph to Moda'));
+            emit('harness', 'Harness graph synced to Moda.', 'completed');
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            warn(renderInitNote(`Harness sync skipped: ${message}`, 'warning'));
+            warn('  Run `moda harness approve --yes && moda harness sync --from-report` later to upload.');
+            emit('harness', 'Harness sync skipped.', 'warning');
+            harnessPhase = { id: 'harness', title: 'Harness discovery', status: 'warning', details: 'sync skipped' };
+        }
+    };
+    const finishLocalAnalyze = async () => {
+        emit('harness', 'Running Moda Analyst harness discovery.');
+        const result = await runAnalyze(false);
+        if (result.exitCode !== 0)
+            throw validationFailure();
+        log(renderInitNote('Wrote or verified .moda/harness-report.json, .moda/harness.json, and .moda/HARNESS.md'));
+        if (human)
+            printHarnessDetectionSummary();
+        emit('harness', 'Harness discovery complete.', 'completed');
+        await approveAndSyncHarness();
+    };
+    // Fire the hosted analysis first so it overlaps everything below.
+    let pollPromise;
+    let pollError;
+    let remoteRunId;
+    // Covers the whole overlapped window (fast tasks, SDK agent, final await):
+    // a Ctrl-C leaves the hosted run resumable and prints the recovery command.
+    const onRemoteSigint = () => {
+        board?.stop();
+        process.stderr.write(`\nHarness analysis keeps running on Moda. Resume anytime with \`${HARNESS_PULL_RECOVERY}\`.\n`);
+        process.exit(130);
+    };
+    if (remote) {
+        emit('harness', 'Running Moda-hosted harness discovery.');
+        try {
+            const harnessContext = createCommandContext({
+                command: 'harness',
+                positional: 'analyze',
+                positionals: ['analyze'],
+                flags: nestedHarnessFlags({
+                    analyst: stringFlag(flags.analyst) ?? 'auto',
+                    remote: true,
+                }),
+            });
+            const started = await startRemoteAnalyze({ context: harnessContext, rootDir });
+            remoteRunId = started.runId;
+            // From this point Ctrl-C is safe and resumable: the state file already
+            // says `running`, so exiting early just detaches from the hosted run.
+            process.once('SIGINT', onRemoteSigint);
+            emit('harness', `Moda accepted harness analysis run ${started.runId}.`);
+            startBoard()?.startLane('harness', 'Harness analysis on Moda', {
+                detail: 'waiting for the hosted analyst',
+                expectation: 'usually 2-4 min',
+            });
+            pollPromise = pollRemoteAnalyzeUntilDone({
+                context: harnessContext,
+                runId: started.runId,
+                onProgress: ({ status, progress }) => {
+                    if (status === 'completed' || status === 'failed') {
+                        // The hosted run just turned terminal, but the lane is only
+                        // finalized after the SDK lane below. Freeze it now so the board
+                        // does not keep a live spinner and climbing elapsed for minutes
+                        // after the analysis actually finished; the post-setup pull
+                        // refines the note (the board allows terminal refinements).
+                        if (status === 'completed') {
+                            board?.complete('harness', 'analysis finished on Moda; finalizing after setup');
+                        }
+                        else {
+                            board?.warn('harness', 'hosted run finished with issues; finalizing after setup');
+                        }
+                        emitLaneProgress('harness', 'harness', `Hosted analysis ${status}; finalizing after setup.`);
+                        return;
+                    }
+                    const message = progress?.message
+                        ?? (typeof progress?.tool_calls === 'number'
+                            ? `${progress.tool_calls} tool call(s) so far`
+                            : `analysis ${status}`);
+                    board?.update('harness', message);
+                    emitLaneProgress('harness', 'harness', message);
+                },
+            }).catch((error) => {
+                // Captured, not thrown: an unhandled rejection here would crash init
+                // in the middle of the fast tasks. Inspected after the SDK lane.
+                pollError = error;
+                return undefined;
+            });
+        }
+        catch (error) {
+            // A remote failure (service down, upload error) must not sink
+            // onboarding; fall back to the local analyst path unless --remote was
+            // pinned explicitly.
+            if (!allowLocalFallback)
+                throw error;
             warn(renderInitNote(`Server-side harness discovery unavailable (${error instanceof Error ? error.message : String(error)}); falling back to local analyst.`, 'warning'));
             emit('harness', 'Server-side discovery failed; falling back to local analyst.', 'warning');
-            harnessResult = await runAnalyze(false);
-        }
-        else {
-            throw error;
+            remote = false;
         }
     }
-    if (harnessResult.exitCode !== 0) {
-        throw new CliInputError('Moda Analyst produced a harness report that did not pass validation.', 'Review .moda/harness-report-validation.json, then rerun `moda init --local --analyst=claude|cursor|codex` or `moda harness analyze --analyst=local-scan --summary`.');
-    }
-    log(renderInitNote('Wrote or verified .moda/harness-report.json, .moda/harness.json, and .moda/HARNESS.md'));
-    if (human)
-        printHarnessDetectionSummary();
-    emit('harness', 'Harness discovery complete.', 'completed');
-    // Upload the cited harness graph so Moda's backend has the understanding, not
-    // just local artifacts. `harness sync --from-report` refuses an unapproved
-    // report, so approve it first. Best-effort: a network blip on either call must
-    // not abort onboarding — auth + key provisioning already succeeded.
-    try {
-        await runHarnessCommand(createCommandContext({
-            command: 'harness',
-            positional: 'approve',
-            positionals: ['approve'],
-            flags: commandFlags({ yes: true, json: json || agent, agent, quiet: true, 'no-telemetry': true }),
-        }));
-        await runHarnessCommand(createCommandContext({
-            command: 'harness',
-            positional: 'sync',
-            positionals: ['sync'],
-            flags: commandFlags({ 'from-report': true, yes: true, json: json || agent, agent, quiet: true, 'no-telemetry': true }),
-        }));
-        log(renderInitNote('Synced harness graph to Moda'));
-        emit('harness', 'Harness graph synced to Moda.', 'completed');
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        warn(renderInitNote(`Harness sync skipped: ${message}`, 'warning'));
-        warn('  Run `moda harness approve --yes && moda harness sync --from-report` later to upload.');
-        emit('harness', 'Harness sync skipped.', 'warning');
-    }
-    phases.push({ id: 'harness', title: 'Harness Discovery', status: 'completed' });
-    // Step 5: Setup plan
-    log(renderInitStep(5, 7, 'Setup Plan', 'Every write/sync action is explicit before it is applied.'));
-    const setupPlan = buildSetupPlan({
-        installHooks: false,
-        integrateSdk: await shouldIntegrateSdk(flags, yes),
-        configureCiCd: await shouldConfigureCiCd(flags, yes),
-        configureAutosync: await shouldConfigureAutosync(flags, yes),
-    });
-    if (json || agent) {
-        const skipped = setupPlan
-            .filter((action) => (action.category === 'sdk' || action.category === 'ci-cd' || action.category === 'autosync') &&
-            action.approved === false)
-            .map((action) => `${action.category}: ${action.command ?? 'explicit flag required'}`);
-        if (skipped.length > 0) {
-            emit('plan', `Non-interactive init skipped optional actions (${skipped.join('; ')}).`, 'warning');
-        }
+    // Local-analyst mode keeps today's sequential behavior: analyze (AnalystTui
+    // renders live progress), then approve + sync, then the fast tasks below.
+    if (!remote) {
+        await finishLocalAnalyze();
     }
-    log(renderInitSetupPlan(setupPlan));
-    emit('plan', 'Setup plan ready.', 'completed');
-    phases.push({ id: 'plan', title: 'Setup Plan', status: 'completed' });
-    // Step 6: Apply approved setup changes.
-    log(renderInitStep(6, 7, 'Apply Approved Changes'));
     emit('apply', 'Applying approved setup changes.');
+    const laneBoard = startBoard();
     const ingestCodingAgentTraces = false;
     const agents = detectAgents();
+    laneBoard?.startLane('agent-skills', 'Agent skills');
     if (agents.length > 0) {
-        log(renderInitNote(`Detected coding agents: ${agents.join(', ')}`));
-        // Install only the moda-cli skill so those agents can query Moda analytics
-        // from the terminal. SDK integration is a one-shot agent run below, not a
-        // persistent skill.
-        await installRules(agents, { yes, silent: !human });
+        // The Step 3 plan already covered the skill install; never re-prompt.
+        await installRules(agents, { yes: true, silent: true });
+        laneBoard?.complete('agent-skills', `moda-cli skill installed for ${agents.join(', ')}`);
     }
     else {
-        log(renderInitNote('No coding agents detected, skipping', 'skipped'));
+        laneBoard?.complete('agent-skills', 'no coding agents detected');
     }
     await initPrompts({ silent: true });
-    log(renderInitNote('Created or verified .moda/prompts.yml'));
+    laneBoard?.startLane('prompts', 'Prompts', { detail: 'Created or verified .moda/prompts.yml' });
     // Push the manifest's prompt files to Moda so production traces can attribute
-    // managed prompt versions. A fresh repo has none yet — that's a harmless no-op.
+    // managed prompt versions. A fresh repo has none yet; that's a harmless no-op.
     try {
-        const promptSync = await runPromptSync({}, { profile: stringFlag(flags.profile) });
-        log(renderInitNote(promptSync.synced.length > 0
-            ? `Synced ${promptSync.synced.length} prompt(s) to Moda`
-            : 'No prompt files to sync yet (add paths to .moda/prompts.yml)'));
+        const promptSync = await runPromptSync({}, { profile });
+        laneBoard?.complete('prompts', promptSync.synced.length > 0
+            ? `${promptSync.synced.length} prompt(s) synced`
+            : 'manifest ready (no prompt files to sync yet)');
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        warn(renderInitNote(`Prompt sync skipped: ${message}`, 'warning'));
+        laneBoard?.warn('prompts', `sync skipped: ${message}`);
     }
     // Push locally-authored skills (`.claude/skills/**/SKILL.md`) to Moda, in
-    // parallel intent with prompt sync. A fresh repo has none yet — harmless
-    // no-op. Best-effort: a network blip must not abort onboarding.
+    // parallel intent with prompt sync. Best-effort: a network blip must not
+    // abort onboarding.
+    laneBoard?.startLane('skills', 'Skills');
     try {
-        const skillSync = await runSkillSync({}, { profile: stringFlag(flags.profile) });
-        if (skillSync.synced.length > 0) {
-            log(renderInitNote(`Synced ${skillSync.synced.length} skill(s) to Moda`));
-        }
-        else {
-            log(renderInitNote('No local skills to sync yet (add .claude/skills/<name>/SKILL.md)'));
-        }
+        const skillSync = await runSkillSync({}, { profile });
+        laneBoard?.complete('skills', skillSync.synced.length > 0
+            ? `${skillSync.synced.length} skill(s) synced`
+            : 'no local skills to sync yet');
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        warn(renderInitNote(`Skill sync skipped: ${message}`, 'warning'));
+        laneBoard?.warn('skills', `sync skipped: ${message}`);
+    }
+    if (setupPlan.find((action) => action.category === 'ci-cd')?.approved === true) {
+        const workflowPath = writeCiCdWorkflow();
+        laneBoard?.startLane('ci-cd', 'CI/CD workflow');
+        laneBoard?.complete('ci-cd', `wrote ${workflowPath}`);
+        markApplied(setupPlan, 'ci-cd');
+    }
+    if (setupPlan.find((action) => action.category === 'autosync')?.approved === true) {
+        const workflowPath = writeAutosyncWorkflow();
+        laneBoard?.startLane('autosync', 'Autosync workflow');
+        laneBoard?.complete('autosync', `wrote ${workflowPath}`);
+        markApplied(setupPlan, 'autosync');
     }
     const sdkAction = setupPlan.find((action) => action.category === 'sdk');
     if (sdkAction?.approved === true) {
-        log(renderInitNote('Running your coding agent to integrate the Moda SDK (this can take a few minutes)...', 'warning'));
-        const result = await runSdkIntegration({ human });
+        laneBoard?.startLane('sdk', 'SDK integration', {
+            detail: 'launching your coding agent',
+            expectation: 'usually 3-10 min',
+        });
+        emit('apply', 'Running your coding agent to integrate the Moda SDK.');
+        const result = await runSdkIntegration({
+            onProgress: (message) => {
+                laneBoard?.update('sdk', message);
+                emitLaneProgress('apply', 'sdk', message);
+            },
+            // Presence of onEvent selects the streaming agent invocation so tool
+            // cards arrive incrementally; onProgress above receives the rendered
+            // cards (describeCodingAgentEvent), which is all the lane needs.
+            onEvent: () => { },
+        });
         if (result.status === 'integrated') {
-            log(renderInitNote(`Integrated the Moda SDK with ${result.adapter}. Review the diff before committing.`));
+            laneBoard?.complete('sdk', `integrated with ${result.adapter}; review the diff before committing`);
             markApplied(setupPlan, 'sdk');
         }
         else if (result.status === 'no-agent') {
             const guidePath = writeSdkIntegrationGuide();
             sdkAction.files = [guidePath];
-            log(renderInitNote(`No coding agent CLI found; wrote ${guidePath} to integrate by hand`, 'warning'));
+            laneBoard?.warn('sdk', `no coding agent CLI found; wrote ${guidePath} to integrate by hand`);
             markApplied(setupPlan, 'sdk');
         }
         else {
             const guidePath = writeSdkIntegrationGuide();
             sdkAction.files = [guidePath];
-            warn(renderInitNote(`SDK integration via ${result.adapter} did not complete: ${result.detail}`, 'warning'));
-            log(renderInitNote(`Wrote ${guidePath} so you can finish the integration manually`));
+            laneBoard?.warn('sdk', `${result.adapter} did not complete; wrote ${guidePath} to finish manually`);
             markApplied(setupPlan, 'sdk');
         }
     }
     else {
-        log(renderInitNote('Skipped SDK integration', 'skipped'));
         markApplied(setupPlan, 'sdk', 'User skipped SDK integration.');
     }
-    const configureCiCd = setupPlan.find((action) => action.category === 'ci-cd')?.approved === true;
-    if (configureCiCd) {
-        const workflowPath = writeCiCdWorkflow();
-        log(renderInitNote(`Wrote ${workflowPath}`));
-        markApplied(setupPlan, 'ci-cd');
-    }
-    const configureAutosync = setupPlan.find((action) => action.category === 'autosync')?.approved === true;
-    if (configureAutosync) {
-        const workflowPath = writeAutosyncWorkflow();
-        log(renderInitNote(`Wrote ${workflowPath}`));
-        markApplied(setupPlan, 'autosync');
-    }
-    log(renderInitNote('Reusing approved Step 4 harness report; no second analyst run needed'));
-    markApplied(setupPlan, 'harness');
     markApplied(setupPlan, 'hooks', ingestCodingAgentTraces ? undefined : 'Coding-agent trace capture is temporarily unavailable.');
     markApplied(setupPlan, 'prompts');
     markApplied(setupPlan, 'skills');
+    // Await the hosted analysis last: it has been polling concurrently since the
+    // top of this step. Ctrl-C or a poll deadline leaves the run resumable
+    // (state file stays `running`) and prints the pull recovery command.
+    if (remote && pollPromise && remoteRunId) {
+        const final = await pollPromise;
+        process.removeListener('SIGINT', onRemoteSigint);
+        const fallBackToLocal = async (error) => {
+            board?.fail('harness', 'hosted analysis failed');
+            board?.stop();
+            if (!allowLocalFallback)
+                throw error;
+            warn(renderInitNote(`Server-side harness discovery failed (${error instanceof Error ? error.message : String(error)}); falling back to local analyst.`, 'warning'));
+            emit('harness', 'Server-side discovery failed; falling back to local analyst.', 'warning');
+            await finishLocalAnalyze();
+        };
+        if (pollError !== undefined) {
+            await fallBackToLocal(pollError);
+        }
+        else if (!final || (final.status !== 'completed' && final.status !== 'failed')) {
+            // The poll deadline passed while the hosted run kept going. Expected on
+            // very large repos, and safe: the run state file stays `running`.
+            harnessDeferred = true;
+            harnessPhase = { id: 'harness', title: 'Harness discovery', status: 'warning', details: 'still running on Moda' };
+            markApplied(setupPlan, 'harness', `Analysis still running on Moda; run \`${HARNESS_PULL_RECOVERY}\` to fetch and sync it.`);
+            board?.warn('harness', `still running on Moda; run \`${HARNESS_PULL_RECOVERY}\` in a few minutes`);
+            board?.stop();
+            log(renderInitNote(`Harness analysis is still running on Moda. Run \`${HARNESS_PULL_RECOVERY}\` in a few minutes to fetch and sync the result.`, 'info'));
+            emit('harness', `Harness analysis still running on Moda; resume with \`${HARNESS_PULL_RECOVERY}\`.`, 'warning');
+        }
+        else {
+            board?.update('harness', 'writing local artifacts');
+            let pullResult;
+            try {
+                // `harness pull` finalizes exactly like `harness analyze --remote`
+                // (repair, local re-validation, .moda artifact writes) from the
+                // already-terminal hosted run.
+                pullResult = await runHarnessCommand(createCommandContext({
+                    command: 'harness',
+                    positional: 'pull',
+                    positionals: ['pull'],
+                    flags: nestedHarnessFlags({ 'run-id': remoteRunId }),
+                }));
+            }
+            catch (error) {
+                await fallBackToLocal(error);
+            }
+            if (pullResult) {
+                if (pullResult.exitCode !== 0) {
+                    board?.fail('harness', 'report validation failed');
+                    board?.stop();
+                    throw validationFailure();
+                }
+                board?.complete('harness', 'report written to .moda/');
+                board?.stop();
+                log(renderInitNote('Wrote or verified .moda/harness-report.json, .moda/harness.json, and .moda/HARNESS.md'));
+                if (human)
+                    printHarnessDetectionSummary();
+                emit('harness', 'Harness discovery complete.', 'completed');
+                await approveAndSyncHarness();
+            }
+        }
+    }
+    board?.stop();
+    if (!harnessDeferred)
+        markApplied(setupPlan, 'harness');
+    phases.push(harnessPhase);
     emit('apply', 'Approved changes applied.', 'completed');
-    phases.push({ id: 'apply', title: 'Apply Approved Changes', status: 'completed' });
+    phases.push({ id: 'apply', title: 'Set up', status: 'completed' });
+    // Step 5: Verify.
     const offlineValidation = isTruthyFlag(flagValue(flags, 'offline'));
-    log(renderInitStep(7, 7, 'Validate', offlineValidation
+    log(renderInitStep(5, 5, 'Verify', offlineValidation
         ? 'Running local doctor checks so the setup leaves a clear state.'
         : 'Running Moda doctor online to confirm setup and that telemetry is reaching Moda.'));
     emit('validate', `Running Moda doctor diagnostics (${offlineValidation ? 'offline' : 'online'}).`);
@@ -315,20 +559,33 @@ export async function runInit(flags, options = {}) {
     }), { offline: offlineValidation });
     markApplied(setupPlan, 'validation');
     log(renderInitNote(`Validation checks completed: ${doctorReport.summary.pass} passing, ${doctorReport.summary.warning} warning, ${doctorReport.summary.fail} failing`));
+    let telemetrySeen;
     if (!offlineValidation) {
         const cloud = doctorReport.checks.find((check) => check.id === 'cloud_data_flow');
         if (cloud) {
-            log(renderInitNote(`Moda Cloud telemetry: ${cloud.status}`, cloud.status === 'pass' ? undefined : 'warning'));
+            telemetrySeen = cloud.status === 'pass';
+            if (telemetrySeen) {
+                log(renderInitNote('Moda Cloud telemetry: flowing'));
+            }
+            else {
+                // Expected before the app has run with the SDK installed; surfaced as
+                // a next step on the completion screen, not a warning badge.
+                log(renderInitNote('No telemetry yet. Expected until your app runs with the SDK; see next steps.', 'info'));
+            }
         }
     }
     emit('validate', 'Validation checks complete.', doctorReport.summary.fail > 0 ? 'warning' : 'completed');
-    phases.push({ id: 'validate', title: 'Validate', status: 'completed' });
-    // Done
+    phases.push({ id: 'validate', title: 'Verify', status: 'completed' });
+    // Done: end on the payoff.
     log(renderInitComplete({
         tenantName,
+        dashboardUrl: `${resolveModaBaseUrl({ profile })}/dashboard`,
+        harness: harnessDeferred
+            ? { state: 'pending' }
+            : { state: 'mapped', ...readHarnessGraphCounts() },
         filesChanged: changedFiles(setupPlan),
         skipped: setupPlan.filter((item) => item.status === 'skipped' || item.status === 'manual'),
-        phases,
+        telemetrySeen,
     }));
     return { apiKey, tenantName, phases, setupPlan };
 }
@@ -336,7 +593,9 @@ function buildSetupPlan(options) {
     return [
         {
             category: 'harness',
-            title: 'Analyze harness, write cited report, and sync the graph to Moda',
+            title: options.remote
+                ? "Analyze the harness on Moda's servers, write the cited report, and sync the graph to Moda"
+                : 'Analyze the harness locally, write the cited report, and sync the graph to Moda',
             status: 'planned',
             approved: true,
             files: [
@@ -346,7 +605,9 @@ function buildSetupPlan(options) {
                 '.moda/harness.json',
                 '.moda/HARNESS.md',
             ],
-            command: 'moda harness analyze --analyst=auto --summary && moda harness approve --yes && moda harness sync --from-report',
+            command: options.remote
+                ? 'moda harness analyze --remote --summary && moda harness approve --yes && moda harness sync --from-report'
+                : 'moda harness analyze --analyst=auto --summary && moda harness approve --yes && moda harness sync --from-report',
         },
         {
             category: 'hooks',
@@ -436,7 +697,7 @@ function changedFiles(setupPlan) {
 // The CLI version generated workflows pin to. Pinning (rather than `@latest`,
 // which resolves at CI run time) keeps a future compromised `@moda-ai/cli`
 // publish from silently executing in adopters' CI with their MODA_API_KEY /
-// MODA_TENANT_ID present — especially important for autosync, which *writes* to
+// MODA_TENANT_ID present. Especially important for autosync, which *writes* to
 // the Moda registry. The pin tracks the CLI that generated the file, so each
 // `moda init` upgrade is an explicit, reviewable bump of the workflow.
 const GENERATED_WORKFLOW_CLI = `@moda-ai/cli@${VERSION}`;
@@ -541,6 +802,22 @@ function printHarnessDetectionSummary(cwd = process.cwd()) {
         console.log('  Detected harness summary is available in .moda/HARNESS.md');
     }
 }
+/** Agent/artifact counts for the completion screen's harness payoff line. */
+function readHarnessGraphCounts(cwd = process.cwd()) {
+    const manifestPath = join(cwd, '.moda', 'harness.json');
+    if (!existsSync(manifestPath))
+        return {};
+    try {
+        const graph = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        return {
+            agents: Array.isArray(graph.runtimeAgents) ? graph.runtimeAgents.length : 0,
+            artifacts: Array.isArray(graph.artifacts) ? graph.artifacts.length : 0,
+        };
+    }
+    catch {
+        return {};
+    }
+}
 function commandFlags(flags) {
     return Object.fromEntries(Object.entries(flags)
         .filter(([, value]) => value !== undefined && value !== false)
@@ -579,47 +856,41 @@ function resumeFlagsForInit(flags) {
     }
     return out;
 }
-async function shouldConfigureCiCd(flags, yes) {
+/**
+ * Explicit CI/CD decision from flags, or undefined when the Plan beat decides
+ * (interactive default off; --yes/--json/--agent default off).
+ */
+function resolveCiCdFlag(flags) {
     const explicit = parseOptionalBoolean(flagValue(flags, 'ci-cd', 'ci_cd', 'ci'));
     if (explicit !== undefined)
         return explicit;
     if (isTruthyFlag(flagValue(flags, 'no-ci-cd', 'no_ci_cd')))
         return false;
-    if (yes)
-        return false;
-    return confirm({
-        message: 'Create a GitHub Actions workflow for Moda validation?',
-        default: false,
-    });
+    return undefined;
 }
-async function shouldConfigureAutosync(flags, yes) {
+/** Explicit autosync decision from flags, or undefined when the Plan beat decides. */
+function resolveAutosyncFlag(flags) {
     const explicit = parseOptionalBoolean(flagValue(flags, 'autosync', 'auto-sync', 'auto_sync'));
     if (explicit !== undefined)
         return explicit;
     if (isTruthyFlag(flagValue(flags, 'no-autosync', 'no_autosync', 'no-auto-sync', 'no_auto_sync')))
         return false;
-    if (yes)
-        return false;
-    return confirm({
-        message: 'Create a GitHub Actions workflow to autosync prompts and skills to Moda on push to main?',
-        default: false,
-    });
+    return undefined;
 }
-async function shouldIntegrateSdk(flags, yes) {
+/**
+ * Explicit SDK-integration decision from flags, or undefined when the Plan
+ * beat decides (interactive default: on when a coding-agent CLI is installed;
+ * --yes/--json/--agent default off because the agent edits source and installs
+ * packages, which must never happen unattended without an explicit opt-in).
+ */
+function resolveSdkIntegrateFlag(flags) {
     const explicit = parseOptionalBoolean(flagValue(flags, 'sdk-integrate', 'sdk_integrate', 'sdk-guide', 'sdk_guide', 'sdk'));
     if (explicit !== undefined)
         return explicit;
     if (isTruthyFlag(flagValue(flags, 'no-sdk-integrate', 'no_sdk_integrate', 'no-sdk-guide', 'no_sdk_guide', 'no-sdk', 'no_sdk'))) {
         return false;
     }
-    // SDK integration now installs packages and edits source via a coding agent.
-    // Never do that unattended (--yes/--json/--agent); require an explicit opt-in.
-    if (yes)
-        return false;
-    return confirm({
-        message: 'Run your coding agent now to install the Moda SDK and instrument your LLM calls? (Edits source, installs packages.)',
-        default: true,
-    });
+    return undefined;
 }
 function parseOptionalBoolean(value) {
     if (value === undefined)
@@ -661,6 +932,19 @@ export function resolveHarnessRemote(flags) {
     }
     return true;
 }
+/**
+ * True when the user pinned the remote/local decision (flags or a
+ * deterministic analyst), so the Plan checkbox must not offer to re-toggle it.
+ */
+function hasExplicitRemoteChoice(flags) {
+    if (isTruthyFlag(flagValue(flags, 'local')))
+        return true;
+    if (isTruthyFlag(flagValue(flags, 'no-remote', 'no_remote')))
+        return true;
+    if (parseOptionalBoolean(flagValue(flags, 'remote')) !== undefined)
+        return true;
+    return isDeterministicLocalAnalyst(stringFlag(flagValue(flags, 'analyst')));
+}
 function flagValue(flags, ...keys) {
     for (const key of keys) {
         if (flags[key] !== undefined)