@moda-ai/cli 1.1.1 → 1.3.0

package/dist/production-intelligence.js

@@ -0,0 +1,1113 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { callControlAPI, callDataAPI } from './api-client.js';
+import { CliInputError } from './errors.js';
+import { asNumber, asRecord, asString } from './transforms.js';
+const INVESTIGATION_SCHEMA_VERSION = 'production_investigation.v0.1';
+const OVERVIEW_SCHEMA_VERSION = 'production_overview.v0.1';
+const ASK_SCHEMA_VERSION = 'production_ask.v0.1';
+export async function runProductionCommand(context) {
+    const daysBack = numberFlag(context.flags, 'days-back', 7);
+    if (context.command === 'overview') {
+        const briefing = await loadOverviewBriefing({ daysBack, cwd: context.cwd });
+        if (context.flags.raw === 'true') {
+            context.output.writeData(briefing.rawOverview, {
+                summary: 'Loaded raw Moda overview.',
+                nextCommands: ['moda overview', `moda investigate --days-back=${daysBack}`],
+            });
+        }
+        else if (context.outputMode === 'human') {
+            if (!context.quiet)
+                console.log(renderOverviewBriefingHuman(briefing));
+        }
+        else {
+            context.output.writeData(briefing, overviewAgentOptions(briefing));
+        }
+        return { exitCode: 0 };
+    }
+    if (context.command === 'ask') {
+        const question = context.positionals.join(' ').trim();
+        if (!question) {
+            throw new CliInputError('<question> is required', 'Usage: moda ask "what should I fix first?" [--days-back=N]');
+        }
+        const result = await askModa({ question, daysBack, cwd: context.cwd, profile: context.profile });
+        if (context.outputMode === 'human') {
+            if (!context.quiet)
+                console.log(renderAskHuman(result));
+        }
+        else {
+            context.output.writeData(result, askAgentOptions(result));
+        }
+        return { exitCode: 0 };
+    }
+    if (context.command === 'why-failed') {
+        const runId = context.positional;
+        if (!runId) {
+            throw new CliInputError('<run_id> is required', 'Usage: moda why-failed <run_id>');
+        }
+        const investigation = await investigateProduction({ daysBack, cwd: context.cwd, runId });
+        writeInvestigation(context, investigation);
+        return { exitCode: 0 };
+    }
+    if (context.command === 'failures') {
+        const investigation = await investigateProduction({
+            daysBack,
+            cwd: context.cwd,
+            failureOnly: true,
+            toolName: context.flags.tool,
+        });
+        writeInvestigation(context, investigation);
+        return { exitCode: 0 };
+    }
+    if (context.command === 'investigate') {
+        const investigation = await investigateProduction({
+            daysBack,
+            cwd: context.cwd,
+            runId: context.flags.run,
+            conversationId: context.flags.conversation,
+            toolName: context.flags.tool,
+            loopId: context.flags.loop,
+        });
+        writeInvestigation(context, investigation);
+        return { exitCode: 0 };
+    }
+    throw new CliInputError(`Unknown production command '${context.command}'`);
+}
+export async function loadOverviewBriefing(options) {
+    const endpoint = `/overview?days_back=${options.daysBack}`;
+    const overview = await callDataAPI(endpoint);
+    const hints = loadHarnessHints(options.cwd);
+    const evidenceRefs = [
+        {
+            id: 'overview:data',
+            kind: 'data_api',
+            label: `Overview for last ${options.daysBack} day(s)`,
+            endpoint,
+            value: overviewMetrics(overview),
+        },
+    ];
+    const findings = findingsFromOverview(overview, options.daysBack, hints, evidenceRefs);
+    const topFinding = findings[0] ?? null;
+    const conversations = numberAt(overview, ['conversations', 'total']);
+    const recent = recentActivity(overview)[0];
+    const dataFlowStatus = conversations > 0 || recent ? 'flowing' : 'quiet';
+    const nextCommand = topFinding
+        ? `moda investigate --days-back=${options.daysBack}`
+        : 'moda doctor --online';
+    return {
+        schemaVersion: OVERVIEW_SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        daysBack: options.daysBack,
+        status: topFinding
+            ? 'attention'
+            : dataFlowStatus === 'flowing'
+                ? 'healthy'
+                : 'quiet',
+        dataFlow: {
+            status: dataFlowStatus,
+            conversations,
+            ...(recent ? { lastEvent: recent } : {}),
+        },
+        harnessSync: localSyncBrief(options.cwd, '.moda/sync-state.json', 'Harness graph'),
+        promptSync: localSyncBrief(options.cwd, '.moda/prompts.lock.json', 'Prompt versions'),
+        skillSync: localSkillBrief(options.cwd),
+        metrics: overviewMetrics(overview),
+        topFinding,
+        evidenceRefs,
+        nextCommand,
+        rawOverview: overview,
+    };
+}
+export async function investigateProduction(options) {
+    const warnings = [];
+    const sourceStatus = {};
+    const hints = loadHarnessHints(options.cwd);
+    const overviewEndpoint = `/overview?days_back=${options.daysBack}`;
+    const toolEndpoint = options.toolName
+        ? `/tool-failures/${encodeURIComponent(options.toolName)}?days_back=${options.daysBack}&limit=5`
+        : `/tool-failures?days_back=${options.daysBack}`;
+    const frustrationsEndpoint = `/frustrations?days_back=${options.daysBack}&limit=5`;
+    const runsEndpoint = options.runId
+        ? `/runs/${encodeURIComponent(options.runId)}`
+        : `/runs?time_range=${timeRangeForDays(options.daysBack)}&limit=20`;
+    const loopsEndpoint = options.loopId
+        ? `/loops/${encodeURIComponent(options.loopId)}`
+        : '/loops/active?limit=20';
+    const [overview, tools, frustrations, runs, loops] = await Promise.all([
+        safeData(overviewEndpoint),
+        safeData(toolEndpoint),
+        safeData(frustrationsEndpoint),
+        safeData(runsEndpoint),
+        safeData(loopsEndpoint),
+    ]);
+    for (const [key, result] of Object.entries({ overview, tools, frustrations, runs, loops })) {
+        sourceStatus[key] = result.status;
+        if (result.warning)
+            warnings.push(result.warning);
+    }
+    const evidenceRefs = [];
+    const findings = [];
+    addOverviewEvidence(overview.data, overviewEndpoint, evidenceRefs);
+    findings.push(...toolFailureFindings(tools.data, options.daysBack, hints, evidenceRefs, options.toolName));
+    if (!options.failureOnly) {
+        findings.push(...frustrationFindings(frustrations.data, options.daysBack, evidenceRefs));
+        findings.push(...runFindings(runs.data, evidenceRefs, options.runId));
+        findings.push(...loopFindings(loops.data, evidenceRefs, options.loopId));
+    }
+    else {
+        findings.push(...runFindings(runs.data, evidenceRefs, options.runId).filter((finding) => finding.kind === 'partial_run'));
+        findings.push(...loopFindings(loops.data, evidenceRefs, options.loopId));
+    }
+    if (findings.length === 0) {
+        findings.push(insufficientDataFinding(overview.data, evidenceRefs));
+    }
+    findings.sort(compareFindings);
+    const boundedFindings = findings.slice(0, 8);
+    const nextCommands = nextCommandsForFindings(boundedFindings, options.daysBack);
+    return {
+        schemaVersion: INVESTIGATION_SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        daysBack: options.daysBack,
+        scope: {
+            ...(options.runId ? { runId: options.runId } : {}),
+            ...(options.conversationId ? { conversationId: options.conversationId } : {}),
+            ...(options.toolName ? { toolName: options.toolName } : {}),
+            ...(options.loopId ? { loopId: options.loopId } : {}),
+            ...(options.question ? { question: options.question } : {}),
+        },
+        summary: summarizeInvestigation(boundedFindings),
+        findings: boundedFindings,
+        evidenceRefs: uniqueEvidenceRefs(evidenceRefs),
+        nextCommands,
+        warnings,
+        sourceStatus,
+    };
+}
+export async function askModa(options) {
+    try {
+        const response = await callControlAPI('/cli/ask', {
+            method: 'POST',
+            body: JSON.stringify({
+                question: options.question,
+                daysBack: options.daysBack,
+                profile: options.profile,
+                harness: localHarnessSummary(options.cwd),
+            }),
+        });
+        const cloud = normalizeCloudAsk(response, options.question);
+        if (cloud)
+            return cloud;
+    }
+    catch {
+        // The endpoint is intentionally future-facing. Until cloud intelligence is
+        // deployed everywhere, the CLI keeps answering from bounded Data API evidence.
+    }
+    const investigation = await investigateProduction({
+        daysBack: options.daysBack,
+        cwd: options.cwd,
+        question: options.question,
+    });
+    const top = investigation.findings[0];
+    const answer = top
+        ? `Moda Cloud intelligence is not available yet, so I synthesized this from production evidence. The strongest signal is: ${top.title}. ${top.summary}`
+        : 'Moda Cloud intelligence is not available yet, and the local Data API evidence did not contain a strong production signal.';
+    return {
+        schemaVersion: ASK_SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        source: 'local_fallback',
+        question: options.question,
+        answer,
+        confidence: capFallbackConfidence(investigation.summary.confidence),
+        evidenceRefs: investigation.evidenceRefs.slice(0, 12),
+        findings: investigation.findings.slice(0, 5),
+        nextCommands: investigation.nextCommands,
+        warnings: [
+            'Cloud ask endpoint unavailable; synthesized answer from local Data API evidence.',
+            ...investigation.warnings,
+        ],
+    };
+}
+function writeInvestigation(context, investigation) {
+    if (context.outputMode === 'human') {
+        if (!context.quiet)
+            console.log(renderInvestigationHuman(investigation));
+        return;
+    }
+    context.output.writeData(investigation, investigationAgentOptions(investigation));
+}
+async function safeData(endpoint) {
+    try {
+        return { data: await callDataAPI(endpoint), status: 'ok' };
+    }
+    catch (error) {
+        return {
+            data: null,
+            status: 'unavailable',
+            warning: `Could not load ${endpoint}: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+function findingsFromOverview(overview, daysBack, hints, evidenceRefs) {
+    const findings = [];
+    const toolFailureTotal = numberAt(overview, ['tool_failures', 'total']);
+    if (toolFailureTotal > 0) {
+        const conversations = numberAt(overview, ['tool_failures', 'conversations']);
+        const evidenceId = 'overview:tool_failures';
+        evidenceRefs.push({
+            id: evidenceId,
+            kind: 'data_api',
+            label: `${toolFailureTotal} tool failure(s) across ${conversations} conversation(s)`,
+            endpoint: `/overview?days_back=${daysBack}`,
+            value: valueAt(overview, ['tool_failures']),
+        });
+        findings.push({
+            id: 'finding_overview_tool_failures',
+            kind: 'tool_failure',
+            title: `${toolFailureTotal} tool failure(s) need investigation`,
+            severity: severityForCount(toolFailureTotal, 10, 3),
+            confidence: 'medium',
+            impactScore: 80 + Math.min(toolFailureTotal, 20),
+            rankReason: 'Tool failures directly block agent tasks and have explicit production evidence.',
+            summary: `Moda saw ${toolFailureTotal} failed tool call(s) in the last ${daysBack} day(s).`,
+            evidenceRefIds: [evidenceId],
+            likelyLocations: defaultLikelyLocations(hints, 'tool'),
+            recommendedActions: [{
+                    id: 'action_investigate_tools',
+                    title: 'Open the ranked production investigation.',
+                    rationale: 'The overview only has aggregate counts; investigation pulls examples and likely file paths.',
+                    command: `moda investigate --days-back=${daysBack}`,
+                    mutability: 'read',
+                    requiresApproval: false,
+                }],
+        });
+    }
+    const frustrationRate = numberAt(overview, ['frustrations', 'rate_pct']);
+    const frustrated = numberAt(overview, ['frustrations', 'frustrated']);
+    if (frustrated > 0 || frustrationRate >= 10) {
+        const evidenceId = 'overview:frustrations';
+        evidenceRefs.push({
+            id: evidenceId,
+            kind: 'data_api',
+            label: `${frustrationRate}% frustration rate`,
+            endpoint: `/overview?days_back=${daysBack}`,
+            value: valueAt(overview, ['frustrations']),
+        });
+        findings.push({
+            id: 'finding_overview_frustration',
+            kind: 'frustration',
+            title: `${frustrationRate}% user frustration rate`,
+            severity: frustrationRate >= 25 ? 'high' : 'medium',
+            confidence: 'medium',
+            impactScore: 65 + Math.min(frustrationRate, 30),
+            rankReason: 'Frustration indicates users are getting stuck even when runs may not hard-fail.',
+            summary: `Moda classified ${frustrated} frustrated conversation(s) in the last ${daysBack} day(s).`,
+            evidenceRefIds: [evidenceId],
+            likelyLocations: defaultLikelyLocations(hints, 'prompt'),
+            recommendedActions: [{
+                    id: 'action_investigate_frustration',
+                    title: 'Inspect frustration anchors.',
+                    rationale: 'Frustration anchors show the user turn where the experience degraded.',
+                    command: `moda frustrations --days-back=${daysBack} --include-window`,
+                    mutability: 'read',
+                    requiresApproval: false,
+                }],
+        });
+    }
+    return findings.sort(compareFindings);
+}
+function toolFailureFindings(data, daysBack, hints, evidenceRefs, scopedTool) {
+    const tools = toolRows(data, scopedTool);
+    return tools.flatMap((tool) => {
+        const name = tool.name;
+        if (!name)
+            return [];
+        const count = tool.count;
+        if (count <= 0)
+            return [];
+        const evidenceId = `tool:${name}`;
+        const subtype = tool.subtype ? ` (${tool.subtype})` : '';
+        evidenceRefs.push({
+            id: evidenceId,
+            kind: 'tool_failure',
+            label: `${name}: ${count} failure(s)${subtype}`,
+            endpoint: scopedTool
+                ? `/tool-failures/${encodeURIComponent(name)}?days_back=${daysBack}`
+                : `/tool-failures?days_back=${daysBack}`,
+            toolName: name,
+            value: tool.raw,
+        });
+        const location = likelyToolLocation(name, hints);
+        if (location?.path) {
+            evidenceRefs.push({
+                id: `harness:tool:${name}`,
+                kind: 'harness',
+                label: `Likely tool definition for ${name}`,
+                path: location.path,
+                toolName: name,
+            });
+        }
+        const conversations = tool.conversations > 0 ? tool.conversations : count;
+        return [{
+                id: `finding_tool_failure_${slug(name)}`,
+                kind: 'tool_failure',
+                title: `${name} is failing in production`,
+                severity: severityForCount(count, 10, 3),
+                confidence: 'high',
+                impactScore: 90 + Math.min(count, 25),
+                rankReason: `${count} failed call(s) across ${conversations} conversation(s), with direct tool failure evidence.`,
+                summary: `${name} produced ${count} failed call(s) in the last ${daysBack} day(s).${tool.subtype ? ` The dominant subtype is ${tool.subtype}.` : ''}`,
+                evidenceRefIds: location?.path ? [evidenceId, `harness:tool:${name}`] : [evidenceId],
+                likelyLocations: [location ?? unknownLocation('tool', `No local definition matched ${name}.`)],
+                recommendedActions: [{
+                        id: `action_tool_detail_${slug(name)}`,
+                        title: `Inspect ${name} failure examples.`,
+                        rationale: 'Examples include conversation anchors and error subtypes.',
+                        command: `moda tool-failure-detail ${name} --include-window`,
+                        mutability: 'read',
+                        requiresApproval: false,
+                    }],
+            }];
+    });
+}
+function frustrationFindings(data, daysBack, evidenceRefs) {
+    const summary = asRecord(valueAt(data, ['summary']));
+    const frustrations = Array.isArray(valueAt(data, ['frustrations']))
+        ? valueAt(data, ['frustrations'])
+        : [];
+    const count = numberValue(summary?.frustrated_count) || frustrations.length;
+    const atRisk = numberValue(summary?.at_risk_count);
+    if (count <= 0 && atRisk <= 0 && frustrations.length === 0)
+        return [];
+    const first = asRecord(frustrations[0]);
+    const conversationId = asString(first?.conversation_id);
+    const quote = firstQuote(first);
+    const evidenceId = conversationId ? `frustration:${conversationId}` : 'frustration:summary';
+    evidenceRefs.push({
+        id: evidenceId,
+        kind: 'frustration',
+        label: quote ? `Frustration anchor: "${quote}"` : `${count} frustrated conversation(s)`,
+        endpoint: `/frustrations?days_back=${daysBack}&limit=5`,
+        ...(conversationId ? { conversationId } : {}),
+        value: first ?? summary ?? data,
+    });
+    return [{
+            id: 'finding_frustration_rate',
+            kind: 'frustration',
+            title: count > 0 ? `${count} frustrated conversation(s)` : `${atRisk} at-risk conversation(s)`,
+            severity: count >= 10 ? 'high' : 'medium',
+            confidence: first ? 'high' : 'medium',
+            impactScore: 70 + Math.min(count * 3 + atRisk, 25),
+            rankReason: 'User frustration is a product-quality signal even when the agent technically completes.',
+            summary: first?.primary_cause
+                ? `Primary cause: ${String(first.primary_cause)}.`
+                : `Moda found frustration or risk in the last ${daysBack} day(s).`,
+            evidenceRefIds: [evidenceId],
+            likelyLocations: [unknownLocation('prompt', 'Prompt or policy issue likely; inspect the conversation window.')],
+            recommendedActions: [{
+                    id: 'action_frustration_window',
+                    title: 'Read the frustration window.',
+                    rationale: 'The user quote and nearby turns reveal what confused or blocked the user.',
+                    command: conversationId
+                        ? `moda context ${conversationId} --window=3`
+                        : `moda frustrations --days-back=${daysBack} --include-window`,
+                    mutability: 'read',
+                    requiresApproval: false,
+                }],
+        }];
+}
+function runFindings(data, evidenceRefs, scopedRunId) {
+    const rows = runRows(data);
+    return rows.flatMap((run) => {
+        const runId = run.id || scopedRunId;
+        const outcome = run.outcome;
+        if (!runId || !['failed', 'partial', 'abandoned', 'loop'].includes(outcome))
+            return [];
+        const evidenceId = `run:${runId}`;
+        evidenceRefs.push({
+            id: evidenceId,
+            kind: 'run',
+            label: `${run.agentName || 'Agent run'} ${outcome}`,
+            endpoint: `/runs/${runId}`,
+            runId,
+            conversationId: run.conversationId,
+            value: run.raw,
+        });
+        return [{
+                id: `finding_run_${slug(runId)}`,
+                kind: outcome === 'partial' ? 'partial_run' : 'tool_failure',
+                title: `${run.agentName || 'Agent run'} ended as ${outcome}`,
+                severity: outcome === 'failed' ? 'high' : 'medium',
+                confidence: 'high',
+                impactScore: outcome === 'failed' ? 88 : 76,
+                rankReason: `Run outcome is ${outcome}${run.reason ? `: ${run.reason}` : ''}.`,
+                summary: run.reason || 'Moda classified this run as incomplete or unhealthy.',
+                evidenceRefIds: [evidenceId],
+                likelyLocations: [unknownLocation('entrypoint', 'Map this run to a harness entrypoint after harness sync.')],
+                recommendedActions: [{
+                        id: `action_run_${slug(runId)}`,
+                        title: 'Open the run detail.',
+                        rationale: 'Run detail includes receipts and missing effects.',
+                        command: `moda run ${runId}`,
+                        mutability: 'read',
+                        requiresApproval: false,
+                    }],
+            }];
+    });
+}
+function loopFindings(data, evidenceRefs, scopedLoopId) {
+    const rows = loopRows(data);
+    return rows.flatMap((loop) => {
+        const id = loop.id || scopedLoopId;
+        if (!id)
+            return [];
+        const evidenceId = `loop:${id}`;
+        evidenceRefs.push({
+            id: evidenceId,
+            kind: 'loop',
+            label: loop.signature || `${loop.type || 'Loop'} detected`,
+            endpoint: `/loops/${id}`,
+            detectionId: id,
+            conversationId: loop.conversationId,
+            value: loop.raw,
+        });
+        return [{
+                id: `finding_loop_${slug(id)}`,
+                kind: 'loop',
+                title: loop.signature || `${loop.type || 'Loop'} detected`,
+                severity: loop.blastRadius >= 5 ? 'high' : 'medium',
+                confidence: 'high',
+                impactScore: 84 + Math.min(loop.blastRadius, 10),
+                rankReason: `Active loop detection${loop.blastRadius ? ` with blast radius ${loop.blastRadius}` : ''}.`,
+                summary: loop.rootCause || 'The agent appears to repeat work or retry a failing path.',
+                evidenceRefIds: [evidenceId],
+                likelyLocations: [unknownLocation('prompt', 'Loops often come from retry policy, stop conditions, or tool handling.')],
+                recommendedActions: [{
+                        id: `action_loop_${slug(id)}`,
+                        title: 'Inspect loop detail.',
+                        rationale: 'Loop detail includes signature, cycle length, and root-cause hypothesis.',
+                        command: `moda loop ${id}`,
+                        mutability: 'read',
+                        requiresApproval: false,
+                    }],
+            }];
+    });
+}
+function insufficientDataFinding(overview, evidenceRefs) {
+    const evidenceId = 'overview:data';
+    if (!evidenceRefs.some((ref) => ref.id === evidenceId)) {
+        evidenceRefs.push({
+            id: evidenceId,
+            kind: 'data_api',
+            label: 'Overview did not contain actionable production signals',
+            endpoint: '/overview',
+            value: overview,
+        });
+    }
+    return {
+        id: 'finding_insufficient_data',
+        kind: 'insufficient_data',
+        title: 'No strong production issue found yet',
+        severity: 'info',
+        confidence: 'medium',
+        impactScore: 10,
+        rankReason: 'Moda needs more recent production traces before ranking failures.',
+        summary: 'Data flow may be quiet or current signals are below the investigation threshold.',
+        evidenceRefIds: [evidenceId],
+        likelyLocations: [],
+        recommendedActions: [{
+                id: 'action_doctor_online',
+                title: 'Validate data flow.',
+                rationale: 'A quiet overview can mean no traffic or broken ingestion.',
+                command: 'moda doctor --online',
+                mutability: 'read',
+                requiresApproval: false,
+            }],
+    };
+}
+function normalizeCloudAsk(response, question) {
+    const record = asRecord(response);
+    const answer = asString(record?.answer);
+    if (!answer)
+        return null;
+    const evidenceRefs = Array.isArray(record?.evidence_refs)
+        ? record.evidence_refs.flatMap((item) => {
+            const ref = asRecord(item);
+            if (!ref)
+                return [];
+            return [{
+                    id: asString(ref.id) ?? `ask:evidence:${slug(asString(ref.label) ?? 'ref')}`,
+                    kind: evidenceKind(asString(ref.kind)),
+                    label: asString(ref.label) ?? asString(ref.id) ?? 'Cloud evidence',
+                    path: asString(ref.path) ?? undefined,
+                    value: ref.value,
+                }];
+        })
+        : [];
+    const nextCommands = Array.isArray(record?.next_commands)
+        ? record.next_commands.filter((item) => typeof item === 'string')
+        : ['moda investigate'];
+    const confidence = normalizeConfidence(record?.confidence);
+    return {
+        schemaVersion: ASK_SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        source: 'cloud',
+        question,
+        answer,
+        confidence,
+        evidenceRefs,
+        findings: [],
+        nextCommands,
+        warnings: [],
+    };
+}
+function investigationAgentOptions(investigation) {
+    return {
+        summary: investigation.summary,
+        findings: investigation.findings.map(agentFinding),
+        evidenceRefs: investigation.evidenceRefs.map(agentEvidence),
+        recommendedActions: investigation.findings.flatMap((finding) => finding.recommendedActions.map(agentAction)),
+        nextCommands: investigation.nextCommands.map(nextCommand),
+        warnings: investigation.warnings,
+    };
+}
+function overviewAgentOptions(briefing) {
+    return {
+        summary: {
+            text: `Moda health briefing: ${briefing.status}. Next: ${briefing.nextCommand}`,
+            confidence: briefing.topFinding ? briefing.topFinding.confidence : 'medium',
+        },
+        findings: briefing.topFinding ? [agentFinding(briefing.topFinding)] : [],
+        evidenceRefs: briefing.evidenceRefs.map(agentEvidence),
+        recommendedActions: briefing.topFinding
+            ? briefing.topFinding.recommendedActions.map(agentAction)
+            : [],
+        nextCommands: [nextCommand(briefing.nextCommand)],
+    };
+}
+function askAgentOptions(result) {
+    return {
+        summary: { text: result.answer, confidence: result.confidence },
+        findings: result.findings.map(agentFinding),
+        evidenceRefs: result.evidenceRefs.map(agentEvidence),
+        recommendedActions: result.findings.flatMap((finding) => finding.recommendedActions.map(agentAction)),
+        nextCommands: result.nextCommands.map(nextCommand),
+        warnings: result.warnings,
+    };
+}
+function agentFinding(finding) {
+    return {
+        id: finding.id,
+        title: finding.title,
+        severity: finding.severity,
+        description: `${finding.summary} ${finding.rankReason}`,
+        evidence_ref_ids: finding.evidenceRefIds,
+    };
+}
+function agentEvidence(ref) {
+    return {
+        id: ref.id,
+        kind: ref.kind,
+        label: ref.label,
+        path: ref.path,
+        line: ref.line,
+    };
+}
+function agentAction(action) {
+    return {
+        id: action.id,
+        title: action.title,
+        rationale: action.rationale,
+        command: action.command,
+        mutability: action.mutability,
+        requires_approval: action.requiresApproval,
+    };
+}
+function nextCommand(command) {
+    return {
+        command,
+        purpose: purposeForCommand(command),
+        mutability: command.includes(' sync') ? 'sync' : 'read',
+        requires_approval: command.includes(' sync') || command.includes(' --yes'),
+    };
+}
+function renderOverviewBriefingHuman(briefing) {
+    const lines = [];
+    lines.push('Moda overview');
+    lines.push('Production health briefing');
+    lines.push('');
+    lines.push(`Status      ${briefing.status}`);
+    lines.push(`Data flow   ${briefing.dataFlow.status} (${briefing.dataFlow.conversations} conversation(s))`);
+    if (briefing.dataFlow.lastEvent) {
+        lines.push(`Last event  ${briefing.dataFlow.lastEvent.summary}${briefing.dataFlow.lastEvent.timestamp ? ` - ${briefing.dataFlow.lastEvent.timestamp}` : ''}`);
+    }
+    lines.push('');
+    lines.push('Sync');
+    lines.push(`  Harness   ${briefing.harnessSync.status} - ${briefing.harnessSync.summary}`);
+    lines.push(`  Prompts   ${briefing.promptSync.status} - ${briefing.promptSync.summary}`);
+    lines.push(`  Skills    ${briefing.skillSync.status} - ${briefing.skillSync.summary}`);
+    lines.push('');
+    lines.push('Signals');
+    for (const [label, value] of overviewSignalPairs(briefing.metrics)) {
+        lines.push(`  ${label.padEnd(18)} ${String(value)}`);
+    }
+    lines.push('');
+    lines.push('Top signal');
+    if (briefing.topFinding) {
+        lines.push(`  ${briefing.topFinding.severity.toUpperCase()} ${briefing.topFinding.title}`);
+        lines.push(`  ${briefing.topFinding.summary}`);
+        lines.push(`  Why ranked: ${briefing.topFinding.rankReason}`);
+    }
+    else {
+        lines.push('  No urgent production issue found in the selected window.');
+    }
+    lines.push('');
+    lines.push('Next best action');
+    lines.push(`  ${briefing.nextCommand}`);
+    return lines.join('\n');
+}
+function renderInvestigationHuman(investigation) {
+    const lines = [];
+    lines.push('Moda investigation');
+    lines.push(`Window: last ${investigation.daysBack} day(s)`);
+    lines.push('');
+    lines.push(investigation.summary.text);
+    for (const finding of investigation.findings) {
+        lines.push('');
+        lines.push(`${finding.severity.toUpperCase()} ${finding.title}`);
+        lines.push(`  Confidence: ${finding.confidence}`);
+        lines.push(`  Impact: ${finding.impactScore}`);
+        lines.push(`  ${finding.summary}`);
+        lines.push(`  Why ranked: ${finding.rankReason}`);
+        if (finding.likelyLocations.length > 0) {
+            lines.push('  Likely location:');
+            for (const location of finding.likelyLocations.slice(0, 3)) {
+                lines.push(`    - ${location.path ?? location.label} (${location.confidence})`);
+            }
+        }
+        if (finding.recommendedActions.length > 0) {
+            lines.push('  Next:');
+            for (const action of finding.recommendedActions.slice(0, 2)) {
+                lines.push(`    ${action.command}`);
+            }
+        }
+    }
+    lines.push('');
+    lines.push('Next commands');
+    for (const command of investigation.nextCommands.slice(0, 6))
+        lines.push(`  ${command}`);
+    if (investigation.warnings.length > 0) {
+        lines.push('');
+        lines.push('Warnings');
+        for (const warning of investigation.warnings.slice(0, 5))
+            lines.push(`  - ${warning}`);
+    }
+    return lines.join('\n');
+}
+function renderAskHuman(result) {
+    const lines = [];
+    lines.push('Moda ask');
+    lines.push(`Question: ${result.question}`);
+    lines.push('');
+    lines.push(result.answer);
+    lines.push('');
+    lines.push(`Confidence: ${result.confidence}`);
+    if (result.evidenceRefs.length > 0) {
+        lines.push('');
+        lines.push('Evidence');
+        for (const ref of result.evidenceRefs.slice(0, 8)) {
+            lines.push(`  - ${ref.label}${ref.path ? ` (${ref.path})` : ''}`);
+        }
+    }
+    if (result.nextCommands.length > 0) {
+        lines.push('');
+        lines.push('Next commands');
+        for (const command of result.nextCommands.slice(0, 5))
+            lines.push(`  ${command}`);
+    }
+    if (result.warnings.length > 0) {
+        lines.push('');
+        lines.push('Warnings');
+        for (const warning of result.warnings.slice(0, 3))
+            lines.push(`  - ${warning}`);
+    }
+    return lines.join('\n');
+}
+function addOverviewEvidence(data, endpoint, refs) {
+    refs.push({
+        id: 'overview:data',
+        kind: 'data_api',
+        label: 'Production overview aggregate',
+        endpoint,
+        value: overviewMetrics(data),
+    });
+}
+function toolRows(data, scopedTool) {
+    const record = asRecord(data);
+    const directToolName = asString(record?.tool_name) ?? scopedTool;
+    const examples = Array.isArray(record?.examples) ? record.examples : [];
+    if (directToolName) {
+        return [{
+                name: directToolName,
+                count: numberValue(record?.failure_count) || numberValue(record?.total_failures) || examples.length,
+                conversations: numberValue(record?.failed_conversations) || numberValue(record?.conversation_count) || examples.length,
+                subtype: asString(record?.top_error_subtype) ?? asString(record?.error_subtype) ?? undefined,
+                raw: data,
+            }];
+    }
+    const tools = Array.isArray(record?.tools)
+        ? record.tools
+        : Array.isArray(record?.tool_failures)
+            ? record.tool_failures
+            : Array.isArray(record?.failures)
+                ? record.failures
+                : [];
+    return tools.flatMap((item) => {
+        const row = asRecord(item);
+        const name = asString(row?.tool_name) ?? asString(row?.name);
+        if (!name)
+            return [];
+        return [{
+                name,
+                count: numberValue(row?.failure_count) || numberValue(row?.total_failures) || numberValue(row?.count),
+                conversations: numberValue(row?.failed_conversations) || numberValue(row?.conversation_count),
+                subtype: asString(row?.top_error_subtype) ?? asString(row?.error_subtype) ?? undefined,
+                raw: row,
+            }];
+    });
+}
+function runRows(data) {
+    const record = asRecord(data);
+    const run = asRecord(record?.run);
+    const rows = Array.isArray(record?.runs) ? record.runs : run ? [run] : [];
+    return rows.flatMap((item) => {
+        const row = asRecord(item);
+        if (!row)
+            return [];
+        return [{
+                id: asString(row.job_id) ?? asString(row.run_id) ?? '',
+                outcome: asString(row.outcome) ?? 'unknown',
+                agentName: asString(row.agent_name) ?? undefined,
+                reason: asString(row.outcome_reason) ?? undefined,
+                conversationId: asString(row.conversation_id) ?? undefined,
+                raw: row,
+            }];
+    });
+}
+function loopRows(data) {
+    const record = asRecord(data);
+    const rows = Array.isArray(record?.loops)
+        ? record.loops
+        : asRecord(record)
+            ? [record]
+            : [];
+    return rows.flatMap((item) => {
+        const row = asRecord(item);
+        if (!row)
+            return [];
+        return [{
+                id: asString(row.detection_id) ?? '',
+                type: asString(row.loop_type) ?? undefined,
+                signature: asString(row.loop_signature_human) ?? undefined,
+                blastRadius: numberValue(row.blast_radius),
+                conversationId: asString(row.conversation_id) ?? undefined,
+                rootCause: asString(row.root_cause_hypothesis) ?? undefined,
+                raw: row,
+            }];
+    }).filter((loop) => loop.id);
+}
+function firstQuote(row) {
+    const quotes = Array.isArray(row?.user_quotes) ? row.user_quotes : [];
+    const first = asRecord(quotes[0]);
+    return asString(first?.quote)?.slice(0, 160) ?? undefined;
+}
+function likelyToolLocation(toolName, hints) {
+    const normalized = normalizeKey(toolName);
+    for (const [key, path] of hints.toolPaths.entries()) {
+        if (key.includes(normalized) || normalized.includes(key)) {
+            return {
+                kind: 'tool',
+                path,
+                label: `Tool definition for ${toolName}`,
+                confidence: 'medium',
+                reason: 'Matched tool name against the local harness graph.',
+            };
+        }
+    }
+    return null;
+}
+function defaultLikelyLocations(hints, kind) {
+    const source = kind === 'tool' ? hints.toolPaths : kind === 'prompt' ? hints.promptPaths : hints.skillPaths;
+    const first = [...source.values()][0];
+    if (first) {
+        return [{
+                kind,
+                path: first,
+                label: `${kind} artifact`,
+                confidence: 'low',
+                reason: 'The overview is aggregate-only; investigation will map specific production evidence.',
+            }];
+    }
+    if (hints.reportPath) {
+        return [{
+                kind: 'harness',
+                path: hints.reportPath,
+                label: 'Local harness manifest',
+                confidence: 'low',
+                reason: 'Use the local harness graph to map production signals to code.',
+            }];
+    }
+    return [];
+}
+function unknownLocation(kind, reason) {
+    return {
+        kind,
+        label: 'Unknown local path',
+        confidence: 'unknown',
+        reason,
+    };
+}
+function loadHarnessHints(cwd) {
+    const hints = {
+        toolPaths: new Map(),
+        promptPaths: new Map(),
+        skillPaths: new Map(),
+        entrypointPaths: [],
+    };
+    const harnessPath = join(cwd, '.moda', 'harness.json');
+    if (!existsSync(harnessPath))
+        return hints;
+    hints.reportPath = '.moda/harness.json';
+    try {
+        const parsed = JSON.parse(readFileSync(harnessPath, 'utf8'));
+        const graph = asRecord(parsed);
+        const artifacts = Array.isArray(graph?.artifacts) ? graph.artifacts : [];
+        for (const item of artifacts) {
+            const artifact = asRecord(item);
+            if (!artifact)
+                continue;
+            const name = asString(artifact.name) ?? asString(artifact.id) ?? '';
+            const path = asString(artifact.sourcePath) ?? asString(artifact.path);
+            const type = asString(artifact.type);
+            if (!path || !name)
+                continue;
+            const key = normalizeKey(name);
+            if (type === 'tool')
+                hints.toolPaths.set(key, path);
+            if (type === 'prompt')
+                hints.promptPaths.set(key, path);
+            if (type === 'skill')
+                hints.skillPaths.set(key, path);
+            if (type === 'entrypoint')
+                hints.entrypointPaths.push(path);
+        }
+    }
+    catch {
+        return hints;
+    }
+    return hints;
+}
+function localHarnessSummary(cwd) {
+    const path = join(cwd, '.moda', 'harness.json');
+    if (!existsSync(path))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        return {
+            harnessId: parsed.harnessId,
+            graphHash: parsed.graphHash,
+            runtimeAgentCount: Array.isArray(parsed.runtimeAgents) ? parsed.runtimeAgents.length : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function localSyncBrief(cwd, relativePath, label) {
+    const path = join(cwd, relativePath);
+    if (!existsSync(path)) {
+        return { status: 'missing', summary: `${label} state not found`, path: relativePath };
+    }
+    return { status: 'present', summary: `${label} state exists locally`, path: relativePath };
+}
+function localSkillBrief(cwd) {
+    const claudeSkill = join(cwd, '.claude', 'skills');
+    const cursorRules = join(cwd, '.cursor', 'rules');
+    if (existsSync(claudeSkill) || existsSync(cursorRules)) {
+        return { status: 'present', summary: 'Local agent skill/rule directory exists' };
+    }
+    return { status: 'missing', summary: 'No local agent skill/rule directory found' };
+}
+function summarizeInvestigation(findings) {
+    const top = findings[0];
+    if (!top) {
+        return { text: 'No production findings were generated.', confidence: 'unknown' };
+    }
+    if (top.kind === 'insufficient_data') {
+        return { text: top.title, confidence: top.confidence };
+    }
+    return {
+        text: `Top production finding: ${top.title}. ${top.summary}`,
+        confidence: top.confidence,
+    };
+}
+function nextCommandsForFindings(findings, daysBack) {
+    const commands = findings
+        .flatMap((finding) => finding.recommendedActions.map((action) => action.command))
+        .filter(Boolean);
+    commands.push(`moda overview --days-back=${daysBack}`);
+    commands.push('moda doctor --online');
+    return [...new Set(commands)].slice(0, 8);
+}
+function compareFindings(a, b) {
+    const severityDelta = severityWeight(b.severity) - severityWeight(a.severity);
+    if (severityDelta !== 0)
+        return severityDelta;
+    return b.impactScore - a.impactScore;
+}
+function severityWeight(severity) {
+    return { critical: 5, high: 4, medium: 3, low: 2, info: 1 }[severity];
+}
+function severityForCount(count, high, medium) {
+    if (count >= high)
+        return 'critical';
+    if (count >= medium)
+        return 'high';
+    return 'medium';
+}
+function uniqueEvidenceRefs(refs) {
+    const seen = new Set();
+    const out = [];
+    for (const ref of refs) {
+        if (seen.has(ref.id))
+            continue;
+        seen.add(ref.id);
+        out.push(ref);
+    }
+    return out;
+}
+function overviewMetrics(data) {
+    return {
+        conversations: valueAt(data, ['conversations', 'total']) ?? 0,
+        conversationTrendPct: valueAt(data, ['conversations', 'trend_pct']) ?? 0,
+        toolFailures: valueAt(data, ['tool_failures', 'total']) ?? 0,
+        failedToolConversations: valueAt(data, ['tool_failures', 'conversations']) ?? 0,
+        impactedTools: valueAt(data, ['tool_failures', 'tools']) ?? 0,
+        frustrated: valueAt(data, ['frustrations', 'frustrated']) ?? 0,
+        atRisk: valueAt(data, ['frustrations', 'at_risk']) ?? 0,
+        frustrationRatePct: valueAt(data, ['frustrations', 'rate_pct']) ?? 0,
+        recentActivity: recentActivity(data).length,
+    };
+}
+function overviewSignalPairs(metrics) {
+    return [
+        ['Conversations', metrics.conversations],
+        ['Tool failures', metrics.toolFailures],
+        ['Failed convos', metrics.failedToolConversations],
+        ['Impacted tools', metrics.impactedTools],
+        ['Frustrated', metrics.frustrated],
+        ['At risk', metrics.atRisk],
+        ['Frustration %', metrics.frustrationRatePct],
+        ['Recent events', metrics.recentActivity],
+    ];
+}
+function recentActivity(data) {
+    const activity = valueAt(data, ['recent_activity']);
+    if (!Array.isArray(activity))
+        return [];
+    return activity.flatMap((item) => {
+        const row = asRecord(item);
+        const summary = asString(row?.summary) ?? asString(row?.title) ?? asString(row?.event);
+        if (!summary)
+            return [];
+        return [{
+                summary,
+                timestamp: asString(row?.timestamp) ?? asString(row?.created_at) ?? undefined,
+                conversationId: asString(row?.conversation_id) ?? undefined,
+            }];
+    });
+}
+function valueAt(value, path) {
+    let cursor = value;
+    for (const key of path) {
+        const record = asRecord(cursor);
+        if (!record)
+            return undefined;
+        cursor = record[key];
+    }
+    return cursor;
+}
+function numberAt(value, path) {
+    return numberValue(valueAt(value, path));
+}
+function numberValue(value) {
+    const direct = asNumber(value);
+    if (direct !== null)
+        return direct;
+    if (typeof value === 'string') {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+    return 0;
+}
+function numberFlag(flags, key, fallback) {
+    const raw = flags[key];
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed < 1)
+        return fallback;
+    return Math.min(Math.floor(parsed), 90);
+}
+function timeRangeForDays(days) {
+    if (days <= 1)
+        return '24h';
+    if (days <= 3)
+        return '3d';
+    if (days <= 7)
+        return '7d';
+    if (days <= 30)
+        return '30d';
+    return '90d';
+}
+function normalizeConfidence(value) {
+    if (value === 'high' || value === 'medium' || value === 'low' || value === 'unknown')
+        return value;
+    return 'medium';
+}
+function capFallbackConfidence(confidence) {
+    return confidence === 'high' ? 'medium' : confidence;
+}
+function evidenceKind(value) {
+    if (value === 'data_api' ||
+        value === 'tool_failure' ||
+        value === 'frustration' ||
+        value === 'loop' ||
+        value === 'run' ||
+        value === 'harness' ||
+        value === 'ask')
+        return value;
+    return 'ask';
+}
+function normalizeKey(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, '');
+}
+function slug(value) {
+    const clean = value.replace(/[^a-zA-Z0-9_-]+/g, '_').replace(/^_+|_+$/g, '');
+    return clean || 'unknown';
+}
+function purposeForCommand(command) {
+    if (command.startsWith('moda investigate'))
+        return 'Open the ranked production investigation.';
+    if (command.startsWith('moda tool-failure-detail'))
+        return 'Inspect tool failure examples and conversation anchors.';
+    if (command.startsWith('moda context'))
+        return 'Read the relevant conversation window.';
+    if (command.startsWith('moda loop'))
+        return 'Inspect loop detection details.';
+    if (command.startsWith('moda run'))
+        return 'Inspect one agent run and side-effect receipts.';
+    if (command.startsWith('moda doctor'))
+        return 'Validate Moda setup and data flow.';
+    if (command.startsWith('moda overview'))
+        return 'Return to the harness health briefing.';
+    return 'Suggested next Moda command.';
+}
+//# sourceMappingURL=production-intelligence.js.map