@sanity/ailf 2.9.0 → 3.1.0

package/dist/_vendor/ailf-core/artifact-capture/association.d.ts

@@ -33,3 +33,40 @@ export interface AssocContext {
  * boundary actually lives.
  */
 export declare function assoc(ctx: AssocContext, partial?: Omit<AssociationValues, "run">): AssociationValues;
+/**
+ * Literacy-mode task descriptions carry a `(gold)` / `(baseline)` suffix that
+ * encodes which half of the with-docs / without-docs pair the judgment belongs
+ * to. The D0033 artifact axes treat that variant as the `mode` axis — a single
+ * promptfoo run of evaluation mode "literacy" produces artifacts whose `mode`
+ * axis is "gold" or "baseline". All producers and all readers must agree on
+ * this decomposition, or signed-URL lookups 404.
+ *
+ * This helper is the single source of truth for the split. It's shared between:
+ *   - eval's `emit-eval-results.ts` (rawResults, renderedPrompts,
+ *     graderPrompts, graderJudgments)
+ *   - eval's `upload-test-outputs.ts` (testOutputs)
+ *   - core's `slim-report-summary.ts` (slim judgment / failure-mode ids)
+ *   - studio's `JudgmentList#testOutputsKeyFor` (hover prefetch keys)
+ *
+ * Non-literacy modes (mcp-server, agent-harness, …) do not suffix their task
+ * descriptions; `splitTaskVariant` returns `variant: null` and the caller
+ * falls back to the high-level eval mode. See `resolveVariantMode`.
+ *
+ * Pure function — safe to call from browser or Node.
+ */
+export interface TaskVariantSplit {
+    /** Task id with any trailing `(gold)` / `(baseline)` suffix stripped. */
+    readonly task: string;
+    /** Lowercased variant (`"gold"` | `"baseline"`), or `null` when absent. */
+    readonly variant: "baseline" | "gold" | null;
+}
+export declare function splitTaskVariant(taskId: string): TaskVariantSplit;
+/**
+ * Resolve the `mode` axis value for an artifact association: prefer the
+ * per-task variant when present, fall back to the high-level evaluation mode.
+ * Mirrors `mode = variant ?? defaultMode` in `slim-report-summary#slimJudgments`.
+ */
+export declare function resolveVariantMode(taskId: string, defaultMode: string): {
+    mode: string;
+    task: string;
+};

package/dist/_vendor/ailf-core/artifact-capture/association.js

@@ -26,3 +26,22 @@
 export function assoc(ctx, partial = {}) {
     return { run: ctx.runId, ...partial };
 }
+const VARIANT_SUFFIX_PATTERN = /\s*\((gold|baseline)\)\s*$/i;
+export function splitTaskVariant(taskId) {
+    const match = VARIANT_SUFFIX_PATTERN.exec(taskId);
+    if (!match)
+        return { task: taskId, variant: null };
+    return {
+        task: taskId.slice(0, match.index).trim(),
+        variant: match[1].toLowerCase(),
+    };
+}
+/**
+ * Resolve the `mode` axis value for an artifact association: prefer the
+ * per-task variant when present, fall back to the high-level evaluation mode.
+ * Mirrors `mode = variant ?? defaultMode` in `slim-report-summary#slimJudgments`.
+ */
+export function resolveVariantMode(taskId, defaultMode) {
+    const { task, variant } = splitTaskVariant(taskId);
+    return { mode: variant ?? defaultMode, task };
+}

package/dist/_vendor/ailf-core/artifact-registry.d.ts

@@ -41,7 +41,7 @@ export type ArtifactMime = "application/json" | "application/x-ndjson" | "text/m
  */
 export type ArtifactTruncationPolicy = "reject" | "trailing-truncate" | "fielded-truncate" | "trial-oversize";
 /** The union of every artifact type known to AILF. */
-export type ArtifactType = "runManifest" | "scoreSummary" | "pipelineResult" | "pipelineContext" | "documentManifest" | "prComment" | "readinessReport" | "reportSnapshot" | "autoComparison" | "gapReport" | "sinkResults" | "callbackRequest" | "callbackResponse" | "configSnapshot" | "evalConfigGenerated" | "comparisonReport" | "discoveryReport" | "failureModes" | "taskDefinitions" | "renderedPrompts" | "rawResults" | "testOutputs" | "graderPrompts" | "graderJudgments" | "traces" | "evalResults";
+export type ArtifactType = "runManifest" | "scoreSummary" | "pipelineResult" | "pipelineContext" | "documentManifest" | "prComment" | "readinessReport" | "reportSnapshot" | "autoComparison" | "gapReport" | "sinkResults" | "callbackRequest" | "callbackResponse" | "configSnapshot" | "evalConfigGenerated" | "comparisonReport" | "discoveryReport" | "failureModes" | "taskDefinitions" | "renderedPrompts" | "rawResults" | "testOutputs" | "graderPrompts" | "graderJudgments" | "traces";
 /**
  * Result of parsing a per-entry key into a sanitized filename component.
  * Success carries the sanitized value; failure carries a reason for 4xx responses.

package/dist/_vendor/ailf-core/artifact-registry.js

@@ -333,7 +333,7 @@ function buildDescriptor(input) {
     };
 }
 // ---------------------------------------------------------------------------
-// The registry — 21 live descriptors + 1 deprecated (evalResults)
+// The registry — 21 live descriptors
 // ---------------------------------------------------------------------------
 /**
  * The canonical artifact descriptor for every artifact type. Iterate with
@@ -630,23 +630,6 @@ export const ARTIFACT_REGISTRY = {
         capBytes: 10_000_000,
         truncation: "trial-oversize",
     }),
-    /**
-     * @deprecated Emit removed in W0050 (no producer calls `emit("evalResults")`
-     * any more — `emit-eval-results.ts` decomposes the promptfoo aggregate into
-     * per-entry rawResults / renderedPrompts / graderPrompts / graderJudgments
-     * instead). Descriptor retained for read-compat on pre-W0050 reports until
-     * W0052 removes it entirely. No code path should re-introduce emission.
-     */
-    evalResults: buildDescriptor({
-        type: "evalResults",
-        slug: "eval-results",
-        layout: "bulk",
-        axes: ["run"],
-        entrySchema: unknownEntry,
-        mime: "application/json",
-        capBytes: 10_000_000,
-        optional: true,
-    }),
 };
 /** All artifact types in declaration order. */
 export const ARTIFACT_TYPES = Object.keys(ARTIFACT_REGISTRY);

