@sanity/ailf 6.1.0 → 6.1.1

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

@@ -200,6 +200,23 @@ export interface ArtifactDescriptor<TEntry = unknown, TPreview = unknown> {
      *   descriptors. `entryKey` is ignored on versioned bulk paths.
      */
     readonly objectPath: ArtifactObjectPath;
+    /**
+     * Extract the positional args (beyond `runId`) to pass to `objectPath`
+     * when this descriptor needs more than `runId` to build its path.
+     *
+     * The default plain-bulk path is `objectPath(runId)`. The default
+     * per-entry path is `objectPath(runId, entryKey)`. Descriptors whose
+     * path needs additional axes from `association` and/or fields from the
+     * payload (e.g. the bulk-versioned-with-report-axis carve-out used by
+     * the diagnosis descriptor — see `BULK_VERSIONED_WITH_REPORT_AXIS`)
+     * set this function. The writer calls it and spreads the result:
+     *   `objectPath(runId, ...extractPathArgs(association, payload))`.
+     *
+     * Returning `[undefined]` (or any `undefined` element) is fine — the
+     * underlying builder is expected to throw a meaningful error in that
+     * case, which the writer surfaces via its existing try/catch.
+     */
+    readonly extractPathArgs?: (association: AssociationValues, payload: unknown) => readonly (string | undefined)[];
     /**
      * Build a filename-safe entry key from association values. Only meaningful
      * for `layout === "per-entry"` — bulk descriptors omit it.

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

@@ -674,6 +674,7 @@ function buildDescriptor(input) {
         versionedBy: input.versionedBy,
         pathSafetyMarker: input.pathSafetyMarker,
         objectPath,
+        extractPathArgs: input.extractPathArgs,
         formatEntryKey,
         parseEntryKey,
         manifestPreview: input.manifestPreview,
@@ -1185,6 +1186,19 @@ export const ARTIFACT_REGISTRY = {
         writePolicy: "post-hoc",
         versionedBy: "diagnosisVersion",
         objectPath: diagnosisPathBuilder(),
+        // The diagnosis path builder takes (runId, reportId, version). The
+        // reportId comes from association.report; the version is a compound
+        // `diagnosisVersion|cardVersion` synthesized from the payload's
+        // `inputs` field via `encodeDiagnosisPathVersion`. Writers spread
+        // this beyond `runId` when calling `objectPath`.
+        extractPathArgs: (assoc, payload) => {
+            const reportId = typeof assoc.report === "string" ? assoc.report : undefined;
+            const diag = payload;
+            const dv = diag?.inputs?.diagnosisVersion;
+            const cv = diag?.inputs?.cardVersion;
+            const version = dv && cv ? encodeDiagnosisPathVersion(dv, cv) : undefined;
+            return [reportId, version];
+        },
         // Defense-in-depth: this descriptor's axes (`run`, `report`) are both
         // bounded, so the `assertValidArtifactDescriptor` unbounded-axis rule
         // does not fire and the carve-out is never consulted at module load

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

@@ -343,6 +343,16 @@ export interface ReportStorePort {
     read(id: string): Promise<null | unknown>;
     /** Patch synthesis telemetry onto a published report (Phase 6 / DIAG-06). */
     patchSynthesis(id: string, telemetry: unknown): Promise<void>;
+    /**
+     * Patch a single artifact-manifest entry onto a published report.
+     *
+     * Used by deferred commands (e.g. `ailf interpret`) whose post-hoc writer
+     * produces a new ArtifactRef after the doc was already published. The
+     * pipeline path lifts the full manifest at publish time
+     * (publish-report-step); this is the post-hoc equivalent for one slot.
+     * Non-fatal on Sanity failure — mirrors `patchSynthesis`.
+     */
+    patchArtifactManifest(id: string, slot: string, ref: unknown): Promise<void>;
 }
 /**
  * Minimal report sink interface used by AppContext.

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

@@ -27,7 +27,7 @@
  * @see docs/decisions/D0032-run-anchored-artifact-store.md
  * @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 ArtifactEntry, type ArtifactRef, type ArtifactType, type ArtifactWriter, type AssociationValues, type RunId, type RunManifest, type WriteSource } 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"). */
