fix(fill): accept a surrogate pair split across stdin string chunks

- A string stream may split a surrogate pair across chunks, and the
  per-chunk lone-surrogate check refused valid input. A trailing high
  surrogate is now held back until the next string chunk; a byte chunk
  or the end of input still refuses it as invalid UTF-8.
- Size a string chunk with Buffer.byteLength before encoding it, so an
  oversized chunk is refused without being copied first.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: Metehan-Bicer

src/commands/interaction/fill-text-stdin.test.ts

@@ -29,6 +29,7 @@ test.each([
   ['surrounding spaces and inner newlines', ['  two\nlines  \n'], '  two\nlines  '],
   ['a value split across chunks', ['hun', Buffer.from('ter'), '2\n'], 'hunter2'],
   ['a multi-byte character split across chunks', [Buffer.from([0xc3]), Buffer.from([0xa7])], 'ç'],
+  ['a surrogate pair split across string chunks', ['a\uD83D', '\uDE00b'], 'a\u{1F600}b'],
 ])('reads %s', async (_name, chunks, expected) => {
   expect(await readFillTextFromStdin(pipe(...chunks))).toBe(expected);
 });
@@ -64,6 +65,18 @@ test.each([
     'fill_text_stdin_invalid_utf8',
     'lone-surrogate-',
   ],
+  [
+    'a high surrogate followed by a byte chunk',
+    () => pipe('held-surrogate-\uD83D', Buffer.from('x')),
+    'fill_text_stdin_invalid_utf8',
+    'held-surrogate-',
+  ],
+  [
+    'an oversized string chunk before checking its surrogates',
+    () => pipe(`${'s3cret'.repeat(FILL_TEXT_STDIN_MAX_BYTES)}\uDC00`),
+    'fill_text_stdin_too_large',
+    's3cret',
+  ],
 ])('refuses %s with a typed reason and no echoed input', async (_name, stdin, reason, input) => {
   const error = await readError(stdin());
 

src/commands/interaction/fill-text-stdin.ts

@@ -3,7 +3,7 @@ import { AppError } from '@agent-device/kernel/errors';
 /** Most UTF-8 input `fill --text-stdin` accepts, trailing newline included. */
 export const FILL_TEXT_STDIN_MAX_BYTES = 64 * 1024;
 
-type StdinSource = AsyncIterable<Uint8Array | string> & { isTTY?: boolean };
+type StdinSource = AsyncIterable<StdinPiece> & { isTTY?: boolean };
 
 /**
  * Reads the `fill --text-stdin` value. Exactly one trailing `\n` or `\r\n` is removed so a value
@@ -24,18 +24,21 @@ export async function readFillTextFromStdin(stdin: StdinSource): Promise<string>
   }
   const chunks: Uint8Array[] = [];
   let byteLength = 0;
+  let heldHighSurrogate = '';
   for await (const chunk of stdin) {
-    const bytes = typeof chunk === 'string' ? encodeWellFormed(chunk) : chunk;
-    byteLength += bytes.byteLength;
+    const next = joinHeldHighSurrogate(heldHighSurrogate, chunk);
+    heldHighSurrogate = next.held;
+    byteLength += utf8ByteLength(next.piece);
     if (byteLength > FILL_TEXT_STDIN_MAX_BYTES) {
       throw new AppError(
         'INVALID_ARGS',
         `fill --text-stdin accepts at most ${FILL_TEXT_STDIN_MAX_BYTES} bytes of input.`,
         { reason: 'fill_text_stdin_too_large', maxBytes: FILL_TEXT_STDIN_MAX_BYTES },
       );
     }
-    chunks.push(bytes);
+    chunks.push(encodeWellFormed(next.piece));
   }
+  if (heldHighSurrogate) throw invalidUtf8Error();
   const text = stripOneTrailingNewline(decodeUtf8(Buffer.concat(chunks)));
   if (text === '') {
     throw new AppError('INVALID_ARGS', 'fill --text-stdin received no text.', {
@@ -47,11 +50,38 @@ export async function readFillTextFromStdin(stdin: StdinSource): Promise<string>
 }
 
 const LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+const TRAILING_HIGH_SURROGATE = /[\uD800-\uDBFF]$/;
+
+type StdinPiece = Uint8Array | string;
+
+/**
+ * A string stream may split a surrogate pair across chunks, so a trailing high surrogate is held
+ * back until the next string chunk; a byte chunk cannot complete it.
+ */
+function joinHeldHighSurrogate(
+  held: string,
+  chunk: StdinPiece,
+): { piece: StdinPiece; held: string } {
+  if (typeof chunk !== 'string') {
+    if (held) throw invalidUtf8Error();
+    return { piece: chunk, held: '' };
+  }
+  const text = held + chunk;
+  return TRAILING_HIGH_SURROGATE.test(text)
+    ? { piece: text.slice(0, -1), held: text.slice(-1) }
+    : { piece: text, held: '' };
+}
+
+/** Sized before encoding, so an oversized string chunk is refused without being copied. */
+function utf8ByteLength(piece: StdinPiece): number {
+  return typeof piece === 'string' ? Buffer.byteLength(piece, 'utf8') : piece.byteLength;
+}
 
 /** `Buffer.from` would turn a lone surrogate into U+FFFD; refuse it like an invalid byte. */
-function encodeWellFormed(chunk: string): Uint8Array {
-  if (LONE_SURROGATE.test(chunk)) throw invalidUtf8Error();
-  return Buffer.from(chunk, 'utf8');
+function encodeWellFormed(piece: StdinPiece): Uint8Array {
+  if (typeof piece !== 'string') return piece;
+  if (LONE_SURROGATE.test(piece)) throw invalidUtf8Error();
+  return Buffer.from(piece, 'utf8');
 }
 
 function decodeUtf8(bytes: Uint8Array): string {