tabby-agent-recovery 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 1.1.0
+
+- Standalone exact-conversation recovery for Codex and Claude Code. Linux detects running agents; explicit UUID resume profiles work without process discovery.
+- Native and external bound panes stay open after process exit and initialize in background tabs.
+- Missing external launchers no longer replace existing reconnect scripts with a broken command.
+- Extra snapshots omit scrollback and nonessential environment by default; retain the last 20 startup snapshots.
+- Document the difference between resuming conversation history and keeping a process alive, platform support, and explicit-profile fallback.
+
+## 1.0.0
+
+- Initial Tabby recovery bridge for existing agent-sessions bindings, split layouts, and optional terminal logs.

package/PRIVACY.md

@@ -1,17 +1,25 @@
 # Privacy
 
-`tabby-agent-recovery` does not send network requests. It only reads and writes files on the local machine.
+`tabby-agent-recovery` makes no network requests and has no analytics endpoint. Agent CLIs and Tabby have their own network behavior.
+
+## Read locally
+
+On Linux, native detection reads the current user's process ancestry and, for candidate agent processes in a pane, command lines, working directories, executable links, and environment. Only `CODEX_HOME` and `CLAUDE_CONFIG_DIR` are carried into the recovered command; other process environment values are discarded. The plugin reads the first metadata record of an open transcript or Claude's local process registry to identify the conversation. It does not search unrelated conversations by recency.
+
+If a compatible `agent-sessions` launcher is installed, its `pane-bindings` command and local state provide the optional external bindings.
 
 ## Written locally
 
-Under the state directory (`$AGENT_SESSIONS_STATE`, or `~/.local/state/agent-sessions` when that tree already exists, otherwise `~/.local/state/tabby-agent-recovery`):
+Under `$AGENT_SESSIONS_STATE`, or `~/.local/state/agent-sessions` when its state file exists, otherwise `~/.local/state/tabby-agent-recovery`:
 
-- `tabby-layout.json` — pane keys and split paths
-- `tabby-latest-snapshot.json` and `layout-snapshots/` — recovery tokens, including cwd, command, and Tabby's saved scrollback
-- `terminal-logs/` — pane output, only when `TABBY_AGENT_RECOVERY_LOG=1`
+- `tabby-layout.json`: external pane keys and positions.
+- `tabby-latest-snapshot.json`: the latest saved recovery layout.
+- `layout-snapshots/`: up to 20 startup snapshots.
+- `tabby-layout-before-binding.json`: the first layout backup before external binding migration.
+- `terminal-logs/`: terminal output, only with `TABBY_AGENT_RECOVERY_LOG=1`.
 
-Files are created mode `0600` in a `0700` directory.
+By default the extra layout snapshots omit scrollback and profile environment except `CODEX_HOME` / `CLAUDE_CONFIG_DIR`. They still contain conversation IDs, titles, paths, and commands, which can be sensitive. `TABBY_AGENT_RECOVERY_SCROLLBACK=1` opts into full recovery tokens, including terminal scrollback and profile environment. Output logs may contain secrets printed by programs and are not automatically pruned.
 
-## Not collected
+Files are created with mode `0600` and directories with `0700` where supported by the operating system. Tabby's own local recovery storage remains separate: the plugin updates its resume commands but does not remove Tabby's saved scrollback or existing profile environment.
 
-Keyboard input is not recorded by this plugin. Credentials, cookies, and npm/GitHub tokens are not read. There is no analytics endpoint.
+Keyboard input is not logged by the plugin. No credentials are uploaded. Resumed agents use their existing local authentication.

package/README.md

@@ -1,66 +1,81 @@
 # tabby-agent-recovery
 
