@volter/supercode-teams 0.3.137 → 0.3.139

package/connector/index.mjs

@@ -1,4 +1,5 @@
-import { mkdirSync, readFileSync, writeFileSync, renameSync, existsSync, chmodSync, realpathSync, statSync, openSync, closeSync, fsyncSync, unlinkSync, readSync, readdirSync, rmSync } from 'node:fs';
+import { mkdirSync, readFileSync, writeFileSync, renameSync, existsSync, chmodSync, statSync, openSync, closeSync, fsyncSync, unlinkSync, readSync, readdirSync, rmSync } from 'node:fs';
+import { realpathSync } from './path.mjs';
 import { redactionBasis } from '@volter/teams/redact';
 import { Redactor } from './redactor.mjs';
 import { basename, dirname, join, sep } from 'node:path';

package/connector/native-effects.mjs

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync, statSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, statSync } from 'node:fs';
+import { realpathSync } from './path.mjs';
 import { join, resolve, relative, dirname, isAbsolute, sep } from 'node:path';
 
 const digest = value => createHash('sha256').update(value).digest('hex');

package/connector/path.mjs

@@ -0,0 +1,9 @@
+import { realpathSync as nodeRealpathSync } from 'node:fs';
+
+// Rust discovery returns Windows namespace paths (\\?\C:\...). Node's JS
+// resolver tries to lstat the drive component as "C:" and refuses those paths.
+// The OS-native resolver accepts them and preserves filesystem resolution,
+// including junctions and UNC paths. Keep the existing POSIX resolver.
+export const realpathSync = process.platform === 'win32'
+  ? nodeRealpathSync.native
+  : nodeRealpathSync;

package/machine.mjs