package/dist/_vendor/ailf-core/batch-signing.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Batch signed-URL types (D0033 / W0052 M3).
+ *
+ * Contract shared between the API Gateway and Studio for the two batch
+ * endpoints that amortise signing over many artifacts in a single round-trip:
+ *
+ *   POST /v1/runs/:runId/artifacts/batch/read-urls
+ *   POST /v1/runs/:runId/artifacts/batch/upload-urls
+ *
+ * The batch shape is intentionally symmetric: request carries the set of
+ * artifact types and (for per-entry layouts) the entry keys; response carries
+ * signed URLs keyed by type and entry key. For bulk layouts the response key
+ * is the empty string, since bulk artifacts have no entry dimension.
+ *
+ * Validation is all-or-nothing per AC 4 — a single malformed entry key, an
+ * unknown artifact type, or a missing keys list for a per-entry type causes
+ * the whole request to 400 with zero signed URLs emitted.
+ *
+ * @see docs/design-docs/unified-run-artifacts.md § M3
+ * @see docs/decisions/D0033-unified-run-anchored-artifact-capture.md
+ */
+import type { ArtifactType } from "./artifact-registry.js";
+/** The empty entry-key sentinel used for bulk responses. */
+export declare const BULK_ENTRY_KEY: "";
+/**
+ * Batch request body.
+ *
+ * - `types` — the artifact types to sign. Must be non-empty. Unknown types
+ *   cause a 400.
+ * - `keys` — per-type arrays of entry keys. Required for per-entry layouts;
+ *   omitted (or an empty array) for bulk layouts. Extra keys for a bulk type
+ *   are rejected; missing keys for a per-entry type are rejected.
+ */
+export interface BatchSignRequest {
+    readonly types: readonly ArtifactType[];
+    readonly keys?: Partial<Record<ArtifactType, readonly string[]>>;
+}
+/** One signed read URL in a batch read response. */
+export interface BatchSignedReadUrl {
+    readonly url: string;
+    readonly path: string;
+    readonly expiresIn: number;
+}
+/** One signed upload URL in a batch upload response. */
+export interface BatchSignedUploadUrl {
+    readonly url: string;
+    readonly method: "PUT";
+    readonly path: string;
+    readonly expiresIn: number;
+    readonly requiredHeaders: Readonly<Record<string, string>>;
+}
+/**
+ * Batch response. Outer map is keyed by artifact type; inner map is keyed by
+ * entry key (empty string for bulk layouts). All types requested in the
+ * request body are present in the response, even when `keys[type]` was empty.
+ */
+export interface BatchSignReadResponse {
+    readonly bucket: string;
+    readonly urls: Partial<Record<ArtifactType, Readonly<Record<string, BatchSignedReadUrl>>>>;
+}
+export interface BatchSignUploadResponse {
+    readonly bucket: string;
+    readonly urls: Partial<Record<ArtifactType, Readonly<Record<string, BatchSignedUploadUrl>>>>;
+}

