Normalize report_intent tool-list drift in replay proxy

The 1.0.72 CLI now appends the full built-in tool enumeration to the
"Tool 'report_intent' does not exist." error, while existing snapshots
recorded it truncated. Strip the whole "Available tools that can be
called are <list>." sentence on both the request and stored sides so
list-present, list-absent, and differing list contents are all
equivalent, fixing subagent_hooks (all SDKs) and should_abort_a_session
(Go/Python/Rust/.NET) without editing any snapshots.

Also collapse the new trailing multi-turn advice on the task tool's
background-agent start result to a stable placeholder.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: e94bab38-c22e-4a38-8d8b-c82c1991a33c

Author: stephentoub

test/harness/replayingCapiProxy.test.ts

@@ -509,7 +509,7 @@ Always include PINEAPPLE_COCONUT_42.
     expect(toolMessages[1].content).toBe("[beta result]");
   });
 
-  test("collapses the available-tools list to a stable placeholder", async () => {
+  test("strips the available-tools list so its contents don't matter", async () => {
     const requestBody = JSON.stringify({
       messages: [
         { role: "user", content: "Help me" },
@@ -543,10 +543,52 @@ Always include PINEAPPLE_COCONUT_42.
     const toolMessage = result.conversations[0].messages.find(
       (m) => m.role === "tool",
     );
-    // The whole enumeration collapses so snapshots stay stable as the built-in
-    // tool set evolves (e.g. write_agent being added).
+    // The whole "Available tools..." sentence is stripped so snapshots stay
+    // stable whether or not the runtime emits the list and as the built-in tool
+    // set evolves (e.g. write_agent being added).
     expect(toolMessage?.content).toBe(
-      "Tool 'report_intent' does not exist. Available tools that can be called are ${available_tools}.",
+      "Tool 'report_intent' does not exist.",
+    );
+  });
+
+  test("collapses background-agent start advice to a stable placeholder", async () => {
+    const requestBody = JSON.stringify({
+      messages: [
+        { role: "user", content: "Help me" },
+        {
+          role: "assistant",
+          tool_calls: [
+            {
+              id: "tc1",
+              type: "function",
+              function: { name: "task", arguments: "{}" },
+            },
+          ],
+        },
+        {
+          role: "tool",
+          tool_call_id: "tc1",
+          content:
+            "Agent started in background with agent_id: read-file. You'll be notified when it completes. Tell the user you're waiting and end your response, or continue unrelated work until notified. The agent supports multi-turn conversations — use write_agent to send follow-up messages.",
+        },
+      ],
+    });
+    const responseBody = JSON.stringify({
+      choices: [{ message: { role: "assistant", content: "Done" } }],
+    });
+
+    const outputPath = await createProxy([
+      { url: "/chat/completions", requestBody, responseBody },
+    ]);
+
+    const result = await readYamlOutput(outputPath);
+    const toolMessage = result.conversations[0].messages.find(
+      (m) => m.role === "tool",
+    );
+    // The volatile advice tail collapses so snapshots stay stable as the wording
+    // evolves across runtime versions, while the agent_id is preserved.
+    expect(toolMessage?.content).toBe(
+      "Agent started in background with agent_id: read-file. ${background_agent_advice}",
     );
   });
 
@@ -947,6 +989,163 @@ Always include PINEAPPLE_COCONUT_42.
       }
     });
 
+    test("matches truncated report_intent results against a runtime that emits the tool list", async () => {
+      const cachePath = path.join(tempDir, "cache.yaml");
+      // Older snapshots truncated the report_intent error to just the first
+      // sentence, with no "Available tools..." enumeration recorded on disk.
+      const cacheContent = yaml.stringify({
+        models: ["test-model"],
+        conversations: [
+          {
+            messages: [
+              { role: "system", content: "${system}" },
+              { role: "user", content: "Report intent" },
+              {
+                role: "assistant",
+                tool_calls: [
+                  {
+                    id: "toolcall_0",
+                    type: "function",
+                    function: { name: "report_intent", arguments: "{}" },
+                  },
+                ],
+              },
+              {
+                role: "tool",
+                tool_call_id: "toolcall_0",
+                content: "Tool 'report_intent' does not exist.",
+              },
+              { role: "assistant", content: "Done" },
+            ],
+          },
+        ],
+      } satisfies NormalizedData);
+      await writeFile(cachePath, cacheContent);
+
+      const proxy = new ReplayingCapiProxy(
+        "http://localhost:9999",
+        cachePath,
+        workDir,
+      );
+      const proxyUrl = await proxy.start();
+
+      try {
+        const response = await makeRequest(proxyUrl, "/chat/completions", {
+          body: {
+            model: "test-model",
+            messages: [
+              { role: "system", content: "System prompt" },
+              { role: "user", content: "Report intent" },
+              {
+                role: "assistant",
+                tool_calls: [
+                  {
+                    id: "runtime-call-id",
+                    type: "function",
+                    function: { name: "report_intent", arguments: "{}" },
+                  },
+                ],
+              },
+              {
+                role: "tool",
+                tool_call_id: "runtime-call-id",
+                // Newer runtime appends the full built-in tool enumeration.
+                content:
+                  "Tool 'report_intent' does not exist. Available tools that can be called are bash, read_bash, view, read_agent, list_agents, write_agent, grep, glob, task.",
+              },
+            ],
+          },
+        });
+
+        expect(response.status).toBe(200);
+        expect(
+          (JSON.parse(response.body) as ChatCompletion).choices[0].message
+            .content,
+        ).toBe("Done");
+      } finally {
+        await proxy.stop();
+      }
+    });
+
+    test("matches background-agent start results after the advice wording changes", async () => {
+      const cachePath = path.join(tempDir, "cache.yaml");
+      // Legacy snapshot recorded before the runtime appended multi-turn advice
+      // to the background-agent start message.
+      const cacheContent = yaml.stringify({
+        models: ["test-model"],
+        conversations: [
+          {
+            messages: [
+              { role: "system", content: "${system}" },
+              { role: "user", content: "Spawn an agent" },
+              {
+                role: "assistant",
+                tool_calls: [
+                  {
+                    id: "toolcall_0",
+                    type: "function",
+                    function: { name: "task", arguments: "{}" },
+                  },
+                ],
+              },
+              {
+                role: "tool",
+                tool_call_id: "toolcall_0",
+                content:
+                  "Agent started in background with agent_id: read-file. You'll be notified when it completes. Tell the user you're waiting and end your response, or continue unrelated work until notified.",
+              },
+              { role: "assistant", content: "Done" },
+            ],
+          },
+        ],
+      } satisfies NormalizedData);
+      await writeFile(cachePath, cacheContent);
+
+      const proxy = new ReplayingCapiProxy(
+        "http://localhost:9999",
+        cachePath,
+        workDir,
+      );
+      const proxyUrl = await proxy.start();
+
+      try {
+        const response = await makeRequest(proxyUrl, "/chat/completions", {
+          body: {
+            model: "test-model",
+            messages: [
+              { role: "system", content: "System prompt" },
+              { role: "user", content: "Spawn an agent" },
+              {
+                role: "assistant",
+                tool_calls: [
+                  {
+                    id: "runtime-call-id",
+                    type: "function",
+                    function: { name: "task", arguments: "{}" },
+                  },
+                ],
+              },
+              {
+                role: "tool",
+                tool_call_id: "runtime-call-id",
+                // Newer runtime appends multi-turn advice referencing write_agent.
+                content:
+                  "Agent started in background with agent_id: read-file. You'll be notified when it completes. Tell the user you're waiting and end your response, or continue unrelated work until notified. The agent supports multi-turn conversations — use write_agent to send follow-up messages.",
+              },
+            ],
+          },
+        });
+
+        expect(response.status).toBe(200);
+        expect(
+          (JSON.parse(response.body) as ChatCompletion).choices[0].message
+            .content,
+        ).toBe("Done");
+      } finally {
+        await proxy.stop();
+      }
+    });
+
     test("expands workdir placeholder in cached response", async () => {
       const cachePath = path.join(tempDir, "cache.yaml");
       const cacheContent = yaml.stringify({

test/harness/replayingCapiProxy.ts

@@ -127,6 +127,7 @@ export class ReplayingCapiProxy extends CapturingHttpProxy {
     { toolName: "${shell}", normalizer: normalizeShellExitMarkers },
     { toolName: "*", normalizer: normalizeGhAuthMessages },
     { toolName: "*", normalizer: normalizeAvailableToolNames },
+    { toolName: "task", normalizer: normalizeBackgroundAgentAdvice },
     { toolName: "read_agent", normalizer: normalizeReadAgentTimings },
   ];
 
@@ -1299,17 +1300,17 @@ function coalesceMessages(
   return result;
 }
 
-// Re-normalizes the built-in tool enumeration in stored tool results at load
-// time. Snapshots recorded before normalizeAvailableToolNames collapsed the
-// whole list (or recorded against an older tool set) still contain the literal
-// enumeration on disk; the result normalizers only run against live requests,
-// so without this the stored side would keep the stale list and never match a
-// request whose tool set has since changed.
+// Re-normalizes stored tool results at load time. Snapshots recorded against an
+// older runtime still contain the literal built-in tool enumeration (or the
+// background-agent advice wording) on disk; the result normalizers only run
+// against live requests, so without this the stored side would keep the stale
+// text and never match a request whose runtime output has since changed.
 function normalizeStoredToolMessages(conversations: NormalizedConversation[]) {
   for (const conversation of conversations) {
     for (const message of conversation.messages) {
       if (message.role === "tool" && typeof message.content === "string") {
         message.content = normalizeAvailableToolNames(message.content);
+        message.content = normalizeBackgroundAgentAdvice(message.content);
       }
     }
   }
@@ -1405,21 +1406,35 @@ function normalizeReadAgentTimings(result: string): string {
     .replace(/\bduration: \d+(?:\.\d+)?s\b/g, "duration: 0s");
 }
 
-// Stable placeholder for the built-in tool enumeration the runtime emits when a
-// nonexistent tool is called (see normalizeAvailableToolNames).
-export const availableToolsPlaceholder = "${available_tools}";
-
 // When a model calls a tool that doesn't exist (e.g., the removed report_intent
-// tool), the runtime replies with "Available tools that can be called are <list>."
-// That enumeration is both platform-specific (shell tool family names differ
-// across OSes) and runtime-version-specific (built-in tools such as write_agent
-// are added or removed over time), so any test that trips this path would break
-// whenever the tool set changes. Collapse the whole list to a stable placeholder
-// so snapshots keep matching as the built-in tool set evolves.
+// tool), the runtime replies with "Tool '<name>' does not exist. Available tools
+// that can be called are <list>." Some runtime versions omit that second sentence
+// entirely, and when present the enumeration is both platform-specific (shell tool
+// family names differ across OSes) and runtime-version-specific (built-in tools
+// such as write_agent are added or removed over time). Strip the whole "Available
+// tools..." sentence so its presence, absence, and exact contents are all
+// equivalent and snapshots keep matching as the built-in tool set evolves.
 function normalizeAvailableToolNames(result: string): string {
   return result.replace(
-    /(Available tools that can be called are )[^.]*/g,
-    (_full, prefix: string) => prefix + availableToolsPlaceholder,
+    /\s*Available tools that can be called are [^.]*\./g,
+    "",
+  );
+}
+
+// Stable placeholder for the advice text the runtime appends after starting a
+// background agent (see normalizeBackgroundAgentAdvice).
+export const backgroundAgentAdvicePlaceholder = "${background_agent_advice}";
+
+// When the task tool starts an agent in the background, the runtime replies with
+// "Agent started in background with agent_id: <id>." followed by advice text
+// ("You'll be notified when it completes... The agent supports multi-turn
+// conversations — use write_agent...") that changes across runtime versions.
+// Collapse that trailing advice to a stable placeholder so snapshots keep
+// matching as the wording evolves, while preserving the meaningful agent_id.
+function normalizeBackgroundAgentAdvice(result: string): string {
+  return result.replace(
+    /(Agent started in background with agent_id: \S+\.)[\s\S]*/,
+    (_full, prefix: string) => `${prefix} ${backgroundAgentAdvicePlaceholder}`,
   );
 }