@stigmer/runner 3.11.1-dev.20260812192248 → 3.12.1

package/src/__test-utils__/zip-fixtures.ts

@@ -0,0 +1,206 @@
+/**
+ * Shared ZIP fixture builder for runner unit tests.
+ *
+ * Emits complete, real-shaped archives — local file headers (optionally
+ * streaming-style, the Go stdlib writer's default), payloads, central
+ * directory, and EOCD — because that is the only shape that can reach the
+ * runner: both editions' skill push gates validate artifacts with
+ * central-directory-based readers (see zip-extract.ts's module doc and
+ * design record 017). Earlier fixtures emitted local headers only, a
+ * shape no real ZIP writer produces, and were coupled to the old parser's
+ * front-to-back walk.
+ *
+ * Mirrors the conformance suite's `zipFilesStreaming()`
+ * (test/conformance/src/support/skills.ts) so unit fixtures and
+ * cross-edition fixtures share one shape.
+ *
+ * Lives in src/__test-utils__/ so `tsc --noEmit` covers it while
+ * tsconfig.build.json keeps it out of dist/.
+ */
+
+import { deflateRawSync } from "node:zlib";
+
+export interface ZipFixtureFile {
+  name: string;
+  /** Text content is UTF-8 encoded; pass bytes directly for binary payloads. */
+  content: string | Uint8Array;
+  /** Compression method for the entry. Defaults to stored. */
+  method?: "stored" | "deflated";
+  /**
+   * Emit the entry the way Go's archive/zip does by default: general-purpose
+   * flag bit 3 set, zeroed sizes in the local header, and a trailing data
+   * descriptor (with the conventional signature) carrying the real values.
+   */
+  streaming?: boolean;
+  /**
+   * Lie about the entry's uncompressed size everywhere the writer would
+   * declare it (local header, data descriptor, central directory). Models a
+   * crafted archive whose declarations disagree with its actual payload —
+   * the input class the attachment injector's declared-size enforcement
+   * exists to reject (issue #567).
+   */
+  declaredUncompressedSize?: number;
+}
+
+export interface ZipFixtureOptions {
+  /** Trailing archive comment appended after the EOCD record. */
+  comment?: string;
+  /**
+   * Drop the central directory and EOCD, leaving only local headers and
+   * payloads. No real ZIP writer produces this shape — it models a download
+   * truncated before the archive's index.
+   */
+  omitCentralDirectory?: boolean;
+}
+
+/** Build a ZIP archive from path + content pairs. */
+export function buildZip(files: ZipFixtureFile[], options?: ZipFixtureOptions): Uint8Array {
+  const out = new ByteWriter();
+
+  interface WrittenEntry {
+    nameBytes: Uint8Array;
+    payload: Uint8Array;
+    declaredUncompressed: number;
+    crc: number;
+    flags: number;
+    method: number;
+    localHeaderOffset: number;
+  }
+  const written: WrittenEntry[] = [];
+
+  for (const file of files) {
+    const contentBytes =
+      typeof file.content === "string" ? new TextEncoder().encode(file.content) : file.content;
+    const deflated = file.method === "deflated";
+    const payload = deflated ? new Uint8Array(deflateRawSync(contentBytes)) : contentBytes;
+    const entry: WrittenEntry = {
+      nameBytes: new TextEncoder().encode(file.name),
+      payload,
+      declaredUncompressed: file.declaredUncompressedSize ?? contentBytes.length,
+      crc: crc32(contentBytes),
+      flags: file.streaming ? 0x0008 : 0,
+      method: deflated ? 8 : 0,
+      localHeaderOffset: out.length,
+    };
+    written.push(entry);
+
+    out.u32(0x04034b50); // local file header signature
+    out.u16(20); // version needed to extract
+    out.u16(entry.flags);
+    out.u16(entry.method);
+    out.u16(0); // mod time
+    out.u16(0); // mod date
+    out.u32(file.streaming ? 0 : entry.crc);
+    out.u32(file.streaming ? 0 : payload.length);
+    out.u32(file.streaming ? 0 : entry.declaredUncompressed);
+    out.u16(entry.nameBytes.length);
+    out.u16(0); // extra field length
+    out.raw(entry.nameBytes);
+    out.raw(payload);
+
+    if (file.streaming) {
+      out.u32(0x08074b50); // data descriptor signature (Go writes it)
+      out.u32(entry.crc);
+      out.u32(payload.length);
+      out.u32(entry.declaredUncompressed);
+    }
+  }
+
+  if (options?.omitCentralDirectory) {
+    return out.toUint8Array();
+  }
+
+  const centralDirectoryOffset = out.length;
+  for (const entry of written) {
+    out.u32(0x02014b50); // central directory record signature
+    out.u16(20); // version made by
+    out.u16(20); // version needed to extract
+    out.u16(entry.flags);
+    out.u16(entry.method);
+    out.u16(0); // mod time
+    out.u16(0); // mod date
+    out.u32(entry.crc);
+    out.u32(entry.payload.length);
+    out.u32(entry.declaredUncompressed);
+    out.u16(entry.nameBytes.length);
+    out.u16(0); // extra field length
+    out.u16(0); // comment length
+    out.u16(0); // disk number start
+    out.u16(0); // internal attributes
+    out.u32(0); // external attributes
+    out.u32(entry.localHeaderOffset);
+    out.raw(entry.nameBytes);
+  }
+  const centralDirectorySize = out.length - centralDirectoryOffset;
+
+  const commentBytes = new TextEncoder().encode(options?.comment ?? "");
+  out.u32(0x06054b50); // EOCD signature
+  out.u16(0); // disk number
+  out.u16(0); // disk with central directory
+  out.u16(written.length); // entries on this disk
+  out.u16(written.length); // total entries
+  out.u32(centralDirectorySize);
+  out.u32(centralDirectoryOffset);
+  out.u16(commentBytes.length);
+  out.raw(commentBytes);
+
+  return out.toUint8Array();
+}
+
+// Chunked assembly instead of a number[]-per-byte accumulator: fixtures at
+// the injector's 100 MB zip-bomb limit are built from payload-sized chunks,
+// which a per-byte spread-push cannot survive (argument-count overflow).
+class ByteWriter {
+  private readonly chunks: Uint8Array[] = [];
+  private size = 0;
+
+  get length(): number {
+    return this.size;
+  }
+
+  u16(v: number): void {
+    this.raw(new Uint8Array([v & 0xff, (v >>> 8) & 0xff]));
+  }
+
+  u32(v: number): void {
+    this.raw(new Uint8Array([v & 0xff, (v >>> 8) & 0xff, (v >>> 16) & 0xff, (v >>> 24) & 0xff]));
+  }
+
+  raw(b: Uint8Array): void {
+    this.chunks.push(b);
+    this.size += b.length;
+  }
+
+  toUint8Array(): Uint8Array {
+    const result = new Uint8Array(this.size);
+    let offset = 0;
+    for (const chunk of this.chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
+  }
+}
+
+// Standard CRC-32 (IEEE 802.3, the ZIP checksum), table-driven so fixtures
+// at the injector's 100 MB limit stay cheap to build. Semantically identical
+// to the conformance suite's inline bit-loop helper.
+const CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let bit = 0; bit < 8; bit++) {
+      c = (c >>> 1) ^ (0xedb88320 & -(c & 1));
+    }
+    table[n] = c;
+  }
+  return table;
+})();
+
+function crc32(data: Uint8Array): number {
+  let crc = 0xffffffff;
+  for (let i = 0; i < data.length; i++) {
+    crc = (crc >>> 8) ^ CRC_TABLE[(crc ^ data[i]!) & 0xff]!;
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}

package/src/activities/execute-cursor/__tests__/attachment-resolver.test.ts

@@ -78,7 +78,11 @@ describe("resolveAttachments", () => {
     const result = await resolveAttachments([makeAttachment()], options({ storage }));
 
     expect(result).toEqual([
-      { filename: "plan.md", relativePath: ".stigmer/inputs/plan.md" },
+      {
+        filename: "plan.md",
+        relativePath: ".stigmer/inputs/plan.md",
+        downloadUrl: "mem://attachments/01ABC/plan.md",
+      },
     ]);
     expect(readFileSync(join(platformDir, "inputs", "plan.md"), "utf-8")).toBe("# The Plan");
   });
@@ -130,11 +134,16 @@ describe("resolveAttachments", () => {
     );
 
     expect(result).toEqual([
-      { filename: "report.pdf", relativePath: ".stigmer/inputs/report.pdf" },
+      {
+        filename: "report.pdf",
+        relativePath: ".stigmer/inputs/report.pdf",
+        downloadUrl: "mem://attachments/01AAA/report.pdf",
+      },
       {
         filename: "report-2.pdf",
         relativePath: ".stigmer/inputs/report-2.pdf",
         renamedFrom: "report.pdf",
+        downloadUrl: "mem://attachments/01BBB/report.pdf",
       },
     ]);
     expect(readFileSync(join(platformDir, "inputs", "report.pdf"), "utf-8")).toBe("first bytes");
@@ -155,12 +164,15 @@ describe("resolveAttachments", () => {
       options({ storage }),
     );
 
+    // The key-less local file lists no URL; the storage twin does — the
+    // per-file split the prompt renders.
     expect(result).toEqual([
       { filename: "notes.md", relativePath: ".stigmer/inputs/notes.md" },
       {
         filename: "notes-2.md",
         relativePath: ".stigmer/inputs/notes-2.md",
         renamedFrom: "notes.md",
+        downloadUrl: "mem://attachments/01ABC/notes.md",
       },
     ]);
     expect(readFileSync(join(platformDir, "inputs", "notes.md"), "utf-8")).toBe("local copy");
@@ -225,7 +237,11 @@ describe("resolveAttachments", () => {
     );
 
     expect(result).toEqual([
-      { filename: "evil.md", relativePath: ".stigmer/inputs/evil.md" },
+      {
+        filename: "evil.md",
+        relativePath: ".stigmer/inputs/evil.md",
+        downloadUrl: "mem://attachments/01ABC/x",
+      },
     ]);
     expect(readFileSync(join(platformDir, "inputs", "evil.md"), "utf-8")).toBe("contained");
     // Nothing escaped two levels up (where `../../evil.md` would have landed).
@@ -247,6 +263,50 @@ describe("resolveAttachments", () => {
     expect(readFileSync(join(platformDir, "inputs", "evil.txt"), "utf-8")).toBe("local-contained");
   });
 
+  // ── Download-URL hand-off (issue #532) ───────────────────────────────────
+  // The URL is strictly additive (shared/attachment-download-urls.ts): every
+  // case below also asserts the file materialized exactly as it would
+  // without one.
+
+  describe("download-URL minting during resolution", () => {
+    it("degrades to no URL when the mint fails — file still materialized, turn proceeds", async () => {
+      const { storage } = makeInMemoryArtifactStorage();
+      await storage.upload("attachments/01ABC/plan.md", Buffer.from("# The Plan"), "text/markdown");
+      storage.getDownloadUrl.mockRejectedValueOnce(new Error("presign endpoint unreachable"));
+
+      const result = await resolveAttachments([makeAttachment()], options({ storage }));
+
+      expect(result).toEqual([
+        { filename: "plan.md", relativePath: ".stigmer/inputs/plan.md" },
+      ]);
+      expect(readFileSync(join(platformDir, "inputs", "plan.md"), "utf-8")).toBe("# The Plan");
+    });
+
+    it("mints a URL on the localPath fast path when an uploaded copy also exists", async () => {
+      // The fast path skips storage for the BYTES; the mint rule is
+      // branch-independent, so the uploaded copy still backs the URL.
+      const srcPath = join(workspaceDir, "src.csv");
+      writeFileSync(srcPath, "a,b,c");
+      const { storage } = makeInMemoryArtifactStorage();
+
+      const result = await resolveAttachments(
+        [makeAttachment({ filename: "data.csv", storageKey: "attachments/01ABC/data.csv", localPath: srcPath })],
+        options({ storage }),
+      );
+
+      expect(result).toEqual([
+        {
+          filename: "data.csv",
+          relativePath: ".stigmer/inputs/data.csv",
+          downloadUrl: "mem://attachments/01ABC/data.csv",
+        },
+      ]);
+      // Bytes came off local disk, not storage — the fast path is intact.
+      expect(storage.download).not.toHaveBeenCalled();
+      expect(readFileSync(join(platformDir, "inputs", "data.csv"), "utf-8")).toBe("a,b,c");
+    });
+  });
+
   // ── Vision selection (T04) ────────────────────────────────────────────────
   // Vision is strictly additive: every case below also asserts the file
   // materialized exactly as it would without a budget.

package/src/activities/execute-cursor/__tests__/build-prompt.test.ts

@@ -9,10 +9,8 @@
 
 import { describe, it, expect } from "vitest";
 import { create } from "@bufbuild/protobuf";
-import { DatastoreUsageSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/spec_pb";
 import { ApprovalAction, InteractionMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { PendingApprovalSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/approval_pb";
-import { ApiResourceReferenceSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/io_pb";
 
 import { appendStructuredOutputDirective, buildPrompt, isHitlReinvocation, primarySendCarriesImages } from "../index.js";
 import type { BuildPromptInput } from "../index.js";
@@ -89,33 +87,6 @@ describe("buildPrompt", () => {
     expect(prompt).toContain(USER_MESSAGE);
   });
 
-  it("renders the <available_datastores> section on the first execution (T05)", () => {
-    const prompt = buildPrompt(
-      input({
-        resolution: resolution("local", "created_first_execution"),
-        datastoreUsages: [
-          create(DatastoreUsageSchema, {
-            datastoreRef: create(ApiResourceReferenceSchema, { slug: "clinic" }),
-          }),
-        ],
-      }),
-    );
-    expect(prompt).toContain("<available_datastores>");
-    expect(prompt).toContain("- clinic");
-    expect(prompt).toContain("describe_datastore");
-    // The standing failure-disclosure instruction (issue #325) is this
-    // harness's ONLY outage coverage: the Cursor SDK connects MCP itself,
-    // so the runner can never reconcile the live roster here.
-    expect(prompt).toContain("do not answer from memory");
-  });
-
-  it("omits the datastores section when the agent uses no datastores", () => {
-    const prompt = buildPrompt(
-      input({ resolution: resolution("local", "created_first_execution") }),
-    );
-    expect(prompt).not.toContain("<available_datastores>");
-  });
-
   it("carries the rollover context bridge on the first execution (DD-013)", () => {
     const prompt = buildPrompt(
       input({
@@ -454,6 +425,68 @@ describe("attachments on a resumed turn (T04 — the mid-session WhatsApp case)"
     expect(prompt).toContain("Attached inline and visible to you, in order: 1. a.jpg");
   });
 
+  it("lists a minted download URL beside its file with the presigned hand-off line (issue #532)", () => {
+    const prompt = buildPrompt(
+      input({
+        ...RESUMED,
+        attachments: [
+          { path: ".stigmer/inputs/lease.pdf", downloadUrl: "https://r2.example/lease?sig=abc" },
+          { path: ".stigmer/inputs/notes.md" },
+        ],
+        downloadUrlKind: "presigned",
+      }),
+    );
+    expect(prompt).toContain(
+      "- `.stigmer/inputs/lease.pdf` — download URL: https://r2.example/lease?sig=abc",
+    );
+    // The URL-less file keeps a clean entry.
+    expect(prompt).toContain("- `.stigmer/inputs/notes.md`\n");
+    expect(prompt).toContain("These URLs are time-limited");
+  });
+
+  it("words a local-serve URL honestly — reachable only from this machine", () => {
+    const prompt = buildPrompt(
+      input({
+        ...RESUMED,
+        attachments: [
+          { path: ".stigmer/inputs/lease.pdf", downloadUrl: "http://localhost:7235/attachments/01A/lease.pdf" },
+        ],
+        downloadUrlKind: "local-serve",
+      }),
+    );
+    expect(prompt).toContain("download URL: http://localhost:7235/attachments/01A/lease.pdf");
+    expect(prompt).toContain("reachable only from this machine");
+    expect(prompt).not.toContain("time-limited");
+  });
+
+  it("renders no hand-off line when no listed file carries a URL (kind alone is not enough)", () => {
+    const prompt = buildPrompt(
+      input({
+        ...RESUMED,
+        attachments: [{ path: ".stigmer/inputs/local-only.csv" }],
+        downloadUrlKind: "presigned",
+      }),
+    );
+    expect(prompt).toContain("<input_files>");
+    expect(prompt).not.toContain("download URL");
+    expect(prompt).not.toContain("time-limited");
+  });
+
+  it("renders the download URL inside the enhanced first-turn prompt too", () => {
+    const prompt = buildPrompt(
+      input({
+        resolution: resolution("local", "created_first_execution"),
+        attachments: [
+          { path: ".stigmer/inputs/lease.pdf", downloadUrl: "https://r2.example/lease?sig=abc" },
+        ],
+        downloadUrlKind: "presigned",
+      }),
+    );
+    expect(prompt).toContain("<input_files>");
+    expect(prompt).toContain("download URL: https://r2.example/lease?sig=abc");
+    expect(prompt).toContain("These URLs are time-limited");
+  });
+
   it("a HITL re-invocation carries no input-files section — its prompt has no user message at all", () => {
     const prompt = buildPrompt(
       input({

package/src/activities/execute-cursor/__tests__/skill-resolver.test.ts

@@ -3,6 +3,7 @@ import { mkdtempSync, readFileSync, existsSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { resolveSkills } from "../skill-resolver.js";
+import { buildZip } from "../../../__test-utils__/zip-fixtures.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────
 
@@ -10,46 +11,6 @@ function makeTempDir(prefix: string): string {
   return mkdtempSync(join(tmpdir(), prefix));
 }
 
-/**
- * Build a minimal stored (method 0) ZIP archive for testing.
- */
-function buildStoredZip(files: { name: string; content: string }[]): Uint8Array {
-  const parts: Uint8Array[] = [];
-
-  for (const file of files) {
-    const nameBytes = new TextEncoder().encode(file.name);
-    const contentBytes = new TextEncoder().encode(file.content);
-    const isDir = file.name.endsWith("/");
-
-    const header = new ArrayBuffer(30);
-    const view = new DataView(header);
-    view.setUint32(0, 0x04034b50, true);
-    view.setUint16(4, 20, true);
-    view.setUint16(6, 0, true);
-    view.setUint16(8, 0, true);
-    view.setUint16(10, 0, true);
-    view.setUint16(12, 0, true);
-    view.setUint32(14, 0, true);
-    view.setUint32(18, isDir ? 0 : contentBytes.length, true);
-    view.setUint32(22, isDir ? 0 : contentBytes.length, true);
-    view.setUint16(26, nameBytes.length, true);
-    view.setUint16(28, 0, true);
-
-    parts.push(new Uint8Array(header));
-    parts.push(nameBytes);
-    if (!isDir) parts.push(contentBytes);
-  }
-
-  const totalLength = parts.reduce((sum, p) => sum + p.length, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const part of parts) {
-    result.set(part, offset);
-    offset += part.length;
-  }
-  return result;
-}
-
 function makeSkillProto(overrides: {
   name?: string;
   slug?: string;
@@ -141,7 +102,7 @@ describe("resolveSkills — artifact extraction", () => {
     const skillMd = "# Garden Design Makeover\n\nSee [references/database-schema.md](references/database-schema.md)";
     const schemaContent = "# Database Schema\n\nTable definitions here.";
 
-    const artifact = buildStoredZip([
+    const artifact = buildZip([
       { name: "SKILL.md", content: skillMd },
       { name: "references/", content: "" },
       { name: "references/database-schema.md", content: schemaContent },
@@ -232,7 +193,7 @@ describe("resolveSkills — artifact extraction", () => {
     const specContent = "# Authoritative SKILL.md from spec";
     const zipContent = "# Stale SKILL.md from ZIP";
 
-    const artifact = buildStoredZip([
+    const artifact = buildZip([
       { name: "SKILL.md", content: zipContent },
       { name: "references/data.md", content: "data" },
     ]);

package/src/activities/execute-cursor/attachment-resolver.ts

@@ -40,6 +40,7 @@ import { mkdir, copyFile, readFile, stat, writeFile } from "node:fs/promises";
 import { join, basename } from "node:path";
 import type { Attachment } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/spec_pb";
 import type { ArtifactStorage } from "../../shared/artifact-storage.js";
+import { mintAttachmentDownloadUrl } from "../../shared/attachment-download-urls.js";
 import { allocateUniqueName } from "../../shared/attachment-naming.js";
 import {
   isVisionCandidate,
@@ -73,6 +74,17 @@ export interface ResolvedAttachment {
    * Attachments that were never image-shaped carry neither field.
    */
   visionDegraded?: VisionDegradedReason;
+  /**
+   * A download URL for the attachment's stored object, listed in the prompt's
+   * `<input_files>` section so the agent can hand the file to a tool whose
+   * backend cannot read the sandbox filesystem (issue #532). Minted whenever
+   * the attachment has a `storageKey` and a usable storage — including on the
+   * localPath fast path when an uploaded copy also exists. Absent when there
+   * is nothing to mint or the mint failed (non-fatal — the policy, the
+   * degrade log, and the prompt wording all live in
+   * shared/attachment-download-urls.ts).
+   */
+  downloadUrl?: string;
 }
 
 export interface AttachmentResolverOptions {
@@ -165,11 +177,18 @@ async function resolveAttachment(
         `${err instanceof Error ? err.message : String(err)}`,
       );
     }
+    // The fast path skips storage for the BYTES, but an uploaded copy (an
+    // attachment carrying both localPath and storageKey) still supports the
+    // URL hand-off — the mint rule is branch-independent.
+    const downloadUrl = await mintAttachmentDownloadUrl(
+      options.storage, attachment.storageKey, filename,
+    );
     return {
       filename,
       relativePath: join(STIGMER_LOCAL_STATE_DIR, INPUTS_SUBDIR, filename),
       ...(renamedFrom !== undefined ? { renamedFrom } : {}),
       ...visionOutcomeFields(vision),
+      ...(downloadUrl !== undefined ? { downloadUrl } : {}),
     };
   }
 
@@ -209,11 +228,16 @@ async function resolveAttachment(
   // no pre-filter needed on this branch).
   const vision = options.visionBudget?.offer(filename, attachment.contentType, content);
 
+  const downloadUrl = await mintAttachmentDownloadUrl(
+    options.storage, attachment.storageKey, filename,
+  );
+
   return {
     filename,
     relativePath: join(STIGMER_LOCAL_STATE_DIR, INPUTS_SUBDIR, filename),
     ...(renamedFrom !== undefined ? { renamedFrom } : {}),
     ...visionOutcomeFields(vision),
+    ...(downloadUrl !== undefined ? { downloadUrl } : {}),
   };
 }
 

package/src/activities/execute-cursor/blueprint-resolver.ts

@@ -14,7 +14,7 @@
 import { resolve } from "node:path";
 import type { StigmerClient } from "../../client/stigmer-client.js";
 import type { Agent } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
-import type { AgentSpec, DatastoreUsage, McpServerUsage, SubAgent } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/spec_pb";
+import type { AgentSpec, McpServerUsage, SubAgent } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/spec_pb";
 import type { Session } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
 import type { SessionSpec } from "@stigmer/protos/ai/stigmer/agentic/session/v1/spec_pb";
 import type { WorkspaceEntry } from "@stigmer/protos/ai/stigmer/agentic/session/v1/workspace_pb";
@@ -46,14 +46,6 @@ export interface ResolvedBlueprint {
   subAgents: SubAgent[];
   mergedMcpServerUsages: McpServerUsage[];
   mergedSkillRefs: ApiResourceReference[];
-  /**
-   * The agent's datastore usages (AgentSpec only — sessions carry no
-   * datastore overlay by design: the usage edge is authorization-bearing
-   * for the server's reach chain, DD-006, so it binds per-blueprint).
-   * Non-empty triggers the synthesized records attachment
-   * (shared/datastore-attachment.ts).
-   */
-  datastoreUsages: DatastoreUsage[];
   workspaceDirs: string[];
   cloudRepos: CloudRepo[];
 }
@@ -98,7 +90,6 @@ export async function resolveBlueprint(
     subAgents: agentSpec.subAgents,
     mergedMcpServerUsages,
     mergedSkillRefs,
-    datastoreUsages: agentSpec.datastoreUsages,
     workspaceDirs,
     cloudRepos,
   };