package/dist/_vendor/ailf-core/batch-signing.js

@@ -0,0 +1,23 @@
+/**
+ * Batch signed-URL types (D0033 / W0052 M3).
+ *
+ * Contract shared between the API Gateway and Studio for the two batch
+ * endpoints that amortise signing over many artifacts in a single round-trip:
+ *
+ *   POST /v1/runs/:runId/artifacts/batch/read-urls
+ *   POST /v1/runs/:runId/artifacts/batch/upload-urls
+ *
+ * The batch shape is intentionally symmetric: request carries the set of
+ * artifact types and (for per-entry layouts) the entry keys; response carries
+ * signed URLs keyed by type and entry key. For bulk layouts the response key
+ * is the empty string, since bulk artifacts have no entry dimension.
+ *
+ * Validation is all-or-nothing per AC 4 — a single malformed entry key, an
+ * unknown artifact type, or a missing keys list for a per-entry type causes
+ * the whole request to 400 with zero signed URLs emitted.
+ *
+ * @see docs/design-docs/unified-run-artifacts.md § M3
+ * @see docs/decisions/D0033-unified-run-anchored-artifact-capture.md
+ */
+/** The empty entry-key sentinel used for bulk responses. */
+export const BULK_ENTRY_KEY = "";

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

@@ -16,9 +16,9 @@ export * from "./ports/index.js";
 export * from "./services/index.js";
 export * from "./examples/index.js";
 export * from "./artifact-registry.js";
+export * from "./batch-signing.js";
 export { defineConfig, defineFeatures, defineModeBase, defineModels, definePricingTable, definePreset, definePrompts, defineRubrics, defineSchedules, defineSinks, defineSources, defineTask, defineThresholds, } from "./config-helpers.js";
 export type { PricingEntry, PromptEntry, SourceEntry, } from "./config-helpers.js";
 export { env } from "./env-helper.js";
-export { NoOpArtifactCollector } from "./artifact-capture/noop-collector.js";
 export { NoOpArtifactWriter, NotImplementedError, } from "./ports/artifact-writer.js";
-export { assoc, type AssocContext } from "./artifact-capture/association.js";
+export { assoc, resolveVariantMode, splitTaskVariant, type AssocContext, type TaskVariantSplit, } from "./artifact-capture/association.js";

package/dist/_vendor/ailf-core/index.js

@@ -16,11 +16,11 @@ export * from "./ports/index.js";
 export * from "./services/index.js";
 export * from "./examples/index.js";
 export * from "./artifact-registry.js";
