@moda-ai/cli 1.17.2 → 1.18.1

package/dist/prompts-propose.js

@@ -1,14 +1,20 @@
 import { writeFileSync } from 'node:fs';
 import { isAbsolute, resolve } from 'node:path';
 import { callControlAPI } from './api-client.js';
-import { validateConfig } from './config.js';
+import { resolveTenantId, validateConfig } from './config.js';
+import { candidateOutcome, enqueueAndPollComparison, formatVerdict, resolvePromptArmSpec, } from './prompts-ab.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.
+ * 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 async function runPromptPropose(positionals, flags, profileOptions, context) {
     validateConfig();
@@ -16,21 +22,124 @@ export async function runPromptPropose(positionals, flags, profileOptions, conte
     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]');
+        throw new Error('Usage: moda prompts propose --prompt-key=<key> --from-run=<run_id> --set-id=<replay_set_id> [--max-dossiers=8] [--model=<slug>] [--out=path.prompt.md] [--gate] [--promote-on-win]');
     }
     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 }));
+    const model = (flags.model ?? flags['revise-model'] ?? '').trim();
+    const result = (await callControlAPI(`/prompts/${encodeURIComponent(promptKey)}/propose`, {
+        method: 'POST',
+        body: JSON.stringify({ fromRunId, replaySetId, maxDossiers, model: model || undefined }),
+    }, 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');
     }
+    // The gate needs the candidate content in-hand for the proposed arm.
+    const wantGate = flags.gate === 'true';
+    const promoteOnWin = flags['promote-on-win'] === 'true';
+    let gate;
+    if (wantGate) {
+        if (result.status !== 'proposed' || !result.content) {
+            gate = {
+                ran: false,
+                scope: 'full-set',
+                scopeNote: `no candidate to gate (${result.status})`,
+                verdict: 'skipped',
+                outcome: 'no-run',
+                runId: null,
+                promoted: false,
+            };
+        }
+        else {
+            gate = await runGate({
+                result,
+                promptKey,
+                replaySetId,
+                flags,
+                promoteOnWin,
+                profileOptions,
+                context,
+            });
+        }
+    }
+    if (context.outputMode === 'human') {
+        printHuman(result, outPath, gate);
+    }
+    context.output.writeData({
+        ...result,
+        ...(outPath ? { outPath } : {}),
+        ...(gate ? { gate } : {}),
+    });
+}
+async function runGate(args) {
+    const { result, promptKey, replaySetId, flags, promoteOnWin, profileOptions, context } = args;
+    const tenantId = flags['tenant-id'] || resolveTenantId(profileOptions);
+    if (!tenantId) {
+        throw new Error('Missing tenant id for --gate. Run `moda init` or pass --tenant-id=<id>.');
+    }
+    // prod arm = the on-disk/registry baseline. `promptKey` is always a registry
+    // key here, so resolve key-first (`preferKey`) — otherwise a same-named file or
+    // dir in the cwd could shadow it and gate the candidate against wrong content.
+    // proposed arm = the freshly proposed candidate content returned above.
+    const prodArm = resolvePromptArmSpec(promptKey, 'baseline', { preferKey: true });
+    const proposedArm = {
+        content: result.content ?? '',
+        prompt_version_id: result.versionId ?? '',
+        prompt_id: '',
+        prompt_label: 'candidate',
+    };
+    const seedsPerCase = parsePositiveInt(flags.seeds ?? flags['seeds-per-case'], 3, 10);
+    const assistantModel = (flags['assistant-model'] ?? '').trim();
+    const timeoutMs = parsePositiveInt(flags['gate-timeout'] ?? flags.timeout, 2 * 60 * 60 * 1000, 24 * 60 * 60 * 1000);
+    const pollIntervalMs = parsePositiveInt(flags['poll-interval'], 15_000, 120_000);
+    // The /run endpoint scores the WHOLE replay set — there is no per-case subset
+    // knob — so the gate cannot be scoped to just the holdout ids the revision
+    // never saw. Say so plainly so a win isn't read as overfitting-proof.
+    const scopeNote = result.holdoutCaseIds.length
+        ? `gated over the FULL replay set (${result.holdoutCaseIds.length} holdout case(s) could not be isolated — the run endpoint scores every case)`
+        : 'gated over the FULL replay set';
     if (context.outputMode === 'human') {
-        printHuman(result, outPath);
+        process.stderr.write(`\nGating candidate for '${promptKey}' — ${scopeNote}...\n`);
     }
-    context.output.writeData(outPath ? { ...result, outPath } : result);
+    const payload = await enqueueAndPollComparison({
+        tenantId,
+        replaySetId,
+        promptArms: { prod: prodArm, proposed: proposedArm },
+        seedsPerCase,
+        assistantModel: assistantModel || undefined,
+        promotePrimary: false,
+        timeoutMs,
+        pollIntervalMs,
+        onWaiting: context.outputMode === 'human'
+            ? (status) => process.stderr.write(`Waiting for gate run (${status})...\n`)
+            : undefined,
+    }, profileOptions);
+    const outcome = candidateOutcome(payload);
+    const gate = {
+        ran: true,
+        scope: 'full-set',
+        scopeNote,
+        verdict: formatVerdict(payload),
+        outcome,
+        runId: payload.run?.runId ?? null,
+        promoted: false,
+    };
+    if (promoteOnWin) {
+        if (outcome === 'candidate' && result.versionId) {
+            await callControlAPI(`/prompts/${encodeURIComponent(promptKey)}/labels`, { method: 'POST', body: JSON.stringify({ label: 'prod', versionId: result.versionId }) }, profileOptions);
+            gate.promoted = true;
+        }
+        else {
+            gate.promoteSkippedReason =
+                outcome === 'candidate'
+                    ? 'no candidate versionId to promote'
+                    : `candidate did not strictly win (${outcome})`;
+        }
+    }
+    return gate;
 }
