@moda-ai/cli 1.9.6 → 1.10.1

package/dist/cli.js

@@ -2,7 +2,7 @@
 import { z } from 'zod';
 import { validateConfig, VERSION, resolveApiKey } from './config.js';
 import { callDataAPI, ApiError, getApiRequestCount, resetApiRequestCount, } from './api-client.js';
-import { OverviewSchema, ClustersSchema, ClusterConversationsSchema, ConversationsSchema, SearchSchema, WorldStateSchema, ContextSchema, FrustrationsSchema, ToolFailuresSchema, ToolFailureDetailSchema, WorkflowsSchema, RunsSchema, RunDetailSchema, LoopsSchema, LoopDetailSchema, } from './schemas.js';
+import { OverviewSchema, ClustersSchema, ClusterConversationsSchema, ConversationsSchema, SearchSchema, WorldStateSchema, ContextSchema, AuditSchema, FrustrationsSchema, ToolFailuresSchema, ToolFailureDetailSchema, LoopsSchema, LoopDetailSchema, } from './schemas.js';
 import { withFrustrationAnchors, withToolFailureAnchors, embeddedWindowSize, asRecord, asString, asNumber } from './transforms.js';
 import { runPromptsCommand } from './prompts.js';
 // Coding-agent capture (shadow workspace / Shadow Spark / trace hooks) is temporarily
