@sanity/ailf 7.0.0 → 7.1.0

package/dist/job-store.d.ts

@@ -101,4 +101,22 @@ export declare class JobStore {
      * Update a job's status and optional associated data.
      */
     updateJob(jobId: string, update: Partial<Pick<JobDocument, "completedAt" | "error" | "execution" | "progress" | "reportId" | "startedAt" | "status">>): Promise<boolean>;
+    /**
+     * Patch the parent ailf.evalRequest doc when this job reaches a terminal
+     * state. The webhook handler writes `jobId` onto the evalRequest at
+     * dispatch time, so we look the parent up by that field.
+     *
+     * Best-effort: returns `false` on lookup miss or write failure, never
+     * throws. Closes the S1-B gap from the 2026-05-24 new-eval audit — until
+     * this runs, evalRequest docs stay `status: "dispatched"` indefinitely
+     * and the dashboard can't surface completion or errors to users.
+     *
+     * @returns true on successful patch, false on lookup miss or write error
+     */
+    patchEvalRequestForJob(jobId: string, patch: {
+        status: "completed" | "failed";
+        completedAt: string;
+        reportId?: string;
+        error?: string;
+    }): Promise<boolean>;
 }

package/dist/job-store.js

@@ -149,6 +149,40 @@ export class JobStore {
             return false;
         }
     }
