@sanity/ailf 2.8.0 → 3.0.0

package/dist/_vendor/ailf-core/services/slim-report-summary.js

@@ -0,0 +1,217 @@
+/**
+ * slim-report-summary.ts
+ *
+ * Pure transformer: a full `ScoreSummary` (the shape of `score-summary.json`)
+ * into the slim `ReportSummary` that Phase C of D0033 publishes on the
+ * Report Content-Lake document. Inlined prose and long arrays are replaced
+ * with `id` references to external artifacts (graderJudgments, failureModes,
+ * gapReport, traces).
+ *
+ * **The `id` principle**: every slim reference carries the manifest entry
+ * key of the external artifact it points at, produced by the descriptor's
+ * own `formatEntryKey(axes)`. Studio looks the id up in `Report.artifactManifest`
+ * to get the preview, and hydrates the full payload on drill-down.
+ *
+ * @see docs/decisions/D0033-unified-run-anchored-artifact-capture.md (§ M7)
+ * @see docs/work-items/W0051-report-slim-down-manifest-preview-hooks.json
+ */
+import { ARTIFACT_REGISTRY } from "../artifact-registry.js";
+/**
+ * Transform a full pipeline `ScoreSummary` into its slim Report counterpart.
+ *
+ * Each of the four heavy fields is reshaped independently; everything else
+ * flows through untouched via structural spread. Pure function — the input
+ * summary is not mutated.
+ *
+ * @param mode The evaluation mode (used to populate the `mode` axis on slim
+ *             judgment / failure-mode ids). `score-summary.json` carries
+ *             the mode in `evaluationMode` but the publisher supplies it
+ *             explicitly to keep the helper independent of that field.
+ */
+export function buildSlimReportSummary(summary, mode) {
+    const { agentBehavior: fullAgentBehavior, failureModes: fullFailureModes, lowScoringJudgments: fullJudgments, recommendations: fullRecommendations, ...rest } = summary;
+    return {
+        ...rest,
+        ...(fullJudgments
+            ? { lowScoringJudgments: slimJudgments(fullJudgments, mode) }
+            : {}),
+        ...(fullFailureModes
+            ? { failureModes: slimFailureModes(fullFailureModes, mode) }
+            : {}),
+        ...(fullRecommendations
+            ? { recommendations: slimRecommendations(fullRecommendations) }
+            : {}),
+        ...(fullAgentBehavior
+            ? { agentBehavior: slimAgentBehavior(fullAgentBehavior) }
+            : {}),
+    };
+}
+// ---------------------------------------------------------------------------
+// Judgments — axes {mode, task, model, grader}
+// ---------------------------------------------------------------------------
+/**
+ * Variant-suffix stripper. Judgments' `taskId` today carries `(gold)` /
+ * `(baseline)` suffixes that encode the pipeline mode. We strip the suffix
+ * to build the canonical `task` axis value and use the caller-supplied
+ * `mode` for the `mode` axis — matching how `formatEntryKey` is computed
+ * at producer emit time.
+ */
+function splitTaskVariant(taskId) {
+    const match = /\s*\((gold|baseline)\)\s*$/i.exec(taskId);
+    if (!match)
+        return { task: taskId, variant: null };
+    return {
+        task: taskId.slice(0, match.index).trim(),
+        variant: match[1].toLowerCase(),
+    };
+}
+function slimJudgments(full, defaultMode) {
+    const descriptor = ARTIFACT_REGISTRY.graderJudgments;
+    const formatKey = descriptor.formatEntryKey;
+    if (!formatKey) {
+        throw new Error("slimJudgments: graderJudgments descriptor is missing formatEntryKey");
+    }
+    return full.map((j) => {
+        const { task, variant } = splitTaskVariant(j.taskId);
+        // The judgment's task variant overrides the caller-supplied mode when
+        // present — a single summary run may carry judgments from both the
+        // gold and baseline halves of a literacy run.
+        const mode = variant ?? defaultMode;
+        const graderId = j.dimension;
+        const id = formatKey({
+            mode,
+            task,
+            model: j.modelId,
+            grader: graderId,
+        });
+        const reason = typeof j.reason === "string" ? j.reason : "";
+        const reasonPreview = reason.length > 280 ? reason.slice(0, 280) : reason;
+        return {
+            id,
+            taskId: j.taskId,
+            modelId: j.modelId,
+            graderId,
+            // Legacy alias — pre-W0051 Studio readers access `.dimension`.
+            // Removed in Slice 6 when those consumers migrate.
+            dimension: graderId,
+            score: j.score,
+            // Inline fallback for offline/cache-skipped runs whose manifest is
+            // empty. Truncated to match the graderJudgments descriptor preview
+            // schema so either source renders identically at the same cap.
+            reasonPreview,
+            // Legacy alias — same truncated text under the old name.
+            reason: reasonPreview,
+        };
+    });
+}
+// ---------------------------------------------------------------------------
+// Failure modes — axes {mode, category}, top-N by count
+// ---------------------------------------------------------------------------
+const FAILURE_MODE_TOP_N = 5;
+function slimFailureModes(full, defaultMode) {
+    const descriptor = ARTIFACT_REGISTRY.failureModes;
+    const formatKey = descriptor.formatEntryKey;
+    if (!formatKey) {
+        throw new Error("slimFailureModes: failureModes descriptor is missing formatEntryKey");
+    }
+    const counts = { ...full.summary };
+    const nonZero = Object.entries(counts).filter(([, n]) => n > 0);
+    nonZero.sort((a, b) => b[1] - a[1]);
+    const topTitles = nonZero
+        .slice(0, FAILURE_MODE_TOP_N)
+        .map(([category, count]) => ({
+        id: formatKey({ mode: defaultMode, category }),
+        category,
+        severity: severityForCount(count),
+        title: toTitleCase(category),
+        count,
+    }));
+    return {
+        counts,
+        topTitles,
+        totalJudgments: full.totalJudgments,
+        classificationRate: full.classificationRate,
+    };
+}
+function severityForCount(count) {
+    if (count >= 10)
+        return "critical";
+    if (count >= 5)
+        return "high";
+    if (count >= 2)
+        return "medium";
+    return "low";
+}
+function toTitleCase(id) {
+    return id
+        .split("-")
+        .map((w) => (w.length === 0 ? w : w[0].toUpperCase() + w.slice(1)))
+        .join(" ");
+}
+// ---------------------------------------------------------------------------
+// Recommendations — bulk artifact; id is a synthetic area--mode composite
+// ---------------------------------------------------------------------------
+const RECOMMENDATION_TOP_N = 3;
+function slimRecommendations(full) {
+    const counts = {};
+    for (const gap of full.gaps) {
+        counts[gap.area] = (counts[gap.area] ?? 0) + 1;
+    }
+    // Sort by priority descending, break ties by estimatedLift.
+    const sorted = [...full.gaps].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0) ||
+        (b.estimatedLift ?? 0) - (a.estimatedLift ?? 0));
+    const top3 = sorted
+        .slice(0, RECOMMENDATION_TOP_N)
+        .map((g) => ({
+        id: gapId(g),
+        area: g.area,
+        title: toTitleCase(g.failureMode),
+        priority: g.priority,
+    }));
+    return {
+        counts,
+        top3,
+        totalGaps: full.gaps.length,
+        totalPotentialLift: full.totalPotentialLift,
+    };
+}
+/**
+ * Synthetic composite id for a gap — the gapReport artifact is bulk, so a
+ * per-gap manifest entry does not exist. This id lets Studio deduplicate
+ * gaps and deep-link within the bulk artifact.
+ */
+function gapId(g) {
+    return `${sanitizeIdSegment(g.area)}--${sanitizeIdSegment(g.failureMode)}`;
+}
+function sanitizeIdSegment(s) {
+    return s
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+// ---------------------------------------------------------------------------
+// Agent behavior — counts + first-N samples per feature
+// ---------------------------------------------------------------------------
+const BEHAVIOR_SAMPLE_N = 5;
+function slimAgentBehavior(full) {
+    return full.map((f) => {
+        const uniqueQueries = dedupe(f.searchQueries);
+        const uniqueSlugs = dedupe(f.docSlugsVisited);
+        return {
+            feature: f.feature,
+            avgDocPagesVisited: f.avgDocPagesVisited,
+            avgNetworkTimeMs: f.avgNetworkTimeMs,
+            avgSearchesPerformed: f.avgSearchesPerformed,
+            tasksWithBehaviorData: f.tasksWithBehaviorData,
+            externalDomains: f.externalDomains,
+            searchQueriesCount: uniqueQueries.length,
+            searchQueriesSample: uniqueQueries.slice(0, BEHAVIOR_SAMPLE_N),
+            docSlugsVisitedCount: uniqueSlugs.length,
+            docSlugsVisitedSample: uniqueSlugs.slice(0, BEHAVIOR_SAMPLE_N),
+        };
+    });
+}
+function dedupe(items) {
+    return [...new Set(items)];
+}

package/dist/_vendor/ailf-core/types/branded-ids.d.ts

@@ -62,6 +62,39 @@ export type RubricId = Brand<string, "RubricId">;
 export type FixtureId = Brand<string, "FixtureId">;
 /** Unique identifier for a build artifact */
 export type ArtifactId = Brand<string, "ArtifactId">;
+/**
+ * The dimensions an artifact is evidence about. Axes determine where the
+ * artifact lives, how its entry key is shaped, and — at module load — whether
+ * its declared layout is allowed.
+ *
+ * Unbounded axes (`task`, `model`, `trial`) force `layout: "per-entry"` at the
+ * registry invariant; the other axes are finite enough that bulk is acceptable.
+ *
+ * `category` identifies a classification bucket for artifacts that partition
+ * per-mode (e.g. `failureModes`, one entry per classified failure category —
+ * D0033 M7, W0051 Slice 2).
+ */
+export type AssociationAxis = "run" | "mode" | "task" | "model" | "grader" | "trial" | "category";
+/**
+ * The sanitized, filename-safe identifier for a single per-entry artifact
+ * object. Produced by `ArtifactDescriptor.formatEntryKey` and parsed by
+ * `parseEntryKey`; not a free-form string at runtime.
+ */
+export type EntryKey = Brand<string, "EntryKey">;
+/**
+ * The subset of `AssociationAxis` values an artifact carries at write time.
+ * Used on the writer API (`emit(type, association, payload)`) and on manifest
+ * entries so the axes that identify the entry are self-describing in storage.
+ *
+ * Canonical axes are strongly-keyed. Descriptors whose per-entry layout is
+ * discriminated by a name that isn't a pipeline axis (e.g. `sinkResults` by
+ * sink name, `callbackRequest` by callback target) read that identifier from
+ * the `name` slot. Keep ad-hoc keys out of the canonical axis list so the
+ * module-load invariant (unbounded-axis ⇒ per-entry) stays crisp.
+ */
+export type AssociationValues = Partial<Record<AssociationAxis, string | number>> & {
+    readonly name?: string;
+};
 /**
  * A success result containing a value.
  */

package/dist/_vendor/ailf-core/types/index.d.ts

@@ -10,7 +10,8 @@
  * re-export barrel that preserves backward compatibility.
  */
 import type { DocumentRef as _DocumentRef, EvalMode, RunContext } from "../../ailf-shared/index.d.ts";
-import type { RunId } from "./branded-ids.js";
+import type { ArtifactType } from "../artifact-registry.js";
+import type { AssociationValues, RunId } from "./branded-ids.js";
 export type { ActualScoreEntry, ComponentResult, TestResult, UrlMetadata, } from "./scoring-input.js";
 export type { DocumentRef, RunContext, RunTrigger } from "../../ailf-shared/index.d.ts";
 export type { StoredBaseline, StoredReport, StoredRun, StoredTaskResult, StoredTrace, SchemaVersioned, } from "./storage-schema.js";
@@ -22,7 +23,7 @@ export { evalModeType } from "./eval-mode-config.js";
 export type { DependencyEdge, ResolvedFixture, TaskGraph, TaskNode, } from "./task-graph.js";
 export type { VariableDeclaration, VariableEnvelope, VariableProvenance, VariableSource, } from "./variable-envelope.js";
 export type { EvalTrace, ToolCallCategory, ToolCallRecord, TraceEvent, TraceSpan, TraceTokenUsage, } from "./trace.js";
-export type { ArtifactId, Brand, Err, FixtureId, IdValidationError, NewReportId, Ok, ProviderId, PromptId, Result, ResultId, RubricId, RunFingerprint, RunId, SuiteId, TaskId, TaskSlug, TraceId, } from "./branded-ids.js";
+export type { ArtifactId, AssociationAxis, AssociationValues, Brand, EntryKey, Err, FixtureId, IdValidationError, NewReportId, Ok, ProviderId, PromptId, Result, ResultId, RubricId, RunFingerprint, RunId, SuiteId, TaskId, TaskSlug, TraceId, } from "./branded-ids.js";
 export { err, fixtureId, generateRunId, ok, providerId, resultId, runId, suiteId, taskId, traceId, } from "./branded-ids.js";
 export type { AgentHarnessTaskDefinition, CustomTaskDefinition, GeneralizedAssertionDefinition, GeneralizedDocRef, GeneralizedTaskDefinition, GeneralizedTemplatedAssertion, GeneralizedValueAssertion, IdDocRef, KnowledgeProbeTaskDefinition, LiteracyTaskDefinition, MCPServerTaskDefinition, PathDocRef, PerspectiveDocRef, RubricRef, SlugDocRef, TaskCommonFields, TaskDifficulty, TaskOptions, TaskProviderConfig, TaskStatus, } from "./generalized-task.js";
 type DocumentRef = _DocumentRef;
@@ -901,6 +902,142 @@ export interface ScoreSummary {
     };
     timestamp: string;
 }