@@ -17,7 +17,8 @@ import { buildSearchAdoptionTelemetry, isTelemetryDisabled, SEARCH_MODES, sendCl
 import { isUpdateCheckDisabled, printUpdateNotice, startUpdateCheck, stripUpdateCheckFlag, } from './update-check.js';
 import { createCommandContext } from './command-context.js';
 import { createCommandRegistry } from './command-registry.js';
-import { createAgentErrorEnvelope, errorToAgentError, outputModeFromFlags, } from './output.js';
+import { createAgentErrorEnvelope, errorToAgentError, resolveOutputMode, } from './output.js';
+import { renderJsonSchemas } from './agent-schemas.js';
 import { runAuthCommand, runConfigCommand, runKeysCommand, runProfilesCommand } from './profile-commands.js';
 import { runAgentCommand } from './agent.js';
 import { runProductionCommand } from './production-intelligence.js';
@@ -51,6 +52,9 @@ export function parseArgs(argv) {
 const GLOBAL_BOOLEAN_FLAGS = new Set([
     'agent',
     'json',
+    'human',
+    'prose',
+    'json-schemas',
     'help',
     'version',
     'quiet',
@@ -126,7 +130,6 @@ Commands:
   agent evidence <ref>             Expand one evidence reference
   investigate                      Rank production issues with evidence
   failures                         Show production failures worth fixing first
-  why-failed <run_id>              Explain a failed or partial production run
   ask "question"                   Ask Moda a production/harness question
   sync                             Sync the local harness graph to Moda Cloud
   sync harness                     Sync the local harness graph to Moda Cloud
@@ -140,14 +143,11 @@ Commands:
   search "<query>"                 Search conversation messages (keyword/semantic/hybrid)
   world-state <conversation_id>    Get a conversation's world state (slots/threads/events)
   context <conversation_id>        Get windowed conversation context
+  audit <conversation_id|trace_id> Raw span/trace audit (spans, hierarchy, orphans, duplicates)
   frustrations                     Get user frustration detections
   tool-failures                    Get tool failure overview
   tool-failure-detail <tool_name>  Get per-tool failure detail
 
-  Agent runs runtime:
-  workflows                        Recurring workflow catalog (per-class 30d health)
-  runs                             List workflow executions with classified outcomes
-  run <run_id>                     Get single execution + side-effect receipts
   loops                            Currently-active loop detections
   loop <detection_id>              Single loop detail
 
@@ -169,6 +169,7 @@ Commands:
 Options:
   --help                           Show this help message
   --version                        Show version number
+  --json-schemas                   Print JSON Schemas for the agent output contract
 
 Common flags:
   --days-back=N                    Number of days to look back (1-90)
@@ -179,6 +180,13 @@ Common flags:
   --json                           Emit machine-readable JSON
   --agent                          Emit schema-versioned agent JSON
   --stream                         With --agent, emit NDJSON agent events
+  --human                          Force human prose (overrides auto-detection)
+
+Output auto-detection (no flags needed):
+  Piped/redirected stdout, CI, or an agent env (CLAUDECODE/CURSOR/MODA_AGENT)
+  => schema-versioned agent JSON. An interactive terminal => human prose.
+  Override with the flags above or MODA_FORMAT=human|json|agent|agent-stream.
+  Exit codes: 0 ok, 3 degraded (local fallback), 1 error.
   --dry-run                        Show the planned mutation when supported
   --yes                            Accept explicit automation defaults
   --tui                            Force the human analyst dashboard when supported
@@ -203,11 +211,6 @@ World-state flags:
   --summary-only                   Return segment summaries only (omit the event stream)
   --event-limit=N                  Max world-state events to return (1-5000, default 2000)
 
-Runs flags:
-  --outcome=OUTCOME                Filter by outcome (running|succeeded|partial|failed|loop|abandoned|unknown)
-  --class-id=ID                    Filter to a single workflow class (e.g. cron:helpscout-triage-hourly)
-  --user-id=ID                     Filter to a single user
-
 Init flags:
   --yes                            Accept all defaults (non-interactive)
   --analyst=auto|claude|codex|cursor|local-scan
@@ -243,7 +246,6 @@ Examples:
   moda agent evidence doctor:harness_report_approved_synced
   moda investigate
   moda failures
-  moda why-failed 12345678-1234-1234-1234-1234567890ab
   moda ask "what should I fix first?"
   moda sync --dry-run
   moda sync harness --profile=prod
@@ -261,10 +263,8 @@ Examples:
   moda world-state <conversation_id> --summary-only
   moda frustrations --days-back=14 --limit=20
   moda context <conversation_id> --window=3
-  moda workflows --time-range=7d
-  moda runs --time-range=24h --outcome=partial
-  moda runs --class-id=cron:helpscout-triage-hourly --limit=20
-  moda run 12345678-1234-1234-1234-1234567890ab
+  moda audit <conversation_id|trace_id>
+  moda audit <trace_id> --kind=trace --json
   moda loops --limit=10
   moda loop 12345678-1234-1234-1234-1234567890ab
   moda prompts status
@@ -386,15 +386,12 @@ export async function runCommand(command, positional, flags, positionals = posit
         case 'overview': {
             const args = flagsToArgs(flags);
             OverviewSchema.parse(args);
-            await runProductionCommand(context);
-            break;
+            return (await runProductionCommand(context)).exitCode;
         }
         case 'investigate':
         case 'failures':
-        case 'why-failed':
         case 'ask': {
-            await runProductionCommand(context);
-            break;
+            return (await runProductionCommand(context)).exitCode;
         }
         case 'clusters': {
             const args = flagsToArgs(flags);
@@ -519,6 +516,25 @@ export async function runCommand(command, positional, flags, positionals = posit
             context.output.writeData(data);
             break;
         }
+        case 'audit':
+        case 'trace': {
+            if (!positional) {
+                throw new CliInputError('<conversation_id|trace_id> is required', 'Usage: moda audit <conversation_id|trace_id> [--kind=auto|trace|conversation] [--include-raw] [--limit=N]');
+            }
+            const args = flagsToArgs(flags, 'id', positional);
+            const params = AuditSchema.parse(args);
+            const query = new URLSearchParams();
+            if (params.kind && params.kind !== 'auto')
+                query.set('kind', params.kind);
+            if (params.include_raw === true)
+                query.set('include_raw', '1');
+            if (params.limit)
+                query.set('limit', params.limit.toString());
+            const queryString = query.toString() ? `?${query.toString()}` : '';
+            const data = await callDataAPI(`/audit/${encodeURIComponent(params.id)}${queryString}`);
+            context.output.writeData(data);
+            break;
+        }
         case 'frustrations': {
             const args = flagsToArgs(flags);
             const params = FrustrationsSchema.parse(args);
@@ -562,51 +578,6 @@ export async function runCommand(command, positional, flags, positionals = posit
             await printWithOptionalWindows(withToolFailureAnchors(data), 'examples', params.include_window === true, params.window ?? 1, context.output);
             break;
         }
-        // ─── Workflows + Runs ──────────────────────────────────────
-        case 'workflows': {
-            const args = flagsToArgs(flags);
-            const params = WorkflowsSchema.parse(args);
-            const query = new URLSearchParams();
-            if (params.time_range)
-                query.set('time_range', params.time_range);
-            if (params.user_id)
-                query.set('user_id', params.user_id);
-            const queryString = query.toString() ? `?${query.toString()}` : '';
-            const data = await callDataAPI(`/workflows${queryString}`);
-            context.output.writeData(data);
-            break;
-        }
-        case 'runs': {
-            const args = flagsToArgs(flags);
-            const params = RunsSchema.parse(args);
-            const query = new URLSearchParams();
-            if (params.time_range)
-                query.set('time_range', params.time_range);
-            if (params.outcome)
-                query.set('outcome', params.outcome);
-            if (params.class_id)
-                query.set('class_id', params.class_id);
-            if (params.user_id)
-                query.set('user_id', params.user_id);
-            if (params.limit)
-                query.set('limit', params.limit.toString());
-            if (params.offset !== undefined)
-                query.set('offset', params.offset.toString());
-            const queryString = query.toString() ? `?${query.toString()}` : '';
-            const data = await callDataAPI(`/runs${queryString}`);
-            context.output.writeData(data);
-            break;
-        }
-        case 'run': {
-            if (!positional) {
-                throw new CliInputError('<run_id> is required', 'Usage: moda run <run_id>');
-            }
-            const args = flagsToArgs(flags, 'run_id', positional);
-            const params = RunDetailSchema.parse(args);
-            const data = await callDataAPI(`/runs/${params.run_id}`);
-            context.output.writeData(data);
-            break;
-        }
         case 'loops': {
             const args = flagsToArgs(flags);
             const params = LoopsSchema.parse(args);
@@ -631,13 +602,14 @@ export async function runCommand(command, positional, flags, positionals = posit
         default:
             throw new CliInputError(`Unknown command '${command}'`, 'Run "moda --help" for usage information.');
     }
+    return 0;
 }
 function legacyCommand(metadata) {
     return {
         ...metadata,
         handler: async (context) => {
-            await runCommand(context.command, context.positional, context.flags, context.positionals, context);
-            return { exitCode: 0 };
+            const exitCode = await runCommand(context.command, context.positional, context.flags, context.positionals, context);
+            return { exitCode };
         },
     };
 }
@@ -894,12 +866,6 @@ export const commandRegistry = createCommandRegistry([
         examples: ['moda failures', 'moda failures --tool lookupCustomer'],
         ...dataApiDefaults,
     }),
-    legacyCommand({
-        name: 'why-failed',
-        description: 'Explain a failed or partial production run',
-        examples: ['moda why-failed 12345678-1234-1234-1234-1234567890ab'],
-        ...dataApiDefaults,
-    }),
     legacyCommand({
         name: 'ask',
         description: 'Ask Moda a production intelligence question',
@@ -952,6 +918,17 @@ export const commandRegistry = createCommandRegistry([
         examples: ['moda context <conversation_id> --window=3'],
         ...dataApiDefaults,
     }),
+    legacyCommand({
+        name: 'audit',
+        aliases: ['trace'],
+        description: 'Raw non-deduped span/trace audit (hierarchy, tool spans, orphans, duplicates)',
+        examples: [
+            'moda audit <conversation_id|trace_id>',
+            'moda audit <trace_id> --kind=trace --json',
+            'moda audit <conversation_id> --include-raw',
+        ],
+        ...dataApiDefaults,
+    }),
     legacyCommand({
         name: 'frustrations',
         description: 'Get user frustration detections',
@@ -970,24 +947,6 @@ export const commandRegistry = createCommandRegistry([
         examples: ['moda tool-failure-detail search --include-window'],
         ...dataApiDefaults,
     }),
-    legacyCommand({
-        name: 'workflows',
-        description: 'Recurring workflow catalog',
-        examples: ['moda workflows --time-range=7d'],
-        ...dataApiDefaults,
-    }),
-    legacyCommand({
-        name: 'runs',
-        description: 'List workflow executions',
-        examples: ['moda runs --time-range=24h --outcome=partial'],
-        ...dataApiDefaults,
-    }),
-    legacyCommand({
-        name: 'run',
-        description: 'Get a single workflow execution',
-        examples: ['moda run 12345678-1234-1234-1234-1234567890ab'],
-        ...dataApiDefaults,
-    }),
     legacyCommand({
         name: 'loops',
         description: 'List currently-active loop detections',
@@ -1139,6 +1098,10 @@ export async function dispatchParsedCommand(parsed, startedAt = Date.now()) {
         printHelp();
         return 0;
     }
+    if (command === '--json-schemas' || flags['json-schemas'] === 'true') {
+        console.log(renderJsonSchemas());
+        return 0;
+    }
     if (!command) {
         printHelp();
         return 1;
@@ -1146,7 +1109,11 @@ export async function dispatchParsedCommand(parsed, startedAt = Date.now()) {
     const definition = commandRegistry.find(command);
     if (!definition) {
         const error = new CliInputError(`Unknown command '${command}'`, 'Run "moda --help" for usage information.');
-        if (outputModeFromFlags(commandFlags) === 'agent' || outputModeFromFlags(commandFlags) === 'agent-stream') {
+        const mode = resolveOutputMode(commandFlags, {
+            isTTY: process.stdout.isTTY,
+            env: process.env,
+        });
+        if (mode === 'agent' || mode === 'agent-stream') {
             printAgentCliError(command, error);
         }
         else {
@@ -1173,6 +1140,13 @@ export async function dispatchParsedCommand(parsed, startedAt = Date.now()) {
         commandFlags,
         rawFlags: flags,
         startedAt,
+        // Agent-safe output auto-selection happens here (not in createCommandContext)
+        // so direct callers/tests keep flag-only behavior. We resolve from the real
+        // stdout TTY + environment, leaving `commandFlags` (and telemetry) untouched.
+        outputMode: resolveOutputMode(commandFlags, {
+            isTTY: process.stdout.isTTY,
+            env: process.env,
+        }),
     });
     try {
         const result = await definition.handler(context);

package/dist/command-context.d.ts

@@ -45,5 +45,11 @@ export declare function createCommandContext(input: CommandContextInput, options
     startedAt?: number;
     cwd?: string;
     env?: NodeJS.ProcessEnv;
+    /**
+     * Pre-resolved output mode from the dispatcher (TTY/env auto-detection).
+     * When omitted we fall back to flag-only resolution so direct callers
+     * (tests, internal helpers) keep their explicit behavior.
+     */
+    outputMode?: CliOutputMode;
 }): CommandContext;
 //# sourceMappingURL=command-context.d.ts.map

package/dist/command-context.js

@@ -5,7 +5,7 @@ function flagEnabled(flags, key) {
 export function createCommandContext(input, options = {}) {
     const flags = options.commandFlags ?? input.flags;
     const rawFlags = options.rawFlags ?? input.flags;
-    const outputMode = outputModeFromFlags(flags);
+    const outputMode = options.outputMode ?? outputModeFromFlags(flags);
     const quiet = flagEnabled(flags, 'quiet');
     const interactive = outputMode === 'human' &&
         !quiet &&

package/dist/intelligence-schema.d.ts

@@ -0,0 +1,349 @@
+/**
+ * moda.intelligence.v1 — the unified Moda intelligence wire format (MODA-388).
+ *
+ * ONE versioned payload that every surface projects from:
+ *   - CLI `moda ask --json` / `--agent` (the agent-facing contract),
+ *   - the backend `POST /api/cli/ask` response,
+ *   - the (future) MCP server's `structuredContent`,
+ *   - the dashboard UI.
+ *
+ * Design rules:
+ *   - snake_case everywhere (no mixed casing — the prior split between the
+ *     snake_case envelope and the camelCase `production_ask.v0.1` data payload
+ *     was the main source of agent-integration pain).
+ *   - It is a SUPERSET. Differentiation between a human reader and an agent is a
+ *     RENDERING concern at the edge, not a forked schema:
+ *       · human projection  → narrative `answer_markdown`, `summary.confidence`
+ *                             as a word, raw ids/anchors hidden.
+ *       · agent projection  → full `evidence_refs` (with `anchor` + `grounding`),
+ *                             `answer_claims` (claim → evidence), structured
+ *                             `next_commands`.
+ *   - Additive evolution only within v1; breaking changes bump the version.
+ *
+ * This module is the SINGLE SOURCE OF TRUTH for the shape. The backend mirrors
+ * these field names on the wire and the contract tests validate real CLI output
+ * against {@link MODA_INTELLIGENCE_V1_JSON_SCHEMA}.
+ */
+export declare const INTELLIGENCE_SCHEMA_VERSION: "moda.intelligence.v1";
+export type IntelligenceConfidence = 'high' | 'medium' | 'low' | 'unknown';
+/** Where the answer came from. `local_fallback` ⇒ degraded (lower trust). */
+export type IntelligenceSource = 'cloud' | 'local_fallback';
+/** How a signal was derived — a measured fact vs a model/heuristic estimate. */
+export type Provenance = 'measured' | 'inferred';
+/** Whether a suggested command reads, writes, or syncs state. */
+export type CommandMutability = 'read' | 'write' | 'sync' | 'unknown';
+/** Classification of a single quantitative/factual claim in the answer. */
+export type ClaimKind = 'percentage' | 'count' | 'qualitative';
+/**
+ * Verdict for one claim made in the answer, checked against the structured tool
+ * data the agent actually saw (MODA-377/378). `unverifiable` means the claim is
+ * not a checkable figure (or there was no tool data to check it against).
+ */
+export type ClaimStatus = 'grounded' | 'ungrounded' | 'unverifiable';
+export interface IntelligenceSummary {
+    text: string;
+    confidence: IntelligenceConfidence;
+}
+/**
+ * A structured locator so a surface can deep-link a piece of evidence. All
+ * fields optional — different evidence kinds populate different anchors.
+ */
+export interface EvidenceAnchor {
+    conversation_id?: string;
+    message_index?: number;
+    run_id?: string;
+    tool_name?: string;
+}
+export interface IntelligenceEvidenceRef {
+    /** Stable id, referenced by `findings[].evidence_ref_ids` and `answer_claims[].evidence_ref_ids`. */
+    id: string;
+    /** 'overview' | 'conversation' | 'message' | 'tool_failure' | 'run' | 'frustration' | 'cluster' | ... */
+    kind: string;
+    label: string;
+    anchor?: EvidenceAnchor;
+    /** Short human-readable excerpt of the underlying value. */
+    snippet?: string;
+    /** measured (exact) vs inferred (model-derived estimate) — MODA-379. */
+    grounding: Provenance;
+}
+/**
+ * A claim extracted from the answer with its grounding verdict. `value` is set
+ * for numeric claims; `evidence_ref_ids` links to the evidence that supports it
+ * (empty when ungrounded/unverifiable).
+ */
+export interface IntelligenceClaim {
+    text: string;
+    value?: number;
+    kind: ClaimKind;
+    status: ClaimStatus;
+    evidence_ref_ids: string[];
+    /** Path into the structured tool data where the value matched, when grounded. */
+    matched_path?: string;
+}
+export interface IntelligenceRecommendedAction {
+    id: string;
+    title: string;
+    rationale?: string;
+    command?: string;
+    mutability: CommandMutability;
+    requires_approval: boolean;
+}
+export interface IntelligenceFinding {
+    id: string;
+    title: string;
+    severity?: 'critical' | 'high' | 'medium' | 'low' | 'info';
+    description?: string;
+    evidence_ref_ids: string[];
+    recommended_actions: IntelligenceRecommendedAction[];
+}
+export interface IntelligenceNextCommand {
+    command: string;
+    purpose?: string;
+    mutability: CommandMutability;
+    requires_approval: boolean;
+}
+/**
+ * The canonical `moda.intelligence.v1` payload. Emitted by the backend ask
+ * endpoint and surfaced as the CLI agent envelope's `data` (and by `--json`).
+ */
+export interface ModaIntelligenceV1 {
+    schema_version: typeof INTELLIGENCE_SCHEMA_VERSION;
+    generated_at: string;
+    /** The originating command, e.g. "ask". */
+    command: string;
+    source: IntelligenceSource;
+    /** True when the answer was NOT produced by Moda Cloud intelligence. */
+    degraded: boolean;
+    question: string;
+    summary: IntelligenceSummary;
+    /** Full markdown answer (the human-facing narrative). */
+    answer_markdown: string;
+    /** Per-claim grounding verdicts (agent projection). */
+    answer_claims: IntelligenceClaim[];
+    /** Ranked findings; may be empty for a plain `ask`. */
+    findings: IntelligenceFinding[];
+    evidence_refs: IntelligenceEvidenceRef[];
+    next_commands: IntelligenceNextCommand[];
+    warnings: string[];
+    meta?: Record<string, unknown>;
+}
+/**
+ * Published draft-07 JSON Schema for {@link ModaIntelligenceV1}. This is what
+ * `moda --json-schemas` emits and what the contract tests validate CLI/backend
+ * output against. Keep in lockstep with the interfaces above.
+ */
+export declare const MODA_INTELLIGENCE_V1_JSON_SCHEMA: {
+    readonly $schema: "http://json-schema.org/draft-07/schema#";
+    readonly $id: "moda.intelligence.v1";
+    readonly title: "Moda Intelligence v1";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["schema_version", "generated_at", "command", "source", "degraded", "question", "summary", "answer_markdown", "answer_claims", "findings", "evidence_refs", "next_commands", "warnings"];
+    readonly properties: {
+        readonly schema_version: {
+            readonly const: "moda.intelligence.v1";
+        };
+        readonly generated_at: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly command: {
+            readonly type: "string";
+        };
+        readonly source: {
+            readonly type: "string";
+            readonly enum: readonly ["cloud", "local_fallback"];
+        };
+        readonly degraded: {
+            readonly type: "boolean";
+        };
+        readonly question: {
+            readonly type: "string";
+        };
+        readonly summary: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["text", "confidence"];
+            readonly properties: {
+                readonly text: {
+                    readonly type: "string";
+                };
+                readonly confidence: {
+                    readonly type: "string";
+                    readonly enum: readonly ["high", "medium", "low", "unknown"];
+                };
+            };
+        };
+        readonly answer_markdown: {
+            readonly type: "string";
+        };
+        readonly answer_claims: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["text", "kind", "status", "evidence_ref_ids"];
+                readonly properties: {
+                    readonly text: {
+                        readonly type: "string";
+                    };
+                    readonly value: {
+                        readonly type: "number";
+                    };
+                    readonly kind: {
+                        readonly type: "string";
+                        readonly enum: readonly ["percentage", "count", "qualitative"];
+                    };
+                    readonly status: {
+                        readonly type: "string";
+                        readonly enum: readonly ["grounded", "ungrounded", "unverifiable"];
+                    };
+                    readonly evidence_ref_ids: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly matched_path: {
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
+        readonly findings: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["id", "title", "evidence_ref_ids", "recommended_actions"];
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "string";
+                    };
+                    readonly title: {
+                        readonly type: "string";
+                    };
+                    readonly severity: {
+                        readonly type: "string";
+                        readonly enum: readonly ["critical", "high", "medium", "low", "info"];
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                    };
+                    readonly evidence_ref_ids: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly recommended_actions: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["id", "title", "mutability", "requires_approval"];
+                            readonly properties: {
+                                readonly id: {
+                                    readonly type: "string";
+                                };
+                                readonly title: {
+                                    readonly type: "string";
+                                };
+                                readonly rationale: {
+                                    readonly type: "string";
+                                };
+                                readonly command: {
+                                    readonly type: "string";
+                                };
+                                readonly mutability: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["read", "write", "sync", "unknown"];
+                                };
+                                readonly requires_approval: {
+                                    readonly type: "boolean";
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        readonly evidence_refs: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["id", "kind", "label", "grounding"];
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "string";
+                    };
+                    readonly kind: {
+                        readonly type: "string";
+                    };
+                    readonly label: {
+                        readonly type: "string";
+                    };
+                    readonly anchor: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly conversation_id: {
+                                readonly type: "string";
+                            };
+                            readonly message_index: {
+                                readonly type: "number";
+                            };
+                            readonly run_id: {
+                                readonly type: "string";
+                            };
+                            readonly tool_name: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                    readonly snippet: {
+                        readonly type: "string";
+                    };
+                    readonly grounding: {
+                        readonly type: "string";
+                        readonly enum: readonly ["measured", "inferred"];
+                    };
+                };
+            };
+        };
+        readonly next_commands: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["command", "mutability", "requires_approval"];
+                readonly properties: {
+                    readonly command: {
+                        readonly type: "string";
+                    };
+                    readonly purpose: {
+                        readonly type: "string";
+                    };
+                    readonly mutability: {
+                        readonly type: "string";
+                        readonly enum: readonly ["read", "write", "sync", "unknown"];
+                    };
+                    readonly requires_approval: {
+                        readonly type: "boolean";
+                    };
+                };
+            };
+        };
+        readonly warnings: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+        readonly meta: {
+            readonly type: "object";
+        };
+    };
+};
+//# sourceMappingURL=intelligence-schema.d.ts.map