@volter/supercode-teams 0.3.105 → 0.3.107

package/codex-startup.mjs

@@ -131,3 +131,30 @@ export async function settleCodexHookReview(host, sessionId, { signal, deadlineM
   }
   return signal.aborted ? 'aborted' : 'deadline';
 }
+
+/** The most one bracketed paste carries into a Windows Codex: ConPTY and Codex drop a whole paste past about 8190
+ *  characters (measured 2026-10-06, codex-cli 0.160.1: 8180 arrived, 8200 did not), while consecutive pastes join
+ *  into one composer entry. */
+export const CODEX_WINDOWS_PASTE_CHARS = 8000;
+
+/** 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
+ *  hands Codex as exactly that character. ASCII and astral characters go as they are. */
+function codexWindowsCharacter(character) {
+  const unit = character.codePointAt(0);
+  if (unit < 0x80 || unit > 0xffff) return character;
+  return `\u001b[231;0;${unit};1;0;1_\u001b[231;0;${unit};0;0;1_`;
+}
+
+/** 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. */
+export function codexWindowsPastes(text) {
+  const characters = Array.from(String(text));
+  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~`);
+  }
+  return pastes;
+}

package/machine.mjs

@@ -41,6 +41,7 @@ import { render } from './mail/envelope.mjs';
 import { Agents } from './mail/agents.mjs';
 import { Relays } from './mail/relay.mjs';
 import { serveRelayEndpoint } from './mail/relay-endpoint.mjs';
+import { MailCarrier } from './mail/carrier.mjs';
 import { MailSend } from './mail/send.mjs';
 import { AgentVerbs } from './mail/verbs.mjs';
 import { deliverToRuntime } from './mail/runtime.mjs';
@@ -92,7 +93,7 @@ import { JobOwner, executionCapabilities, streamProgram, serveWorkspace } from '
 import { TerminalMailbox, retainedTerminalMail } from './terminal-mail.mjs';
 import { confirmNativeInitialInput } from './native-initial-input.mjs';
 import { sessionPeople } from './session-people.mjs';
-import { canonicalCodexFolderTrust, codexProgram, codexStartupArguments, codexUpdatePrompt, codexVersion, settleCodexHookReview } from './codex-startup.mjs';
+import { canonicalCodexFolderTrust, codexProgram, codexStartupArguments, codexUpdatePrompt, codexVersion, codexWindowsPastes, settleCodexHookReview } from './codex-startup.mjs';
 import { sessionNoticeTarget } from './session-notice-target.mjs';
 import { serveAppDoor } from './app-door.mjs';
 
@@ -202,6 +203,26 @@ const TURN_CONFIRM_MS = 60_000;
  * as the program (`open --new "npm run build"`), that line through this machine's own shell, so a caller on
  * another machine need not know which shell or platform this one has.
  */
+/** How long the Windows pane host's command line for `program args` is, quoted as it quotes a batch program's
+ *  arguments (sdk/terminal `batchArgument`: `"` doubled, a `\` run before a `"` doubled, `%` as `%%cd:~,%`), plus
+ *  the `cmd /e:ON /v:OFF /d /s /c "…"` around it. An upper bound for a program cmd does not run. */
+function windowsCommandLineLength(program, args) {
+  const quoted = (value) => {
+    let length = 2;
+    let backslashes = 0;
+    for (const character of String(value)) {
+      if (character === '\\') backslashes += 1;
+      else {
+        if (character === '"') length += backslashes + 1;
+        backslashes = 0;
+      }
+      length += character === '%' ? 8 : 1;
+    }
+    return length + backslashes;
+  };
+  return [program, ...args].reduce((total, value) => total + quoted(value) + 1, 0) + 32;
+}
+
 function launchCommand(program, args) {
   const line = typeof program === 'string' ? program.trim() : '';
   if (!args.length && /\s/.test(line) && !existsSync(line)) {
@@ -729,19 +750,44 @@ export class TeamsMachine extends MachineCore {
       endpointOf: async () => (await this.relayEndpoint)?.url ?? null,
       arrived: (sessionId, landed) => claudeTranscriptHolds([...live.claudeDirs.keys()].map((dir) => join(dirname(dir), 'projects')), sessionId, landed),
       log: (line) => this.emit('mail-log', line) });
+    // a turn or a wake typed into a daemon pane's empty composer, in process (as `panes.turn` types one)
+    const typeTurn = async (pane, harness, text, messageIds) => {
+      const session = await this.#paneByContext(pane);
+      if (!session) throw new Error(`no pane with context ${pane}`);
+      const result = await this.#paneTurn(session, pane, text, { messageIds, harness });
+      if (result.refused) throw new Error(result.refused.reason);
+      return result.waits ?? result;
+    };
     this.mailSend = new MailSend({ machine, mailRoot, live, store: this.mailStore, agents: this.agents, relays: this.relays,
       // a send waits on its receiver's door there (a relay's receipt takes up to 90 s), never past MAIL_SEND_MS
       askMachine: (to, request) => this.#askMailDoor(to, request, MAIL_SEND_MS),
       deliverRuntime: deliverToRuntime, codexAnswer: (request) => codexQuestions(request),
       // a user's own turn typed into its pane, in process (as `panes.turn` types one)
-      typeTurn: async (pane, harness, text, messageIds) => {
-        const session = await this.#paneByContext(pane);
-        if (!session) throw new Error(`no pane with context ${pane}`);
-        const result = await this.#paneTurn(session, pane, text, { messageIds, harness });
-        if (result.refused) throw new Error(result.refused.reason);
-        return result.waits ?? result;
-      },
+      typeTurn,
       log: (line) => this.emit('mail-log', line) });
+    // the mailbox's own delivery (step 4b): each wake attempted by its session's door, or carried to its machine
+    this.carrier = new MailCarrier({ machine, mailRoot, store: this.mailStore, live,
+      handOver: (address, id) => this.mailSend.handOver(address, id),
+      typeTurn, askMachine: (to, request) => this.#askMailDoor(to, request, MAIL_SEND_MS),
+      log: (line) => this.emit('mail-log', line) }).start();
+    // the user's own turns that wait in a pane session's mailbox (a draft in its composer when they came) are typed once
+    // its composer is free: tried at each change of its mailbox, and every 2 s while one waits (mail_watch.rs
+    // `deliver_waiting_user_turns` read every pane's mailbox every 2 s)
+    const turnsWaiting = new Map(); // address → timer
+    const typeWaiting = async (address) => {
+      clearTimeout(turnsWaiting.get(address)); turnsWaiting.delete(address);
+      const session = live.sessions().find((row) => row.address === address);
+      const pane = session ? this.mail.paneOf(session) : null;
+      if (!pane || !this.mailStore.userTurns(address).length) return;
+      try { await this.mailSend.typeUserTurns(address, pane); } catch (error) { this.emit('mail-log', `the user's turns for ${address} wait: ${error.message}`); }
+      if (this.mailStore.userTurns(address).length) { const timer = setTimeout(() => void typeWaiting(address), 2000); timer.unref?.(); turnsWaiting.set(address, timer); }
+    };
+    this.mailStore.on('changed', (address) => { if (address && !turnsWaiting.has(address)) void typeWaiting(address); });
+    // the turns already waiting when this listener came (the store read every mailbox at its start, before it), and every
+    // mailbox again once per 5 min, so a turn no event named is typed within that bound
+    const everyMailbox = () => { for (const address of this.mailStore.addresses()) if (!turnsWaiting.has(address)) void typeWaiting(address); };
+    everyMailbox();
+    this.turnsSweep = setInterval(everyMailbox, 300_000); this.turnsSweep.unref?.();
     // an agent's verbs (3b-2): its threads, a delegation, its record
     this.agentVerbs = new AgentVerbs({ machine, store: this.mailStore, agents: this.agents, live, supercodeBin: this.supercodeBin, env: this.env,
       paneOf: (session) => this.mail.paneOf(session), mailRoot,
@@ -1053,6 +1099,8 @@ export class TeamsMachine extends MachineCore {
     this.stoppingMailWatch = true;
     this.mailWatch?.kill('SIGTERM');
     void this.relayEndpoint?.then((endpoint) => endpoint?.close()).catch(() => {});
+    this.carrier?.stop();
+    clearInterval(this.turnsSweep);
     this.stoppingServe = true;
     clearTimeout(this.serveRestart);
     // said, so a stop reads as one in the log and never as a serve that broke
@@ -1754,20 +1802,24 @@ export class TeamsMachine extends MachineCore {
     const name = String(params.program ?? '').split(/[\\/]/).pop();
     // Windows has no Unix endpoint for a pane's own native server, so a fresh Codex there starts with no session to
     // type into: its rollout appears only with its first turn. Its first input is therefore Codex's own argv prompt,
-    // as it is on the other platforms, and the receipt is the rollout that records it under CODEX_HOME. A batch
-    // command line cannot carry a line break, so multi-line input keeps the pane and is typed as before.
+    // as it is on the other platforms, and the receipt is the rollout that records it under CODEX_HOME. Input a
+    // command line cannot carry — a line break (a batch line ends there), or past cmd's 8191 characters
+    // (CreateProcess's 32767 for an .exe) — is pasted into the composer once it is up instead
+    // (#typeCodexFirstInput), under the same receipt.
     if (process.platform === 'win32' && params.kind === 'codex' && /^codex(?:\.cmd|\.exe)?$/i.test(name)) {
-      const initialInput = params.initialInput && !/[\r\n\0]/.test(params.initialInput) && !args.includes('--') &&
+      const initialInput = params.initialInput && !args.includes('--') &&
         !args.some((arg) => arg === '--remote' || arg.startsWith('--remote=')) ? params.initialInput : null;
       if (!initialInput) return launchCommand(params.program, args);
+      const typed = /[\r\n\0]/.test(initialInput) || windowsCommandLineLength(params.program, [...args, '--', initialInput]) >
+        (/\.(cmd|bat)$/i.test(params.program) ? 8000 : 32000);
       const codexHome = params.env?.CODEX_HOME || this.env.CODEX_HOME || join(homedir(), '.codex');
       // A resume appends to the rollout it names (`resume <id>`; `--last` names none). A fork writes a new
       // rollout, so its receipt is found as a fresh session's is.
       const verb = args.indexOf('resume');
       const named = verb >= 0 ? args.slice(verb + 1).find((arg) => /^[0-9a-f]{8}-[0-9a-f-]{27}$/i.test(arg)) : null;
       nativeInput({ kind: params.kind, text: initialInput, startedAt: Date.now(), codexSessions: join(codexHome, 'sessions'),
-        cwd: params.cwd || null, continuing: verb >= 0, resumeId: named ?? null });
-      return launchCommand(params.program, [...args, '--', initialInput]);
+        cwd: params.cwd || null, continuing: verb >= 0, resumeId: named ?? null, typed });
+      return launchCommand(params.program, typed ? args : [...args, '--', initialInput]);
     }
     if (process.platform === 'win32' || !((params.kind === 'codex' && name === 'codex') ||
       (params.kind === 'claude-code' && name === 'claude'))) return launchCommand(params.program, args);
@@ -2065,11 +2117,26 @@ export class TeamsMachine extends MachineCore {
   #deliverInitialInput({ key, contextKey, session, kind, by, input, act, nativeInput, executable = {}, resumed = {} }) {
     const abort = new AbortController();
     const task = (async () => {
+      let nativeReadyBy = 'native-prompt';
+      if (nativeInput?.typed) {
+        // A Windows Codex input its command line could not carry: pasted once the composer is up, and confirmed by
+        // the same rollout receipt as an argv prompt. Its pane has no native session to mail yet.
+        nativeReadyBy = await this.#awaitInputReady(session, contextKey, kind, abort.signal);
+        if (nativeReadyBy === 'aborted') return;
+        const typed = nativeReadyBy === 'pane-gone' || nativeReadyBy === 'deadline' ? { delivered: false, reason: nativeReadyBy }
+          : await this.#typeCodexFirstInput(session, input, abort.signal);
+        if (!typed.delivered) {
+          this.launches.record({ key, pane: contextKey, kind, by, ...resumed, ...executable, status: 'ready', inputDelivered: false,
+            inputReadyBy: nativeReadyBy, inputError: typed.reason });
+          act('launch', `pane:${contextKey}`, 'failed', `first input undelivered: ${typed.reason}`);
+          return;
+        }
+      }
       if (nativeInput) {
         const result = await confirmNativeInitialInput(nativeInput, { signal: abort.signal,
           deadlineMs: Date.now() + INITIAL_INPUT_READY_DEADLINE_MS, live: async () => Boolean(await this.#paneByContext(contextKey)) });
         this.launches.record({ key, pane: contextKey, kind, by, ...resumed, ...executable, status: 'ready', inputDelivered: result.delivered,
-          inputReadyBy: 'native-prompt', ...(result.delivered ? { inputReceipt: result.receipt } : { inputError: result.reason }),
+          inputReadyBy: nativeReadyBy, ...(result.delivered ? { inputReceipt: result.receipt } : { inputError: result.reason }),
           ...(result.native_session ? { native_session: result.native_session } : {}) });
         act('launch', `pane:${contextKey}`, result.delivered ? 'ok' : result.queued ? 'input-pending' : 'failed',
           result.delivered ? 'first input confirmed by native user message' : `native first input unconfirmed: ${result.reason}`);
@@ -2211,6 +2278,41 @@ export class TeamsMachine extends MachineCore {
     return filed?.code === 0 ? null : `the line was typed but its sender was not recorded: ${filed?.text ?? 'the filing door answered nothing'}`;
   }
 
+  /**
+   * A fresh Windows Codex's first input, pasted into its empty composer and submitted once: the input its command
+   * line could not carry. Each bracketed paste stays under CODEX_WINDOWS_PASTE_CHARS, and Codex joins consecutive
+   * ones into one entry. Delivery is not claimed here — the caller's rollout receipt confirms what Codex took.
+   */
+  async #typeCodexFirstInput(session, text, signal) {
+    const body = String(text).replace(/\r\n?/g, '\n').replace(/\n+$/u, '');
+    if (!body.trim() || /[\u0000-\u0008\u000b-\u001f\u007f]/u.test(body)) return { delivered: false, reason: 'unsupported-text' };
+    if (this.inputInFlight.has(session.id)) return { delivered: false, reason: 'input-in-flight' };
+    this.inputInFlight.add(session.id);
+    try {
+      const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+      // Styled, so the composer's dim placeholder ("Ask Codex to do anything") reads as empty.
+      const composer = async () => terminal.composerText?.('codex', await this.host.capture(session.id, { preserveEscapes: true })) ?? null;
+      if (await composer() !== '') return { delivered: false, reason: 'composer-not-empty' };
+      for (const paste of codexWindowsPastes(body)) {
+        if (signal.aborted) return { delivered: false, reason: 'aborted' };
+        await this.host.sendInput(session.id, paste, { submitMode: 'none' });
+        await pause(300);
+      }
+      let held = false;
+      for (let attempt = 0; attempt < 20 && !held && !signal.aborted; attempt += 1) {
+        held = Boolean(await composer());
+        if (!held) await pause(150);
+      }
+      if (!held) return { delivered: false, reason: 'paste-unconfirmed' };
+      await this.host.sendInput(session.id, '\r', { submitMode: 'single' });
+      return { delivered: true };
+    } catch (error) {
+      return { delivered: false, reason: error?.message ?? String(error) };
+    } finally {
+      this.inputInFlight.delete(session.id);
+    }
+  }
+
   async #deliverPaneText(session, contextKey, text, options = {}) {
     const kind = this.#paneKind(contextKey, session);
     if (kind === 'codex' && codexUpdatePrompt(await this.host.capture(session.id, { lines: 120 }))) return { delivered: false, reason: 'codex-update-prompt: delivery refused; restart Codex with check_for_update_on_startup=false' };

package/mail/carrier.mjs

@@ -0,0 +1,311 @@
+// The mailbox's own delivery (D140; docs/architecture/overview.md, step 4b): every message filed with a wake (by a filer
+// that does not wait, a board's dispatcher, a send to a hooked session) is handed to its session by the session's own
+// door, by this daemon. Mail for another machine is carried there through its mail door and filed with the same wake,
+// so that machine's daemon delivers it. The native watch did this by reading every mailbox every two seconds
+// (mail_watch.rs `MailCarrier`); here a wake is followed from its own file event (one read of the mail folder at start),
+// and each is attempted when it is due. Its rules and its records are the native carrier's, file for file:
+// - a failed attempt waits FIRST_RETRY_MS doubling to LAST_RETRY_MS, kept in the wake itself (`wake/<id>`);
+// - a wake expires once it has failed WAKE_ATTEMPTS counted times and its first counted failure is older than its bound
+//   (LOCAL_WAKE_LIFETIME_MS here, REMOTE_WAKE_LIFETIME_MS for another machine): the message stays filed and unread, and
+//   the expiry is recorded in its mailbox (`expired/<id>.json`, read by `supercode message expired`);
+// - mail for a machine that is offline is not failing: the machine is probed once per LAST_RETRY_MS (its wait kept once
+//   per machine, `machines/<machine>.json`, read by `supercode message waiting`), all its mail is carried when it
+//   answers, and the mail expires only past OFFLINE_CEILING_MS;
+// - a hand-over is waited for at most HANDOVER_BOUND_MS, and one mailbox's attempt never waits on another's;
+// - each attempt is a line of `carrier.jsonl`.
+import { appendFileSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { render } from './envelope.mjs';
+
+const FIRST_RETRY_MS = 2_000;
+const LAST_RETRY_MS = 300_000;
+const WAKE_ATTEMPTS = 8;
+const LOCAL_WAKE_LIFETIME_MS = 30 * 60_000;
+const REMOTE_WAKE_LIFETIME_MS = 3 * 24 * 60 * 60_000;
+const OFFLINE_CEILING_MS = 30 * 24 * 60 * 60_000;
+// a hand-over is waited for this long (mail_watch.rs HANDOVER_BOUND); one still running past it is attempted again later,
+// and the hand-over itself answers 'later' until it settles (MailSend.handOver), so a frozen door holds only its own
+// mailbox's wakes, and only for this long
+const HANDOVER_BOUND_MS = 150_000;
+
+const readJson = (path) => { try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; } };
+const offline = (text) => String(text).includes('machine_offline');
+const safeMachine = (machine) => String(machine).replace(/[^A-Za-z0-9._-]/g, '_');
+
+export class MailCarrier {
+  /**
+   * `store` the mail store (its events name each wake); `live` the live-session map (a hooked session's pane);
+   * `handOver(address, id)` the daemon's hand-over of a filed message to its session's door (mail/send.mjs);
+   * `typeTurn(pane, harness, text, ids)` a wake typed into a hooked session's pane; `askMachine(machine, request)` one
+   * request to another machine's mail door.
+   */
+  constructor({ machine, mailRoot, store, live, handOver, typeTurn, askMachine, log = () => {} }) {
+    Object.assign(this, { machine, mailRoot, store, live, handOver, typeTurn, askMachine, log });
+    this.timers = new Map(); // `${folder}\0${id}` → timer of a wake here, due
+    this.running = new Set(); // mailbox folders with an attempt in flight
+    this.machines = new Map(); // machine → timer of its next carry
+    this.carrying = new Set(); // machines with a carry in flight
+    this.remote = new Map(); // machine → Map(`${folder}\0${id}` → { folder, address, id }): wakes for another machine
+  }
+
+  /** Follow every wake: those filed before this daemon (one read of the mail folder), each as the store names it (its
+   *  file's event, or a mailbox the store read whole), and every wake again once per LAST_RETRY_MS, so a wake no event
+   *  named is carried within that bound. */
+  start() {
+    this.store.on('wake', ({ folder, id }) => this.#wake(folder, id));
+    this.#sweep();
+    this.sweeper = setInterval(() => this.#sweep(), LAST_RETRY_MS);
+    this.sweeper.unref?.();
+    return this;
+  }
+
+  /** Every mailbox's wakes read from its folder and followed (one already due or scheduled is not scheduled twice). */
+  #sweep() {
+    let folders = [];
+    try { folders = readdirSync(this.mailRoot); } catch { return; }
+    for (const folder of folders) this.#rewake(folder);
+  }
+
+  stop() { clearInterval(this.sweeper); for (const timer of [...this.timers.values(), ...this.machines.values()]) clearTimeout(timer); this.timers.clear(); this.machines.clear(); }
+
+  #address(folder) { try { return readFileSync(join(this.mailRoot, folder, 'address'), 'utf8').trim(); } catch { return null; } }
+
+  /** A wake seen (its file written or changed): attempted when it is due. */
+  #wake(folder, id) {
+    if (!/^[A-Za-z0-9_-]+$/.test(id)) return;
+    const address = this.#address(folder);
+    if (!address) return;
+    const machine = address.split(':')[1];
+    if (machine !== this.machine) {
+      if (!this.remote.has(machine)) this.remote.set(machine, new Map());
+      this.remote.get(machine).set(`${folder}\0${id}`, { folder, address, id });
+      this.#scheduleMachine(machine);
+      return;
+    }
+    const key = `${folder}\0${id}`;
+    if (this.timers.has(key)) return;
+    const state = this.store.wakeState(address, id);
+    const timer = setTimeout(() => { this.timers.delete(key); void this.#local(folder, address); }, Math.max(0, (state.next_at_ms ?? 0) - Date.now()));
+    timer.unref?.();
+    this.timers.set(key, timer);
+  }
+
+  /** The wakes of one mailbox here that are due, attempted (mail_watch.rs `tick`, its local half). */
+  async #local(folder, address) {
+    if (this.running.has(folder)) { setTimeout(() => this.#rewake(folder), 1000).unref?.(); return; }
+    this.running.add(folder);
+    try {
+      const now = Date.now();
+      const due = this.#pending(folder, address).filter((id) => (this.store.wakeState(address, id).next_at_ms ?? 0) <= now);
+      if (!due.length) return;
+      // a session in a daemon pane whose mail is typed there: a hooked one (its hook shows it the rest), and one with no
+      // hook and no relay (Grok), whose mail that found its composer busy waits here until it is free
+      const session = this.live.sessions().find((row) => row.address === address);
+      if ((session?.door === 'hook' || session?.door === 'pane') && session.pane) {
+        for (const id of due) {
+          const stored = this.store.findIn(address, id);
+          const envelope = stored ? readJson(stored.path) : null;
+          let carried;
+          if (!envelope) carried = { kind: 'filed' };
+          else {
+            try {
+              const typed = await this.typeTurn(session.pane, address.split(':')[2], render(envelope), [id]);
+              // held: the daemon's queue for the session types it once the composer frees; nothing asks it again
+              carried = typed?.delivered ? { kind: 'delivered' } : typed?.queued ? { kind: 'filed' } : { kind: 'later', reason: 'its pane was not at its prompt' };
+            } catch (error) { carried = { kind: 'later', reason: error.message }; }
+          }
+          this.#record({ to: address, id, path: `${session.door}-pane`, carried });
+          this.#settle(folder, address, id, carried);
+        }
+        return;
+      }
+      for (const id of due) {
+        const found = this.store.findIn(address, id);
+        let carried;
+        // its recipient has it already (its own read, or a hand-over by an attempt that ended before it was settled):
+        // never delivered twice; a read by anyone else does not count
+        if (!found || (found.state === 'read' && this.store.claimOf(address, id)?.recipient === true)) carried = { kind: 'filed' };
+        else {
+          try {
+            let bound;
+            const answer = await Promise.race([
+              this.handOver(address, id),
+              new Promise((settle) => { bound = setTimeout(() => settle({ outcome: 'later', detail: `its hand-over was still running after ${HANDOVER_BOUND_MS / 1000} s` }), HANDOVER_BOUND_MS); bound.unref?.(); }),
+            ]).finally(() => clearTimeout(bound));
+            carried = answer?.outcome === 'delivered' ? { kind: 'delivered' } : answer?.outcome === 'filed' ? { kind: 'filed' } : { kind: 'later', reason: answer?.detail ?? 'not handed over' };
+          } catch (error) { carried = { kind: 'later', reason: `this machine's daemon did not hand it over: ${error.message}` }; }
+        }
+        this.#record({ to: address, id, path: 'door', carried });
+        this.#settle(folder, address, id, carried);
+      }
+    } finally {
+      this.running.delete(folder);
+      this.#rewake(folder);
+    }
+  }
+
+  /** A mailbox's wakes followed again (each one scheduled at its own due time). */
+  #rewake(folder) {
+    let ids = [];
+    try { ids = readdirSync(join(this.mailRoot, folder, 'wake')); } catch { return; }
+    for (const id of ids) this.#wake(folder, id);
+  }
+
+  /** A mailbox's wakes whose message is still filed; a wake whose message is gone is let go (mailbox.rs `pending_wakes`). */
+  #pending(folder, address) {
+    let ids = [];
+    try { ids = readdirSync(join(this.mailRoot, folder, 'wake')); } catch { return []; }
+    return ids.filter((id) => {
+      if (this.store.findIn(address, id)) return true;
+      try { rmSync(join(this.mailRoot, folder, 'wake', id), { force: true }); } catch { /* gone */ }
+      return false;
+    });
+  }
+
+  // ---- another machine's mail ------------------------------------------------------------------------------------
+
+  #machineWaitPath(machine) { return join(this.mailRoot, 'machines', `${safeMachine(machine)}.json`); }
+
+  /** A machine's mail carried at its next due time: its wait's next probe when it is offline, else its earliest wake. */
+  #scheduleMachine(machine) {
+    if (this.machines.has(machine) || this.carrying.has(machine)) return;
+    const wait = readJson(this.#machineWaitPath(machine));
+    let at = wait?.next_probe_ms ?? null;
+    if (at == null) {
+      at = Infinity;
+      for (const { address, id } of this.#remoteWakes(machine)) at = Math.min(at, this.store.wakeState(address, id).next_at_ms ?? 0);
+      if (!Number.isFinite(at)) return;
+    }
+    const timer = setTimeout(() => { this.machines.delete(machine); void this.#carry(machine); }, Math.max(0, at - Date.now()));
+    timer.unref?.();
+    this.machines.set(machine, timer);
+  }
+
+  /** Every wake filed here for `machine` (as their events named them), with when its message was filed, oldest first; a
+   *  wake whose file or message is gone is let go. */
+  #remoteWakes(machine) {
+    const items = [];
+    for (const [key, item] of this.remote.get(machine) ?? []) {
+      let present = true;
+      try { readFileSync(join(this.mailRoot, item.folder, 'wake', item.id)); } catch { present = false; }
+      const found = present ? this.store.findIn(item.address, item.id) : null;
+      if (!found) { this.remote.get(machine).delete(key); if (present) { try { rmSync(join(this.mailRoot, item.folder, 'wake', item.id), { force: true }); } catch { /* gone */ } } continue; }
+      const envelope = readJson(found.path);
+      items.push({ ...item, filed: Number(envelope?.created_at_ms) || 0 });
+    }
+    return items.sort((a, b) => a.filed - b.filed);
+  }
+
+  /** One machine's mail carried (mail_watch.rs `tick`, its remote half): its oldest due message probes the machine, and
+   *  when it answers, the rest follow in this pass. */
+  async #carry(machine) {
+    this.carrying.add(machine);
+    try {
+      const now = Date.now();
+      const items = this.#remoteWakes(machine);
+      if (!items.length) return;
+      const wait = readJson(this.#machineWaitPath(machine));
+      if (wait) {
+        // a machine away longer than the ceiling is not coming back for this mail: it expires, saying so
+        if (now - (wait.offline_since_ms ?? now) >= OFFLINE_CEILING_MS) {
+          const reason = `${machine} has been offline for ${OFFLINE_CEILING_MS / 86_400_000} days (since epoch ms ${wait.offline_since_ms}): ${wait.last_error ?? 'not linked'}`;
+          for (const item of items) this.#expire(item.folder, item.address, item.id, this.store.wakeState(item.address, item.id).attempts ?? 0, reason);
+          this.#setMachineWait(machine, null);
+          this.#line({ t: now, machine, outcome: 'expired', messages: items.length, reason });
+          return;
+        }
+        if ((wait.next_probe_ms ?? 0) > now) return;
+      }
+      let carriedHere = 0, offlineAnswer = null, called = false;
+      for (const item of items) {
+        if (!wait && (this.store.wakeState(item.address, item.id).next_at_ms ?? 0) > now) continue;
+        const found = this.store.findIn(item.address, item.id);
+        let carried;
+        // carried already (this carrier's own record): never carried twice
+        if (!found || (found.state === 'read' && this.store.claimOf(item.address, item.id)?.recipient === true)) carried = { kind: 'filed' };
+        else {
+          called = true;
+          carried = await this.#carryOne(machine, item.address, readJson(found.path));
+        }
+        if (carried.kind === 'offline') { offlineAnswer = carried.reason; break; }
+        carriedHere++;
+        this.#settle(item.folder, item.address, item.id, carried);
+      }
+      if (called) this.#line({ t: now, machine, outcome: offlineAnswer ? 'offline' : 'carried', waiting: items.length, carried: carriedHere, reason: offlineAnswer });
+      if (offlineAnswer) this.#setMachineWait(machine, { machine, offline_since_ms: wait?.offline_since_ms ?? now, next_probe_ms: now + LAST_RETRY_MS, probes: (wait?.probes ?? 0) + 1, last_error: offlineAnswer });
+      else if (called) this.#setMachineWait(machine, null);
+    } finally {
+      this.carrying.delete(machine);
+      this.#scheduleMachine(machine);
+    }
+  }
+
+  /** One message carried to its machine's mail door, filed there with a wake. */
+  async #carryOne(machine, to, envelope) {
+    if (!envelope) return { kind: 'filed' };
+    try {
+      const answer = await this.askMachine(machine, { op: 'file', to, envelope, wake: true });
+      if (answer?.code === 0) return { kind: 'delivered' };
+      const reason = `${machine} did not take it: ${answer?.text ?? answer?.detail ?? 'no reason given'}`;
+      return offline(JSON.stringify(answer)) ? { kind: 'offline', reason } : { kind: 'later', reason };
+    } catch (error) {
+      return offline(error.code ?? error.message) || offline(error.message)
+        ? { kind: 'offline', reason: `${machine} is offline: ${error.message}` }
+        : { kind: 'later', reason: `its mail door did not carry it to ${machine}: ${error.message}` };
+    }
+  }
+
+  #setMachineWait(machine, wait) {
+    const path = this.#machineWaitPath(machine);
+    if (!wait) { try { rmSync(path, { force: true }); } catch { /* gone */ } return; }
+    try { mkdirSync(join(this.mailRoot, 'machines'), { recursive: true }); writeFileSync(`${path}.tmp`, JSON.stringify(wait)); renameSync(`${path}.tmp`, path); }
+    catch (error) { this.log(`carrier: ${machine}'s wait was not kept: ${error.message}`); }
+  }
+
+  // ---- how an attempt went ---------------------------------------------------------------------------------------
+
+  /** Record how a wake went: done, waiting for its next attempt, or expired at its bound (mail_watch.rs `settle`). */
+  #settle(folder, address, id, carried) {
+    const wakePath = join(this.mailRoot, folder, 'wake', id);
+    if (carried.kind === 'delivered' || carried.kind === 'filed') {
+      if (carried.kind === 'delivered') {
+        // the carrier's own hand-off record: delivered here by its door, or carried to its machine
+        try { this.store.claimFor(address, id, { pid: process.pid, via: 'carrier', caller: null, recipient: true, at_ms: Date.now() }); } catch { /* best kept */ }
+        const found = this.store.findIn(address, id);
+        if (found && found.state !== 'read') { try { this.store.markRead(address, found.path); } catch { /* read already */ } }
+      }
+      try { rmSync(wakePath, { force: true }); } catch { /* gone */ }
+      return;
+    }
+    if (carried.kind === 'offline') return;
+    const now = Date.now();
+    const state = this.store.wakeState(address, id);
+    const attempts = (state.attempts ?? 0) + 1;
+    const since = state.failing_since_ms ?? now;
+    const lifetime = address.split(':')[1] === this.machine ? LOCAL_WAKE_LIFETIME_MS : REMOTE_WAKE_LIFETIME_MS;
+    if (attempts >= WAKE_ATTEMPTS && now - since >= lifetime) { this.#expire(folder, address, id, attempts, carried.reason); return; }
+    const wait = Math.min(LAST_RETRY_MS, FIRST_RETRY_MS * 2 ** Math.min(attempts - 1, 16));
+    this.store.setWakeState(address, id, { ...state, attempts, failing_since_ms: since, next_at_ms: now + wait, last_error: carried.reason });
+  }
+
+  /** End a wake undelivered: the message stays filed and unread, and the expiry is recorded in its mailbox. */
+  #expire(folder, address, id, attempts, reason) {
+    const found = this.store.findIn(address, id);
+    const envelope = found ? readJson(found.path) : null;
+    const expiry = { id, to: address, from: envelope?.from ?? '', subject: envelope?.subject ?? null, filed_at_ms: Number(envelope?.created_at_ms) || 0, expired_at_ms: Date.now(), attempts, reason };
+    try {
+      mkdirSync(join(this.mailRoot, folder, 'expired'), { recursive: true });
+      const temporary = join(this.mailRoot, folder, 'tmp', `expired.${id}`);
+      writeFileSync(temporary, JSON.stringify(expiry));
+      renameSync(temporary, join(this.mailRoot, folder, 'expired', `${id}.json`));
+      rmSync(join(this.mailRoot, folder, 'wake', id), { force: true });
+    } catch (error) { this.log(`carrier: the expiry of ${id} was not recorded: ${error.message}`); }
+  }
+
+  /** One local delivery attempt in the carrier's record (`carrier.jsonl`). */
+  #record({ to, id, path, carried }) {
+    this.#line({ t: Date.now(), to, id, path, outcome: carried.kind, reason: carried.reason ?? null });
+  }
+
+  #line(line) { try { appendFileSync(join(this.mailRoot, 'carrier.jsonl'), `${JSON.stringify(line)}\n`); } catch { /* the record is best kept */ } }
+}

package/mail/send.mjs

@@ -353,7 +353,9 @@ export class MailSend {
       if (typed?.delivered) { this.store.deliverRead(to, sent); delivered = 'typed'; }
       // held by the daemon's queue for the pane, typed once its composer frees: not typed yet, so kept unread
       else if (typed?.queued) { this.store.deliver(to, sent); delivered = 'pane_held'; }
-      else { this.store.deliver(to, sent); delivered = wake ? 'pane_waits' : 'queued'; }
+      // not typed (its composer held a draft or a turn ran): it waits unread with a wake, so the carrier types it once the
+      // composer is empty (mail/carrier.mjs), never left for a read a session with no hook never makes
+      else { this.store.deliver(to, sent); if (wake) this.store.requestWake(to, sent.id); delivered = wake ? 'pane_waits' : 'queued'; }
     } else if (door.kind === 'stored') { this.store.deliver(to, sent); delivered = 'stored'; }
     else { this.store.deliver(to, sent); delivered = 'operator'; }
     // a hand-over to the recipient's own door is its delivery, recorded as such

package/mail/store.mjs

@@ -68,6 +68,8 @@ export class MailStore extends EventEmitter {
     const [folder, part, file] = name.split(/[\\/]/);
     if (!folder) return;
     if (!part) return this.#readBox(folder);
+    // a wake written or changed: the carrier's (mail/carrier.mjs) to attempt
+    if (part === 'wake' && file) { this.emit('wake', { folder, id: file }); return; }
     if (!STATES[part] || !file) { if (part === 'address') this.#readBox(folder); return; }
     if (!this.boxes.has(folder)) return this.#readBox(folder);
     this.#readFile(folder, part, file);
@@ -103,6 +105,11 @@ export class MailStore extends EventEmitter {
       for (const file of files) this.#take(box, part, file);
     }
     this.emit('changed', address);
+    // every wake the mailbox holds, read with it: a mailbox read whole (at start, or on a rescan once a lost watch is back)
+    // names each one to the carrier, so a wake written while no event could say so is carried all the same
+    let wakes = [];
+    try { wakes = readdirSync(join(box.dir, 'wake')); } catch { /* none */ }
+    for (const id of wakes) this.emit('wake', { folder, id });
   }
 
   /** One envelope file read again on its event: held while it is there, let go once it is gone. */

package/native-initial-input.mjs

@@ -7,6 +7,9 @@ import { codexQuestions } from './native-questions.mjs';
 
 const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
+/** Input as a composer takes it: line ends as `\n`, without the outer whitespace a submit trims. */
+const normalizedInput = (text) => String(text).replace(/\r\n?/g, '\n').trim();
+
 /** Rollouts one daemon's launches have already taken as their receipt, with when: a launch that began before a
  *  claim does not answer from that transcript, while a later launch (a resume of the same session) still can, since
  *  its receipt must be newer than it anyway. This orders launches; it does not prove ownership — two panes in one
@@ -100,7 +103,10 @@ export async function confirmNativeInitialInput({ binding, kind, text, startedAt
               content.every((part) => ['text', 'input_text'].includes(part.type)) ? content.map((part) => part.text).join('') : null;
             // The transcript that confirms the input also names the session it belongs to: the launch records it,
             // so a session can be told apart as one an agent launched (Claude Code's sessionId; Codex's rollout id).
-            if (value === text) {
+            // A Windows Codex input may have been pasted: its line ends normalized and trailing newlines dropped.
+            const same = codexSessions && typeof value === 'string'
+              ? normalizedInput(value) === normalizedInput(text) : value === text;
+            if (same) {
               const native = kind === 'claude-code' ? record.sessionId : /([0-9a-f]{8}-[0-9a-f-]{27})\.jsonl$/.exec(entry.path)?.[1];
               if (codexSessions) claimedRollouts.set(entry.path, Date.now());
               return { delivered: true, receipt: 'native-user-message', ...(typeof native === 'string' && native ? { native_session: native } : {}) };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.105",
+  "version": "0.3.107",
   "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

@@ -5,7 +5,7 @@ import { join } from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import { StringDecoder } from 'node:string_decoder';
-import { codexUpdatePrompt } from './codex-startup.mjs';
+import { codexUpdatePrompt, codexWindowsPastes } from './codex-startup.mjs';
 
 // When process `pid` started (ms), from `ps -o etime=` ([[dd-]hh:]mm:ss); null when it cannot be read.
 function startedAt(pid) {
@@ -154,8 +154,14 @@ export class TerminalMailbox {
       // it never guesses that an unacknowledged paste did not happen.
       Object.assign(batch, { phase: 'paste_started', terminal: this.session.id, pid: this.session.rootPid ?? null, pasted_at: Date.now() }); this.save();
       // The terminal host's final newline selects one bracketed paste;
-      // submitMode:none holds the separate Enter until the paste completes.
-      await this.host.sendInput(this.session.id, `${batch.text}\n`, { submitMode: 'none' });
+      // submitMode:none holds the separate Enter until the paste completes. A Windows Codex takes its own pastes:
+      // at most 8000 characters each, non-ASCII as key events (codex-startup.mjs codexWindowsPastes).
+      if (process.platform === 'win32' && batch.kind === 'codex') {
+        for (const paste of codexWindowsPastes(batch.text)) {
+          await this.host.sendInput(this.session.id, paste, { submitMode: 'none' });
+          await new Promise((resolve) => setTimeout(resolve, 300));
+        }
+      } else await this.host.sendInput(this.session.id, `${batch.text}\n`, { submitMode: 'none' });
       batch.phase = 'pasted'; this.save();
     }
     if (batch.phase === 'paste_started') {