+export * from "./batch-signing.js";
 // ---------------------------------------------------------------------------
 // Architecture overhaul — Phase 0 helpers
 // ---------------------------------------------------------------------------
 export { defineConfig, defineFeatures, defineModeBase, defineModels, definePricingTable, definePreset, definePrompts, defineRubrics, defineSchedules, defineSinks, defineSources, defineTask, defineThresholds, } from "./config-helpers.js";
 export { env } from "./env-helper.js";
-export { NoOpArtifactCollector } from "./artifact-capture/noop-collector.js";
 export { NoOpArtifactWriter, NotImplementedError, } from "./ports/artifact-writer.js";
-export { assoc } from "./artifact-capture/association.js";
+export { assoc, resolveVariantMode, splitTaskVariant, } from "./artifact-capture/association.js";

package/dist/_vendor/ailf-core/ports/context.d.ts

@@ -13,12 +13,12 @@
  */
 import type { RunId } from "../types/branded-ids.js";
 import type { DebugOptions, EvalMode, PluginRegistry } from "../types/index.js";
-import type { ArtifactCollector } from "./artifact-collector.js";
 import type { ArtifactWriter } from "./artifact-writer.js";
 import type { CacheStore } from "./cache-store.js";
 import type { DocFetcher } from "./doc-fetcher.js";
 import type { EvalRunner } from "./eval-runner.js";
 import type { Logger } from "./logger.js";
+import type { ProgressReporter } from "./progress-reporter.js";
 import type { TaskSource } from "./task-source.js";
 /**
  * Resolved pipeline configuration — the typed, validated result of
@@ -153,19 +153,10 @@ export interface ResolvedConfig {
     apiKey?: string;
     /** External preset file paths or npm package names to load */
     presets?: string[];
-    /** Whether artifact capture is enabled for this run (default: false) */
-    captureEnabled?: boolean;
-    /** Base directory for capture output (default: results/captures/) */
-    captureDir?: string;
-    /** Whether to compress capture output to tar.gz (default: true) */
-    captureCompress?: boolean;
-    /** Whether to include mode-specific extra artifacts (default: true) */
-    captureExtras?: boolean;
     /**
-     * D0033 / W0049 — the unified artifact surface. Wired into the writer in
-     * W0050; consumed by the writer factory to decide whether to attach a
-     * writer at all, where it writes to, and what to skip. These fields are
-     * additive and do not replace the legacy `capture*` fields until W0052.
+     * D0033 unified artifact surface. Consumed by the writer factory to
+     * decide whether to attach a writer at all, where it writes to, and
+     * what to skip. Legacy `capture*` fields were retired in W0052.
      */
     /** Disables all artifact writers — `--no-artifacts`. */
     artifactsDisabled?: boolean;
