@stigmer/runner 3.11.1-dev.20260812192248 → 3.12.0

package/src/activities/execute-deep-agent/__tests__/attachment-injector.test.ts

@@ -1014,3 +1014,108 @@ describe("injectAttachments — vision selection", () => {
     expect(injected[1].visionDegraded).toBe("budget_exhausted");
   });
 });
+
+// ═══════════════════════════════════════════════════════════════════════
+// injectAttachments — download-URL hand-off (issue #532)
+// ═══════════════════════════════════════════════════════════════════════
+// The URL is strictly additive (shared/attachment-download-urls.ts): every
+// case also asserts the file injected exactly as it would without one.
+
+describe("injectAttachments — download-URL hand-off", () => {
+  it("mints a URL for a storage-key attachment", async () => {
+    const content = Buffer.from("cloud data");
+    const storage = makeMockStorage();
+    await storage.upload("attachments/xyz/data.csv", content);
+    const backend = mockWorkspaceBackend();
+
+    const result = await injectAttachments({
+      backend,
+      attachments: [makeAttachment({ filename: "data.csv", storageKey: "attachments/xyz/data.csv" })],
+      storage,
+      isLocalMode: false,
+    });
+
+    expect(result[0]).toMatchObject({
+      path: ".stigmer/inputs/data.csv",
+      downloadUrl: "mem://attachments/xyz/data.csv",
+    });
+  });
+
+  it("mints a URL for an explicit-mountPath attachment (the rule ignores mount location)", async () => {
+    const storage = makeMockStorage();
+    await storage.upload("attachments/xyz/config.yaml", Buffer.from("a: 1"));
+    const backend = mockWorkspaceBackend();
+
+    const result = await injectAttachments({
+      backend,
+      attachments: [makeAttachment({
+        filename: "config.yaml",
+        storageKey: "attachments/xyz/config.yaml",
+        mountPath: "config/app.yaml",
+      })],
+      storage,
+      isLocalMode: false,
+    });
+
+    expect(result[0]).toMatchObject({
+      path: "config/app.yaml",
+      downloadUrl: "mem://attachments/xyz/config.yaml",
+    });
+  });
+
+  it("carries no URL on extracted ZIP entries — the stored object is the ZIP, not any listed file", async () => {
+    const zip = makeZip({ "src/a.txt": "alpha", "src/b.txt": "beta" });
+    const storage = makeMockStorage();
+    await storage.upload("attachments/xyz/code.zip", zip);
+    const backend = mockWorkspaceBackend();
+
+    const result = await injectAttachments({
+      backend,
+      attachments: [makeAttachment({
+        filename: "code.zip",
+        storageKey: "attachments/xyz/code.zip",
+        extract: true,
+      })],
+      storage,
+      isLocalMode: false,
+    });
+
+    expect(result.length).toBeGreaterThan(0);
+    for (const file of result) {
+      expect(file.downloadUrl).toBeUndefined();
+    }
+  });
+
+  it("carries no URL for a key-less local file", async () => {
+    const localFile = join(tmpdir(), `injector-url-${Date.now()}.txt`);
+    await writeFile(localFile, "local only");
+    const backend = mockWorkspaceBackend();
+
+    const result = await injectAttachments({
+      backend,
+      attachments: [makeAttachment({ filename: "local.txt", storageKey: "", localPath: localFile })],
+      storage: makeMockStorage(),
+      isLocalMode: true,
+    });
+
+    expect(result[0].downloadUrl).toBeUndefined();
+  });
+
+  it("degrades to no URL when the mint fails — file still injected, no throw", async () => {
+    const content = Buffer.from("cloud data");
+    const storage = makeMockStorage();
+    await storage.upload("attachments/xyz/data.csv", content);
+    storage.getDownloadUrl.mockRejectedValueOnce(new Error("presign endpoint unreachable"));
+    const backend = mockWorkspaceBackend();
+
+    const result = await injectAttachments({
+      backend,
+      attachments: [makeAttachment({ filename: "data.csv", storageKey: "attachments/xyz/data.csv" })],
+      storage,
+      isLocalMode: false,
+    });
+
+    expect(result[0].downloadUrl).toBeUndefined();
+    expect(backend.writeFileBuffer).toHaveBeenCalledWith(".stigmer/inputs/data.csv", content);
+  });
+});

