@sanity/ailf 3.0.0 → 3.1.1

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/index.d.ts

@@ -21,4 +21,4 @@ export { defineConfig, defineFeatures, defineModeBase, defineModels, definePrici
 export type { PricingEntry, PromptEntry, SourceEntry, } from "./config-helpers.js";
 export { env } from "./env-helper.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

@@ -23,4 +23,4 @@ export * from "./batch-signing.js";
 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 { 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

@@ -18,6 +18,7 @@ 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
@@ -215,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

@@ -14,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/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>;

package/dist/artifact-capture/api-gateway-artifact-writer.js

@@ -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,10 +28,13 @@
  * @see docs/decisions/D0033-unified-run-anchored-artifact-capture.md
  */
 import { ARTIFACT_REGISTRY, NotImplementedError, } from "../_vendor/ailf-core/index.js";
+import { NO_OP_UPLOAD_METRICS, } from "./upload-metrics.js";
 export class ApiGatewayArtifactWriter {
     options;
+    metrics;
     constructor(options) {
         this.options = options;
+        this.metrics = options.metrics ?? NO_OP_UPLOAD_METRICS;
     }
     // ---- Canonical W0049 API ------------------------------------------------
     async emit(type, association, payload) {
@@ -46,12 +49,13 @@ export class ApiGatewayArtifactWriter {
             return this.putJson(uploadUrlPath, payload, {
                 layout: "bulk",
                 entryCount: entryCountOf(payload),
+                type,
             });
         }
         // per-entry
         const entryKey = descriptor.formatEntryKey(association);
         const uploadUrlPath = `/v1/runs/${encodeURIComponent(runId)}/artifacts/${encodeURIComponent(type)}/${encodeURIComponent(entryKey)}/upload-url`;
-        const result = await this.putJsonRaw(uploadUrlPath, payload);
+        const result = await this.putJsonRaw(uploadUrlPath, payload, type);
         if (!result)
             return null;
         return {
@@ -72,8 +76,11 @@ export class ApiGatewayArtifactWriter {
             "the batch route.");
     }
     async writeManifest(runId, manifest) {
-        const uploadUrlPath = `/v1/runs/${encodeURIComponent(runId)}/artifacts/manifest/upload-url`;
-        return this.putJson(uploadUrlPath, manifest, { layout: "bulk" });
+        const uploadUrlPath = `/v1/runs/${encodeURIComponent(runId)}/artifacts/upload-url`;
+        return this.putJson(uploadUrlPath, manifest, {
+            layout: "bulk",
+            type: "manifest",
+        });
     }
     // ---- Deprecated legacy surface (W0052) ----------------------------------
     /** @deprecated Use `emit()` instead. */
@@ -82,6 +89,7 @@ export class ApiGatewayArtifactWriter {
         return this.putJson(uploadUrlPath, data, {
             layout: "bulk",
             entryCount: entryCountOf(data),
+            type,
         });
     }
     /** @deprecated Use `emit()` per entry instead. */
@@ -101,7 +109,7 @@ export class ApiGatewayArtifactWriter {
                 continue;
             }
             const uploadUrlPath = `/v1/runs/${encodeURIComponent(runId)}/artifacts/${encodeURIComponent(type)}/${encodeURIComponent(entry.key)}/upload-url`;
-            const result = await this.putJsonRaw(uploadUrlPath, entry.data);
+            const result = await this.putJsonRaw(uploadUrlPath, entry.data, type);
             if (!result)
                 continue;
             bucket = result.bucket;
@@ -122,7 +130,7 @@ export class ApiGatewayArtifactWriter {
     }
     // ---- Internals ----------------------------------------------------------
     async putJson(uploadUrlPath, data, meta) {
-        const result = await this.putJsonRaw(uploadUrlPath, data);
+        const result = await this.putJsonRaw(uploadUrlPath, data, meta.type);
         if (!result)
             return null;
         return {
@@ -134,23 +142,38 @@ export class ApiGatewayArtifactWriter {
             layout: meta.layout,
         };
     }
-    async putJsonRaw(uploadUrlPath, data) {
+    async putJsonRaw(uploadUrlPath, data, type) {
         const json = JSON.stringify(data);
         const bytes = Buffer.byteLength(json, "utf-8");
         try {
-            const signed = await this.fetchSignedUrl(uploadUrlPath);
+            const signed = await this.fetchSignedUrl(uploadUrlPath, type);
             if (!signed)
                 return null;
-            const putRes = await fetch(signed.url, {
-                body: json,
-                headers: signed.requiredHeaders,
-                method: "PUT",
-            });
-            if (!putRes.ok) {
-                console.warn(`  ⚠️  Artifact upload failed (non-blocking): ${signed.path} — GCS PUT ${putRes.status} ${putRes.statusText}`);
-                return null;
+            const putStart = Date.now();
+            let putSuccess = false;
+            try {
+                const putRes = await fetch(signed.url, {
+                    body: json,
+                    headers: signed.requiredHeaders,
+                    method: "PUT",
+                });
+                if (!putRes.ok) {
+                    console.warn(`  ⚠️  Artifact upload failed (non-blocking): ${signed.path} — GCS PUT ${putRes.status} ${putRes.statusText}`);
+                    return null;
+                }
+                putSuccess = true;
+                return { bucket: signed.bucket, path: signed.path, bytes };
+            }
+            finally {
+                this.metrics.record({
+                    phase: "put",
+                    writer: "ApiGatewayArtifactWriter",
+                    type,
+                    ms: Date.now() - putStart,
+                    bytes,
+                    success: putSuccess,
+                });
             }
-            return { bucket: signed.bucket, path: signed.path, bytes };
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
@@ -158,33 +181,47 @@ export class ApiGatewayArtifactWriter {
             return null;
         }
     }
-    async fetchSignedUrl(uploadUrlPath) {
-        const url = `${this.options.apiBaseUrl.replace(/\/$/, "")}${uploadUrlPath}`;
-        const res = await fetch(url, {
-            headers: { Authorization: `Bearer ${this.options.apiKey}` },
-            method: "GET",
-        });
-        if (!res.ok) {
-            console.warn(`  ⚠️  Signed-URL request failed: ${res.status} ${res.statusText}`);
-            return null;
+    async fetchSignedUrl(uploadUrlPath, type) {
+        const start = Date.now();
+        let success = false;
+        try {
+            const url = `${this.options.apiBaseUrl.replace(/\/$/, "")}${uploadUrlPath}`;
+            const res = await fetch(url, {
+                headers: { Authorization: `Bearer ${this.options.apiKey}` },
+                method: "GET",
+            });
+            if (!res.ok) {
+                console.warn(`  ⚠️  Signed-URL request failed: ${res.status} ${res.statusText}`);
+                return null;
+            }
+            const body = (await res.json());
+            if (body.object !== "signed_upload_url" ||
+                typeof body.url !== "string" ||
+                typeof body.path !== "string" ||
+                typeof body.bucket !== "string" ||
+                !body.requiredHeaders) {
+                console.warn(`  ⚠️  Signed-URL response was malformed`);
+                return null;
+            }
+            success = true;
+            return {
+                bucket: body.bucket,
+                method: "PUT",
+                object: "signed_upload_url",
+                path: body.path,
+                requiredHeaders: body.requiredHeaders,
+                url: body.url,
+            };
         }
-        const body = (await res.json());
-        if (body.object !== "signed_upload_url" ||
-            typeof body.url !== "string" ||
-            typeof body.path !== "string" ||
-            typeof body.bucket !== "string" ||
-            !body.requiredHeaders) {
-            console.warn(`  ⚠️  Signed-URL response was malformed`);
-            return null;
+        finally {
+            this.metrics.record({
+                phase: "sign",
+                writer: "ApiGatewayArtifactWriter",
+                type,
+                ms: Date.now() - start,
+                success,
+            });
         }
-        return {
-            bucket: body.bucket,
-            method: "PUT",
-            object: "signed_upload_url",
-            path: body.path,
-            requiredHeaders: body.requiredHeaders,
-            url: body.url,
-        };
     }
 }
 function entryCountOf(data) {