@volter/supercode-terminal 0.2.66 → 0.2.68

package/CAPABILITIES.md

@@ -23,6 +23,7 @@ means it must not be presented as supported.
 | Scrollback, selection and copy | UI/xterm | verified | Bounded scrollback and native xterm selection. |
 | Find in one terminal, next/previous match | UI | verified | Search covers the active xterm buffer. Cross-tab search is missing. |
 | URL detection | UI | partial | The stable xterm web-link provider is active; host policy and end-to-end link opening still need a dedicated proof. |
+| Exclusive input ownership | tmux/host | partial | `acquireInput`, `ownsInput` and `releaseInput` serialize a paste with other input and remain with the pane across a client restart. [Recorded tmux proof](../../docs/evidence/claude-input-2026-10-07.md#recorded-review-fixes) rejects a replacement while the badge is unrecorded, then confirms one native message after daemon restart. Older pane servers refuse this door; Windows ownership restart remains unmeasured. |
 | Paste and bracketed paste | UI | verified | Multiline or large pastes require confirmation; history is memory-only. Advanced transforms and slow paste are missing. |
 | Save terminal contents | UI | partial | The normal buffer is projected to a bounded plain-text download; the browser download boundary and continuous logging still need dedicated proof. |
 | Bell and background activity | UI | verified | A controlled tmux shell proved active visual bell plus inactive activity/bell tab state. System notifications are host policy. |

package/index.d.ts

@@ -56,9 +56,13 @@ export class TmuxTerminalHost {
   sendInput(
     sessionId: string,
     data: string,
-    options?: { deadlineMs?: number; submitMode?: 'retry' | 'single' | 'none' },
+    options?: { deadlineMs?: number; submitMode?: 'retry' | 'single' | 'none'; inputOwner?: string },
   ): Promise<TerminalInputDelivery>;
   /** Persist an opaque application context association on a session owned by this host. */
+  /** Exclusive input ownership, retained by the pane host across client restart. */
+  acquireInput(sessionId: string, owner: string): Promise<boolean> | boolean;
+  ownsInput(sessionId: string, owner: string): Promise<boolean> | boolean;
+  releaseInput(sessionId: string, owner: string): Promise<boolean> | boolean;
   bindContext(sessionId: string, contextKey: string): Promise<TerminalSession>;
   issueAttachment(sessionId: string, options?: { mode?: 'observe' | 'control' }): TerminalAttachmentGrant;
   attachSocket(
@@ -81,7 +85,11 @@ export class PaneServerHost {
   listSessions(): Promise<TerminalSession[]>;
   createSession(input: { command: TmuxCommand; contextKey?: string; cwd?: string; env?: Record<string, string>; name?: string }): Promise<TerminalSession>;
   capture(sessionId: string, options?: { lines?: number; preserveEscapes?: boolean }): Promise<string>;
-  sendInput(sessionId: string, data: string, options?: { deadlineMs?: number; submitMode?: 'retry' | 'single' | 'none' }): Promise<TerminalInputDelivery>;
+  sendInput(sessionId: string, data: string, options?: { deadlineMs?: number; submitMode?: 'retry' | 'single' | 'none'; inputOwner?: string }): Promise<TerminalInputDelivery>;
+  /** Exclusive input ownership, retained by the pane host across client restart. */
+  acquireInput(sessionId: string, owner: string): Promise<boolean> | boolean;
+  ownsInput(sessionId: string, owner: string): Promise<boolean> | boolean;
+  releaseInput(sessionId: string, owner: string): Promise<boolean> | boolean;
   bindContext(sessionId: string, contextKey: string): Promise<TerminalSession>;
   renameWindow(sessionId: string, title?: string | null): Promise<string>;
   issueAttachment(sessionId: string, options?: { mode?: 'observe' | 'control' }): Promise<TerminalAttachmentGrant>;
@@ -111,8 +119,12 @@ export class PtyTerminalHost {
   sendInput(
     sessionId: string,
     data: string,
-    options?: { deadlineMs?: number; submitMode?: 'retry' | 'single' | 'none' },
+    options?: { deadlineMs?: number; submitMode?: 'retry' | 'single' | 'none'; inputOwner?: string },
   ): Promise<TerminalInputDelivery>;
+  /** Exclusive input ownership, retained by the pane host across client restart. */
+  acquireInput(sessionId: string, owner: string): Promise<boolean> | boolean;
+  ownsInput(sessionId: string, owner: string): Promise<boolean> | boolean;
+  releaseInput(sessionId: string, owner: string): Promise<boolean> | boolean;
   bindContext(sessionId: string, contextKey: string): Promise<TerminalSession>;
   /** A ConPTY pane has no window to rename; returns its label. */
   renameWindow(sessionId: string, title?: string | null): string;
@@ -253,6 +265,6 @@ export type { TerminalInputDelivery, TmuxCommand, TmuxWindowSize };
 
 /** The bounded live composer text, or null for an unrecognized screen. */
 export function composerText(kind: string, screen: string | undefined): string | null;
-export function restoreComposerInput(host: TmuxTerminalHost | PtyTerminalHost | PaneServerHost, sessionId: string, kind: string, text: string, options?: { pasted?: string | null }): Promise<{ restored: boolean; reason?: string; remaining?: string }>;
+export function restoreComposerInput(host: TmuxTerminalHost | PtyTerminalHost | PaneServerHost, sessionId: string, kind: string, text: string, options?: { pasted?: string | null; inputOwner?: string }): Promise<{ restored: boolean; reason?: string; remaining?: string }>;
 /** Failed input is restored or returns an explicit cleanup obligation; never blindly resend. */
 export function deliverComposerInput(host: TmuxTerminalHost | PtyTerminalHost | PaneServerHost, sessionId: string, kind: string, text: string, options?: { deadlineMs?: number; signal?: AbortSignal }): Promise<{ delivered: boolean; reason?: string; restored?: boolean; cleanup_required?: boolean; cleanup_reason?: string; cleanup_remaining?: string; delivery?: TerminalInputDelivery }>;

package/index.mjs

@@ -15,6 +15,7 @@ import { openLocalTerminal as defaultOpenLocalTerminal } from './substrate/local
 const DEFAULT_ATTACHMENT_TTL_MS = 30_000;
 const DEFAULT_CONTEXT_OPTION = '@supercode-context';
 const DEFAULT_OWNER_OPTION = '@supercode-owner';
+const INPUT_OWNER_OPTION = '@supercode-input-owner';
 const SESSION_NAME = /^[A-Za-z0-9_-]{1,64}$/;
 // A pane should feel like the terminal it is shown in, not like tmux: no status
 // bar, no prefix key taking keystrokes from the program, and no mouse capture,
@@ -24,6 +25,20 @@ const SESSION_NAME = /^[A-Za-z0-9_-]{1,64}$/;
 // keep their own settings.
 const TERMINAL_LIKE_SESSION = Object.freeze({ status: 'off', mouse: 'off', prefix: 'None', prefix2: 'None', 'remain-on-exit': 'failed' });
 
+function inputOwner(value) {
+  if (typeof value !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/u.test(value)) throw new TypeError('An input owner must be an opaque token.');
+  return value;
+}
+
+function runTmuxInput(socket, args, input = null) {
+  return new Promise((resolve, reject) => {
+    const child = execFile('tmux', [...(socket ? ['-L', socket] : []), ...args], { encoding: 'utf8', timeout: 5000, maxBuffer: 1024 * 1024 },
+      (error, stdout) => error ? reject(error) : resolve(stdout.trim()));
+    child.stdin.on('error', () => {});
+    child.stdin.end(input);
+  });
+}
+
 // The four native harness kinds this package can host interactively, mapped to
 // the vendor CLI a tmux pane runs. These are the plain interactive TUIs, not the
 // registry's stdio/ACP launches (crates/harness/src/support.rs), whose protocol
@@ -287,6 +302,8 @@ export class TmuxTerminalHost {
     if (!this.#canControl(entry.name)) {
       throw new TerminalHostError('input_not_allowed', 'This host does not own that tmux session.');
     }
+    if (options.inputOwner) return this.#sendOwnedInput(entry.name, data, options);
+    if (await this.#inputOwned(entry.name)) throw new TerminalHostError('input_owned', 'This pane is confirming another input; no input was sent.');
     return await this.#tmux.sendInputAsync({
       data,
       deadlineMs: options.deadlineMs,
@@ -296,6 +313,58 @@ export class TmuxTerminalHost {
     });
   }
 
+  async #inputOwned(name, owner = null) {
+    const state = await runTmuxInput(this.#socket, ['display-message', '-p', '-t', `${name}:0.0`, `#{${INPUT_OWNER_OPTION}}:#{pane_input_off}`]);
+    return owner == null ? state.split(':')[0] !== '' : state === `${owner}:1`;
+  }
+
+  async acquireInput(sessionId, owner) {
+    inputOwner(owner);
+    const entry = this.#entry(sessionId);
+    if (!this.#canControl(entry.name)) throw new TerminalHostError('input_not_allowed', 'This host does not own that pane.');
+    if (await this.#inputOwned(entry.name, owner)) return true;
+    const target = `${entry.name}:0.0`;
+    const condition = `#{&&:#{==:#{${INPUT_OWNER_OPTION}},},#{==:#{pane_input_off},0}}`;
+    const command = `set-option -p -t ${target} ${INPUT_OWNER_OPTION} ${owner} ; select-pane -d -t ${target} ; display-message -p acquired`;
+    return await runTmuxInput(this.#socket, ['if-shell', '-F', '-t', target, condition, command, 'display-message -p busy']) === 'acquired';
+  }
+
+  ownsInput(sessionId, owner) { return this.#inputOwned(this.#entry(sessionId).name, inputOwner(owner)); }
+
+  async releaseInput(sessionId, owner) {
+    inputOwner(owner);
+    const target = `${this.#entry(sessionId).name}:0.0`;
+    const condition = `#{==:#{${INPUT_OWNER_OPTION}},${owner}}`;
+    const command = `set-option -pu -t ${target} ${INPUT_OWNER_OPTION} ; select-pane -e -t ${target} ; display-message -p released`;
+    return await runTmuxInput(this.#socket, ['if-shell', '-F', '-t', target, condition, command, 'display-message -p other']) === 'released';
+  }
+
+  async #sendOwnedInput(name, data, options) {
+    const owner = inputOwner(options.inputOwner), target = `${name}:0.0`;
+    const write = async command => {
+      if (options.deadlineMs != null && Date.now() >= options.deadlineMs) throw new TerminalHostError('input_expired', 'Terminal input expired before delivery.');
+      const condition = `#{&&:#{==:#{${INPUT_OWNER_OPTION}},${owner}},#{==:#{pane_input_off},1}}`;
+      // The command queue does not yield between enable, write and disable:
+      // attached clients cannot replace a paste while it waits for its badge.
+      const guarded = `select-pane -e -t ${target} ; ${command} ; select-pane -d -t ${target} ; display-message -p sent`;
+      if (await runTmuxInput(this.#socket, ['if-shell', '-F', '-t', target, condition, guarded, 'display-message -p other']) !== 'sent')
+        throw new TerminalHostError('input_owned', 'Input ownership changed; no input was sent.');
+    };
+    const submitted = defaultTmux.submittedTextFromInput(data);
+    if (submitted != null && submitted !== '') {
+      const buffer = `supercode-input-${randomUUID()}`;
+      await runTmuxInput(this.#socket, ['load-buffer', '-b', buffer, '-'], submitted);
+      try { await write(`paste-buffer -d -p -b ${buffer} -t ${target}`); }
+      finally { await runTmuxInput(this.#socket, ['delete-buffer', '-b', buffer]).catch(() => {}); }
+      if (options.submitMode !== 'none') { await sleep(SINGLE_SUBMIT_DELAY_MS); await write(`send-keys -t ${target} Enter`); }
+      return 'submitted-paste';
+    }
+    if (submitted === '' && options.submitMode === 'none') return 'submitted-line';
+    const bytes = Buffer.from(data.replace(/\n/gu, '\r'));
+    if (bytes.length) await write(`send-keys -H -t ${target} ${[...bytes].map(byte => byte.toString(16)).join(' ')}`);
+    return submitted === '' ? 'submitted-line' : 'keystream';
+  }
+
   async bindContext(sessionId, contextKey) {
     assertContextKey(contextKey);
     const entry = this.#entry(sessionId);
@@ -339,11 +408,10 @@ export class TmuxTerminalHost {
     }
     const attach = this.#attachSocket ?? (await import('./substrate/tmux-stream.js')).attachTmuxTerminalSocket;
     const attachment = await attach({
-      authorizeInput: grant.mode === 'control'
-        ? undefined
-        : () => {
-            throw new TerminalHostError('input_not_allowed', 'This is a read-only terminal attachment.');
-          },
+      authorizeInput: async () => {
+        if (grant.mode !== 'control') throw new TerminalHostError('input_not_allowed', 'This is a read-only terminal attachment.');
+        if (await this.#inputOwned(grant.name)) throw new TerminalHostError('input_owned', 'This pane is confirming another input; no input was sent.');
+      },
       errorLabel: 'supercode',
       readOnly: grant.mode === 'observe',
       ...(grant.mode === 'control' && size.cols ? { cols: size.cols } : {}),
@@ -674,10 +742,12 @@ export class PtyTerminalHost {
 
   async sendInput(sessionId, data, options = {}) {
     const entry = this.#live(sessionId);
+    if ((entry.inputOwner ?? null) !== (options.inputOwner ?? null)) throw new TerminalHostError('input_owned', 'This pane is confirming another input; no input was sent.');
     if (typeof data !== 'string') throw new Error('Input data must be a string.');
     const deadline = options.deadlineMs;
     const write = (bytes) => {
       if (deadline !== undefined && deadline - Date.now() <= 0) throw new Error('Terminal input expired before delivery.');
+      if ((entry.inputOwner ?? null) !== (options.inputOwner ?? null)) throw new TerminalHostError('input_owned', 'Input ownership changed; no input was sent.');
       this.#live(entry.id).child.write(bytes);
     };
     const submit = async () => {
@@ -702,6 +772,18 @@ export class PtyTerminalHost {
     return 'keystream';
   }
 
+  acquireInput(sessionId, owner) {
+    const entry = this.#live(sessionId); inputOwner(owner);
+    if (entry.inputOwner && entry.inputOwner !== owner) return false;
+    entry.inputOwner = owner; return true;
+  }
+  ownsInput(sessionId, owner) { return this.#live(sessionId).inputOwner === inputOwner(owner); }
+  releaseInput(sessionId, owner) {
+    const entry = this.#live(sessionId); inputOwner(owner);
+    if (entry.inputOwner !== owner) return false;
+    entry.inputOwner = null; return true;
+  }
+
   async bindContext(sessionId, contextKey) {
     assertContextKey(contextKey);
     this.#entry(sessionId).contextKey = contextKey;
@@ -777,6 +859,7 @@ export class PtyTerminalHost {
           socket.close(1008, 'terminal access ended');
           return;
         }
+        if (entry.inputOwner) throw new TerminalHostError('input_owned', 'This pane is confirming another input; no input was sent.');
         if (this.#sessions.has(entry.id) && !entry.exit) entry.child.write(message.data);
       } catch (error) {
         refuse(error);
@@ -1020,6 +1103,9 @@ export class PaneServerHost {
   createSession(input) { return this.#request('createSession', [input]); }
   capture(sessionId, options = {}) { return this.#request('capture', [sessionId, options]); }
   sendInput(sessionId, data, options = {}) { return this.#request('sendInput', [sessionId, data, options]); }
+  acquireInput(sessionId, owner) { return this.#request('acquireInput', [sessionId, owner]); }
+  ownsInput(sessionId, owner) { return this.#request('ownsInput', [sessionId, owner]); }
+  releaseInput(sessionId, owner) { return this.#request('releaseInput', [sessionId, owner]); }
   closeSession(sessionId) { return this.#request('closeSession', [sessionId]); }
   renameWindow(sessionId, title) { return this.#request('renameWindow', [sessionId, title]); }
   issueAttachment(sessionId, options = {}) { return this.#request('issueAttachment', [sessionId, options]); }
@@ -1851,23 +1937,24 @@ function composerMatches(value, wanted) {
   return offsets.has(wanted.length);
 }
 
-/** Claude collapses a multi-line paste to `[Pasted text #N +K lines]`, and its composer then shows that placeholder,
- * never the text. The placeholder (as shown) when it can stand for `text`: K is the pasted text's line breaks (the
+/** Claude collapses a long single-line paste to `[Pasted text #N]` and a multi-line paste to
+ * `[Pasted text #N +K lines]`. The placeholder (as shown) when it can stand for `text`: K is the pasted text's line breaks (the
  * trimmed text's, or the sent payload's with its closing newline). Which paste it is, #N, only the paste itself
  * tells: a caller holds the placeholder its own paste produced and accepts no other. */
 function pastePlaceholder(composer, text) {
   const shown=String(composer??'').trim();
-  const placeholder=/^\[Pasted text #\d+ \+(\d+) lines?\]$/u.exec(shown);
+  const placeholder=/^\[Pasted text #\d+(?: \+(\d+) lines?)?\]$/u.exec(shown);
   if(!placeholder)return null;
   const breaks=value=>(value.match(/\n/gu)??[]).length;
-  return [breaks(String(text).trim()),breaks(`${text}\n`)].includes(Number(placeholder[1]))?shown:null;
+  return (placeholder[1]===undefined?breaks(String(text).trim())===0:
+    [breaks(String(text).trim()),breaks(`${text}\n`)].includes(Number(placeholder[1])))?shown:null;
 }
 
 /** Undo only text this input wrote, including when a turn started meanwhile.
  * Never Enter, Escape, or Ctrl-C: restoration must not submit or stop work.
  * `pasted`: the `[Pasted text #N …]` placeholder this input's own paste produced. Only that one is cleared: another
  * of the same size is a person's own paste. */
-export async function restoreComposerInput(host, sessionId, kind, text, { pasted = null } = {}) {
+export async function restoreComposerInput(host, sessionId, kind, text, { pasted = null, inputOwner: owner = null } = {}) {
   const read=async()=>composerText(kind,await host.capture(sessionId,{preserveEscapes:true}));
   let remaining=await read();
   if(remaining==='')return {restored:true};
@@ -1875,14 +1962,14 @@ export async function restoreComposerInput(host, sessionId, kind, text, { pasted
   const lines=remaining.split('\n').length+2;
   for(let line=0;line<lines;line++) {
     if(await read()!==remaining)return {restored:false,reason:'composer-changed',remaining};
-    await host.sendInput(sessionId,'\u0005\u0015',{submitMode:'none'});
+    await host.sendInput(sessionId,'\u0005\u0015',{submitMode:'none',...(owner ? { inputOwner: owner } : {})});
     await sleep(100);
     let after=await read();
     if(after==='')return {restored:true};
     if(after===null||!remaining.includes(after))return {restored:false,reason:'composer-changed',remaining};
     remaining=after;
     if(await read()!==remaining)return {restored:false,reason:'composer-changed',remaining};
-    await host.sendInput(sessionId,'\u007f',{submitMode:'none'});
+    await host.sendInput(sessionId,'\u007f',{submitMode:'none',...(owner ? { inputOwner: owner } : {})});
     await sleep(100);after=await read();
     if(after==='')return {restored:true};
     if(after===null||!remaining.replace(/\n/g,'').includes(after.replace(/\n/g,'')))return {restored:false,reason:'composer-changed',remaining};
@@ -1894,7 +1981,21 @@ export async function restoreComposerInput(host, sessionId, kind, text, { pasted
 /** Paste only into a stable idle composer. A failed paste is restored; an
  * unreadable/concurrently changed composer returns an explicit repair obligation. */
 export async function deliverComposerInput(host, sessionId, kind, text, { deadlineMs = Date.now() + 10_000, signal } = {}) {
-  const capture=()=>host.capture(sessionId,{preserveEscapes:true});
+  if (kind !== 'claude-code') return deliverOwnedComposerInput(host, sessionId, kind, text, { deadlineMs, signal });
+  const owner = randomUUID();
+  try {
+    if (!host.acquireInput || !await host.acquireInput(sessionId, owner)) return { delivered: false, reason: 'input-ownership-unavailable; no input pasted' };
+    return await deliverOwnedComposerInput(host, sessionId, kind, text, { deadlineMs, signal, owner });
+  } catch (error) { return { delivered: false, reason: error?.message ?? String(error) }; }
+  finally { await Promise.resolve(host.releaseInput?.(sessionId, owner)).catch(() => {}); }
+}
+
+async function deliverOwnedComposerInput(host, sessionId, kind, text, { deadlineMs, signal, owner = null }) {
+  const capture=async()=>{
+    if (owner && !await host.ownsInput(sessionId, owner)) throw new TerminalHostError('input_owned', 'Input ownership changed; the composer is preserved.');
+    return host.capture(sessionId,{preserveEscapes:true});
+  };
+  const inputOptions = owner ? { inputOwner: owner } : {};
   const read=async()=>composerText(kind,await capture());
   const expired=()=>signal?.aborted||Date.now()>=deadlineMs;
   let touched=false;
@@ -1904,7 +2005,7 @@ export async function deliverComposerInput(host, sessionId, kind, text, { deadli
   const failed=async (reason, evidence={})=>{
     if(!touched)return {delivered:false,reason,...evidence};
     let restored;
-    try{restored=await restoreComposerInput(host,sessionId,kind,text,{pasted});}catch(error){restored={restored:false,reason:error.message};}
+    try{restored=await restoreComposerInput(host,sessionId,kind,text,{pasted,...inputOptions});}catch(error){restored={restored:false,reason:error.message};}
     return {delivered:false,reason,...evidence,restored:restored.restored,cleanup_required:!restored.restored,cleanup_reason:restored.reason,cleanup_remaining:restored.remaining};
   };
   if(expired())return failed('deadline');
@@ -1924,22 +2025,35 @@ export async function deliverComposerInput(host, sessionId, kind, text, { deadli
   if(expired())return failed('deadline');
   try {
     touched=true;
-    const delivery=await host.sendInput(sessionId,`${text}\n`,{submitMode:'none',deadlineMs});
-    let pasted=false;
-    for(let attempt=0;attempt<10&&!expired();attempt++) {
+    const delivery=await host.sendInput(sessionId,`${text}\n`,{submitMode:'none',deadlineMs,...inputOptions});
+    let pasteVisible=false;
+    while(!expired()) {
       await sleep(100);
-      if(holds(await read())){pasted=true;break;}
+      if(holds(await read())){pasteVisible=true;break;}
+    }
+    // A final paint at the deadline still belongs to this paste. Submit it
+    // once; its caller must confirm the native user-message receipt.
+    if(expired()) {
+      if(!signal?.aborted&&holds(await read())) {
+        await host.sendInput(sessionId,'\r',{submitMode:'single',deadlineMs:Date.now()+1000,...inputOptions});
+        return {delivered:false,reason:'native-transcript-confirmation-required',delivery};
+      }
+      return failed('paste-unconfirmed');
     }
-    if(!pasted)return failed('paste-unconfirmed');
+    if(!pasteVisible)return failed('paste-unconfirmed');
     for(let attempt=0;attempt<3;attempt++) {
       if(expired())return failed('deadline');
       const screen=await capture();
       if(!holds(composerText(kind,screen)))return failed('composer-changed');
       if(expired())return failed('deadline');
-      await host.sendInput(sessionId,'\r',{submitMode:'single',deadlineMs});
+      await host.sendInput(sessionId,'\r',{submitMode:'single',deadlineMs,...inputOptions});
       for(let poll=0;poll<10&&!expired();poll++) {
         await sleep(100);
         const current=await read();
+        // This helper reports its transport submit to the standalone terminal
+        // controller. Teams-owned Claude panes use the retained native-receipt
+        // queue; changing this SDK result would mark every controller launch
+        // failed even when its input was submitted.
         if(current==='')return kind === 'claude-code' ? {delivered:true,delivery,path:'composer_submit'} : {delivered:false,reason:'native-transcript-confirmation-required',delivery};
         if(!holds(current))return failed('submission-unconfirmed');
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-terminal",
-  "version": "0.2.66",
+  "version": "0.2.68",
   "type": "module",
   "description": "Optional leak-safe terminal and tmux host adapter for Volter Harness frontends",
   "exports": {

package/substrate/pane-server.mjs

@@ -32,7 +32,7 @@ function leave() {
   setTimeout(() => { server.close(); for (const connection of clients) connection.end(); setTimeout(done, 500); }, 3_000).unref?.();
 }
 
-const OPS = new Set(['listSessions', 'createSession', 'capture', 'sendInput', 'closeSession', 'renameWindow', 'issueAttachment', 'bindContext']);
+const OPS = new Set(['listSessions', 'createSession', 'capture', 'sendInput', 'acquireInput', 'ownsInput', 'releaseInput', 'closeSession', 'renameWindow', 'issueAttachment', 'bindContext']);
 
 function scheduleIdleExit() {
   clearTimeout(idleTimer);

package/substrate/tmux.js

@@ -63,7 +63,7 @@ export async function createSession({ command, cwd, env, name, owner, ownerOptio
     // it. When an agent's session started the server (or is the launcher), that includes the session's own harness
     // identity, so a new pane would resolve as that session. A pane's identity is only what its own session sets:
     // every identity variable the server or the launcher holds and the session does not set is unset in the pane.
-    const identity = /^(CLAUDECODE|CLAUDE_CODE_SESSION_ID|CLAUDE_CODE_ENTRYPOINT|CODEX_THREAD_ID|CODEX_SESSION_ID|SUPERCODE_CALLER|SUPERCODE_CALLER_NAME|SUPERCODE_AGENT_[A-Z_]+)$/;
+    const identity = /^(CLAUDECODE|CLAUDE_CODE_SESSION_ID|CLAUDE_CODE_ENTRYPOINT|CODEX_THREAD_ID|CODEX_SESSION_ID|SUPERCODE_CALLER|SUPERCODE_CALLER_NAME|SUPERCODE_LAUNCHED_BY|SUPERCODE_AGENT_[A-Z_]+)$/;
     const serverNames = await runAsync("tmux", tmuxArgs(socket, ["show-environment", "-g"]))
         .then((out) => out.split("\n").map((line) => /^([A-Za-z_][A-Za-z0-9_]*)=/.exec(line)?.[1]).filter((name) => Boolean(name)))
         .catch(() => []); // no server yet: the one this creates starts from this launcher's environment