-Restore Tabby panes after a restart.
-
-Tabby already saves the main window layout. After a reboot the old PTY is gone, so a pane that used to hold a live session comes back as a new shell — or disappears if the process exited with `behaviorOnSessionEnd: auto`. This plugin rewrites the recovery token to a stable attach command, keeps the split tree, and starts bound panes without stealing focus.
-
-![Recovered pane](screenshot.png)
+Resume the same Codex or Claude Code conversation in the same Tabby pane after a restart. Keep nested splits and finished panes. No separate launcher is required.
 
 ## Install
 
-Tabby → **Settings** → **Plugins** → search **agent-recovery** → Install → restart Tabby.
+Tabby → **Settings → Plugins** → search **agent-recovery** → Install → restart Tabby.
 
-Or from the plugins directory Tabby shows under Settings → Plugins:
+If the search has not indexed the package yet, open **Plugins folder** in those settings and run:
 
 ```bash
-npm install tabby-agent-recovery
-# until the npm listing is live:
-# npm install github:vixkosla/tabby-agent-recovery
+npm install tabby-agent-recovery@latest
 ```
 
-Then restart Tabby. The package name must stay `tabby-agent-recovery` (`tabby-plugin` keyword) so the Plugin Manager lists it.
+Restart Tabby after installing or updating. Enable Tabby's **Restore tabs on start** option. The agent CLI must already be installed and authenticated.
+
+If you use a development copy through a symlink in the plugins directory, update that source copy instead: npm installation would replace the symlink.
+
+## Standalone recovery
+
+On Linux, the plugin inspects the processes belonging to each local pane when Tabby saves its tabs. For Codex and Claude Code, it records the **exact conversation UUID**, executable, working directory, and supported CLI options. After a restart, the pane runs `codex resume <UUID>` or `claude --resume <UUID>`.
+
+- New conversations are identified from the pane's open transcript or Claude's process registry. Explicit resume commands also work.
+- Nested splits, their order, titles, and ratios are kept by Tabby's existing recovery system.
+- Identified panes stay in the layout when their process finishes.
+- Bound background panes start without selecting the tab or focusing the window.
+- The plugin keeps the latest layout checkpoint and the last 20 startup snapshots.
+
+This starts a **new agent process with the saved conversation**. It does not keep computation alive while the computer is off or submit a new prompt. CLI login, conversation files, and the executable must still be available. After a crash, only Tabby's most recently saved layout can be recovered.
+
+### Supported cases and fallback
 
-## What it does
+Automatic process discovery currently supports **Linux**, Codex, and Claude Code. It does not guess by folder, modification time, `--last`, or `--continue`. Headless jobs, ambiguous panes, subagent transcripts, unknown CLI flags, and shared daemons without an identifiable pane transcript are left unchanged.
 
-- On save, bind a local pane to `agent-sessions attach <key>` when that launcher can identify the process.
-- On recover, migrate the saved layout before Tabby builds tabs. Nested splits, titles, and ratios stay as they were.
-- Bound panes use `behaviorOnSessionEnd: keep`, so a crash does not delete the tab from the layout.
-- Bound background panes start their PTY without selecting the tab or focusing the window.
-- A private layout snapshot is written once at launch, before autosave can replace it.
+For those cases, or on **macOS and Windows**, create a local Tabby profile with an explicit resume command:
 
-Without `agent-sessions`, already-bound reconnect commands (including scripts in `<state>/reconnect/*.sh`) still restore. Ordinary bash panes are left alone.
+| Profile field | Codex | Claude Code |
+| --- | --- | --- |
+| Command | Full path to `codex` | Full path to `claude` |
+| Arguments | `resume <UUID>` | `--resume <UUID>` |
+| Working directory | Your project directory | Your project directory |
 
-## Optional companion
+Replace `<UUID>` with the actual conversation ID. The arguments are separate from the executable path. On Codex versions that support it, `--no-daemon` can make a new conversation's transcript identifiable inside its pane; an explicit UUID is the reliable fallback for an existing conversation.
 
