@moda-ai/cli 1.22.1 → 1.23.0

package/dist/prompts-ab.js

@@ -1,313 +0,0 @@
-import { existsSync } from 'node:fs';
-import { isAbsolute, resolve } from 'node:path';
-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;
-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);
-    if (!tenantId) {
-        throw new Error('Missing tenant id. Run `moda init` or pass --tenant-id=<id>.');
-    }
-    const baselineSource = flags.baseline || flags['baseline-file'] || flags['baseline-key'];
-    const candidateSource = flags.candidate || flags['candidate-file'] || flags['candidate-key'];
-    if (!baselineSource || !candidateSource) {
-        throw new Error('Usage: moda prompts ab --baseline=<file|key> --candidate=<file|key> [--auto-generate|--set-id=ID|--conversations=id1,id2]');
-    }
-    if (flags.sync === 'true') {
-        await runPromptSync({ ...flags, watch: 'false' }, profileOptions);
-    }
-    const promptArms = {
-        prod: resolvePromptArmSpec(baselineSource, 'baseline'),
-        proposed: resolvePromptArmSpec(candidateSource, 'candidate'),
-    };
-    const replaySetId = await ensureReplaySet(flags, tenantId, profileOptions);
-    const seedsPerCase = parsePositiveInt(flags.seeds ?? flags['seeds-per-case'], DEFAULT_SEEDS_PER_CASE, 10);
-    const assistantModel = (flags.model ?? flags['assistant-model'] ?? '').trim();
-    const enqueue = await callControlAPI(`/tenants/${encodeURIComponent(tenantId)}/replay-sets/${encodeURIComponent(replaySetId)}/run`, {
-        method: 'POST',
-        body: JSON.stringify({
-            promptArms,
-            seedsPerCase,
-            assistantModel: assistantModel || undefined,
-            promotePrimary: flags['no-promote'] !== 'true',
-        }),
-    }, profileOptions, { timeoutMs: 120_000, retries: 1 });
-    const noWait = flags.wait === 'false' || flags['no-wait'] === 'true';
-    if (noWait) {
-        context.output.writeData({
-            replaySetId,
-            runId: enqueue.runId,
-            status: enqueue.status,
-            message: enqueue.message ?? 'Replay comparison queued',
-        });
-        return;
-    }
-    const timeoutMs = parsePositiveInt(flags.timeout, DEFAULT_WAIT_TIMEOUT_MS, 24 * 60 * 60 * 1000);
-    const pollIntervalMs = parsePositiveInt(flags['poll-interval'], DEFAULT_POLL_INTERVAL_MS, 120_000);
-    const deadline = Date.now() + timeoutMs;
-    let latest = null;
-    while (Date.now() < deadline) {
-        latest = await fetchLatestRun(tenantId, replaySetId, enqueue.runId, profileOptions);
-        const status = latest.run?.status ?? '';
-        const runId = latest.run?.runId ?? '';
-        if (TERMINAL_RUN_STATUSES.has(status) && runId === enqueue.runId) {
-            break;
-        }
-        if (context.outputMode === 'human') {
-            process.stderr.write(`Waiting for replay run (${status || 'pending'})...\n`);
-        }
-        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`);
-    }
-    const result = {
-        replaySetId,
-        runId: latest.run.runId,
-        status: latest.run.status,
-        verdict: formatVerdict(latest),
-        run: { ...latest.run },
-        cases: latest.cases.map((row) => ({ ...row })),
-    };
-    if (context.outputMode === 'human') {
-        printHumanVerdict(result);
-    }
-    context.output.writeData(result);
-}
-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;
-    // 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 match = fromDiscovery();
-        if (!match) {
-            throw new Error(`Could not resolve prompt '${trimmed}' — pass a .prompt.md path or a discovered prompt key`);
-        }
-        key = match.key;
-        content = match.content;
-    }
-    const locked = readPromptLock()?.prompts[key];
-    return {
-        content,
-        prompt_version_id: locked?.versionId ?? '',
-        prompt_id: locked?.promptId ?? '',
-        prompt_label: label,
-    };
-}
-async function ensureReplaySet(flags, tenantId, profileOptions) {
-    const existingSetId = (flags['set-id'] || flags['replay-set-id'] || '').trim();
-    if (existingSetId) {
-        return existingSetId;
-    }
-    const conversations = parseCsv(flags.conversations ?? flags['conversation-ids']);
-    if (conversations.length) {
-        return createSetFromConversations(conversations, flags, tenantId, profileOptions);
-    }
-    if (flags['auto-generate'] === 'false' && !existingSetId) {
-        throw new Error('Provide --set-id=, --conversations=, or allow --auto-generate (default)');
-    }
-    const caseCount = parsePositiveInt(flags.cases ?? flags['case-count'], 5, 25);
-    const lookbackDays = parsePositiveInt(flags['lookback-days'], 30, 365);
-    const name = (flags.name ?? flags['set-name'] ?? `Prompt A/B ${new Date().toISOString().slice(0, 10)}`).trim();
-    const generated = await callControlAPI(`/tenants/${encodeURIComponent(tenantId)}/replay-sets/auto-generate`, {
-        method: 'POST',
-        body: JSON.stringify({ name, caseCount, lookbackDays }),
-    }, profileOptions, { timeoutMs: 300_000, retries: 0 });
-    if (!generated?.id) {
-        throw new Error('Auto-generate did not return a replay set id');
-    }
-    return generated.id;
-}
-async function createSetFromConversations(conversationIds, flags, tenantId, profileOptions) {
-    const name = (flags.name ?? flags['set-name'] ?? `Prompt A/B ${conversationIds.length} conv`).trim();
-    const created = await callControlAPI(`/tenants/${encodeURIComponent(tenantId)}/replay-sets`, {
-        method: 'POST',
-        body: JSON.stringify({ name, description: 'Created by moda prompts ab' }),
-    }, profileOptions);
-    let position = 0;
-    for (const conversationId of conversationIds) {
-        const scenario = await loadScenarioFromConversation(conversationId);
-        await callControlAPI(`/tenants/${encodeURIComponent(tenantId)}/replay-sets/${encodeURIComponent(created.id)}/cases`, {
-            method: 'POST',
-            body: JSON.stringify({
-                title: conversationId,
-                scenario,
-                sourceConversationId: conversationId,
-                successCriteria: [
-                    'The agent understands the user request',
-                    'The agent uses tools appropriately when needed',
-                    'The agent provides a helpful final answer',
-                ],
-                position: position++,
-            }),
-        }, profileOptions);
-    }
-    return created.id;
-}
-async function loadScenarioFromConversation(conversationId) {
-    try {
-        const data = await callDataAPI(`/conversations/${encodeURIComponent(conversationId)}/context?msg_index=0&window=0`);
-        const firstUser = (data.messages ?? []).find((message) => message.role === 'user' && String(message.content ?? '').trim());
-        const opening = String(firstUser?.content ?? '').trim();
-        if (opening) {
-            return `The user says: "${opening}"\n\nReplay the conversation faithfully and help them accomplish their goal.`;
-        }
-    }
-    catch {
-        // Fall through to generic scenario.
-    }
-    return `Replay conversation ${conversationId}: help the user accomplish their original goal using the available tools.`;
-}
-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 });
-}
-/**
- * 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';
-    if (run.status === 'skipped')
-        return `skipped: ${run.notes || 'no reason'}`;
-    if (run.status === 'error')
-        return `error: ${run.notes || 'unknown error'}`;
-    if (run.status !== 'completed')
-        return `status=${run.status}`;
-    const delta = run.proposedPassCount - run.prodPassCount;
-    const winner = delta > 0 ? 'candidate wins' : delta < 0 ? 'baseline wins' : 'tie on case passes';
-    const rates = `baseline ${run.prodPassCount}/${run.caseCount} (${pct(run.prodPassRate)}), candidate ${run.proposedPassCount}/${run.caseCount} (${pct(run.proposedPassRate)})`;
-    const notes = run.notes?.trim();
-    return `${winner}; ${rates}${notes ? `; ${notes}` : ''}`;
-}
-function printHumanVerdict(result) {
-    process.stderr.write('\nPrompt A/B replay verdict\n');
-    process.stderr.write('-------------------------\n');
-    process.stderr.write(`Replay set: ${result.replaySetId}\n`);
-    process.stderr.write(`Run id:     ${result.runId}\n`);
-    process.stderr.write(`Status:     ${result.status}\n`);
-    process.stderr.write(`Verdict:    ${result.verdict}\n`);
-    if (result.cases.length) {
-        process.stderr.write('\nPer-case:\n');
-        for (const row of result.cases) {
-            const caseId = String(row.caseId ?? '');
-            const prod = formatPass(row.prodPass);
-            const proposed = formatPass(row.proposedPass);
-            process.stderr.write(`  ${caseId}: baseline=${prod} candidate=${proposed}\n`);
-        }
-    }
-    process.stderr.write('\n');
-}
-function formatPass(value) {
-    if (value === null || value === undefined)
-        return 'abstained';
-    return value ? 'pass' : 'fail';
-}
-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;
-    const parsed = Number.parseInt(raw, 10);
-    if (!Number.isFinite(parsed) || parsed < 1)
-        return fallback;
-    return Math.min(parsed, max);
-}
-function parseCsv(raw) {
-    if (!raw?.trim())
-        return [];
-    return raw.split(',').map((part) => part.trim()).filter(Boolean);
-}
-function sleep(ms) {
-    return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
-}
-//# sourceMappingURL=prompts-ab.js.map

package/dist/prompts-propose.d.ts

@@ -1,15 +0,0 @@
-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 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

package/dist/prompts-propose.js

@@ -1,212 +0,0 @@
-import { writeFileSync } from 'node:fs';
-import { isAbsolute, resolve } from 'node:path';
-import { callControlAPI } from './api-client.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 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();
-    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] [--model=<slug>] [--out=path.prompt.md] [--gate] [--promote-on-win]');
-    }
-    const maxDossiers = parsePositiveInt(flags['max-dossiers'], 8, 16);
-    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') {
-        process.stderr.write(`\nGating candidate for '${promptKey}' — ${scopeNote}...\n`);
-    }
-    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, gate) {
-    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}`);
-    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(', ')}`);
-    }
-    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(`  # 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) {
-    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.d.ts

