@sanity/ailf 5.0.0 → 6.1.0

package/dist/commands/interpret.js

@@ -0,0 +1,221 @@
+/**
+ * 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 { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+import { CARD_REGISTRY_VERSION, diagnosisVersion, } from "../_vendor/ailf-core/index.js";
+import { addOutputDirOption } from "./shared/options.js";
+import { resolveOutputDir } from "./shared/resolve-output-dir.js";
+// ---------------------------------------------------------------------------
+// Module-level root constant (same pattern as compare.ts)
+// ---------------------------------------------------------------------------
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, "..", "..");
+// ---------------------------------------------------------------------------
+// Card output formatting (AI-SPEC §6 graceful-degradation-visibility)
+// ---------------------------------------------------------------------------
+/**
+ * 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 const STATUS_ICONS = {
+    ready: "✓",
+    degraded: "⚠",
+    missing: "—",
+};
+function getCardSummaryText(card) {
+    if (card.status === "ready") {
+        return card.body.summary;
+    }
+    if (card.status === "degraded") {
+        return card.reason;
+    }
+    // missing
+    return card.reason;
+}
+/**
+ * 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 function formatCardSummaryLine(card) {
+    const icon = STATUS_ICONS[card.status];
+    const text = getCardSummaryText(card);
+    return `${icon} ${card.cardType}: ${text}`;
+}
+// ---------------------------------------------------------------------------
+// Default versions resolver
+// ---------------------------------------------------------------------------
+/**
+ * Derive VersionedInputs from a stored report record.
+ *
+ * The four-version chain is carried in `report.summary.versions` per the
+ * Phase 5 schema, with `diagnosisVersion` sourced from the runner's const.
+ * Falls back to hard-coded "unknown" values when the fields are not present
+ * (legacy reports without version metadata).
+ */
+function defaultVersionsFromReport(report) {
+    const rec = report;
+    const summary = rec.summary;
+    const versions = summary?.versions;
+    return {
+        graderJudgmentsVersion: typeof versions?.graderJudgmentsVersion === "string"
+            ? versions.graderJudgmentsVersion
+            : "unknown",
+        ensembleVersion: typeof versions?.ensembleVersion === "string"
+            ? versions.ensembleVersion
+            : "unknown",
+        diagnosisVersion: typeof versions?.diagnosisVersion === "string"
+            ? versions.diagnosisVersion
+            : diagnosisVersion,
+        cardVersion: typeof versions?.cardVersion === "string"
+            ? versions.cardVersion
+            : CARD_REGISTRY_VERSION,
+    };
+}
+// ---------------------------------------------------------------------------
+// Command factory
+// ---------------------------------------------------------------------------
+/**
+ * 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 function createInterpretCommand(options = {}) {
+    const { runnerFactory, storeFactory, versionsFromReport } = options;
+    const cmd = new Command("interpret")
+        .description("Generate a Diagnosis for a Report — 8 typed cards explaining what's weak and what to do")
+        .argument("<reportId>", "Report ID (or 'latest' for the most recent)")
+        .option("-c, --compare <ref>", "Baseline report ID for regression-vs-baseline comparison")
+        .option("--refresh", "Bypass the version-keyed cache and recompute")
+        .option("--json", "Print full Diagnosis JSON instead of one-line-per-card summary")
+        .action(async (reportId, opts) => {
+        const outputDir = resolveOutputDir(opts.outputDir);
+        // ---------------------------------------------------------------------------
+        // Resolve store: injected factory (tests) or composition root (production)
+        // ---------------------------------------------------------------------------
+        let store;
+        let ctx;
+        if (storeFactory) {
+            store = storeFactory();
+            ctx = null;
+        }
+        else {
+            // Production path — lazy import to keep the module fast in tests
+            // Minimal config: report-read-only, no eval/fetch/publish.
+            const { createAppContext } = await import("../composition-root.js");
+            ctx = createAppContext({
+                compareEnabled: false,
+                gapAnalysisEnabled: false,
+                mode: "literacy",
+                noAutoScope: false,
+                noCache: true,
+                noRemoteCache: true,
+                outputDir,
+                publishEnabled: false,
+                rootDir: ROOT,
+                searchMode: "open",
+                skipEval: true,
+                skipFetch: true,
+                remote: false,
+                apiUrl: "https://ailf-api.sanity.build",
+            });
+            const prodCtx = ctx;
+            store = prodCtx.reportStore;
+        }
+        if (!store) {
+            process.stderr.write("Error: report store is not available\n");
+            process.exit(1);
+        }
+        // ---------------------------------------------------------------------------
+        // Resolve main report
+        // ---------------------------------------------------------------------------
+        const report = reportId === "latest"
+            ? await store.latest()
+            : await store.read(reportId);
+        if (!report) {
+            process.stderr.write(`Error: report not found: ${reportId}\n`);
+            process.exit(1);
+        }
+        // ---------------------------------------------------------------------------
+        // Optionally resolve baseline (DIAG-05)
+        // ---------------------------------------------------------------------------
+        let baseline;
+        if (opts.compare) {
+            baseline = await store.read(opts.compare);
+            if (!baseline) {
+                process.stderr.write(`Error: baseline report not found: ${opts.compare}\n`);
+                process.exit(1);
+            }
+        }
+        // ---------------------------------------------------------------------------
+        // Resolve versions
+        // ---------------------------------------------------------------------------
+        const versions = versionsFromReport
+            ? versionsFromReport(report)
+            : defaultVersionsFromReport(report);
+        // ---------------------------------------------------------------------------
+        // Build runner
+        // ---------------------------------------------------------------------------
+        let runner;
+        if (runnerFactory) {
+            runner = runnerFactory(ctx);
+        }
+        else {
+            const { getDiagnosisRunner } = await import("../composition-root.js");
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            runner = getDiagnosisRunner(ctx);
+        }
+        // ---------------------------------------------------------------------------
+        // Run diagnosis
+        // ---------------------------------------------------------------------------
+        const diagnosis = await runner.run({
+            // The report here is the eval's ReportStore record, which satisfies
+            // the Report interface for runner.run purposes (both carry id + provenance.runId).
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            report: report,
+            versions,
+            ...(baseline ? { baseline: baseline } : {}),
+            refresh: opts.refresh ?? false,
+        });
+        // ---------------------------------------------------------------------------
+        // Print output
+        // ---------------------------------------------------------------------------
+        if (opts.json) {
+            process.stdout.write(`${JSON.stringify(diagnosis, null, 2)}\n`);
+        }
+        else {
+            for (const card of diagnosis.cards) {
+                process.stdout.write(`${formatCardSummaryLine(card)}\n`);
+            }
+        }
+    });
+    addOutputDirOption(cmd);
+    return cmd;
+}

package/dist/commands/pipeline-action.d.ts

@@ -12,6 +12,7 @@
  */
 import { type ImpactSummary } from "../pipeline/reverse-mapping.js";
 import type { DebugOptions, EvalMode } from "../pipeline/types.js";
