@sanity/ailf 2.8.0 → 3.0.0

package/dist/artifact-capture/redact-artifact.js

@@ -1,9 +1,7 @@
 /**
- * Artifact redaction — strips sensitive data from captured artifacts before
- * they are written to disk.
- *
- * Applied during FilesystemArtifactCollector.flush() so that secrets
- * (resolved env vars, auth headers, session cookies) never reach storage.
+ * Artifact redaction — strips sensitive data from written artifacts so that
+ * secrets (resolved env vars, auth headers, session cookies) never reach
+ * local or remote storage.
  *
  * Two-layer approach:
  * 1. **Header stripping** — known-sensitive HTTP header keys are replaced

package/dist/cli.js

@@ -76,6 +76,60 @@ else if (process.argv.includes("--quiet") || process.argv.includes("-q")) {
     process.env.AILF_LOG_LEVEL = "quiet";
 }
 // ---------------------------------------------------------------------------
+// W0052 — hard-error on retired capture flags and env vars.
+// --------------------------------------------------------------------------
+// The legacy collector has been removed. Callers still using
+// --capture / --capture-dir / --no-capture-compress / --no-capture-extras
+// or AILF_CAPTURE* / AILF_LEGACY_COLLECTOR / AILF_UNIFIED_ARTIFACTS must
+// migrate to --artifacts-dir / --no-artifacts / --artifacts-exclude. We
+// print a clear pointer so failures don't bubble up as opaque "unknown
+// option" errors from Commander.
+// ---------------------------------------------------------------------------
+const RETIRED_FLAGS = [
+    "--capture",
+    "--capture-dir",
+    "--no-capture-compress",
+    "--no-capture-extras",
+    "--capture-exclude",
+];
+const RETIRED_ENV_VARS = [
+    "AILF_CAPTURE",
+    "AILF_CAPTURE_DIR",
+    "AILF_CAPTURE_COMPRESS",
+    "AILF_CAPTURE_EXTRAS",
+    "AILF_CAPTURE_GCS_BUCKET",
+    "AILF_CAPTURE_GCS_PREFIX",
+    "AILF_LEGACY_COLLECTOR",
+    "AILF_UNIFIED_ARTIFACTS",
+];
+function findRetiredFlag() {
+    for (const arg of process.argv) {
+        const bare = arg.split("=")[0];
+        if (RETIRED_FLAGS.includes(bare)) {
+            return bare;
+        }
+    }
+    return undefined;
+}
+function findRetiredEnv() {
+    for (const name of RETIRED_ENV_VARS) {
+        if (process.env[name] !== undefined)
+            return name;
+    }
+    return undefined;
+}
+const retiredFlag = findRetiredFlag();
+const retiredEnv = findRetiredEnv();
+if (retiredFlag || retiredEnv) {
+    const source = retiredFlag
+        ? `flag "${retiredFlag}"`
+        : `environment variable "${retiredEnv}"`;
+    console.error(`❌ ${source} was retired in W0052 along with the legacy artifact collector.`);
+    console.error("   Use --artifacts-dir / --no-artifacts / --artifacts-exclude instead.");
+    console.error("   See docs/cli.md and docs/decisions/D0033-unified-run-anchored-artifact-capture.md.");
+    process.exit(2);
+}
+// ---------------------------------------------------------------------------
 // Build CLI program
 // ---------------------------------------------------------------------------
 import { Command } from "commander";
@@ -134,6 +188,8 @@ import { createBaselineCommand } from "./commands/baseline.js";
 program.addCommand(createBaselineCommand().helpGroup(CommandGroup.CoreWorkflow));
 import { createPublishCommand } from "./commands/publish.js";
 program.addCommand(createPublishCommand().helpGroup(CommandGroup.CoreWorkflow));
+import { createRunsCommand } from "./commands/runs.js";
+program.addCommand(createRunsCommand().helpGroup(CommandGroup.CoreWorkflow));
 // ── Analysis & Reports ────────────────────────────────────────────────
 import { createReadinessReportCommand } from "./commands/readiness-report.js";
 program.addCommand(createReadinessReportCommand().helpGroup(CommandGroup.AnalysisReports));
@@ -179,8 +235,6 @@ program.addCommand(createLookupDocCommand().helpGroup(CommandGroup.PipelineInter
 import { createWebhookServerCommand } from "./commands/webhook-server.js";
 program.addCommand(createWebhookServerCommand().helpGroup(CommandGroup.PipelineInternals));
 // ── Developer Tools ───────────────────────────────────────────────────
-import { createCaptureCommand } from "./commands/capture.js";
-program.addCommand(createCaptureCommand().helpGroup(CommandGroup.DeveloperTools));
 import { createInteractiveCommand } from "./commands/interactive.js";
 program.addCommand(createInteractiveCommand().helpGroup(CommandGroup.DeveloperTools));
 // Shell completion — must be registered last (needs full program tree)

package/dist/commands/explain-handler.js

@@ -723,10 +723,10 @@ async function buildPipelineExplainPlan(actionCommand, rootDir) {
         taskSource: raw.taskSource,
         remoteCache: raw.remoteCache,
         config: raw.config,
-        capture: raw.capture ?? false,
-        captureCompress: raw.captureCompress ?? true,
-        captureExtras: raw.captureExtras ?? true,
-        captureDir: raw.captureDir,
+        artifacts: raw.artifacts ?? true,
+        artifactsDir: raw.artifactsDir,
+        artifactsDryRun: raw.artifactsDryRun ?? false,
+        artifactsExclude: raw.artifactsExclude,
     };
     const resolved = computeResolvedOptions(withDefaults);
     const planOpts = {

package/dist/commands/pipeline-action.d.ts

@@ -63,10 +63,11 @@ export interface ResolvedOptions {
     urlArgs: string[];
     apiUrl: string;
     apiKey?: string;
-    captureEnabled: boolean;
-    captureDir?: string;
-    captureCompress: boolean;
-    captureExtras: boolean;
+    /** D0033 / W0049 — unified artifact surface (W0050 wires it into writer). */
+    artifactsDisabled: boolean;
+    artifactsDir?: string;
+    artifactsDryRun: boolean;
+    artifactsExclude?: readonly string[];
 }
 /**
  * Pure option resolution — computes ResolvedOptions from CLI flags without

package/dist/commands/pipeline-action.js

@@ -263,13 +263,33 @@ export function computeResolvedOptions(opts) {
         tagOption,
         taskSourceType: resolvedTaskSourceType,
         urlArgs,
-        captureEnabled: opts.capture || process.env.AILF_CAPTURE === "1",
-        captureDir: opts.captureDir ?? process.env.AILF_CAPTURE_DIR,
-        captureCompress: opts.captureCompress !== false &&
-            process.env.AILF_CAPTURE_COMPRESS !== "0",
-        captureExtras: opts.captureExtras !== false && process.env.AILF_CAPTURE_EXTRAS !== "0",
+        artifactsDisabled: opts.artifacts === false,
+        artifactsDir: resolveArtifactsDir(opts),
+        artifactsDryRun: opts.artifactsDryRun,
+        artifactsExclude: parseArtifactsExcludeList(opts.artifactsExclude),
     };
 }
+/**
+ * Resolve the artifacts output directory from CLI flags and env vars.
+ * Precedence (highest first):
+ *   1. `--artifacts-dir` flag
+ *   2. `AILF_ARTIFACTS_DIR` env var
+ *
+ * The `--capture-dir` / `AILF_CAPTURE_DIR` aliases were retired in W0052;
+ * callers of those names are rejected at CLI entry (see cli.ts).
+ */
+function resolveArtifactsDir(opts) {
+    return opts.artifactsDir ?? process.env.AILF_ARTIFACTS_DIR;
+}
+function parseArtifactsExcludeList(raw) {
+    if (!raw)
+        return undefined;
+    const list = raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    return list.length > 0 ? list : undefined;
+}
 /** Resolve and validate the --task-source flag value. */
 function resolveTaskSourceType(raw) {
     if (!raw || raw === "content-lake")
@@ -315,19 +335,16 @@ export async function executePipeline(cliOpts) {
         }
         // Output dir: explicit CLI flag → $CWD/.ailf/results/latest/
         config.outputDir = resolveOutputDir(cliOpts.outputDir);
-        // Capture options — CLI flags and env vars aren't in the config file,
+        // Artifact options — CLI flags and env vars aren't in the config file,
         // so merge them here (same logic as resolveOptions).
-        config.captureEnabled = cliOpts.capture || process.env.AILF_CAPTURE === "1";
-        if (cliOpts.captureDir ?? process.env.AILF_CAPTURE_DIR) {
-            config.captureDir = cliOpts.captureDir ?? process.env.AILF_CAPTURE_DIR;
+        const resolvedArtifactsDir = resolveArtifactsDir(cliOpts);
+        config.artifactsDisabled ??= cliOpts.artifacts === false;
+        config.artifactsDir ??= resolvedArtifactsDir;
+        config.artifactsDryRun ??= cliOpts.artifactsDryRun;
+        const excludeList = parseArtifactsExcludeList(cliOpts.artifactsExclude);
+        if (excludeList) {
+            config.artifactsExclude = excludeList;
         }
-        config.captureCompress =
-            cliOpts.captureCompress !== false &&
-                process.env.AILF_CAPTURE_COMPRESS !== "0";
-        config.captureExtras =
-            cliOpts.captureExtras !== false && process.env.AILF_CAPTURE_EXTRAS !== "0";
-        config.captureGcsBucket ??= process.env.AILF_CAPTURE_GCS_BUCKET;
-        config.captureGcsPrefix ??= process.env.AILF_CAPTURE_GCS_PREFIX;
         config.artifactGcsBucket ??= process.env.AILF_GCS_ARTIFACT_BUCKET;
         config.artifactUpload ??= parseArtifactUploadEnv(process.env.AILF_ARTIFACT_UPLOAD);
         // Create AppContext directly from the merged config so adapters

package/dist/commands/pipeline.d.ts

@@ -64,9 +64,9 @@ export interface PipelineCliOptions {
     url: string[];
     urls: string[];
     apiUrl?: string;
-    capture: boolean;
-    captureDir?: string;
-    captureCompress: boolean;
-    captureExtras: boolean;
+    artifacts: boolean;
+    artifactsDir?: string;
+    artifactsDryRun: boolean;
+    artifactsExclude?: string;
 }
 export declare function createPipelineCommand(): Command;

package/dist/commands/pipeline.js

@@ -54,10 +54,10 @@ export function createPipelineCommand() {
         .option("--repo-tasks-path <path>", "Path to repo-based task definitions (.ailf/tasks/ directory)")
         .option("--remote", "Submit evaluation to the AILF API instead of running locally", false)
         .option("--api-url <url>", "AILF API base URL (default: https://ailf-api.sanity.build)")
-        .option("--capture", "Enable artifact capture for this run", false)
-        .option("--capture-dir <path>", "Base directory for capture output (default: .ailf/results/captures/)")
-        .option("--no-capture-compress", "Disable tar.gz compression of captures")
-        .option("--no-capture-extras", "Exclude mode-specific artifacts from captures")
+        .option("--no-artifacts", "Disable all artifact writers (D0033). Overrides --artifacts-dir.")
+        .option("--artifacts-dir <path>", "Root directory for local artifact output (D0033; default: .ailf/results/captures/)")
+        .option("--artifacts-dry-run", "Run artifact writers in dry-run mode — log intended writes, touch no storage", false)
+        .option("--artifacts-exclude <types>", "Comma-separated artifact types to skip (e.g. traces,graderPrompts)")
         .action(async (opts) => {
         const { executePipeline } = await import("./pipeline-action.js");
         await executePipeline(opts);

package/dist/commands/publish.js

@@ -27,6 +27,7 @@ import { addOutputDirOption } from "./shared/options.js";
 import { getCallerCwd, resolveOutputDir } from "./shared/resolve-output-dir.js";
 import { buildProvenance, } from "../pipeline/provenance.js";
 import { generateReportTitle } from "../pipeline/report-title.js";
+import { buildSlimReportSummary } from "../_vendor/ailf-core/index.js";
 import { generateReportId, } from "../report-store.js";
 import { withRetry } from "../sinks/retry.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -174,13 +175,15 @@ async function runPublishCommand(summaryPath, outputDir, opts) {
     }
     const reportId = generateReportId();
     const title = generateReportTitle({ provenance });
+    // W0051 Slice 3: slim the summary at publish time.
+    const slimSummary = buildSlimReportSummary(summary, provenance.mode);
     const report = {
         comparison: comparison ?? undefined,
         completedAt: now,
         durationMs: 0, // manual publish — no pipeline duration
         id: reportId,
         provenance,
-        summary,
+        summary: slimSummary,
         tag: opts.tag,
         title,
     };

package/dist/commands/runs.d.ts

@@ -0,0 +1,18 @@
+/**
+ * runs command — utilities for working with run-anchored artifacts on disk.
+ *
+ * The unified artifact writer (D0033 M4) lays artifacts down under
+ * `.ailf/results/captures/runs/{runId}/…`. Downstream tooling (CI archivers,
+ * external consumers that used to parse the legacy collector tarball) still
+ * want a single-file bundle. `runs export --format tarball` reproduces that
+ * bundle from the existing tree — no re-materialisation, just a tar of the
+ * files already written.
+ *
+ * The on-disk layout is identical to what the legacy FilesystemArtifactCollector
+ * produced (same paths, same filenames), so the tarball shape is stable for
+ * existing consumers.
+ *
+ * @see docs/decisions/D0033-unified-run-anchored-artifact-capture.md
+ */
+import { Command } from "commander";
+export declare function createRunsCommand(): Command;

package/dist/commands/runs.js

@@ -0,0 +1,71 @@
+/**
+ * runs command — utilities for working with run-anchored artifacts on disk.
+ *
+ * The unified artifact writer (D0033 M4) lays artifacts down under
+ * `.ailf/results/captures/runs/{runId}/…`. Downstream tooling (CI archivers,
+ * external consumers that used to parse the legacy collector tarball) still
+ * want a single-file bundle. `runs export --format tarball` reproduces that
+ * bundle from the existing tree — no re-materialisation, just a tar of the
+ * files already written.
+ *
+ * The on-disk layout is identical to what the legacy FilesystemArtifactCollector
+ * produced (same paths, same filenames), so the tarball shape is stable for
+ * existing consumers.
+ *
+ * @see docs/decisions/D0033-unified-run-anchored-artifact-capture.md
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { Command } from "commander";
+const DEFAULT_ARTIFACTS_DIR = ".ailf/results/captures";
+function resolveArtifactsDir(flag) {
+    return resolve(flag ?? process.env.AILF_ARTIFACTS_DIR ?? DEFAULT_ARTIFACTS_DIR);
+}
+function resolveOutputPath(explicit, artifactsDir, runId) {
+    if (explicit)
+        return resolve(explicit);
+    return resolve(artifactsDir, `runs-${runId}.tar.gz`);
+}
+function exportTarball(opts) {
+    if (opts.format !== "tarball") {
+        console.error(`❌ Unsupported --format "${opts.format}". Supported: tarball.`);
+        return 2;
+    }
+    const artifactsDir = resolveArtifactsDir(opts.artifactsDir);
+    const runRoot = resolve(artifactsDir, "runs", opts.runId);
+    if (!existsSync(runRoot)) {
+        console.error(`❌ No artifacts on disk for run "${opts.runId}" at ${runRoot}`);
+        console.error("   Set --artifacts-dir / AILF_ARTIFACTS_DIR or check the runId.");
+        return 1;
+    }
+    const outputPath = resolveOutputPath(opts.output, artifactsDir, opts.runId);
+    const outputDir = dirname(outputPath);
+    mkdirSync(outputDir, { recursive: true });
+    // Spawn system tar — the unified tree is byte-for-byte identical to the
+    // legacy collector's output, so `tar -czf` produces a tarball with the
+    // same file list consumers depended on.
+    const tar = spawnSync("tar", ["-czf", outputPath, "-C", resolve(artifactsDir, "runs"), opts.runId], { stdio: "inherit" });
+    if (tar.status !== 0) {
+        console.error(`❌ tar exited with status ${tar.status}`);
+        return tar.status ?? 1;
+    }
+    console.log(`  ✅ Exported ${runRoot} → ${outputPath}`);
+    return 0;
+}
+export function createRunsCommand() {
+    const cmd = new Command("runs").description("Utilities for working with run-anchored artifact trees on disk");
+    cmd
+        .command("export")
+        .description("Export a run's artifact tree to a portable archive. Only `--format tarball` is supported.")
+        .requiredOption("--run-id <runId>", "Run id to export (required)")
+        .option("--format <fmt>", "Output format (currently only: tarball)", "tarball")
+        .option("--artifacts-dir <path>", "Override the root directory containing runs/{runId}/… (default: .ailf/results/captures)")
+        .option("-o, --output <path>", "Output archive path (default: {artifacts-dir}/runs-{runId}.tar.gz)")
+        .action((opts) => {
+        const code = exportTarball(opts);
+        if (code !== 0)
+            process.exit(code);
+    });
+    return cmd;
+}

package/dist/composition-root.d.ts

@@ -24,21 +24,24 @@ import { type AppContext, type ArtifactWriter, type AssertionRegistration, type
  */
 export declare function createAppContext(config: ResolvedConfig): AppContext;
 /**
- * Selects an ArtifactWriter implementation based on available credentials.
+ * Selects the `ArtifactWriter` wiring per D0033 M4:
  *
- * Selection order:
- *   1. config.artifactUpload === false → always skip (explicit opt-out)
- *   2. GOOGLE_APPLICATION_CREDENTIALS or GCLOUD_PROJECT present → direct GCS
- *   3. apiKey + apiUrl present → gateway-signed PUT URL
- *   4. Neither → skip silently (P5)
+ *   1. `--no-artifacts` (`config.artifactsDisabled === true`, or legacy
+ *      `config.artifactUpload === false`) → `NoOpArtifactWriter`.
+ *   2. Otherwise: always attach `LocalFilesystemArtifactWriter` under
+ *      `--artifacts-dir` (default `.ailf/results/captures`).
+ *   3. When a remote backend is reachable (ADC, GCLOUD_PROJECT, or an
+ *      AILF API key + URL), layer it via `FanoutArtifactWriter([local, gcs])`.
+ *      Local is listed first so a local success + remote failure still
+ *      produces a non-null ref.
  *
- * The bucket defaults to DEFAULT_ARTIFACT_BUCKET when not explicitly set —
- * users only need to override for self-hosted deployments with a different
- * bucket (and matching gateway signing credentials).
+ * Always returns a writer — pipeline code can assume `ctx.artifactWriter`
+ * is present. Producers post-W0050 drop their `if (ctx.artifactWriter)`
+ * guards in Slice 6.
  *
  * Exported for unit-test access; not part of the public package API.
  */
-export declare function createArtifactWriter(config: ResolvedConfig, logger: Logger): ArtifactWriter | undefined;
+export declare function createArtifactWriter(config: ResolvedConfig, logger: Logger): ArtifactWriter;
 /**
  * Generic Promptfoo assertion types available to all evaluation modes.
  *

package/dist/composition-root.js

@@ -15,12 +15,12 @@
  * @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, generateRunId, } from "./_vendor/ailf-core/index.js";
+import { InMemoryPluginRegistry, NoOpArtifactWriter, 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 { FilesystemArtifactCollector } from "./artifact-capture/filesystem-collector.js";
-import { GcsArtifactCollector } from "./artifact-capture/gcs-collector.js";
+import { FanoutArtifactWriter } from "./artifact-capture/fanout-artifact-writer.js";
 import { GcsArtifactWriter } from "./artifact-capture/gcs-artifact-writer.js";
+import { LocalFilesystemArtifactWriter } from "./artifact-capture/local-fs-artifact-writer.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";
@@ -60,28 +60,6 @@ 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
@@ -94,7 +72,6 @@ export function createAppContext(config) {
     return {
         artifactWriter,
         cache,
-        collector,
         config,
         docFetcher,
         evalRunner,
@@ -129,44 +106,95 @@ function createLogger() {
  */
 const DEFAULT_ARTIFACT_BUCKET = "ailf-artifacts";
 /**
- * Selects an ArtifactWriter implementation based on available credentials.
+ * D0033 M4 default root for local artifacts when `--artifacts-dir` is unset.
+ * Mirrors the pre-W0050 capture root so existing dev tooling (Studio
+ * retrieval, CI archivers) keeps finding files at the same path prefix.
+ */
+const DEFAULT_LOCAL_ARTIFACTS_DIR = ".ailf/results/captures";
+/**
+ * Selects the `ArtifactWriter` wiring per D0033 M4:
  *
- * Selection order:
- *   1. config.artifactUpload === false → always skip (explicit opt-out)
- *   2. GOOGLE_APPLICATION_CREDENTIALS or GCLOUD_PROJECT present → direct GCS
- *   3. apiKey + apiUrl present → gateway-signed PUT URL
- *   4. Neither → skip silently (P5)
+ *   1. `--no-artifacts` (`config.artifactsDisabled === true`, or legacy
+ *      `config.artifactUpload === false`) → `NoOpArtifactWriter`.
+ *   2. Otherwise: always attach `LocalFilesystemArtifactWriter` under
+ *      `--artifacts-dir` (default `.ailf/results/captures`).
+ *   3. When a remote backend is reachable (ADC, GCLOUD_PROJECT, or an
+ *      AILF API key + URL), layer it via `FanoutArtifactWriter([local, gcs])`.
+ *      Local is listed first so a local success + remote failure still
+ *      produces a non-null ref.
  *
- * The bucket defaults to DEFAULT_ARTIFACT_BUCKET when not explicitly set —
- * users only need to override for self-hosted deployments with a different
- * bucket (and matching gateway signing credentials).
+ * Always returns a writer — pipeline code can assume `ctx.artifactWriter`
+ * is present. Producers post-W0050 drop their `if (ctx.artifactWriter)`
+ * guards in Slice 6.
  *
  * Exported for unit-test access; not part of the public package API.
  */
 export function createArtifactWriter(config, logger) {
-    if (config.artifactUpload === false) {
-        logger.debug("Artifact upload explicitly disabled via artifactUpload=false");
-        return undefined;
+    // 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) {
+        logger.debug("Artifact writer: NoOpArtifactWriter (--no-artifacts / artifactsDisabled / artifactUpload=false)");
+        return new NoOpArtifactWriter();
     }
+    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);
+    const base = remote
+        ? new FanoutArtifactWriter([local, remote])
+        : local;
+    if (!remote) {
+        logger.debug(`Artifact writer: LocalFilesystemArtifactWriter only (rootDir=${rootDir})`);
+    }
+    else {
+        logger.debug(`Artifact writer: FanoutArtifactWriter([local=${rootDir}, ${remote.constructor.name}])`);
+    }
+    // Wrap in the accumulator so FinalizeRunStep can build a populated
+    // 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);
+}
+/**
+ * Validate the exclude list against the registry. Unknown types are dropped
+ * with a warning — a typo'd CLI flag shouldn't silently match nothing.
+ */
+function resolveExcludeList(raw, logger) {
+    if (!raw || raw.length === 0)
+        return [];
+    const valid = [];
+    for (const name of raw) {
+        if (isArtifactType(name)) {
+            valid.push(name);
+        }
+        else {
+            logger.warn(`--artifacts-exclude: "${name}" is not a known artifact type — ignored`);
+        }
+    }
+    return valid;
+}
+/**
+ * The optional remote-backend writer layered on top of the local writer.
+ * Returns null when no credentials are available — the local writer stays
+ * the sole backend for that run, which is the D0033 M4 default for laptops
+ * and CI without GCS creds.
+ */
+function createRemoteArtifactWriter(config, logger) {
     const bucket = config.artifactGcsBucket ?? DEFAULT_ARTIFACT_BUCKET;
-    // CI / GCP runtime — direct GCS upload (fastest, no extra hop).
-    // We treat the presence of either env var as the user opting in to ADC.
     const hasGcsCredentials = Boolean(process.env.GOOGLE_APPLICATION_CREDENTIALS || process.env.GCLOUD_PROJECT);
     if (hasGcsCredentials) {
-        logger.debug(`Artifact writer: GcsArtifactWriter (direct GCS via ADC, bucket=${bucket})`);
+        logger.debug(`Artifact remote backend: GcsArtifactWriter (ADC, bucket=${bucket})`);
         return new GcsArtifactWriter({ bucket });
     }
-    // Local dev — request signed PUT URLs from the API gateway, no GCS creds needed.
     if (config.apiKey && config.apiUrl) {
-        logger.debug(`Artifact writer: ApiGatewayArtifactWriter (signed URL via ${config.apiUrl}, bucket=${bucket})`);
+        logger.debug(`Artifact remote backend: ApiGatewayArtifactWriter (via ${config.apiUrl}, bucket=${bucket})`);
         return new ApiGatewayArtifactWriter({
             apiBaseUrl: config.apiUrl,
             apiKey: config.apiKey,
             bucket,
         });
     }
-    logger.debug("Artifact upload skipped: no GCS credentials or AILF_API_KEY available");
-    return undefined;
+    return null;
 }
 function createCache(config) {
     const local = new FilesystemCache(config.rootDir);

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

@@ -11,7 +11,7 @@
  * each step completes. This enables the GET /v1/jobs/:jobId polling
  * endpoint to show real-time progress.
  */
-import type { AppContext, PipelineResult, PipelineStep } from "../_vendor/ailf-core/index.d.ts";
+import { type AppContext, type PipelineResult, type PipelineStep } from "../_vendor/ailf-core/index.d.ts";
 /**
  * Run a sequence of pipeline steps, short-circuiting on required step failure.
  *