@@ -1,58 +0,0 @@
-import { type CommandContext } from './command-context.js';
-import type { ProfileIOOptions } from './profiles.js';
-interface PromptFile {
-    key: string;
-    name: string;
-    description?: string;
-    category?: string;
-    sourcePath: string;
-    content: string;
-    systemPrompt?: string;
-    messages?: unknown[];
-    variables?: unknown[];
-    variablesSchema?: Record<string, unknown>;
-    modelConfig?: Record<string, unknown>;
-    toolRefs?: unknown[];
-    responseSchema?: Record<string, unknown>;
-    contentHash: string;
-}
-interface PromptLock {
-    version: 1;
-    generatedAt: string;
-    prompts: Record<string, {
-        key: string;
-        sourcePath: string;
-        contentHash: string;
-        versionId?: string;
-        promptId?: string;
-    }>;
-}
-export declare function runPromptsCommand(input: CommandContext | string[], legacyFlags?: Record<string, string>, legacyProfileOptions?: ProfileIOOptions): Promise<void>;
-export declare function initPrompts(options?: {
-    silent?: boolean;
-}): Promise<void>;
-export interface PromptSyncResult {
-    synced: Array<{
-        key: string;
-        promptId?: string;
-        versionId?: string;
-        contentHash: string;
-        sourcePath?: string;
-    }>;
-    dryRun: boolean;
-}
-/**
- * Sync the manifest's prompt files to the backend and update the lockfile.
- * Returns the synced list without printing, so callers (e.g. `moda init`)
- * control their own output. `moda prompts sync` wraps this with JSON output.
- */
-export declare function runPromptSync(flags: Record<string, string>, profileOptions: ProfileIOOptions): Promise<PromptSyncResult>;
-export declare function discoverPrompts(): PromptFile[];
-export declare function readPromptLock(): PromptLock | null;
-/** Parse a prompt file for A/B runs (body text + registry key). */
-export declare function parsePromptFileForAb(absPath: string): {
-    key: string;
-    content: string;
-};
-export {};
-//# sourceMappingURL=prompts.d.ts.map