-An optional local `agent-sessions` launcher (`~/.local/bin/agent-sessions`) can keep agent dialogs alive in tmux when Tabby closes. The plugin talks to it through:
+Recognized options include model, profile, sandbox/approval or permission mode, additional directories, and selected UI flags. Already selected permission bypass flags are preserved, never enabled by the plugin. Unknown or sensitive inline configuration makes automatic recovery skip that invocation. Ordinary shells and arbitrary commands are not converted into agent sessions.
 
-| Env | Default |
+## Check it
+
+1. Start a conversation with Codex or Claude Code inside a Tabby pane.
+2. Create a split and close Tabby normally so it saves the layout.
+3. Open Tabby again. Check the conversation identity, working directory, and split arrangement.
+4. If it opens an ordinary shell, use an explicit resume profile as described above.
+
+## Optional existing agent-sessions integration
+
+If you already run a compatible local `agent-sessions` launcher, the plugin can preserve `agent-sessions attach <key>` bindings and migrate saved PTY bindings before Tabby builds its tabs. The launcher is optional and is not installed by this package. Existing reconnect scripts are not replaced when the launcher is missing.
+
+| Environment variable | Default / effect |
 | --- | --- |
 | `AGENT_SESSIONS_LAUNCHER` | `~/.local/bin/agent-sessions` |
-| `AGENT_SESSIONS_STATE` | `~/.local/state/agent-sessions` if `state.json` exists, else `~/.local/state/tabby-agent-recovery` |
-| `TABBY_AGENT_RECOVERY_LOG=1` | write pane output to `<state>/terminal-logs/` (off by default) |
+| `AGENT_SESSIONS_STATE` | `~/.local/state/agent-sessions` if its `state.json` exists; otherwise `~/.local/state/tabby-agent-recovery` |
+| `TABBY_AGENT_RECOVERY_SCROLLBACK=1` | Include terminal scrollback and full profile environment in extra snapshots; off by default |
+| `TABBY_AGENT_RECOVERY_LOG=1` | Write terminal output to `<state>/terminal-logs/`; off by default |
 
-State files are mode `0600`. They can contain paths, commands, and (if logging is on) terminal output. Nothing is uploaded.
+Set these in the environment that launches Tabby. No configuration is needed for ordinary standalone use.
 
-## Already using the local copy
+## Privacy
 
-If Tabby already loads this plugin from a symlink under `~/.config/tabby/plugins/node_modules/tabby-agent-recovery`, do not also install it from the Plugin Manager — npm would replace that symlink.
+No network requests or analytics are made by the plugin. Default extra snapshots omit terminal scrollback and environment variables other than `CODEX_HOME` / `CLAUDE_CONFIG_DIR`. Paths and commands are still saved and may be sensitive. Tabby's own recovery storage is separate and retains its existing behavior. See [PRIVACY.md](PRIVACY.md).
 
 ## Development
 
 ```bash
 npm test
-TABBY_PLUGINS="$(pwd)" tabby --debug
+TABBY_PLUGINS="$PWD" tabby --debug
 ```
 
-## Publish
-
-Tabby's plugin catalog is the public npm registry. There is no separate review form: a package named `tabby-*` with keyword `tabby-plugin` appears in Settings → Plugins after `npm publish`.
-
-```bash
-npm login --auth-type=web
-npm publish --access public
-```
+Tests cover native identity discovery, ambiguity, CLI wrappers, missing launchers, nested layouts, background initialization, privacy defaults, and snapshot retention. Integration was checked in an isolated Tabby 1.0.238 on Linux, using local CLI fixtures without network/model calls: two conversations resumed with their exact IDs after a full app restart, splits retained their ratios, and an exited pane stayed open. Native metadata formats can change between agent versions; explicit resume profiles remain the fallback.
 
 ## License
 

package/bridge.js

@@ -8,6 +8,11 @@ const { execFile } = require('child_process')
 const { promisify } = require('util')
 const run = promisify(execFile)
 const KEY = /^[a-z0-9-]{1,80}$/
