fix(text): keep reachable truncation boundaries UTF-16 safe

Consolidates #102007, #101818, and #101782.

Co-authored-by: 杨浩宇0668001029 <yang.haoyu@xydigit.com>
Co-authored-by: NIO <nocodet@mail.com>
Co-authored-by: Cursor <cursoragent@cursor.com>

extensions/slack/src/monitor/message-handler/prepare-thread-context-root.test.ts

@@ -244,4 +244,11 @@ describe("formatSlackBotStarterThreadLabel", () => {
       }),
     ).toBe("Slack thread DM (assistant root): Line one Line two");
   });
+
+  it("drops a surrogate-pair emoji whole when it straddles the snippet limit", () => {
+    const starterText = `${"a".repeat(79)}🐱tail`;
+    expect(formatSlackBotStarterThreadLabel({ roomLabel: "DM", starterText })).toBe(
+      `Slack thread DM (assistant root): ${"a".repeat(79)}`,
+    );
+  });
 });

extensions/slack/src/monitor/message-handler/prepare-thread-context-root.ts

@@ -1,4 +1,6 @@
 // Slack plugin module implements prepare thread context root behavior.
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+
 type SlackBotAuthorIdentity = {
   botUserId?: string;
   botId?: string;
@@ -107,9 +109,13 @@ export function formatSlackBotStarterThreadLabel(params: {
   if (!params.starterText) {
     return base;
   }
-  const snippet = params.starterText.replace(/\s+/g, " ").slice(0, 80).trim();
+  const snippet = formatSlackThreadLabelSnippet(params.starterText).trim();
   if (!snippet) {
     return base;
   }
   return `${base} (assistant root): ${snippet}`;
 }
+
+export function formatSlackThreadLabelSnippet(text: string): string {
+  return truncateUtf16Safe(text.replace(/\s+/g, " "), 80);
+}

extensions/slack/src/monitor/message-handler/prepare-thread-context.test.ts

@@ -225,6 +225,22 @@ describe("resolveSlackThreadContextData", () => {
     expect(result.threadHistoryBody).not.toContain("blocked follow-up");
   });
 
+  it("keeps a user-started thread label UTF-16 safe at the snippet limit", async () => {
+    const starterText = `${"a".repeat(79)}🐱tail`;
+    const { result } = await resolveAllowlistedThreadContext({
+      repliesMessages: [],
+      threadStarter: {
+        text: starterText,
+        userId: "U1",
+        ts: "100.000",
+      },
+      allowFromLower: ["u1"],
+      allowNameMatching: false,
+    });
+
+    expect(result.threadLabel).toBe(`Slack thread #general: ${"a".repeat(79)}`);
+  });
+
   it("includes bot-authored starter as assistant root context for a new thread session (default)", async () => {
     const { result } = await resolveAllowlistedThreadContext({
       repliesMessages: [

extensions/slack/src/monitor/message-handler/prepare-thread-context.ts

@@ -19,6 +19,7 @@ import {
   applySlackThreadHistoryFilterPolicy,
   ensureSlackThreadHistoryHasBotRoot,
   formatSlackBotStarterThreadLabel,
+  formatSlackThreadLabelSnippet,
   isSlackThreadAuthorCurrentBot,
   resolveSlackThreadHistoryFilterPolicy,
   shouldIncludeBotThreadStarterContext,
@@ -224,7 +225,7 @@ export async function resolveSlackThreadContextData(params: {
 
   if (starter?.text && includeStarterContext) {
     threadStarterBody = starter.text;
-    const snippet = starter.text.replace(/\s+/g, " ").slice(0, 80);
+    const snippet = formatSlackThreadLabelSnippet(starter.text);
     threadLabel = `Slack thread ${params.roomLabel}${snippet ? `: ${snippet}` : ""}`;
     // Root media seeds a new thread session once. Rehydrating it later makes
     // old files look like current-turn uploads and repeats media processing.

extensions/zalo/src/send.test.ts

@@ -119,6 +119,29 @@ describe("zalo send", () => {
     expect(sendPhotoMock).not.toHaveBeenCalled();
   });
 
+  it("keeps outbound text and photo captions UTF-16 safe at the 2000-char limit", async () => {
+    sendMessageMock.mockResolvedValueOnce({
+      ok: true,
+      result: { message_id: "z-msg-surrogate" },
+    });
+    sendPhotoMock.mockResolvedValueOnce({
+      ok: true,
+      result: { message_id: "z-photo-surrogate" },
+    });
+    const boundaryText = `${"a".repeat(1999)}🐱`;
+
+    await sendMessageZalo("dm-chat-surrogate-text", boundaryText, {
+      token: "zalo-token",
+    });
+    await sendPhotoZalo("dm-chat-surrogate-caption", "https://example.com/photo.jpg", {
+      token: "zalo-token",
+      caption: boundaryText,
+    });
+
+    expect(sendMessageMock.mock.calls[0]?.[1]?.text).toBe("a".repeat(1999));
+    expect(sendPhotoMock.mock.calls[0]?.[1]?.caption).toBe("a".repeat(1999));
+  });
+
   it("sends cfg-backed media directly without hosted-media rewrites", async () => {
     sendPhotoMock.mockResolvedValueOnce({
       ok: true,

extensions/zalo/src/send.ts

@@ -6,6 +6,7 @@ import {
 } from "openclaw/plugin-sdk/channel-outbound";
 import type { OpenClawConfig } from "openclaw/plugin-sdk/config-contracts";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { resolveZaloAccount } from "./accounts.js";
 import type { ZaloFetch } from "./api.js";
 import { sendMessage, sendPhoto } from "./api.js";
@@ -167,7 +168,7 @@ export async function sendMessageZalo(
       context.token,
       {
         chat_id: context.chatId,
-        text: text.slice(0, 2000),
+        text: truncateUtf16Safe(text, 2000),
       },
       context.fetcher,
     ),
@@ -200,7 +201,8 @@ export async function sendPhotoZalo(
         {
           chat_id: context.chatId,
           photo: photoUrl.trim(),
-          caption: options.caption?.slice(0, 2000),
+          caption:
+            options.caption !== undefined ? truncateUtf16Safe(options.caption, 2000) : undefined,
         },
         context.fetcher,
       ))(),

src/agents/sessions/exec.test.ts

@@ -121,6 +121,25 @@ describe("execCommand", () => {
     expect(result.stdoutTruncatedChars).toBe(3);
   });
 
+  it("keeps caller-capped retained output UTF-16 safe", async () => {
+    const child = createStubChild();
+    const wait = createDeferred<number | null>();
+    spawnMock.mockReturnValue(child);
+    waitForChildProcessMock.mockReturnValue(wait.promise);
+    const { execCommand } = await import("./exec.js");
+
+    const resultPromise = execCommand("cmd", [], "/tmp", { maxOutputChars: 2 });
+    child.stdout.emit("data", Buffer.from("A😀B"));
+    child.stderr.emit("data", Buffer.from("C😀D"));
+    wait.resolve(0);
+
+    const result = await resultPromise;
+    expect(result.stdout).toBe("B");
+    expect(result.stderr).toBe("D");
+    expect(result.stdoutTruncatedChars).toBe(3);
+    expect(result.stderrTruncatedChars).toBe(3);
+  });
+
   it("fails instead of silently truncating default exec output", async () => {
     const child = createStubChild();
     const wait = createDeferred<number | null>();
@@ -129,7 +148,7 @@ describe("execCommand", () => {
     const { execCommand } = await import("./exec.js");
 
     const resultPromise = execCommand("cmd", [], "/tmp");
-    child.stdout.emit("data", Buffer.from("x".repeat(16 * 1024 * 1024 + 1)));
+    child.stdout.emit("data", Buffer.from(`${"x".repeat(16 * 1024 * 1024 - 1)}😀`));
     wait.resolve(0);
 
     const result = await resultPromise;
@@ -141,8 +160,9 @@ describe("execCommand", () => {
     expect(result.code).toBe(1);
     expect(result.killed).toBe(true);
     expect(result.outputLimitExceeded).toBe("stdout");
-    expect(result.stdout.length).toBe(16 * 1024 * 1024);
-    expect(result.stdoutTruncatedChars).toBe(1);
+    expect(result.stdout.length).toBe(16 * 1024 * 1024 - 1);
+    expect(result.stdout.endsWith("x")).toBe(true);
+    expect(result.stdoutTruncatedChars).toBe(2);
     expect(result.stderr).toContain("exec stdout exceeded output limit");
   });
 

src/agents/sessions/exec.ts

@@ -3,6 +3,7 @@
  */
 
 import { spawn } from "node:child_process";
+import { sliceUtf16Safe } from "@openclaw/normalization-core/utf16-slice";
 import { killProcessTree } from "../../process/kill-tree.js";
 import { waitForChildProcess } from "../utils/child-process.js";
 
@@ -63,9 +64,12 @@ function appendCapturedOutput(
       truncatedChars: current.truncatedChars,
     };
   }
+  const nextText = truncateTail
+    ? sliceUtf16Safe(combined, overflowChars)
+    : sliceUtf16Safe(combined, 0, maxOutputChars);
   return {
-    text: truncateTail ? combined.slice(overflowChars) : combined.slice(0, maxOutputChars),
-    truncatedChars: current.truncatedChars + overflowChars,
+    text: nextText,
+    truncatedChars: current.truncatedChars + combined.length - nextText.length,
   };
 }