@sanity/ailf 2.9.0 → 3.1.0

package/dist/composition-root.js

@@ -15,20 +15,22 @@
  * @see packages/core/src/ports/context.ts — AppContext interface
  * @see docs/archive/exec-plans/ports-and-adapters/phase-7-composition-root.md
  */
-import { join } from "node:path";
-import { InMemoryPluginRegistry, NoOpArtifactCollector, NoOpArtifactWriter, generateRunId, isArtifactType, } from "./_vendor/ailf-core/index.js";
+import { ARTIFACT_EXPORT_PHASE_ID, InMemoryPluginRegistry, NoOpArtifactWriter, NoOpProgressReporter, generateRunId, isArtifactType, } from "./_vendor/ailf-core/index.js";
 import { AccumulatingArtifactWriter } from "./artifact-capture/accumulating-artifact-writer.js";
 import { ApiGatewayArtifactWriter } from "./artifact-capture/api-gateway-artifact-writer.js";
+import { BatchingApiGatewayArtifactWriter } from "./artifact-capture/batching-api-gateway-artifact-writer.js";
 import { FanoutArtifactWriter } from "./artifact-capture/fanout-artifact-writer.js";
-import { FilesystemArtifactCollector } from "./artifact-capture/filesystem-collector.js";
-import { GcsArtifactCollector } from "./artifact-capture/gcs-collector.js";
 import { GcsArtifactWriter } from "./artifact-capture/gcs-artifact-writer.js";
+import { InstrumentedArtifactWriter } from "./artifact-capture/instrumented-artifact-writer.js";
 import { LocalFilesystemArtifactWriter } from "./artifact-capture/local-fs-artifact-writer.js";
+import { resolveUploadConcurrency, setDefaultUploadConcurrency, } from "./artifact-capture/parallel-emit.js";
+import { UploadMetrics } from "./artifact-capture/upload-metrics.js";
 import { ContentLakeCacheAdapter } from "./adapters/cache/content-lake-cache.js";
 import { loadExternalPresets } from "./pipeline/compiler/preset-loader.js";
 import { FilesystemCache } from "./adapters/cache/filesystem-cache.js";
 import { PromptfooEvalAdapter } from "./adapters/eval-runners/promptfoo-eval-adapter.js";
 import { ConsoleLogger, JsonLogger, QuietLogger, } from "./adapters/loggers/index.js";
+import { ConsoleProgressReporter } from "./adapters/progress/console-progress-reporter.js";
 import { CompositeTaskSource, ContentLakeTaskSource, RepoTaskSource, } from "./adapters/task-sources/index.js";
 import { createAgentHarnessBase, createKnowledgeProbeBase, createLiteracyModeBase, createMcpServerModeBase, } from "./pipeline/compiler/mode-bases/index.js";
 import { createSanityLiteracyPreset } from "./pipeline/compiler/presets/index.js";