+import { type Diagnosis, type ReportStorePort, type SynthesisCostTelemetry } from "../_vendor/ailf-core/index.d.ts";
 import type { PipelineCliOptions } from "./run.js";
 export interface ResolvedOptions {
     allowedOriginArgs: string[];
@@ -63,6 +64,12 @@ export interface ResolvedOptions {
     studioOriginOverride?: string;
     remote: boolean;
     repoTasksPath?: string;
+    /** Phase 6 / DIAG-06: post-run diagnosis summary policy. Precedence
+     * resolution (CLI flag > env > config > auto) lives in
+     * shouldRunPostSummary() — this field carries only the config-file
+     * signal so the helper has a single typed input.
+     */
+    summaryOnRun?: "auto" | "always" | "never";
     taskOption?: string;
     tagOption?: string[];
     taskSourceType?: "content-lake" | "repo";
@@ -88,6 +95,43 @@ export interface ResolvedOptions {
  * Exported so the plan builder can call it independently.
  */
 export declare function computeResolvedOptions(opts: PipelineCliOptions): ResolvedOptions;
+/**
+ * Determine whether the post-run diagnosis summary hook should fire.
+ *
+ * 4-level precedence chain (D6-20):
+ *   Level 1 — CLI flag (absolute): if `cliOpts.summary` is boolean, use it.
+ *   Level 2 — AILF_INTERPRET_ON_RUN env var (absolute): strict "1"/"0" parse;
+ *             anything else falls through (T-06-11 spoofing mitigation).
+ *   Level 3 — config `summary.onRun` (absolute): "always" → true; "never" → false;
+ *             "auto" or absent falls through to level 4.
+ *   Level 4 — default auto: TTY && !CI (SC1 default-off in CI).
+ */
+export declare function shouldRunPostSummary(cliOpts: PipelineCliOptions, resolvedOnRun: "auto" | "always" | "never" | undefined): boolean;
+export declare function buildSynthesisTelemetry(diagnosis: Diagnosis): SynthesisCostTelemetry;
+/**
+ * Run post-pipeline hooks after the pipeline completes.
+ *
+ * Fires after orchestratePipeline() + writePipelineResult() (D6-02).
+ * Hook failure prints to stderr but does NOT change exit code (D6-03).
+ * CI default-off: fires only when shouldRunPostSummary returns true (D6-20).
+ *
+ * @param ctx - App context (composition root wiring)
+ * @param result - Pipeline result (includes reportId when published)
+ * @param args - Hook options (cliOpts, summaryOnRun from config, optional runnerFactory for tests)
+ */
+export declare function runPostPipelineHooks(ctx: {
+    reportStore?: ReportStorePort;
+}, result: {
+    success: boolean;
+    reportId?: string;
+}, args: {
+    cliOpts: PipelineCliOptions;
+    summaryOnRun?: "auto" | "always" | "never";
+    /** Override runner factory for tests — avoids vi.mock of composition root */
+    runnerFactory?: (ctx: unknown) => {
+        run(opts: unknown): Promise<Diagnosis>;
+    };
+}): Promise<void>;
 /**
  * Execute the evaluation pipeline.
  *

package/dist/commands/pipeline-action.js

@@ -20,9 +20,13 @@ import { buildAppContext, parseArtifactUploadEnv, } from "../orchestration/build
 import { buildStepSequence } from "../orchestration/build-step-sequence.js";
 import { orchestratePipeline } from "../orchestration/pipeline-orchestrator.js";
 import { load } from "js-yaml";
-import { PLACEHOLDER_OWNER_TEAM } from "../_vendor/ailf-core/index.js";
+import { PLACEHOLDER_OWNER_TEAM, } from "../_vendor/ailf-core/index.js";
 import { parseRepoConfig, } from "../adapters/task-sources/repo-schemas.js";
 import { getCallerCwd, resolveOutputDir } from "./shared/resolve-output-dir.js";
+// Phase 6 / DIAG-06 — single formatter, single visual contract (D6-04).
+// Import statically so bundlers and type-checkers can verify the export
+// exists at build time rather than deferring to runtime dynamic import.
+import { formatCardSummaryLine } from "./interpret.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = resolve(__dirname, "..", "..");
 // ---------------------------------------------------------------------------
@@ -250,6 +254,10 @@ export function computeResolvedOptions(opts) {
     const graderReplications = repoConfig?.execution?.graderReplications;
     const borderlineReplications = repoConfig?.execution?.borderlineReplications;
     const gapAnalysisEnabled = repoConfig?.execution?.gapAnalysis ?? true;
+    // Phase 6 / DIAG-06 — post-run diagnosis summary policy from .ailf/config.yaml.
+    // Precedence resolution (CLI flag > env > config > auto) lives in
+    // shouldRunPostSummary(); this only carries the config-file signal.
+    const summaryOnRun = repoConfig?.summary?.onRun;
     // Grader context policy. Cascade: env var > .ailf/config.yaml > unset
     // (defaults to rubric-only at the EvalConfig boundary). The env var is the
     // operational lever for one-shot comparison runs without editing the config file.
@@ -348,6 +356,7 @@ export function computeResolvedOptions(opts) {
             undefined,
         purposeOption: opts.purpose?.trim() || undefined,
         labelOptions: opts.label ?? [],
+        summaryOnRun,
     };
 }
 const PUBLISH_AUTO_VALUES = ["always", "full-runs", "never"];
@@ -373,6 +382,179 @@ function resolvePublishAuto(repoValue) {
     }
     return "full-runs";
 }
+// ---------------------------------------------------------------------------
+// Phase 6 / DIAG-06 — post-run diagnosis summary helpers
+// ---------------------------------------------------------------------------
+/**
+ * Determine whether the post-run diagnosis summary hook should fire.
+ *
+ * 4-level precedence chain (D6-20):
+ *   Level 1 — CLI flag (absolute): if `cliOpts.summary` is boolean, use it.
+ *   Level 2 — AILF_INTERPRET_ON_RUN env var (absolute): strict "1"/"0" parse;
+ *             anything else falls through (T-06-11 spoofing mitigation).
+ *   Level 3 — config `summary.onRun` (absolute): "always" → true; "never" → false;
+ *             "auto" or absent falls through to level 4.
+ *   Level 4 — default auto: TTY && !CI (SC1 default-off in CI).
+ */
+export function shouldRunPostSummary(cliOpts, resolvedOnRun) {
+    // Level 1: CLI flag wins absolutely
+    if (cliOpts.summary === true)
+        return true;
+    if (cliOpts.summary === false)
+        return false;
+    // Level 2: AILF_INTERPRET_ON_RUN env var (strict parse)
+    const envVal = process.env.AILF_INTERPRET_ON_RUN;
+    if (envVal === "1")
+        return true;
+    if (envVal === "0")
+        return false;
+    // Anything else (garbage, unset) falls through
+    // Level 3: config summary.onRun
+    if (resolvedOnRun === "always")
+        return true;
+    if (resolvedOnRun === "never")
+        return false;
+    // "auto" or undefined falls through
+    // Level 4: default auto — fire only when stdout is interactive and not in CI
+    return Boolean(process.stdout.isTTY) && process.env.CI !== "true";
+}
+/**
+ * Build a SynthesisCostTelemetry payload from a completed Diagnosis.
+ *
+ * Aggregates:
+ *   - cost: sum of meta.cost across all cards (undefined treated as 0)
+ *   - parseFailureCount: cards where status==="degraded" (parse failures)
+ *   - parseFailureRate: parseFailureCount / total-cards (max 8 per D6-09)
+ *   - perCard: per-card row with safe-extracted structured metadata
+ *
+ * Deliberately does NOT read card.body — only structured meta fields are
+ * persisted (T-06-14 PII guard per threat model).
+ */
+// D6-09: denominator is always the fixed card-registry size, not cards.length.
+// Using cards.length would allow parseFailureRate > 1.0 when the registry is
+// a subset (e.g. test registries), violating the SynthesisCostTelemetrySchema
+// min(0).max(1) constraint. Single edit point if the registry ever grows.
+const CARD_REGISTRY_SIZE = 8;
+export function buildSynthesisTelemetry(diagnosis) {
+    const cards = diagnosis.cards;
+    let totalCost = 0;
+    let parseFailureCount = 0;
+    const perCard = cards.map((card) => {
+        // "missing" cards have no `meta` — narrow with status guard
+        const meta = card.status !== "missing" ? card.meta : undefined;
+        const cost = meta?.cost ?? 0;
+        totalCost += cost;
+        // Parse failures produce status="degraded" (not "missing") in the current
+        // runner (diagnosis-runner.ts). A "missing" card is absence, not failure.
+        // If a future code path can produce status="missing" from a parse failure,
+        // this line must be updated and the parseFailed contract re-evaluated.
+        const parseFailed = card.status === "degraded";
+        if (parseFailed)
+            parseFailureCount++;
+        const row = {
+            cardType: card.cardType,
+            parseFailed,
+            cardVersion: meta?.cardVersion ?? "unknown",
+            generatedAt: meta?.generatedAt ?? new Date().toISOString(),
+        };
+        if (cost > 0)
+            row.cost = cost;
+        if (meta?.latencyMs !== undefined)
+            row.latencyMs = meta.latencyMs;
+        if (meta?.tokenUsage?.input !== undefined)
+            row.tokenInput = meta.tokenUsage.input;
+        if (meta?.tokenUsage?.output !== undefined)
+            row.tokenOutput = meta.tokenUsage.output;
+        return row;
+    });
+    return {
+        cost: totalCost,
+        parseFailureCount,
+        parseFailureRate: parseFailureCount / CARD_REGISTRY_SIZE,
+        perCard,
+    };
+}
+/**
+ * Run post-pipeline hooks after the pipeline completes.
+ *
+ * Fires after orchestratePipeline() + writePipelineResult() (D6-02).
+ * Hook failure prints to stderr but does NOT change exit code (D6-03).
+ * CI default-off: fires only when shouldRunPostSummary returns true (D6-20).
+ *
+ * @param ctx - App context (composition root wiring)
+ * @param result - Pipeline result (includes reportId when published)
+ * @param args - Hook options (cliOpts, summaryOnRun from config, optional runnerFactory for tests)
+ */
+export async function runPostPipelineHooks(ctx, result, args) {
+    if (!shouldRunPostSummary(args.cliOpts, args.summaryOnRun))
+        return;
+    if (!result.reportId) {
+        process.stderr.write("ℹ️ No report published — skipping post-summary.\n");
+        return;
+    }
+    const reportId = result.reportId;
+    try {
+        // Build the runner — use injected factory (tests) or composition root (production)
+        let runner;
+        if (args.runnerFactory) {
+            runner = args.runnerFactory(ctx);
+        }
+        else {
+            const { getDiagnosisRunner } = await import("../composition-root.js");
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            runner = getDiagnosisRunner(ctx);
+        }
+        // Read the stored report — needed by the runner for version metadata
+        const report = await ctx.reportStore?.read(reportId);
+        if (!report) {
+            process.stderr.write(`ℹ️ Report not found: ${reportId} — skipping post-summary.\n`);
+            return;
+        }
+        // Derive version metadata from the stored report (same approach as interpret.ts)
+        const rec = report;
+        const summary = rec.summary;
+        const versions = summary?.versions;
+        const versionedInputs = {
+            graderJudgmentsVersion: typeof versions?.graderJudgmentsVersion === "string"
+                ? versions.graderJudgmentsVersion
+                : "unknown",
+            ensembleVersion: typeof versions?.ensembleVersion === "string"
+                ? versions.ensembleVersion
+                : "unknown",
+            diagnosisVersion: typeof versions?.diagnosisVersion === "string"
+                ? versions.diagnosisVersion
+                : "unknown",
+            cardVersion: typeof versions?.cardVersion === "string"
+                ? versions.cardVersion
+                : "unknown",
+        };
+        // Run the diagnosis
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const diagnosis = await runner.run({
+            report: report,
+            versions: versionedInputs,
+            refresh: false,
+        });
+        // Print per-card summary lines to stdout (D6-04 single formatter)
+        for (const card of diagnosis.cards) {
+            process.stdout.write(`${formatCardSummaryLine(card)}\n`);
+        }
+        // Build and write synthesis telemetry back to the report doc (D6-08)
+        // patchSynthesis is now part of ReportStorePort (CR-01) — guard on store
+        // presence only; absent store means no report store is configured (expected).
+        if (ctx.reportStore) {
+            const telemetry = buildSynthesisTelemetry(diagnosis);
+            await ctx.reportStore.patchSynthesis(reportId, telemetry);
+        }
+        else {
+            process.stderr.write("ℹ️ No reportStore configured — synthesis telemetry not written to Sanity.\n");
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`⚠️ Diagnosis failed: ${msg}. Run \`ailf interpret ${reportId}\` to retry.\n`);
+    }
+}
 /** Resolve and validate the --task-source flag value. */
 function resolveTaskSourceType(raw) {
     if (!raw || raw === "content-lake")
@@ -471,6 +653,11 @@ export async function executePipeline(cliOpts) {
         const steps = buildStepSequence(ctx, pipelineStart);
         const result = await orchestratePipeline(ctx, steps);
         writePipelineResult(result, config.outputDir);
+        // Phase 6 / DIAG-06: post-run hook fires after artifacts are written (D6-02)
+        await runPostPipelineHooks(ctx, result, {
+            cliOpts,
+            summaryOnRun: config.summaryOnRun,
+        });
         process.exit(result.success ? 0 : 1);
     }
     const o = resolveOptions(cliOpts);
@@ -510,6 +697,11 @@ export async function executePipeline(cliOpts) {
     const steps = buildStepSequence(ctx, pipelineStart);
     const result = await orchestratePipeline(ctx, steps);
     writePipelineResult(result, o.outputDir);
+    // Phase 6 / DIAG-06: post-run hook fires after artifacts are written (D6-02)
+    await runPostPipelineHooks(ctx, result, {
+        cliOpts,
+        summaryOnRun: o.summaryOnRun,
+    });
     process.exit(result.success ? 0 : 1);
 }
 // ---------------------------------------------------------------------------

package/dist/commands/run.d.ts

@@ -47,6 +47,8 @@ export interface PipelineCliOptions {
     publish?: boolean;
     publishTag?: string;
     remoteCache?: boolean;
+    /** Phase 6 / DIAG-06: post-run diagnosis summary toggle. Undefined when neither flag is passed. */
+    summary?: boolean;
     sanityDocument: string[];
     sanityPerspective?: string;
     search?: string;

package/dist/commands/run.js

@@ -43,6 +43,8 @@ export function createRunCommand() {
         .option("-p, --publish", "Write report to Sanity + fan out to sinks (auto-enabled for full runs when report store is configured)")
         .option("--no-publish", "Suppress auto-publishing")
         .option("--publish-tag <tag>", "Label for published report")
+        .option("--summary", "Force post-run diagnosis summary (overrides config and CI default-off)")
+        .option("--no-summary", "Suppress post-run diagnosis summary")
         .option("--config <path>", "Load pipeline config from a TS/JS/YAML/JSON file (overrides most CLI flags)")
         .option("-o, --output <path>", "Write PR comment markdown to file")
         .option("--promptfoo-url <url>", "Promptfoo share URL for report")

package/dist/composition-root.d.ts

@@ -15,7 +15,8 @@
  * @see packages/core/src/ports/context.ts — AppContext interface
  * @see docs/archive/exec-plans/ports-and-adapters/phase-7-composition-root.md
  */
-import { type AppContext, type ArtifactWriter, type ArtifactWriterProgressOptions, type AssertionRegistration, type LLMClient, type Logger, type ResolvedConfig } from "./_vendor/ailf-core/index.d.ts";
+import { type AppContext, type ArtifactWriter, type ArtifactWriterProgressOptions, type AssertionRegistration, type CardRegistry, type DiagnosisRunner, type Logger, type ResolvedConfig } from "./_vendor/ailf-core/index.d.ts";
+export type { LLMClientKeys } from "./_vendor/ailf-core/index.d.ts";
 import { type BorderlineConsensusOptions, type BorderlineConsensusResult } from "./pipeline/borderline-consensus-runner.js";
 import { CompositeTaskSource, ContentLakeTaskSource, RepoTaskSource } from "./adapters/task-sources/index.js";
 /**
@@ -25,28 +26,6 @@ import { CompositeTaskSource, ContentLakeTaskSource, RepoTaskSource } from "./ad
  * Swapping an adapter is a one-line change in this function.
  */
 export declare function createAppContext(config: ResolvedConfig): AppContext;
-/**
- * Typed key bag passed to `createLLMClient`. The composition root reads
- * env once and supplies values here; the factory stays pure so tests don't
- * have to mutate `process.env`.
- */
-export interface LLMClientKeys {
-    anthropicApiKey?: string;
-    openaiApiKey?: string;
-}
-/**
- * Select the LLMClient adapter based on `config.llmProvider` and the
- * supplied API keys. Returns `undefined` when no usable credential is
- * present — `AppContext.llmClient` stays unset and consumers handle that
- * explicitly.
- *
- * Adapters never read `process.env` themselves (per
- * `.claude/rules/typescript.md`); env mapping happens at the call site
- * (typically `createAppContext`).
- *
- * Exported for unit-test access; not part of the public package API.
- */
-export declare function createLLMClient(config: ResolvedConfig, keys: LLMClientKeys, logger: Logger): LLMClient | undefined;
 /**
  * Selects the `ArtifactWriter` wiring per D0033 M4:
  *
@@ -119,3 +98,22 @@ export declare const DEFAULT_BORDERLINE_REPLICATIONS = 3;
 export declare function createBorderlineConsensusRunner(opts: {
     borderlineReplications?: number;
 }): (args: Pick<BorderlineConsensusOptions, "judgments" | "logger" | "regrade">) => Promise<BorderlineConsensusResult>;
+/**
+ * Returns the full 8-card `CardRegistry` backed by `DIAGNOSIS_CARD_GENERATORS`
+ * from `@sanity/ailf-core`. Exposed as a function (not a module-level const)
+ * so the composition root remains the single-seam factory and tests can assert
+ * the call site (AI-SPEC §3 Pitfall 1 — no module-scope mutables).
+ */
+export declare function buildDiagnosisRegistry(): CardRegistry;
+/**
+ * Build a fully-wired `DiagnosisRunner` from an `AppContext`.
+ *
+ * Wires the full 8-card registry, `loadAttributions` bound to the local
+ * filesystem (Phase-4 per-entry attribution objects at
+ * `{artifactsDir}/runs/{runId}/attribution/*.json`), and no-op cache
+ * reader/writer (Plan-06 CLI command will wire the real cache seam).
+ *
+ * Plan-06 API/CLI consumers import this function from the composition root
+ * and pass `ctx` from `createAppContext(config)`.
+ */
+export declare function getDiagnosisRunner(ctx: AppContext): DiagnosisRunner;