-function printHuman(result, outPath) {
+function printHuman(result, outPath, gate) {
     const w = (s) => process.stderr.write(s + '\n');
     if (result.status !== 'proposed') {
         w(`No candidate produced (${result.status}): ${result.note}`);
@@ -46,7 +155,33 @@ function printHuman(result, outPath) {
         w(`  risks:        ${result.risks.map((r) => `- ${r}`).join('\n                ')}`);
     if (outPath)
         w(`  written to:   ${outPath}`);
+    if (result.lowN) {
+        w('');
+        w(`  ⚠ low sample: ${result.lowN}`);
+    }
     w('');
+    if (gate?.ran) {
+        w('Gate (automatic A/B of candidate vs baseline):');
+        w(`  scope:    ${gate.scopeNote}`);
+        w(`  verdict:  ${gate.verdict}`);
+        if (gate.runId)
+            w(`  run id:   ${gate.runId}`);
+        if (gate.promoted) {
+            w(`  promoted: candidate won — promoted version ${result.versionId} to label 'prod'`);
+        }
+        else if (gate.promoteSkippedReason) {
+            w(`  promote:  skipped (${gate.promoteSkippedReason})`);
+        }
+        w('');
+        if (!gate.promoted) {
+            w(`  moda prompts promote ${result.promptKey} --label=prod --version=${result.versionId}`);
+        }
+        return;
+    }
+    if (gate && !gate.ran) {
+        w(`Gate not run: ${gate.scopeNote}`);
+        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(', ')}`);
@@ -65,6 +200,7 @@ function printHuman(result, outPath) {
         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(`  # or: moda prompts propose ... --gate --promote-on-win  (auto-A/B, promote on a strict win)`);
     w(`  moda prompts promote ${result.promptKey} --label=prod --version=${result.versionId}`);
 }
 function parsePositiveInt(raw, fallback, max) {

package/dist/schemas.d.ts

@@ -43,24 +43,24 @@ export declare const ConversationsSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     search?: string | undefined;
     environment?: "staging" | "all" | "development" | "production" | undefined;
+    outcome?: "any" | "positive" | "negative" | undefined;
     time_range?: "all" | "1h" | "3d" | "7d" | "24h" | "30d" | "90d" | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
     cluster_id?: string | undefined;
     user_id?: string | undefined;
     world_state?: string | undefined;
-    outcome?: "any" | "positive" | "negative" | undefined;
     include_world_state?: boolean | undefined;
 }, {
     search?: string | undefined;
     environment?: "staging" | "all" | "development" | "production" | undefined;
+    outcome?: "any" | "positive" | "negative" | undefined;
     time_range?: "all" | "1h" | "3d" | "7d" | "24h" | "30d" | "90d" | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
     cluster_id?: string | undefined;
     user_id?: string | undefined;
     world_state?: string | undefined;
-    outcome?: "any" | "positive" | "negative" | undefined;
     include_world_state?: unknown;
 }>;
 /** moda world-state <conversationId> — per-conversation world-state drill-in. */

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.2",
+  "version": "1.18.1",
   "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-09T02:37:26.434Z",
-  "cli_version": "1.17.2",
+  "bundled_at": "2026-07-10T23:46:28.191Z",
+  "cli_version": "1.18.1",
   "skills": [
     {
       "id": "integration-node-anthropic",