@@ -41,10 +41,20 @@ export interface ApiGatewayArtifactWriterOptions {
      * Defaults to a no-op so the hot path stays free when metrics are off.
      */
     metrics?: UploadMetricsSink;
+    /**
+     * Identifies what kind of execution context owns this writer instance.
+     * The D0050 guard refuses to emit a descriptor whose `writePolicy` is
+     * different from this value. `"pipeline"` (the default) is for writers
+     * driven by an `ailf run` pipeline; `"post-hoc"` is for writers driven
+     * by deferred commands like `ailf interpret` that emit descriptors
+     * declared `writePolicy: "post-hoc"` (D0050).
+     */
+    writerSource?: WriteSource;
 }
 export declare class ApiGatewayArtifactWriter implements ArtifactWriter {
     private readonly options;
     private readonly metrics;
+    private readonly writerSource;
     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

@@ -33,14 +33,16 @@ import { NO_OP_UPLOAD_METRICS, } from "./upload-metrics.js";
 export class ApiGatewayArtifactWriter {
     options;
     metrics;
+    writerSource;
     constructor(options) {
         this.options = options;
         this.metrics = options.metrics ?? NO_OP_UPLOAD_METRICS;
+        this.writerSource = options.writerSource ?? "pipeline";
     }
     // ---- Canonical W0049 API ------------------------------------------------
     async emit(type, association, payload) {
         const descriptor = ARTIFACT_REGISTRY[type];
-        assertWritePolicyMatches("pipeline", descriptor);
+        assertWritePolicyMatches(this.writerSource, descriptor);
         const runId = association.run;
         if (!runId) {
             console.warn(`  ⚠️  emit("${type}"): association.run is required, skipping`);

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

@@ -25,7 +25,7 @@
  * does this writer. Traces flow through the GCS-direct writer when ADC
  * credentials are present.
  */
-import { type ArtifactEntry, type ArtifactRef, type ArtifactType, type ArtifactWriter, type AssociationValues, type RunId, type RunManifest } from "../_vendor/ailf-core/index.d.ts";
+import { type ArtifactEntry, type ArtifactRef, type ArtifactType, type ArtifactWriter, type AssociationValues, type RunId, type RunManifest, type WriteSource } from "../_vendor/ailf-core/index.d.ts";
 import { type UploadMetricsSink } from "./upload-metrics.js";
 export interface BatchingApiGatewayArtifactWriterOptions {
     /** Base URL of the API gateway (e.g., "https://ailf-api.sanity.build"). */
@@ -46,12 +46,22 @@ export interface BatchingApiGatewayArtifactWriterOptions {
     putConcurrency?: number;
     /** Optional metrics sink; defaults to no-op. */
     metrics?: UploadMetricsSink;
+    /**
+     * Identifies what kind of execution context owns this writer instance.
+     * The D0050 guard refuses to emit a descriptor whose `writePolicy` is
+     * different from this value. `"pipeline"` (the default) is for writers
+     * driven by an `ailf run` pipeline; `"post-hoc"` is for writers driven
+     * by deferred commands like `ailf interpret` that emit descriptors
+     * declared `writePolicy: "post-hoc"` (D0050).
+     */
+    writerSource?: WriteSource;
 }
 export declare class BatchingApiGatewayArtifactWriter implements ArtifactWriter {
     private readonly options;
     private readonly pending;
     private flushing;
     private microtaskScheduled;
+    private readonly writerSource;
     constructor(options: BatchingApiGatewayArtifactWriterOptions);
     emit<T extends ArtifactType>(type: T, association: AssociationValues, payload: unknown): Promise<ArtifactRef | null>;
     appendNdjson(): Promise<ArtifactRef | null>;

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

@@ -51,6 +51,7 @@ export class BatchingApiGatewayArtifactWriter {
     pending = [];
     flushing = null;
     microtaskScheduled = false;
+    writerSource;
     constructor(options) {
         this.options = {
             apiBaseUrl: options.apiBaseUrl,
@@ -60,11 +61,12 @@ export class BatchingApiGatewayArtifactWriter {
             putConcurrency: options.putConcurrency ?? DEFAULT_PUT_CONCURRENCY,
             metrics: options.metrics ?? NO_OP_UPLOAD_METRICS,
         };
+        this.writerSource = options.writerSource ?? "pipeline";
     }
     // ---- ArtifactWriter surface --------------------------------------------
     async emit(type, association, payload) {
         const descriptor = ARTIFACT_REGISTRY[type];
-        assertWritePolicyMatches("pipeline", descriptor);
+        assertWritePolicyMatches(this.writerSource, descriptor);
         const runId = association.run;
         if (!runId) {
             console.warn(`  ⚠️  emit("${type}"): association.run is required, skipping`);

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

@@ -28,7 +28,7 @@
  * @see docs/decisions/D0033-unified-run-anchored-artifact-capture.md
  */
 import { Storage } from "@google-cloud/storage";
-import { type ArtifactEntry, type ArtifactRef, type ArtifactType, type ArtifactWriter, type ArtifactWriterProgressOptions, type AssociationValues, type RunId, type RunManifest } from "../_vendor/ailf-core/index.d.ts";
+import { type ArtifactEntry, type ArtifactRef, type ArtifactType, type ArtifactWriter, type ArtifactWriterProgressOptions, type AssociationValues, type RunId, type RunManifest, type WriteSource } from "../_vendor/ailf-core/index.d.ts";
 import { type UploadMetricsSink } from "./upload-metrics.js";
 export interface GcsArtifactWriterOptions {
     /** GCS bucket name (e.g., "ailf-artifacts") */
@@ -51,6 +51,15 @@ export interface GcsArtifactWriterOptions {
      * Defaults to a no-op so the hot path stays free when metrics are off.
      */
     metrics?: UploadMetricsSink;
+    /**
+     * Identifies what kind of execution context owns this writer instance.
+     * The D0050 guard refuses to emit a descriptor whose `writePolicy` is
+     * different from this value. `"pipeline"` (the default) is for writers
+     * driven by an `ailf run` pipeline; `"post-hoc"` is for writers driven
+     * by deferred commands like `ailf interpret` that emit descriptors
+     * declared `writePolicy: "post-hoc"` (D0050).
+     */
+    writerSource?: WriteSource;
 }
 export declare class GcsArtifactWriter implements ArtifactWriter {
     private client;
@@ -68,6 +77,7 @@ export declare class GcsArtifactWriter implements ArtifactWriter {
      * measured safe, without forcing the producer to own that knob.
      */
     private readonly limiter;
+    private readonly writerSource;
     constructor(options: GcsArtifactWriterOptions);
     private reportProgress;
     emit<T extends ArtifactType>(type: T, association: AssociationValues, payload: unknown): Promise<ArtifactRef | null>;

package/dist/artifact-capture/gcs-artifact-writer.js

@@ -57,9 +57,11 @@ export class GcsArtifactWriter {
      * measured safe, without forcing the producer to own that knob.
      */
     limiter;
+    writerSource;
     constructor(options) {
         this.options = options;
         this.metrics = options.metrics ?? NO_OP_UPLOAD_METRICS;
+        this.writerSource = options.writerSource ?? "pipeline";
         if (options.storage) {
             this.client = options.storage;
         }
@@ -79,7 +81,7 @@ export class GcsArtifactWriter {
     // ---- Canonical W0049 API ------------------------------------------------
     async emit(type, association, payload) {
         const descriptor = ARTIFACT_REGISTRY[type];
-        assertWritePolicyMatches("pipeline", descriptor);
+        assertWritePolicyMatches(this.writerSource, descriptor);
         const runId = association.run;
         if (!runId) {
             console.warn(`  ⚠️  emit("${type}"): association.run is required, skipping`);
@@ -92,7 +94,8 @@ export class GcsArtifactWriter {
         const { body } = prepareUploadBody(payload, descriptor.mime);
         const preview = buildManifestPreview(descriptor, payload);
         if (descriptor.layout === "bulk") {
-            const path = descriptor.objectPath(runId);
+            const extra = descriptor.extractPathArgs?.(association, payload) ?? [];
+            const path = descriptor.objectPath(runId, ...extra);
             const ref = await this.putBody(path, body, {
                 layout: "bulk",
                 mime: descriptor.mime,
@@ -133,7 +136,7 @@ export class GcsArtifactWriter {
     }
     async appendNdjson(type, association, rows) {
         const descriptor = ARTIFACT_REGISTRY[type];
-        assertWritePolicyMatches("pipeline", descriptor);
+        assertWritePolicyMatches(this.writerSource, descriptor);
         if (descriptor.mime !== "application/x-ndjson") {
             console.warn(`  ⚠️  appendNdjson("${type}"): descriptor mime is ${descriptor.mime}, not application/x-ndjson — skipping`);
             return null;

package/dist/artifact-capture/local-fs-artifact-writer.d.ts

@@ -36,7 +36,7 @@
  * @see docs/decisions/D0033-unified-run-anchored-artifact-capture.md (§ M4)
  * @see packages/eval/src/artifact-capture/gcs-artifact-writer.ts (mirror)
  */
-import { type ArtifactEntry, type ArtifactRef, type ArtifactType, type ArtifactWriter, type ArtifactWriterProgressOptions, type AssociationValues, type RunId, type RunManifest } from "../_vendor/ailf-core/index.d.ts";
+import { type ArtifactEntry, type ArtifactRef, type ArtifactType, type ArtifactWriter, type ArtifactWriterProgressOptions, type AssociationValues, type RunId, type RunManifest, type WriteSource } from "../_vendor/ailf-core/index.d.ts";
 export interface LocalFilesystemArtifactWriterOptions {
     /**
      * Absolute or cwd-relative root directory under which `runs/{runId}/…`
@@ -56,10 +56,20 @@ export interface LocalFilesystemArtifactWriterOptions {
      * render per-batch updates during long export phases.
      */
     progress?: ArtifactWriterProgressOptions;
+    /**
+     * Identifies what kind of execution context owns this writer instance.
+     * The D0050 guard refuses to emit a descriptor whose `writePolicy` is
+     * different from this value. `"pipeline"` (the default) is for writers
+     * driven by an `ailf run` pipeline; `"post-hoc"` is for writers driven
+     * by deferred commands like `ailf interpret` that emit descriptors
+     * declared `writePolicy: "post-hoc"` (D0050).
+     */
+    writerSource?: WriteSource;
 }
 export declare class LocalFilesystemArtifactWriter implements ArtifactWriter {
     private readonly options;
     private readonly excludeSet;
+    private readonly writerSource;
     constructor(options: LocalFilesystemArtifactWriterOptions);
     private reportProgress;
     emit<T extends ArtifactType>(type: T, association: AssociationValues, payload: unknown): Promise<ArtifactRef | null>;

package/dist/artifact-capture/local-fs-artifact-writer.js

@@ -46,9 +46,11 @@ import { redactArtifactData } from "./redact-artifact.js";
 export class LocalFilesystemArtifactWriter {
     options;
     excludeSet;
+    writerSource;
     constructor(options) {
         this.options = options;
         this.excludeSet = new Set(options.exclude ?? []);
+        this.writerSource = options.writerSource ?? "pipeline";
     }
     reportProgress(ref) {
         const progress = this.options.progress;
@@ -66,7 +68,7 @@ export class LocalFilesystemArtifactWriter {
         if (this.excludeSet.has(type))
             return null;
         const descriptor = ARTIFACT_REGISTRY[type];
-        assertWritePolicyMatches("pipeline", descriptor);
+        assertWritePolicyMatches(this.writerSource, descriptor);
         const runId = association.run;
         if (!runId) {
             console.warn(`  ⚠️  emit("${type}"): association.run is required, skipping`);
@@ -81,7 +83,8 @@ export class LocalFilesystemArtifactWriter {
         // descriptor's capBytes.
         const preview = buildManifestPreview(descriptor, payload);
         if (descriptor.layout === "bulk") {
-            const relPath = descriptor.objectPath(runId);
+            const extra = descriptor.extractPathArgs?.(association, payload) ?? [];
+            const relPath = descriptor.objectPath(runId, ...extra);
             const absPath = this.resolve(relPath);
             const wrote = await this.writeAtomic(absPath, body);
             if (!wrote)
@@ -128,7 +131,7 @@ export class LocalFilesystemArtifactWriter {
         if (this.excludeSet.has(type))
             return null;
         const descriptor = ARTIFACT_REGISTRY[type];
-        assertWritePolicyMatches("pipeline", descriptor);
+        assertWritePolicyMatches(this.writerSource, descriptor);
         if (descriptor.mime !== "application/x-ndjson") {
             console.warn(`  ⚠️  appendNdjson("${type}"): descriptor mime is ${descriptor.mime}, not application/x-ndjson — skipping`);
             return null;

package/dist/composition-root.d.ts

@@ -15,7 +15,7 @@
  * @see packages/core/src/ports/context.ts — AppContext interface
  * @see docs/archive/exec-plans/ports-and-adapters/phase-7-composition-root.md
  */
-import { type AppContext, type ArtifactWriter, type ArtifactWriterProgressOptions, type AssertionRegistration, type CardRegistry, type DiagnosisRunner, type Logger, type ResolvedConfig } from "./_vendor/ailf-core/index.d.ts";
+import { type AppContext, type ArtifactWriter, type ArtifactWriterProgressOptions, type AssertionRegistration, type CardRegistry, type DiagnosisRunner, type Logger, type ResolvedConfig, type WriteSource } from "./_vendor/ailf-core/index.d.ts";
 export type { LLMClientKeys } from "./_vendor/ailf-core/index.d.ts";
 import { type BorderlineConsensusOptions, type BorderlineConsensusResult } from "./pipeline/borderline-consensus-runner.js";
 import { CompositeTaskSource, ContentLakeTaskSource, RepoTaskSource } from "./adapters/task-sources/index.js";
@@ -44,7 +44,7 @@ export declare function createAppContext(config: ResolvedConfig): AppContext;
  *
  * Exported for unit-test access; not part of the public package API.
  */
-export declare function createArtifactWriter(config: ResolvedConfig, logger: Logger, progress?: ArtifactWriterProgressOptions): ArtifactWriter;
+export declare function createArtifactWriter(config: ResolvedConfig, logger: Logger, progress?: ArtifactWriterProgressOptions, writerSource?: WriteSource): ArtifactWriter;
 /**
  * Build the `TaskSource` adapter wired by the composition root for a
  * given `ResolvedConfig`. Exported for test access — composition-root
@@ -110,10 +110,27 @@ export declare function buildDiagnosisRegistry(): CardRegistry;
  *
  * Wires the full 8-card registry, `loadAttributions` bound to the local
  * filesystem (Phase-4 per-entry attribution objects at
- * `{artifactsDir}/runs/{runId}/attribution/*.json`), and no-op cache
- * reader/writer (Plan-06 CLI command will wire the real cache seam).
+ * `{artifactsDir}/runs/{runId}/attribution/*.json`), and the real
+ * `diagnosisWriter` that emits the Diagnosis through a post-hoc-flagged
+ * artifact writer AND patches the report doc's
+ * `summary.artifactManifest.diagnosis` slot. Two steps because `ailf interpret`
+ * runs after the report doc has already been published — the pipeline path's
+ * publish-report-step.ts:187 lifts the in-memory run manifest into the doc at
+ * end-of-run, but that step never fires for a deferred command.
+ *
+ * The post-hoc writer is built with `writerSource: "post-hoc"` so the D0050
+ * guard accepts the diagnosis descriptor (`writePolicy: "post-hoc"`). Without
+ * this, every emit would be rejected at runtime.
+ *
+ * `diagnosisReader` is still a no-op shim: the Studio data path uses the
+ * artifact-manifest entry (populated by the writer + patch) plus a signed-URL
+ * fetch, so reader-side cache wiring is deferred to a follow-up W-item.
+ * Without the reader, `ailf interpret --refresh` cache hits are not yet served
+ * from GCS — they recompute.
  *
  * Plan-06 API/CLI consumers import this function from the composition root
  * and pass `ctx` from `createAppContext(config)`.
  */
-export declare function getDiagnosisRunner(ctx: AppContext): DiagnosisRunner;
+export declare function getDiagnosisRunner(ctx: AppContext, opts?: {
+    artifactWriter?: ArtifactWriter;
+}): DiagnosisRunner;

package/dist/composition-root.js

@@ -192,7 +192,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, progress) {
+export function createArtifactWriter(config, logger, progress, writerSource = "pipeline") {
     // 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) {
@@ -214,10 +214,11 @@ export function createArtifactWriter(config, logger, progress) {
     // 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 remote = createRemoteArtifactWriter(config, logger, metrics, writerSource);
     const local = new LocalFilesystemArtifactWriter({
         rootDir,
         exclude,
+        writerSource,
         ...(remote ? {} : { progress }),
     });
     // W0064 — when a remote backend is wired, list it first so its ArtifactRef
@@ -267,7 +268,7 @@ 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, metrics) {
+function createRemoteArtifactWriter(config, logger, metrics, writerSource = "pipeline") {
     const bucket = config.artifactGcsBucket ?? DEFAULT_ARTIFACT_BUCKET;
     const hasGcsCredentials = Boolean(process.env.GOOGLE_APPLICATION_CREDENTIALS || process.env.GCLOUD_PROJECT);
     if (hasGcsCredentials) {
@@ -279,6 +280,7 @@ function createRemoteArtifactWriter(config, logger, metrics) {
         logger.debug(`Artifact remote backend: GcsArtifactWriter (ADC, bucket=${bucket}, defaultConcurrency=8)`);
         return new GcsArtifactWriter({
             bucket,
+            writerSource,
             ...(metrics ? { metrics } : {}),
         });
     }
@@ -306,6 +308,7 @@ function createRemoteArtifactWriter(config, logger, metrics) {
                 apiKey: config.apiKey,
                 bucket,
                 putConcurrency: concurrency,
+                writerSource,
                 ...(metrics ? { metrics } : {}),
             });
         }
@@ -314,6 +317,7 @@ function createRemoteArtifactWriter(config, logger, metrics) {
             apiBaseUrl: config.apiUrl,
             apiKey: config.apiKey,
             bucket,
+            writerSource,
             ...(metrics ? { metrics } : {}),
         });
     }
@@ -585,17 +589,83 @@ async function loadAttributionsFromLocalFs(runId, artifactsDir, logger) {
  *
  * Wires the full 8-card registry, `loadAttributions` bound to the local
  * filesystem (Phase-4 per-entry attribution objects at
- * `{artifactsDir}/runs/{runId}/attribution/*.json`), and no-op cache
- * reader/writer (Plan-06 CLI command will wire the real cache seam).
+ * `{artifactsDir}/runs/{runId}/attribution/*.json`), and the real
+ * `diagnosisWriter` that emits the Diagnosis through a post-hoc-flagged
+ * artifact writer AND patches the report doc's
+ * `summary.artifactManifest.diagnosis` slot. Two steps because `ailf interpret`
+ * runs after the report doc has already been published — the pipeline path's
+ * publish-report-step.ts:187 lifts the in-memory run manifest into the doc at
+ * end-of-run, but that step never fires for a deferred command.
+ *
+ * The post-hoc writer is built with `writerSource: "post-hoc"` so the D0050
+ * guard accepts the diagnosis descriptor (`writePolicy: "post-hoc"`). Without
+ * this, every emit would be rejected at runtime.
+ *
+ * `diagnosisReader` is still a no-op shim: the Studio data path uses the
+ * artifact-manifest entry (populated by the writer + patch) plus a signed-URL
+ * fetch, so reader-side cache wiring is deferred to a follow-up W-item.
+ * Without the reader, `ailf interpret --refresh` cache hits are not yet served
+ * from GCS — they recompute.
  *
  * Plan-06 API/CLI consumers import this function from the composition root
  * and pass `ctx` from `createAppContext(config)`.
  */
-export function getDiagnosisRunner(ctx) {
+export function getDiagnosisRunner(ctx, opts) {
     const artifactsDir = ctx.config.artifactsDir ?? DIAGNOSIS_LOCAL_ARTIFACTS_DIR;
-    // No-op cache shims — Plan 06 wires the real cache.
+    // Post-hoc artifact writer — built with the same fanout/remote/local layering
+    // as the pipeline writer but flagged so the D0050 guard accepts post-hoc
+    // descriptors. Construction is per-runner so the AccumulatingArtifactWriter's
+    // internal manifest doesn't carry state between unrelated interpret runs.
+    // Tests inject their own writer via opts.artifactWriter; the production
+    // CLI / pipeline callers never pass it.
+    const postHocArtifactWriter = opts?.artifactWriter ??
+        createArtifactWriter(ctx.config, ctx.logger, undefined, "post-hoc");
+    // No-op reader — see JSDoc above. The Studio data path is manifest-driven,
+    // not reader-driven, so the writer + patch alone unblock Phase 7.
     const diagnosisReader = async (_path) => null;
-    const diagnosisWriter = async (_path, _diagnosis) => { };
+    // Real writer — two-step persistence:
+    //  1. Emit the diagnosis payload through the post-hoc writer; the descriptor's
+    //     `objectPath: diagnosisPathBuilder()` derives the storage path from
+    //     `{runId, reportId, compoundVersion}`.
+    //  2. Patch the published report doc's `summary.artifactManifest.diagnosis`
+    //     slot with the returned ArtifactRef, so Studio's slim-shape GROQ
+    //     projection surfaces the entry. (The pipeline path runs this lift via
+    //     publish-report-step.ts; that step never fires for a deferred command,
+    //     hence the explicit patch here.)
+    //
+    // Errors are caught and logged rather than thrown — the diagnosis runner
+    // separates "compute" from "persist". Failed persistence should not panic
+    // the runner; the computed cards still surface to API/CLI callers in-memory.
+    // ReportStore.patchArtifactManifest is itself non-fatal on Sanity failure,
+    // so it does not need its own try/catch.
+    const diagnosisWriter = async (_descriptorPath, diagnosis) => {
+        let ref;
+        try {
+            // Anchor the diagnosis to the REPORT's run, not the post-hoc CLI's
+            // session run. `ctx.runId` is freshly generated per interpret
+            // invocation; the report doc's `provenance.runId` is what Studio
+            // and the signing endpoint look up. Using `assoc(ctx, ...)` would
+            // bind `run` to ctx.runId — the path would be writeable but
+            // unreachable from the Studio side.
+            ref = await postHocArtifactWriter.emit("diagnosis", { run: diagnosis.runId, report: diagnosis.reportId }, diagnosis);
+        }
+        catch (error) {
+            ctx.logger.warn("diagnosis-emit-failed", {
+                reportId: diagnosis.reportId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return;
+        }
+        if (!ref)
+            return;
+        if (!ctx.reportStore) {
+            ctx.logger.warn("diagnosis-emit: no reportStore on context", {
+                reportId: diagnosis.reportId,
+            });
+            return;
+        }
+        await ctx.reportStore.patchArtifactManifest(diagnosis.reportId, "diagnosis", ref);
+    };
     return createDiagnosisRunner({
         llm: ctx.llmClient,
         model: modelId("anthropic:claude-opus-4-6"),

package/dist/orchestration/steps/gap-analysis-step.js

@@ -215,7 +215,6 @@ export class GapAnalysisStep {
                 ...(documentManifest !== undefined && { documentManifest }),
                 failureModes: failureModeReport,
                 lowScoringJudgments,
-                recommendations: gapReport,
                 scores: enrichedScores,
                 ...(testResults !== undefined && { testResults }),
             };

package/dist/report-store.d.ts

@@ -15,7 +15,7 @@
  * @see docs/design-docs/report-store/domain-model.md
  */
 import type { SanityClient } from "@sanity/client";
-import type { SynthesisCostTelemetry } from "./_vendor/ailf-core/index.d.ts";
+import type { ArtifactRef, ArtifactType, SynthesisCostTelemetry } from "./_vendor/ailf-core/index.d.ts";
 import type { ComparisonReport, ISOTimestamp, LineageQuery, Report, ReportId, ReportProvenance, ScoreSummary } from "./pipeline/types.js";
 /**
  * Result of an auto-comparison, bundling the ComparisonReport with the
@@ -134,6 +134,20 @@ export declare class ReportStore {
      * Document _id is `report-${reportId}` (see `toSanityReportDoc` L559).
      */
     patchSynthesis(reportId: ReportId, telemetry: SynthesisCostTelemetry): Promise<void>;
+    /**
+     * Patch a single artifact-manifest entry onto a published report.
+     *
+     * Used by deferred commands like `ailf interpret` whose post-hoc writer
+     * produces a new ArtifactRef *after* the report doc was published. The
+     * pipeline path lifts the full manifest into the doc at publish time
+     * (publish-report-step.ts:187); this method is the post-hoc equivalent
+     * for a single slot.
+     *
+     * Non-fatal on Sanity failure — mirrors `patchSynthesis` (L423).
+     *
+     * Document _id is `report-${reportId}` (see `toSanityReportDoc` L559).
+     */
+    patchArtifactManifest(reportId: ReportId, slot: ArtifactType, ref: ArtifactRef): Promise<void>;
     /**
      * Query error arrays from the last N reports for chronic failure detection.
      *

package/dist/report-store.js

@@ -327,6 +327,31 @@ export class ReportStore {
             console.warn(`  ⚠️  Failed to patch synthesis telemetry on report ${reportId}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    /**
+     * Patch a single artifact-manifest entry onto a published report.
+     *
+     * Used by deferred commands like `ailf interpret` whose post-hoc writer
+     * produces a new ArtifactRef *after* the report doc was published. The
+     * pipeline path lifts the full manifest into the doc at publish time
+     * (publish-report-step.ts:187); this method is the post-hoc equivalent
+     * for a single slot.
+     *
+     * Non-fatal on Sanity failure — mirrors `patchSynthesis` (L423).
+     *
+     * Document _id is `report-${reportId}` (see `toSanityReportDoc` L559).
+     */
+    async patchArtifactManifest(reportId, slot, ref) {
+        try {
+            await this.client
+                .patch(`report-${reportId}`)
+                .setIfMissing({ "summary.artifactManifest": {} })
+                .set({ [`summary.artifactManifest.${slot}`]: ref })
+                .commit();
+        }
+        catch (error) {
+            console.warn(`  ⚠️  Failed to patch artifactManifest.${slot} on report ${reportId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     /**
      * Query error arrays from the last N reports for chronic failure detection.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/ailf",
-  "version": "6.1.0",
+  "version": "6.1.1",
   "private": false,
   "publishConfig": {
     "access": "public"