fix(agents): keep chunkString and buildResumeMessage truncation UTF-16 safe

wm0018 · wm0018 · commit 99b58c454ea7 · 2026-07-09T08:40:32.000+08:00
diff --git a/src/agents/bash-tools.shared.test.ts b/src/agents/bash-tools.shared.test.ts
@@ -3,7 +3,7 @@
  * Covers strict env parsing and compact session labels.
  */
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { deriveSessionName, readEnvInt } from "./bash-tools.shared.js";
+import { chunkString, deriveSessionName, readEnvInt } from "./bash-tools.shared.js";
 
 describe("readEnvInt", () => {
   afterEach(() => {
@@ -70,3 +70,42 @@ describe("deriveSessionName", () => {
     }
   });
 });
+
+describe("chunkString", () => {
+  it("preserves surrogate pairs at chunk boundaries", () => {
+    // 8191 'a' + emoji + "b" = 8194 code units. With chunk limit 8192,
+    // raw slice(0, 8192) would cut between the emoji's high surrogate at
+    // index 8191 and low surrogate at index 8192 → lone surrogate in chunk 1.
+    // sliceUtf16Safe backs out the boundary → both surrogates stay together.
+    const input = "a".repeat(8191) + "🚀b";
+    const chunks = chunkString(input, 8192);
+    expect(chunks.length).toBe(2);
+    for (const chunk of chunks) {
+      const rt = new TextDecoder().decode(new TextEncoder().encode(chunk));
+      expect(rt).not.toContain("�");
+    }
+    // The emoji must not be lost across chunks.
+    const rejoined = chunks.join("");
+    expect(rejoined).toBe(input);
+  });
+
+  it("returns single chunk for input smaller than limit", () => {
+    const chunks = chunkString("hello", 8192);
+    expect(chunks).toEqual(["hello"]);
+  });
+
+  it("splits cleanly when chunk boundary aligns with surrogate pair", () => {
+    // 2 'a' + emoji + 2 'b' = 6 code units. chunk limit 2 splits at
+    // index 2 (inside the emoji). sliceUtf16Safe backs out to index 2
+    // at chunk end and advances to index 3 at chunk start → both halves
+    // preserved, data not lost.
+    const input = "aa🚀bb";
+    const chunks = chunkString(input, 2);
+    const rejoined = chunks.join("");
+    expect(rejoined).toBe(input);
+    for (const chunk of chunks) {
+      const rt = new TextDecoder().decode(new TextEncoder().encode(chunk));
+      expect(rt).not.toContain("�");
+    }
+  });
+});
diff --git a/src/agents/bash-tools.shared.ts b/src/agents/bash-tools.shared.ts
@@ -133,11 +133,20 @@ export function readEnvInt(key: string, legacyKey?: string) {
   return parseStrictInteger(raw);
 }
 
-/** Splits large output into fixed-size UTF-16 chunks for transport. */
+/** Splits large output into fixed-size chunks for transport, preserving UTF-16 surrogate pairs at chunk boundaries. */
 export function chunkString(input: string, limit = CHUNK_LIMIT) {
   const chunks: string[] = [];
-  for (let i = 0; i < input.length; i += limit) {
-    chunks.push(input.slice(i, i + limit));
+  let i = 0;
+  while (i < input.length) {
+    const chunk = sliceUtf16Safe(input, i, i + limit);
+    if (chunk.length === 0 && limit > 0) {
+      // sliceUtf16Safe backed out completely — force-advance past the
+      // surrogate pair so we don't loop forever on a tiny limit.
+      i += Math.max(2, input.codePointAt(i) !== undefined ? 2 : 1);
+      continue;
+    }
+    chunks.push(chunk);
+    i += chunk.length;
   }
   return chunks;
 }
diff --git a/src/agents/subagent-orphan-recovery.ts b/src/agents/subagent-orphan-recovery.ts
@@ -23,6 +23,7 @@ import { callGateway } from "../gateway/call.js";
 import { readSessionMessagesAsync } from "../gateway/session-transcript-readers.js";
 import { formatErrorMessage } from "../infra/errors.js";
 import { createSubsystemLogger } from "../logging/subsystem.js";
+import { truncateUtf16Safe } from "../utils.js";
 import { resolveInternalSessionEffectsTranscriptPath } from "./internal-session-effects.js";
 import {
   evaluateSubagentRecoveryGate,
@@ -72,7 +73,8 @@ function reclassifyLegacyRestartInterruptedRun(runRecord: SubagentRunRecord): vo
  */
 function buildResumeMessage(task: string, lastHumanMessage?: string): string {
   const maxTaskLen = 2000;
-  const truncatedTask = task.length > maxTaskLen ? `${task.slice(0, maxTaskLen)}...` : task;
+  const truncatedTask =
+    task.length > maxTaskLen ? `${truncateUtf16Safe(task, maxTaskLen)}...` : task;
 
   let message =
     `[System] Your previous turn was interrupted by a gateway reload. ` +
diff --git a/src/agents/task-resume-utf16-safe.test.ts b/src/agents/task-resume-utf16-safe.test.ts
@@ -0,0 +1,31 @@
+// UTF-16-safe truncation test for `task.slice(0, 2000)` in
+// buildResumeMessage (src/agents/subagent-orphan-recovery.ts:75).
+// Subagent orphan recovery truncates the task description in the resume
+// message at 2000 code units, which can split a surrogate pair.
+import { describe, expect, it } from "vitest";
+import { truncateUtf16Safe } from "../utils.js";
+
+describe("task resume truncation", () => {
+  it("drops the incomplete emoji pair instead of producing a lone surrogate (maxChars=2000)", () => {
+    // task = 1999 't' + emoji = 2001 code units. emoji high surrogate at
+    // index 1999 (within the 2000-char limit), low surrogate at index 2000
+    // (outside). slice(0, 2000) → lone high surrogate → U+FFFD.
+    // truncateUtf16Safe(2000) backs out to 1999 pure 't'.
+    const task = "t".repeat(1999) + "🚀";
+    expect(task.slice(0, 2000).charCodeAt(1999)).toBe(0xd83d); // lone high surrogate
+    expect(truncateUtf16Safe(task, 2000)).toBe("t".repeat(1999)); // pair dropped cleanly
+  });
+
+  it("preserves the complete emoji when it fits fully within the boundary", () => {
+    // task = 1998 't' + emoji = 2000 code units. Both surrogate halves
+    // are within the limit — no truncation needed.
+    const task = "t".repeat(1998) + "🚀";
+    expect(task.length).toBe(2000);
+    expect(truncateUtf16Safe(task, 2000)).toBe(task);
+  });
+
+  it("preserves task strings shorter than the limit unchanged", () => {
+    expect(truncateUtf16Safe("deploy database migration", 2000)).toBe("deploy database migration");
+    expect(truncateUtf16Safe("", 2000)).toBe("");
+  });
+});
