@moda-ai/cli 1.17.2 → 1.18.1

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-ab.d.ts

@@ -1,5 +1,8 @@
 import type { CommandContext } from './command-context.js';
 import type { ProfileIOOptions } from './profiles.js';
+export declare const DEFAULT_POLL_INTERVAL_MS = 15000;
+export declare const DEFAULT_WAIT_TIMEOUT_MS: number;
+export declare const TERMINAL_RUN_STATUSES: Set<string>;
 export interface PromptArmPayload {
     content: string;
     prompt_version_id?: string;
@@ -15,4 +18,54 @@ export interface PromptAbResult {
     cases: Array<Record<string, unknown>>;
 }
 export declare function runPromptAb(flags: Record<string, string>, profileOptions: ProfileIOOptions, context: CommandContext): Promise<void>;
+export interface ComparisonPayload {
+    run: {
+        runId: string;
+        status: string;
+        caseCount: number;
+        prodPassCount: number;
+        proposedPassCount: number;
+        prodPassRate: number;
+        proposedPassRate: number;
+        notes: string;
+    } | null;
+    cases: Array<{
+        caseId: string;
+        prodPass: boolean | null;
+        proposedPass: boolean | null;
+        prodScore: number | null;
+        proposedScore: number | null;
+    }>;
+}
+export declare function resolvePromptArmSpec(source: string, label: string, opts?: {
+    preferKey?: boolean;
+}): PromptArmPayload;
+export declare function fetchLatestRun(tenantId: string, replaySetId: string, runId: string, profileOptions: ProfileIOOptions): Promise<ComparisonPayload>;
+/**
+ * Strict outcome of a completed comparison for gating: 'candidate' only when the
+ * proposed arm passed strictly more cases than prod on a completed run. A tie,
+ * regression, skip, error, or missing run is never a candidate win.
+ */
+export declare function candidateOutcome(payload: ComparisonPayload): 'candidate' | 'baseline' | 'tie' | 'no-run';
+export declare function formatVerdict(payload: ComparisonPayload): string;
+/**
+ * Enqueue a prod-vs-proposed replay comparison and poll `/runs/latest` (pinned to
+ * OUR run id) until it reaches a terminal status or the deadline. Shared by
+ * `prompts ab` and the `prompts propose --gate` auto-gate. Returns the terminal
+ * comparison payload; throws on enqueue/poll timeout.
+ */
+export declare function enqueueAndPollComparison(args: {
+    tenantId: string;
+    replaySetId: string;
+    promptArms: {
+        prod: PromptArmPayload;
+        proposed: PromptArmPayload;
+    };
+    seedsPerCase?: number;
+    assistantModel?: string;
+    promotePrimary?: boolean;
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    onWaiting?: (status: string) => void;
+}, profileOptions: ProfileIOOptions): Promise<ComparisonPayload>;
 //# sourceMappingURL=prompts-ab.d.ts.map

package/dist/prompts-ab.js

@@ -4,9 +4,9 @@ import { callControlAPI, callDataAPI } from './api-client.js';
 import { resolveTenantId, validateConfig } from './config.js';
 import { discoverPrompts, parsePromptFileForAb, readPromptLock, runPromptSync, } from './prompts.js';
 const DEFAULT_SEEDS_PER_CASE = 3;
-const DEFAULT_POLL_INTERVAL_MS = 15_000;
-const DEFAULT_WAIT_TIMEOUT_MS = 2 * 60 * 60 * 1000;
-const TERMINAL_RUN_STATUSES = new Set(['completed', 'skipped', 'error']);
+export const DEFAULT_POLL_INTERVAL_MS = 15_000;
+export const DEFAULT_WAIT_TIMEOUT_MS = 2 * 60 * 60 * 1000;
+export const TERMINAL_RUN_STATUSES = new Set(['completed', 'skipped', 'error']);
 export async function runPromptAb(flags, profileOptions, context) {
     validateConfig();
     const tenantId = flags['tenant-id'] || resolveTenantId(profileOptions);
@@ -81,23 +81,40 @@ export async function runPromptAb(flags, profileOptions, context) {
     }
     context.output.writeData(result);
 }
-function resolvePromptArmSpec(source, label) {
+export function resolvePromptArmSpec(source, label, opts = {}) {
     const trimmed = source.trim();
     if (!trimmed) {
         throw new Error(`Empty prompt source for ${label}`);
     }
+    const fromDiscovery = () => {
+        const discovered = discoverPrompts();
+        const match = discovered.find((prompt) => prompt.key === trimmed)
+            ?? discovered.find((prompt) => prompt.sourcePath === trimmed);
+        return match ? { key: match.key, content: match.content } : null;
+    };
     const absPath = isAbsolute(trimmed) ? trimmed : resolve(process.cwd(), trimmed);
     let key;
     let content;
-    if (existsSync(absPath)) {
+    // When the caller knows `source` is a registry key (e.g. `propose --gate`'s
+    // `--prompt-key`), resolve by discovery first so a same-named file/dir in the
+    // cwd can't shadow the intended prompt; fall back to path resolution otherwise.
+    const preferred = opts.preferKey ? fromDiscovery() : null;
+    if (preferred) {
+        key = preferred.key;
+        content = preferred.content;
+    }
+    else if (opts.preferKey) {
+        // Key-first resolution must NOT fall through to path resolution — otherwise a
+        // cwd file named like the key would still shadow an unresolved registry key.
+        throw new Error(`Could not resolve prompt key '${trimmed}' — no discovered prompt matched this key`);
+    }
+    else if (existsSync(absPath)) {
         const parsed = parsePromptFileForAb(absPath);
         key = parsed.key;
         content = parsed.content;
     }
     else {
-        const discovered = discoverPrompts();
-        const match = discovered.find((prompt) => prompt.key === trimmed)
-            ?? discovered.find((prompt) => prompt.sourcePath === trimmed);
+        const match = fromDiscovery();
         if (!match) {
             throw new Error(`Could not resolve prompt '${trimmed}' — pass a .prompt.md path or a discovered prompt key`);
         }
@@ -176,13 +193,29 @@ async function loadScenarioFromConversation(conversationId) {
     }
     return `Replay conversation ${conversationId}: help the user accomplish their original goal using the available tools.`;
 }
-async function fetchLatestRun(tenantId, replaySetId, runId, profileOptions) {
+export async function fetchLatestRun(tenantId, replaySetId, runId, profileOptions) {
     // Pin the poll to OUR run id — otherwise a concurrent comparison on the same
     // set would make `/runs/latest` return the newer run forever and this command
     // would stall until timeout even after its own run finished.
     return callControlAPI(`/tenants/${encodeURIComponent(tenantId)}/replay-sets/${encodeURIComponent(replaySetId)}/runs/latest?runId=${encodeURIComponent(runId)}`, { method: 'GET' }, profileOptions, { timeoutMs: 60_000, retries: 2 });
 }
-function formatVerdict(payload) {
+/**
+ * Strict outcome of a completed comparison for gating: 'candidate' only when the
+ * proposed arm passed strictly more cases than prod on a completed run. A tie,
+ * regression, skip, error, or missing run is never a candidate win.
+ */
+export function candidateOutcome(payload) {
+    const run = payload.run;
+    if (!run || run.status !== 'completed')
+        return 'no-run';
+    const delta = run.proposedPassCount - run.prodPassCount;
+    if (delta > 0)
+        return 'candidate';
+    if (delta < 0)
+        return 'baseline';
+    return 'tie';
+}
+export function formatVerdict(payload) {
     const run = payload.run;
     if (!run)
         return 'no run';
@@ -224,6 +257,43 @@ function formatPass(value) {
 function pct(rate) {
     return `${Math.round(Math.max(0, Math.min(1, rate)) * 100)}%`;
 }
+/**
+ * Enqueue a prod-vs-proposed replay comparison and poll `/runs/latest` (pinned to
+ * OUR run id) until it reaches a terminal status or the deadline. Shared by
+ * `prompts ab` and the `prompts propose --gate` auto-gate. Returns the terminal
+ * comparison payload; throws on enqueue/poll timeout.
+ */
+export async function enqueueAndPollComparison(args, profileOptions) {
+    const enqueue = (await callControlAPI(`/tenants/${encodeURIComponent(args.tenantId)}/replay-sets/${encodeURIComponent(args.replaySetId)}/run`, {
+        method: 'POST',
+        body: JSON.stringify({
+            promptArms: args.promptArms,
+            seedsPerCase: args.seedsPerCase ?? DEFAULT_SEEDS_PER_CASE,
+            assistantModel: args.assistantModel || undefined,
+            promotePrimary: args.promotePrimary ?? false,
+        }),
+    }, profileOptions, { timeoutMs: 120_000, retries: 1 }));
+    const timeoutMs = args.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+    const pollIntervalMs = args.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const deadline = Date.now() + timeoutMs;
+    let latest = null;
+    while (Date.now() < deadline) {
+        latest = await fetchLatestRun(args.tenantId, args.replaySetId, enqueue.runId, profileOptions);
+        const status = latest.run?.status ?? '';
+        const runId = latest.run?.runId ?? '';
+        if (TERMINAL_RUN_STATUSES.has(status) && runId === enqueue.runId) {
+            return latest;
+        }
+        args.onWaiting?.(status || 'pending');
+        await sleep(pollIntervalMs);
+    }
+    if (!latest?.run
+        || latest.run.runId !== enqueue.runId
+        || !TERMINAL_RUN_STATUSES.has(latest.run.status)) {
+        throw new Error(`Timed out after ${timeoutMs}ms waiting for replay run ${enqueue.runId} to finish`);
+    }
+    return latest;
+}
 function parsePositiveInt(raw, fallback, max) {
     if (!raw)
         return fallback;

package/dist/prompts-propose.d.ts

@@ -2,9 +2,14 @@ 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.
+ * candidate registered as a new (unlabeled) prompt version. Does NOT promote by
+ * default: 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.
+ *
+ * `--gate` chains that gate automatically: it A/Bs the fresh candidate (proposed
+ * arm) vs the on-disk baseline (prod arm) over the same replay set and prints the
+ * verdict. `--promote-on-win` then promotes the candidate to `prod` ONLY on a
+ * strict candidate win. `--model=<slug>` overrides the revision model.
  */
 export declare function runPromptPropose(positionals: string[], flags: Record<string, string>, profileOptions: ProfileIOOptions, context: CommandContext): Promise<void>;
 //# sourceMappingURL=prompts-propose.d.ts.map