handmux 0.23.0 → 0.24.0

package/dist/public/assets/pcm-worklet-CxcDy7PB.js

@@ -0,0 +1 @@
+(function(){"use strict";class s extends AudioWorkletProcessor{process(e){const r=e[0]&&e[0][0];return r&&r.length&&this.port.postMessage(r.slice(0)),!0}}registerProcessor("pcm-forwarder",s)})();

package/{public → dist/public}/index.html

@@ -22,7 +22,7 @@
     <link rel="apple-touch-icon" href="/icons/apple-touch-icon.png?v=2" />
 
     <!-- Inline boot splash: paints instantly (before the JS bundle loads) so a cold launch shows the
-         brand, not a blank dark screen. main.jsx calls window.__hideBootSplash() once React has painted.
+         brand, not a blank dark screen. main.tsx calls window.__hideBootSplash() once React has painted.
          Until then it must remain visible: a slow bundle should never expose the still-empty app root. -->
     <style>
       html, body { margin: 0; background: #1a1b1e; } /* opaque dark from frame one — no wallpaper showing through */
@@ -48,8 +48,8 @@
       @keyframes bootDot { 0%,100% { opacity: .22; transform: translateY(0); } 40% { opacity: 1; transform: translateY(-3px); } }
       @media (prefers-reduced-motion: reduce) { .boot-glow, .boot-dots i { animation: none; opacity: .8; } }
     </style>
-    <script type="module" crossorigin src="/assets/index-D1DWcC5u.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-C3N7OkyP.css" media="print" onload="this.media='all'"><noscript><link rel="stylesheet" crossorigin href="/assets/index-C3N7OkyP.css"></noscript>
+    <script type="module" crossorigin src="/assets/index-D4VP5t8h.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CicdY9E9.css" media="print" onload="this.media='all'"><noscript><link rel="stylesheet" crossorigin href="/assets/index-CicdY9E9.css"></noscript>
   </head>
   <body>
     <div id="boot-splash" aria-hidden="true">
@@ -61,8 +61,9 @@
       <div class="boot-dots"><i></i><i></i><i></i></div>
     </div>
     <div id="root"></div>
+    <div id="overlay-root"></div>
     <script>
-      // Hide the splash once the app has painted (main.jsx), but keep it up at least ~650ms so the glow
+      // Hide the splash once the app has painted (main.tsx), but keep it up at least ~650ms so the glow
       // is actually seen, not a flicker. Slow or unavailable bundles leave this branded loading state visible.
       window.__bootStart = Date.now();
       window.__hideBootSplash = function () {

package/{src → dist/src}/agents/claude.js

@@ -13,7 +13,10 @@ import os from 'node:os';
 import { resolveEncodedDirSession, isSessionUuid } from './scanUtils.js';
 import { resolveByExecutable, executableBasename } from './processIdentity.js';
 import { createTranscriptParser, parseTranscript } from '../transcriptParse.js';
-
+const record = (value) => (value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? value
+    : null);
+const text = (value) => typeof value === 'string' ? value : '';
 // The NATIVE installer names the real binary by version (~/.local/share/claude/versions/2.1.196 —
 // ~/.local/bin/claude is only a symlink to it), and tmux #{pane_current_command} follows that basename
 // ("2_1_196", dots sanitized to underscores) instead of "claude". ps can't tie it: ps `comm` shows the
@@ -29,61 +32,70 @@ import { createTranscriptParser, parseTranscript } from '../transcriptParse.js';
 // transient negative probe retries after 3s instead of poisoning the pane until server restart.
 const VERSION_COMM_RE = /^\d+[._]\d+[._]\d+$/;
 const CLAUDE_PATH_RE = /claude/;
-
 export async function resolveVersionedComms(panes, run, verdicts = new Map(), opts = {}) {
-  return resolveByExecutable(panes, run, verdicts, {
-    candidate: (cmd) => VERSION_COMM_RE.test(cmd),
-    normalized: 'claude',
-    matches: (exe, cmd) => {
-      const base = executableBasename(exe);
-      return (base === cmd || base === cmd.replace(/_/g, '.')) && CLAUDE_PATH_RE.test(exe);
-    },
-    ...opts,
-  });
+    return resolveByExecutable(panes, run, verdicts, {
+        candidate: (cmd) => VERSION_COMM_RE.test(cmd),
+        normalized: 'claude',
+        matches: (exe, cmd) => {
+            const base = executableBasename(exe);
+            return (base === cmd || base === cmd.replace(/_/g, '.')) && CLAUDE_PATH_RE.test(exe);
+        },
+        ...opts,
+    });
 }
-
 // Build the 需要你 one-liner for a PermissionRequest, from the tool it's gating on (PermissionRequest
 // carries tool_name + tool_input, unlike the later permission_prompt Notification which only has an
 // English message).
 function permMsg(body) {
-  const t = body.tool_name;
-  if (t === 'AskUserQuestion') {
-    const q = body.tool_input && body.tool_input.questions && body.tool_input.questions[0];
-    const text = (q && (q.question || q.header)) || '';
-    return text ? `需要你回答：${text}` : '需要你回答';
-  }
-  if (t === 'ExitPlanMode') return '需要你批准计划';
-  return t ? `需要你授权：${t}` : '需要你';
+    const t = text(body.tool_name);
+    if (t === 'AskUserQuestion') {
+        const toolInput = record(body.tool_input);
+        const questions = toolInput?.questions;
+        const question = Array.isArray(questions) ? record(questions[0]) : null;
+        const prompt = text(question?.question) || text(question?.header);
+        return prompt ? `需要你回答：${prompt}` : '需要你回答';
+    }
+    if (t === 'ExitPlanMode')
+        return '需要你批准计划';
+    return t ? `需要你授权：${t}` : '需要你';
 }
-
 // Friendly Chinese for the StopFailure error type (matcher values, see the hooks doc). The payload shape
 // isn't verified against a live rate-limit yet, so read the type defensively from several likely fields and
 // always fall back to a bare 本轮出错 — a wrong field name degrades to the generic label, never throws.
 const STOPFAIL_LABEL = {
-  rate_limit: '触发限流', overloaded: '服务过载', authentication_failed: '认证失败',
-  oauth_org_not_allowed: '组织未授权', billing_error: '额度/账单问题', invalid_request: '请求无效',
-  model_not_found: '模型不可用', server_error: '服务端错误', max_output_tokens: '输出超长', unknown: '未知错误',
+    rate_limit: '触发限流', overloaded: '服务过载', authentication_failed: '认证失败',
+    oauth_org_not_allowed: '组织未授权', billing_error: '额度/账单问题', invalid_request: '请求无效',
+    model_not_found: '模型不可用', server_error: '服务端错误', max_output_tokens: '输出超长', unknown: '未知错误',
 };
-function stopFailMsg(body = {}) {
-  const type = body.error_type || body.reason || body.type
-    || (body.error && (typeof body.error === 'string' ? body.error : body.error.type)) || '';
-  if (STOPFAIL_LABEL[type]) return STOPFAIL_LABEL[type];
-  const raw = typeof body.error === 'string' ? body.error : (body.message || '');
-  return raw ? String(raw).replace(/\s+/g, ' ').trim().slice(0, 80) : '';
+function stopFailMsg(body) {
+    const error = record(body.error);
+    const type = text(body.error_type) || text(body.reason) || text(body.type)
+        || text(body.error) || text(error?.type);
+    const label = STOPFAIL_LABEL[type];
+    if (label)
+        return label;
+    const raw = text(body.error) || text(body.message);
+    return raw ? String(raw).replace(/\s+/g, ' ').trim().slice(0, 80) : '';
 }
-
 // Build the 进行中 one-liner for a resume (PostToolUse after the user answered/approved), surfacing the
 // choice they just made — AskUserQuestion stores it in tool_input.answers, keyed by question.
 function resumeMsg(body) {
-  const a = (body.tool_input && body.tool_input.answers) || (body.tool_response && body.tool_response.answers);
-  if (a && typeof a === 'object') {
-    const picks = Object.values(a).flat().filter(Boolean).join('、');
-    if (picks) return `已答：${picks}`;
-  }
-  if (body.tool_name === 'ExitPlanMode') return '已批准计划';
-  return '';
+    const toolInput = record(body.tool_input);
+    const toolResponse = record(body.tool_response);
+    const answers = record(toolInput?.answers) || record(toolResponse?.answers);
+    if (answers) {
+        const picks = Object.values(answers)
+            .flatMap((value) => Array.isArray(value) ? value : [value])
+            .filter(Boolean)
+            .map(String)
+            .join('、');
+        if (picks)
+            return `已答：${picks}`;
+    }
+    if (body.tool_name === 'ExitPlanMode')
+        return '已批准计划';
+    return '';
 }
-
 // Map a hook event (src + raw Claude payload) to a notification "kind". Pure — no I/O, easy to test.
 //   stop                       → done       (turn finished; carries last message)
 //   prompt                     → working    (UserPromptSubmit; carries the prompt)
@@ -109,51 +121,61 @@ function resumeMsg(body) {
 //   stopfail                   → error      (StopFailure: the turn ended on an API error — no Stop fires, so
 //                                             this is the only signal that un-sticks the pane from 进行中)
 //   anything else              → null       (ignored: auth_success, elicitation_*, etc.)
-export function classifyClaude(src, body = {}) {
-  if (src === 'stop') return { kind: 'done', msg: body.last_assistant_message || '' };
-  if (src === 'prompt') return { kind: 'working', msg: body.prompt || '' };
-  if (src === 'resume') return { kind: 'working', msg: resumeMsg(body) };
-  if (src === 'permreq') return { kind: 'permission', msg: permMsg(body) };
-  if (src === 'compacting') return { kind: 'compacting', msg: '' };   // PreCompact: 压缩上下文进行中
-  if (src === 'compact') return null;                                 // PostCompact: done → clear 压缩中/进行中
-  if (src === 'stopfail') return { kind: 'error', msg: stopFailMsg(body) }; // turn died on an API error
-  if (src === 'end') return { kind: 'end' };
-  if (src === 'start') return null;                                   // SessionStart: only (re)binds pane→session
-  if (src === 'notify') {
-    if (body.notification_type === 'idle_prompt') return { kind: 'idle', msg: body.message || '' };
-    if (body.notification_type === 'permission_prompt') return { kind: 'permission', msg: body.message || '' };
-  }
-  return null;
+export function classifyClaude(src, rawBody = {}) {
+    const body = record(rawBody) || {};
+    if (src === 'stop')
+        return { kind: 'done', msg: text(body.last_assistant_message) };
+    if (src === 'prompt')
+        return { kind: 'working', msg: text(body.prompt) };
+    if (src === 'resume')
+        return { kind: 'working', msg: resumeMsg(body) };
+    if (src === 'permreq')
+        return { kind: 'permission', msg: permMsg(body) };
+    if (src === 'compacting')
+        return { kind: 'compacting', msg: '' }; // PreCompact: 压缩上下文进行中
+    if (src === 'compact')
+        return null; // PostCompact: done → clear 压缩中/进行中
+    if (src === 'stopfail')
+        return { kind: 'error', msg: stopFailMsg(body) }; // turn died on an API error
+    if (src === 'end')
+        return { kind: 'end' };
+    if (src === 'start')
+        return null; // SessionStart: only (re)binds pane→session
+    if (src === 'notify') {
+        if (body.notification_type === 'idle_prompt')
+            return { kind: 'idle', msg: text(body.message) };
+        if (body.notification_type === 'permission_prompt')
+            return { kind: 'permission', msg: text(body.message) };
+    }
+    return null;
 }
-
 export const projectsDir = (home = os.homedir()) => path.join(home, '.claude', 'projects');
-
 export const claude = {
-  id: 'claude',
-  label: 'Claude Code',
-  procName: 'claude',
-  // Which tmux #{pane_current_command} values mean "this agent is still the pane's foreground app" (inbox
-  // liveness). Claude sets its process title to "claude", so an exact single-name match is right — for
-  // native-install machines (whose comm is the VERSION string) resolveVersionedComms below normalizes the
-  // cmd back to 'claude' at ingest, keeping every match here exact-name.
-  procNames: ['claude'],
-  // The `claude` CLI sets its process title to "claude" (verified via ps): match the program token at the
-  // start of argv — bare "claude", "claude --continue", or an absolute path ending in /claude. Anchored so
-  // "vim claude.js" / "node build/claude.js" don't match.
-  procMatch: /^(\S*\/)?claude(\s|$)/,
-  takeoverPrefix: 'cc', // tmux session name prefix for a takeover (cc-<label>-<n>)
-  classify: classifyClaude,
-  transcript: { createParser: createTranscriptParser, parse: parseTranscript },
-  sessions: {
-    isId: isSessionUuid,
-    dirOptKey: 'projectsDir', // scanOrphans option that overrides `dir` (back-compat + tests)
-    dir: projectsDir,
-    // Resolve a cwd to its Claude session within `dir`: newest jsonl in the encoded project dir whose
-    // recorded cwd matches. Layout: ~/.claude/projects/<enc-cwd>/<uuid>.jsonl.
-    resolve: (dir, cwd, opts = {}) => resolveEncodedDirSession(dir, cwd, opts),
-    // `claude --resume <uuid>` appends to the SAME jsonl with no OS lock, so the takeover kills the original
-    // to guarantee a single writer (see orphans.js).
-    resumeArgs: (id) => ['claude', '--resume', id],
-    resumeCmd: (id) => `claude --resume ${id}`,
-  },
+    id: 'claude',
+    label: 'Claude Code',
+    procName: 'claude',
+    // Which tmux #{pane_current_command} values mean "this agent is still the pane's foreground app" (inbox
+    // liveness). Claude sets its process title to "claude", so an exact single-name match is right — for
+    // native-install machines (whose comm is the VERSION string) resolveVersionedComms below normalizes the
+    // cmd back to 'claude' at ingest, keeping every match here exact-name.
+    procNames: ['claude'],
+    // The `claude` CLI sets its process title to "claude" (verified via ps): match the program token at the
+    // start of argv — bare "claude", "claude --continue", or an absolute path ending in /claude. Anchored so
+    // "vim claude.js" / "node build/claude.js" don't match.
+    procMatch: /^(\S*\/)?claude(\s|$)/,
+    takeoverPrefix: 'cc', // tmux session name prefix for a takeover (cc-<label>-<n>)
+    classify: classifyClaude,
+    transcript: { createParser: createTranscriptParser, parse: parseTranscript },
+    sessions: {
+        isId: isSessionUuid,
+        dirOptKey: 'projectsDir', // scanOrphans option that overrides `dir` (back-compat + tests)
+        dir: projectsDir,
+        // Resolve a cwd to its Claude session within `dir`: newest jsonl in the encoded project dir whose
+        // recorded cwd matches. Layout: ~/.claude/projects/<enc-cwd>/<uuid>.jsonl.
+        resolve: (dir, cwd, opts = {}) => resolveEncodedDirSession(dir, cwd, opts),
+        // `claude --resume <uuid>` appends to the SAME jsonl with no OS lock, so the takeover kills the original
+        // to guarantee a single writer (see orphans.js).
+        resumeArgs: (id) => ['claude', '--resume', id],
+        resumeCmd: (id) => `claude --resume ${id}`,
+    },
 };

package/dist/src/agents/codex.js

@@ -0,0 +1,217 @@
+// Codex process/session discovery. App Server owns chat, approvals, stopping, inbox state and exact thread
+// identity; plain Codex is identified only as a live process until the user opts into managed mode.
+import path from 'node:path';
+import os from 'node:os';
+import { promises as fsp } from 'node:fs';
+import { readHead, readTail, firstCwd, isSessionUuid } from './scanUtils.js';
+import { resolveByExecutable, executableBasename } from './processIdentity.js';
+import { createCodexTranscriptParser, isCodexSyntheticUserText, parseCodexTranscript, } from '../codexTranscriptParse.js';
+const isRecord = (value) => (value !== null && typeof value === 'object' && !Array.isArray(value));
+export const sessionsDir = (home = os.homedir()) => path.join(home, '.codex', 'sessions');
+// A Codex rollout file is `rollout-<ISO-ish timestamp>-<uuid>.jsonl`; the session id Codex's `resume` wants
+// is that trailing uuid. Pull it out of the basename.
+export function rolloutSessionId(name) {
+    const m = String(name).match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i);
+    return m?.[1] || null;
+}
+const UUID_PARTS = '([0-9a-f]{8})\\s*-\\s*([0-9a-f]{4})\\s*-\\s*([0-9a-f]{4})\\s*-\\s*([0-9a-f]{4})\\s*-\\s*([0-9a-f]{12})';
+function lastUuidAfter(text, prefix) {
+    const matches = [...String(text || '').matchAll(new RegExp(`${prefix}\\s*${UUID_PARTS}`, 'gi'))];
+    const match = matches.at(-1);
+    if (!match)
+        return null;
+    const parts = match.slice(1, 6);
+    return parts.length === 5 && parts.every(Boolean) ? parts.join('-').toLowerCase() : null;
+}
+// A normal Codex exit prints the exact command for the session that just exited. Keep this deliberately
+// stricter than a generic `codex resume` search so conversation text or shell history is not mistaken for
+// the current exit notice.
+export function codexExitSessionId(text) {
+    return lastUuidAfter(text, 'To continue this session, run\\s+codex\\s+resume');
+}
+// Last user turn out of a Codex rollout tail, for a recognizable one-line label. Codex records turns as
+// response_item messages: {payload:{type:'message',role:'user',content:[{type:'input_text',text}]}} (and a
+// flatter {type:'message',role:'user',...} in some versions). Skips the synthetic context turns Codex
+// injects (including repository instructions after a resume). Best-effort → '' on miss.
+export function codexUserSnippet(tailText, max = 80) {
+    const rows = String(tailText).split('\n');
+    for (let i = rows.length - 1; i >= 0; i--) {
+        const line = rows[i]?.trim() ?? '';
+        if (!line || line[0] !== '{')
+            continue;
+        let data;
+        try {
+            data = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!isRecord(data))
+            continue;
+        const payload = isRecord(data.payload) ? data.payload : null;
+        const msg = payload?.type === 'message' ? payload
+            : data.type === 'message' ? data : null;
+        if (!msg || msg.role !== 'user')
+            continue;
+        const c = msg.content;
+        let text = '';
+        if (typeof c === 'string')
+            text = c;
+        else if (Array.isArray(c))
+            text = c
+                .filter((block) => isRecord(block)
+                && (block.type === 'input_text' || block.type === 'text'))
+                .map((block) => typeof block.text === 'string' ? block.text : '')
+                .join(' ');
+        if (!text || isCodexSyntheticUserText(text))
+            continue;
+        text = text.replace(/\s+/g, ' ').trim();
+        if (!text)
+            continue;
+        return text.length > max ? `${text.slice(0, max)}…` : text;
+    }
+    return '';
+}
+// The npm-installed Codex launcher leaves `node` as tmux's pane_current_command. Never accept that
+// ambiguous name by itself: prove a foreground process on the same TTY has a real executable named
+// `codex` from a Codex path, then normalize the pane to the canonical agent name.
+export async function resolveCodexComms(panes, run, verdicts = new Map(), opts = {}) {
+    return resolveByExecutable(panes, run, verdicts, {
+        candidate: (cmd) => cmd === 'node',
+        normalized: 'codex',
+        matches: (exe) => /^codex(?:\.exe)?$/i.test(executableBasename(exe)) && /codex/i.test(exe),
+        ...opts,
+    });
+}
+// Walk the date-nested sessions tree (…/YYYY/MM/DD/rollout-*.jsonl) newest-first and collect up to `limit`
+// rollout files with their mtimes. Unlike Claude's flat encoded-cwd dir, Codex partitions by date, so we
+// descend year→month→day in descending name order and stop once we have enough — the newest sessions are
+// always in the latest date dir, so a live orphan's session is found without reading the whole history.
+async function recentRollouts(dir, limit = 80) {
+    const out = [];
+    async function descend(d, depth) {
+        if (out.length >= limit)
+            return;
+        let entries;
+        try {
+            entries = await fsp.readdir(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        if (depth < 3) {
+            const subdirs = entries.filter((e) => e.isDirectory()).map((e) => e.name).sort().reverse();
+            for (const name of subdirs) {
+                if (out.length >= limit)
+                    break;
+                await descend(path.join(d, name), depth + 1);
+            }
+            return;
+        }
+        const files = entries.filter((e) => e.isFile() && e.name.startsWith('rollout-') && e.name.endsWith('.jsonl'));
+        for (const f of files) {
+            try {
+                out.push({ file: path.join(d, f.name), name: f.name, mtime: (await fsp.stat(path.join(d, f.name))).mtimeMs });
+            }
+            catch { /* gone */ }
+        }
+    }
+    await descend(dir, 0);
+    out.sort((a, b) => b.mtime - a.mtime);
+    return out.slice(0, limit);
+}
+// Resolve one known App Server thread id to its exact rollout. This never falls back by cwd: several
+// Codex panes can share a project, while the UUID suffix is the durable one-to-one session identity.
+const rolloutPathCache = new Map();
+export async function resolveCodexRollout(dir, sessionId) {
+    if (!isSessionUuid(sessionId))
+        return null;
+    const key = `${dir}\0${sessionId}`;
+    const cached = rolloutPathCache.get(key);
+    if (cached) {
+        try {
+            await fsp.access(cached);
+            return cached;
+        }
+        catch {
+            rolloutPathCache.delete(key);
+        }
+    }
+    const suffix = `-${sessionId}.jsonl`;
+    let found = null;
+    async function descend(current, depth) {
+        if (found)
+            return;
+        let entries;
+        try {
+            entries = await fsp.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        if (depth < 3) {
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                await descend(path.join(current, entry.name), depth + 1);
+                if (found)
+                    return;
+            }
+            return;
+        }
+        const match = entries.find((entry) => entry.isFile()
+            && entry.name.startsWith('rollout-') && entry.name.endsWith(suffix));
+        if (match)
+            found = path.join(current, match.name);
+    }
+    await descend(dir, 0);
+    if (found)
+        rolloutPathCache.set(key, found);
+    return found;
+}
+// Resolve a live orphan's cwd to its Codex session: the newest rollout whose recorded cwd matches. Same
+// shape as Claude's resolver ({ sessionId, state, snippet, lastActivity }) so the orphan engine is agnostic.
+export async function resolveCodexSession(dir, cwd, { busyMs = 8000, now = Date.now } = {}) {
+    const files = await recentRollouts(dir);
+    for (const { file, name, mtime } of files) {
+        let head;
+        try {
+            head = await readHead(file);
+        }
+        catch {
+            continue;
+        }
+        if (firstCwd(head) !== cwd)
+            continue;
+        const sessionId = rolloutSessionId(name);
+        if (!sessionId)
+            continue;
+        let snippet = '';
+        try {
+            snippet = codexUserSnippet(await readTail(file));
+        }
+        catch { /* best effort */ }
+        return { sessionId, state: now() - mtime < busyMs ? 'busy' : 'idle', snippet, lastActivity: Math.round(mtime), file };
+    }
+    return {};
+}
+export const codex = {
+    id: 'codex',
+    label: 'Codex CLI',
+    procName: 'codex',
+    // Ambiguous `node` launchers are normalized by resolveCodexComms only after real-executable proof.
+    procNames: ['codex'],
+    procMatch: /^(\S*\/)?codex(\s|$)/,
+    takeoverPrefix: 'cx', // tmux session name prefix for a takeover (cx-<label>-<n>)
+    transcript: { createParser: createCodexTranscriptParser, parse: parseCodexTranscript },
+    sessions: {
+        isId: isSessionUuid,
+        dirOptKey: 'sessionsDir', // scanOrphans option that overrides `dir`
+        dir: sessionsDir,
+        resolve: (dir, cwd, opts = {}) => resolveCodexSession(dir, cwd, opts),
+        // `codex resume <uuid>` continues the session from its rollout file.
+        resumeArgs: (id) => ['codex', 'resume', id],
+        resumeCmd: (id) => `codex resume ${id}`,
+        managedResumeCmd: (id) => `handmux codex resume ${id}`,
+    },
+};

package/{src → dist/src}/agents/index.js

@@ -3,19 +3,19 @@
 // engine consume drivers through this list, so process and session behavior stays centralized.
 import { claude } from './claude.js';
 import { codex } from './codex.js';
-
 // Order matters for proc matching (parseAgentProcs takes the first match) — keep the patterns disjoint so
 // order is irrelevant in practice, but list the flagship first.
 export const AGENTS = [claude, codex];
-
-const BY_ID = new Map(AGENTS.map((a) => [a.id, a]));
-
+const BY_ID = new Map(AGENTS.map((agent) => [agent.id, agent]));
 // Resolve a driver by id. State-file entries written before agents existed carry no `agent` field, and the
 // only writer then was Claude — so an unknown/missing id defaults to Claude (back-compat, never undefined).
-export function getAgent(id) { return BY_ID.get(id) || claude; }
-
+export function getAgent(id) {
+    return typeof id === 'string' ? BY_ID.get(id) || claude : claude;
+}
 // The driver whose foreground process this tmux #{pane_current_command} is, or null. Used by the inbox to
 // decide a recorded pane is still running its agent (vs. the agent having exited to a shell). Matches the
 // canonical procName only — never the ambiguous extras in procNames (e.g. Codex's 'node'); native-install
 // Claude binaries (comm = version string) are normalized to 'claude' at ingest (resolveVersionedComms).
-export function agentForProc(cmd) { return AGENTS.find((a) => a.procName === cmd) || null; }
+export function agentForProc(cmd) {
+    return AGENTS.find((agent) => agent.procName === cmd) || null;
+}

package/dist/src/agents/processIdentity.js

@@ -0,0 +1,80 @@
+import { promises as fsp } from 'node:fs';
+import path from 'node:path';
+import { normTty } from './scanUtils.js';
+const SUCCESS_TTL_MS = 30_000;
+const FAILURE_TTL_MS = 3_000;
+// Real executable path of a pid. lsof resolves launch symlinks on macOS; /proc is the cheap Linux path.
+// A transient lsof failure is inconclusive, not a negative identity verdict that should escape the call.
+export async function executablePath(run, pid) {
+    let out = '';
+    try {
+        out = await run('lsof', ['-a', '-p', String(pid), '-d', 'txt', '-Fn']);
+    }
+    catch { /* try /proc */ }
+    for (const line of String(out).split('\n'))
+        if (line[0] === 'n')
+            return line.slice(1).trim();
+    try {
+        return await fsp.readlink(`/proc/${pid}/exe`);
+    }
+    catch {
+        return '';
+    }
+}
+function parseForegroundProcesses(out) {
+    const rows = [];
+    for (const line of String(out).split('\n')) {
+        const m = line.match(/^\s*(\S+)\s+(\d+)\s+(\S+)\s*$/);
+        if (!m)
+            continue;
+        const [, rawTty, pid, stat] = m;
+        if (!rawTty || !pid || !stat)
+            continue;
+        const tty = normTty(rawTty);
+        if (tty && stat.includes('+'))
+            rows.push({ tty, pid });
+    }
+    return rows;
+}
+// Normalize ambiguous tmux pane_current_command values only after tying the pane's TTY to a foreground
+// process whose REAL executable proves the agent identity. Every call refreshes the cheap ps snapshot;
+// the cache only skips lsof while the exact foreground pid set is unchanged and its short TTL is live.
+// This makes TTY reuse/process replacement invalidate immediately, and failed probes retry quickly.
+export async function resolveByExecutable(panes, run, verdicts, { candidate, normalized, matches, now = () => Date.now(), successTtlMs = SUCCESS_TTL_MS, failureTtlMs = FAILURE_TTL_MS, }) {
+    const candidates = panes.filter((p) => p && p.tty && candidate(p.cmd || ''));
+    if (!candidates.length)
+        return panes;
+    const rows = parseForegroundProcesses(await run('ps', ['-Ao', 'tty=,pid=,stat=']));
+    for (const pane of candidates) {
+        const tty = normTty(pane.tty);
+        const procs = rows.filter((r) => r.tty === tty);
+        const signature = procs.map((r) => r.pid).sort().join(',');
+        const key = `${normalized}|${tty}|${pane.cmd}`;
+        const cached = verdicts.get(key);
+        if (cached && cached.signature === signature && cached.expiresAt > now()) {
+            if (cached.ok)
+                pane.cmd = normalized;
+            continue;
+        }
+        let ok = false;
+        let matchedPid = null;
+        for (const proc of procs) {
+            const exe = await executablePath(run, proc.pid);
+            if (matches(exe, pane.cmd || '')) {
+                ok = true;
+                matchedPid = proc.pid;
+                break;
+            }
+        }
+        verdicts.set(key, {
+            ok,
+            pid: matchedPid,
+            signature,
+            expiresAt: now() + (ok ? successTtlMs : failureTtlMs),
+        });
+        if (ok)
+            pane.cmd = normalized;
+    }
+    return panes;
+}
+export const executableBasename = (file) => path.basename(String(file || ''));