+    /**
+     * Patch the parent ailf.evalRequest doc when this job reaches a terminal
+     * state. The webhook handler writes `jobId` onto the evalRequest at
+     * dispatch time, so we look the parent up by that field.
+     *
+     * Best-effort: returns `false` on lookup miss or write failure, never
+     * throws. Closes the S1-B gap from the 2026-05-24 new-eval audit — until
+     * this runs, evalRequest docs stay `status: "dispatched"` indefinitely
+     * and the dashboard can't surface completion or errors to users.
+     *
+     * @returns true on successful patch, false on lookup miss or write error
+     */
+    async patchEvalRequestForJob(jobId, patch) {
+        try {
+            const evalRequest = await this.client.fetch(`*[_type == "ailf.evalRequest" && jobId == $jobId][0]{_id}`, { jobId });
+            if (!evalRequest?._id) {
+                return false;
+            }
+            await this.client
+                .patch(evalRequest._id)
+                .set({
+                status: patch.status,
+                completedAt: patch.completedAt,
+                ...(patch.reportId ? { reportId: patch.reportId } : {}),
+                ...(patch.error ? { error: patch.error } : {}),
+            })
+                .commit();
+            return true;
+        }
+        catch (error) {
+            console.warn(`  ⚠️  Failed to patch ailf.evalRequest for jobId ${jobId}: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    }
 }
 // ---------------------------------------------------------------------------
 // Helpers

package/dist/orchestration/build-app-context.js

@@ -8,6 +8,7 @@
  * Once all commands construct ResolvedConfig directly (or use --config),
  * this bridge can be deleted.
  */
+import { isLiteracyVariant } from "../_vendor/ailf-shared/index.js";
 import { createAppContext } from "../composition-root.js";
 import { tryLoadConfigFile } from "../pipeline/compiler/config-loader.js";
 /**
@@ -18,10 +19,16 @@ import { tryLoadConfigFile } from "../pipeline/compiler/config-loader.js";
  * are derived (e.g., areas from areaOption).
  */
 export function mapToResolvedConfig(opts, rootDir) {
+    // `opts.variant` is a free-form string from CLI / config flags; narrow it
+    // to the closed `LiteracyVariant` set so downstream consumers (the report
+    // provenance derivation, in particular) never see a bogus string.
+    // Unknown values silently drop to undefined — the legacy behavior — but a
+    // narrowing surface is in place for the day we want to error here.
+    const variant = isLiteracyVariant(opts.variant) ? opts.variant : undefined;
     return {
         rootDir,
         mode: opts.mode,
-        variant: opts.variant,
+        variant,
         noAutoScope: opts.noAutoScope ?? false,
         debug: opts.debug,
         areas: opts.areaOption

package/dist/orchestration/pipeline-orchestrator.js

@@ -69,6 +69,35 @@ async function reportJobProgress(ctx, stepName, completedSteps, totalSteps, stat
         ctx.logger.warn(`Failed to report job progress for step "${stepName}" — continuing`);
     }
 }
+/**
+ * Patch the parent ailf.evalRequest doc when the underlying ailf.job
+ * reaches a terminal state (completed | failed).
+ *
+ * Thin wrapper over `JobStore.patchEvalRequestForJob` that handles client
+ * construction (env-driven token) and the logger callback. Best-effort:
+ * never throws, logs warnings on lookup miss or write failure.
+ *
+ * Closes the S1-B gap from the 2026-05-24 new-eval audit — until this
+ * runs, evalRequest docs stay `status: "dispatched"` indefinitely and
+ * the dashboard can't surface completion or errors to users.
+ */
+async function patchEvalRequestForJob(ctx, jobId, patch) {
+    try {
+        const { JobStore } = await import("../job-store.js");
+        const store = new JobStore({
+            token: process.env.AILF_REPORT_SANITY_API_TOKEN ??
+                process.env.SANITY_API_TOKEN ??
+                undefined,
+        });
+        const patched = await store.patchEvalRequestForJob(jobId, patch);
+        if (!patched) {
+            ctx.logger.debug(`No ailf.evalRequest patched for jobId ${jobId} — lookup miss or write failure`);
+        }
+    }
+    catch (err) {
+        ctx.logger.warn(`Failed to patch ailf.evalRequest for jobId ${jobId}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 // ---------------------------------------------------------------------------
 // Artifact capture
 // ---------------------------------------------------------------------------
@@ -188,6 +217,11 @@ export async function orchestratePipeline(ctx, steps) {
                     message: failedError,
                     step: step.name,
                 }, jobUpdates);
+                await patchEvalRequestForJob(ctx, ctx.config.jobId, {
+                    status: "failed",
+                    completedAt: new Date().toISOString(),
+                    error: `${step.name}: ${failedError}`,
+                });
             }
             // Capture pipeline context before exiting. `job-updates` was an
             // observability-only capture not tied to a registered artifact type;
@@ -242,9 +276,10 @@ export async function orchestratePipeline(ctx, steps) {
             // (P5 / local-first) and `success: true` is preserved; the `error`
             // field is the wire signal that a configured optional step failed.
             const firstOptionalFailure = getFirstOptionalFailure(steps, results);
+            const completedAt = new Date().toISOString();
             await store.updateJob(ctx.config.jobId, {
                 status: "completed",
-                completedAt: new Date().toISOString(),
+                completedAt,
                 progress: {
                     currentStep: "complete",
                     completedSteps: steps.length,
@@ -253,6 +288,16 @@ export async function orchestratePipeline(ctx, steps) {
                 ...(state.reportId ? { reportId: state.reportId } : {}),
                 ...(firstOptionalFailure ? { error: firstOptionalFailure } : {}),
             });
+            await patchEvalRequestForJob(ctx, ctx.config.jobId, {
+                status: "completed",
+                completedAt,
+                ...(state.reportId ? { reportId: state.reportId } : {}),
+                ...(firstOptionalFailure
+                    ? {
+                        error: `${firstOptionalFailure.step}: ${firstOptionalFailure.message}`,
+                    }
+                    : {}),
+            });
         }
         catch {
             ctx.logger.warn("Failed to report job completion — continuing");

package/dist/orchestration/steps/compare-step.d.ts

@@ -4,6 +4,13 @@
  * This step is already pure (no execSync, no env vars) — the logic is
  * inlined directly from the former pipeline/steps/compare-step.ts.
  * This is an optional step — failure doesn't stop the pipeline.
+ *
+ * Baseline resolution order (highest priority first):
+ *  1. `compareBaselineReportId` — fetch the named report doc
+ *     and use its `summary` (a ReportSummary, which is a
+ *     superset of ComparableSummary) as the baseline.
+ *  2. `compareBaseline` — local filesystem path (CLI ergonomics).
+ *  3. Latest baseline in `results/baselines/`.
  */
 import { type AppContext, type PipelineStep, type StepResult, type ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
 export declare class CompareStep implements PipelineStep {

package/dist/orchestration/steps/compare-step.js

@@ -4,6 +4,13 @@
  * This step is already pure (no execSync, no env vars) — the logic is
  * inlined directly from the former pipeline/steps/compare-step.ts.
  * This is an optional step — failure doesn't stop the pipeline.
+ *
+ * Baseline resolution order (highest priority first):
+ *  1. `compareBaselineReportId` — fetch the named report doc
+ *     and use its `summary` (a ReportSummary, which is a
+ *     superset of ComparableSummary) as the baseline.
+ *  2. `compareBaseline` — local filesystem path (CLI ergonomics).
+ *  3. Latest baseline in `results/baselines/`.
  */
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, } from "fs";
 import { join, resolve } from "path";
@@ -29,39 +36,68 @@ export class CompareStep {
         }
         // Load experiment (current run)
         const experiment = JSON.parse(readFileSync(scoreSummaryPath, "utf-8"));
-        // Resolve baseline
-        let resolvedBaselinePath;
-        if (ctx.config.compareBaseline) {
-            resolvedBaselinePath = resolve(ctx.config.compareBaseline);
-        }
-        else {
-            const baselinesDir = resolve(rootDir, "results", "baselines");
-            if (!existsSync(baselinesDir)) {
+        // Resolve baseline. Pinned report id wins over local FS, which wins
+        // over auto-discovery of the most recent file in `results/baselines/`.
+        let baseline;
+        const pinnedReportId = ctx.config.compareBaselineReportId;
+        if (pinnedReportId) {
+            if (!ctx.reportStore) {
                 return {
-                    reason: "No baselines directory found. Run 'pnpm baseline:save' first.",
+                    reason: "compareBaselineReportId set but no reportStore is configured. " +
+                        "Check Sanity credentials in .ailf/config.yaml.",
                     status: "skipped",
                 };
             }
-            const files = readdirSync(baselinesDir)
-                .filter((f) => f.endsWith(".json"))
-                .sort()
-                .reverse();
-            if (files.length === 0) {
+            const result = await ctx.reportStore.loadBaselineFromReport(pinnedReportId);
+            if (result.kind === "error") {
+                return {
+                    durationMs: Date.now() - start,
+                    error: `Failed to load baseline report ${pinnedReportId}: ${result.message}`,
+                    status: "failed",
+                };
+            }
+            if (result.kind === "not_found") {
                 return {
-                    reason: "No baseline files found. Run 'pnpm baseline:save' first.",
+                    reason: `Baseline report ${pinnedReportId} not found.`,
                     status: "skipped",
                 };
             }
-            resolvedBaselinePath = join(baselinesDir, files[0]);
+            baseline = result.baseline;
         }
-        if (!existsSync(resolvedBaselinePath)) {
-            return {
-                durationMs: Date.now() - start,
-                error: `Baseline file not found: ${resolvedBaselinePath}`,
-                status: "failed",
-            };
+        else {
+            let resolvedBaselinePath;
+            if (ctx.config.compareBaseline) {
+                resolvedBaselinePath = resolve(ctx.config.compareBaseline);
+            }
+            else {
+                const baselinesDir = resolve(rootDir, "results", "baselines");
+                if (!existsSync(baselinesDir)) {
+                    return {
+                        reason: "No baselines directory found. Run 'pnpm baseline:save' first.",
+                        status: "skipped",
+                    };
+                }
+                const files = readdirSync(baselinesDir)
+                    .filter((f) => f.endsWith(".json"))
+                    .sort()
+                    .reverse();
+                if (files.length === 0) {
+                    return {
+                        reason: "No baseline files found. Run 'pnpm baseline:save' first.",
+                        status: "skipped",
+                    };
+                }
+                resolvedBaselinePath = join(baselinesDir, files[0]);
+            }
+            if (!existsSync(resolvedBaselinePath)) {
+                return {
+                    durationMs: Date.now() - start,
+                    error: `Baseline file not found: ${resolvedBaselinePath}`,
+                    status: "failed",
+                };
+            }
+            baseline = JSON.parse(readFileSync(resolvedBaselinePath, "utf-8"));
         }
-        const baseline = JSON.parse(readFileSync(resolvedBaselinePath, "utf-8"));
         // Run comparison
         const options = ctx.config.compareThreshold
             ? { noiseThreshold: ctx.config.compareThreshold }

package/dist/orchestration/steps/fetch-docs-step.js

@@ -37,6 +37,9 @@ export class FetchDocsStep {
             ...(ctx.config.areas?.length ? { areas: ctx.config.areas } : {}),
             ...(ctx.config.tasks?.length ? { taskIds: ctx.config.tasks } : {}),
             ...(ctx.config.tags?.length ? { tags: ctx.config.tags } : {}),
+            ...(ctx.config.changedDocs?.length
+                ? { changedDocs: ctx.config.changedDocs }
+                : {}),
         };
         const allTasks = await ctx.taskSource.loadTasks(Object.keys(filter).length > 0 ? filter : undefined);
         // Bridge: narrow to literacy tasks for canonical doc access

package/dist/orchestration/steps/finalize-run-step.js

@@ -84,6 +84,8 @@ export class FinalizeRunStep {
             rootDir: ctx.config.rootDir,
             source: resolvedSource,
             taskIds: ctx.config.tasks,
+            variant: ctx.config.variant,
+            requestedModelIds: ctx.config.models,
         });
         // W0051 revisit: the composition-root wraps `ctx.artifactWriter` in
         // `AccumulatingArtifactWriter`, which keeps a map of every ref any

package/dist/orchestration/steps/generate-configs-step.d.ts

@@ -8,7 +8,7 @@
  * When the variant is "full", the handler is called twice (baseline + agentic)
  * and three YAML files are written. Other modes produce one YAML file.
  */
-import { type AppContext, type PipelineState, type PipelineStep, type StepResult, type ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
+import { type AppContext, type ModelsConfig, type PipelineState, type PipelineStep, type StepResult, type ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
 export declare class GenerateConfigsStep implements PipelineStep {
     readonly name = "generate-configs";
     /** Task IDs from the last loadTasks call (pre-filter), for error messages. */
@@ -42,3 +42,34 @@ export declare class GenerateConfigsStep implements PipelineStep {
     cacheInputs(ctx: AppContext): string[];
     cacheContext(ctx: AppContext): string[];
 }
+/**
+ * Merge multiple compile results into one.
+ *
+ * Note: `providers` and `prompts` are taken from the first result only.
+ * This is correct for single-mode compilation where all tasks share the
+ * same provider set. Cross-mode merging with per-task provider overrides
+ * would need deduplication here.
+ */
+/**
+ * Apply `PipelineRequest.models` to the loaded model cohort (W0281).
+ *
+ * Returns one of three outcomes:
+ *   - `unfiltered` — caller didn't pin any models; pass through.
+ *   - `filtered`   — at least one requested ID matched the cohort; unknown
+ *                    IDs are reported via a structured warning so callers
+ *                    can detect typos.
+ *   - `no-match`   — every requested ID is unknown. Caller wired this
+ *                    step into a failure path so the rejection reason
+ *                    surfaces on the job's `error` field, not silently.
+ */
+export type FilterModelsResult = {
+    kind: "unfiltered";
+    models: ModelsConfig;
+} | {
+    kind: "filtered";
+    models: ModelsConfig;
+} | {
+    kind: "no-match";
+    reason: string;
+};
+export declare function filterModelsByRequest(loaded: ModelsConfig, requested: string[] | undefined, logger: import("@sanity/ailf-core").Logger): FilterModelsResult;

package/dist/orchestration/steps/generate-configs-step.js

@@ -67,12 +67,32 @@ export class GenerateConfigsStep {
                 };
             }
             // Load models
-            const { loadModelsAndProviders } = await import("../../pipeline/compiler/provider-assembler.js");
+            const { loadModelsAndProviders, loadModelsYaml } = await import("../../pipeline/compiler/provider-assembler.js");
             const overrides = configToSourceOverrides(ctx.config);
             const resolvedSource = ctx.config.source
                 ? loadSource(ctx.config.source, overrides)
                 : undefined;
-            const { models, providers } = loadModelsAndProviders(ctx.config.rootDir, resolvedSource, ctx.config.searchMode, ctx.config.allowedOrigins);
+            // W0281: when the caller pinned a subset of models via
+            // `PipelineRequest.models`, filter the cohort BEFORE provider
+            // assembly. Filtering only the returned `models` field would silently
+            // defeat the filter — promptfoo decides which LLMs to call from the
+            // providers array, which is assembled from the unfiltered set unless
+            // we hand the assembler a pre-filtered ModelsConfig. Unknown IDs are
+            // surfaced via a structured warning AND a failed step result (whose
+            // message lands on `ailf.job.error`) so callers can detect typos
+            // instead of silently running the full default cohort.
+            const rawModels = loadModelsYaml(ctx.config.rootDir);
+            const filtered = filterModelsByRequest(rawModels, ctx.config.models, ctx.logger);
+            if (filtered.kind === "no-match") {
+                return {
+                    durationMs: Date.now() - start,
+                    error: filtered.reason,
+                    status: "failed",
+                };
+            }
+            const loaded = loadModelsAndProviders(ctx.config.rootDir, resolvedSource, ctx.config.searchMode, ctx.config.allowedOrigins, filtered.models);
+            const models = loaded.models;
+            const providers = loaded.providers;
             // Literacy mode: variant expansion (baseline + agentic → 3 YAML files)
             if (mode === "literacy") {
                 return this.compileLiteracyVariants(ctx, handler, tasks, models, providers, start);
@@ -239,6 +259,9 @@ export class GenerateConfigsStep {
             ...(ctx.config.areas?.length ? { areas: ctx.config.areas } : {}),
             ...(ctx.config.tasks?.length ? { taskIds: ctx.config.tasks } : {}),
             ...(ctx.config.tags?.length ? { tags: ctx.config.tags } : {}),
+            ...(ctx.config.changedDocs?.length
+                ? { changedDocs: ctx.config.changedDocs }
+                : {}),
         };
         const allTasks = await ctx.taskSource.loadTasks(Object.keys(filter).length > 0 ? filter : undefined);
         // Mode filter — the adapter may return a mixed-mode set (e.g. a user's
@@ -345,17 +368,28 @@ export class GenerateConfigsStep {
         return buildCacheContext(ctx.config);
     }
 }
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/**
- * Merge multiple compile results into one.
- *
- * Note: `providers` and `prompts` are taken from the first result only.
- * This is correct for single-mode compilation where all tasks share the
- * same provider set. Cross-mode merging with per-task provider overrides
- * would need deduplication here.
- */
+export function filterModelsByRequest(loaded, requested, logger) {
+    if (!requested || requested.length === 0) {
+        return { kind: "unfiltered", models: loaded };
+    }
+    const availableIds = new Set(loaded.models.map((m) => m.id));
+    const requestedSet = new Set(requested);
+    const kept = loaded.models.filter((m) => requestedSet.has(m.id));
+    const unknown = requested.filter((id) => !availableIds.has(id));
+    if (kept.length === 0) {
+        const reason = `[generate-configs] PipelineRequest.models rejected — none of ` +
+            `[${requested.join(", ")}] match config/models.ts. ` +
+            `Available IDs: ${[...availableIds].join(", ") || "(none configured)"}.`;
+        logger.warn(reason);
+        return { kind: "no-match", reason };
+    }
+    if (unknown.length > 0) {
+        logger.warn(`[generate-configs] PipelineRequest.models partial match — ignoring ` +
+            `unknown ID(s) [${unknown.join(", ")}]; ` +
+            `running ${kept.length}/${requested.length} requested.`);
+    }
+    return { kind: "filtered", models: { ...loaded, models: kept } };
+}
 function mergeCompileResults(results) {
     const tests = results.flatMap((r) => r.tests);
     const warnings = results.flatMap((r) => r.warnings);

package/dist/orchestration/steps/grader-consistency-step.js

@@ -18,7 +18,18 @@ export class GraderConsistencyStep {
     }
     async execute(ctx) {
         const start = Date.now();
+        // Default-on-omit is 5 (matches consistency-analysis-friendly defaults).
+        // The dashboard sends 1 by default for cost reasons (see W0283 / new-eval
+        // audit S1-E). When the resolved value is <2, the analysis can't compute
+        // variance — skip instead of failing so the job doesn't carry a
+        // misleading `error.step: "grader-consistency"`.
         const replications = ctx.config.graderReplications ?? 5;
+        if (replications < 2) {
+            return {
+                reason: `graderReplications=${replications} (<2) — consistency analysis requires at least 2 replications`,
+                status: "skipped",
+            };
+        }
         const primaryResultsRun = ctx.config.mode === "literacy"
             ? ctx.config.variant === LiteracyVariant.FULL
                 ? LiteracyVariant.STANDARD

package/dist/orchestration/steps/publish-report-step.d.ts

@@ -10,7 +10,8 @@
  * - P5: Local-first (pipeline never fails because of a store write)
  * - P6: Sinks are fire-and-forget (failures logged, not thrown)
  */
-import { type AppContext, type PipelineState, type PipelineStep, type PromptfooUrlEntry, type StepResult, type ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
+import { type AppContext, type PipelineState, type PipelineStep, type PromptfooUrlEntry, type ReportAutoScope, type ScoreSummary, type StepResult, type ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
+import { type ProvenanceInput } from "../../pipeline/provenance.js";
 export declare class PublishReportStep implements PipelineStep {
     private readonly pipelineStart;
     private readonly options;
@@ -24,3 +25,13 @@ export declare class PublishReportStep implements PipelineStep {
     check(): ValidationIssue[];
     execute(ctx: AppContext, state: PipelineState): Promise<StepResult>;
 }
+/**
+ * Assemble provenance input from the score summary and pipeline context.
+ *
+ * Exported for unit testing — direct consumers should still call
+ * `buildProvenance` (which calls this transitively via the publish step).
+ */
+export declare function buildProvenanceInput(summary: ScoreSummary, ctx: AppContext, options: {
+    evalFingerprint?: string;
+    promptfooUrls?: PromptfooUrlEntry[];
+}, autoScope?: ReportAutoScope): ProvenanceInput;

package/dist/orchestration/steps/publish-report-step.js

@@ -194,21 +194,35 @@ export class PublishReportStep {
 // ---------------------------------------------------------------------------
 /**
  * Assemble provenance input from the score summary and pipeline context.
+ *
+ * Exported for unit testing — direct consumers should still call
+ * `buildProvenance` (which calls this transitively via the publish step).
  */
-function buildProvenanceInput(summary, ctx, options, autoScope) {
+export function buildProvenanceInput(summary, ctx, options, autoScope) {
     const areas = summary.scores.map((s) => s.feature);
     const mode = ctx.config.mode;
     // Read document IDs from config
     const sanityDocumentIds = ctx.config.sanityDocumentArgs;
     // Read task filter from config
     const taskIds = ctx.config.tasks;
-    // Build source from summary metadata or config
+    // Build source from summary metadata or config. Resolution order:
+    //   1. summary.source — written by calculate-scores after a successful
+    //      `loadSource` round-trip.
+    //   2. ctx.config.source — the caller-requested source name. Preserves
+    //      the user's intent when `loadSource` failed silently upstream
+    //      (calculate-scores-step:104-108 swallows the throw, leaving
+    //      summary.source undefined). Without this fallback, the report
+    //      reads "production" regardless of what the dashboard sent.
+    //   3. "production" — last-resort built-in default.
+    if (summary.source?.name === undefined && ctx.config.source) {
+        ctx.logger.warn(`[publish-report] summary.source is missing; falling back to ctx.config.source="${ctx.config.source}" for provenance.source.name`);
+    }
     const source = {
         baseUrl: summary.source?.baseUrl ?? "https://www.sanity.io/docs",
         dataset: summary.source?.dataset ?? ctx.config.datasetOverride ?? "next",
         documentIds: [],
         llmsTxt: (summary.source?.baseUrl ?? "https://www.sanity.io/docs") + "/llms.txt",
-        name: summary.source?.name ?? "production",
+        name: summary.source?.name ?? ctx.config.source ?? "production",
         perspective: summary.source?.perspective ??
             ctx.config.perspectiveOverride ??
             undefined,
@@ -235,6 +249,8 @@ function buildProvenanceInput(summary, ctx, options, autoScope) {
         source,
         sourceReportId: ctx.config.sourceReportId,
         taskIds,
+        variant: ctx.config.variant,
+        requestedModelIds: ctx.config.models,
     };
 }
 /**

package/dist/pipeline/cache-hit-restore.d.ts

@@ -8,14 +8,39 @@
  * @see docs/decisions/D0040-artifact-ref-source-run-id.md
  * @see docs/design-docs/cache-hit-artifact-restoration.md
  */
-import type { ArtifactManifest, RunId } from "../_vendor/ailf-core/index.d.ts";
+import { type ArtifactManifest, type RunId } from "../_vendor/ailf-core/index.d.ts";
 /**
- * Copy an artifact manifest verbatim and stamp `sourceRunId` on every ref.
+ * Copy an artifact manifest verbatim and stamp `sourceRunId` on every ref
+ * that doesn't already carry one.
  *
  * The ref's `path`, `bucket`, `entries`, `bytes`, `preview`, etc. travel
- * unchanged — they already point at the source run's storage. Only
- * `sourceRunId` is added so retention/GC and observability tooling can
- * follow the cross-run dependency.
+ * unchanged — they already point at the source run's storage. `sourceRunId`
+ * is added so retention/GC and observability tooling can follow the
+ * cross-run dependency.
+ *
+ * **Transitive lineage.** When a cached report's refs already carry a
+ * `sourceRunId` (because that report was itself a cache hit), we preserve it.
+ * `opts.sourceRunId` is only the *immediate* cache parent; if the cached
+ * report's refs already point at the ultimate source run, blindly overwriting
+ * would drop the lineage one hop per cache propagation and 404 readers that
+ * trust `sourceRunId` for path reconstruction.
+ *
+ * Invariant maintained across any number of cache hops: every ref's
+ * `sourceRunId` equals the runId encoded in its `path` (= where the bytes
+ * physically live).
+ *
+ * **Post-hoc artifacts are dropped.** Refs whose descriptor has
+ * `writePolicy: "post-hoc"` (e.g. `diagnosis`) are skipped: the cached
+ * report's slot points at the *previous* run's path, but the post-hoc
+ * producer fires again on the new run and emits a fresh ref anchored at
+ * the new runId. Injecting the cached cross-run ref into the accumulator
+ * makes `FinalizeRunStep` embed the stale path into the on-GCS
+ * `runs/<newRunId>/manifest.json`; the post-hoc emit then only patches the
+ * Sanity report doc, leaving the GCS manifest stale. Dropping the ref
+ * here keeps the GCS manifest consistent with the cache-miss shape (no
+ * post-hoc slot until the post-hoc emit lands), and the reader-side
+ * fallback resolves diagnosis via the Sanity doc, which the post-hoc
+ * patch keeps correct.
  *
  * Pure function; safe to call without side effects.
  */

package/dist/pipeline/cache-hit-restore.js

@@ -8,13 +8,39 @@
  * @see docs/decisions/D0040-artifact-ref-source-run-id.md
  * @see docs/design-docs/cache-hit-artifact-restoration.md
  */
+import { ARTIFACT_REGISTRY, } from "../_vendor/ailf-core/index.js";
 /**
- * Copy an artifact manifest verbatim and stamp `sourceRunId` on every ref.
+ * Copy an artifact manifest verbatim and stamp `sourceRunId` on every ref
+ * that doesn't already carry one.
  *
  * The ref's `path`, `bucket`, `entries`, `bytes`, `preview`, etc. travel
- * unchanged — they already point at the source run's storage. Only
- * `sourceRunId` is added so retention/GC and observability tooling can
- * follow the cross-run dependency.
+ * unchanged — they already point at the source run's storage. `sourceRunId`
+ * is added so retention/GC and observability tooling can follow the
+ * cross-run dependency.
+ *
+ * **Transitive lineage.** When a cached report's refs already carry a
+ * `sourceRunId` (because that report was itself a cache hit), we preserve it.
+ * `opts.sourceRunId` is only the *immediate* cache parent; if the cached
+ * report's refs already point at the ultimate source run, blindly overwriting
+ * would drop the lineage one hop per cache propagation and 404 readers that
+ * trust `sourceRunId` for path reconstruction.
+ *
+ * Invariant maintained across any number of cache hops: every ref's
+ * `sourceRunId` equals the runId encoded in its `path` (= where the bytes
+ * physically live).
+ *
+ * **Post-hoc artifacts are dropped.** Refs whose descriptor has
+ * `writePolicy: "post-hoc"` (e.g. `diagnosis`) are skipped: the cached
+ * report's slot points at the *previous* run's path, but the post-hoc
+ * producer fires again on the new run and emits a fresh ref anchored at
+ * the new runId. Injecting the cached cross-run ref into the accumulator
+ * makes `FinalizeRunStep` embed the stale path into the on-GCS
+ * `runs/<newRunId>/manifest.json`; the post-hoc emit then only patches the
+ * Sanity report doc, leaving the GCS manifest stale. Dropping the ref
+ * here keeps the GCS manifest consistent with the cache-miss shape (no
+ * post-hoc slot until the post-hoc emit lands), and the reader-side
+ * fallback resolves diagnosis via the Sanity doc, which the post-hoc
+ * patch keeps correct.
  *
  * Pure function; safe to call without side effects.
  */
@@ -23,9 +49,13 @@ export function remapToCacheHitRefs(source, opts) {
     for (const [type, ref] of Object.entries(source)) {
         if (!ref)
             continue;
+        const descriptor = ARTIFACT_REGISTRY[type];
+        if (descriptor?.writePolicy === "post-hoc")
+            continue;
+        const typed = ref;
         out[type] = {
-            ...ref,
-            sourceRunId: opts.sourceRunId,
+            ...typed,
+            sourceRunId: typed.sourceRunId ?? opts.sourceRunId,
         };
     }
     return out;