@@ -1957,7 +1957,7 @@ export class TeamsMachine extends MachineCore {
   // app-server process boundary. Process ancestry alone cannot recover it.
   #nativeQuestionCommand(params, pane, by, nativeInput) {
     if (params.env?.SUPERCODE_BOARD_PROCESS_GUARD === '1' && process.platform === 'win32') throw new Error('board process guard is unavailable on Windows; no unguarded session was launched');
-    const args = boardGuardArguments(params.kind,params.arguments ?? [],{cwd:params.cwd,enabled:params.env?.SUPERCODE_BOARD_PROCESS_GUARD === '1'});
+    let args = boardGuardArguments(params.kind,params.arguments ?? [],{cwd:params.cwd,enabled:params.env?.SUPERCODE_BOARD_PROCESS_GUARD === '1'});
     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,
@@ -1980,37 +1980,55 @@ export class TeamsMachine extends MachineCore {
         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);
+    const claude = params.kind === 'claude-code' && /^claude(?:\.cmd|\.exe)?$/i.test(name);
+    if ((process.platform === 'win32' && !claude) || !((params.kind === 'codex' && name === 'codex') || claude)) return launchCommand(params.program, args);
+    if (claude && params.initialInput) {
+      const delimiter = args.indexOf('--');
+      if (delimiter >= 0) {
+        if (delimiter !== args.length - 1) throw Object.assign(new Error('Claude first input conflicts with a prompt already supplied after --; provide one prompt'), { code: 400 });
+        args = args.slice(0, delimiter);
+      }
+    }
     // the hook is the front door's (mail step 1b): taken when the machine's stable supercode serves it
     this.nativeQuestionHooksSupported ??= this.#frontDoorServes('message native-question-hook');
-    if (!this.nativeQuestionHooksSupported) return launchCommand(params.program, args);
+    if (!this.nativeQuestionHooksSupported) {
+      if (claude && params.initialInput) throw Object.assign(new Error('Claude first input requires the native SessionStart receipt hook; this front door does not serve it'), { code: 503 });
+      return launchCommand(params.program, args);
+    }
     const mailHome = this.env.SUPERCODE_HOME || join(this.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'supercode');
     const dir = join(mailHome, 'mail', 'native-launches');
     mkdirSync(dir, { recursive: true, mode: 0o700 });
     // A reused pane key still gets a new receipt baseline. A late hook from
     // its previous process cannot publish evidence for this launch.
     const binding = join(dir, `${pane}-${randomBytes(9).toString('base64url')}.json`);
-    // Claude records an argv prompt verbatim when it runs at once, but trimmed
-    // when it queues behind work restored on resume (a pending task
-    // notification). Sending the trimmed text makes both records equal it.
+    // Claude's first input uses the same retained composer delivery as later
+    // mail. It never travels in a shell command line, including on Windows.
     const prompt = params.kind === 'claude-code' && typeof params.initialInput === 'string' ? params.initialInput.trim() : params.initialInput;
-    const initialInput = prompt && !args.includes('--') &&
+    const initialInput = !claude && prompt && !args.includes('--') &&
       !args.some((arg) => arg === '--remote' || arg.startsWith('--remote=')) ? prompt : null;
-    writeFileSync(binding, JSON.stringify({ kind: params.kind, pane, by, program: params.program, arguments: args, initialInput }), { mode: 0o600 });
-    if (initialInput) nativeInput({ binding, kind: params.kind, text: initialInput, startedAt: Date.now() });
-    const claudeCommand = (next) => launchCommand(params.program, initialInput ? [...next, '--', initialInput] : next);
-    const quote = (value) => `'${String(value).replaceAll("'", "'\\''")}'`;
-    // the machine's stable supercode: the session outlives this daemon's install path (an upgrade or a move)
-    const command = `env SUPERCODE_HOME=${quote(mailHome)} ${quote(this.#stableSupercode())} message native-question-hook ${quote(binding)}`;
-    const handler = { type: 'command', command, timeout: 3600 };
+    const claudeInput = claude && prompt ? { kind: params.kind, text: prompt, startedAt: Date.now(),
+      deadlineMs: Date.now() + INITIAL_INPUT_READY_DEADLINE_MS + 10_000, typed: true } : null;
+    writeFileSync(binding, JSON.stringify({ key: params.key, kind: params.kind, pane, by, program: params.program, arguments: args, initialInput, claudeInput }), { mode: 0o600 });
+    // The first input is durable before createSession can start the program.
+    // Its body stays in the private binding, never in the launch journal.
+    if (claudeInput) {
+      this.launches.record({ ...this.launches.find(params.key), nativeInputBinding: binding });
+      nativeInput({ ...claudeInput, binding });
+    }
+    else if (initialInput) nativeInput({ binding, kind: params.kind, text: initialInput, startedAt: Date.now() });
     if (params.kind === 'claude-code') {
+      // Claude's exec-form hook passes each argument unchanged on all platforms.
+      // A Windows .cmd shim is resolved to its Node executable and front door.
+      const stable = this.#stableSupercode();
+      const direct = /\.(cmd|bat)$/i.test(stable) ? shimTarget(stable) : [stable];
+      if (!direct) throw Object.assign(new Error('the stable supercode shim has no executable native hook target'), { code: 503 });
+      const handler = { type: 'command', command: direct[0], args: [...direct.slice(1), 'message', 'native-question-hook', binding, '--home', mailHome], timeout: 3600 };
       const hooks = { SessionStart: [{ hooks: [handler] }], PreToolUse: [{ matcher: 'AskUserQuestion', hooks: [handler] }], PostToolUse: [{ matcher: 'AskUserQuestion', hooks: [handler] }] };
       // Claude accepts only one settings value. Preserve an existing inline
       // object or file, including its hook arrays, in that same argument.
       const next = [...args];
       const at = next.findIndex((arg) => arg === '--settings' || arg.startsWith('--settings='));
-      if (at < 0) return claudeCommand([...next, '--settings', JSON.stringify({ hooks })]);
+      if (at < 0) return launchCommand(params.program, [...next, '--settings', JSON.stringify({ hooks })]);
       const inline = next[at].startsWith('--settings=');
       const value = inline ? next[at].slice('--settings='.length) : next[at + 1];
       const settings = JSON.parse(value?.trimStart().startsWith('{') ? value : readFileSync(resolve(params.cwd || process.cwd(), value), 'utf8'));
@@ -2018,7 +2036,7 @@ export class TeamsMachine extends MachineCore {
       settings.hooks ??= {};
       for (const [event, groups] of Object.entries(hooks)) settings.hooks[event] = [...(settings.hooks[event] ?? []), ...groups];
       next.splice(at, inline ? 1 : 2, '--settings', JSON.stringify(settings));
-      return claudeCommand(next);
+      return launchCommand(params.program, next);
     }
     // The stock TUI's default embedded server has no attachable question
     // door. Give this pane its own native server, through Codex's --remote
@@ -2368,9 +2386,24 @@ export class TeamsMachine extends MachineCore {
    * where an unhandled rejection would take the daemon down over one pane.
    */
   #deliverInitialInput({ key, contextKey, session, kind, by, input, act, nativeInput, executable = {}, resumed = {} }) {
+    if (this.pendingInitialInputs.has(key)) return;
     const abort = new AbortController();
     const task = (async () => {
       let nativeReadyBy = 'native-prompt';
+      if (nativeInput?.typed && kind === 'claude-code') {
+        nativeReadyBy = await this.#awaitInputReady(session, contextKey, kind, abort.signal, nativeInput.deadlineMs);
+        if (nativeReadyBy === 'aborted') return;
+        const result = nativeReadyBy === 'pane-gone' || nativeReadyBy === 'deadline'
+          ? { delivered: false, refused: true, reason: nativeReadyBy }
+          : await this.#deliverClaudeInitialInput(session, contextKey, nativeInput, abort.signal);
+        this.launches.record({ key, pane: contextKey, kind, by, ...resumed, ...executable, status: 'ready', inputDelivered: result.delivered,
+          inputReadyBy: nativeReadyBy, ...(result.delivered ? { inputReceipt: result.receipt } : { inputError: result.reason }),
+          inputRefused: result.refused === true, inputPending: result.queued === true,
+          ...(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' : `first input unconfirmed: ${result.reason}`);
+        return;
+      }
       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.
@@ -2417,20 +2450,77 @@ export class TeamsMachine extends MachineCore {
     this.pendingInitialInputs.set(key, { abort, task });
   }
 
+  async #deliverClaudeInitialInput(session, contextKey, input, signal) {
+    const deadline = input.deadlineMs ?? Date.now() + INITIAL_INPUT_READY_DEADLINE_MS + 10_000;
+    const pause = () => new Promise(resolve => setTimeout(resolve, 250));
+    let identity;
+    while (!signal.aborted && Date.now() < deadline) {
+      if ((await this.#paneByContext(contextKey))?.id !== session.id) return { delivered: false, reason: 'pane-gone' };
+      const start = readJson(input.binding.replace(/\.json$/, '.session.json'));
+      const id = /([0-9a-f]{8}-[0-9a-f-]{27})\.jsonl$/i.exec(String(start?.path ?? ''))?.[1];
+      if (id && Number.isSafeInteger(start.offset) && start.offset >= 0) {
+        identity = { kind: 'claude-code', path: start.path, sessionId: id, offset: start.offset };
+        break;
+      }
+      await pause();
+    }
+    if (!identity) return { delivered: false, refused: !signal.aborted, reason: signal.aborted ? 'aborted' : 'native-session-unresolved' };
+    const options = { messageIds: [`first-${basename(input.binding, '.json')}`], deadlineMs: deadline };
+    let result;
+    while (!signal.aborted && Date.now() < deadline) {
+      if ((await this.#paneByContext(contextKey))?.id !== session.id) return { delivered: false, queued: Boolean(result?.queued), reason: 'pane-gone' };
+      result = await this.#terminalMail(session, contextKey, identity.kind, input.text, options, identity);
+      if (result.delivered || result.refused) return { ...result, native_session: identity.sessionId };
+      await pause();
+    }
+    return { ...result, delivered: false, refused: !signal.aborted && !result?.queued,
+      reason: signal.aborted ? 'aborted' : result?.reason ?? 'native-input-unconfirmed' };
+  }
+
+  /** Recover only the current launch's saved first input; the stable id joins
+   * any queue already retained before this daemon ended. */
+  #recoverClaudeInitialInputs(panes, onlyKey = null) {
+    for (const launch of this.launches.all()) {
+      if ((onlyKey && launch.key !== onlyKey) || launch.kind !== 'claude-code' || !launch.nativeInputBinding ||
+        launch.inputDelivered || launch.inputRefused || this.pendingInitialInputs.has(launch.key) ||
+        !['issued', 'ready'].includes(launch.status)) continue;
+      const seed = readJson(launch.nativeInputBinding);
+      if (seed?.key !== launch.key || seed.pane !== launch.pane || seed.by !== launch.by || !seed.claudeInput?.text) continue;
+      const session = panes.find(row => row.contextKey === launch.pane && !row.dead);
+      if (!session) {
+        this.launches.record({ ...launch, inputDelivered: false, inputRefused: true, inputPending: false, inputError: 'pane-gone' });
+        continue;
+      }
+      const { t: _previousAt, ...facts } = launch;
+      this.#deliverInitialInput({ key: launch.key, contextKey: launch.pane, session, kind: launch.kind, by: launch.by,
+        input: seed.claudeInput.text, nativeInput: { ...seed.claudeInput, binding: launch.nativeInputBinding },
+        executable: { ...facts, nativeInputBinding: launch.nativeInputBinding },
+        act: (cap, target, outcome, detail) => this.log.append({ principal: null, cap, target, outcome, detail }) });
+    }
+  }
+
   async #drainTerminalMail() {
     // One pane listing per tick, shared by every mailbox: a listing per mailbox each second was most of this
     // daemon's tmux spawns (8 retained mailboxes, about 70 tmux processes a second, t_23e47b73).
     const retained = retainedTerminalMail(this.terminalMailRoot);
-    if (!retained.length && !this.terminalMailboxes.size) return;
+    if (this.initialInputsRecovered && !retained.length && !this.terminalMailboxes.size) return;
     const panes = await this.host.listSessions();
+    if (!this.initialInputsRecovered) {
+      this.initialInputsRecovered = true;
+      this.#recoverClaudeInitialInputs(panes);
+    }
     const paneByContext = (contextKey) => panes.find((s) => s.contextKey === contextKey) ?? null;
     for (const saved of retained) {
       if (this.terminalMailboxes.has(saved.recipient) || !saved.binding) continue;
       const session = paneByContext(saved.binding.context);
-      if (!session || session.id !== saved.binding.terminal || session.rootPid !== saved.binding.pid) continue;
-      const queue = new TerminalMailbox(this.terminalMailRoot, saved.recipient, receipt => this.log.append({ principal: null, cap: 'control',
-        target: `pane:${saved.binding.context}`, outcome: receipt.delivered ? 'input-delivered' : 'input-pending', detail: JSON.stringify(receipt) }), (locator, options) => this.#serveRequest('harness.v1.sessions.load', { locator, options: { ...options, include_subagents: false } }, 10000));
+      if (!session || session.rootPid !== saved.binding.pid) continue;
+      const queue = new TerminalMailbox(this.terminalMailRoot, saved.recipient, receipt => this.#recordTerminalReceipt(saved.binding.context, receipt),
+        (locator, options) => this.#serveRequest('harness.v1.sessions.load', { locator, options: { ...options, include_subagents: false } }, 10000));
       queue.identity = saved.binding.identity; queue.host = this.host; queue.session = session;
+      // A tmux host remints its client IDs after restart. Context and the live
+      // process still bind this queue; drain verifies its pane-held token
+      // before adopting a pasted batch under the new client ID.
+      queue.state.binding.terminal = session.id; queue.save();
       this.terminalMailboxes.set(saved.recipient, queue);
     }
     // A queue whose pane has ended is not retried every second into a terminal that no longer
@@ -2443,7 +2533,23 @@ export class TeamsMachine extends MachineCore {
     await Promise.all([...this.terminalMailboxes.values()].filter(queue => !this.inputRepairs[queue.state.binding?.context] && !this.inputInFlight.has(queue.session?.id)).map(queue => queue.kick()));
   }
 
-  async #terminalMail(session, contextKey, kind, text, options) {
+  #recordTerminalReceipt(contextKey, receipt) {
+    this.log.append({ principal: null, cap: 'control', target: `pane:${contextKey}`,
+      outcome: receipt.delivered ? 'input-delivered' : receipt.refused ? 'input-refused' : 'input-pending', detail: JSON.stringify(receipt) });
+    if (!receipt.delivered && !receipt.refused) return;
+    for (const id of receipt.message_ids ?? []) {
+      if (!/^first-[A-Za-z0-9_-]+$/.test(id)) continue;
+      const path = join(this.terminalMailRoot, 'native-launches', `${id.slice(6)}.json`);
+      const seed = readJson(path), launch = seed?.key && this.launches.find(seed.key);
+      if (!launch || seed.pane !== contextKey || launch.pane !== contextKey) continue;
+      const native = /([0-9a-f]{8}-[0-9a-f-]{27})\.jsonl$/i.exec(String(readJson(path.replace(/\.json$/, '.session.json'))?.path ?? ''))?.[1];
+      const { t: _previousAt, ...facts } = launch;
+      this.launches.record({ ...facts, inputDelivered: receipt.delivered, inputPending: false, inputRefused: receipt.refused === true,
+        ...(receipt.delivered ? { inputReceipt: receipt.receipt, inputError: null, ...(native ? { native_session: native } : {}) } : { inputError: receipt.reason }) });
+    }
+  }
+
+  async #terminalMail(session, contextKey, kind, text, options, identity = null) {
     // Mail a queue of this terminal already holds (the watch asking again after the same message ids) is answered from
     // that queue, which types it once the composer frees: nothing is asked of the harness again for it.
     const ids = options.messageIds ?? [];
@@ -2453,29 +2559,33 @@ export class TeamsMachine extends MachineCore {
         if (binding?.context === contextKey && binding.terminal === session.id && ids.every(id => held.state.accepted?.[id])) return held.receipt(ids);
       }
     }
-    const activity = await this.#serveRequest('harness.v1.sessions.activity_under', { pids: [session.rootPid] });
-    const under = activity?.activities?.find(row => row.pid === session.rootPid);
-    const native = under?.activity;
-    if (!native?.session_id) return { delivered: false, reason: 'native-session-unresolved' };
-    const key = `${kind}:${native.session_id}`;
+    let under;
+    if (!identity) {
+      const activity = await this.#serveRequest('harness.v1.sessions.activity_under', { pids: [session.rootPid] });
+      under = activity?.activities?.find(row => row.pid === session.rootPid);
+      const native = under?.activity;
+      if (!native?.session_id) return { delivered: false, reason: 'native-session-unresolved' };
+      identity = { kind, sessionId: native.session_id };
+    }
+    const key = `${kind}:${identity.sessionId}`;
     let queue = this.terminalMailboxes.get(key);
     // A session's transcript does not move: its queue knows it once found, and the harness names it with the session it
     // found under the pane (a supercode from t_09a795fd on). Only an older one leaves a discovery to make.
     const known = queue?.state.binding?.identity;
-    let path = known?.path, locator = known?.locator;
+    let path = identity.path ?? known?.path, locator = identity.locator ?? known?.locator;
     if (!locator && under?.locator?.storage?.path) { locator = under.locator; path = under.locator.storage.path; }
-    if (!locator) {
-      const found = await this.#serveRequest('harness.v1.sessions.discover', { query: native.session_id, harnesses: [kind], limit: 20 });
-      const row = found?.sessions?.find(row => row.locator?.session_id === native.session_id);
+    if (!locator && !path) {
+      const found = await this.#serveRequest('harness.v1.sessions.discover', { query: identity.sessionId, harnesses: [kind], limit: 20 });
+      const row = found?.sessions?.find(row => row.locator?.session_id === identity.sessionId);
       path = row?.locator?.storage?.path; locator = row?.locator;
     }
-    if (!locator || (kind === 'codex' && !path)) return { delivered: false, reason: 'native-transcript-unresolved' };
+    if ((!locator && !['codex', 'claude-code'].includes(kind)) || (['codex', 'claude-code'].includes(kind) && !path)) return { delivered: false, reason: 'native-transcript-unresolved' };
     if (!queue) {
-      queue = new TerminalMailbox(this.terminalMailRoot, key, receipt => this.log.append({ principal: null, cap: 'control', target: `pane:${contextKey}`,
-        outcome: receipt.delivered ? 'input-delivered' : 'input-pending', detail: JSON.stringify(receipt) }), (locator, options) => this.#serveRequest('harness.v1.sessions.load', { locator, options: { ...options, include_subagents: false } }, 10000));
+      queue = new TerminalMailbox(this.terminalMailRoot, key, receipt => this.#recordTerminalReceipt(contextKey, receipt),
+        (locator, options) => this.#serveRequest('harness.v1.sessions.load', { locator, options: { ...options, include_subagents: false } }, 10000));
       this.terminalMailboxes.set(key, queue);
     }
-    const enqueued = queue.enqueue(text, options.messageIds, { kind, path, locator }, this.host, session);
+    const enqueued = queue.enqueue(text, options.messageIds, { ...identity, kind, path, locator }, this.host, session, { deadlineMs: options.deadlineMs });
     return queue.receipt(enqueued);
   }
 
@@ -2610,22 +2720,11 @@ export class TeamsMachine extends MachineCore {
   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' };
-    if (['codex', 'grok', 'gemini', 'goose', 'opencode', 'pi', 'hermes', 'openclaw'].includes(kind)) return this.#terminalMail(session, contextKey, kind, submission(text, false), options);
     if(this.inputRepairs[contextKey])return {delivered:false,reason:'input-cleanup-pending',cleanup_required:true};
+    if (['claude-code', 'codex', 'grok', 'gemini', 'goose', 'opencode', 'pi', 'hermes', 'openclaw'].includes(kind)) return this.#terminalMail(session, contextKey, kind, submission(text, false), options);
     if (this.inputInFlight.has(session.id)) return { delivered: false, reason: 'input-in-flight' };
     this.inputInFlight.add(session.id);
     try {
-      if (kind === 'claude-code') {
-        if (typeof terminal.deliverComposerInput !== 'function') return { delivered: false, reason: 'terminal-package-too-old' };
-        const result=await terminal.deliverComposerInput(this.host, session.id, kind, submission(text, false), options);
-        if(result.cleanup_required){
-          this.inputRepairs[contextKey]={session:session.id,kind,text:result.cleanup_remaining??submission(text,false),at:Date.now(),reason:result.cleanup_reason};
-          writeJson(this.inputRepairsPath,this.inputRepairs);this.#watchInputRepairs();
-          this.log.append({principal:null,cap:'control',target:`pane:${contextKey}`,outcome:'input-cleanup-pending',detail:result.cleanup_reason});
-        }
-        const {cleanup_remaining,...receipt}=result;
-        return receipt;
-      }
       const delivery = await this.host.sendInput(session.id, submission(text), { ...options, submitMode: 'single' });
       return { delivered: true, delivery };
     } catch (error) {
@@ -2737,9 +2836,9 @@ export class TeamsMachine extends MachineCore {
    *   deadline   neither, for `INITIAL_INPUT_READY_DEADLINE_MS`. The caller
    *              leaves input undelivered without typing into that screen.
    */
-  async #awaitInputReady(session, contextKey, kind, signal) {
+  async #awaitInputReady(session, contextKey, kind, signal, deadlineMs = null) {
     const composerKind = this.#paneKind(contextKey, session);
-    const until = Date.now() + INITIAL_INPUT_READY_DEADLINE_MS;
+    const until = deadlineMs ?? Date.now() + INITIAL_INPUT_READY_DEADLINE_MS;
     let readySince = null;
     while (!signal.aborted && Date.now() < until) {
       const capture = await Promise.resolve().then(() => this.host.capture(session.id, { preserveEscapes: true })).catch(() => '');
@@ -3405,7 +3504,10 @@ export class TeamsMachine extends MachineCore {
             const session = await this.#paneByContext(existing.pane);
             const latest = this.launches.find(key);
             if (JSON.stringify(latest) !== JSON.stringify(existing)) { existing = latest; continue; }
-            if (session && !session.dead) return { key, pane: existing.pane, reused: true, status: existing.status };
+            if (session && !session.dead) {
+              this.#recoverClaudeInitialInputs([session], key);
+              return { key, pane: existing.pane, reused: true, status: existing.status };
+            }
           }
           break;
         }
@@ -3435,7 +3537,7 @@ export class TeamsMachine extends MachineCore {
           }
           if (params.kind === 'codex') params = { ...params, arguments: canonicalCodexFolderTrust(params.cwd, params.arguments) };
           session = await this.host.createSession({
-            command: this.#nativeQuestionCommand(params, contextKey, by, (value) => { nativeInput = value; }),
+            command: this.#nativeQuestionCommand({ ...params, key }, contextKey, by, (value) => { nativeInput = value; }),
             contextKey,
             cwd: params.cwd,
             // A pane that runs one verb for its launcher (`close`/`stop` on another machine) is told who that is; what a
@@ -3452,6 +3554,7 @@ export class TeamsMachine extends MachineCore {
           act('launch', `pane:${contextKey}`, 'failed', error.code ?? error.message);
           throw error;
         }
+        if (nativeInput?.binding) executable = { ...executable, nativeInputBinding: nativeInput.binding };
         // The agent the launch's environment names is kept with the launch: the pane's session is bound to it once the
         // session is seen in the pane (sessionBindings).
         const agent = launchAgent(params.env);
@@ -4241,7 +4344,11 @@ function initialInputFacts(record) {
   if (record?.inputDelivered === undefined) return {};
   return {
     inputDelivered: Boolean(record.inputDelivered),
+    ...(record.inputPending !== undefined ? { inputPending: record.inputPending === true } : {}),
+    ...(record.inputRefused !== undefined ? { inputRefused: record.inputRefused === true } : {}),
     inputReadyBy: record.inputReadyBy ?? null,
+    ...(record.inputReceipt ? { inputReceipt: record.inputReceipt } : {}),
+    ...(record.native_session ? { native_session: record.native_session } : {}),
     ...(record.inputDeliveredLate ? { inputDeliveredLate: true } : {}),
     ...(record.inputError ? { inputError: record.inputError } : {}),
   };

package/package.json

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

@@ -6,6 +6,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import { StringDecoder } from 'node:string_decoder';
 import { codexUpdatePrompt, codexWindowsPastes } from './codex-startup.mjs';
+import { composerText, restoreComposerInput } from '@volter/supercode-terminal';
 
 // When process `pid` started (ms), from `ps -o etime=` ([[dd-]hh:]mm:ss); null when it cannot be read.
 function startedAt(pid) {
@@ -19,9 +20,42 @@ function startedAt(pid) {
 
 const hash = value => createHash('sha256').update(value).digest('hex');
 const textOf = content => typeof content === 'string' ? content : Array.isArray(content) && content.every(p => ['text', 'input_text'].includes(p.type)) ? content.map(p => p.text).join('') : null;
+const incrementalKind = kind => kind === 'codex' || kind === 'claude-code';
+const transcriptSize = path => { try { return statSync(path).size; } catch (error) { if (error.code === 'ENOENT') return 0; throw error; } };
+const pause = ms => new Promise(resolve => setTimeout(resolve, ms));
+const normalized = text => String(text).replace(/\r\n?/g, '\n').trim();
+
+function claudeHolds(batch, shown, owned = false) {
+  if (shown == null || shown === '') return false;
+  const wanted = normalized(batch.text);
+  if (shown.trim() === wanted) return true;
+  // Screen wrapping may add row breaks or consume one original space/newline.
+  // Every other character must remain exact; whitespace is never erased.
+  const rows = shown.trim().split('\n');
+  let offsets = new Set([0]);
+  for (let row = 0; row < rows.length; row++) {
+    const next = new Set();
+    for (const offset of offsets) {
+      if (!wanted.startsWith(rows[row], offset)) continue;
+      const end = offset + rows[row].length;
+      if (row === rows.length - 1) next.add(end);
+      else { next.add(end); if (wanted[end] === ' ' || wanted[end] === '\n') next.add(end + 1); }
+    }
+    offsets = next;
+  }
+  if (offsets.has(wanted.length)) return true;
+  const placeholder = /^\[Pasted text #\d+(?: \+(\d+) lines?)?\]$/u.exec(shown.trim());
+  const breaks = text => (text.match(/\n/gu) ?? []).length;
+  if (!placeholder || (placeholder[1] === undefined
+    ? breaks(normalized(batch.text)) !== 0
+    : ![breaks(normalized(batch.text)), breaks(`${batch.text}\n`)].includes(Number(placeholder[1])))) return false;
+  if (owned && !batch.placeholder) batch.placeholder = placeholder[0];
+  return batch.placeholder === placeholder[0];
+}
 
 function confirmed(batch) {
-  const fd = openSync(batch.path, 'r');
+  let fd;
+  try { fd = openSync(batch.path, 'r'); } catch (error) { if (error.code === 'ENOENT') return false; throw error; }
   try {
     let offset = batch.offset, buffered = '';
     const decoder = new StringDecoder('utf8');
@@ -36,10 +70,15 @@ function confirmed(batch) {
         const line = buffered.slice(0, end); buffered = buffered.slice(end + 1);
         let row; try { row = JSON.parse(line); } catch { continue; }
         const content = batch.kind === 'codex' && row.type === 'response_item' && row.payload?.type === 'message' && row.payload.role === 'user'
-          ? row.payload.content : batch.kind === 'grok' && row.type === 'user' ? row.content : null;
+          ? row.payload.content : batch.kind === 'claude-code' && row.type === 'user' && !row.isMeta && (!batch.sessionId || row.sessionId === batch.sessionId)
+            ? row.message?.content : batch.kind === 'grok' && row.type === 'user' ? row.content : null;
         const text = textOf(content);
         if (text === null || text.length === 0) continue;
         if (text === batch.text) return { fragments: 1 };
+        if (batch.kind === 'claude-code') {
+          if (normalized(text) === normalized(batch.text)) return { fragments: 1 };
+          continue;
+        }
         // 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
@@ -78,11 +117,13 @@ export class TerminalMailbox {
   }
   receipt(ids) {
     const delivered = ids.every(id => this.state.receipts.some(r => r.message_ids.includes(id)));
+    const refused = (this.state.refusals ?? []).find(r => r.message_ids.some(id => ids.includes(id)));
+    if (!delivered && refused) return { delivered: false, queued: false, refused: true, message_ids: ids, reason: refused.reason };
     const batch = this.state.active;
     return { delivered, queued: !delivered, message_ids: ids,
       ...(delivered ? { receipt: this.state.receipts.some(r => r.receipt === 'native-user-messages' && r.message_ids.some(id => ids.includes(id))) ? 'native-user-messages' : 'native-user-message' } : { reason: batch?.error ?? 'queued', batch: batch?.id ?? null }) };
   }
-  enqueue(text, ids, identity, host, session) {
+  enqueue(text, ids, identity, host, session, { deadlineMs = null } = {}) {
     const messageIds = ids?.length ? ids : [`input-${randomUUID()}`];
     if (messageIds.some(id => typeof id !== 'string' || !/^[A-Za-z0-9_-]{1,160}$/.test(id))) throw new Error('invalid terminal message id');
     const digest = hash(text);
@@ -92,7 +133,7 @@ export class TerminalMailbox {
     if (!previous.length) {
       for (const id of messageIds) accepted[id] = digest;
       // New mail joins the next paste while the current one awaits its receipt.
-      this.state.pending.push({ ids: messageIds, text }); this.save();
+      this.state.pending.push({ ids: messageIds, text, deadlineMs }); this.save();
     }
     this.identity = identity; this.host = host; this.session = session;
     this.state.binding = { context: session.contextKey, terminal: session.id, pid: session.rootPid, identity }; this.save();
@@ -113,48 +154,149 @@ export class TerminalMailbox {
     }).finally(() => { this.work = null; });
     return this.work;
   }
+  async refuseClaude(batch) {
+    if (!batch.inputOwner || !await this.host.ownsInput?.(this.session.id, batch.inputOwner)) {
+      await this.recordRefusal(batch, `${batch.confirmationError ?? 'native transcript unconfirmed'}; input ownership unavailable; composer preserved`);
+      return;
+    }
+    const screen = await this.host.capture(this.session.id, { lines: 200, preserveEscapes: true });
+    const shown = composerText(batch.kind, screen);
+    const own = claudeHolds(batch, shown, true);
+    // One final read/Enter at the deadline, then a bounded native receipt
+    // grace. A badge that painted late never goes straight to refusal.
+    if (own && !batch.confirmationError && !batch.finalEnter && !/\besc to (?:interrupt|cancel)\b/iu.test(screen)) {
+      batch.finalEnter = true; batch.phase = 'pasted'; batch.expiresAt = Date.now() + 5000;
+      batch.enters++; batch.last_enter = Date.now(); this.save();
+      await this.host.sendInput(this.session.id, '\r', { submitMode: 'single', inputOwner: batch.inputOwner });
+      this.log({ delivered: false, queued: true, batch: batch.id, message_ids: batch.message_ids, attempt: batch.enters, final: true, at: Date.now() });
+      return;
+    }
+    const reason = batch.confirmationError ?? 'native transcript unconfirmed at delivery deadline';
+    if (shown === null || (!own && shown !== '')) {
+      await this.recordRefusal(batch, `${reason}; composer changed or unreadable; composer preserved`); return;
+    }
+    if (own) {
+      const result = await restoreComposerInput(this.host, this.session.id, batch.kind, normalized(batch.text), { pasted: batch.placeholder ?? null, inputOwner: batch.inputOwner });
+      if (!result.restored) {
+        await this.recordRefusal(batch, `${reason}; cleanup unconfirmed (${result.reason}); composer preserved`); return;
+      }
+    }
+    await this.recordRefusal(batch, `${reason}; ${own ? 'own unsent input restored' : 'composer empty'}`);
+  }
+  async recordRefusal(batch, reason) {
+    const receipt = { delivered: false, queued: false, refused: true, reason,
+      batch: batch.id, message_ids: batch.message_ids, at: Date.now() };
+    if (batch.inputOwner) await this.releaseOwner(batch);
+    (this.state.refusals ??= []).push(receipt);
+    this.state.active = null; this.save(); this.log(receipt);
+  }
+  async releaseOwner(batch) {
+    try { await this.host.releaseInput?.(this.session.id, batch.inputOwner); }
+    catch (error) {
+      // An older pane server never acquired this token. A closed pane has no
+      // composer to release. Other failures remain explicit in the receipt.
+      if (!['unsupported', 'session_not_found'].includes(error.code)) throw error;
+    }
+  }
   async drain() {
     let batch = this.state.active;
     if (!batch && this.state.pending.length) {
       const items = []; let size = 0;
       for (const message of this.state.pending) {
         if (items.length && size + Buffer.byteLength(message.text) > 32768) break;
+        if (items.length && (items[0].deadlineMs ?? null) !== (message.deadlineMs ?? null)) break;
         items.push(message); size += Buffer.byteLength(message.text);
       }
       const text = items.map(m => m.text).join('\n\n');
-      const incremental = this.identity.kind === 'codex';
+      const incremental = incrementalKind(this.identity.kind);
       const baseline = incremental ? null : await this.load(this.identity.locator, { message_tail: 1 });
       batch = { id: randomUUID(), message_ids: items.flatMap(m => m.ids), text, kind: this.identity.kind,
-        path: this.identity.path, offset: incremental ? statSync(this.identity.path).size : null,
-        locator: this.identity.locator, messageOffset: baseline?.window?.total_messages ?? null, phase: 'prepared', enters: 0, last_enter: 0 };
+        path: this.identity.path, sessionId: this.identity.sessionId ?? this.identity.locator?.session_id,
+        offset: incremental ? this.identity.offset ?? transcriptSize(this.identity.path) : null,
+        locator: this.identity.locator, messageOffset: baseline?.window?.total_messages ?? null, phase: 'prepared', enters: 0, last_enter: 0,
+        ...(this.identity.kind === 'claude-code' ? { inputOwner: randomUUID(), expiresAt: items[0].deadlineMs ?? null } : {}) };
       this.state.active = batch; this.state.pending = this.state.pending.filter(message => !items.includes(message)); this.save();
     }
     if (!batch) return;
-    const seen = batch.offset !== null ? confirmed(batch) : (await this.load(batch.locator, { message_offset: batch.messageOffset, message_limit: 1000 })).session?.messages?.some(message => message.role === 'user' && textOf(message.content) === batch.text);
+    let seen;
+    try {
+      seen = batch.offset !== null ? confirmed(batch) : (await this.load(batch.locator, { message_offset: batch.messageOffset, message_limit: 1000 })).session?.messages?.some(message => message.role === 'user' && textOf(message.content) === batch.text);
+      batch.confirmationError = null;
+    } catch (error) {
+      if (batch.kind !== 'claude-code') throw error;
+      // A failed receipt read must reach the same guarded cleanup as expiry.
+      // It never justifies another paste or an Enter we cannot confirm.
+      batch.confirmationError = `native transcript unavailable: ${error.code ?? error.message}`;
+      if (batch.phase === 'prepared') await this.recordRefusal(batch, `${batch.confirmationError}; no input pasted`);
+      else await this.refuseClaude(batch);
+      return;
+    }
     if (seen) {
       const receipt = { batch: batch.id, message_ids: batch.message_ids, delivered: true, receipt: seen.fragments > 1 ? 'native-user-messages' : 'native-user-message', fragments: seen.fragments ?? 1, at: Date.now() };
       appendFileSync(join(this.dir, 'receipts.jsonl'), JSON.stringify(receipt) + '\n', { mode: 0o600 });
+      if (batch.inputOwner) await this.releaseOwner(batch);
       this.state.receipts.push(receipt);
       this.state.active = null; this.save(); this.log(receipt); return;
     }
+    if (batch.kind === 'claude-code' && batch.phase !== 'prepared') {
+      if (!batch.inputOwner || !await this.host.ownsInput?.(this.session.id, batch.inputOwner)) {
+        await this.recordRefusal(batch, 'native transcript unconfirmed; input ownership unavailable; composer preserved'); return;
+      }
+      // tmux host IDs belong to a client, not the lasting pane. Only the same
+      // live process AND the pane's saved token authorize adopting that ID.
+      if (batch.pid === this.session.rootPid && batch.terminal !== this.session.id) {
+        batch.terminal = this.session.id; this.save();
+      }
+    }
     if (batch.phase !== 'prepared' && this.session && this.pastedElsewhere(batch)) {
       // The paste went to a terminal the session no longer runs in (its pane's process was replaced, a resume): that
       // composer died with its process and the transcript never got the text, so the batch is pasted again here.
       // Nothing is guessed: the transcript was read above, from the paste's own offset, and holds no such message.
       this.log({ delivered: false, queued: true, batch: batch.id, message_ids: batch.message_ids, reason: `pasted into terminal ${batch.terminal ?? 'unrecorded'}, which the session no longer runs in; pasting again into ${this.session.id}` });
-      const baseline = batch.kind === 'codex' ? null : await this.load(this.identity.locator, { message_tail: 1 });
+      const baseline = incrementalKind(batch.kind) ? null : await this.load(this.identity.locator, { message_tail: 1 });
       Object.assign(batch, { phase: 'prepared', enters: 0, last_enter: 0, error: null, path: this.identity.path, locator: this.identity.locator,
-        offset: batch.kind === 'codex' ? statSync(this.identity.path).size : null, messageOffset: baseline?.window?.total_messages ?? null });
+        offset: incrementalKind(batch.kind) ? transcriptSize(this.identity.path) : null, messageOffset: baseline?.window?.total_messages ?? null,
+        expiresAt: batch.expiresAt ?? null, finalEnter: false, placeholder: null,
+        ...(batch.kind === 'claude-code' ? { inputOwner: randomUUID() } : {}) });
       this.save();
     }
     if (batch.kind === 'codex' && codexUpdatePrompt(await this.host.capture(this.session.id, { lines: 120 }))) {
       batch.error = 'codex-update-prompt: delivery retained; restart Codex with check_for_update_on_startup=false';
       this.save(); this.log({ delivered: false, queued: true, reason: batch.error, message_ids: batch.message_ids }); return;
     }
+    if (batch.kind === 'claude-code' && batch.phase === 'prepared' && batch.expiresAt && Date.now() >= batch.expiresAt) {
+      await this.recordRefusal(batch, 'delivery deadline elapsed; no input pasted'); return;
+    }
+    if (batch.kind === 'claude-code' && (batch.phase === 'refusing' || (batch.expiresAt && Date.now() >= batch.expiresAt))) {
+      await this.refuseClaude(batch); return;
+    }
     if (batch.phase === 'prepared') {
+      if (batch.kind === 'claude-code') {
+        if (!normalized(batch.text) || /[\u0000-\u0008\u000b-\u001f\u007f]/u.test(normalized(batch.text))) {
+          await this.recordRefusal(batch, 'unsupported-text; no input pasted'); return;
+        }
+        try {
+          batch.expiresAt ??= Date.now() + 90_000; this.save();
+          if (!this.host.acquireInput || !await this.host.acquireInput(this.session.id, batch.inputOwner)) {
+            batch.error = 'input ownership busy; no input pasted'; this.save(); return;
+          }
+        } catch (error) {
+          await this.recordRefusal(batch, `input ownership unavailable (${error.code ?? error.message}); no input pasted`); return;
+        }
+        for (let check = 0; check < 2; check++) {
+          const screen = await this.host.capture(this.session.id, { lines: 200, preserveEscapes: true });
+          const held = composerText(batch.kind, screen);
+          if (held !== '' || /\besc to (?:interrupt|cancel)\b/iu.test(screen)) {
+            await this.host.releaseInput(this.session.id, batch.inputOwner);
+            batch.error = held == null ? 'no-composer' : held ? 'draft' : 'working'; this.save(); return;
+          }
+          if (check === 0) await pause(200);
+        }
+      }
       // Persist uncertainty before I/O. A daemon restart checks the transcript;
       // 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();
+      Object.assign(batch, { phase: 'paste_started', terminal: this.session.id, pid: this.session.rootPid ?? null, pasted_at: Date.now(),
+        ...(batch.kind === 'claude-code' ? { expiresAt: batch.expiresAt ?? Date.now() + 90_000 } : {}) }); this.save();
       // The terminal host's final newline selects one bracketed paste;
       // 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).
@@ -163,23 +305,45 @@ export class TerminalMailbox {
           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' });
+      } else await this.host.sendInput(this.session.id, `${batch.kind === 'claude-code' ? normalized(batch.text) : batch.text}\n`, {
+        submitMode: 'none', ...(batch.kind === 'claude-code' ? { inputOwner: batch.inputOwner, deadlineMs: batch.expiresAt } : {}) });
       batch.phase = 'pasted'; this.save();
     }
     if (batch.phase === 'paste_started') {
-      batch.error = 'paste outcome uncertain; native transcript confirmation pending'; this.save(); return;
+      if (batch.kind === 'claude-code' && claudeHolds(batch, composerText(batch.kind, await this.host.capture(this.session.id, { lines: 200, preserveEscapes: true })), true)) {
+        batch.phase = 'pasted'; this.save();
+      } else {
+        batch.error = 'paste outcome uncertain; native transcript confirmation pending'; this.save(); return;
+      }
     }
-    if (batch.enters < 3 && Date.now() - batch.last_enter >= 5000) {
+    if ((batch.kind === 'claude-code' || batch.enters < 3) && Date.now() - batch.last_enter >= 5000) {
+      if (batch.kind === 'claude-code') {
+        // A receipt read before the paste can become unavailable while the
+        // terminal paints it. Re-read before Enter; uncertainty never submits.
+        try { if (confirmed(batch)) return; }
+        catch (error) {
+          batch.confirmationError = `native transcript unavailable: ${error.code ?? error.message}`;
+          await this.refuseClaude(batch); return;
+        }
+        if (batch.expiresAt && Date.now() >= batch.expiresAt) { await this.refuseClaude(batch); return; }
+        const screen = await this.host.capture(this.session.id, { lines: 200, preserveEscapes: true });
+        // Re-read until the deadline: a Windows paste badge can appear well
+        // after one second. Ownership is held by the pane host, across daemon
+        // restart, from before the empty reads through receipt/refusal.
+        if (!claudeHolds(batch, composerText(batch.kind, screen), true) || /\besc to (?:interrupt|cancel)\b/iu.test(screen)) {
+          batch.error = 'composer changed or unreadable; native transcript confirmation pending'; this.save(); return;
+        }
+      }
       if (batch.kind === 'codex' && codexUpdatePrompt(await this.host.capture(this.session.id, { lines: 120 }))) {
         batch.error = 'codex-update-prompt: Enter refused'; this.save(); return;
       }
       batch.enters += 1; batch.last_enter = Date.now(); this.save();
-      await this.host.sendInput(this.session.id, '\r', { submitMode: 'single' });
+      await this.host.sendInput(this.session.id, '\r', { submitMode: 'single', ...(batch.kind === 'claude-code' ? { inputOwner: batch.inputOwner } : {}) });
       const attempt = { delivered: false, queued: true, batch: batch.id, message_ids: batch.message_ids, attempt: batch.enters, at: Date.now() };
       appendFileSync(join(this.dir, 'attempts.jsonl'), JSON.stringify(attempt) + '\n', { mode: 0o600 });
       this.log(attempt);
     }
-    batch.error = batch.enters >= 3 ? 'native transcript unconfirmed after Enter retries' : 'native transcript confirmation pending';
+    batch.error = batch.kind !== 'claude-code' && batch.enters >= 3 ? 'native transcript unconfirmed after Enter retries' : 'native transcript confirmation pending';
     this.save();
   }
 }