@sanity/ailf 5.0.0 → 6.1.0

package/dist/_vendor/ailf-core/types/synthesis-telemetry.js

@@ -0,0 +1,18 @@
+/**
+ * Synthesis cost telemetry types — canonical TS-first shapes for
+ * Phase 6 DIAG-06 cost and parse-failure observability.
+ *
+ * These interfaces are authored independently of their Zod adapter schema
+ * (Plan 06-02) per D0045: the Zod schema declares
+ * `satisfies z.ZodType<SynthesisCostTelemetry>` against this independent
+ * type so drift is a build error, not a runtime bug.
+ *
+ * The 14 attribute paths on `SynthesisCostTelemetry` + `SynthesisPerCardTelemetry`
+ * land on the `ailf.report` Sanity doc under `summary.synthesis.diagnosis.*`
+ * (D6-09). No new sibling doc type (D0033 / D6-09).
+ *
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @see .planning/phases/06-post-run-integration-cost-telemetry/06-CONTEXT.md §D6-09
+ * @see .planning/phases/06-post-run-integration-cost-telemetry/06-CONTEXT.md §D6-12
+ */
+export {};

package/dist/adapters/config-sources/file-config-adapter.js

@@ -115,12 +115,10 @@ function mapEvalConfigToResolvedConfig(config, rootDir) {
         compareBaseline: config.compareBaseline,
         gapAnalysisEnabled: config.execution?.gapAnalysis ?? true,
         // W0077 Phase 4 — `publish` is now a policy object. Map the auto value
-        // directly to a boolean for the file-config path; the runtime
-        // smart-default logic in pipeline-action.ts isn't relevant here because
-        // the user has explicitly handed us a config file.
-        publishEnabled: config.publish?.auto === "never"
-            ? false
-            : config.publish?.auto !== undefined,
+        // to a boolean for the file-config path. Absence of publish.auto mirrors
+        // the CLI's "full-runs" default (enable publish; composition root gates on
+        // token availability). Only "never" explicitly disables auto-publish.
+        publishEnabled: config.publish?.auto !== "never",
         publishTag: config.publish?.tag,
         noCache: config.noCache ?? false,
         noRemoteCache: config.noRemoteCache ?? false,
@@ -150,5 +148,9 @@ function mapEvalConfigToResolvedConfig(config, rootDir) {
             ? resolve(rootDir, config.taskSource.repoTasksPath)
             : undefined,
         presets: config.presets,
+        // Phase 6 / DIAG-06 — thread summary.onRun into ResolvedConfig so the
+        // file-config exit branch in executePipeline can pass it to
+        // runPostPipelineHooks.
+        summaryOnRun: config.summary?.onRun,
     };
 }

package/dist/adapters/llm/fake-llm-client.d.ts

