@moda-ai/cli 1.13.5 → 1.13.7

package/dist/cli.js

@@ -181,9 +181,11 @@ Commands:
   prompts sync                     Upload changed prompt versions
   prompts sync --watch             Upload again when prompt files change
   prompts promote <key>            Move a dev/staging/prod label
+  prompts ab                       Run a judged prompt A/B replay experiment
 
   Skills:
   skills gen                       Kick off tenant-wide skill generation
+  skills status [run-id]           Show a generation run's status, outcome, and recent events (default: latest run)
   skills pull                      Pull tenant-generated skills into .claude/skills (and .cursor/rules)
   skills pull --status=proposed    Include not-yet-promoted skills (default: approved)
   skills sync                      Push local .claude/skills/**/SKILL.md up to Moda
@@ -309,6 +311,7 @@ Examples:
   moda prompts status
   moda prompts sync
   moda prompts promote support.triage --label=prod --version=pver_abc123
+  moda prompts ab --baseline=prompts/agent.prompt.md --candidate=prompts/agent-v2.prompt.md --conversations=conv_1,conv_2
   moda skills pull`);
 }
 // --- Command Handlers ---
@@ -1056,7 +1059,7 @@ export const commandRegistry = createCommandRegistry([
     legacyCommand({
         name: 'prompts',
         description: 'Manage prompt versions and labels',
-        examples: ['moda prompts status', 'moda prompts sync'],
+        examples: ['moda prompts status', 'moda prompts sync', 'moda prompts ab --baseline=old.md --candidate=new.md'],
         auth: 'api-key',
         outputModes: ['human', 'json', 'agent'],
         mutability: 'write',
@@ -1121,7 +1124,7 @@ export const commandRegistry = createCommandRegistry([
     {
         name: 'skills',
         description: 'Generate, pull, and sync Moda skills',
-        examples: ['moda skills gen', 'moda skills pull', 'moda skills sync'],
+        examples: ['moda skills gen', 'moda skills status', 'moda skills pull', 'moda skills sync'],
         auth: 'none',
         outputModes: ['human', 'json', 'agent'],
         mutability: 'write',

package/dist/harness-artifact-bodies.d.ts

@@ -0,0 +1,21 @@
+import type { HarnessArtifactType, HarnessEvidence, HarnessGraph } from './harness.js';
+export interface ArtifactBodyAnnotation {
+    values: Record<string, string[]>;
+    evidence: HarnessEvidence;
+    sourceAbsPath: string;
+    rootDir: string;
+}
+export interface ArtifactBodyFileItem {
+    path: string;
+    rootDir: string;
+    text?: string;
+}
+export declare function extractToolBodyFromText(text: string, toolName: string): string | undefined;
+export declare function readPromptOrToolBody(type: HarnessArtifactType, sourcePath: string, annotation: ArtifactBodyAnnotation): string | undefined;
+export declare function extractToolBody(file: ArtifactBodyFileItem, tool: {
+    name: string;
+    reason: string;
+}): string | undefined;
+export declare function hydratePromptAndToolBodies(graph: HarnessGraph, rootDir: string): void;
+export declare function enrichScanCaptureMetadata(graph: HarnessGraph): void;
+//# sourceMappingURL=harness-artifact-bodies.d.ts.map

package/dist/harness-artifact-bodies.js

@@ -0,0 +1,201 @@
+import { existsSync, lstatSync, readFileSync, realpathSync } from 'node:fs';
+import { basename, dirname, isAbsolute, relative, resolve } from 'node:path';
+import { artifactHasBody, firstEvidencePath, requiresArtifactBody, } from './harness-report.js';
+const MAX_SCANNED_FILE_BYTES = 512 * 1024;
+const SNAPSHOT_BUDGET_SKIP_REASONS = new Set([
+    'file too large for harness scan',
+    'scan text budget exceeded',
+]);
+function first(values) {
+    return values?.[0];
+}
+function normalizePath(path) {
+    return path.replace(/\\/g, '/');
+}
+function isTextFile(path) {
+    return /\.(ts|tsx|js|jsx|mjs|cjs|py|md|json|ya?ml|toml|txt|sh|rb|go|rs|swift|kt|java|cs|php|sql|graphql|gql|proto|css|scss|less|html|vue|svelte)$/i.test(path);
+}
+function isSecretishPath(path) {
+    const normalized = normalizePath(path).toLowerCase();
+    return normalized.includes('.env') ||
+        normalized.endsWith('.pem') ||
+        normalized.endsWith('.key') ||
+        normalized.includes('/secrets/') ||
+        normalized.includes('/credentials/');
+}
+function isOutsideRoot(rel) {
+    return rel === '' || rel === '..' || rel.startsWith('../') || isAbsolute(rel);
+}
+function readBoundedRepoText(absPath, rootDir) {
+    if (!existsSync(absPath))
+        return undefined;
+    const rel = normalizePath(relative(rootDir, absPath));
+    // Containment: never read files that resolve outside the scan root. Guards against
+    // `..` traversal or absolute paths (e.g. via a crafted `path=` annotation / sourcePath /
+    // evidence path) being hydrated into synced artifact bodies.
+    if (isOutsideRoot(rel))
+        return undefined;
+    if (isSecretishPath(rel))
+        return undefined;
+    let stat;
+    try {
+        stat = lstatSync(absPath);
+    }
+    catch {
+        return undefined;
+    }
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_SCANNED_FILE_BYTES) {
+        return undefined;
+    }
+    if (!isTextFile(rel))
+        return undefined;
+    // Realpath containment: the lexical `rel` check is purely textual and `lstatSync` only
+    // inspects the final component, so an intermediate directory symlink (e.g.
+    // `tools/outside -> /tmp/public`) could still let `readFileSync` follow the link out of
+    // the repo. Canonicalize both sides and re-check before reading.
+    try {
+        if (isOutsideRoot(normalizePath(relative(realpathSync(rootDir), realpathSync(absPath))))) {
+            return undefined;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        return readFileSync(absPath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function readRepoRelativeText(rootDir, relPath) {
+    return readBoundedRepoText(resolve(rootDir, relPath), rootDir);
+}
+function isDedicatedToolFilePath(path) {
+    return /(^|\/)tools?\//i.test(path) && /\.(ts|tsx|js|mjs|py)$/i.test(path);
+}
+function firstEvidenceLineNumber(evidence) {
+    if (!Array.isArray(evidence))
+        return undefined;
+    for (const entry of evidence) {
+        if (typeof entry.line === 'number' && Number.isFinite(entry.line) && entry.line > 0) {
+            return Math.floor(entry.line);
+        }
+    }
+    return undefined;
+}
+function extractSnippetAroundLine(text, line, radius) {
+    const lines = text.split(/\r?\n/);
+    const start = Math.max(0, line - 1 - radius);
+    // `line` is 1-indexed and slice's end is exclusive, so include through
+    // (line-1)+radius: end = line + radius. Using line-1+radius dropped the tail line.
+    const end = Math.min(lines.length, line + radius);
+    return lines.slice(start, end).join('\n');
+}
+export function extractToolBodyFromText(text, toolName) {
+    const lines = text.split(/\r?\n/);
+    const normalizedName = toolName.replace(/\s+/g, '').toLowerCase();
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const compact = line.replace(/\s+/g, '').toLowerCase();
+        const mentionsTool = compact.includes(normalizedName) || compact.includes(`def${normalizedName}`);
+        if (!mentionsTool)
+            continue;
+        if (line.includes('function_tool') ||
+            line.includes('tool(') ||
+            line.includes('createTool') ||
+            line.includes('functionTool') ||
+            line.includes('dynamicTool') ||
+            line.includes('new Tool') ||
+            line.includes('def ')) {
+            return extractSnippetAroundLine(text, index + 1, 30);
+        }
+    }
+    return undefined;
+}
+function readAnnotatedSourceText(sourcePath, annotation) {
+    const explicitSourcePath = normalizePath(sourcePath) !== normalizePath(annotation.evidence.path);
+    const candidates = explicitSourcePath ? [
+        resolve(annotation.rootDir, sourcePath),
+        resolve(dirname(annotation.sourceAbsPath), sourcePath),
+    ] : [
+        resolve(annotation.rootDir, sourcePath),
+        resolve(dirname(annotation.sourceAbsPath), sourcePath),
+        annotation.sourceAbsPath,
+    ];
+    const seen = new Set();
+    for (const candidate of candidates) {
+        if (seen.has(candidate))
+            continue;
+        seen.add(candidate);
+        const text = readBoundedRepoText(candidate, annotation.rootDir);
+        if (text !== undefined)
+            return text;
+    }
+    return undefined;
+}
+export function readPromptOrToolBody(type, sourcePath, annotation) {
+    if (!requiresArtifactBody(type))
+        return undefined;
+    const text = readAnnotatedSourceText(sourcePath, annotation);
+    if (text === undefined)
+        return undefined;
+    if (type === 'prompt' || isDedicatedToolFilePath(sourcePath))
+        return text;
+    return extractToolBodyFromText(text, first(annotation.values.name) ?? basename(sourcePath)) ?? text;
+}
+export function extractToolBody(file, tool) {
+    const text = file.text ?? readRepoRelativeText(file.rootDir, file.path);
+    if (!text)
+        return undefined;
+    if (isDedicatedToolFilePath(file.path))
+        return text;
+    return extractToolBodyFromText(text, tool.name);
+}
+function hydrateArtifactBody(artifact, rootDir) {
+    if (artifact.sourcePath) {
+        const wholeFile = readRepoRelativeText(rootDir, artifact.sourcePath);
+        if (wholeFile !== undefined) {
+            if (artifact.type === 'prompt' || isDedicatedToolFilePath(artifact.sourcePath)) {
+                return wholeFile;
+            }
+            if (artifact.type === 'tool') {
+                return extractToolBodyFromText(wholeFile, artifact.name) ?? wholeFile;
+            }
+        }
+    }
+    const evidenceLine = firstEvidenceLineNumber(artifact.evidence);
+    const evidencePath = firstEvidencePath(artifact);
+    if (evidencePath && evidenceLine !== undefined) {
+        const text = readRepoRelativeText(rootDir, evidencePath);
+        if (text !== undefined) {
+            return extractSnippetAroundLine(text, evidenceLine, artifact.type === 'tool' ? 30 : 80);
+        }
+    }
+    return undefined;
+}
+export function hydratePromptAndToolBodies(graph, rootDir) {
+    for (const artifact of graph.artifacts) {
+        if (!requiresArtifactBody(artifact.type) || artifactHasBody(artifact)) {
+            continue;
+        }
+        const hydrated = hydrateArtifactBody(artifact, rootDir);
+        if (hydrated)
+            artifact.body = hydrated;
+    }
+}
+function countIncompletePromptToolBodies(graph) {
+    return graph.artifacts.filter((artifact) => requiresArtifactBody(artifact.type) &&
+        !artifactHasBody(artifact)).length;
+}
+export function enrichScanCaptureMetadata(graph) {
+    const budgetSkips = graph.scan.skipped
+        .map((skip) => skip.reason)
+        .filter((reason) => SNAPSHOT_BUDGET_SKIP_REASONS.has(reason));
+    const truncationReasons = [...new Set(budgetSkips)];
+    graph.scan.truncated = truncationReasons.length > 0;
+    graph.scan.truncationReasons = truncationReasons.length > 0 ? truncationReasons : undefined;
+    const incomplete = countIncompletePromptToolBodies(graph);
+    graph.scan.incompleteArtifactCount = incomplete > 0 ? incomplete : undefined;
+}
+//# sourceMappingURL=harness-artifact-bodies.js.map

package/dist/harness-remote.js

@@ -9,7 +9,7 @@
  */
 import { resolveApiKey, resolveIngestUrl } from './config.js';
 import { CliInputError } from './errors.js';
-import { normalizeHarnessReport, validateHarnessReport, writeHarnessReportArtifacts, } from './harness-report.js';
+import { normalizeHarnessReport, stampRemoteSnapshotTruncation, validateHarnessReport, writeHarnessReportArtifacts, } from './harness-report.js';
 import { buildSourceSnapshot, emitWrittenArtifacts, numericEnv, numericEnvAllowZero, repairExternalAnalystReport, sleep, summarizeHarness, summarizeInvalidAnalystReport, truncateText, writeHarnessAnalyzeResult, writeHarnessArtifacts, writeHumanProgress, } from './harness.js';
 const DEFAULT_REMOTE_ANALYZE_TIMEOUT_MS = 900_000;
 const DEFAULT_REMOTE_POLL_INITIAL_MS = 3_000;
@@ -75,6 +75,15 @@ export async function runRemoteHarnessAnalyst(options) {
         elapsed_ms: Date.now() - context.startedAt,
     });
     writeHumanProgress(context, `Moda Analyst (remote): uploading ${snapshot.fileCount} file(s) for server-side analysis...`);
+    if (snapshot.truncated) {
+        context.output.writeEvent({
+            event: 'warning',
+            phase: 'remote_upload',
+            message: 'Source snapshot is truncated; server-side analysis may be incomplete.',
+            elapsed_ms: Date.now() - context.startedAt,
+        });
+        writeHumanProgress(context, 'Warning: source snapshot is truncated — analysis may be incomplete.');
+    }
     const accepted = await postRemoteAnalyze(ingestUrl, apiKey, {
         snapshot,
         options: buildRemoteAnalyzeOptions(context.flags),
@@ -98,7 +107,10 @@ export async function runRemoteHarnessAnalyst(options) {
             'Increase MODA_HARNESS_REMOTE_TIMEOUT_MS if large repos need longer.',
         ].join('\n'));
     }
-    const report = repairExternalAnalystReport(normalizeHarnessReport(final.report), rootDir);
+    let report = repairExternalAnalystReport(normalizeHarnessReport(final.report), rootDir);
+    if (snapshot.truncated) {
+        report = stampRemoteSnapshotTruncation(report);
+    }
     const validation = validateHarnessReport(report, rootDir);
     context.output.writeEvent({
         event: 'progress',

package/dist/harness-report.d.ts

@@ -123,6 +123,13 @@ export declare function loadHarnessReportForSync(rootDir: string, reportPath: st
 };
 export declare function readHarnessReport(reportPath: string): HarnessReport;
 export declare function normalizeHarnessReport(value: unknown): HarnessReport;
+/** prompt/tool artifacts must carry full usable content for downstream optimization. */
+export declare function requiresArtifactBody(type: unknown): boolean;
+export declare function artifactHasBody(item: Record<string, unknown>): boolean;
+/** Canonical evidence path for graph items: prefer explicit sourcePath, then evidence. */
+export declare function firstEvidencePath(item: Record<string, unknown>): string | undefined;
+/** Stamp remote snapshot truncation onto a validated report graph scan metadata. */
+export declare function stampRemoteSnapshotTruncation(report: HarnessReport): HarnessReport;
 export declare function resolveHarnessReportPath(rootDir: string, value?: string): string;
 export declare function writeHarnessReportArtifacts(options: {
     rootDir: string;

package/dist/harness-report.js

@@ -320,6 +320,7 @@ export function validateHarnessReport(report, rootDir) {
             check(`graph_${field}_array`, Array.isArray(report.graph[field]), `Graph field ${field} must be an array.`);
         }
         validateGraphItemShapes(report.graph, errors);
+        validateCaptureQuality(report.graph, warn);
     }
     if (report?.summary && typeof report.summary === 'object') {
         for (const field of HARNESS_REPORT_SUMMARY_FIELDS) {
@@ -811,8 +812,18 @@ function validateGraphCollection(graph, errors, field, shape) {
         if (field === 'artifacts' && requiresArtifactEvidenceLine(item.type) && !artifactHasRetrievableLocation(item)) {
             errors.push(`Graph ${label} is a ${String(item.type)} artifact and must include a numeric evidence line (or a dedicated whole-file source) so its exact text can be retrieved.`);
         }
+        if (field === 'artifacts' && requiresArtifactBody(item.type) && !artifactHasBody(item)) {
+            errors.push(`Graph ${label} is a ${String(item.type)} artifact and must include a non-empty string body with its usable content.`);
+        }
     }
 }
+/** prompt/tool artifacts must carry full usable content for downstream optimization. */
+export function requiresArtifactBody(type) {
+    return type === 'prompt' || type === 'tool';
+}
+export function artifactHasBody(item) {
+    return typeof item.body === 'string' && item.body.trim().length > 0;
+}
 /** prompt/tool artifacts must pin an exact source location for downstream retrieval. */
 function requiresArtifactEvidenceLine(type) {
     return type === 'prompt' || type === 'tool';
@@ -828,6 +839,20 @@ function artifactHasRetrievableLocation(item) {
         return true;
     return isWholeFileArtifact(item);
 }
+function validateCaptureQuality(graph, warn) {
+    const scan = graph.scan;
+    if (!isRecord(scan))
+        return;
+    if (scan.truncated === true) {
+        const reasons = Array.isArray(scan.truncationReasons) && scan.truncationReasons.length > 0
+            ? scan.truncationReasons.map((reason) => String(reason)).join(', ')
+            : 'scan budget or upload cap reached';
+        warn('scan_truncated', `Harness scan is partial (truncated): ${reasons}. Re-run with --path=<agent-dir> or review skipped files in the report.`);
+    }
+    if (typeof scan.incompleteArtifactCount === 'number' && scan.incompleteArtifactCount > 0) {
+        warn('artifacts_missing_body', `${scan.incompleteArtifactCount} prompt/tool artifact(s) are still missing captured body content after hydration.`);
+    }
+}
 function isWholeFileArtifact(item) {
     if (typeof item.sourcePath !== 'string' || item.sourcePath.length === 0)
         return false;
@@ -884,7 +909,10 @@ function normalizeGraphItemFieldAliases(collection, item) {
         }
     }
 }
-function firstEvidencePath(item) {
+/** Canonical evidence path for graph items: prefer explicit sourcePath, then evidence. */
+export function firstEvidencePath(item) {
+    if (typeof item.sourcePath === 'string' && item.sourcePath.length > 0)
+        return item.sourcePath;
     if (!Array.isArray(item.evidence))
         return undefined;
     for (const evidence of item.evidence) {
@@ -894,6 +922,27 @@ function firstEvidencePath(item) {
     }
     return undefined;
 }
+/** Stamp remote snapshot truncation onto a validated report graph scan metadata. */
+export function stampRemoteSnapshotTruncation(report) {
+    const scanRecord = isRecord(report.graph.scan) ? report.graph.scan : {};
+    const truncationReasons = Array.isArray(scanRecord.truncationReasons)
+        ? scanRecord.truncationReasons.map(String)
+        : [];
+    return {
+        ...report,
+        graph: {
+            ...report.graph,
+            scan: {
+                ...report.graph.scan,
+                truncated: true,
+                truncationReasons: [
+                    ...truncationReasons,
+                    'remote source snapshot truncated before upload',
+                ],
+            },
+        },
+    };
+}
 function requiresGraphItemConfidence(collection) {
     return collection !== 'relationships' && collection !== 'unknowns';
 }

package/dist/harness-sync-limits.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Maximum serialized harness graph size accepted by the backend sync endpoint.
+ * Must match `MAX_HARNESS_SYNC_GRAPH_BYTES` in
+ * `apps/moda-backend/src/harnesses/harness-sync-limits.ts`.
+ */
+export declare const MAX_HARNESS_SYNC_GRAPH_BYTES = 2000000;
+export declare function assertHarnessGraphSyncSize(graph: unknown): void;
+//# sourceMappingURL=harness-sync-limits.d.ts.map

package/dist/harness-sync-limits.js

@@ -0,0 +1,21 @@
+import { CliInputError } from './errors.js';
+/**
+ * Maximum serialized harness graph size accepted by the backend sync endpoint.
+ * Must match `MAX_HARNESS_SYNC_GRAPH_BYTES` in
+ * `apps/moda-backend/src/harnesses/harness-sync-limits.ts`.
+ */
+export const MAX_HARNESS_SYNC_GRAPH_BYTES = 2_000_000;
+export function assertHarnessGraphSyncSize(graph) {
+    if (!graph || typeof graph !== 'object' || Array.isArray(graph)) {
+        throw new CliInputError('Harness graph must be an object before sync.');
+    }
+    const graphBytes = Buffer.byteLength(JSON.stringify(graph), 'utf8');
+    if (graphBytes > MAX_HARNESS_SYNC_GRAPH_BYTES) {
+        throw new CliInputError(`Harness graph is too large to sync (${graphBytes.toLocaleString()} bytes; limit ${MAX_HARNESS_SYNC_GRAPH_BYTES.toLocaleString()}).`, [
+            'Run `moda harness analyze --path=<agent-dir>` to narrow the harness root.',
+            'Reduce captured prompt/tool bodies if the graph grew too large.',
+            'Split multiple agent roots into separate harness syncs per tenant.',
+        ].join('\n'));
+    }
+}
+//# sourceMappingURL=harness-sync-limits.js.map

package/dist/harness.d.ts

@@ -32,6 +32,12 @@ export interface HarnessScanMetadata {
         path: string;
         reason: string;
     }>;
+    /** True when the scan dropped files due to size/budget caps or snapshot limits. */
+    truncated?: boolean;
+    /** Human-readable reasons the scan is partial (budget skips, upload cap, etc.). */
+    truncationReasons?: string[];
+    /** Prompt/tool artifacts still missing a captured body after hydration. */
+    incompleteArtifactCount?: number;
 }
 export interface HarnessScanReadPlan {
     scope: 'broad' | 'narrow';

package/dist/harness.js

@@ -10,7 +10,9 @@ import { resolveApiKey, resolveTenantId } from './config.js';
 import { CliInputError, CliInputRequiredError } from './errors.js';
 import { isRemoteHarnessAnalyze, runRemoteHarnessAnalyst } from './harness-remote.js';
 import { getActiveProfile } from './profiles.js';
+import { enrichScanCaptureMetadata, extractToolBody, hydratePromptAndToolBodies, readPromptOrToolBody, } from './harness-artifact-bodies.js';
 import { approveHarnessReport, createHarnessReport, graphForReport, hashHarnessReport, hashStableJson as hashHarnessReportStableJson, HARNESS_REPORT_PATH, loadHarnessReportForSync, normalizeHarnessReport, readHarnessReport, resolveHarnessReportPath, validateHarnessReport, writeHarnessReportArtifacts, } from './harness-report.js';
+import { assertHarnessGraphSyncSize } from './harness-sync-limits.js';
 import { renderHarnessAnalystChoice, renderHarnessAnalystLaunch, renderHarnessAnalystPreflight, renderHarnessAnalyzeHumanResult, renderHarnessProgress, } from './tui.js';
 const MODA_DIR = '.moda';
 const HARNESS_PATH = join(MODA_DIR, 'harness.json');
@@ -1607,6 +1609,8 @@ export function scanHarness(options = {}) {
     applyHeuristics(graph, files);
     linkFrameworksAndProviders(graph);
     finalizeGraph(graph);
+    hydratePromptAndToolBodies(graph, rootDir);
+    enrichScanCaptureMetadata(graph);
     return graph;
 }
 export function summarizeHarness(graph) {
@@ -1864,6 +1868,7 @@ function plannedDryRunRemote(plan) {
     };
 }
 async function syncHarnessWithRemote(context, body) {
+    assertHarnessGraphSyncSize(body.graph);
     const profileOptions = { profile: context.profile, env: context.env };
     const hasApiKey = Boolean(resolveApiKey(profileOptions));
     if (context.dryRun && !hasApiKey)
@@ -2436,6 +2441,7 @@ function artifactFromAnnotation(annotation) {
     const type = artifactType(first(values.kind) ?? first(values.type));
     const sourcePath = first(values.path) ?? annotation.evidence.path;
     const id = first(values.id) ?? stableId(type, first(values.name) ?? sourcePath);
+    const body = readPromptOrToolBody(type, sourcePath, annotation);
     return {
         id,
         type,
@@ -2443,6 +2449,7 @@ function artifactFromAnnotation(annotation) {
         scope: scopeValue(first(values.scope)),
         sourcePath,
         contentHash: contentHashForAnnotatedSource(sourcePath, annotation),
+        body,
         ownedByAgentId: first(values.owner),
         usedByAgentIds: values.agent ?? [],
         confidence: numberValue(first(values.confidence), 0.85),
@@ -2811,12 +2818,14 @@ function maybeAddToolArtifact(graph, file) {
     if (tools.length === 0)
         return;
     for (const tool of tools) {
+        const body = extractToolBody(file, tool);
         upsertArtifact(graph, {
             id: stableId('tool', `${file.path}:${tool.name}`),
             type: 'tool',
             name: titleFromId(tool.name),
             scope: 'agent',
             sourcePath: file.path,
+            body,
             usedByAgentIds: [],
             confidence: 0.6,
             evidence: [{ path: file.path, reason: `Tool definition detected (${tool.reason}).` }],
@@ -3216,6 +3225,7 @@ function finalizeGraph(graph) {
                     type: artifactTypeFromId(artifactId),
                     name: titleFromId(artifactId),
                     scope: 'agent',
+                    sourcePath: agent.evidence[0]?.path,
                     usedByAgentIds: [agent.id],
                     confidence: 0.45,
                     evidence: agent.evidence,
@@ -3375,6 +3385,8 @@ function upsertArtifact(graph, next) {
     existing.ownedByAgentId = existing.ownedByAgentId ?? next.ownedByAgentId;
     existing.contentHash = existing.contentHash ?? next.contentHash;
     existing.sourcePath = existing.sourcePath ?? next.sourcePath;
+    if (!existing.body && next.body)
+        existing.body = next.body;
     if (existing.scope !== 'shared')
         existing.scope = next.scope;
 }

package/dist/prompts-ab.d.ts

@@ -0,0 +1,18 @@
+import type { CommandContext } from './command-context.js';
+import type { ProfileIOOptions } from './profiles.js';
+export interface PromptArmPayload {
+    content: string;
+    prompt_version_id?: string;
+    prompt_id?: string;
+    prompt_label?: string;
+}
+export interface PromptAbResult {
+    replaySetId: string;
+    runId: string;
+    status: string;
+    verdict: string;
+    run: Record<string, unknown> | null;
+    cases: Array<Record<string, unknown>>;
+}
+export declare function runPromptAb(flags: Record<string, string>, profileOptions: ProfileIOOptions, context: CommandContext): Promise<void>;
+//# sourceMappingURL=prompts-ab.d.ts.map

package/dist/prompts-ab.js

@@ -0,0 +1,243 @@
+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;
+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 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);
+}
+function resolvePromptArmSpec(source, label) {
+    const trimmed = source.trim();
+    if (!trimmed) {
+        throw new Error(`Empty prompt source for ${label}`);
+    }
+    const absPath = isAbsolute(trimmed) ? trimmed : resolve(process.cwd(), trimmed);
+    let key;
+    let content;
+    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);
+        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.`;
+}
+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) {
+    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)}%`;
+}
+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.d.ts

@@ -1,5 +1,32 @@
 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;
@@ -20,4 +47,12 @@ export interface PromptSyncResult {
  * 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

package/dist/prompts.js

@@ -4,6 +4,7 @@ import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, writeFileS
 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';
 const MODA_DIR = '.moda';
 const MANIFEST_PATH = join(MODA_DIR, 'prompts.yml');
 const LOCK_PATH = join(MODA_DIR, 'prompts.lock.json');
@@ -51,8 +52,11 @@ export async function runPromptsCommand(input, legacyFlags, legacyProfileOptions
         case 'promote':
             await promotePrompt(positionals, flags, profileOptions, context);
             break;
+        case 'ab':
+            await runPromptAb(flags, profileOptions, context);
+            break;
         default:
-            throw new Error(`Unknown prompts command '${subcommand}'. Use init, status, diff, sync, or promote.`);
+            throw new Error(`Unknown prompts command '${subcommand}'. Use init, status, diff, sync, promote, or ab.`);
     }
 }
 export async function initPrompts(options = {}) {
@@ -195,7 +199,7 @@ async function getPromptStatus() {
         prompts: rows,
     };
 }
-function discoverPrompts() {
+export function discoverPrompts() {
     const manifest = readManifest();
     // A pattern like `src/prompts/**/*.prompt.md` should *only* match files under
     // src/prompts. Extract both the base directory (everything up to the first
@@ -290,6 +294,14 @@ function readManifest() {
         .filter((path) => path.includes('.prompt.'));
     return { promptPaths: promptPaths.length ? promptPaths : DEFAULT_PROMPT_PATHS };
 }
+export function readPromptLock() {
+    return readLock();
+}
+/** Parse a prompt file for A/B runs (body text + registry key). */
+export function parsePromptFileForAb(absPath) {
+    const parsed = parsePromptFile(absPath);
+    return { key: parsed.key, content: parsed.content };
+}
 function readLock() {
     if (!existsSync(LOCK_PATH))
         return null;

package/dist/skills.js

@@ -74,6 +74,108 @@ async function fetchSkills(status) {
         status,
     };
 }
+/**
+ * Authenticated GET against the ingest worker's `/v1/skills/runs` surface.
+ * Returns `{ status, body }` so callers can treat 404 (no such run) as data;
+ * every other non-2xx throws.
+ */
+async function skillRunsRequest(url) {
+    const apiKey = resolveApiKey();
+    if (!apiKey) {
+        throw new CliInputError('No Moda API key found. Run `moda init` first (or set MODA_API_KEY).');
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), SKILLS_REQUEST_TIMEOUT_MS);
+    let response;
+    try {
+        response = await fetch(url, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+            signal: controller.signal,
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Network error: failed to reach ${url} (${message})`);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    const text = await response.text().catch(() => '');
+    if (!response.ok && response.status !== 404) {
+        throw new Error(`Failed to fetch run status (HTTP ${response.status}): ${text.slice(0, 200)}`);
+    }
+    let body = {};
+    try {
+        body = text ? JSON.parse(text) : {};
+    }
+    catch {
+        body = {};
+    }
+    return { status: response.status, body };
+}
+/**
+ * Resolve a run's status + recent events. Without a run id, the tenant's
+ * latest run (`GET /v1/skills/runs?limit=1`) is used; the detail form
+ * (`GET /v1/skills/runs/:id`) always supplies the event breadcrumbs.
+ */
+async function fetchSkillRunStatus(runId) {
+    const ingestUrl = resolveIngestUrl().replace(/\/$/, '');
+    let resolvedRunId = runId;
+    if (!resolvedRunId) {
+        const list = await skillRunsRequest(`${ingestUrl}/v1/skills/runs?limit=1`);
+        const listBody = list.body;
+        const latest = Array.isArray(listBody.runs) ? listBody.runs[0] : undefined;
+        if (!latest)
+            return { run: null, events: [] };
+        resolvedRunId = latest.generation_run_id;
+        // Defensive: a row without an id can still be shown, just without events.
+        if (!resolvedRunId)
+            return { run: latest, events: [] };
+    }
+    const detail = await skillRunsRequest(`${ingestUrl}/v1/skills/runs/${encodeURIComponent(resolvedRunId)}`);
+    if (detail.status === 404) {
+        if (runId) {
+            throw new CliInputError(`No skill generation run found with id '${runId}'`);
+        }
+        return { run: null, events: [] };
+    }
+    const detailBody = detail.body;
+    return {
+        run: detailBody.run ?? null,
+        events: Array.isArray(detailBody.events) ? detailBody.events : [],
+    };
+}
+const STATUS_HUMAN_EVENT_LIMIT = 10;
+/** Human rendering for `moda skills status` (key: value lines, gen-style). */
+function formatRunStatusHuman(run, events) {
+    const counters = run.counters ?? {};
+    const lines = [
+        run.generation_run_id && `run: ${run.generation_run_id}`,
+        `status: ${run.status || 'unknown'}`,
+        run.current_stage && `stage: ${run.current_stage}`,
+        run.outcome && `outcome: ${run.outcome}`,
+        `processed: ${Number(counters.sessions_processed ?? 0)}`,
+        `failed: ${Number(counters.sessions_failed ?? 0)}`,
+        Number(counters.distilled_skills_generated ?? 0) > 0
+            && `distilled: ${Number(counters.distilled_skills_generated ?? 0)}`,
+        Number(counters.skills_indexed ?? 0) > 0
+            && `indexed: ${Number(counters.skills_indexed ?? 0)}`,
+        (run.generated_skill_ids?.length ?? 0) > 0
+            && `skills: ${(run.generated_skill_ids ?? []).join(', ')}`,
+        run.error && `error: ${run.error}`,
+        run.started_at && `started: ${run.started_at}`,
+        run.updated_at && `updated: ${run.updated_at}`,
+    ].filter(Boolean);
+    if (events.length > 0) {
+        lines.push('recent events (newest first):');
+        for (const event of events.slice(0, STATUS_HUMAN_EVENT_LIMIT)) {
+            lines.push(`  ${[event.created_at, event.level, event.stage, event.message]
+                .filter(Boolean)
+                .join('  ')}`);
+        }
+    }
+    return lines.join('\n');
+}
 /**
  * Write `content` to `filePath`, creating parent dirs. Returns whether the
  * file was created, updated (content differed), or left unchanged.
@@ -463,6 +565,8 @@ export async function runSkillsCommand(input) {
                 'accepted: true',
                 result.generation_run_id && `generation_run_id: ${result.generation_run_id}`,
                 result.message && `message: ${result.message}`,
+                result.generation_run_id
+                    && `follow progress: moda skills status ${result.generation_run_id}`,
             ].filter(Boolean).join('\n'));
         }
         else {
@@ -473,10 +577,26 @@ export async function runSkillsCommand(input) {
                 `pending_found: ${result.pending_sessions_found ?? 0}`,
                 `distilled: ${Number(result.cluster_result?.distilled_skills_generated ?? 0)}`,
                 `indexed: ${Number(result.cluster_result?.skills_indexed ?? 0)}`,
-            ].join('\n'));
+                result.distillation_skipped
+                    && `distillation skipped: ${result.distillation_skip_reason || 'unknown'}`,
+            ].filter(Boolean).join('\n'));
         }
         return Number(result.sessions_failed ?? 0) > 0 ? 1 : 0;
     }
+    if (sub === 'status') {
+        const runId = positionals[1] || flags['run-id'] || undefined;
+        const { run, events } = await fetchSkillRunStatus(runId);
+        if (context.outputMode !== 'human') {
+            context.output.writeData({ run, events }, { status: run?.status === 'failed' ? 'error' : 'success' });
+        }
+        else if (!run) {
+            console.log('No skill generation runs found yet. Start one with `moda skills gen`.');
+        }
+        else {
+            console.log(formatRunStatusHuman(run, events));
+        }
+        return run?.status === 'failed' ? 1 : 0;
+    }
     if (sub === 'proposals' && positionals[1] === 'list') {
         const proposals = await fetchSkillProposals(flags, { profile: context.profile });
         if (flags.json === 'true') {
@@ -533,7 +653,7 @@ export async function runSkillsCommand(input) {
         return 0;
     }
     if (sub !== 'pull') {
-        throw new CliInputError(sub ? `Unknown skills subcommand '${sub}'` : 'A skills subcommand is required', 'Usage: moda skills gen [--source=all|sdk|coding-agent] [--max-sessions=N] [--start-at=ISO] [--end-at=ISO] [--replay] [--replay-set-id=ID] [--reprocess-segments] [--force-reprocess] [--wait] | moda skills proposals list [--status=ready_for_pr] | moda skills proposal apply <proposal-id> | moda skills pull [--status=approved|proposed|all] | moda skills sync [--dry-run]');
+        throw new CliInputError(sub ? `Unknown skills subcommand '${sub}'` : 'A skills subcommand is required', 'Usage: moda skills gen [--source=all|sdk|coding-agent] [--max-sessions=N] [--start-at=ISO] [--end-at=ISO] [--replay] [--replay-set-id=ID] [--reprocess-segments] [--force-reprocess] [--wait] | moda skills status [run-id] | moda skills proposals list [--status=ready_for_pr] | moda skills proposal apply <proposal-id> | moda skills pull [--status=approved|proposed|all] | moda skills sync [--dry-run]');
     }
     const status = (flags.status ?? 'approved').toLowerCase();
     if (!VALID_STATUSES.has(status)) {
@@ -580,7 +700,7 @@ async function generateSkills(flags) {
         replay_set_id: flags['replay-set-id'] || flags['eval-set-id'] || undefined,
         run_clustering: flags['no-clustering'] !== 'true',
         source: normalizeSkillSource(flags.source),
-        clustering_timeout_seconds: parsePositiveInt(flags['clustering-timeout-seconds'], 0),
+        clustering_timeout_seconds: parsePositiveInt(flags['clustering-timeout-seconds'], 7200),
         clustering_poll_seconds: parsePositiveInt(flags['clustering-poll-seconds'], 15),
         max_cluster_pct: parseOptionalFloat(flags['max-cluster-pct']),
         reprocess_segments: flags['reprocess-segments'] === 'true' || forceReprocess,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moda-ai/cli",
-  "version": "1.13.5",
+  "version": "1.13.7",
   "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-06T22:15:52.641Z",
-  "cli_version": "1.13.5",
+  "bundled_at": "2026-07-08T02:33:51.881Z",
+  "cli_version": "1.13.7",
   "skills": [
     {
       "id": "integration-node-anthropic",