+const native = require('./native')
+
+function executable (file) {
+    try { fs.accessSync(file, process.platform === 'win32' ? fs.constants.F_OK : fs.constants.X_OK); return true } catch { return false }
+}
 
 function readJSON (file, fallback) {
     try { return JSON.parse(fs.readFileSync(file, 'utf8')) } catch { return fallback }
@@ -64,7 +69,7 @@ function tokenKey (token, statePath, launcher) {
 
 function bindToken (token, key, state, launcher) {
     key = canonical(key, state)
-    if (!key || state.entries[key].enabled === false) return token
+    if (!key || state.entries[key].enabled === false || !executable(launcher)) return token
     token.profile = { ...token.profile, behaviorOnSessionEnd: 'keep', options: {
         ...token.profile.options,
         command: launcher,
@@ -102,15 +107,16 @@ function manifest (tokens, statePath, launcher) {
 }
 
 function layoutOnly (tokens) {
-    return tokens.map(({ savedState, children, ...token }) => ({
-        ...token,
+    return tokens.map(({ savedState, children, profile, ...token }) => ({
+        ...token, ...(profile ? { profile: { ...profile, options: { ...profile.options, env: native.safeEnvironment(profile.options?.env) } } } : {}),
         ...(Array.isArray(children) ? { children: layoutOnly(children) } : {}),
     }))
 }
 
 function install ({
     core, local, ipc, storage, statePath, launcher, lookupBindings,
-    logTerminalOutput, warning = console.warn,
+    logTerminalOutput, includeScrollback = process.env.TABBY_AGENT_RECOVERY_SCROLLBACK === '1',
+    detectNative = native.createDetector(), warning = console.warn,
 } = {}) {
     statePath ||= defaultStatePath()
     launcher ||= defaultLauncher()
@@ -121,6 +127,7 @@ function install ({
     const state = () => readJSON(path.join(statePath, 'state.json'), { entries: {} })
     let cache, cachedAt = 0
     const bindings = () => {
+        if (!lookupBindings && !executable(launcher)) return Promise.resolve({})
         if (!cache || Date.now() - cachedAt > 1000) {
             cachedAt = Date.now()
             cache = (lookupBindings ? lookupBindings() : run(launcher, ['pane-bindings'], { timeout: 2500, maxBuffer: 65536 })
@@ -138,7 +145,15 @@ function install ({
             const pty = token.profile?.options?.restoreFromPTYID
             const pid = pty && ipc.sendSync('pty:get-pid', pty)
             const key = (pid && (await bindings())[String(pid)]) || tokenKey(token, statePath, launcher)
-            if (key) bindToken(token, key, state(), launcher)
+            if (key && canonical(key, state()) && executable(launcher)) bindToken(token, key, state(), launcher)
+            else native.bindNative(token, (pid && await detectNative(Number(pid))) || native.fromProfile(token))
+            if (token.profile?.behaviorOnSessionEnd === 'keep' &&
+                (native.fromProfile(token) || tokenKey(token, statePath, launcher))) {
+                // Keep the newly identified pane now, not only after its next restart.
+                const { restoreFromPTYID, ...options } = token.profile.options
+                tab.profile = { ...token.profile, options }
+                if (tab.session) tab.session.pauseAfterExit = true
+            }
         } catch {
             warning('agent-recovery: could not refresh a pane binding; preserving its profile')
         }
@@ -156,15 +171,17 @@ function install ({
                 if (!launchSnapshotSaved && Array.isArray(original) && original.length) {
                     const stamp = new Date().toISOString().replace(/[:.]/g, '-')
                     atomicJSON(path.join(statePath, 'layout-snapshots', `${stamp}-${process.pid}.json`), {
-                        version: 1, saved_at: new Date().toISOString(), tabs: original,
+                        version: 1, saved_at: new Date().toISOString(), tabs: includeScrollback ? original : layoutOnly(original),
                     })
+                    const snapshots = path.join(statePath, 'layout-snapshots')
+                    fs.readdirSync(snapshots).filter(name => /^\d{4}-.*\.json$/.test(name)).sort().slice(0, -20).forEach(name => fs.unlinkSync(path.join(snapshots, name)))
                     launchSnapshotSaved = true
                 }
                 const tokens = migrate(original, state(), pending, statePath, launcher)
                 const after = JSON.stringify(tokens)
                 if (before !== after) {
                     const backup = path.join(statePath, 'tabby-layout-before-binding.json')
-                    if (!fs.existsSync(backup)) atomicJSON(backup, JSON.parse(before))
+                    if (!fs.existsSync(backup)) atomicJSON(backup, includeScrollback ? JSON.parse(before) : layoutOnly(JSON.parse(before)))
                     storage.tabsRecovery = after
                 }
                 atomicJSON(path.join(statePath, 'tabby-layout.json'), manifest(tokens, statePath, launcher))
@@ -183,7 +200,7 @@ function install ({
                 const tokens = JSON.parse(storage.tabsRecovery)
                 atomicJSON(path.join(statePath, 'tabby-layout.json'), manifest(tokens, statePath, launcher))
                 atomicJSON(path.join(statePath, 'tabby-latest-snapshot.json'), {
-                    version: 1, saved_at: new Date().toISOString(), tabs: tokens,
+                    version: 1, saved_at: new Date().toISOString(), tabs: includeScrollback ? tokens : layoutOnly(tokens),
                 })
             } catch {
                 warning('agent-recovery: could not checkpoint pane manifest')
@@ -221,12 +238,13 @@ function install ({
     terminal.ngOnInit = function (...args) {
         const token = { type: 'app:local-tab', profile: this.profile }
         const key = tokenKey(token, statePath, launcher)
-        if (key && state().entries[key]?.enabled !== false) {
+        const bound = (key && state().entries[key]?.enabled !== false) || native.fromProfile(token)
+        if (bound) {
             this.profile.behaviorOnSessionEnd = 'keep'
             this.profile.options.pauseAfterExit = true
         }
         onInit.apply(this, args)
-        if (!key || this.session || state().entries[key]?.enabled === false) return
+        if (!bound || this.session) return
         const initialize = this.initializeSession
         initialize.call(this, this.size?.columns || 80, this.size?.rows || 24)
         const started = this.session
@@ -243,5 +261,5 @@ function install ({
 
 module.exports = {
     install, canonical, tokenKey, bindToken, walk, migrate, manifest, layoutOnly,
-    defaultLauncher, defaultStatePath,
+    defaultLauncher, defaultStatePath, executable,
 }

package/native.js

@@ -0,0 +1,221 @@
+'use strict'
+
+// Native conversation recovery: no supervisor, shell eval or "latest" lookup.
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+const ENV_KEYS = ['CODEX_HOME', 'CLAUDE_CONFIG_DIR']
+const FLAGS = {
+    codex: {
+        value: ['--model', '-m', '--profile', '-p', '--sandbox', '-s', '--ask-for-approval', '-a', '--add-dir', '--enable', '--disable', '--local-provider'],
+        switch: ['--search', '--no-alt-screen', '--no-daemon', '--oss', '--strict-config', '--full-auto', '--dangerously-bypass-approvals-and-sandbox', '--yolo'],
+    },
+    claude: {
+        value: ['--model', '--effort', '--permission-mode', '--agent', '--add-dir'],
+        switch: ['--chrome', '--no-chrome', '--dangerously-skip-permissions', '--allow-dangerously-skip-permissions'],
+    },
+}
+
+function invocation (argv) {
+    if (!Array.isArray(argv) || !argv.length) return null
+    let command = argv[0], prefix = [], name = path.basename(command).replace(/\.exe$/i, '')
+    if (/^node(?:js)?$/.test(name) && typeof argv[1] === 'string') {
+        if (/@anthropic-ai[\\/]claude-code[\\/]cli\.js$/.test(argv[1])) name = 'claude'
+        else if (/@openai[\\/]codex[\\/]bin[\\/]codex\.js$/.test(argv[1])) name = 'codex'
+        else return null
+        prefix = [argv[1]]
+    }
+    if (!FLAGS[name]) return null
+    return { kind: name, command, prefix, args: argv.slice(1 + prefix.length) }
+}
+
+function resumeArgs (kind, args, id) {
+    if (!UUID.test(id || '') || !FLAGS[kind]) return null
+    const kept = [], rules = FLAGS[kind]
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i]
+        if (typeof arg !== 'string') return null
+        if (['exec', 'review', 'app-server', 'mcp', 'login', 'logout', 'auth', 'update', 'install', 'agents', 'attach', 'remote-control', '--help', '-h', '--version', '-V', '--print'].includes(arg) || (kind === 'claude' && arg === '-p')) return null
+        if (kind === 'codex' && arg === 'resume') {
+            if (args[i + 1] && !args[i + 1].startsWith('-')) i++
+            continue
+        }
+        if (kind === 'claude' && ['--resume', '-r', '--session-id'].includes(arg)) {
+            if (args[i + 1] && !args[i + 1].startsWith('-')) i++
+            continue
+        }
+        if (['--last', '--all'].includes(arg) || (kind === 'claude' && ['--continue', '-c'].includes(arg))) continue
+        const equal = arg.indexOf('=')
+        const flag = equal > 0 ? arg.slice(0, equal) : arg
+        if (rules.value.includes(flag)) {
+            const value = equal > 0 ? arg.slice(equal + 1) : args[++i]
+            if (!value || value.startsWith('-')) return null
+            kept.push(flag, value)
+        } else if (rules.switch.includes(arg)) kept.push(arg)
+        else if (kind === 'codex' && ['-c', '--config'].includes(flag)) {
+            const value = equal > 0 ? arg.slice(equal + 1) : args[++i]
+            // Preserve ordinary UI configuration, not inline credentials/hooks.
+            if (!/^(check_for_update_on_startup|model_reasoning_effort)=(?:true|false|"(?:low|medium|high|xhigh|max)")$/.test(value || '')) return null
+            kept.push(flag, value)
+        } else if (arg.startsWith('-')) return null
+        // Positional initial prompts already belong to the native conversation.
+    }
+    return [...kept, ...(kind === 'codex' ? ['resume', id] : ['--resume', id])]
+}
+
+function explicitID ({ kind, args }) {
+    const ids = []
+    for (let i = 0; i < args.length - 1; i++) {
+        if ((kind === 'codex' && args[i] === 'resume') || (kind === 'claude' && ['--resume', '-r', '--session-id'].includes(args[i]))) {
+            if (UUID.test(args[i + 1])) ids.push(args[i + 1])
+        }
+    }
+    return new Set(ids).size === 1 ? ids[0] : null
+}
+
+function safeEnvironment (env = {}) {
+    return Object.fromEntries(ENV_KEYS.filter(key => typeof env[key] === 'string').map(key => [key, env[key]]))
+}
+
+function fromProfile (token) {
+    const options = token.profile?.options || {}
+    const call = invocation([options.command || '', ...(options.args || [])])
+    if (!call) return null
+    const id = explicitID(call), args = resumeArgs(call.kind, call.args, id)
+    return args ? { kind: call.kind, id, command: call.command, args: [...call.prefix, ...args], cwd: options.cwd, env: safeEnvironment(options.env) } : null
+}
+
+async function firstJSON (file, whole = false) {
+    let handle
+    try {
+        handle = await fs.promises.open(file, 'r')
+        const buffer = Buffer.alloc(65536)
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0)
+        const text = buffer.subarray(0, bytesRead).toString('utf8')
+        return JSON.parse(whole ? text : text.split('\n')[0])
+    } catch { return null } finally { await handle?.close() }
+}
+
+function createDetector ({ procRoot = '/proc', platform = process.platform, home = os.homedir(), uid = process.getuid?.() } = {}) {
+    let inventory, inventoryAt = 0
+    const processTree = async () => {
+        if (inventory && Date.now() - inventoryAt < 1000) return inventory
+        inventoryAt = Date.now()
+        inventory = (async () => {
+            const rows = new Map()
+            for (const name of await fs.promises.readdir(procRoot)) {
+                if (!/^\d+$/.test(name)) continue
+                try {
+                    const dir = path.join(procRoot, name)
+                    if (uid != null && (await fs.promises.stat(dir)).uid !== uid) continue
+                    const stat = (await fs.promises.readFile(path.join(dir, 'stat'), 'utf8')).split(') ').slice(1).join(') ').split(' ')
+                    rows.set(Number(name), { pid: Number(name), ppid: Number(stat[1]), start: stat[19], dir })
+                } catch {}
+            }
+            return rows
+        })()
+        return inventory
+    }
+    async function readProcess (info) {
+        try {
+            const argv = (await fs.promises.readFile(path.join(info.dir, 'cmdline'), 'utf8')).split('\0').filter(Boolean)
+            const call = invocation(argv)
+            if (!call) return null
+            const processEnv = Object.fromEntries((await fs.promises.readFile(path.join(info.dir, 'environ'), 'utf8')).split('\0').filter(x => x.includes('=')).map(x => [x.slice(0, x.indexOf('=')), x.slice(x.indexOf('=') + 1)]))
+            const env = safeEnvironment(processEnv)
+            const cwd = await fs.promises.readlink(path.join(info.dir, 'cwd'))
+            if (!path.isAbsolute(call.command)) {
+                const choices = call.command.includes('/') ? [path.resolve(cwd, call.command)] : (processEnv.PATH || '').split(path.delimiter).filter(path.isAbsolute).map(dir => path.join(dir, call.command))
+                const resolved = choices.find(file => {
+                    try { fs.accessSync(file, fs.constants.X_OK); return true } catch { return false }
+                })
+                call.command = resolved || await fs.promises.readlink(path.join(info.dir, 'exe'))
+            }
+            return { ...info, ...call, env, cwd }
+        } catch { return null }
+    }
+    async function identity (proc, rows) {
+        if (proc.kind === 'claude') {
+            const root = proc.env.CLAUDE_CONFIG_DIR || path.join(home, '.claude')
+            const meta = await firstJSON(path.join(root, 'sessions', `${proc.pid}.json`), true)
+            if (meta?.kind === 'interactive' && String(meta.procStart) === proc.start && UUID.test(meta.sessionId)) return meta.sessionId
+        }
+        // Only files held by this pane's process (or its own private app-server).
+        // Never inspect a shared daemon or pick a conversation by modification time.
+        const owners = [proc, ...[...rows.values()].filter(row => row.ppid === proc.pid)]
+        const ids = new Set()
+        for (const owner of owners) {
+            if (owner.pid !== proc.pid) {
+                const child = await readProcess(owner)
+                if (!child || child.kind !== proc.kind || !child.args.includes('app-server')) continue
+            }
+            let fds
+            try { fds = await fs.promises.readdir(path.join(owner.dir, 'fd')) } catch { continue }
+            for (const fd of fds) {
+                try {
+                    const file = await fs.promises.readlink(path.join(owner.dir, 'fd', fd))
+                    if (!file.endsWith('.jsonl')) continue
+                    if (proc.kind === 'codex' && file.includes('/sessions/')) {
+                        const meta = await firstJSON(file), p = meta?.payload
+                        if (meta?.type !== 'session_meta' || !UUID.test(p?.id)) continue
+                        if (p.source && typeof p.source === 'object' && 'subagent' in p.source) continue
+                        if (p.session_id && p.session_id !== p.id) continue
+                        ids.add(p.id)
+                    } else if (proc.kind === 'claude' && file.includes('/projects/')) {
+                        const id = path.basename(file, '.jsonl'), meta = await firstJSON(file)
+                        if (UUID.test(id) && meta?.sessionId === id) ids.add(id)
+                    }
+                } catch {}
+            }
+        }
+        if (ids.size > 1) return null
+        return [...ids][0] || explicitID(proc)
+    }
+    return async function detect (ptyPID) {
+        if (platform !== 'linux' || !Number.isInteger(ptyPID) || ptyPID <= 0) return null
+        try {
+            const rows = await processTree(), descendants = new Set([ptyPID])
+            for (let depth = 0; depth < 32; depth++) {
+                let added = false
+                for (const row of rows.values()) if (descendants.has(row.ppid) && !descendants.has(row.pid)) { descendants.add(row.pid); added = true }
+                if (!added) break
+            }
+            if (descendants.size > 128) return null
+            const candidates = []
+            for (const pid of descendants) {
+                const proc = rows.has(pid) && await readProcess(rows.get(pid))
+                if (proc && resumeArgs(proc.kind, proc.args, '00000000-0000-4000-8000-000000000001')) candidates.push(proc)
+            }
+            // The npm Codex entrypoint stays alive above its native binary.
+            // Treat that wrapper and binary as one interactive CLI.
+            const interactive = candidates.filter(proc => !proc.prefix.length || !candidates.some(child => child.ppid === proc.pid && child.kind === proc.kind && !child.prefix.length))
+            const top = interactive.filter(proc => {
+                let ppid = proc.ppid
+                for (let depth = 0; depth < 32 && rows.has(ppid); depth++) {
+                    if (interactive.some(other => other.pid === ppid)) return false
+                    ppid = rows.get(ppid).ppid
+                }
+                return true
+            })
+            if (top.length !== 1) return null
+            const proc = top[0], id = await identity(proc, rows)
+            const args = resumeArgs(proc.kind, proc.args, id)
+            if (!args) return null
+            return { kind: proc.kind, id, command: proc.command, args: [...proc.prefix, ...args], cwd: proc.cwd, env: proc.env }
+        } catch { return null }
+    }
+}
+
+function bindNative (token, entry) {
+    if (!entry || !UUID.test(entry.id || '') || !Array.isArray(entry.args)) return token
+    token.profile = { ...token.profile, behaviorOnSessionEnd: 'keep', options: {
+        ...token.profile.options, command: entry.command, args: entry.args,
+        cwd: entry.cwd || token.profile.options?.cwd,
+        env: { ...token.profile.options?.env, ...safeEnvironment(entry.env) }, pauseAfterExit: true,
+    } }
+    delete token.profile.options.agentSessionKey
+    return token
+}
+
+module.exports = { invocation, resumeArgs, explicitID, fromProfile, createDetector, bindNative, safeEnvironment }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tabby-agent-recovery",
-  "version": "1.0.0",
-  "description": "Restore Tabby panes after restart: reattach surviving sessions, keep splits, and stop tabs from vanishing when a process exits.",
+  "version": "1.1.0",
+  "description": "Resume exact Codex and Claude Code conversations in Tabby after restart. Keep splits and finished panes; no separate launcher required.",
   "keywords": [
     "tabby-plugin",
     "tabby",
@@ -13,13 +13,14 @@
   "files": [
     "index.js",
     "bridge.js",
+    "native.js",
     "README.md",
     "LICENSE",
     "PRIVACY.md",
-    "screenshot.png"
+    "CHANGELOG.md"
   ],
   "scripts": {
-    "test": "node --test test/bridge.test.cjs",
+    "test": "node --test test/*.test.cjs",
     "prepublishOnly": "npm test"
   },
   "repository": {