package/src/activities/execute-deep-agent/__tests__/hitl-reject.test.ts

@@ -184,7 +184,6 @@ function fakeHttpRejectSetup(): SetupResult {
     session: { spec: { workspaceEntries: [] } },
     workspaceBackend: { rootDir: "/tmp/stigmer-test-ws-reject-http" },
     mcpConnection: null,
-    datastoreToolsMissing: [],
     mergedEnvVars: {},
     secretKeys: new Set<string>(),
     modelName: "claude-sonnet",
@@ -220,7 +219,6 @@ function fakeMemoryRejectSetup(): SetupResult {
     session: { spec: { workspaceEntries: [] } },
     workspaceBackend: { rootDir: "/tmp/stigmer-test-ws-reject-mem" },
     mcpConnection: null,
-    datastoreToolsMissing: [],
     mergedEnvVars: {},
     secretKeys: new Set<string>(),
     modelName: "claude-sonnet",

package/src/activities/execute-deep-agent/__tests__/hitl-resume-approve-all.test.ts

@@ -264,7 +264,6 @@ function fakeDurableResumeSetup(): SetupResult {
     // path shared across files would serialize parallel test workers for real.
     workspaceBackend: { rootDir: "/tmp/stigmer-test-ws-hitl-approve-all" },
     mcpConnection: null,
-    datastoreToolsMissing: [],
     mergedEnvVars: {},
     secretKeys: new Set<string>(),
     modelName: "claude-sonnet",

package/src/activities/execute-deep-agent/__tests__/hitl-resume-history.test.ts

@@ -219,7 +219,6 @@ function fakeDurableResumeSetup(): SetupResult {
     // path shared across files would serialize parallel test workers for real.
     workspaceBackend: { rootDir: "/tmp/stigmer-test-ws-hitl-history" },
     mcpConnection: null,
-    datastoreToolsMissing: [],
     mergedEnvVars: {},
     secretKeys: new Set<string>(),
     modelName: "claude-sonnet",

package/src/activities/execute-deep-agent/__tests__/mcp-gate.test.ts

@@ -12,7 +12,6 @@ import { shouldConnectMcp } from "../mcp-gate.js";
 
 const nothing = {
   mcpServerUsageCount: 0,
-  datastoreUsageCount: 0,
   channelMessagingCount: 0,
   conversationChannelId: undefined,
 };
@@ -26,17 +25,13 @@ describe("shouldConnectMcp", () => {
     expect(shouldConnectMcp({ ...nothing, mcpServerUsageCount: 1 })).toBe(true);
   });
 
-  it("enters on datastore usages alone (the records attachment)", () => {
-    expect(shouldConnectMcp({ ...nothing, datastoreUsageCount: 1 })).toBe(true);
-  });
-
   it("enters on a serving proactive channel alone (the channels attachment)", () => {
     expect(shouldConnectMcp({ ...nothing, channelMessagingCount: 1 })).toBe(true);
   });
 
   it("enters on a channel conversation alone (the conversation attachment)", () => {
-    // The reply-only pilot shape: no declared servers, no datastores,
-    // no proactive channel — the escalation tool is the ONLY source.
+    // The reply-only pilot shape: no declared servers, no proactive
+    // channel — the escalation tool is the ONLY source.
     expect(shouldConnectMcp({ ...nothing, conversationChannelId: "agch_1" })).toBe(true);
   });
 });

package/src/activities/execute-deep-agent/__tests__/prompt-builder.test.ts

@@ -190,6 +190,77 @@ describe("buildEnhancedSystemPrompt", () => {
     expect(prompt).toContain("`.stigmer/inputs/report.pdf` (10 bytes)\n");
   });
 
+  it("lists a minted download URL beside its file with the presigned hand-off line (issue #532)", () => {
+    const prompt = buildEnhancedSystemPrompt({
+      instructions: "Test",
+      provisionResults: [],
+      containerRoot: "",
+      skillsPromptSection: "",
+      workspaceFileRefs: [],
+      workspaceRoot: "/workspace",
+      injectedFiles: [
+        {
+          filename: "lease.pdf",
+          path: ".stigmer/inputs/lease.pdf",
+          sizeBytes: 2048,
+          downloadUrl: "https://r2.example/lease?sig=abc",
+        },
+        { filename: "notes.md", path: ".stigmer/inputs/notes.md", sizeBytes: 12 },
+      ],
+      downloadUrlKind: "presigned",
+    });
+
+    expect(prompt).toContain(
+      "`.stigmer/inputs/lease.pdf` (2048 bytes) — download URL: https://r2.example/lease?sig=abc",
+    );
+    // The URL-less file keeps a clean entry.
+    expect(prompt).toContain("`.stigmer/inputs/notes.md` (12 bytes)\n");
+    expect(prompt).toContain("These URLs are time-limited");
+  });
+
+  it("words a local-serve URL honestly — reachable only from this machine", () => {
+    const prompt = buildEnhancedSystemPrompt({
+      instructions: "Test",
+      provisionResults: [],
+      containerRoot: "",
+      skillsPromptSection: "",
+      workspaceFileRefs: [],
+      workspaceRoot: "/workspace",
+      injectedFiles: [
+        {
+          filename: "lease.pdf",
+          path: ".stigmer/inputs/lease.pdf",
+          sizeBytes: 2048,
+          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 = buildEnhancedSystemPrompt({
+      instructions: "Test",
+      provisionResults: [],
+      containerRoot: "",
+      skillsPromptSection: "",
+      workspaceFileRefs: [],
+      workspaceRoot: "/workspace",
+      injectedFiles: [
+        { filename: "local.csv", path: ".stigmer/inputs/local.csv", sizeBytes: 5 },
+      ],
+      downloadUrlKind: "presigned",
+    });
+
+    expect(prompt).toContain("## Input Files");
+    expect(prompt).not.toContain("download URL");
+    expect(prompt).not.toContain("time-limited");
+  });
+
   it("produces a git repo description for git workspace entries", () => {
     const prompt = buildEnhancedSystemPrompt({
       instructions: "Test",

package/src/activities/execute-deep-agent/__tests__/sequential-gate-resume.test.ts

@@ -196,7 +196,6 @@ function fakeMemoryGateSetup(opts: {
       readFile: vi.fn(async () => ""),
     },
     mcpConnection: null,
-    datastoreToolsMissing: [],
     mergedEnvVars: {},
     secretKeys: new Set<string>(),
     modelName: "claude-sonnet",

package/src/activities/execute-deep-agent/attachment-injector.ts

@@ -27,6 +27,7 @@ import { posix } from "node:path";
 import type { Attachment } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/spec_pb";
 import type { WorkspaceBackend } from "../../shared/workspace/types.js";
 import type { ArtifactStorage } from "../../shared/artifact-storage.js";
+import { mintAttachmentDownloadUrl } from "../../shared/attachment-download-urls.js";
 import { allocateUniqueName } from "../../shared/attachment-naming.js";
 import type {
   VisionBudget,
@@ -66,6 +67,17 @@ export interface InjectedFile {
    * Attachments that were never image-shaped carry neither field.
    */
   readonly visionDegraded?: VisionDegradedReason;
+  /**
+   * A download URL for the attachment's stored object, listed in the system
+   * 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; never
+   * present on extracted ZIP entries (no attachment-level object). Absent
+   * when there is nothing to mint or the mint failed (non-fatal — policy,
+   * degrade log, and prompt wording live in
+   * shared/attachment-download-urls.ts).
+   */
+  readonly downloadUrl?: string;
 }
 
 export interface InjectAttachmentsOptions {
@@ -300,7 +312,10 @@ export async function injectAttachments(opts: InjectAttachmentsOptions): Promise
       );
       // A renamed mount DIR is visible through every extracted path; the
       // entries themselves were not renamed, so they carry no renamedFrom
-      // (per-file disclosure would misattribute the rename).
+      // (per-file disclosure would misattribute the rename). Extracted
+      // entries also carry no downloadUrl: the stored object is the ZIP, not
+      // any listed file, and a URL to bytes that differ from the listing
+      // would be a false promise.
       injectedFiles.push(...extracted);
     } else {
       await backend.writeFileBuffer(mountPath, content);
@@ -313,6 +328,9 @@ export async function injectAttachments(opts: InjectAttachmentsOptions): Promise
       // the vision budget before they go out of scope (the sniff decides
       // eligibility; the budget owns every size/count rule).
       const vision = visionBudget?.offer(filename, attachment.contentType, content);
+      const downloadUrl = await mintAttachmentDownloadUrl(
+        storage, attachment.storageKey, filename,
+      );
       injectedFiles.push({
         filename,
         path: mountPath,
@@ -320,6 +338,7 @@ export async function injectAttachments(opts: InjectAttachmentsOptions): Promise
         ...(renamedFrom !== undefined ? { renamedFrom } : {}),
         ...(vision?.kind === "accepted" ? { vision: vision.image } : {}),
         ...(vision?.kind === "degraded" ? { visionDegraded: vision.reason } : {}),
+        ...(downloadUrl !== undefined ? { downloadUrl } : {}),
       });
     }
   }

package/src/activities/execute-deep-agent/index.ts

@@ -32,7 +32,6 @@ import {
 } from "../../shared/workspace/stigmer-link.js";
 import type { ToolOutputOffloadContext } from "../../shared/status-offload.js";
 import { publishPlanArtifact } from "../../shared/plan-artifact.js";
-import { formatDatastoreDegradationNotice } from "../../shared/datastore-attachment.js";
 import { classifyTool } from "../../shared/tool-kind.js";
 import {
   POLICY_ENGINE_VERSION,
@@ -153,24 +152,6 @@ export function createDeepAgentActivities(config: Config) {
           ? seedStatusFromExecution(setup.execution)
           : create(AgentExecutionStatusSchema, {});
 
-        // Datastore degradation disclosure, operator half (issue #325): the
-        // prompt already tells the agent to disclose the outage; this makes
-        // it visible on the execution record without reading a transcript.
-        // Appended to initialStatus BEFORE streaming (not via a status
-        // builder): both the v2 and v3 stream paths construct their own
-        // builder around this same proto and only ever append messages, so
-        // this row survives whichever path runs and rides every persist.
-        if (setup.datastoreToolsMissing.length > 0) {
-          initialStatus.messages.push(create(AgentMessageSchema, {
-            type: MessageType.MESSAGE_SYSTEM,
-            content: formatDatastoreDegradationNotice(
-              setup.agent.spec?.datastoreUsages?.length ?? 0,
-              setup.datastoreToolsMissing,
-            ),
-            timestamp: utcTimestamp(),
-          }));
-        }
-
         const statusBuilder = new StatusBuilder(executionId, initialStatus);
 
         statusBuilder.setApprovalProvider({

package/src/activities/execute-deep-agent/mcp-gate.ts

@@ -17,8 +17,6 @@
 export interface McpToolSources {
   /** Declared MCP server usages (agent spec + session spec). */
   readonly mcpServerUsageCount: number;
-  /** Declared datastore usages (the records attachment, T05). */
-  readonly datastoreUsageCount: number;
   /** Serving proactive-messaging channels (the channels attachment, DD-006). */
   readonly channelMessagingCount: number;
   /** The serving channel id when this session IS a live channel
@@ -30,7 +28,6 @@ export interface McpToolSources {
 export function shouldConnectMcp(sources: McpToolSources): boolean {
   return (
     sources.mcpServerUsageCount > 0 ||
-    sources.datastoreUsageCount > 0 ||
     sources.channelMessagingCount > 0 ||
     sources.conversationChannelId !== undefined
   );

package/src/activities/execute-deep-agent/prompt-builder.ts

@@ -21,6 +21,10 @@ import {
   visionDisclosureLines,
   type NotViewableEntry,
 } from "../../shared/attachment-vision.js";
+import {
+  downloadUrlDisclosureLine,
+  type DownloadUrlKind,
+} from "../../shared/attachment-download-urls.js";
 import { PLAN_MODE_DIRECTIVE } from "../../shared/plan-mode-prompt.js";
 import {
   buildImplementPlanDirective,
@@ -99,14 +103,6 @@ export interface PromptBuilderInput {
   provisionResults: ProvisionResult[];
   containerRoot: string;
   skillsPromptSection: string;
-  /**
-   * The datastores section (shared/datastore-attachment.ts
-   * formatDatastoresSection): `<available_datastores>` when the connected
-   * record-tool roster is complete, `<unavailable_datastores>` when setup's
-   * reconciliation found record tools missing (issue #325). Empty when the
-   * agent uses no datastores.
-   */
-  datastoresPromptSection?: string;
   /**
    * The `<available_channel_templates>` section
    * (shared/channel-attachment.ts formatChannelTemplatesSection); absent
@@ -122,6 +118,12 @@ export interface PromptBuilderInput {
    * Rendered inside the Input Files section.
    */
   vision?: VisionPromptInfo;
+  /**
+   * What kind of URL the turn's storage backend mints (issue #532) — keys
+   * the Input Files section's hand-off wording (attachment-download-urls.ts).
+   * One turn-level fact: all attachments ride the one configured storage.
+   */
+  downloadUrlKind?: DownloadUrlKind;
   /**
    * The execution's interaction mode. PLAN appends the shared plan-mode
    * directive so the model knows the turn's deliverable is a plan document.
@@ -201,10 +203,6 @@ export function buildEnhancedSystemPrompt(input: PromptBuilderInput): string {
     prompt += input.skillsPromptSection;
   }
 
-  if (input.datastoresPromptSection) {
-    prompt += "\n\n" + input.datastoresPromptSection;
-  }
-
   if (input.channelTemplatesPromptSection) {
     prompt += "\n\n" + input.channelTemplatesPromptSection;
   }
@@ -220,7 +218,9 @@ export function buildEnhancedSystemPrompt(input: PromptBuilderInput): string {
   }
 
   if (input.injectedFiles.length > 0) {
-    prompt += buildInjectedFilesSection(input.injectedFiles, input.vision);
+    prompt += buildInjectedFilesSection(
+      input.injectedFiles, input.vision, input.downloadUrlKind,
+    );
   }
 
   if (input.senderIdentity) {
@@ -401,6 +401,7 @@ function buildReferencedFilesSection(
 function buildInjectedFilesSection(
   files: readonly InjectedFile[],
   vision?: VisionPromptInfo,
+  downloadUrlKind?: DownloadUrlKind,
 ): string {
   let section = "\n\n## Input Files\n\n";
   section +=
@@ -416,12 +417,23 @@ function buildInjectedFilesSection(
     const sizeInfo = ` (${f.sizeBytes} bytes)`;
     // A duplicate-renamed file (attachment-naming.ts) discloses its original
     // name so the agent can connect "the two report.pdfs" in the user's
-    // message to distinct files on disk.
+    // message to distinct files on disk. A file with a minted download URL
+    // (attachment-download-urls.ts) lists it beside the path for the remote
+    // hand-off story.
     const renameInfo =
       f.renamedFrom !== undefined
         ? ` (renamed from duplicate '${f.renamedFrom}')`
         : "";
-    section += `- \`${f.path}\`${sizeInfo}${renameInfo}\n`;
+    const urlInfo =
+      f.downloadUrl !== undefined ? ` — download URL: ${f.downloadUrl}` : "";
+    section += `- \`${f.path}\`${sizeInfo}${renameInfo}${urlInfo}\n`;
+  }
+
+  // The URL hand-off line (shared wording, attachment-download-urls.ts)
+  // renders only when some listed file actually carries a URL — its wording
+  // keys on what kind of URL the storage backend mints.
+  if (downloadUrlKind !== undefined && files.some((f) => f.downloadUrl !== undefined)) {
+    section += "\n" + downloadUrlDisclosureLine(downloadUrlKind) + "\n";
   }
 
   // The vision lines (shared wording, attachment-vision.ts) tell the model

package/src/activities/execute-deep-agent/setup.ts

@@ -36,12 +36,6 @@ import { connectMcpServers, type McpConnectionResult } from "../../shared/mcp-ma
 import { mergeMcpServerUsages, resolveMcpServers } from "../../shared/mcp-resolver.js";
 import { resolveMcpTransportPosture } from "../../shared/mcp-transport-guard.js";
 import { backfillMcpServersIfNeeded } from "../../shared/connect-backfill.js";
-import {
-  DATASTORE_ATTACHMENT_SLUG,
-  formatDatastoresSection,
-  missingRecordTools,
-  synthesizeDatastoreAttachment,
-} from "../../shared/datastore-attachment.js";
 import {
   discoverChannelMessaging,
   formatChannelTemplatesSection,
@@ -129,16 +123,6 @@ export interface SetupResult {
   readonly session: Session;
   readonly workspaceBackend: WorkspaceBackend;
   readonly mcpConnection: McpConnectionResult | null;
-  /**
-   * Record tools declared via datastore_usages but absent from the connected
-   * stigmer-records roster this turn (issue #325). Empty = healthy (also when
-   * the agent uses no datastores). Non-empty selects the degraded prompt
-   * section in Step 8, and the activity surfaces it to operators as a
-   * MESSAGE_SYSTEM row — the vision-facts pattern: setup computes the honest
-   * struct, the caller discloses. Recomputed every turn, so a healed outage
-   * stops disclosing on the next turn.
-   */
-  readonly datastoreToolsMissing: readonly string[];
   readonly mergedEnvVars: Record<string, string>;
   readonly secretKeys: ReadonlySet<string>;
   readonly modelName: string;
@@ -369,7 +353,6 @@ export async function performSetup(deps: SetupDependencies): Promise<SetupResult
       agent.spec!.mcpServerUsages || [],
       session.spec!.mcpServerUsages || [],
     );
-    const datastoreUsages = agent.spec!.datastoreUsages || [];
 
     // The synthesized attachments' credential story (DD-006 D4): the
     // exchanged token authenticates the discovery reads per-call (the
@@ -410,7 +393,6 @@ export async function performSetup(deps: SetupDependencies): Promise<SetupResult
     let resolvedMcpServers: Awaited<ReturnType<typeof resolveMcpServers>> | null = null;
     if (shouldConnectMcp({
       mcpServerUsageCount: mcpServerUsages.length,
-      datastoreUsageCount: datastoreUsages.length,
       channelMessagingCount: channelMessaging.length,
       conversationChannelId,
     })) {
@@ -444,25 +426,9 @@ export async function performSetup(deps: SetupDependencies): Promise<SetupResult
         envResult.secretKeys,
       );
 
-      // The datastore records attachment (T05) — injected AFTER resolve +
-      // backfill so the destructiveHint tightener can never gate it; empty
-      // approval maps keep it approval-free by construction (see
-      // shared/datastore-attachment.ts).
-      if (datastoreUsages.length > 0) {
-        const attachment = synthesizeDatastoreAttachment(datastoreUsages, {
-          bridgeEndpoint: config.mcpBridgeEndpoint,
-          credential: attachmentCredential,
-          backendEndpoint: config.stigmerBackendEndpoint,
-        });
-        if (attachment) {
-          backfilledServers = injectSynthesizedAttachment(
-            backfilledServers, attachment, "datastore records",
-          );
-        }
-      }
-
-      // The channel messaging attachment (DD-006 D7/D8) — the records
-      // attachment's twin, injected under the same after-backfill rule.
+      // The channel messaging attachment (DD-006 D7/D8) — injected AFTER
+      // resolve + backfill so the destructiveHint tightener can never gate
+      // it; empty approval maps keep it approval-free by construction.
       if (channelMessaging.length > 0) {
         const attachment = synthesizeChannelAttachment(channelMessaging, {
           bridgeEndpoint: config.mcpBridgeEndpoint,
@@ -477,8 +443,8 @@ export async function performSetup(deps: SetupDependencies): Promise<SetupResult
       }
 
       // The conversation participation attachment (DD-008 D-c) — the
-      // third sibling, same after-backfill rule. HTTP-only: synthesize
-      // answers undefined with no bridge endpoint by design (see
+      // channel attachment's sibling, same after-backfill rule. HTTP-only:
+      // synthesize answers undefined with no bridge endpoint by design (see
       // shared/conversation-attachment.ts).
       const conversationAttachment = synthesizeConversationAttachment(conversationChannelId, {
         bridgeEndpoint: config.mcpBridgeEndpoint,
@@ -585,37 +551,12 @@ export async function performSetup(deps: SetupDependencies): Promise<SetupResult
     }
     timing.mark("inject_attachments");
 
-    // Reconcile the declared datastores against the record tools actually
-    // connected (issue #325): the records roster always serves all five
-    // tools, so any absence means the store is degraded, and the prompt
-    // must say so instead of promising tools the agent does not have. The
-    // connected roster is post-connect truth — when usages exist, MCP
-    // connect always ran above (a thrown connect already failed the run).
-    const datastoreToolsMissing = datastoreUsages.length > 0 && mcpConnection
-      ? missingRecordTools(
-          (mcpConnection.serverToolMap[DATASTORE_ATTACHMENT_SLUG] ?? [])
-            .map((t) => t.name),
-        )
-      : [];
-    if (datastoreToolsMissing.length > 0) {
-      console.warn(
-        `[setup] Datastore record tools degraded: declared ` +
-        `${datastoreUsages.length} datastore usage(s) but the ` +
-        `'${DATASTORE_ATTACHMENT_SLUG}' roster is missing ` +
-        `[${datastoreToolsMissing.join(", ")}] — the prompt discloses the ` +
-        `outage instead of the available-datastores section.`,
-      );
-    }
-
     // Step 8: Build enhanced system prompt
     const systemPrompt = buildEnhancedSystemPrompt({
       instructions,
       provisionResults,
       containerRoot: workspaceBackend.rootDir,
       skillsPromptSection,
-      datastoresPromptSection: datastoreUsages.length > 0
-        ? formatDatastoresSection(datastoreUsages, datastoreToolsMissing)
-        : undefined,
       // "" (nothing sendable) threads as undefined: the tool alone still
       // serves text sends inside a 24-hour window (DD-006 D6).
       channelTemplatesPromptSection: channelMessaging.length > 0
@@ -625,6 +566,7 @@ export async function performSetup(deps: SetupDependencies): Promise<SetupResult
       workspaceRoot: workspaceBackend.rootDir,
       injectedFiles,
       vision: visionPromptInfo,
+      downloadUrlKind: artifactStorage?.downloadUrlKind,
       interactionMode: execution.spec!.executionConfig?.interactionMode,
       buildFromPlan: execution.spec!.executionConfig?.buildFromPlan,
       contextBridge: readContextBridge(session.spec!.metadata),
@@ -936,7 +878,6 @@ export async function performSetup(deps: SetupDependencies): Promise<SetupResult
       session,
       workspaceBackend,
       mcpConnection,
-      datastoreToolsMissing,
       mergedEnvVars: envResult.mergedEnvVars,
       secretKeys: envResult.secretKeys,
       modelName,

package/src/config.ts

@@ -61,11 +61,12 @@ export interface Config {
   readonly stigmerBackendEndpoint: string;
   readonly stigmerToken: string | null;
   /**
-   * The MCP bridge endpoint for the runner-synthesized datastore
-   * records attachment (STIGMER_MCP_BRIDGE_ENDPOINT, e.g.
-   * https://mcp.stigmer.ai). Null selects the OSS/local shape: a
-   * spawned `stigmer mcp-server` stdio child against the local backend.
-   * See shared/datastore-attachment.ts.
+   * The MCP bridge endpoint for the runner-synthesized attachments —
+   * channel messaging and conversation participation
+   * (STIGMER_MCP_BRIDGE_ENDPOINT, e.g. https://mcp.stigmer.ai). Null
+   * selects the OSS/local shape: a spawned `stigmer mcp-server` stdio
+   * child against the local backend. See shared/channel-attachment.ts
+   * and shared/conversation-attachment.ts.
    */
   readonly mcpBridgeEndpoint: string | null;
   /**

package/src/shared/__tests__/artifact-storage.test.ts

@@ -49,6 +49,10 @@ describe("LocalArtifactStorage", () => {
     expect(url).toBe("http://localhost:7235/artifacts/file.txt");
   });
 
+  it("self-describes its URLs as local-serve (loopback reach, no expiry — issue #532)", () => {
+    expect(storage.downloadUrlKind).toBe("local-serve");
+  });
+
   it("returns true for existing keys", async () => {
     const key = "artifacts/exec-1/file.bin";
     await storage.upload(key, Buffer.from("data"));
@@ -167,6 +171,11 @@ describe("ProxyArtifactStorage", () => {
     globalThis.fetch = originalFetch;
   });
 
+  it("self-describes its URLs as presigned (time-limited, remotely fetchable — issue #532)", () => {
+    const s = new ProxyArtifactStorage("https://proxy.example.com", "tok");
+    expect(s.downloadUrlKind).toBe("presigned");
+  });
+
   it("uploads via presigned URL flow", async () => {
     const calls: { url: string; method: string; body?: string }[] = [];