@sanity/ailf 3.9.0 → 4.0.1

package/dist/config/models.ts

@@ -35,16 +35,23 @@ export default defineModels({
 
     // ── OpenAI ─────────────────────────────────────────────────
     {
+      // gpt-5.2 routes through chat completions (and through the in-house
+      // agentic provider for naive/optimized variants). `verbosity` is a
+      // Responses-API-only field — it would be silently dropped here, so
+      // it isn't configured. See W0131.
       id: "openai:chat:gpt-5.2",
       label: "GPT 5.2",
       config: {
         max_completion_tokens: 8192,
-        verbosity: "medium",
       },
       modes: ["literacy", "knowledge-probe"],
       // All literacy variants included by default
     },
     {
+      // GPT 5.4 evaluated only on the baseline literacy variant. Promptfoo's
+      // native handling of `openai:responses:` honors reasoning / verbosity /
+      // summary; the in-house agentic provider does not (W0131). MCP-server
+      // and knowledge-probe routes go through Promptfoo native too.
       id: "openai:responses:gpt-5.4",
       label: "GPT 5.4",
       config: {
@@ -55,7 +62,9 @@ export default defineModels({
       },
       timeoutMs: 600_000, // 10 min — reasoning model needs more headroom
       modes: ["literacy", "mcp-server", "knowledge-probe"],
-      // All literacy variants included by default
+      variants: {
+        literacy: ["baseline"],
+      },
     },
 
     // ── Disabled models (uncomment to enable) ──────────────────
@@ -93,12 +102,31 @@ export default defineModels({
   defaults: {
     temperature: 0.2,
     max_tokens: 4096,
-    maxToolRounds: 5, // for agentic modes
+    // Global default round budget for agentic modes. Per-mode overrides
+    // below give naive more headroom (W0134) since it spends rounds on
+    // retries when fetches fail. Per-model `config.maxToolRounds` still
+    // wins over both values.
+    maxToolRounds: 5,
+    modeMaxToolRounds: {
+      "agentic-naive": 8,
+      "agentic-optimized": 5,
+    },
     observerOptions: {
-      maxPreviewBytes: 2048,
+      // Per-class preview caps (W0133): default 4 KB, but search responses
+      // get 16 KB and llms.txt gets 128 KB so trace audits can resolve
+      // which result the model actually saw.
+      maxPreviewBytes: 4096,
+      previewLimits: {
+        default: 4096,
+        llmsTxt: 131072,
+        search: 16384,
+      },
       captureResponsePreview: true,
       includePatterns: ["sanity.io", "sanity.dev", "cdn.sanity.io"],
       sensitiveHeaders: ["authorization", "cookie", "x-api-key"],
+      // statusOnlyForUnmatched defaults to true (W0132) — model-side
+      // traffic to api.openai.com / api.anthropic.com / googleapis.com
+      // surfaces in run artifacts as slim status-only entries.
     },
   },
 })

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

@@ -8,10 +8,13 @@
 import { existsSync, mkdirSync, writeFileSync } from "fs";
 import { resolve } from "path";
 import { emitPerEntryEvalResults } from "../../pipeline/emit-eval-results.js";
+import { AccumulatingArtifactWriter } from "../../artifact-capture/accumulating-artifact-writer.js";
 import { getStepInputPaths } from "../../pipeline/cache.js";
 import { buildCacheContext } from "../cache-context.js";
+import { remapToCacheHitRefs } from "../../pipeline/cache-hit-restore.js";
 import { checkCanonicalContextsExist, checkGeneratedConfigsExist, checkResultsExist, } from "../../pipeline/checks.js";
 import { computeEvalFingerprint } from "../../pipeline/eval-fingerprint.js";
+import { loadGraderModel } from "../../pipeline/grader-api.js";
 import { buildFilterFlags, configFileForMode, resultsFileForMode, scanResultsForErrors, } from "../../pipeline/eval-constants.js";
 export class RunEvalStep {
     mode;
@@ -39,31 +42,31 @@ export class RunEvalStep {
                 status: "failed",
             };
         }
+        // Load the task set once and reuse it for both the literacy precondition
+        // check and the fingerprint. Mirrors the area/task filter applied by
+        // fetch-docs so we only see tasks that were actually fetched.
+        const filter = ctx.config.areas || ctx.config.tasks || ctx.config.tags
+            ? {
+                ...(ctx.config.areas ? { areas: ctx.config.areas } : {}),
+                ...(ctx.config.tasks ? { taskIds: ctx.config.tasks } : {}),
+                ...(ctx.config.tags ? { tags: ctx.config.tags } : {}),
+            }
+            : undefined;
+        let tasks = await ctx.taskSource.loadTasks(filter);
+        // Release auto-scope: narrow to affected tasks (mirrors GenerateConfigsStep)
+        if (state.releaseAutoScope && !ctx.config.noAutoScope) {
+            const scopedIds = new Set(state.releaseAutoScope.affectedTaskIds);
+            tasks = tasks.filter((t) => scopedIds.has(t.id));
+        }
         // Precondition: canonical context files exist for filtered tasks.
         // Only applies to literacy mode — other modes don't use canonical doc contexts.
         if (this.mode === "literacy") {
-            // Must apply the same area/task filter as fetch-docs so we only
-            // check contexts that were actually fetched.
-            const filter = ctx.config.areas || ctx.config.tasks || ctx.config.tags
-                ? {
-                    ...(ctx.config.areas ? { areas: ctx.config.areas } : {}),
-                    ...(ctx.config.tasks ? { taskIds: ctx.config.tasks } : {}),
-                    ...(ctx.config.tags ? { tags: ctx.config.tags } : {}),
-                }
-                : undefined;
-            let tasks = await ctx.taskSource.loadTasks(filter);
-            // Release auto-scope: narrow to affected tasks (mirrors GenerateConfigsStep)
-            if (state.releaseAutoScope && !ctx.config.noAutoScope) {
-                const scopedIds = new Set(state.releaseAutoScope.affectedTaskIds);
-                tasks = tasks.filter((t) => scopedIds.has(t.id));
-            }
             // Only check context files for tasks that have canonical docs.
             // Tasks without canonical docs are skipped by FetchDocsStep (they
             // have no docs to fetch), so no context file is written for them.
             // The generated Promptfoo config still includes their "without-docs"
             // variant (testing model knowledge alone), which doesn't need a
             // context file.
-            // Bridge: narrow to literacy tasks with docs
             const tasksWithDocs = tasks.filter((t) => t.mode === "literacy" && (t.context?.docs?.length ?? 0) > 0);
             const taskIds = tasksWithDocs.map((t) => t.id);
             const contextIssues = checkCanonicalContextsExist(rootDir, taskIds);
@@ -83,14 +86,8 @@ export class RunEvalStep {
         if (!debug?.enabled) {
             try {
                 evalFingerprint = computeEvalFingerprint({
-                    filter: ctx.config.areas || ctx.config.tasks || ctx.config.tags
-                        ? {
-                            areas: ctx.config.areas,
-                            taskIds: ctx.config.tasks,
-                            tags: ctx.config.tags,
-                        }
-                        : undefined,
-                    graderModel: "default",
+                    tasks,
+                    graderModel: loadGraderModel(rootDir).id,
                     mode: this.mode,
                     rootDir,
                 });
@@ -119,11 +116,22 @@ export class RunEvalStep {
                     state.promptfooUrls ??= [];
                     state.promptfooUrls.push(...remoteCacheResult.promptfooUrls);
                 }
-                // W0050 — score-summary-cached was an unregistered capture;
-                // scoreSummary is already emitted by calculate-scores-step on the
-                // non-cached path, which also runs when we have a remote cache hit
-                // (populating state.remoteCacheHits → CalculateScoresStep still
-                // invokes for the score-summary emit). Dropped here.
+                // D0040 / W0135 — restore the cached report's artifact manifest into
+                // the accumulator so the new run's RunManifest advertises the cached
+                // artifacts via cross-run lineage (`sourceRunId`) instead of skipping
+                // them entirely. Without this, Studio drill-downs on the new report
+                // 404 because per-entry GCS objects were never written under the new
+                // runId. Bytes are not duplicated; the original prefix is untouched.
+                if (remoteCacheResult.artifactManifest &&
+                    remoteCacheResult.sourceRunId &&
+                    ctx.artifactWriter instanceof AccumulatingArtifactWriter) {
+                    const restored = remapToCacheHitRefs(remoteCacheResult.artifactManifest, { sourceRunId: remoteCacheResult.sourceRunId });
+                    ctx.artifactWriter.injectAccumulated(restored);
+                    const count = Object.keys(restored).length;
+                    if (count > 0) {
+                        console.log(`  ↪ Restored ${count} artifact ref${count === 1 ? "" : "s"} from run ${remoteCacheResult.sourceRunId}`);
+                    }
+                }
                 return {
                     durationMs: Date.now() - start,
                     status: "success",
@@ -241,9 +249,11 @@ async function checkRemoteCache(fingerprint, reportStore, rootDir) {
         console.log(`  ✅ Remote cache hit — reusing report ${cachedReport.id} from ${cachedReport.completedAt}`);
         console.log(`  ℹ️  Fingerprint: ${fingerprint.slice(0, 16)}... (${queryMs}ms)`);
         return {
+            artifactManifest: cachedReport.artifactManifest,
             completedAt: cachedReport.completedAt,
             promptfooUrls: cachedReport.provenance?.promptfooUrls,
             reportId: cachedReport.id,
+            sourceRunId: cachedReport.provenance?.runId,
         };
     }
     catch (err) {

package/dist/pipeline/baseline.d.ts

@@ -29,9 +29,20 @@ export interface ScoreComparison {
     delta: number;
     feature: string;
 }
-export declare function compareBaseline(rootDir: string, baselineFile?: string): CompareResult;
-export declare function listBaselines(rootDir: string): BaselineMetadata[];
-export declare function saveBaseline(rootDir: string, tag?: string): {
+/**
+ * Paths the baseline pipeline functions read and write. Callers compose this
+ * from caller-relative paths so the functions stay agnostic of where the
+ * eval package itself lives on disk (W0098).
+ */
+export interface BaselineDirs {
+    /** Directory that contains baseline `*.json` snapshots. */
+    baselinesDir: string;
+    /** Absolute path to the current run's `score-summary.json`. */
+    scoreSummaryPath: string;
+}
+export declare function compareBaseline(dirs: BaselineDirs, baselineFile?: string): CompareResult;
+export declare function listBaselines(baselinesDir: string): BaselineMetadata[];
+export declare function saveBaseline(dirs: BaselineDirs, tag?: string): {
     success: boolean;
     message: string;
 };

package/dist/pipeline/baseline.js

@@ -7,12 +7,8 @@
  */
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, } from "fs";
 import { join } from "path";
-// ---------------------------------------------------------------------------
-// Compare
-// ---------------------------------------------------------------------------
-export function compareBaseline(rootDir, baselineFile) {
-    const baselinesDir = join(rootDir, "results", "baselines");
-    const scoreSummaryPath = join(rootDir, "results", "latest", "score-summary.json");
+export function compareBaseline(dirs, baselineFile) {
+    const { baselinesDir, scoreSummaryPath } = dirs;
     if (!existsSync(scoreSummaryPath)) {
         return {
             message: "No current score-summary.json found.",
@@ -20,7 +16,7 @@ export function compareBaseline(rootDir, baselineFile) {
         };
     }
     // Find baseline to compare against
-    const baselines = listBaselines(rootDir);
+    const baselines = listBaselines(baselinesDir);
     if (baselines.length === 0) {
         return {
             message: "No baselines saved yet. Run 'pnpm baseline:save' first.",
@@ -76,8 +72,7 @@ export function compareBaseline(rootDir, baselineFile) {
 // ---------------------------------------------------------------------------
 // List
 // ---------------------------------------------------------------------------
-export function listBaselines(rootDir) {
-    const baselinesDir = join(rootDir, "results", "baselines");
+export function listBaselines(baselinesDir) {
     if (!existsSync(baselinesDir)) {
         return [];
     }
@@ -102,9 +97,8 @@ export function listBaselines(rootDir) {
 // ---------------------------------------------------------------------------
 // Save
 // ---------------------------------------------------------------------------
-export function saveBaseline(rootDir, tag) {
-    const baselinesDir = join(rootDir, "results", "baselines");
-    const scoreSummaryPath = join(rootDir, "results", "latest", "score-summary.json");
+export function saveBaseline(dirs, tag) {
+    const { baselinesDir, scoreSummaryPath } = dirs;
     if (!existsSync(scoreSummaryPath)) {
         return {
             message: "No score-summary.json found. Run 'pnpm calculate-scores' first.",
@@ -135,7 +129,7 @@ export function saveBaseline(rootDir, tag) {
     };
     writeFileSync(join(baselinesDir, filename), JSON.stringify(baseline, null, 2));
     return {
-        message: `Saved baseline to results/baselines/${filename} (avg: ${Math.round(summary.overall.avgScore)}, ${summary.scores.length} areas)`,
+        message: `Saved baseline to ${join(baselinesDir, filename)} (avg: ${Math.round(summary.overall.avgScore)}, ${summary.scores.length} areas)`,
         success: true,
     };
 }

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

@@ -0,0 +1,24 @@
+/**
+ * cache-hit-restore.ts — helpers for the eval cache-hit branch in
+ * `RunEvalStep`. Stamps `sourceRunId` onto a cached report's artifact
+ * refs so the new run's manifest advertises the cached artifacts via
+ * cross-run lineage instead of pointing at GCS objects that were never
+ * written under the new runId.
+ *
+ * @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";
+/**
+ * Copy an artifact manifest verbatim and stamp `sourceRunId` on every ref.
+ *
+ * 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.
+ *
+ * Pure function; safe to call without side effects.
+ */
+export declare function remapToCacheHitRefs(source: ArtifactManifest, opts: {
+    sourceRunId: RunId;
+}): ArtifactManifest;

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

@@ -0,0 +1,32 @@
+/**
+ * cache-hit-restore.ts — helpers for the eval cache-hit branch in
+ * `RunEvalStep`. Stamps `sourceRunId` onto a cached report's artifact
+ * refs so the new run's manifest advertises the cached artifacts via
+ * cross-run lineage instead of pointing at GCS objects that were never
+ * written under the new runId.
+ *
+ * @see docs/decisions/D0040-artifact-ref-source-run-id.md
+ * @see docs/design-docs/cache-hit-artifact-restoration.md
+ */
+/**
+ * Copy an artifact manifest verbatim and stamp `sourceRunId` on every ref.
+ *
+ * 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.
+ *
+ * Pure function; safe to call without side effects.
+ */
+export function remapToCacheHitRefs(source, opts) {
+    const out = {};
+    for (const [type, ref] of Object.entries(source)) {
+        if (!ref)
+            continue;
+        out[type] = {
+            ...ref,
+            sourceRunId: opts.sourceRunId,
+        };
+    }
+    return out;
+}

package/dist/pipeline/calculate-scores.js

@@ -531,6 +531,45 @@ function printAgentBehaviorReport(agentBehavior, log) {
 // ---------------------------------------------------------------------------
 // Grader cost extraction
 // ---------------------------------------------------------------------------
+/**
+ * Resolve a per-test cost. Promptfoo populates `r.cost` for most providers
+ * directly, but `openai:responses:` (and occasionally `openai:chat:`) leaves
+ * `cost` at 0 for newer models — Promptfoo's pricing table can lag the
+ * model launch. When `cost` is 0 but `response.tokenUsage` is recorded,
+ * fall back to AILF's local pricing table so the per-model rollup row
+ * isn't dropped on the floor. See W0123.
+ */
+function resolveTestCost(r) {
+    const promptfooCost = r.cost ?? 0;
+    if (promptfooCost > 0)
+        return promptfooCost;
+    const tokens = r.response?.tokenUsage;
+    if (!tokens)
+        return promptfooCost;
+    const model = extractModelFromProviderId(r.provider?.id);
+    if (!model)
+        return promptfooCost;
+    return calculateCost(model, tokens.prompt ?? 0, tokens.completion ?? 0);
+}
+/**
+ * Extract the model name from a Promptfoo provider id. Provider ids are
+ * colon-segmented `<vendor>:<surface>:<model>` (e.g. `openai:responses:gpt-5.4`,
+ * `anthropic:messages:claude-opus-4-6`); the model is the trailing segment.
+ * Returns undefined for ids that don't carry a model segment (e.g. agentic
+ * providers whose id ends in a `file://` URL).
+ */
+function extractModelFromProviderId(providerId) {
+    if (!providerId)
+        return undefined;
+    const parts = providerId.split(":");
+    if (parts.length < 2)
+        return undefined;
+    const last = parts[parts.length - 1];
+    if (!last || last.startsWith("file://") || last.startsWith("http")) {
+        return undefined;
+    }
+    return last;
+}
 /**
  * Reads the raw Promptfoo output file and normalizes each result so that
  * `description` is always a top-level field (pulled from `testCase` if needed).
@@ -551,7 +590,7 @@ function readAndNormalizeResults(resultsPath, log) {
     let synthesizedCount = 0;
     for (const r of wrapper.results) {
         const base = {
-            cost: r.cost ?? 0,
+            cost: resolveTestCost(r),
             description: r.testCase?.description ?? "unknown",
             latencyMs: r.latencyMs,
             metadata: r.metadata,

package/dist/pipeline/compiler/provider-assembler.d.ts

@@ -6,6 +6,21 @@
  *
  * Separated into its own module so GenerateConfigsStep can import it
  * without pulling in the full legacy generate-configs machinery.
+ *
+ * W0134 — per-mode maxToolRounds
+ *
+ * The agentic naive variant gets a higher round budget than agentic
+ * optimized: naive simulates current real-world agent behavior under
+ * retrieval pressure (it spends rounds on retries when fetches fail) and
+ * benefits from more headroom; optimized bypasses Jina via the .md-direct
+ * branch and rarely needs more than a couple of rounds. Bumping globally
+ * would inflate optimized cost without changing its measured behavior.
+ *
+ * Resolution order (most specific wins):
+ *   1. `model.config.maxToolRounds` — per-model override.
+ *   2. `defaults.modeMaxToolRounds[variant]` — per-variant override.
+ *   3. `defaults.maxToolRounds` — global default.
+ *   4. Hard fallback (5).
  */
 import { type ModelsConfig } from "../../_vendor/ailf-core/index.d.ts";
 import type { ResolvedSourceConfig } from "../../sources.js";
@@ -37,3 +52,11 @@ export interface ModelsAndProviders {
  * the per-variant promptfoo config files.
  */
 export declare function loadModelsAndProviders(rootDir: string, source?: ResolvedSourceConfig, searchMode?: string, allowedOrigins?: string[]): ModelsAndProviders;
+/**
+ * Resolve `maxToolRounds` for an agentic variant (W0134).
+ *
+ * Most-specific wins: per-model `config.maxToolRounds` > per-variant
+ * `defaults.modeMaxToolRounds[variant]` > global `defaults.maxToolRounds`
+ * > hard fallback (5).
+ */
+export declare function resolveMaxToolRounds(models: ModelsConfig, model: ModelsConfig["models"][number], variant: "agentic-naive" | "agentic-optimized"): number;

package/dist/pipeline/compiler/provider-assembler.js

@@ -6,6 +6,21 @@
  *
  * Separated into its own module so GenerateConfigsStep can import it
  * without pulling in the full legacy generate-configs machinery.
+ *
+ * W0134 — per-mode maxToolRounds
+ *
+ * The agentic naive variant gets a higher round budget than agentic
+ * optimized: naive simulates current real-world agent behavior under
+ * retrieval pressure (it spends rounds on retries when fetches fail) and
+ * benefits from more headroom; optimized bypasses Jina via the .md-direct
+ * branch and rarely needs more than a couple of rounds. Bumping globally
+ * would inflate optimized cost without changing its measured behavior.
+ *
+ * Resolution order (most specific wins):
+ *   1. `model.config.maxToolRounds` — per-model override.
+ *   2. `defaults.modeMaxToolRounds[variant]` — per-variant override.
+ *   3. `defaults.maxToolRounds` — global default.
+ *   4. Hard fallback (5).
  */
 import { extractModelName, extractProvider, mergeConfig, } from "../../_vendor/ailf-core/index.js";
 import { loadConfigFile } from "./config-loader.js";
@@ -100,7 +115,7 @@ function buildAgenticProviders(models, source, searchMode, _allowedOrigins) {
             config: {
                 ...mergeConfig(models.defaults, model.config, {
                     agentMode: "naive",
-                    maxToolRounds: models.defaults.maxToolRounds ?? 5,
+                    maxToolRounds: resolveMaxToolRounds(models, model, "agentic-naive"),
                     model: modelName,
                     provider,
                 }),
@@ -120,7 +135,7 @@ function buildAgenticProviders(models, source, searchMode, _allowedOrigins) {
             config: {
                 ...mergeConfig(models.defaults, model.config, {
                     agentMode: "optimized",
-                    maxToolRounds: models.defaults.maxToolRounds ?? 5,
+                    maxToolRounds: resolveMaxToolRounds(models, model, "agentic-optimized"),
                     model: modelName,
                     provider,
                 }),
@@ -135,6 +150,26 @@ function buildAgenticProviders(models, source, searchMode, _allowedOrigins) {
     }
     return providers;
 }
+/**
+ * Resolve `maxToolRounds` for an agentic variant (W0134).
+ *
+ * Most-specific wins: per-model `config.maxToolRounds` > per-variant
+ * `defaults.modeMaxToolRounds[variant]` > global `defaults.maxToolRounds`
+ * > hard fallback (5).
+ */
+export function resolveMaxToolRounds(models, model, variant) {
+    const perModel = model.config?.maxToolRounds;
+    if (typeof perModel === "number")
+        return perModel;
+    const modeOverrides = models.defaults.modeMaxToolRounds;
+    const perVariant = modeOverrides?.[variant];
+    if (typeof perVariant === "number")
+        return perVariant;
+    const globalDefault = models.defaults.maxToolRounds;
+    if (typeof globalDefault === "number")
+        return globalDefault;
+    return 5;
+}
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

package/dist/pipeline/eval-fingerprint.d.ts

@@ -6,30 +6,35 @@
  * pipeline can query the Sanity Content Lake for a previous report with an
  * identical fingerprint and skip the expensive eval step.
  *
- * The fingerprint captures everything that would change evaluation results:
+ * The fingerprint captures:
  * - Evaluation mode (baseline, observed, agentic)
- * - Model configuration (which models, their settings)
  * - Grader model identity (different graders score differently)
- * - Prompt templates (different instructions → different outputs)
- * - Rubric templates (different criteria → different scores)
- * - Task definitions (what's being evaluated)
- * - Reference solutions (used by grader assertions)
- * - Documentation content (the docs being evaluated — the primary variable)
- * - Filter flags (which subset of tasks is included)
+ * - The task set that was actually loaded for this run, in its canonical
+ *   shape (taken straight from `ctx.taskSource.loadTasks(filter)` so that
+ *   Studio-authored task edits in the Content Lake are picked up — pre-v2
+ *   the fingerprint walked `tasks/` on disk and missed them entirely).
+ * - Repo-tracked config (models, prompts, rubrics) and reference solutions.
+ * - Fetched canonical doc content (contexts/canonical/*.md).
  *
  * The fingerprint intentionally EXCLUDES:
- * - Source name/URL (content matters, not origin)
- * - Git metadata (informational, not eval-affecting)
- * - Trigger type (manual vs CI → same inputs → same results)
- * - Report tags (human labels)
+ * - Source name/URL (content matters, not origin).
+ * - Git metadata (informational, not eval-affecting).
+ * - Trigger type (manual vs CI → same inputs → same results).
+ * - Report tags (human labels).
  *
  * @see docs/design-docs/content-lake-eval-caching.md
  */
-import type { EvalMode, FilterOptions } from "./types.js";
+import type { GeneralizedTaskDefinition } from "../_vendor/ailf-core/index.d.ts";
+import type { EvalMode } from "../_vendor/ailf-shared/index.d.ts";
 /** Inputs needed to compute an evaluation fingerprint. */
 export interface FingerprintInput {
-    /** Filter options (areas, taskIds) — determines which tasks are included */
-    filter?: FilterOptions;
+    /**
+     * Task definitions returned by `ctx.taskSource.loadTasks(filter)` after
+     * any release-auto-scope narrowing has been applied. The fingerprint
+     * captures whatever set the pipeline is actually about to evaluate, so
+     * filter changes are reflected implicitly.
+     */
+    tasks: readonly GeneralizedTaskDefinition[];
     /** Grader model identifier (e.g., "anthropic:messages:claude-opus-4-5-20251101") */
     graderModel: string;
     /** Evaluation mode */
@@ -37,30 +42,23 @@ export interface FingerprintInput {
     /** Path to the packages/eval root directory */
     rootDir: string;
 }
-/**
- * Collect all file paths that contribute to the evaluation fingerprint.
- *
- * This is similar to `getStepInputPaths()` in `cache.ts` but is more
- * comprehensive and explicitly designed for cross-environment cache keys:
- *
- * - Includes `config/prompts` and `config/rubrics` directly
- *   (the local cache only includes them indirectly via generated configs)
- * - Includes `config/models` (model configuration)
- * - Includes task definitions and reference solutions
- * - Includes the actual documentation content (contexts/canonical/*.md)
- * - Respects filter flags to only include relevant files
- */
-export declare function collectFingerprintInputPaths(rootDir: string, filter?: FilterOptions): string[];
 /**
  * Compute a deterministic SHA-256 fingerprint of all evaluation inputs.
  *
- * The fingerprint is content-addressed: identical inputs always produce
- * the same fingerprint, regardless of the environment (local, CI, etc.).
- *
- * Reuses the existing `hashFiles()` from `cache.ts` to hash file content,
- * and adds non-file context (mode, grader model, filter flags) as
- * additional context strings.
+ * Identical inputs always produce the same fingerprint, regardless of the
+ * environment (local, CI, etc.). Cross-environment portability relies on
+ * (a) tasks coming from the same Content Lake source and (b) file paths
+ * being hashed as rootDir-relative.
  *
  * @returns SHA-256 hex string (64 characters)
  */
 export declare function computeEvalFingerprint(input: FingerprintInput): string;
+/**
+ * Collect repo-tracked + fetched file paths that contribute to the
+ * fingerprint. Tasks are NOT collected here — they come from
+ * `ctx.taskSource.loadTasks()` and flow into the hash via the `tasks`
+ * input on `computeEvalFingerprint`.
+ *
+ * Exported for the debug-fingerprint diagnostic script.
+ */
+export declare function collectFingerprintFilePaths(rootDir: string): string[];