+/**
+ * The subset of `ScoreSummary` the `compare()` primitive reads and the
+ * only fields consumers of `ComparisonReport.baseline` / `.experiment`
+ * access at runtime. Both the full pipeline `ScoreSummary` and the slim
+ * `ReportSummary` (W0051) carry these fields unchanged, so stored Reports
+ * can participate in auto-compare without re-hydrating prose fields.
+ */
+export type ComparableSummary = Pick<ScoreSummary, "overall" | "perModel" | "scores">;
+/**
+ * Slim pointer to a single low-scoring grader judgment. Replaces the full
+ * `StoredJudgment` inlined on pre-W0051 reports. The `id` field IS the
+ * `graderJudgments` manifest entry key — Studio looks up `reasonPreview`
+ * there for list rendering and hydrates the full reason on drill-down.
+ *
+ * `reasonPreview` is ALSO carried inline as a graceful-degradation fallback
+ * for runs whose `artifactManifest` is empty (offline dev, failed GCS
+ * upload, cache-skip before manifest aggregation lands). At ~280 chars per
+ * judgment × the 50-judgment cap ≈ 14 KB on the Report — tiny against the
+ * 500 KB budget. Studio's dispatch prefers the manifest-entry preview when
+ * present so GCS drill-down still renders the hydrated-on-demand copy.
+ *
+ * `graderId` replaces the historical `dimension` field at the slim-shape
+ * boundary to match D0033 axis naming; runtime value is identical.
+ */
+export interface SlimJudgmentRef {
+    /** Manifest entry key = `formatEntryKey({mode, task, model, grader})` for `graderJudgments`. */
+    id: string;
+    taskId: string;
+    modelId: string;
+    /** Rubric dimension name at runtime (what `GraderJudgment.dimension` carries). */
+    graderId: string;
+    /**
+     * Alias of `graderId` — carried for pre-W0051 Studio readers that still
+     * access `.dimension` (JudgmentList, judgment-formatting, et al). Remove
+     * in Slice 6 when those consumers migrate to `graderId`. Identical
+     * runtime value; no additional ambiguity.
+     */
+    dimension: string;
+    /** Normalized 0–100 score. */
+    score: number;
+    /**
+     * Truncated grader reason (≤280 chars). Inline fallback used when the
+     * manifest entry's preview is unavailable; the authoritative full reason
+     * lives in the `graderJudgments` external artifact.
+     */
+    reasonPreview?: string;
+    /**
+     * Alias of `reasonPreview` — legacy Studio renderers read `.reason`;
+     * expose the same truncated text under both names for the compat window.
+     * Remove alongside `dimension` in Slice 6.
+     */
+    reason?: string;
+}
+/**
+ * Slim failure-mode entry on the Report summary. One per classified
+ * `FailureModeType` bucket; `id` is the `failureModes` manifest entry key
+ * so drill-down can fetch the full category payload.
+ */
+export interface SlimFailureModeTopTitle {
+    /** Manifest entry key = `formatEntryKey({mode, category})` for `failureModes`. */
+    id: string;
+    category: string;
+    severity: "low" | "medium" | "high" | "critical";
+    title: string;
+    count: number;
+}
+/** Counts + top-N per-category summary on the Report. */
+export interface SlimFailureModesSummary {
+    /** Count by FailureModeType-ish id. */
+    counts: Record<string, number>;
+    /** Top-N categories by count, descending. */
+    topTitles: SlimFailureModeTopTitle[];
+    /** Total classified judgments across all categories. */
+    totalJudgments: number;
+    /** Percentage of judgments that landed in a non-unclassified bucket. */
+    classificationRate: number;
+}
+/**
+ * Slim gap pointer. The `gapReport` artifact is bulk (axes: `{run}`) so
+ * there is no per-gap manifest entry to point at — `id` is a stable
+ * synthetic composite so the UI can deduplicate and deep-link. Drill-down
+ * reads the full `gapReport` artifact and filters by id.
+ */
+export interface SlimRecommendationGap {
+    /** Synthetic id: `${area}--${failureMode}`, kebab-safe. */
+    id: string;
+    area: string;
+    title: string;
+    /** Priority bucketing for triage UI ordering. */
+    priority: number;
+}
+/** Counts + top-3 summary on the Report. */
+export interface SlimRecommendations {
+    /** Count of gaps by area. */
+    counts: Record<string, number>;
+    /** Top-3 gaps by priority, descending. */
+    top3: SlimRecommendationGap[];
+    /** Total actionable gaps identified (sum of counts). */
+    totalGaps: number;
+    /** Aggregate estimated lift (matches `GapAnalysisReport.totalPotentialLift`). */
+    totalPotentialLift: number;
+}
+/**
+ * Slim per-feature agent-behavior summary. Full `searchQueries` and
+ * `docSlugsVisited` arrays move to `traces` NDJSON; the Report keeps only
+ * counts + first-N samples for triage preview. The `firstN` cap is the
+ * producer's choice (we default to 5).
+ */
+export interface SlimAgentBehaviorFeature {
+    feature: string;
+    avgDocPagesVisited: number;
+    avgNetworkTimeMs: number;
+    avgSearchesPerformed: number;
+    tasksWithBehaviorData: number;
+    externalDomains: string[];
+    /** Distinct count of unique search queries across tasks in this feature. */
+    searchQueriesCount: number;
+    /** First-N unique search queries (bounded samples). */
+    searchQueriesSample: string[];
+    /** Distinct count of unique doc slugs visited. */
+    docSlugsVisitedCount: number;
+    /** First-N unique doc slugs (bounded samples). */
+    docSlugsVisitedSample: string[];
+}
+/**
+ * Slim `summary` field on a published `Report`. Structurally
+ * `Omit<ScoreSummary, slimmed-fields> & slim-replacements` — every
+ * pipeline-produced field survives except the four prose/array fields
+ * W0051 moves to external artifacts.
+ */
+export type ReportSummary = Omit<ScoreSummary, "agentBehavior" | "failureModes" | "lowScoringJudgments" | "recommendations"> & {
+    agentBehavior?: SlimAgentBehaviorFeature[];
+    failureModes?: SlimFailureModesSummary;
+    lowScoringJudgments?: SlimJudgmentRef[];
+    recommendations?: SlimRecommendations;
+};
 /** Result of a single pipeline step */
 export type StepResult = {
     status: "failed";
@@ -1074,8 +1211,8 @@ export interface ComparisonReport {
     areas: AreaDelta[];
     /** Per-document attribution (when changed docs are known) */
     attribution?: AttributionReport;
-    /** The "before" or "control" summary */
-    baseline: ScoreSummary;
+    /** The "before" or "control" summary (narrowed in W0051 so slim Reports compare) */
+    baseline: ComparableSummary;
     /** Aggregate deltas */
     deltas: {
         /** Overall score delta (experiment.avgScore − baseline.avgScore) */
@@ -1094,8 +1231,8 @@ export interface ComparisonReport {
             modelId: string;
         }[];
     };
-    /** The "after" or "treatment" summary */
-    experiment: ScoreSummary;
+    /** The "after" or "treatment" summary (narrowed in W0051 so slim Reports compare) */
+    experiment: ComparableSummary;
     /** When this comparison was generated */
     generatedAt: string;
     /** Areas that improved beyond the noise threshold */
@@ -1177,7 +1314,37 @@ export interface PublishResult {
     }[];
 }
 /**
- * Reference to an artifact in external object storage (GCS). See D0032.
+ * A single per-entry row in `ArtifactRef.entries`. Carries enough metadata for
+ * Studio list/triage views to render without fetching the external payload.
+ *
+ * D0033/W0049 extensions:
+ *   - `association` — the axis values that identify this entry (`{task, model}`
+ *     for testOutputs, etc.). Present only on manifests written by
+ *     `emit()`; legacy manifests omit it and readers treat absence as `{}`.
+ *   - `truncated` — whether the entry payload was capped by the descriptor's
+ *     `capBytes`. Readers treat absence as `false` (pre-W0049 manifests were
+ *     never truncated because no caps were enforced).
+ *   - `preview` — an inline summary produced by the descriptor's
+ *     `manifestPreview.extract()`. Typed via the descriptor's preview schema;
+ *     omitted when the descriptor has no `manifestPreview`. Wiring lands in
+ *     W0051; the field is reserved here so manifests written now parse there.
+ */
+export interface ArtifactRefEntry {
+    key: string;
+    bytes: number;
+    association?: AssociationValues;
+    truncated?: boolean;
+    preview?: unknown;
+}
+/**
+ * Reference to an artifact in external object storage.
+ *
+ * `store` discriminates the backend: `"gcs"` uses `bucket` as the bucket
+ * name (D0032); `"local"` uses `bucket` as the absolute rootDir path
+ * under which `path` resolves to a file on disk (D0033 / W0050 M4).
+ * Consumers (Studio retrieval, contract tests) branch on `store` only
+ * when constructing the fetch URL — the `path` is store-relative and
+ * identical across backends for the same logical artifact.
  *
  * `layout` determines the on-disk shape:
  *   - `"bulk"` — a single object at `path`. `entries` is absent.
@@ -1185,34 +1352,40 @@ export interface PublishResult {
  *     separate object at `{path}/{sanitizedKey}.json`. `entries` inlines
  *     the catalog so consumers can render drill-down states without a
  *     second list call.
+ *
+ * D0033/W0049 extensions (optional — legacy manifests parse without them):
+ *   - `truncated` on the bulk row indicates the single-object body was capped.
+ *   - `preview` on the bulk row carries a descriptor-typed summary for list
+ *     views; wiring lands in W0051.
  */
 export interface ArtifactRef {
-    store: "gcs";
+    store: "gcs" | "local";
+    /**
+     * GCS bucket name for `store: "gcs"`; absolute rootDir path for
+     * `store: "local"`. Kept as a single field so callers iterating
+     * manifest entries don't need to branch on `store` just to read the
+     * storage container.
+     */
     bucket: string;
     path: string;
     bytes?: number;
     entryCount?: number;
     layout: "bulk" | "per-entry";
-    entries?: {
-        key: string;
-        bytes: number;
-    }[];
+    entries?: ArtifactRefEntry[];
+    truncated?: boolean;
+    preview?: unknown;
 }
 /**
  * Catalog of artifact refs produced by a single pipeline run.
  *
  * Lives on `RunManifest.artifacts` (source of truth in GCS) and is
  * snapshotted onto `Report.artifactManifest` at publish time.
+ *
+ * Derived from `ArtifactType` so adding a descriptor to the registry
+ * automatically admits it to the manifest catalog — drift between the
+ * two becomes a compile error (W0049 review finding C1).
  */
-export interface ArtifactManifest {
-    testOutputs?: ArtifactRef;
-    renderedPrompts?: ArtifactRef;
-    rawResults?: ArtifactRef;
-    graderPrompts?: ArtifactRef;
-    taskDefinitions?: ArtifactRef;
-    evalResults?: ArtifactRef;
-    traces?: ArtifactRef;
-}
+export type ArtifactManifest = Partial<Record<ArtifactType, ArtifactRef>>;
 /** A published evaluation report — the atomic unit of the report store */
 export interface Report {
     /**
@@ -1232,8 +1405,14 @@ export interface Report {
     id: ReportId;
     /** What produced this report */
     provenance: ReportProvenance;
-    /** The full score summary */
-    summary: ScoreSummary;
+    /**
+     * The slim published summary. Inlined prose fields (grader reasons, full
+     * failure-mode text, gap prose, agent-behavior arrays) moved to external
+     * artifacts in W0051; see `ReportSummary` for the retained shape and
+     * `docs/decisions/D0033-unified-run-anchored-artifact-capture.md` §§ M7 for
+     * the full migration table.
+     */
+    summary: ReportSummary;
     /** Optional human-supplied label */
     tag?: string;
     /** Auto-generated descriptive title for discoverability and sharing */

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

@@ -120,10 +120,6 @@ function mapEvalConfigToResolvedConfig(config, rootDir) {
         allowedOrigins: config.allowedOrigins,
         searchMode: config.searchMode ?? "open",
         concurrency: config.concurrency,
-        captureEnabled: false,
-        captureDir: undefined,
-        captureCompress: true,
-        captureExtras: true,
         remote: false,
         apiUrl: "https://ailf-api.sanity.build",
         presets: config.presets,

package/dist/artifact-capture/accumulating-artifact-writer.d.ts

@@ -0,0 +1,50 @@
+/**
+ * accumulating-artifact-writer.ts
+ *
+ * Decorator that wraps any `ArtifactWriter` and accumulates every
+ * successful `emit()` / `appendNdjson()` return into a run-scoped
+ * manifest slice. FinalizeRunStep reads the accumulator at the end of
+ * a pipeline and writes a `runs/{runId}/manifest.json` populated with
+ * one entry per produced artifact type.
+ *
+ * Before W0051 revisit: only `calculate-scores-step` registered its
+ * ref (for `testOutputs`) into `state.artifactRefs`; every other
+ * producer discarded the returned ref. The result was empty
+ * `Report.artifactManifest` fields and no per-entry preview lookup
+ * for Studio hooks. Wrapping the writer at the composition-root level
+ * closes that gap without per-producer bookkeeping.
+ *
+ * Merging rules (per type):
+ *   - `bulk`: last-writer-wins. A pipeline that emits the same bulk
+ *     artifact twice overwrites — matches GCS semantics.
+ *   - `per-entry`: entries accumulate into a keyed map. A later emit
+ *     at the same `entries[].key` replaces the earlier one.
+ *
+ * The decorator holds no disk state; the `_resetAccumulated()` hook is
+ * for unit tests that rerun emit sequences within a single writer.
+ *
+ * @see docs/decisions/D0033-unified-run-anchored-artifact-capture.md (§ M5)
+ */
+import type { ArtifactEntry, ArtifactManifest, ArtifactRef, ArtifactType, ArtifactWriter, AssociationValues, RunId, RunManifest } from "../_vendor/ailf-core/index.d.ts";
+export declare class AccumulatingArtifactWriter implements ArtifactWriter {
+    /**
+     * Exposed so composition-root tests can assert on the underlying backend
+     * (LocalFilesystemArtifactWriter, FanoutArtifactWriter, etc.) without
+     * plumbing a separate accessor. Treat as read-only.
+     */
+    readonly inner: ArtifactWriter;
+    private readonly accumulated;
+    constructor(inner: ArtifactWriter);
+    /** Snapshot of every ref produced this far, keyed by artifact type. */
+    getAccumulatedArtifactRefs(): ArtifactManifest;
+    /** Test-only. Clears accumulated refs without touching the inner writer. */
+    _resetAccumulated(): void;
+    emit<T extends ArtifactType>(type: T, association: AssociationValues, payload: unknown): Promise<ArtifactRef | null>;
+    appendNdjson<T extends ArtifactType>(type: T, association: AssociationValues, rows: readonly unknown[]): Promise<ArtifactRef | null>;
+    writeManifest(runId: RunId, manifest: RunManifest): Promise<ArtifactRef | null>;
+    /** @deprecated — forwarded to the inner writer without accumulation. */
+    writeBulk(type: ArtifactType, runId: RunId, data: unknown): Promise<ArtifactRef | null>;
+    /** @deprecated — forwarded to the inner writer without accumulation. */
+    writePerEntry(type: ArtifactType, runId: RunId, entries: readonly ArtifactEntry[]): Promise<ArtifactRef | null>;
+    private mergeRef;
+}