@moda-ai/cli 1.17.1 → 1.18.0

package/dist/init/progress-board.d.ts

@@ -0,0 +1,80 @@
+export type ProgressLaneStatus = 'running' | 'done' | 'warning' | 'failed';
+export interface ProgressLane {
+    id: string;
+    title: string;
+    status: ProgressLaneStatus;
+    /** Latest one-line detail while running; frozen summary note when terminal. */
+    detail?: string;
+    /** Duration expectation appended to long-running lanes, e.g. "usually 2-4 min". */
+    expectation?: string;
+    startedAt: number;
+    finishedAt?: number;
+}
+export interface ProgressBoardFrameOptions {
+    now?: number;
+    spinnerFrame?: string;
+    color?: boolean;
+    /** Max visible line width; longer lines are truncated so in-place rewrites never wrap. */
+    width?: number;
+}
+/**
+ * Pure frame renderer (unit-testable without a TTY): one line per lane, in
+ * insertion order. Running lanes show spinner, title, elapsed, latest detail,
+ * and the "(usually X min)" expectation; terminal lanes freeze to a glyph,
+ * title, and their summary note.
+ */
+export declare function renderProgressBoardFrame(lanes: readonly ProgressLane[], options?: ProgressBoardFrameOptions): string[];
+export interface InitProgressBoardOptions {
+    stream?: NodeJS.WriteStream;
+    /** Overrides TTY detection (in-place rendering); defaults to stream.isTTY with TERM=dumb treated as non-TTY. */
+    isTTY?: boolean;
+    color?: boolean;
+    now?: () => number;
+    renderIntervalMs?: number;
+    fallbackIntervalMs?: number;
+}
+/**
+ * Stateful board driver. TTY mode repaints on a ~150ms interval (unref'd so it
+ * never holds the process open); non-TTY mode prints plain lines on lane
+ * start/terminal transitions and throttles intermediate updates to one line
+ * per lane per 10s.
+ */
+export declare class InitProgressBoard {
+    private readonly stream;
+    private readonly tty;
+    private readonly color;
+    private readonly now;
+    private readonly renderIntervalMs;
+    private readonly fallbackIntervalMs;
+    private readonly laneList;
+    private readonly lanesById;
+    private readonly lastFallbackPrint;
+    private timer;
+    private renderedLines;
+    private spinnerIndex;
+    private stopped;
+    constructor(options?: InitProgressBoardOptions);
+    get lanes(): readonly ProgressLane[];
+    startLane(id: string, title: string, options?: {
+        detail?: string;
+        expectation?: string;
+    }): void;
+    update(id: string, detail: string): void;
+    complete(id: string, note?: string): void;
+    warn(id: string, note?: string): void;
+    fail(id: string, note?: string): void;
+    /** Freeze the final frame (TTY) and release the repaint timer. Idempotent. */
+    stop(): void;
+    /**
+     * Terminal transitions are refinable: finishing an already-terminal lane
+     * updates its glyph/note (keeping the first finish time for elapsed), so a
+     * lane frozen early (e.g. "analysis finished on Moda; finalizing after
+     * setup") can be corrected once the final outcome is known. Exact duplicate
+     * finishes stay no-ops; `update()` still applies to running lanes only.
+     */
+    private finish;
+    private ensureTimer;
+    private render;
+    private writeLine;
+}
+//# sourceMappingURL=progress-board.d.ts.map

package/dist/init/progress-board.js

