@sanity/ailf 2.8.0 → 3.0.0

package/dist/orchestration/pipeline-orchestrator.js

@@ -11,6 +11,7 @@
  * each step completes. This enables the GET /v1/jobs/:jobId polling
  * endpoint to show real-time progress.
  */
+import { assoc, } from "../_vendor/ailf-core/index.js";
 import { runStep } from "./step-runner.js";
 // ---------------------------------------------------------------------------
 // Job progress reporter
@@ -75,42 +76,39 @@ async function reportJobProgress(ctx, stepName, completedSteps, totalSteps, stat
  * Capture a snapshot of the pipeline config, final state, and step results.
  * Strips secrets (API keys, tokens) from the config.
  */
-function capturePipelineContext(ctx, state, results) {
-    if (!ctx.collector.enabled)
-        return;
+async function capturePipelineContext(ctx, state, results) {
     const sanitized = Object.fromEntries(Object.entries(ctx.config).filter(([k]) => !/token|secret|key/i.test(k)));
-    ctx.collector.capture("pipeline", "pipeline-context", {
-        config: sanitized,
-        state: {
-            reportId: state.reportId,
-            evalFingerprint: state.evalFingerprint,
-            belowCritical: state.belowCritical,
-            remoteCacheHits: state.remoteCacheHits
-                ? [...state.remoteCacheHits]
-                : undefined,
-            releaseAutoScope: state.releaseAutoScope,
-            testSummary: state.testSummary,
-        },
-        steps: Object.entries(results).map(([name, result]) => ({
-            name,
-            status: result.status,
-            durationMs: result.status !== "skipped" ? result.durationMs : undefined,
-        })),
-    });
-}
-/**
- * Flush captured artifacts to disk. Non-blocking — failures are logged
- * but never affect the pipeline result.
- */
-async function flushArtifacts(ctx) {
-    if (!ctx.collector.enabled)
-        return;
+    // W0050 — migrated from ctx.collector.capture("pipeline", "pipeline-context", …)
+    // to the registry-driven emit() path. The writer handles redaction,
+    // --capture-exclude gating, and local+GCS fanout internally.
+    //
+    // Awaited (not fire-and-forget) so the write is observable by the
+    // orchestrator's caller — a fire-and-forget let the emit fall through
+    // to runtime teardown in tests with aggressive afterEach cleanup.
+    // `emit` is non-blocking internally (P5): failures return null + warn,
+    // never throw, so awaiting can't surface a rejected promise either.
     try {
-        const result = await ctx.collector.flush();
-        ctx.logger.info(`Captured ${result.artifactCount} artifacts → ${result.destination}`);
+        await ctx.artifactWriter.emit("pipelineContext", assoc(ctx), {
+            config: sanitized,
+            state: {
+                reportId: state.reportId,
+                evalFingerprint: state.evalFingerprint,
+                belowCritical: state.belowCritical,
+                remoteCacheHits: state.remoteCacheHits
+                    ? [...state.remoteCacheHits]
+                    : undefined,
+                releaseAutoScope: state.releaseAutoScope,
+                testSummary: state.testSummary,
+            },
+            steps: Object.entries(results).map(([name, result]) => ({
+                name,
+                status: result.status,
+                durationMs: result.status !== "skipped" ? result.durationMs : undefined,
+            })),
+        });
     }
     catch (err) {
-        ctx.logger.warn(`Artifact capture flush failed: ${err instanceof Error ? err.message : err}`);
+        ctx.logger.debug(`pipelineContext emit rejected: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
 // ---------------------------------------------------------------------------
@@ -169,13 +167,10 @@ export async function orchestratePipeline(ctx, steps) {
                     step: step.name,
                 }, jobUpdates);
             }
-            // Capture pipeline context and job updates before flushing
-            capturePipelineContext(ctx, state, results);
-            if (jobUpdates.length > 0) {
-                ctx.collector.capture("job-store", "job-updates", jobUpdates);
-            }
-            // Flush captured artifacts even on failure (partial capture is useful)
-            await flushArtifacts(ctx);
+            // Capture pipeline context before exiting. `job-updates` was an
+            // observability-only capture not tied to a registered artifact type;
+            // dropped in W0050. Use the JobStore path for job telemetry.
+            await capturePipelineContext(ctx, state, results);
             return {
                 belowCritical: state.belowCritical,
                 durationMs: Date.now() - pipelineStart,
@@ -229,13 +224,9 @@ export async function orchestratePipeline(ctx, steps) {
             ctx.logger.warn("Failed to report job completion — continuing");
         }
     }
-    // Capture pipeline context and job updates before flushing
-    capturePipelineContext(ctx, state, results);
-    if (jobUpdates.length > 0) {
-        ctx.collector.capture("job-store", "job-updates", jobUpdates);
-    }
-    // Flush captured artifacts (non-blocking — failures never affect pipeline result)
-    await flushArtifacts(ctx);
+    // Capture pipeline context. `job-updates` observability captures were
+    // dropped in Slice 6.1 — JobStore is the supported telemetry path.
+    await capturePipelineContext(ctx, state, results);
     return {
         belowCritical: state.belowCritical,
         durationMs,

package/dist/orchestration/steps/calculate-scores-step.d.ts

@@ -4,7 +4,7 @@
  * Calls calculateAndWriteScores() from pipeline/calculate-scores.ts with
  * typed options derived from AppContext. No env bridge needed.
  */
-import type { AppContext, PipelineState, PipelineStep, StepResult, ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
+import { type AppContext, type PipelineState, type PipelineStep, type StepResult, type ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
 export declare class CalculateScoresStep implements PipelineStep {
     readonly name = "calculate-scores";
     check(): ValidationIssue[];

package/dist/orchestration/steps/calculate-scores-step.js

@@ -6,6 +6,8 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "path";
+import { assoc, } from "../../_vendor/ailf-core/index.js";
+import { emitFileContents } from "../../artifact-capture/emit-file.js";
 import { LiteracyVariant } from "../../pipeline/normalize-mode.js";
 import { getStepInputPaths } from "../../pipeline/cache.js";
 import { buildCacheContext } from "../cache-context.js";
@@ -122,16 +124,15 @@ export class CalculateScoresStep {
             state.belowCritical = belowCritical;
         }
         // Capture score artifacts
+        // W0050 — score-summary → scoreSummary (run-scoped bulk).
+        // grader-judgments.json and test-results.json were aggregated captures
+        // without registered descriptors. graderJudgments is now per-entry
+        // ({run, mode, task, model, grader}) and lands via run-eval-step in
+        // Slice 6.6; the aggregated file is dropped.
         const resultsDir = join(ctx.config.rootDir, "results", "latest");
-        for (const file of [
-            "score-summary.json",
-            "grader-judgments.json",
-            "test-results.json",
-        ]) {
-            const filePath = join(resultsDir, file);
-            if (existsSync(filePath)) {
-                ctx.collector.captureFile("calculate-scores", file.replace(".json", ""), filePath);
-            }
+        const summaryPath = join(resultsDir, "score-summary.json");
+        if (existsSync(summaryPath)) {
+            await emitFileContents(ctx.artifactWriter, "scoreSummary", assoc(ctx), summaryPath);
         }
         // Upload testOutputs to GCS (D0032 — non-blocking, P5).
         // Read from test-results.json rather than score-summary.json: the
@@ -142,16 +143,15 @@ export class CalculateScoresStep {
         // The full responseOutput lives in the GCS artifact; PublishReportStep
         // later strips it from the inline Content Lake document when this
         // upload succeeds.
-        if (ctx.artifactWriter) {
-            const testResults = tryReadTestResults(ctx.config.rootDir);
-            if (testResults?.length) {
-                const artifactRef = await uploadTestOutputs(ctx.artifactWriter, ctx.runId, testResults);
-                if (artifactRef) {
-                    state.artifactRefs = {
-                        ...state.artifactRefs,
-                        testOutputs: artifactRef,
-                    };
-                }
+        // W0050 — ctx.artifactWriter is always present; no guard needed.
+        const testResults = tryReadTestResults(ctx.config.rootDir);
+        if (testResults?.length) {
+            const artifactRef = await uploadTestOutputs(ctx.artifactWriter, ctx.runId, testResults);
+            if (artifactRef) {
+                state.artifactRefs = {
+                    ...state.artifactRefs,
+                    testOutputs: artifactRef,
+                };
             }
         }
         const criticalSuffix = belowCritical.length > 0

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

@@ -11,7 +11,7 @@
  * @see packages/eval/src/pipeline/callback-delivery.ts
  * @see docs/design-docs/api-service-gateway.md
  */
-import type { AppContext, PipelineState, PipelineStep, StepResult, ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
+import { type AppContext, type PipelineState, type PipelineStep, type StepResult, type ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
 import { type CallbackConfig } from "../../pipeline/callback-delivery.js";
 export declare class CallbackStep implements PipelineStep {
     private readonly callback;

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

@@ -13,6 +13,7 @@
  */
 import { readFileSync } from "fs";
 import { resolve } from "path";
+import { assoc, } from "../../_vendor/ailf-core/index.js";
 import { deliverCallback, } from "../../pipeline/callback-delivery.js";
 export class CallbackStep {
     callback;
@@ -58,11 +59,12 @@ export class CallbackStep {
             reportId: state.reportId,
             summary,
         };
-        // Capture callback payload (Tier 2 — no secrets: headers are NOT captured)
-        ctx.collector.capture("callback", "callback-payload", callbackPayload);
+        // W0050 — callbackRequest/callbackResponse are per-entry artifacts
+        // keyed by the callback target URL (the `name` slot on the association).
+        const callbackName = this.callback.url;
+        await ctx.artifactWriter.emit("callbackRequest", assoc(ctx, { name: callbackName }), callbackPayload);
         const result = await deliverCallback(this.callback, callbackPayload);
-        // Capture callback response status (not the body — that's the user's system)
-        ctx.collector.capture("callback", "callback-response", {
+        await ctx.artifactWriter.emit("callbackResponse", assoc(ctx, { name: callbackName }), {
             ok: result.ok,
             attempts: result.attempts,
             error: result.error,

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

@@ -5,7 +5,7 @@
  * inlined directly from the former pipeline/steps/compare-step.ts.
  * This is an optional step — failure doesn't stop the pipeline.
  */
-import type { AppContext, PipelineStep, StepResult, ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
+import { type AppContext, type PipelineStep, type StepResult, type ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
 export declare class CompareStep implements PipelineStep {
     readonly name = "compare";
     readonly optional = true;

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

@@ -7,6 +7,8 @@
  */
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, } from "fs";
 import { join, resolve } from "path";
+import { assoc, } from "../../_vendor/ailf-core/index.js";
+import { emitFileContents } from "../../artifact-capture/emit-file.js";
 import { compare } from "../../pipeline/compare.js";
 export class CompareStep {
     name = "compare";
@@ -69,8 +71,8 @@ export class CompareStep {
         mkdirSync(ctx.config.outputDir, { recursive: true });
         const reportPath = resolve(ctx.config.outputDir, "comparison-report.json");
         writeFileSync(reportPath, JSON.stringify(report, null, 2));
-        // Capture comparison report
-        ctx.collector.captureFile("compare", "comparison-report", reportPath);
+        // W0050 — comparisonReport is per-entry keyed by mode ({run, mode}).
+        await emitFileContents(ctx.artifactWriter, "comparisonReport", assoc(ctx, { mode: ctx.config.mode }), reportPath);
         // Build summary
         const improved = report.improved.length;
         const regressed = report.regressed.length;

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

@@ -4,7 +4,7 @@
  * Calls pure functions from pipeline/discovery-report.ts directly.
  * Optional step — failure doesn't stop the pipeline.
  */
-import type { AppContext, PipelineStep, StepResult, ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
+import { type AppContext, type PipelineStep, type StepResult, type ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
 export declare class DiscoveryReportStep implements PipelineStep {
     readonly name = "discovery-report";
     readonly optional = true;

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

@@ -6,6 +6,8 @@
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { resolve } from "path";
+import { assoc, } from "../../_vendor/ailf-core/index.js";
+import { emitFileContents } from "../../artifact-capture/emit-file.js";
 import { formatDiscoveryMarkdown, generateDiscoveryReport, } from "../../pipeline/discovery-report.js";
 export class DiscoveryReportStep {
     name = "discovery-report";
@@ -38,7 +40,8 @@ export class DiscoveryReportStep {
             mkdirSync(ctx.config.outputDir, { recursive: true });
             const discoveryPath = resolve(ctx.config.outputDir, "discovery-report.md");
             writeFileSync(discoveryPath, md);
-            ctx.collector.captureFile("discovery-report", "discovery-report", discoveryPath);
+            // W0050 — discoveryReport is per-entry keyed by mode.
+            await emitFileContents(ctx.artifactWriter, "discoveryReport", assoc(ctx, { mode: ctx.config.mode }), discoveryPath);
             console.log(md);
             const invisible = report.invisibleDocs.length;
             const f1 = report.overall.avgF1.toFixed(2);

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

@@ -12,7 +12,8 @@
  */
 import { existsSync, mkdirSync, writeFileSync } from "fs";
 import { join } from "path";
-import { isIdRef, isPathRef, isSlugRef, } from "../../_vendor/ailf-core/index.js";
+import { assoc, isIdRef, isPathRef, isSlugRef, } from "../../_vendor/ailf-core/index.js";
+import { emitFileContents } from "../../artifact-capture/emit-file.js";
 import { getStepInputPaths } from "../../pipeline/cache.js";
 import { buildCacheContext } from "../cache-context.js";
 import { checkCanonicalContextsExist } from "../../pipeline/checks.js";
@@ -94,20 +95,13 @@ export class FetchDocsStep {
             if (result.metadata) {
                 writeMetadataFiles(ctx.config.rootDir, result.metadata);
             }
-            // Capture metadata files (mode-specific extras)
-            if (ctx.collector.extrasEnabled) {
-                const contextsDir = join(ctx.config.rootDir, "contexts");
-                for (const [type, filename] of [
-                    ["document-manifest", "document-manifest.json"],
-                    ["release-impact", "release-impact.json"],
-                    ["document-overlay", "document-overlay.json"],
-                    ["url-fetch", "url-fetch.json"],
-                ]) {
-                    const filePath = join(contextsDir, filename);
-                    if (existsSync(filePath)) {
-                        ctx.collector.captureFile("fetch-docs", type, filePath);
-                    }
-                }
+            // W0050 — documentManifest is run-scoped bulk JSON. The
+            // release-impact/document-overlay/url-fetch captures had no
+            // registered descriptors (they were extras-only); dropped per Q3
+            // ("producers always call emit; registered types only").
+            const documentManifestPath = join(ctx.config.rootDir, "contexts", "document-manifest.json");
+            if (existsSync(documentManifestPath)) {
+                await emitFileContents(ctx.artifactWriter, "documentManifest", assoc(ctx), documentManifestPath);
             }
         }
         catch (err) {

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

@@ -17,6 +17,7 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
+import { AccumulatingArtifactWriter } from "../../artifact-capture/accumulating-artifact-writer.js";
 import { buildRunContext } from "../../pipeline/run-context.js";
 import { loadSource } from "../../sources.js";
 import { configToSourceOverrides } from "../config-to-source-overrides.js";
@@ -34,12 +35,11 @@ export class FinalizeRunStep {
     }
     async execute(ctx, state) {
         const start = Date.now();
-        if (!ctx.artifactWriter) {
-            return {
-                status: "skipped",
-                reason: "No artifactWriter wired — manifest is only written when a writer is available",
-            };
-        }
+        // W0050 — `ctx.artifactWriter` is now required on AppContext
+        // (composition root always provides one; NoOpArtifactWriter when
+        // `--no-artifacts`). The pre-W0050 guard that returned "skipped" has
+        // been removed — a NoOp writer's writeManifest returns null and the
+        // code below already handles that as a non-blocking failure.
         // Resolve the source (same input buildProvenance uses).
         const overrides = configToSourceOverrides(ctx.config);
         const resolvedSource = loadSource(ctx.config.source, overrides);
@@ -57,6 +57,20 @@ export class FinalizeRunStep {
             source: resolvedSource,
             taskIds: ctx.config.tasks,
         });
+        // W0051 revisit: the composition-root wraps `ctx.artifactWriter` in
+        // `AccumulatingArtifactWriter`, which keeps a map of every ref any
+        // producer emitted this run. Merge that into `state.artifactRefs` so
+        // the manifest reflects the FULL set — not just the subset producers
+        // happened to register manually. When the writer is a NoOp / plain
+        // decorator without accumulation, `aggregated` stays empty and the
+        // manifest falls back to the producer-side registration.
+        const aggregated = ctx.artifactWriter instanceof AccumulatingArtifactWriter
+            ? ctx.artifactWriter.getAccumulatedArtifactRefs()
+            : {};
+        const artifacts = {
+            ...aggregated,
+            ...(state.artifactRefs ?? {}),
+        };
         const manifest = {
             version: 1,
             runId: ctx.runId,
@@ -68,7 +82,7 @@ export class FinalizeRunStep {
                 ? { testSummary: state.testSummary }
                 : undefined,
             promptfooUrls: state.promptfooUrls,
-            artifacts: state.artifactRefs ?? {},
+            artifacts,
         };
         const ref = await ctx.artifactWriter.writeManifest(ctx.runId, manifest);
         if (!ref) {

package/dist/orchestration/steps/gap-analysis-step.js

@@ -16,7 +16,8 @@
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join, resolve } from "path";
-import { isSlugRef } from "../../_vendor/ailf-core/index.js";
+import { assoc, isSlugRef } from "../../_vendor/ailf-core/index.js";
+import { emitFileContents } from "../../artifact-capture/emit-file.js";
 export class GapAnalysisStep {
     name = "gap-analysis";
     optional = true;
@@ -194,14 +195,29 @@ export class GapAnalysisStep {
                 ...(testResults !== undefined && { testResults }),
             };
             writeFileSync(scoreSummaryPath, JSON.stringify(enrichedSummary, null, 2));
-            // Capture gap analysis artifacts
-            const failureModesPath = join(outDir, "failure-modes.json");
-            if (existsSync(failureModesPath)) {
-                ctx.collector.captureFile("gap-analysis", "failure-modes", failureModesPath);
+            // W0051 Slice 2 — failureModes is per-entry keyed by {mode, category};
+            // one entry per classified FailureModeType. Zero-count categories are
+            // skipped to keep the manifest honest about what the run surfaced.
+            const classifiedByCategory = new Map();
+            for (const cj of failureModeReport.classifiedJudgments) {
+                const cat = cj.classification.mode;
+                const bucket = classifiedByCategory.get(cat) ?? [];
+                bucket.push(cj);
+                classifiedByCategory.set(cat, bucket);
+            }
+            for (const [category, classified] of classifiedByCategory) {
+                if (classified.length === 0)
+                    continue;
+                await ctx.artifactWriter.emit("failureModes", assoc(ctx, { mode: ctx.config.mode, category }), {
+                    category,
+                    count: classified.length,
+                    title: toTitleCase(category),
+                    judgments: classified.map((c) => c.judgment),
+                });
             }
             const gapReportPath = join(outDir, "gap-analysis.json");
             if (existsSync(gapReportPath)) {
-                ctx.collector.captureFile("gap-analysis", "gap-report", gapReportPath);
+                await emitFileContents(ctx.artifactWriter, "gapReport", assoc(ctx), gapReportPath);
             }
             const gapCount = gapReport.gaps.length;
             const classRate = failureModeReport.classificationRate.toFixed(0);
@@ -223,6 +239,18 @@ export class GapAnalysisStep {
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
+/**
+ * Render a kebab-case FailureModeType id as Title Case for the manifest
+ * entry's display title (e.g. `"missing-docs"` → `"Missing Docs"`). Kept
+ * local to the producer so the registry descriptor stays decoupled from
+ * eval-side types.
+ */
+function toTitleCase(id) {
+    return id
+        .split("-")
+        .map((w) => (w.length === 0 ? w : w[0].toUpperCase() + w.slice(1)))
+        .join(" ");
+}
 /**
  * Extract slug strings from polymorphic canonical doc refs.
  *

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, PipelineState, PipelineStep, StepResult, ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
+import { type AppContext, 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. */

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

@@ -10,6 +10,8 @@
  */
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
+import { assoc, } from "../../_vendor/ailf-core/index.js";
+import { emitFileContents } from "../../artifact-capture/emit-file.js";
 import { LiteracyVariant } from "../../pipeline/normalize-mode.js";
 import { modelMatchesLiteracyVariant } from "../../pipeline/compiler/mode-bases/literacy.js";
 import { getStepInputPaths } from "../../pipeline/cache.js";
@@ -136,12 +138,14 @@ export class GenerateConfigsStep {
             maxConcurrency: models.maxConcurrency,
             logger: ctx.logger,
         });
-        // Capture generated config files (use configFileForMode for legacy naming)
+        // W0050 — configSnapshot is per-entry keyed by mode. For literacy,
+        // each variant produces a distinct config, so the variant name is the
+        // mode-axis value here.
         const { configFileForMode } = await import("../../pipeline/eval-constants.js");
         for (const variant of ["baseline", "agentic", "observed"]) {
             const configPath = resolve(ctx.config.rootDir, configFileForMode(variant));
             if (existsSync(configPath)) {
-                ctx.collector.captureFile("generate-configs", `promptfoo-config-${variant}`, configPath, { mode: "literacy", variant });
+                await emitFileContents(ctx.artifactWriter, "configSnapshot", assoc(ctx, { mode: `literacy-${variant}` }), configPath);
             }
         }
         return this.checkLiteracyPostconditions(ctx, start);
@@ -187,18 +191,14 @@ export class GenerateConfigsStep {
             maxConcurrency: models.maxConcurrency,
             logger: ctx.logger,
         });
-        // Capture generated config file
+        // W0050 — configSnapshot for a single-mode compile.
         const configPath = resolve(ctx.config.rootDir, `promptfooconfig.${mode}.yaml`);
         if (existsSync(configPath)) {
-            ctx.collector.captureFile("generate-configs", "promptfoo-config", configPath, { mode });
-        }
-        // Capture mode-specific test artifacts (extras)
-        if (ctx.collector.extrasEnabled) {
-            const testsPath = resolve(ctx.config.rootDir, "results", "latest", `${mode}-tests.json`);
-            if (existsSync(testsPath)) {
-                ctx.collector.captureFile("generate-configs", `${mode}-tests`, testsPath, { mode });
-            }
+            await emitFileContents(ctx.artifactWriter, "configSnapshot", assoc(ctx, { mode }), configPath);
         }
+        // W0050 — the mode-specific `${mode}-tests.json` file was an
+        // extras-only capture with no registered descriptor. Dropped; the
+        // same information lives in the configSnapshot + rawResults chain.
         return {
             durationMs: Date.now() - start,
             status: "success",

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

@@ -10,7 +10,7 @@
  * - P5: Local-first (pipeline never fails because of a store write)
  * - P6: Sinks are fire-and-forget (failures logged, not thrown)
  */
-import type { AppContext, PipelineState, PipelineStep, PromptfooUrlEntry, StepResult, ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
+import { type AppContext, type PipelineState, type PipelineStep, type PromptfooUrlEntry, type StepResult, type ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
 export declare class PublishReportStep implements PipelineStep {
     private readonly pipelineStart;
     private readonly options;

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

@@ -12,6 +12,7 @@
  */
 import { readFileSync } from "fs";
 import { resolve } from "path";
+import { assoc, buildSlimReportSummary, } from "../../_vendor/ailf-core/index.js";
 import { checkScoreSummaryValid } from "../../pipeline/checks.js";
 import { buildProvenance, } from "../../pipeline/provenance.js";
 import { generateReportTitle } from "../../pipeline/report-title.js";
@@ -103,13 +104,19 @@ export class PublishReportStep {
             };
         }
         const title = generateReportTitle({ provenance });
+        // W0051 Slice 3: transform the full pipeline-internal ScoreSummary into
+        // the slim ReportSummary that lives on the Content Lake document.
+        // Prose fields (grader reasons, failureModes full text, gap prose,
+        // agentBehavior arrays) point at their external artifacts via
+        // `id = manifestEntryKey`; Studio hydrates on drill-down.
+        const slimSummary = buildSlimReportSummary(summary, ctx.config.mode);
         const report = {
             comparison: comparison ?? undefined,
             completedAt: now,
             durationMs,
             id: reportId,
             provenance,
-            summary,
+            summary: slimSummary,
             tag: this.options.publishTag ?? ctx.config.publishTag,
             title,
         };
@@ -126,19 +133,20 @@ export class PublishReportStep {
         // full output lives in the GCS artifact. When no testOutputs artifact
         // exists, leave the inline shape intact so Studio's drill-down UI
         // falls back to it.
-        if (artifactManifest?.testOutputs && summary.testResults?.length) {
+        if (artifactManifest?.testOutputs && slimSummary.testResults?.length) {
             report.summary = {
-                ...summary,
-                testResults: summary.testResults.map(slimTestResult),
+                ...slimSummary,
+                testResults: slimSummary.testResults.map(slimTestResult),
             };
         }
         // Share reportId with downstream steps (CallbackStep + orchestrator job update)
         state.reportId = reportId;
-        // Capture report object (Tier 2)
-        ctx.collector.capture("publish-report", "report-object", report);
-        // Capture auto-comparison if present (Tier 2)
+        // W0050 — migrated from ctx.collector.capture to the unified writer.
+        // reportSnapshot: full Report JSON for replay (run-scoped, bulk).
+        await ctx.artifactWriter.emit("reportSnapshot", assoc(ctx), report);
+        // autoComparison: delta vs baseline (run-scoped, bulk, optional).
         if (comparison) {
-            ctx.collector.capture("publish-report", "auto-comparison", comparison);
+            await ctx.artifactWriter.emit("autoComparison", assoc(ctx), comparison);
         }
         // Write to store (system of record — best-effort, P5)
         const sanityResult = ctx.reportStore
@@ -146,17 +154,14 @@ export class PublishReportStep {
             : null;
         // Run sinks (fire-and-forget, P6)
         const publishResult = await runSinks(report, ctx);
-        // Capture sink results (Tier 2)
-        if (publishResult.sinkResults.length > 0) {
-            ctx.collector.capture("publish-report", "sink-results", {
-                sinkCount: publishResult.sinkResults.length,
-                results: publishResult.sinkResults.map((r) => ({
-                    name: r.name,
-                    status: r.result.status,
-                    ...(r.result.status === "success" ? { detail: r.result.detail } : {}),
-                    ...(r.result.status === "failed" ? { error: r.result.error } : {}),
-                    ...(r.result.status === "skipped" ? { reason: r.result.reason } : {}),
-                })),
+        // sinkResults: per-sink outcome (run-scoped, per-entry keyed by sink name).
+        for (const r of publishResult.sinkResults) {
+            await ctx.artifactWriter.emit("sinkResults", assoc(ctx, { name: r.name }), {
+                name: r.name,
+                status: r.result.status,
+                ...(r.result.status === "success" ? { detail: r.result.detail } : {}),
+                ...(r.result.status === "failed" ? { error: r.result.error } : {}),
+                ...(r.result.status === "skipped" ? { reason: r.result.reason } : {}),
             });
         }
         // Build result summary

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

@@ -4,7 +4,7 @@
  * Calls pure functions from pipeline/readiness-report.ts directly.
  * Optional step — failure doesn't stop the pipeline.
  */
-import type { AppContext, PipelineStep, StepResult, ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
+import { type AppContext, type PipelineStep, type StepResult, type ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
 export declare class ReadinessStep implements PipelineStep {
     readonly name = "readiness";
     readonly optional = true;

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

@@ -7,6 +7,8 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { resolve } from "path";
 import { tryLoadConfigFile } from "../../pipeline/compiler/config-loader.js";
+import { assoc, } from "../../_vendor/ailf-core/index.js";
+import { emitFileContents } from "../../artifact-capture/emit-file.js";
 import { formatReadinessMarkdown, generateReadinessReport, } from "../../pipeline/readiness-report.js";
 import { ThresholdConfigSchema } from "../../pipeline/schemas.js";
 export class ReadinessStep {
@@ -65,7 +67,8 @@ export class ReadinessStep {
                 mkdirSync(ctx.config.outputDir, { recursive: true });
                 const readinessPath = resolve(ctx.config.outputDir, "readiness-report.md");
                 writeFileSync(readinessPath, readinessLines.join("\n---\n\n"));
-                ctx.collector.captureFile("readiness", "readiness-report", readinessPath);
+                // W0050 — readinessReport is run-scoped bulk markdown.
+                await emitFileContents(ctx.artifactWriter, "readinessReport", assoc(ctx), readinessPath);
             }
             const passCount = readinessAreas.filter((area) => {
                 const areaScore = scoreSummary.scores.find((s) => s.feature === area);