@@ -40,9 +40,29 @@ export declare class FakeLLMClient implements LLMClient {
     readonly calls: FakeCallRecord[];
     private readonly completeQueue;
     private readonly structuredQueue;
+    /**
+     * Per-cardId keyed responses. A single-value entry is returned on every
+     * call for that cardId (repeated calls always get the same response). An
+     * array-value entry is consumed in order; once exhausted, calls for that
+     * cardId fall back to the FIFO structuredQueue.
+     *
+     * This is the substrate Plan 07's 17-fixture eval matrix uses to wire
+     * deterministic responses to specific LLM cards.
+     */
+    private readonly keyedResponses;
     constructor(args?: {
         completeResponses?: FakeCompletionResponse[];
         structuredResponses?: FakeStructuredResponse[];
+        /**
+         * Optional keyed-response map. Keys are `cardId` values from
+         * `args.context.cardId`. When a call matches a key the keyed entry is
+         * used instead of the FIFO queue.
+         *
+         * - Single-value entry: same response on every call for this cardId.
+         * - Array-value entry: entries consumed in insertion order; falls back
+         *   to FIFO (or throws) when the array is exhausted.
+         */
+        keyedResponses?: Record<string, FakeStructuredResponse | FakeStructuredResponse[]>;
     });
     complete(args: LLMCompleteArgs): Promise<LLMCompletion>;
     completeStructured<T>(args: LLMCompleteStructuredArgs<T>): Promise<LLMStructuredCompletion<T>>;

package/dist/adapters/llm/fake-llm-client.js

@@ -11,9 +11,25 @@ export class FakeLLMClient {
     calls = [];
     completeQueue;
     structuredQueue;
+    /**
+     * Per-cardId keyed responses. A single-value entry is returned on every
+     * call for that cardId (repeated calls always get the same response). An
+     * array-value entry is consumed in order; once exhausted, calls for that
+     * cardId fall back to the FIFO structuredQueue.
+     *
+     * This is the substrate Plan 07's 17-fixture eval matrix uses to wire
+     * deterministic responses to specific LLM cards.
+     */
+    keyedResponses;
     constructor(args = {}) {
         this.completeQueue = [...(args.completeResponses ?? [])];
         this.structuredQueue = [...(args.structuredResponses ?? [])];
+        // Deep-copy arrays so the caller's fixture data is not mutated.
+        const keyed = {};
+        for (const [key, val] of Object.entries(args.keyedResponses ?? {})) {
+            keyed[key] = Array.isArray(val) ? [...val] : val;
+        }
+        this.keyedResponses = keyed;
     }
     async complete(args) {
         this.calls.push({
@@ -37,13 +53,34 @@ export class FakeLLMClient {
         };
     }
     async completeStructured(args) {
+        // Record every call first so test assertions on this.calls are never
+        // affected by which branch (keyed vs FIFO) handles the response.
         this.calls.push({
             kind: "completeStructured",
             model: args.model,
             prompt: args.prompt,
             ...(args.context ? { context: args.context } : {}),
         });
-        const next = this.structuredQueue.shift();
+        let next;
+        const cardId = args.context?.cardId;
+        if (cardId !== undefined && cardId in this.keyedResponses) {
+            const entry = this.keyedResponses[cardId];
+            if (Array.isArray(entry)) {
+                // Array-value: consume one entry per call. When exhausted, fall
+                // through to the FIFO queue below.
+                if (entry.length > 0) {
+                    next = entry.shift();
+                }
+            }
+            else {
+                // Single-value: return the same response on every call.
+                next = entry;
+            }
+        }
+        if (next === undefined) {
+            // FIFO fallback (existing behavior)
+            next = this.structuredQueue.shift();
+        }
         if (!next) {
             throw new Error("FakeLLMClient: no more queued structured responses (call exceeded queue)");
         }

package/dist/adapters/llm/index.d.ts

@@ -5,5 +5,5 @@ export type { FakeCallRecord, FakeCompletionResponse, FakeStructuredResponse, }
 export { OpenAILLMClient } from "./openai-llm-client.js";
 export type { OpenAILLMClientOptions } from "./openai-llm-client.js";
 export type { ModelPricing } from "./pricing.js";
-export { DEFAULT_RETRY_POLICY, LLMHttpError, isRetryableStatus, parseRetryAfterSeconds, runWithRetry, } from "./retry.js";
+export { DEFAULT_RETRY_POLICY, LLMHttpError, LLMParseError, isRetryableStatus, parseRetryAfterSeconds, runWithRetry, } from "./retry.js";
 export type { RetryPolicy } from "./retry.js";

package/dist/adapters/llm/index.js

@@ -1,4 +1,4 @@
 export { AnthropicLLMClient } from "./anthropic-llm-client.js";
 export { FakeLLMClient } from "./fake-llm-client.js";
 export { OpenAILLMClient } from "./openai-llm-client.js";
-export { DEFAULT_RETRY_POLICY, LLMHttpError, isRetryableStatus, parseRetryAfterSeconds, runWithRetry, } from "./retry.js";
+export { DEFAULT_RETRY_POLICY, LLMHttpError, LLMParseError, isRetryableStatus, parseRetryAfterSeconds, runWithRetry, } from "./retry.js";

package/dist/adapters/llm/openai-llm-client.js

@@ -10,8 +10,9 @@
  * the adapter never reads `process.env`. The composition root maps env vars
  * to typed constructor args.
  */
+import { z } from "zod";
 import { OpenAIChatResponseSchema, splitModelId, } from "../../_vendor/ailf-core/index.js";
-import { DEFAULT_RETRY_POLICY, parseRetryAfterSeconds, runWithRetry, } from "./retry.js";
+import { DEFAULT_RETRY_POLICY, LLMParseError, parseRetryAfterSeconds, runWithRetry, } from "./retry.js";
 const DEFAULT_BASE_URL = "https://api.openai.com/v1/chat/completions";
 /**
  * Conservative defaults for the models in `packages/eval/config/models.ts`.
@@ -67,10 +68,25 @@ export class OpenAILLMClient {
     }
     async completeStructured(args) {
         const { modelName } = splitModelId(args.model);
+        // Derive the JSON Schema from the caller's Zod schema. Zod v4 natively
+        // emits `additionalProperties: false` on every nested z.object node —
+        // this is required for OpenAI strict-mode.
+        const jsonSchema = z.toJSONSchema(args.schema, { target: "draft-2020-12" });
+        // OpenAI strict-mode requires the root to be a plain object schema (no
+        // anyOf/oneOf/allOf at the top level). Discriminated unions produce
+        // anyOf at the root — callers must wrap them in a discriminator object.
+        assertSchemaIsObjectRoot(jsonSchema, args.model);
         const body = buildBody(modelName, args.prompt, {
-            temperature: args.temperature,
-            maxTokens: args.maxTokens,
-            responseFormat: { type: "json_object" },
+            temperature: args.temperature ?? 0.1,
+            maxTokens: args.maxTokens ?? 2000,
+            responseFormat: {
+                type: "json_schema",
+                json_schema: {
+                    name: args.context?.cardId ?? "structured_output",
+                    schema: jsonSchema,
+                    strict: true,
+                },
+            },
         });
         const data = await this.callApi(body);
         const raw = data.choices?.[0]?.message?.content;
@@ -82,8 +98,16 @@ export class OpenAILLMClient {
             parsed = JSON.parse(raw);
         }
         catch (err) {
-            throw new Error(`OpenAI structured completion returned invalid JSON for model ${args.model}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+            // Sanitize: SyntaxError.message embeds a snippet at the failure offset,
+            // which can leak prompt text or user content echoed back by the model.
+            // Keep the raw body on the instance for callers that opt in via .raw,
+            // mirroring the LLMHttpError pattern (verified by the "does not leak
+            // the response body" test in openai-llm-client.test.ts).
+            throw new LLMParseError(`OpenAI structured completion returned invalid JSON for model ${args.model}`, raw, { cause: err });
         }
+        // strict:true guarantees a valid-against-the-schema JSON document, but
+        // the Zod parse is still load-bearing — it brands the result as T and is
+        // the only contract the engine trusts (D0045 parse-don't-validate).
         const value = args.schema.parse(parsed);
         const usage = extractUsage(data.usage);
         const cost = this.computeCost(modelName, usage);
@@ -145,6 +169,36 @@ export class OpenAILLMClient {
             `cost_usd=${cost.toFixed(6)}`);
     }
 }
+/**
+ * Assert that the JSON Schema root is a plain object type.
+ *
+ * OpenAI strict-mode requires the root schema to be `{ type: "object" }`.
+ * A discriminated union (`z.union([...])`) produces `{ anyOf: [...] }` at
+ * the root — callers must wrap the union in a discriminator object before
+ * passing it to `completeStructured`.
+ *
+ * Per AI-SPEC §3 Pitfall 6 + T-05-03-01: caught at request-build time to
+ * avoid wasting API budget on a guaranteed 400.
+ */
+function assertSchemaIsObjectRoot(schema, modelId) {
+    if (typeof schema !== "object" || schema === null) {
+        throw new Error(`OpenAILLMClient: OpenAI strict-mode requires a single z.object at the ` +
+            `schema root for model ${modelId}; got non-object JSON Schema root.`);
+    }
+    const node = schema;
+    if (node.type !== "object") {
+        // Identify the kind so the error message is actionable.
+        const kind = "anyOf" in node
+            ? "z.union"
+            : "oneOf" in node
+                ? "z.discriminatedUnion"
+                : "allOf" in node
+                    ? "z.intersection"
+                    : String(node.type ?? "unknown");
+        throw new Error(`OpenAILLMClient: OpenAI strict-mode requires a single z.object at the ` +
+            `schema root; got ${kind}. Wrap the union in a discriminator object.`);
+    }
+}
 function buildBody(modelName, prompt, opts) {
     const body = {
         model: modelName,

package/dist/adapters/llm/retry.d.ts

@@ -33,6 +33,24 @@ export declare class LLMHttpError extends Error {
     readonly body: string;
     constructor(status: number, body: string, attempts: number);
 }
+/**
+ * Sanitized error raised when an LLM adapter receives an HTTP-200 response
+ * whose body is not valid JSON. The raw response body (which may echo back
+ * user prompt content or even API-key fragments from prompts) is kept on the
+ * instance for callers that opt in via `.raw`, NOT in the message string.
+ *
+ * Mirrors the LLMHttpError pattern verified by the
+ * "does not leak the response body" test in openai-llm-client.test.ts.
+ */
+export declare class LLMParseError extends Error {
+    /** Full raw response body (kept on the instance, NOT in `message`). */
+    readonly raw: string;
+    /** Byte length of `raw` — safe to include in the message. */
+    readonly rawLength: number;
+    constructor(message: string, raw: string, options?: {
+        cause?: unknown;
+    });
+}
 export declare function isRetryableStatus(status: number): boolean;
 export interface RunWithRetryArgs<T> {
     policy: RetryPolicy;

package/dist/adapters/llm/retry.js

@@ -29,6 +29,27 @@ export class LLMHttpError extends Error {
         this.body = body;
     }
 }
+/**
+ * Sanitized error raised when an LLM adapter receives an HTTP-200 response
+ * whose body is not valid JSON. The raw response body (which may echo back
+ * user prompt content or even API-key fragments from prompts) is kept on the
+ * instance for callers that opt in via `.raw`, NOT in the message string.
+ *
+ * Mirrors the LLMHttpError pattern verified by the
+ * "does not leak the response body" test in openai-llm-client.test.ts.
+ */
+export class LLMParseError extends Error {
+    /** Full raw response body (kept on the instance, NOT in `message`). */
+    raw;
+    /** Byte length of `raw` — safe to include in the message. */
+    rawLength;
+    constructor(message, raw, options) {
+        super(`${message} (raw=${raw.length}B)`, options);
+        this.name = "LLMParseError";
+        this.raw = raw;
+        this.rawLength = raw.length;
+    }
+}
 export function isRetryableStatus(status) {
     return status === 429 || (status >= 500 && status < 600);
 }

package/dist/adapters/synthesis/synthesis-telemetry-schema.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Zod adapter schema for SynthesisCostTelemetry at the trust boundary.
+ *
+ * This schema sits at `packages/eval/src/adapters/**` and is therefore
+ * scanned by `pnpm check-trust-boundary-satisfies` (D0045). The
+ * `satisfies z.ZodType<SynthesisCostTelemetry>` clause makes schema/type
+ * drift a build error, not a runtime bug.
+ *
+ * Used by:
+ * - Plan 06-04 `ReportStore.patchSynthesis` — validates telemetry before
+ *   writing to Sanity (process memory → Sanity write boundary, T-06-04).
+ * - Any future Sanity-side reader of `summary.synthesis.diagnosis.*`
+ *   (Sanity Content Lake → eval process boundary, T-06-04).
+ *
+ * Security constraints:
+ * - No `.passthrough()` — schema is closed to prevent PII leakage from
+ *   card body text into the telemetry shape (T-06-05).
+ * - Satisfies clause is load-bearing (T-06-06); no exemption marker.
+ *
+ * @see packages/core/src/types/synthesis-telemetry.ts — independently authored domain types
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @see .planning/phases/06-post-run-integration-cost-telemetry/06-CONTEXT.md §D6-09
+ */
+import { z } from "zod";
+export declare const SynthesisCostTelemetrySchema: z.ZodObject<{
+    cost: z.ZodNumber;
+    parseFailureCount: z.ZodNumber;
+    parseFailureRate: z.ZodNumber;
+    perCard: z.ZodArray<z.ZodObject<{
+        cardType: z.ZodEnum<{
+            "area-summary": "area-summary";
+            "failure-mode-summary": "failure-mode-summary";
+            "no-issues": "no-issues";
+            "top-recommendations": "top-recommendations";
+            "weakest-area": "weakest-area";
+            "low-confidence-attribution": "low-confidence-attribution";
+            "doc-attribution-spotlight": "doc-attribution-spotlight";
+            "regression-vs-baseline": "regression-vs-baseline";
+        }>;
+        cost: z.ZodOptional<z.ZodNumber>;
+        parseFailed: z.ZodBoolean;
+        latencyMs: z.ZodOptional<z.ZodNumber>;
+        tokenInput: z.ZodOptional<z.ZodNumber>;
+        tokenOutput: z.ZodOptional<z.ZodNumber>;
+        cardVersion: z.ZodString;
+        generatedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type { SynthesisCostTelemetry, SynthesisPerCardTelemetry, } from "../../_vendor/ailf-core/index.d.ts";

package/dist/adapters/synthesis/synthesis-telemetry-schema.js

@@ -0,0 +1,55 @@
+/**
+ * Zod adapter schema for SynthesisCostTelemetry at the trust boundary.
+ *
+ * This schema sits at `packages/eval/src/adapters/**` and is therefore
+ * scanned by `pnpm check-trust-boundary-satisfies` (D0045). The
+ * `satisfies z.ZodType<SynthesisCostTelemetry>` clause makes schema/type
+ * drift a build error, not a runtime bug.
+ *
+ * Used by:
+ * - Plan 06-04 `ReportStore.patchSynthesis` — validates telemetry before
+ *   writing to Sanity (process memory → Sanity write boundary, T-06-04).
+ * - Any future Sanity-side reader of `summary.synthesis.diagnosis.*`
+ *   (Sanity Content Lake → eval process boundary, T-06-04).
+ *
+ * Security constraints:
+ * - No `.passthrough()` — schema is closed to prevent PII leakage from
+ *   card body text into the telemetry shape (T-06-05).
+ * - Satisfies clause is load-bearing (T-06-06); no exemption marker.
+ *
+ * @see packages/core/src/types/synthesis-telemetry.ts — independently authored domain types
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @see .planning/phases/06-post-run-integration-cost-telemetry/06-CONTEXT.md §D6-09
+ */
+import { z } from "zod";
+/**
+ * Enum of all valid card types — mirrors `CardType` from diagnosis.ts.
+ * Using `z.enum()` (not `z.string()`) so the schema satisfies
+ * `z.ZodType<SynthesisPerCardTelemetry>` (which requires `cardType: CardType`).
+ */
+const CardTypeSchema = z.enum([
+    "area-summary",
+    "failure-mode-summary",
+    "no-issues",
+    "top-recommendations",
+    "weakest-area",
+    "low-confidence-attribution",
+    "doc-attribution-spotlight",
+    "regression-vs-baseline",
+]);
+const SynthesisPerCardSchema = z.object({
+    cardType: CardTypeSchema,
+    cost: z.number().nonnegative().optional(),
+    parseFailed: z.boolean(),
+    latencyMs: z.number().int().nonnegative().optional(),
+    tokenInput: z.number().int().nonnegative().optional(),
+    tokenOutput: z.number().int().nonnegative().optional(),
+    cardVersion: z.string(),
+    generatedAt: z.string().datetime({ offset: false }), // ISO 8601 UTC required
+});
+export const SynthesisCostTelemetrySchema = z.object({
+    cost: z.number().nonnegative(),
+    parseFailureCount: z.number().int().nonnegative(),
+    parseFailureRate: z.number().min(0).max(1),
+    perCard: z.array(SynthesisPerCardSchema),
+});

package/dist/adapters/task-sources/content-lake-task-source.js

@@ -286,16 +286,21 @@ function mapAssertions(raw) {
                     .map((c) => ({ id: c.id, text: c.text })),
                 template: a.template,
                 type: "llm-rubric",
-                ...(a.weight !== undefined ? { weight: a.weight } : {}),
+                // Use `!= null` (loose) so we drop both `undefined` AND `null`.
+                // GROQ projects missing scalar fields as `null`, but the domain
+                // schema's `z.number().optional()` accepts `T | undefined`, not
+                // `T | null` — a strict `!== undefined` check would forward
+                // `weight: null` and trigger Zod's "Invalid input" on assertions.
+                ...(a.weight != null ? { weight: a.weight } : {}),
             };
         }
-        // Value-based assertion
+        // Value-based assertion — same null-vs-undefined hazard as above.
         const result = { type: a.type };
-        if (a.value !== undefined)
+        if (a.value != null)
             result.value = a.value;
-        if (a.threshold !== undefined)
+        if (a.threshold != null)
             result.threshold = a.threshold;
-        if (a.weight !== undefined)
+        if (a.weight != null)
             result.weight = a.weight;
         return result;
     });

package/dist/adapters/task-sources/repo-schemas.d.ts

@@ -1561,6 +1561,13 @@ export declare const RepoConfigSchema: z.ZodObject<{
         dir: z.ZodOptional<z.ZodString>;
         exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
+    summary: z.ZodOptional<z.ZodObject<{
+        onRun: z.ZodOptional<z.ZodEnum<{
+            never: "never";
+            always: "always";
+            auto: "auto";
+        }>>;
+    }, z.core.$strip>>;
     taskSource: z.ZodOptional<z.ZodObject<{
         type: z.ZodOptional<z.ZodEnum<{
             "content-lake": "content-lake";

package/dist/adapters/task-sources/repo-schemas.js

@@ -646,6 +646,15 @@ const OwnerConfigSchema = z
     individual: z.string().min(1).optional(),
 })
     .optional();
+/**
+ * Post-run diagnosis summary policy (Phase 6 / DIAG-06).
+ * Sits in the W0077 Phase-6a auto-load pathway.
+ */
+const SummaryConfigSchema = z
+    .object({
+    onRun: z.enum(["auto", "always", "never"]).optional(),
+})
+    .optional();
 /**
  * Agentic-mode configuration (W0077 Phase 6f). Replaces the retired
  * `--header` and `--allowed-origin` CLI flags. `headers` is a key/value
@@ -694,6 +703,7 @@ export const RepoConfigSchema = z.object({
     owner: OwnerConfigSchema,
     agentic: AgenticConfigSchema,
     artifacts: ArtifactsConfigSchema,
+    summary: SummaryConfigSchema,
     taskSource: TaskSourceConfigSchema,
     triggers: z
         .object({

package/dist/cli-program.js

@@ -32,6 +32,7 @@ import { createFetchDocsCommand } from "./commands/fetch-docs.js";
 import { createGenerateConfigsCommand } from "./commands/generate-configs.js";
 import { createGraderCommand } from "./commands/grader/index.js";
 import { createInitCommand } from "./commands/init.js";
+import { createInterpretCommand } from "./commands/interpret.js";
 import { createInteractiveCommand } from "./commands/interactive.js";
 import { createLookupDocCommand } from "./commands/lookup-doc.js";
 import { createMeasureRetrievalCommand } from "./commands/measure-retrieval.js";
@@ -110,6 +111,8 @@ export function buildCliProgram(opts) {
         .addCommand(createWeeklyDigestCommand())
         .addCommand(createCheckStalenessCommand());
     program.addCommand(reportCommand.helpGroup(CommandGroup.AnalysisReports));
+    // `ailf interpret <reportId>` — top-level (not nested under report) per AI-SPEC
+    program.addCommand(createInterpretCommand().helpGroup(CommandGroup.AnalysisReports));
     // ── Grader Reliability ────────────────────────────────────────────────
     program.addCommand(createGraderCommand().helpGroup(CommandGroup.GraderReliability));
     // ── Setup & Configuration ─────────────────────────────────────────────

package/dist/commands/interpret.d.ts

@@ -0,0 +1,70 @@
+/**
+ * interpret command — generate a Diagnosis for a Report.
+ *
+ * Wraps `getDiagnosisRunner(ctx)` from the composition root in a Commander
+ * command for consistent CLI integration. Closest analog: compare.ts.
+ *
+ * Entry points:
+ *   ailf interpret <reportId>          — one-line-per-card summary
+ *   ailf interpret <reportId> --json   — full Diagnosis JSON
+ *   ailf interpret latest              — most recent report
+ *   ailf interpret <id> --compare <ref>  — DIAG-05 regression comparison
+ *   ailf interpret <id> --refresh      — bypass version-keyed cache
+ *
+ * @see packages/eval/src/commands/compare.ts — CLI factory analog
+ * @see packages/eval/src/composition-root.ts — getDiagnosisRunner
+ * @see .planning/phases/05-diagnosis-engine-cli-llm-cards/05-AI-SPEC.md §6
+ */
+import { Command } from "commander";
+import { type DiagnosisCard, type DiagnosisRunner, type VersionedInputs } from "../_vendor/ailf-core/index.d.ts";
+interface MinimalReportStore {
+    read(id: string): Promise<unknown | null>;
+    latest(): Promise<unknown | null>;
+}
+export interface InterpretCommandOptions {
+    /**
+     * Override the runner factory for tests. When omitted, the command
+     * imports `getDiagnosisRunner` from the composition root at action time.
+     */
+    readonly runnerFactory?: (ctx: unknown) => DiagnosisRunner;
+    /**
+     * Override the store factory for tests. When omitted, the command
+     * creates the app context and uses `ctx.reportStore` at action time.
+     */
+    readonly storeFactory?: () => MinimalReportStore | null;
+    /**
+     * Override the versions resolver for tests. Receives the stored report
+     * record and returns the `VersionedInputs` needed by the runner.
+     * When omitted, the command derives versions from the report's metadata.
+     */
+    readonly versionsFromReport?: (report: unknown) => VersionedInputs;
+}
+/**
+ * Visual status markers — locked visual contract per plan Test 7:
+ * ready: "✓", degraded: "⚠", missing: "—"
+ *
+ * Exported so Plan 06-04's post-run hook imports the SAME object and
+ * D6-04's "single formatter, single visual contract" is physically
+ * enforced — no copy/paste drift possible.
+ */
+export declare const STATUS_ICONS: Record<DiagnosisCard["status"], string>;
+/**
+ * Format a single card as a one-line summary string.
+ *
+ * Format: `<icon> <cardType>: <summary>`
+ * Per AI-SPEC §6: distinct icons for ready / degraded / missing.
+ *
+ * Exported so Plan 06-04's post-run hook imports the SAME function and
+ * D6-04's "single formatter, single visual contract" is physically
+ * enforced — no copy/paste drift possible.
+ */
+export declare function formatCardSummaryLine(card: DiagnosisCard): string;
+/**
+ * Create the `ailf interpret <reportId>` Commander command.
+ *
+ * Accepts optional `InterpretCommandOptions` for testability — tests can
+ * inject a fake runner factory and store factory without touching module
+ * mocks (preferred per testing.md).
+ */
+export declare function createInterpretCommand(options?: InterpretCommandOptions): Command;
+export {};