@@ -0,0 +1,225 @@
+// src/init/progress-board.ts. Multi-lane live progress board for moda init
+// Step 4 (Set up), where several activities run at once (hosted harness
+// analysis, fast local tasks, the SDK integration agent).
+//
+// Hand-rolled, no dependencies, stderr only. On a TTY the lane block is
+// rewritten in place with cursor-up ANSI, throttled to ~150ms; completed lanes
+// freeze to a check line so the board never grows unbounded. Non-TTY human
+// mode falls back to plain progress lines at most every 10s per lane.
+// Agent/json modes never construct a board (init emits NDJSON progress events
+// instead). Color gating follows tui.ts conventions (NO_COLOR / TERM=dumb
+// respected); spinner and duration helpers follow analyst-tui.ts.
+import { stripAnsi } from '../markdown-terminal.js';
+const SPINNER_FRAMES = ['◐', '◓', '◑', '◒'];
+const GLYPHS = {
+    done: '✓',
+    warning: '!',
+    failed: '✗',
+};
+const GLYPH_COLORS = {
+    done: 32,
+    warning: 33,
+    failed: 31,
+};
+/** Same one-line cap as ask-stream's tool cards. */
+const DETAIL_MAX = 100;
+const RENDER_INTERVAL_MS = 150;
+const NON_TTY_LANE_INTERVAL_MS = 10_000;
+/**
+ * Pure frame renderer (unit-testable without a TTY): one line per lane, in
+ * insertion order. Running lanes show spinner, title, elapsed, latest detail,
+ * and the "(usually X min)" expectation; terminal lanes freeze to a glyph,
+ * title, and their summary note.
+ */
+export function renderProgressBoardFrame(lanes, options = {}) {
+    const now = options.now ?? Date.now();
+    const color = options.color ?? false;
+    const width = Math.max(48, Math.min(options.width ?? 120, 200));
+    const paint = (code, text) => color ? `\u001b[${code}m${text}\u001b[0m` : text;
+    const titleWidth = Math.min(32, lanes.reduce((max, lane) => Math.max(max, lane.title.length), 0));
+    return lanes.map((lane) => {
+        const title = lane.title.padEnd(titleWidth);
+        if (lane.status === 'running') {
+            const elapsed = formatDuration(Math.max(0, Math.round((now - lane.startedAt) / 1000)));
+            const detail = lane.detail ? `   ${oneLine(lane.detail)}` : '';
+            const expectation = lane.expectation ? ` ${paint(90, `(${lane.expectation})`)}` : '';
+            const glyph = paint(36, options.spinnerFrame ?? SPINNER_FRAMES[0]);
+            return truncateVisible(`  ${glyph} ${title}  ${paint(90, elapsed.padStart(6))}${detail}${expectation}`, width);
+        }
+        const glyph = paint(GLYPH_COLORS[lane.status], GLYPHS[lane.status]);
+        const note = lane.detail
+            ? oneLine(lane.detail)
+            : formatDuration(Math.max(0, Math.round(((lane.finishedAt ?? now) - lane.startedAt) / 1000)));
+        return truncateVisible(`  ${glyph} ${title}  ${note}`, width);
+    });
+}
+/**
+ * Stateful board driver. TTY mode repaints on a ~150ms interval (unref'd so it
+ * never holds the process open); non-TTY mode prints plain lines on lane
+ * start/terminal transitions and throttles intermediate updates to one line
+ * per lane per 10s.
+ */
+export class InitProgressBoard {
+    stream;
+    tty;
+    color;
+    now;
+    renderIntervalMs;
+    fallbackIntervalMs;
+    laneList = [];
+    lanesById = new Map();
+    lastFallbackPrint = new Map();
+    timer;
+    renderedLines = 0;
+    spinnerIndex = 0;
+    stopped = false;
+    constructor(options = {}) {
+        this.stream = options.stream ?? process.stderr;
+        const dumbTerm = process.env.TERM === 'dumb';
+        this.tty = options.isTTY ?? (this.stream.isTTY === true && !dumbTerm);
+        // NO_COLOR disables color when set to any value, per no-color.org.
+        this.color = options.color ?? (this.tty && process.env.NO_COLOR === undefined);
+        this.now = options.now ?? Date.now;
+        this.renderIntervalMs = options.renderIntervalMs ?? RENDER_INTERVAL_MS;
+        this.fallbackIntervalMs = options.fallbackIntervalMs ?? NON_TTY_LANE_INTERVAL_MS;
+    }
+    get lanes() {
+        return this.laneList;
+    }
+    startLane(id, title, options = {}) {
+        if (this.stopped || this.lanesById.has(id))
+            return;
+        const lane = {
+            id,
+            title,
+            status: 'running',
+            detail: options.detail,
+            expectation: options.expectation,
+            startedAt: this.now(),
+        };
+        this.laneList.push(lane);
+        this.lanesById.set(id, lane);
+        if (this.tty) {
+            this.ensureTimer();
+            this.render();
+        }
+        else {
+            this.lastFallbackPrint.set(id, this.now());
+            this.writeLine(`  ${title}: ${lane.detail ? oneLine(lane.detail) : 'started'}${lane.expectation ? ` (${lane.expectation})` : ''}`);
+        }
+    }
+    update(id, detail) {
+        const lane = this.lanesById.get(id);
+        if (!lane || this.stopped || lane.status !== 'running')
+            return;
+        lane.detail = detail;
+        if (this.tty)
+            return; // interval repaints
+        const last = this.lastFallbackPrint.get(id) ?? 0;
+        if (this.now() - last < this.fallbackIntervalMs)
+            return;
+        this.lastFallbackPrint.set(id, this.now());
+        const elapsed = formatDuration(Math.max(0, Math.round((this.now() - lane.startedAt) / 1000)));
+        this.writeLine(`  ${lane.title}: ${oneLine(detail)} (${elapsed} elapsed)`);
+    }
+    complete(id, note) {
+        this.finish(id, 'done', note);
+    }
+    warn(id, note) {
+        this.finish(id, 'warning', note);
+    }
+    fail(id, note) {
+        this.finish(id, 'failed', note);
+    }
+    /** Freeze the final frame (TTY) and release the repaint timer. Idempotent. */
+    stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+        if (this.tty && this.laneList.length > 0)
+            this.render();
+    }
+    /**
+     * Terminal transitions are refinable: finishing an already-terminal lane
+     * updates its glyph/note (keeping the first finish time for elapsed), so a
+     * lane frozen early (e.g. "analysis finished on Moda; finalizing after
+     * setup") can be corrected once the final outcome is known. Exact duplicate
+     * finishes stay no-ops; `update()` still applies to running lanes only.
+     */
+    finish(id, status, note) {
+        const lane = this.lanesById.get(id);
+        if (!lane || this.stopped)
+            return;
+        if (lane.status !== 'running' && lane.status === status && lane.detail === note)
+            return;
+        lane.status = status;
+        lane.detail = note;
+        lane.finishedAt ??= this.now();
+        if (this.tty) {
+            this.render();
+            return;
+        }
+        const label = status === 'done' ? 'done' : status === 'warning' ? 'warning' : 'failed';
+        this.writeLine(`  ${lane.title}: ${label}${note ? ` (${oneLine(note)})` : ''}`);
+    }
+    ensureTimer() {
+        if (this.timer || !this.tty)
+            return;
+        this.timer = setInterval(() => this.render(), this.renderIntervalMs);
+        // Never keep the process alive just to animate a spinner.
+        this.timer.unref?.();
+    }
+    render() {
+        if (!this.tty || this.laneList.length === 0)
+            return;
+        const lines = renderProgressBoardFrame(this.laneList, {
+            now: this.now(),
+            spinnerFrame: SPINNER_FRAMES[this.spinnerIndex++ % SPINNER_FRAMES.length],
+            color: this.color,
+            width: this.stream.columns ?? 120,
+        });
+        const up = this.renderedLines > 0 ? `\u001b[${this.renderedLines}A` : '';
+        this.stream.write(`${up}${lines.map((line) => `\u001b[2K${line}`).join('\n')}\n`);
+        this.renderedLines = lines.length;
+    }
+    writeLine(line) {
+        this.stream.write(`${line}\n`);
+    }
+}
+/**
+ * One-line convention shared with ask-stream tool cards: strip escapes,
+ * collapse whitespace, cap ~100 chars. Lane details carry backend/agent
+ * controlled text (hosted progress messages, tool inputs like file paths and
+ * shell commands), so ANSI/OSC escapes and remaining C0 controls must be
+ * removed before the text reaches the terminal; an embedded escape would
+ * otherwise corrupt the in-place cursor-up rewrite or inject control output.
+ */
+function oneLine(text) {
+    const collapsed = stripAnsi(text)
+        .replace(/[\u0000-\u001f\u007f]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return collapsed.length > DETAIL_MAX ? `${collapsed.slice(0, DETAIL_MAX - 1)}…` : collapsed;
+}
+/** Same shape as analyst-tui.ts formatDuration. */
+function formatDuration(seconds) {
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remaining = seconds % 60;
+    return `${minutes}m ${remaining}s`;
+}
+function truncateVisible(value, width) {
+    if (visibleLength(value) <= width)
+        return value;
+    const stripped = stripAnsi(value);
+    return `${stripped.slice(0, Math.max(0, width - 3))}...`;
+}
+function visibleLength(value) {
+    return stripAnsi(value).length;
+}
+//# sourceMappingURL=progress-board.js.map

package/dist/init/sdk-integration.d.ts

@@ -1,4 +1,5 @@
-import { type CodingAgentAdapter } from '../harness.js';
+import { type CodingAgentAdapter, type CodingAgentEvent } from '../harness.js';
+export { describeCodingAgentEvent } from '../harness.js';
 import { type SdkGuideContext } from './sdk-guide.js';
 export type SdkIntegrationResult = {
     status: 'integrated';
@@ -18,6 +19,13 @@ export interface SdkIntegrationOptions {
     /** Stream the agent's progress to the user (human terminals only). */
     human?: boolean;
     onProgress?: (message: string) => void;
+    /**
+     * Receive the structured coding-agent stream events incrementally (tool use,
+     * commands, agent text) so callers like the init progress board can render
+     * their own live view. Providing it enables the streaming invocation even
+     * when `human` is false.
+     */
+    onEvent?: (event: CodingAgentEvent) => void;
 }
 /**
  * Pick an installed coding-agent CLI and run it, in write mode, to integrate

package/dist/init/sdk-integration.js

@@ -8,7 +8,11 @@
 // stack, materialize it into .claude/skills/<id>/, and hand the agent a thin
 // prompt that points at the skill file — the prompt no longer inlines API
 // documentation.
-import { codingAgentDisplayName, detectAvailableCodingAgents, runCodingAgent, } from '../harness.js';
+import { codingAgentDisplayName, describeCodingAgentEvent, detectAvailableCodingAgents, runCodingAgent, } from '../harness.js';
+// Re-exported for callers/tests that treat this module as the card-rendering
+// surface; the implementation lives in harness.ts next to the event parser so
+// the agent-stream analyst path can reuse it without an import cycle.
+export { describeCodingAgentEvent } from '../harness.js';
 import { installIntegrationSkill, readBundledSkillMd } from '../skills-bundled.js';
 import { detectSdkGuideContext, renderDetectionBlock, renderSdkIntegrationGuide, stripSkillFrontmatter, } from './sdk-guide.js';
 import { resolveIntegrationSkillId } from './skill-resolver.js';
@@ -70,9 +74,15 @@ export async function runSdkIntegration(options = {}) {
         prompt,
         rootDir: cwd,
         mode: 'write',
-        stream: human,
+        stream: human || Boolean(options.onEvent),
         progressToStderr: false,
         onProgress: (message) => emit(message),
+        onAgentEvent: (event) => {
+            options.onEvent?.(event);
+            const card = describeCodingAgentEvent(event);
+            if (card)
+                emit(card);
+        },
     });
     if (run.failedToStart) {
         return { status: 'failed', adapter, detail: `${codingAgentDisplayName(adapter)} CLI failed to start.` };

package/dist/manifest.js

@@ -76,6 +76,7 @@ export function buildManifest(commands) {
             { term: 'profile', meaning: 'A named local CLI configuration under ~/.moda that selects environment, tenant, and secret references.' },
             { term: 'harness', meaning: 'Moda’s local graph of runtime agents, prompts, tools, identities, and deployments in a codebase.' },
             { term: 'harness report', meaning: 'A cited analyst artifact under .moda/ that justifies the harness graph before sync.' },
+            { term: 'remote analyze run', meaning: 'A Moda-hosted harness analysis tracked in .moda/harness-remote-run.json; fetch its status or result with `moda harness pull`.' },
             { term: 'conversation', meaning: 'A user-agent interaction thread stored in Moda analytics.' },
             { term: 'trace', meaning: 'Raw OTLP span evidence for one run or conversation, exposed by `moda audit`.' },
             { term: 'ingest key', meaning: 'A `moda_sk_` API key for SDKs, CI, and Data API calls. Treat it as a secret.' },

package/dist/prompts-propose.d.ts

@@ -0,0 +1,10 @@
+import type { CommandContext } from './command-context.js';
+import type { ProfileIOOptions } from './profiles.js';
+/**
+ * `moda prompts propose` — turn a `prompts ab` run's failures into a revised
+ * candidate registered as a new (unlabeled) prompt version. Does NOT promote:
+ * the operator gates the candidate with a fresh `prompts ab` (ideally on the
+ * printed holdout cases the revision never saw) and promotes only if it wins.
+ */
+export declare function runPromptPropose(positionals: string[], flags: Record<string, string>, profileOptions: ProfileIOOptions, context: CommandContext): Promise<void>;
+//# sourceMappingURL=prompts-propose.d.ts.map

package/dist/prompts-propose.js

@@ -0,0 +1,76 @@
+import { writeFileSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+import { callControlAPI } from './api-client.js';
+import { validateConfig } from './config.js';
+// Propose is a single OpenRouter revision behind the backend; give it room.
+const PROPOSE_TIMEOUT_MS = 300_000;
+/**
+ * `moda prompts propose` — turn a `prompts ab` run's failures into a revised
+ * candidate registered as a new (unlabeled) prompt version. Does NOT promote:
+ * the operator gates the candidate with a fresh `prompts ab` (ideally on the
+ * printed holdout cases the revision never saw) and promotes only if it wins.
+ */
+export async function runPromptPropose(positionals, flags, profileOptions, context) {
+    validateConfig();
+    const promptKey = flags['prompt-key'] || positionals[1];
+    const fromRunId = flags['from-run'] || flags['from-run-id'] || flags['run-id'];
+    const replaySetId = flags['set-id'] || flags['replay-set-id'];
+    if (!promptKey || !fromRunId || !replaySetId) {
+        throw new Error('Usage: moda prompts propose --prompt-key=<key> --from-run=<run_id> --set-id=<replay_set_id> [--max-dossiers=8] [--out=path.prompt.md]');
+    }
+    const maxDossiers = parsePositiveInt(flags['max-dossiers'], 8, 16);
+    const result = (await callControlAPI(`/prompts/${encodeURIComponent(promptKey)}/propose`, { method: 'POST', body: JSON.stringify({ fromRunId, replaySetId, maxDossiers }) }, profileOptions, { timeoutMs: PROPOSE_TIMEOUT_MS, retries: 0 }));
+    let outPath;
+    if (result.status === 'proposed' && result.content && flags.out) {
+        outPath = isAbsolute(flags.out) ? flags.out : resolve(process.cwd(), flags.out);
+        writeFileSync(outPath, result.content, 'utf8');
+    }
+    if (context.outputMode === 'human') {
+        printHuman(result, outPath);
+    }
+    context.output.writeData(outPath ? { ...result, outPath } : result);
+}
+function printHuman(result, outPath) {
+    const w = (s) => process.stderr.write(s + '\n');
+    if (result.status !== 'proposed') {
+        w(`No candidate produced (${result.status}): ${result.note}`);
+        return;
+    }
+    w(`Proposed candidate for '${result.promptKey}'`);
+    w(`  new version:  ${result.versionId}  (unlabeled — not promoted)`);
+    w(`  base version: ${result.baseVersionId ?? '(none)'}`);
+    w(`  from run:     built from ${result.dossierCount} failure dossier(s)`);
+    if (result.changelog)
+        w(`  changelog:    ${result.changelog}`);
+    if (result.risks.length)
+        w(`  risks:        ${result.risks.map((r) => `- ${r}`).join('\n                ')}`);
+    if (outPath)
+        w(`  written to:   ${outPath}`);
+    w('');
+    w('Next — gate on holdout cases the revision never saw, then promote if it wins:');
+    if (result.holdoutCaseIds.length) {
+        w(`  holdout cases (${result.holdoutCaseIds.length}): ${result.holdoutCaseIds.join(', ')}`);
+    }
+    else {
+        w('  (too few failures to reserve a holdout — gate on a fresh --auto-generate set)');
+    }
+    if (outPath) {
+        // The candidate lives only in the registry as an unlabeled version; `prompts ab`
+        // resolves --candidate from local file content, so point it at the written --out
+        // file. Using --candidate-key=<key> would resolve to the baseline and compare the
+        // prompt against itself.
+        w(`  moda prompts ab --baseline-key=${result.promptKey} --candidate=${outPath} --auto-generate`);
+    }
+    else {
+        w(`  # re-run with --out=<path.prompt.md> to materialize the candidate, then:`);
+        w(`  moda prompts ab --baseline-key=${result.promptKey} --candidate=<path.prompt.md> --auto-generate`);
+    }
+    w(`  moda prompts promote ${result.promptKey} --label=prod --version=${result.versionId}`);
+}
+function parsePositiveInt(raw, fallback, max) {
+    const n = Number.parseInt(raw ?? '', 10);
+    if (!Number.isFinite(n) || n <= 0)
+        return fallback;
+    return Math.min(n, max);
+}
+//# sourceMappingURL=prompts-propose.js.map

package/dist/prompts.js

@@ -5,6 +5,7 @@ import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { callControlAPI } from './api-client.js';
 import { createCommandContext } from './command-context.js';
 import { runPromptAb } from './prompts-ab.js';
+import { runPromptPropose } from './prompts-propose.js';
 const MODA_DIR = '.moda';
 const MANIFEST_PATH = join(MODA_DIR, 'prompts.yml');
 const LOCK_PATH = join(MODA_DIR, 'prompts.lock.json');
@@ -55,8 +56,11 @@ export async function runPromptsCommand(input, legacyFlags, legacyProfileOptions
         case 'ab':
             await runPromptAb(flags, profileOptions, context);
             break;
+        case 'propose':
+            await runPromptPropose(positionals, flags, profileOptions, context);
+            break;
         default:
-            throw new Error(`Unknown prompts command '${subcommand}'. Use init, status, diff, sync, promote, or ab.`);
+            throw new Error(`Unknown prompts command '${subcommand}'. Use init, status, diff, sync, promote, ab, or propose.`);
     }
 }
 export async function initPrompts(options = {}) {

package/dist/tui.d.ts

@@ -1,5 +1,5 @@
 import type { DoctorCheckStatus, DoctorReport, StatusPayload } from './doctor.js';
-import type { InitPhaseResult, InitSetupAction } from './init/index.js';
+import type { InitSetupAction } from './init/index.js';
 type TerminalBadge = DoctorCheckStatus | 'info' | 'run';
 export declare function renderDoctorHuman(report: DoctorReport, options?: {
     color?: boolean;
@@ -11,13 +11,21 @@ export declare function renderStatusHuman(status: StatusPayload, options?: {
 }): string;
 export declare function renderInitBanner(): string;
 export declare function renderInitStep(index: number, total: number, title: string, detail?: string): string;
-export declare function renderInitNote(message: string, status?: DoctorCheckStatus): string;
-export declare function renderInitSetupPlan(actions: InitSetupAction[]): string;
+export declare function renderInitNote(message: string, status?: DoctorCheckStatus | 'info'): string;
+export declare function renderInitSetupPlan(actions: InitSetupAction[], options?: {
+    snapshotConsent?: boolean;
+}): string;
 export declare function renderInitComplete(options: {
     tenantName: string;
     filesChanged: string[];
     skipped: InitSetupAction[];
-    phases: InitPhaseResult[];
+    dashboardUrl?: string;
+    harness?: {
+        state: 'mapped' | 'pending';
+        agents?: number;
+        artifacts?: number;
+    };
+    telemetrySeen?: boolean;
 }): string;
 export declare function renderHarnessProgress(message: string, status?: TerminalBadge): string;
 export declare function renderHarnessAnalystPreflight(options: {

package/dist/tui.js

@@ -102,7 +102,7 @@ export function renderInitNote(message, status = 'pass') {
     const ui = createTerminalUi();
     return `  ${ui.status(status)} ${message}`;
 }
-export function renderInitSetupPlan(actions) {
+export function renderInitSetupPlan(actions, options = {}) {
     const ui = createTerminalUi();
     const lines = actions.map((action) => {
         const status = action.approved
@@ -113,17 +113,25 @@ export function renderInitSetupPlan(actions) {
         const suffix = action.reason ? ` - ${action.reason}` : '';
         return ui.wrap(`  ${ui.status(status)} ${action.title}${suffix}`, 4);
     });
+    if (options.snapshotConsent) {
+        lines.push('');
+        lines.push(ui.wrap(`  ${ui.status('info')} Moda will analyze a snapshot of this repo on Moda's servers to map your agent harness. Secrets and .env files are excluded and the snapshot is deleted after the run.`, 4));
+    }
     return lines.join('\n');
 }
 export function renderInitComplete(options) {
     const ui = createTerminalUi();
+    const dashboardUrl = options.dashboardUrl ?? 'https://moda.dev';
     const lines = [];
     lines.push('');
-    lines.push(ui.title(`Setup complete for ${options.tenantName}`));
+    lines.push(ui.title(`Workspace ready: ${options.tenantName}`));
+    lines.push(`Dashboard: ${ui.command(dashboardUrl)}`);
     lines.push('');
-    lines.push(ui.section('Phases'));
-    for (const phase of options.phases) {
-        lines.push(`  ${ui.status(phase.status === 'warning' ? 'warning' : phase.status === 'skipped' ? 'skipped' : 'pass')} ${phase.title}${phase.details ? ` - ${phase.details}` : ''}`);
+    if (options.harness?.state === 'pending') {
+        lines.push(ui.wrap(`  ${ui.status('run')} Harness analysis is still running on Moda. Run ${ui.command('moda harness pull --sync')} in a few minutes.`, 4));
+    }
+    else if (options.harness) {
+        lines.push(ui.wrap(`  ${ui.status('pass')} Harness mapped: ${options.harness.agents ?? 0} agent(s), ${options.harness.artifacts ?? 0} artifact(s). View: ${ui.command(dashboardUrl)}`, 4));
     }
     lines.push('');
     lines.push(ui.section('Files changed'));
@@ -142,16 +150,14 @@ export function renderInitComplete(options) {
         }
     }
     lines.push('');
-    lines.push(ui.section('Next commands'));
-    lines.push(`  ${ui.command('moda status')}`);
-    lines.push(`  ${ui.command('moda doctor')}`);
-    lines.push(`  ${ui.command('moda harness sync --summary')}`);
-    lines.push('');
-    lines.push(ui.section('Agent handoff'));
-    lines.push('  Integrate the Moda SDK into this project using .moda/SDK_INTEGRATION.md');
-    lines.push('  and .moda/HARNESS.md. Package installs and source edits stay manual.');
-    lines.push('');
-    lines.push('Dashboard: https://moda.dev');
+    lines.push(ui.section('Next steps'));
+    if (options.telemetrySeen === true) {
+        lines.push(`  Telemetry is flowing. Explore it: ${ui.command('moda overview')}`);
+    }
+    else {
+        lines.push(`  Run your app to send telemetry, then: ${ui.command('moda doctor --online')}`);
+    }
+    lines.push(`  Ask about your agents: ${ui.command('moda ask "what did my agents do today?"')}`);
     return lines.join('\n');
 }
 export function renderHarnessProgress(message, status = 'run') {
@@ -366,11 +372,12 @@ function createTerminalUi(options = {}) {
 function wrapLine(text, width, indent) {
     if (text.length <= width)
         return text;
-    const words = text.split(/\s+/);
+    const lead = text.match(/^\s*/)?.[0] ?? '';
+    const words = text.trimStart().split(/\s+/);
     const lines = [];
     let current = '';
     for (const word of words) {
-        const next = current ? `${current} ${word}` : word;
+        const next = current ? `${current} ${word}` : `${lead}${word}`;
         if (next.length > width && current) {
             lines.push(current);
             current = `${' '.repeat(indent)}${word}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moda-ai/cli",
-  "version": "1.17.1",
+  "version": "1.18.0",
   "description": "CLI for Moda - AI agent analytics and observability",
   "type": "module",
   "bin": {

package/skills/integration/index.json

@@ -1,7 +1,7 @@
 {
   "schema_version": "moda.skill_index.v1",
-  "bundled_at": "2026-07-08T22:22:27.468Z",
-  "cli_version": "1.17.1",
+  "bundled_at": "2026-07-09T22:31:35.483Z",
+  "cli_version": "1.18.0",
   "skills": [
     {
       "id": "integration-node-anthropic",