Late-bind a blob writer for nested tool-result truncation

Nested tools wrap before the child session store exists. Live getters
bind the writer after createSessionStores so oversized fleet and web
results spill to a fetchable tool-output URI instead of a no-store
notice.

Author: TheGreatAxios

src/plugins/result-truncation-plugin.test.ts

@@ -12,6 +12,8 @@ import {
   spillBlobKey,
   truncateToolResultContent,
   wrapAgentToolResultTruncation,
+  wrapAgentToolsWithResultTruncation,
+  type SpillBlobWriter,
 } from "./result-truncation-plugin.js";
 import { toolOutputAbsolutePath } from "./tool-result-materialize.js";
 import { CREDENTIAL_REDACTION } from "./tool-result-secret-scrub.js";
@@ -387,7 +389,9 @@ describe("resultTruncationPlugin", () => {
     const minified = JSON.stringify(obj);
     expect(minified.length).toBeGreaterThan(MAX_RESULT_CHARS);
     const pretty = JSON.stringify(obj, null, 2);
-    const plugin = resultTruncationPlugin({ getBlobWriter: () => store.writeBlob });
+    const plugin = resultTruncationPlugin({
+      getBlobWriter: () => store.writeBlob,
+    });
     if (plugin.middleware === undefined) throw new Error("expected middleware");
     const middleware = plugin.middleware(async (call) => ({
       callId: call.id,
@@ -401,10 +405,14 @@ describe("resultTruncationPlugin", () => {
         new AbortController().signal,
       );
       expect(typeof result.content).toBe("string");
-      expect(String(result.content).length).toBeLessThanOrEqual(MAX_RESULT_CHARS);
+      expect(String(result.content).length).toBeLessThanOrEqual(
+        MAX_RESULT_CHARS,
+      );
       const uri = `tool-output:///${spillBlobKey(callId)}`;
       expect(String(result.content)).toContain(uri);
-      const recovered = new TextDecoder().decode(await createBlobReader(store).read(uri));
+      const recovered = new TextDecoder().decode(
+        await createBlobReader(store).read(uri),
+      );
       expect(recovered).toBe(pretty);
     }
   });
@@ -413,7 +421,9 @@ describe("resultTruncationPlugin", () => {
     const store = fakeBlobStore();
     const original = `Matching agent profiles:\n\n${"body ".repeat(MAX_RESULT_CHARS)}`;
     expect(original.length).toBeGreaterThan(MAX_RESULT_CHARS);
-    const plugin = resultTruncationPlugin({ getBlobWriter: () => store.writeBlob });
+    const plugin = resultTruncationPlugin({
+      getBlobWriter: () => store.writeBlob,
+    });
     if (plugin.middleware === undefined) throw new Error("expected middleware");
     const middleware = plugin.middleware(async (call) => ({
       callId: call.id,
@@ -426,14 +436,18 @@ describe("resultTruncationPlugin", () => {
     expect(String(result.content).length).toBeLessThanOrEqual(MAX_RESULT_CHARS);
     const uri = `tool-output:///${spillBlobKey("call-search")}`;
     expect(String(result.content)).toContain(uri);
-    const recovered = new TextDecoder().decode(await createBlobReader(store).read(uri));
+    const recovered = new TextDecoder().decode(
+      await createBlobReader(store).read(uri),
+    );
     expect(recovered).toBe(original);
   });
 
   test("does not truncate isError results even when over the gate", async () => {
     const store = fakeBlobStore();
     const original = `Error: ${"x".repeat(MAX_RESULT_CHARS + 500)}`;
-    const plugin = resultTruncationPlugin({ getBlobWriter: () => store.writeBlob });
+    const plugin = resultTruncationPlugin({
+      getBlobWriter: () => store.writeBlob,
+    });
     if (plugin.middleware === undefined) throw new Error("expected middleware");
     const middleware = plugin.middleware(async (call) => ({
       callId: call.id,
@@ -453,7 +467,9 @@ describe("resultTruncationPlugin", () => {
 describe("wrapAgentToolResultTruncation", () => {
   test("spills oversized wait_agents JSON from a kind:full handler", async () => {
     const store = fakeBlobStore();
-    const payload = { results: [{ report: "x".repeat(MAX_RESULT_CHARS + 500) }] };
+    const payload = {
+      results: [{ report: "x".repeat(MAX_RESULT_CHARS + 500) }],
+    };
     const minified = JSON.stringify(payload);
     expect(minified.length).toBeGreaterThan(MAX_RESULT_CHARS);
     const pretty = JSON.stringify(payload, null, 2);
@@ -477,7 +493,9 @@ describe("wrapAgentToolResultTruncation", () => {
     expect(String(result.content).length).toBeLessThanOrEqual(MAX_RESULT_CHARS);
     const uri = `tool-output:///${spillBlobKey("call-wrap-wait")}`;
     expect(String(result.content)).toContain(uri);
-    const recovered = new TextDecoder().decode(await createBlobReader(store).read(uri));
+    const recovered = new TextDecoder().decode(
+      await createBlobReader(store).read(uri),
+    );
     expect(recovered).toBe(pretty);
   });
 
@@ -496,15 +514,18 @@ describe("wrapAgentToolResultTruncation", () => {
       },
       { getBlobWriter: () => store.writeBlob },
     );
-    if (wrapped.kind !== "full") throw new Error("expected full wrapper so spill can use callId");
+    if (wrapped.kind !== "full")
+      throw new Error("expected full wrapper so spill can use callId");
     const result = await wrapped.handler(
       { id: "call-wrap-search", name: "search_agents", arguments: {} },
       new AbortController().signal,
     );
     expect(String(result.content).length).toBeLessThanOrEqual(MAX_RESULT_CHARS);
     const uri = `tool-output:///${spillBlobKey("call-wrap-search")}`;
     expect(String(result.content)).toContain(uri);
-    const recovered = new TextDecoder().decode(await createBlobReader(store).read(uri));
+    const recovered = new TextDecoder().decode(
+      await createBlobReader(store).read(uri),
+    );
     expect(recovered).toBe(original);
   });
 
@@ -519,7 +540,11 @@ describe("wrapAgentToolResultTruncation", () => {
           description: "wait",
           inputSchema: { type: "object" },
         },
-        handler: async (call) => ({ callId: call.id, content: original, isError: true }),
+        handler: async (call) => ({
+          callId: call.id,
+          content: original,
+          isError: true,
+        }),
       },
       { getBlobWriter: () => store.writeBlob },
     );
@@ -534,6 +559,58 @@ describe("wrapAgentToolResultTruncation", () => {
   });
 });
 
+describe("wrapAgentToolsWithResultTruncation", () => {
+  test("late-binds a blob writer after wrap so oversized wait_agents JSON spills to a readable URI", async () => {
+    const payload = {
+      results: [{ report: "n".repeat(MAX_RESULT_CHARS + 500) }],
+    };
+    const minified = JSON.stringify(payload);
+    expect(minified.length).toBeGreaterThan(MAX_RESULT_CHARS);
+    const pretty = JSON.stringify(payload, null, 2);
+
+    const childSpill: { writer?: SpillBlobWriter } = {};
+    const [wrapped] = wrapAgentToolsWithResultTruncation(
+      [
+        {
+          kind: "full",
+          definition: {
+            name: "wait_agents",
+            description: "wait",
+            inputSchema: { type: "object" },
+          },
+          handler: async (call) => ({ callId: call.id, content: minified }),
+        },
+      ],
+      { getBlobWriter: () => childSpill.writer },
+    );
+    if (wrapped === undefined || wrapped.kind !== "full") {
+      throw new Error("expected full wrapped tool");
+    }
+
+    const before = await wrapped.handler(
+      { id: "call-nested-before", name: "wait_agents", arguments: {} },
+      new AbortController().signal,
+    );
+    expect(String(before.content)).toContain("NOT retrievable");
+    expect(String(before.content)).not.toContain("tool-output:///");
+
+    const store = fakeBlobStore();
+    childSpill.writer = store.writeBlob;
+    const result = await wrapped.handler(
+      { id: "call-nested-wait", name: "wait_agents", arguments: {} },
+      new AbortController().signal,
+    );
+    expect(String(result.content).length).toBeLessThanOrEqual(MAX_RESULT_CHARS);
+    expect(String(result.content)).not.toContain("NOT retrievable");
+    const uri = `tool-output:///${spillBlobKey("call-nested-wait")}`;
+    expect(String(result.content)).toContain(uri);
+    const recovered = new TextDecoder().decode(
+      await createBlobReader(store).read(uri),
+    );
+    expect(recovered).toBe(pretty);
+  });
+});
+
 describe("scrub-before-spill", () => {
   test("secret scrub runs on the full content before truncation spills", async () => {
     const store = fakeBlobStore();

src/subagent/run.ts

@@ -49,7 +49,10 @@ import { advertiseEditFileLineRange } from "../plugins/edit-file-line-range.js";
 import { createWebFetchTool } from "../tools/web-fetch.js";
 import { createWebSearchTool } from "../tools/web-search.js";
 import { buildCorePosixToolPlugins } from "../agent/posix-tool-plugins.js";
-import { wrapAgentToolsWithResultTruncation } from "../plugins/result-truncation-plugin.js";
+import {
+  wrapAgentToolsWithResultTruncation,
+  type SpillBlobWriter,
+} from "../plugins/result-truncation-plugin.js";
 import {
   allowDeleteFromCapabilities,
   allowShellFromCapabilities,
@@ -518,7 +521,11 @@ async function runSubAgentInner(
   // Child tools resolve spills against the child's own store first, then
   // the parent's: parent tool-output:// URIs handed in the brief must
   // remain readable after spawn, and the child's own spills stay local.
+  // Writer/context dir bind after createSessionStores — tools wrap first,
+  // same late-bind as primary getBlobWriter.
   let childBlobReader: BlobReader | undefined;
+  let childBlobWriter: SpillBlobWriter | undefined;
+  let childContextDir: string | undefined;
   const sessionBlobReader = createCompositeBlobReader(
     () => childBlobReader,
     params.getBlobReader,
@@ -535,6 +542,8 @@ async function runSubAgentInner(
       ...(params.shellEnv !== undefined ? { shellEnv: params.shellEnv } : {}),
       readFileGuard: { blobReader: sessionBlobReader },
       getBackgroundShellRegistry: () => backgroundShells,
+      getBlobWriter: () => childBlobWriter,
+      getContextDir: () => childContextDir,
       extraToolPlugins: [
         ...(params.extraToolPlugins ?? []),
         spawnRegistry.plugin,
@@ -843,7 +852,10 @@ async function runSubAgentInner(
       ];
     }
 
-    tools = wrapAgentToolsWithResultTruncation(tools);
+    tools = wrapAgentToolsWithResultTruncation(tools, {
+      getBlobWriter: () => childBlobWriter,
+      getContextDir: () => childContextDir,
+    });
 
     const environment = await gatherEnvironment(params.cwd);
     const extensions =
@@ -973,6 +985,7 @@ async function runSubAgentInner(
     const sessionId = safeRequestedId ?? generateSessionId();
     const workdir = join(params.workdirBase, "subagents", sessionId);
     await mkdir(workdir, { recursive: true });
+    childContextDir = workdir;
     // One record per stop/nudge, with its measured value beside its
     // threshold, written into this leaf's own trace dir.
     interventions = createInterventionLog(workdir, {
@@ -1000,6 +1013,8 @@ async function runSubAgentInner(
     });
 
     const { storage, audit } = await createSessionStores(workdir);
+    childBlobWriter = (key, bytes, contentType) =>
+      storage.writeBlob(key, bytes, contentType);
     const authorize = createWorkerAuthorize(params.permissionGate);
 
     const head = {