@@ -173,12 +164,8 @@ export interface ResolvedConfig {
     artifactsDir?: string;
     /** Run writers in dry-run mode — `--artifacts-dry-run`. */
     artifactsDryRun?: boolean;
-    /** Comma-separated artifact types to skip — `--capture-exclude`. */
+    /** Comma-separated artifact types to skip — `--artifacts-exclude`. */
     artifactsExclude?: readonly string[];
-    /** GCS bucket for capture upload (enables GCS decorator when set) */
-    captureGcsBucket?: string;
-    /** GCS object prefix for capture uploads (default: "captures/") */
-    captureGcsPrefix?: string;
     /**
      * GCS bucket for report artifact uploads. Defaults to "ailf-artifacts"
      * at the composition root — only set this to override (e.g., self-hosted
@@ -221,8 +208,6 @@ export interface AppContext {
     readonly artifactWriter: ArtifactWriter;
     /** Evaluation caching (filesystem + optional Content Lake fallback) */
     readonly cache?: CacheStore;
-    /** Artifact capture collector (no-op when --capture is not set) */
-    readonly collector: ArtifactCollector;
     /** Resolved pipeline configuration */
     readonly config: ResolvedConfig;
     /** Documentation context fetcher */
@@ -231,6 +216,13 @@ export interface AppContext {
     readonly evalRunner: EvalRunner;
     /** Structured logger */
     readonly logger: Logger;
+    /**
+     * Progress reporter — carries `phase-start / phase-progress / phase-complete`
+     * events for long-running pipeline spans (W0053). The composition root always
+     * wires one; adapters default to `NoOpProgressReporter` for quiet / JSON /
+     * test loggers.
+     */
+    readonly progress: ProgressReporter;
     /** Plugin registry — mode handlers, assertions, rubric templates, etc. */
     readonly registry: PluginRegistry;
     /**

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

@@ -4,10 +4,8 @@
  * Ports define the contracts between the domain kernel and the outside world.
  * Adapters (in packages/eval) implement these interfaces.
  */
-export type { ArtifactCollector, CaptureFlushResult, CaptureManifest, CaptureManifestEntry, } from "./artifact-collector.js";
 export type { ArtifactEntry, ArtifactWriter } from "./artifact-writer.js";
 export { NoOpArtifactWriter } from "./artifact-writer.js";
-export type { ArtifactContentDiff, CaptureDiffReport, ComparisonMode, ComparisonOptions, InventoryDiff, JsonDiffEntry, MetadataComparison, ScoreComparison, SecurityScan, TimingComparison, } from "./capture-comparator.js";
 export type { CacheEntryMetadata, CacheKey, CacheLookupResult, CacheRecordInput, CacheStore, } from "./cache-store.js";
 export type { ConfigSource } from "./config-source.js";
 export type { AppContext, ReportSinkPort, ReportStorePort, ResolvedConfig, } from "./context.js";
@@ -16,5 +14,7 @@ export type { EvalRunConfig, EvalRunner } from "./eval-runner.js";
 export type { CompilationContext, CompileResultAssertion, CompileResultPrompt, CompileResultProvider, CompileResultTestCase, ModeCompileResult, ModeHandler, ModeProviderEntry, ModeRubricConfig, PromptTemplate, } from "./mode-handler.js";
 export type { Logger } from "./logger.js";
 export type { PipelineStep } from "./pipeline-step.js";
+export type { ArtifactWriterProgressOptions, PhaseCompleteEvent, PhaseProgressEvent, PhaseStartEvent, ProgressReporter, } from "./progress-reporter.js";
+export { ARTIFACT_EXPORT_PHASE_ID, NoOpProgressReporter, } from "./progress-reporter.js";
 export type { TaskSource } from "./task-source.js";
 export { canonicalDocRefLabel, isIdRef, isPathRef, isPerspectiveRef, isSlugRef, isTemplatedAssertion, } from "./task-source.js";

package/dist/_vendor/ailf-core/ports/index.js

@@ -5,4 +5,5 @@
  * Adapters (in packages/eval) implement these interfaces.
  */
 export { NoOpArtifactWriter } from "./artifact-writer.js";
+export { ARTIFACT_EXPORT_PHASE_ID, NoOpProgressReporter, } from "./progress-reporter.js";
 export { canonicalDocRefLabel, isIdRef, isPathRef, isPerspectiveRef, isSlugRef, isTemplatedAssertion, } from "./task-source.js";

package/dist/_vendor/ailf-core/ports/progress-reporter.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Port: ProgressReporter — carries user-visible progress for long-running
+ * pipeline phases (artifact export, eval runs, etc.).
+ *
+ * Events follow a `start / progress (batch) / complete` shape. Producers
+ * publish events without formatting; the CLI adapter decides cadence,
+ * layout, and whether to render at all.
+ *
+ * Scope today: the artifact export phase that runs after promptfoo finishes
+ * evaluation (W0053). Forward-compatible with future callers — e.g. the eval
+ * phase itself once we replace promptfoo's terminal-owned progress bar.
+ *
+ * @see docs/work-items/W0053-cli-artifact-upload-progress.json
+ */
+export interface PhaseStartEvent {
+    /** Stable phase identifier. Adapters may use this to disambiguate if phases overlap. */
+    phaseId: string;
+    /** Human-readable label (e.g. `"Exporting run artifacts"`). */
+    label: string;
+    /**
+     * Optional extra context shown only on the header line (e.g. destination
+     * info such as `"local + GCS"`). Kept separate from `label` so the
+     * per-progress-line prefix stays short and scannable on every line.
+     */
+    detail?: string;
+    /** Total work expected, when known up front. */
+    totalItems?: number;
+    /** Total bytes expected, when known up front. */
+    totalBytes?: number;
+    /** Wall-clock timestamp when the phase started (ms since epoch). */
+    startedAt: number;
+}
+export interface PhaseProgressEvent {
+    phaseId: string;
+    /** Items completed in this batch. Default `1`. */
+    items?: number;
+    /** Bytes transferred in this batch. Default `0`. */
+    bytes?: number;
+    /** Label for the most recent item (e.g. artifact path). */
+    label?: string;
+}
+export interface PhaseCompleteEvent {
+    phaseId: string;
+    itemsCompleted: number;
+    bytesCompleted: number;
+    durationMs: number;
+    /** Optional override for the final summary line. */
+    summary?: string;
+}
+export interface ProgressReporter {
+    phaseStart(event: PhaseStartEvent): void;
+    phaseProgress(event: PhaseProgressEvent): void;
+    phaseComplete(event: PhaseCompleteEvent): void;
+}
+/** No-op reporter — used when progress rendering is disabled (quiet / JSON logger / tests). */
+export declare class NoOpProgressReporter implements ProgressReporter {
+    phaseStart(): void;
+    phaseProgress(): void;
+    phaseComplete(): void;
+}
+/**
+ * Canonical phase identifier for the post-eval artifact export span (W0053).
+ * Shared between writer wiring and the pipeline orchestrator so both sides
+ * publish to the same phase.
+ */
+export declare const ARTIFACT_EXPORT_PHASE_ID = "artifact-export";
+/**
+ * Options shared by artifact writer adapters that publish progress events.
+ * Kept in the port module so every writer adapter imports the same shape.
+ */
+export interface ArtifactWriterProgressOptions {
+    reporter: ProgressReporter;
+    phaseId: string;
+}

package/dist/_vendor/ailf-core/ports/progress-reporter.js

@@ -0,0 +1,26 @@
+/**
+ * Port: ProgressReporter — carries user-visible progress for long-running
+ * pipeline phases (artifact export, eval runs, etc.).
+ *
+ * Events follow a `start / progress (batch) / complete` shape. Producers
+ * publish events without formatting; the CLI adapter decides cadence,
+ * layout, and whether to render at all.
+ *
+ * Scope today: the artifact export phase that runs after promptfoo finishes
+ * evaluation (W0053). Forward-compatible with future callers — e.g. the eval
+ * phase itself once we replace promptfoo's terminal-owned progress bar.
+ *
+ * @see docs/work-items/W0053-cli-artifact-upload-progress.json
+ */
+/** No-op reporter — used when progress rendering is disabled (quiet / JSON logger / tests). */
+export class NoOpProgressReporter {
+    phaseStart() { }
+    phaseProgress() { }
+    phaseComplete() { }
+}
+/**
+ * Canonical phase identifier for the post-eval artifact export span (W0053).
+ * Shared between writer wiring and the pipeline orchestrator so both sides
+ * publish to the same phase.
+ */
+export const ARTIFACT_EXPORT_PHASE_ID = "artifact-export";

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

@@ -15,6 +15,7 @@
  * @see docs/decisions/D0033-unified-run-anchored-artifact-capture.md (§ M7)
  * @see docs/work-items/W0051-report-slim-down-manifest-preview-hooks.json
  */
+import { splitTaskVariant } from "../artifact-capture/association.js";
 import { ARTIFACT_REGISTRY } from "../artifact-registry.js";
 /**
  * Transform a full pipeline `ScoreSummary` into its slim Report counterpart.
@@ -49,22 +50,6 @@ export function buildSlimReportSummary(summary, mode) {
 // ---------------------------------------------------------------------------
 // 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;

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/adapters/progress/console-progress-reporter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * ConsoleProgressReporter — the default terminal adapter for the
+ * ProgressReporter port (W0053).
+ *
+ * Renders phase-start / phase-progress / phase-complete as human-readable
+ * lines on stdout. Progress lines are rate-limited so a high-frequency
+ * producer (one event per artifact) never floods the terminal; the adapter
+ * flushes at most once per `tickMs` (default 1s) and always flushes the
+ * final line on `phaseComplete`.
+ *
+ * `verbose: true` emits one line per item — matches the CLI's existing
+ * `--verbose` semantics without re-rendering the rate-limited line twice.
+ */
+import type { PhaseCompleteEvent, PhaseProgressEvent, PhaseStartEvent, ProgressReporter } from "../../_vendor/ailf-core/index.d.ts";
+export interface ConsoleProgressReporterOptions {
+    /** Minimum interval between rate-limited progress lines, in ms. Default 1000. */
+    tickMs?: number;
+    /** Emit one line per item rather than rate-limiting. */
+    verbose?: boolean;
+    /** Sink for output (tests override). Defaults to `console.log`. */
+    write?: (line: string) => void;
+    /** Clock (tests override). Defaults to `Date.now`. */
+    now?: () => number;
+}
+export declare class ConsoleProgressReporter implements ProgressReporter {
+    private readonly tickMs;
+    private readonly verbose;
+    private readonly write;
+    private readonly now;
+    private readonly phases;
+    constructor(options?: ConsoleProgressReporterOptions);
+    phaseStart(event: PhaseStartEvent): void;
+    phaseProgress(event: PhaseProgressEvent): void;
+    phaseComplete(event: PhaseCompleteEvent): void;
+}

package/dist/adapters/progress/console-progress-reporter.js

@@ -0,0 +1,110 @@
+/**
+ * ConsoleProgressReporter — the default terminal adapter for the
+ * ProgressReporter port (W0053).
+ *
+ * Renders phase-start / phase-progress / phase-complete as human-readable
+ * lines on stdout. Progress lines are rate-limited so a high-frequency
+ * producer (one event per artifact) never floods the terminal; the adapter
+ * flushes at most once per `tickMs` (default 1s) and always flushes the
+ * final line on `phaseComplete`.
+ *
+ * `verbose: true` emits one line per item — matches the CLI's existing
+ * `--verbose` semantics without re-rendering the rate-limited line twice.
+ */
+export class ConsoleProgressReporter {
+    tickMs;
+    verbose;
+    write;
+    now;
+    phases = new Map();
+    constructor(options = {}) {
+        this.tickMs = options.tickMs ?? 1000;
+        this.verbose = options.verbose ?? false;
+        this.write = options.write ?? ((line) => console.log(line));
+        this.now = options.now ?? (() => Date.now());
+    }
+    phaseStart(event) {
+        this.phases.set(event.phaseId, {
+            phaseId: event.phaseId,
+            label: event.label,
+            totalItems: event.totalItems,
+            totalBytes: event.totalBytes,
+            startedAt: event.startedAt,
+            itemsCompleted: 0,
+            bytesCompleted: 0,
+            lastFlushAt: event.startedAt,
+        });
+        const total = event.totalItems !== undefined ? ` (${event.totalItems} items)` : "";
+        const detail = event.detail ? ` → ${event.detail}` : "";
+        this.write("");
+        this.write(`  ➜ ${event.label}${detail}${total}…`);
+    }
+    phaseProgress(event) {
+        const state = this.phases.get(event.phaseId);
+        if (!state)
+            return;
+        state.itemsCompleted += event.items ?? 1;
+        state.bytesCompleted += event.bytes ?? 0;
+        if (this.verbose) {
+            const item = event.label ?? `item ${state.itemsCompleted}`;
+            const bytes = event.bytes ?? 0;
+            this.write(`    · ${progressPrefix(state)} ${item} (${formatBytes(bytes)})`);
+            return;
+        }
+        const now = this.now();
+        if (now - state.lastFlushAt < this.tickMs)
+            return;
+        state.lastFlushAt = now;
+        this.write(`    ${renderProgressLine(state, now)}`);
+    }
+    phaseComplete(event) {
+        const state = this.phases.get(event.phaseId);
+        // Prefer the adapter's running totals — we've been counting each batch
+        // event anyway, and most producers call `phaseComplete` without knowing
+        // cumulative numbers themselves. Fall back to the event fields when the
+        // reporter has no state (e.g. first phaseComplete without a phaseStart).
+        const itemsCompleted = Math.max(state?.itemsCompleted ?? 0, event.itemsCompleted);
+        const bytesCompleted = Math.max(state?.bytesCompleted ?? 0, event.bytesCompleted);
+        const durationMs = event.durationMs;
+        const label = state?.label ?? event.phaseId;
+        const summary = event.summary ??
+            `${itemsCompleted} item${itemsCompleted === 1 ? "" : "s"} · ${formatBytes(bytesCompleted)} · ${formatDuration(durationMs)} elapsed`;
+        this.write(`  ✓ ${label} — ${summary}`);
+        this.phases.delete(event.phaseId);
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Shared prefix used on every rate-limited and verbose progress line so the
+ * context is visible without having to scroll up to the phase header.
+ */
+function progressPrefix(state) {
+    return `${state.label}:`;
+}
+function renderProgressLine(state, now) {
+    const elapsed = formatDuration(now - state.startedAt);
+    const itemsPart = state.totalItems !== undefined
+        ? `${state.itemsCompleted}/${state.totalItems}`
+        : String(state.itemsCompleted);
+    return `${progressPrefix(state)} ${itemsPart} · ${formatBytes(state.bytesCompleted)} · ${elapsed} elapsed`;
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60_000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    const minutes = Math.floor(ms / 60_000);
+    const seconds = Math.round((ms % 60_000) / 1000);
+    return `${minutes}m${seconds}s`;
+}

package/dist/artifact-capture/api-gateway-artifact-writer.d.ts

@@ -8,7 +8,7 @@
  * Endpoints:
  *   - Bulk:      GET  {apiBaseUrl}/v1/runs/{runId}/artifacts/{type}/upload-url
  *   - Per-entry: GET  {apiBaseUrl}/v1/runs/{runId}/artifacts/{type}/{entryKey}/upload-url
- *   - Manifest:  GET  {apiBaseUrl}/v1/runs/{runId}/artifacts/manifest/upload-url
+ *   - Manifest:  GET  {apiBaseUrl}/v1/runs/{runId}/artifacts/upload-url
  *
  * ## W0049 API surface
  *
@@ -28,6 +28,7 @@
  * @see docs/decisions/D0033-unified-run-anchored-artifact-capture.md
  */
 import { type ArtifactEntry, type ArtifactRef, type ArtifactType, type ArtifactWriter, type AssociationValues, type RunId, type RunManifest } from "../_vendor/ailf-core/index.d.ts";
+import { type UploadMetricsSink } from "./upload-metrics.js";
 export interface ApiGatewayArtifactWriterOptions {
     /** Base URL of the API gateway (e.g., "https://ailf-api.sanity.build"). */
     apiBaseUrl: string;
@@ -35,9 +36,15 @@ export interface ApiGatewayArtifactWriterOptions {
     apiKey: string;
     /** GCS bucket name — included in the returned ArtifactRef. */
     bucket: string;
+    /**
+     * W0056 spike — optional metrics sink that receives per-phase timing events.
+     * Defaults to a no-op so the hot path stays free when metrics are off.
+     */
+    metrics?: UploadMetricsSink;
 }
 export declare class ApiGatewayArtifactWriter implements ArtifactWriter {
     private readonly options;
+    private readonly metrics;
     constructor(options: ApiGatewayArtifactWriterOptions);
     emit<T extends ArtifactType>(type: T, association: AssociationValues, payload: unknown): Promise<ArtifactRef | null>;
     appendNdjson(): Promise<ArtifactRef | null>;