@volter/supercode-teams 0.3.108 → 0.3.110

package/codex-startup.mjs

@@ -137,6 +137,9 @@ export async function settleCodexHookReview(host, sessionId, { signal, deadlineM
  *  into one composer entry. */
 export const CODEX_WINDOWS_PASTE_CHARS = 8000;
 
+/** The most written characters a Windows Codex paste was measured to take whole (8180 arrived, 8200 did not). */
+const CODEX_WINDOWS_PASTE_MAX = 8180;
+
 /** One character as a Windows Codex reads it from its console. Codex drops some BMP characters that arrive as plain
  *  text through ConPTY (measured: `—`, `…`, `✓` vanish while `é`, `日`, and astral `🙂` arrive), so every BMP
  *  character past ASCII goes as a win32-input-mode key event carrying its UTF-16 unit (VK_PACKET, 231), which ConPTY
@@ -148,13 +151,31 @@ function codexWindowsCharacter(character) {
 }
 
 /** Text as the raw writes that paste it into a Windows Codex composer: bracketed pastes of at most
- *  CODEX_WINDOWS_PASTE_CHARS characters each, non-ASCII BMP characters as key events. Written as they are (a terminal
- *  host turns `\n` into `\r`, which Codex keeps as a line break inside a paste); never submitted here. */
+ *  CODEX_WINDOWS_PASTE_CHARS written characters each (a key event counts as its whole encoding, so non-ASCII-heavy
+ *  text takes more, smaller pastes), non-ASCII BMP characters as key events. A piece ends after its last line break
+ *  when it has one, and never begins with one: a line break arriving first after the gap between pastes could read as
+ *  Enter and submit part of the text. Line ends are normalized to `\n`. Written as they are (a terminal host turns `\n` into `\r`, which Codex keeps
+ *  as a line break inside a paste); never submitted here. */
 export function codexWindowsPastes(text) {
-  const characters = Array.from(String(text));
+  // Line ends as `\n` only: Codex reads a pasted `\r\n` as two line breaks.
+  const encoded = Array.from(String(text).replace(/\r\n?/g, '\n')).map(codexWindowsCharacter);
   const pastes = [];
-  for (let at = 0; at < characters.length; at += CODEX_WINDOWS_PASTE_CHARS) {
-    pastes.push(`\u001b[200~${characters.slice(at, at + CODEX_WINDOWS_PASTE_CHARS).map(codexWindowsCharacter).join('')}\u001b[201~`);
+  for (let start = 0; start < encoded.length;) {
+    let end = start, written = 0, lastBreak = -1;
+    while (end < encoded.length && (end === start || written + encoded[end].length <= CODEX_WINDOWS_PASTE_CHARS)) {
+      written += encoded[end].length;
+      if (encoded[end] === '\n') lastBreak = end;
+      end += 1;
+    }
+    // Cut after the piece's last line break when the text goes on; else keep any line breaks that follow the cut
+    // with this piece, so the next one does not open with one — but never past CODEX_WINDOWS_PASTE_MAX, beyond which
+    // Codex drops the whole paste. Only a run of more blank lines than that margin still opens the next piece.
+    if (end < encoded.length) {
+      if (lastBreak >= start && lastBreak + 1 < end) end = lastBreak + 1;
+      else while (end < encoded.length && encoded[end] === '\n' && written < CODEX_WINDOWS_PASTE_MAX) { written += 1; end += 1; }
+    }
+    pastes.push(`\u001b[200~${encoded.slice(start, end).join('')}\u001b[201~`);
+    start = end;
   }
   return pastes;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.108",
+  "version": "0.3.110",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",

package/terminal-mail.mjs

@@ -40,6 +40,8 @@ function confirmed(batch) {
         const text = textOf(content);
         if (text === null || text.length === 0) continue;
         if (text === batch.text) return { fragments: 1 };
+        // A Windows Codex is pasted its text with line ends as `\n` (codexWindowsPastes).
+        if (batch.kind === 'codex' && text === batch.text.replace(/\r\n?/g, '\n')) return { fragments: 1 };
         // Older mail delivery omitted the paste delimiter, so terminal newlines
         // submitted one envelope as several native user messages. Recover only
         // exact, ordered fragments of the retained bytes, separated by original