@@ -44,6 +46,9 @@ import { loadSinks } from "./sinks/index.js";
 export function createAppContext(config) {
     // Logger — selected by env var preferences
     const logger = createLogger();
+    // Progress reporter — console-backed for the default logger; no-op for
+    // JSON/quiet modes and tests where interactive output is inappropriate.
+    const progress = createProgressReporter();
     // Cache — filesystem, optionally decorated with Content Lake fallback
     const cache = config.noCache ? undefined : createCache(config);
     // Task source — selected by config.taskSourceType
@@ -63,33 +68,16 @@ export function createAppContext(config) {
     const reportStore = createReportStore(config);
     // Sinks — loaded from config/sinks
     const sinks = loadSinks();
-    // Artifact collector — no-op by default, filesystem when --capture is set,
-    // GCS decorator when --capture-gcs-bucket is also provided (D0030/W0035)
-    let collector = new NoOpArtifactCollector();
-    if (config.captureEnabled) {
-        const fsCollector = new FilesystemArtifactCollector({
-            captureDir: config.captureDir ?? join(config.outputDir, "..", "captures"),
-            mode: config.mode,
-            compress: config.captureCompress ?? true,
-            extras: config.captureExtras ?? true,
-            pipeline: {
-                variant: config.variant,
-                source: config.source,
-                areas: config.areas,
-            },
-        });
-        collector = config.captureGcsBucket
-            ? new GcsArtifactCollector(fsCollector, {
-                bucket: config.captureGcsBucket,
-                prefix: config.captureGcsPrefix,
-            })
-            : fsCollector;
-    }
     // Artifact writer — writes run artifacts + manifest to GCS at known
     // `runs/{runId}/…` paths (D0032). Auto-detects the right adapter from
     // available credentials; defaults bucket to "ailf-artifacts". Set
     // artifactUpload: false to opt out entirely.
-    const artifactWriter = createArtifactWriter(config, logger);
+    // W0053 — writers receive a progress reporter scoped to a single
+    // `artifact-export` phase so the CLI can render per-batch updates.
+    const artifactWriter = createArtifactWriter(config, logger, {
+        reporter: progress,
+        phaseId: ARTIFACT_EXPORT_PHASE_ID,
+    });
     // Generate the pipeline's RunId once; every downstream step reads it
     // from the context (D0032).
     const runId = generateRunId();
@@ -97,11 +85,11 @@ export function createAppContext(config) {
     return {
         artifactWriter,
         cache,
-        collector,
         config,
         docFetcher,
         evalRunner,
         logger,
+        progress,
         registry,
         reportStore,
         runId,
@@ -124,6 +112,23 @@ function createLogger() {
             process.env.AILF_VERBOSE === "1",
     });
 }
+/**
+ * Select a ProgressReporter adapter. Matches the logger environment — JSON
+ * and quiet loggers get a no-op reporter so machine-readable output stays
+ * clean; interactive sessions get the console adapter with verbose mirroring.
+ */
+function createProgressReporter() {
+    if (process.env.AILF_LOG_FORMAT === "json")
+        return new NoOpProgressReporter();
+    if (process.env.AILF_LOG_LEVEL === "quiet" ||
+        process.env.AILF_QUIET === "1") {
+        return new NoOpProgressReporter();
+    }
+    return new ConsoleProgressReporter({
+        verbose: process.env.AILF_LOG_LEVEL === "verbose" ||
+            process.env.AILF_VERBOSE === "1",
+    });
+}
 /**
  * Shared GCS bucket for report artifacts. Matches the gateway default at
  * packages/api/src/routes/artifacts.ts — both sides assume ailf-artifacts
@@ -155,7 +160,7 @@ const DEFAULT_LOCAL_ARTIFACTS_DIR = ".ailf/results/captures";
  *
  * Exported for unit-test access; not part of the public package API.
  */
-export function createArtifactWriter(config, logger) {
+export function createArtifactWriter(config, logger, progress) {
     // Legacy `artifactUpload: false` still disables — treat as an alias for
     // the canonical `artifactsDisabled: true` until W0052 removes it.
     if (config.artifactsDisabled === true || config.artifactUpload === false) {
@@ -164,10 +169,27 @@ export function createArtifactWriter(config, logger) {
     }
     const exclude = resolveExcludeList(config.artifactsExclude, logger);
     const rootDir = config.artifactsDir ?? DEFAULT_LOCAL_ARTIFACTS_DIR;
-    const local = new LocalFilesystemArtifactWriter({ rootDir, exclude });
-    const remote = createRemoteArtifactWriter(config, logger);
+    // W0056 — opt-in measurement of the upload path. The collector is passed
+    // to the remote writer (where sign/PUT/compose phases live) AND wraps the
+    // final writer to record caller-observed `emit`/`writeManifest` totals.
+    // `summarize()` fires from the decorator's `writeManifest` hook.
+    const metrics = process.env.AILF_UPLOAD_METRICS === "1"
+        ? new UploadMetrics({
+            logger,
+            detailFile: `${rootDir}/upload-metrics/run-${Date.now()}.ndjson`,
+        })
+        : null;
+    // W0053: progress attaches to the OUTERMOST of (local-only | fanout). When
+    // fanout is wired, the delegates stay silent so we don't double-count the
+    // same caller-visible write across two backends.
+    const remote = createRemoteArtifactWriter(config, logger, metrics);
+    const local = new LocalFilesystemArtifactWriter({
+        rootDir,
+        exclude,
+        ...(remote ? {} : { progress }),
+    });
     const base = remote
-        ? new FanoutArtifactWriter([local, remote])
+        ? new FanoutArtifactWriter([local, remote], { progress })
         : local;
     if (!remote) {
         logger.debug(`Artifact writer: LocalFilesystemArtifactWriter only (rootDir=${rootDir})`);
@@ -179,7 +201,10 @@ export function createArtifactWriter(config, logger) {
     // RunManifest without each producer bookkeeping its own ArtifactRefs
     // (W0051 Slice 3 revisit — Option B of the "manifest empty on real runs"
     // fix).
-    return new AccumulatingArtifactWriter(base);
+    const accumulating = new AccumulatingArtifactWriter(base);
+    return metrics
+        ? new InstrumentedArtifactWriter(accumulating, metrics)
+        : accumulating;
 }
 /**
  * Validate the exclude list against the registry. Unknown types are dropped
@@ -194,7 +219,7 @@ function resolveExcludeList(raw, logger) {
             valid.push(name);
         }
         else {
-            logger.warn(`--capture-exclude: "${name}" is not a known artifact type — ignored`);
+            logger.warn(`--artifacts-exclude: "${name}" is not a known artifact type — ignored`);
         }
     }
     return valid;
@@ -205,19 +230,54 @@ function resolveExcludeList(raw, logger) {
  * the sole backend for that run, which is the D0033 M4 default for laptops
  * and CI without GCS creds.
  */
-function createRemoteArtifactWriter(config, logger) {
+function createRemoteArtifactWriter(config, logger, metrics) {
     const bucket = config.artifactGcsBucket ?? DEFAULT_ARTIFACT_BUCKET;
     const hasGcsCredentials = Boolean(process.env.GOOGLE_APPLICATION_CREDENTIALS || process.env.GCLOUD_PROJECT);
     if (hasGcsCredentials) {
-        logger.debug(`Artifact remote backend: GcsArtifactWriter (ADC, bucket=${bucket})`);
-        return new GcsArtifactWriter({ bucket });
+        // W0056 Phase 1: the GCS-direct path measured 0 failures at
+        // concurrency 8 with a 60 % pipeline-time reduction. Flip parallelism
+        // on by default on this path. `AILF_PARALLEL_UPLOAD=0` still forces
+        // serial as an escape hatch.
+        setDefaultUploadConcurrency(8);
+        logger.debug(`Artifact remote backend: GcsArtifactWriter (ADC, bucket=${bucket}, defaultConcurrency=8)`);
+        return new GcsArtifactWriter({
+            bucket,
+            ...(metrics ? { metrics } : {}),
+        });
     }
     if (config.apiKey && config.apiUrl) {
-        logger.debug(`Artifact remote backend: ApiGatewayArtifactWriter (via ${config.apiUrl}, bucket=${bucket})`);
+        // W0058 Phase 2: batching writer is the default on the API Gateway path.
+        // Prototype B (W0056) showed batch signing + client-side parallelism
+        // eliminates the 429 storm that single-URL parallelism triggered on the
+        // Vercel signing endpoint, at parity with the GCS-direct parallel path
+        // once the sign+PUT overlap optimization lands. Flip the default to 8
+        // concurrency; `AILF_PARALLEL_UPLOAD=0` forces serial as a rollback
+        // escape hatch and auto-selects the legacy single-URL writer.
+        setDefaultUploadConcurrency(8);
+        const concurrency = resolveUploadConcurrency();
+        if (concurrency > 1) {
+            logger.debug(`Artifact remote backend: BatchingApiGatewayArtifactWriter (via ${config.apiUrl}, bucket=${bucket}, putConcurrency=${concurrency})`);
+            // D0034: neither API Gateway writer supports NDJSON `appendNdjson`.
+            // Traces that flow through `appendNdjson` are dropped on this path.
+            // Surface the gap once at startup instead of ambushing users with a
+            // silent null ref at emit time.
+            logger.warn("Artifacts: API Gateway path selected without GCS ADC — " +
+                "trace (NDJSON) artifacts will be skipped (D0034). Set " +
+                "GOOGLE_APPLICATION_CREDENTIALS or GCLOUD_PROJECT to capture traces.");
+            return new BatchingApiGatewayArtifactWriter({
+                apiBaseUrl: config.apiUrl,
+                apiKey: config.apiKey,
+                bucket,
+                putConcurrency: concurrency,
+                ...(metrics ? { metrics } : {}),
+            });
+        }
+        logger.debug(`Artifact remote backend: ApiGatewayArtifactWriter (via ${config.apiUrl}, bucket=${bucket}, serial — AILF_PARALLEL_UPLOAD=0 override)`);
         return new ApiGatewayArtifactWriter({
             apiBaseUrl: config.apiUrl,
             apiKey: config.apiKey,
             bucket,
+            ...(metrics ? { metrics } : {}),
         });
     }
     return null;

package/dist/orchestration/build-app-context.js

@@ -8,7 +8,6 @@
  * Once all commands construct ResolvedConfig directly (or use --config),
  * this bridge can be deleted.
  */
-import { join } from "node:path";
 import { createAppContext } from "../composition-root.js";
 import { tryLoadConfigFile } from "../pipeline/compiler/config-loader.js";
 /**
@@ -78,12 +77,10 @@ export function mapToResolvedConfig(opts, rootDir) {
         remote: opts.remote ?? false,
         apiUrl: opts.apiUrl ?? "https://ailf-api.sanity.build",
         apiKey: opts.apiKey,
-        captureEnabled: opts.captureEnabled ?? false,
-        captureDir: opts.captureDir ?? join(opts.outputDir, "..", "captures"),
-        captureCompress: opts.captureCompress ?? true,
-        captureExtras: opts.captureExtras ?? true,
-        captureGcsBucket: process.env.AILF_CAPTURE_GCS_BUCKET,
-        captureGcsPrefix: process.env.AILF_CAPTURE_GCS_PREFIX,
+        artifactsDisabled: opts.artifactsDisabled,
+        artifactsDir: opts.artifactsDir,
+        artifactsDryRun: opts.artifactsDryRun,
+        artifactsExclude: opts.artifactsExclude,
         artifactGcsBucket: process.env.AILF_GCS_ARTIFACT_BUCKET,
         artifactUpload: parseArtifactUploadEnv(process.env.AILF_ARTIFACT_UPLOAD),
     };

package/dist/orchestration/pipeline-orchestrator.js

@@ -11,7 +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 { ARTIFACT_EXPORT_PHASE_ID, assoc, } from "../_vendor/ailf-core/index.js";
 import { runStep } from "./step-runner.js";
 // ---------------------------------------------------------------------------
 // Job progress reporter
@@ -111,21 +111,6 @@ async function capturePipelineContext(ctx, state, results) {
         ctx.logger.debug(`pipelineContext emit rejected: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
-/**
- * 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;
-    try {
-        const result = await ctx.collector.flush();
-        ctx.logger.info(`Captured ${result.artifactCount} artifacts → ${result.destination}`);
-    }
-    catch (err) {
-        ctx.logger.warn(`Artifact capture flush failed: ${err instanceof Error ? err.message : err}`);
-    }
-}
 // ---------------------------------------------------------------------------
 // Orchestrator
 // ---------------------------------------------------------------------------
@@ -157,10 +142,16 @@ export async function orchestratePipeline(ctx, steps) {
     if (hasJob) {
         await reportJobProgress(ctx, steps[0]?.name ?? "init", 0, steps.length, "running", undefined, jobUpdates);
     }
+    // W0053 — artifact export phase. Opens the first time a non-`run-eval`
+    // step starts, signalling the user that promptfoo's progress bar is done
+    // and the (previously silent) GCS export/upload window is now active.
+    // Closed in a finally after the step loop, regardless of pipeline outcome.
+    const exportPhase = createExportPhaseGate(ctx);
     for (let i = 0; i < steps.length; i++) {
         const step = steps[i];
         ctx.logger.debug(`Starting step ${i + 1}/${steps.length}: ${step.name}`);
         ctx.logger.section(step.name);
+        exportPhase.maybeOpen(step.name);
         // Report current step progress
         if (hasJob) {
             await reportJobProgress(ctx, step.name, i, steps.length, "running", undefined, jobUpdates);
@@ -182,13 +173,11 @@ export async function orchestratePipeline(ctx, steps) {
                     step: step.name,
                 }, jobUpdates);
             }
-            // Capture pipeline context and job updates before flushing
+            // 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);
-            // W0050 — `job-updates` was an observability-only capture not tied
-            // to a registered artifact type; dropped here. Use the JobStore
-            // path if job telemetry is needed.
-            // Flush captured artifacts even on failure (partial capture is useful)
-            await flushArtifacts(ctx);
+            exportPhase.close();
             return {
                 belowCritical: state.belowCritical,
                 durationMs: Date.now() - pipelineStart,
@@ -245,8 +234,7 @@ export async function orchestratePipeline(ctx, steps) {
     // Capture pipeline context. `job-updates` observability captures were
     // dropped in Slice 6.1 — JobStore is the supported telemetry path.
     await capturePipelineContext(ctx, state, results);
-    // Flush captured artifacts (non-blocking — failures never affect pipeline result)
-    await flushArtifacts(ctx);
+    exportPhase.close();
     return {
         belowCritical: state.belowCritical,
         durationMs,
@@ -257,3 +245,91 @@ export async function orchestratePipeline(ctx, steps) {
         validation,
     };
 }
+// ---------------------------------------------------------------------------
+// Artifact export phase gate (W0053)
+// ---------------------------------------------------------------------------
+/**
+ * Returns a lazy gate that opens the `artifact-export` progress phase on the
+ * first step after `run-eval` and closes it on pipeline completion. The gate
+ * tolerates repeated opens / closes — each is a no-op after the first.
+ *
+ * The phase is keyed on step names rather than timestamps so the header lands
+ * exactly when the user sees promptfoo's `Evaluating` bar hit 100% and the
+ * next pipeline step takes over. `run-eval` produces artifacts too, but its
+ * own progress is owned by promptfoo; opening the phase before run-eval would
+ * produce a duplicate progress channel for the same window.
+ */
+function createExportPhaseGate(ctx) {
+    let opened = false;
+    let closed = false;
+    let startedAt = 0;
+    // Step names that run BEFORE the artifact-heavy post-eval section. The
+    // phase opens on the first step whose name is not in this set — typically
+    // `calculate-scores` once promptfoo has handed back control.
+    const preExportSteps = new Set([
+        "validate",
+        "mirror-repo-tasks",
+        "fetch-docs",
+        "generate-configs",
+        "grader-consistency",
+    ]);
+    const { label, detail } = describeExportPhase(ctx);
+    return {
+        maybeOpen(stepName) {
+            if (opened)
+                return;
+            if (stepName.startsWith("run-eval"))
+                return;
+            if (preExportSteps.has(stepName))
+                return;
+            opened = true;
+            startedAt = Date.now();
+            ctx.progress.phaseStart({
+                phaseId: ARTIFACT_EXPORT_PHASE_ID,
+                label,
+                detail,
+                startedAt,
+            });
+        },
+        close() {
+            if (!opened || closed)
+                return;
+            closed = true;
+            // Cumulative counts live inside the reporter adapter (it accumulates
+            // each phaseProgress event). The orchestrator does not track the
+            // running total — it only knows when the phase is over. Adapters that
+            // render a final summary use their own state; NoOp / JSON adapters
+            // ignore the event.
+            ctx.progress.phaseComplete({
+                phaseId: ARTIFACT_EXPORT_PHASE_ID,
+                itemsCompleted: 0,
+                bytesCompleted: 0,
+                durationMs: Date.now() - startedAt,
+            });
+        },
+    };
+}
+/**
+ * Build the user-facing phase label by peeking at the wired writer chain.
+ * `AccumulatingArtifactWriter` wraps a `FanoutArtifactWriter([local, remote])`
+ * when remote credentials are present, or a bare `LocalFilesystemArtifactWriter`
+ * otherwise — naming the destination in the label keeps every progress line
+ * self-describing.
+ */
+function describeExportPhase(ctx) {
+    const writer = ctx.artifactWriter;
+    const inner = writer.inner?.constructor.name ?? writer.constructor.name;
+    if (inner === "FanoutArtifactWriter") {
+        return { label: "Exporting run artifacts", detail: "local + GCS" };
+    }
+    if (inner === "GcsArtifactWriter") {
+        return { label: "Exporting run artifacts", detail: "GCS" };
+    }
+    if (inner === "ApiGatewayArtifactWriter") {
+        return { label: "Exporting run artifacts", detail: "API gateway" };
+    }
+    if (inner === "NoOpArtifactWriter") {
+        return { label: "Finalizing run" };
+    }
+    return { label: "Exporting run artifacts", detail: "local" };
+}

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

@@ -146,7 +146,7 @@ export class CalculateScoresStep {
         // 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);
+            const artifactRef = await uploadTestOutputs(ctx.artifactWriter, ctx.runId, testResults, ctx.config.mode);
             if (artifactRef) {
                 state.artifactRefs = {
                     ...state.artifactRefs,

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

@@ -18,9 +18,36 @@
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { AccumulatingArtifactWriter } from "../../artifact-capture/accumulating-artifact-writer.js";
+import { InstrumentedArtifactWriter } from "../../artifact-capture/instrumented-artifact-writer.js";
 import { buildRunContext } from "../../pipeline/run-context.js";
 import { loadSource } from "../../sources.js";
 import { configToSourceOverrides } from "../config-to-source-overrides.js";
+/**
+ * Walk a writer's `inner` decorator chain looking for an
+ * `AccumulatingArtifactWriter`. Composition root wraps the accumulator
+ * in `InstrumentedArtifactWriter` when `AILF_UPLOAD_METRICS=1`, so a
+ * naive `instanceof AccumulatingArtifactWriter` check misses it and the
+ * manifest comes out empty. Rather than teaching every caller about the
+ * instrumentation wrapper, unwrap once here.
+ *
+ * `MAX_DEPTH` is a safety belt against a future decorator chain
+ * accidentally introducing a cycle — the current writers can't, but one
+ * `inner` self-reference would otherwise spin forever.
+ */
+const FIND_ACCUMULATOR_MAX_DEPTH = 8;
+function findAccumulator(writer) {
+    let cursor = writer;
+    for (let depth = 0; cursor && depth < FIND_ACCUMULATOR_MAX_DEPTH; depth++) {
+        if (cursor instanceof AccumulatingArtifactWriter)
+            return cursor;
+        if (cursor instanceof InstrumentedArtifactWriter) {
+            cursor = cursor.inner;
+            continue;
+        }
+        return null;
+    }
+    return null;
+}
 export class FinalizeRunStep {
     pipelineStart;
     options;
@@ -64,8 +91,12 @@ export class FinalizeRunStep {
         // 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()
+        //
+        // W0058: `findAccumulator` unwraps `InstrumentedArtifactWriter` too
+        // so the manifest stays fully populated when `AILF_UPLOAD_METRICS=1`.
+        const accumulator = findAccumulator(ctx.artifactWriter);
+        const aggregated = accumulator
+            ? accumulator.getAccumulatedArtifactRefs()
             : {};
         const artifacts = {
             ...aggregated,

package/dist/pipeline/emit-eval-results.js

@@ -27,7 +27,7 @@
  * still live inside the full `rawResults` object.
  */
 import { readFileSync } from "node:fs";
-import { classifyRubric, parseRubricScore, } from "../_vendor/ailf-core/index.js";
+import { classifyRubric, parseRubricScore, resolveVariantMode, } from "../_vendor/ailf-core/index.js";
 // ---------------------------------------------------------------------------
 // Public entry point
 // ---------------------------------------------------------------------------
@@ -57,23 +57,40 @@ export async function emitPerEntryEvalResults(writer, ctx, mode, resultsPath) {
         console.warn(`  ⚠️  emitPerEntryEvalResults: ${resultsPath} has no results[]`);
         return;
     }
+    // W0058: fire every emit synchronously and `Promise.all` once at the
+    // end. The previous `parallelMap` pattern created producer-side
+    // backpressure (each worker was blocked on its own `await emit(...)`),
+    // which kept the batching writer's queue shallow (≤ producer
+    // concurrency). With queueing delegated entirely to the writer, the
+    // batching API-Gateway writer gets a fully-populated pending queue
+    // and can pack ~hundreds of entries into a single batch-sign RTT;
+    // the GCS-direct writer's own `ConcurrencyLimiter` caps the PUT
+    // fan-out so the 1 500-concurrent-PUT scenario cannot happen.
+    const emits = [];
     for (const result of rows) {
-        const taskId = result.testCase?.description ?? "unknown-task";
+        const rawTaskId = result.testCase?.description ?? "unknown-task";
         const modelId = result.provider?.id ?? result.provider?.label ?? "unknown-model";
+        // D0033 axis convention: literacy-mode task descriptions carry a
+        // `(gold)` / `(baseline)` suffix; that variant IS the `mode` axis
+        // value. Stripping the suffix here keeps the writer's key aligned
+        // with what `slim-report-summary#slimJudgments` and the Studio
+        // `testOutputsKeyFor` hook compute on the read side. Without this,
+        // signed-URL lookups for grader/judgment artifacts 404.
+        const { mode: axisMode, task: axisTask } = resolveVariantMode(rawTaskId, mode);
         const baseAssoc = {
             run: ctx.runId,
-            mode,
-            task: taskId,
+            mode: axisMode,
+            task: axisTask,
             model: modelId,
         };
         // rawResults — full raw entry (bounded by descriptor capBytes: 1 MB)
-        await writer.emit("rawResults", baseAssoc, result);
+        emits.push(writer.emit("rawResults", baseAssoc, result));
         // renderedPrompts — what the model saw + which provider it went to
         if (result.prompt !== undefined) {
-            await writer.emit("renderedPrompts", baseAssoc, {
+            emits.push(writer.emit("renderedPrompts", baseAssoc, {
                 prompt: result.prompt,
                 provider: result.provider,
-            });
+            }));
         }
         // Per-grader decomposition — only LLM-rubric assertions have a
         // natural grader identity. Code assertions (javascript/contains/…)
@@ -86,15 +103,16 @@ export async function emitPerEntryEvalResults(writer, ctx, mode, resultsPath) {
             if (!dimension)
                 continue;
             const graderAssoc = { ...baseAssoc, grader: dimension };
-            await writer.emit("graderPrompts", graderAssoc, {
+            emits.push(writer.emit("graderPrompts", graderAssoc, {
                 dimension,
                 assertion: comp.assertion,
-            });
-            await writer.emit("graderJudgments", graderAssoc, {
+            }));
+            emits.push(writer.emit("graderJudgments", graderAssoc, {
                 score: parseRubricScore(comp) ?? 0,
                 reason: comp.reason ?? "",
                 pass: comp.pass,
-            });
+            }));
         }
     }
+    await Promise.all(emits);
 }

package/dist/pipeline/map-request-to-config.js

@@ -74,10 +74,6 @@ export function mapRequestToConfig(request, rootDir) {
         callerGit: request.callerGit,
         callback: request.callback,
         jobId: request.jobId,
-        captureEnabled: false,
-        captureDir: undefined,
-        captureCompress: true,
-        captureExtras: true,
         remote: false,
         apiUrl: "https://ailf-api.sanity.build",
         presets: request.presets,

package/dist/pipeline/upload-test-outputs.d.ts

@@ -15,12 +15,19 @@
  *
  * @see docs/decisions/D0032-run-anchored-artifact-store.md
  */
-import type { ArtifactRef, ArtifactWriter, RunId, StoredTestResult } from "../_vendor/ailf-core/index.d.ts";
+import { type ArtifactRef, type ArtifactWriter, type RunId, type StoredTestResult } from "../_vendor/ailf-core/index.d.ts";
 /**
  * Upload testOutputs as per-entry GCS objects under
- * `runs/{runId}/test-outputs/`, one per `{taskId}::{modelId}` pair.
+ * `runs/{runId}/test-outputs/`, one per `(mode, task, model)` triple.
  *
- * Returns the `ArtifactRef` on success, or `null` when upload is skipped or
- * fails (P5: non-blocking).
+ * D0033 axis convention: literacy-mode taskIds carry a `(gold)` / `(baseline)`
+ * suffix whose value is the `mode` axis on the artifact — stripped via
+ * `resolveVariantMode`. This aligns the on-disk key with what the Studio
+ * hover-prefetch (`testOutputsKeyFor`) and slim-report readers compute; the
+ * legacy 2-segment form produced by the pre-D0033 writer 404'd on the new
+ * 3-segment read path.
+ *
+ * Returns the first non-null `ArtifactRef` emitted, or `null` when upload is
+ * skipped / every emit fails (P5: non-blocking).
  */
-export declare function uploadTestOutputs(writer: ArtifactWriter, runId: RunId, testResults: StoredTestResult[]): Promise<ArtifactRef | null>;
+export declare function uploadTestOutputs(writer: ArtifactWriter, runId: RunId, testResults: StoredTestResult[], defaultMode: string): Promise<ArtifactRef | null>;

package/dist/pipeline/upload-test-outputs.js

@@ -15,20 +15,37 @@
  *
  * @see docs/decisions/D0032-run-anchored-artifact-store.md
  */
+import { resolveVariantMode, } from "../_vendor/ailf-core/index.js";
 /**
  * Upload testOutputs as per-entry GCS objects under
- * `runs/{runId}/test-outputs/`, one per `{taskId}::{modelId}` pair.
+ * `runs/{runId}/test-outputs/`, one per `(mode, task, model)` triple.
  *
- * Returns the `ArtifactRef` on success, or `null` when upload is skipped or
- * fails (P5: non-blocking).
+ * D0033 axis convention: literacy-mode taskIds carry a `(gold)` / `(baseline)`
+ * suffix whose value is the `mode` axis on the artifact — stripped via
+ * `resolveVariantMode`. This aligns the on-disk key with what the Studio
+ * hover-prefetch (`testOutputsKeyFor`) and slim-report readers compute; the
+ * legacy 2-segment form produced by the pre-D0033 writer 404'd on the new
+ * 3-segment read path.
+ *
+ * Returns the first non-null `ArtifactRef` emitted, or `null` when upload is
+ * skipped / every emit fails (P5: non-blocking).
  */
-export async function uploadTestOutputs(writer, runId, testResults) {
-    const entries = testResults.map((tr) => ({
-        key: `${tr.taskId}::${tr.modelId}`,
-        data: {
+export async function uploadTestOutputs(writer, runId, testResults, defaultMode) {
+    // W0058: fire every emit synchronously and `Promise.all` once — the
+    // writer (batching or GCS-direct) owns concurrency bounds. See the
+    // equivalent rationale in `emit-eval-results.ts`.
+    const emits = testResults.map((tr) => {
+        const { mode: axisMode, task: axisTask } = resolveVariantMode(tr.taskId, defaultMode);
+        return writer.emit("testOutputs", { run: runId, mode: axisMode, task: axisTask, model: tr.modelId }, {
             responseOutput: tr.responseOutput ?? "",
             responseOutputTruncated: tr.responseOutputTruncated ?? false,
-        },
-    }));
-    return writer.writePerEntry("testOutputs", runId, entries);
+        });
+    });
+    const refs = await Promise.all(emits);
+    let lastRef = null;
+    for (const ref of refs) {
+        if (ref)
+            lastRef = ref;
+    }
+    return lastRef;
 }