botmux 2.9.1 → 2.9.3

package/dist/adapters/cli/claude-code.js

@@ -1,16 +1,45 @@
-import { existsSync, statSync, openSync, readSync, closeSync } from 'node:fs';
+import { existsSync, statSync, openSync, readSync, closeSync, readFileSync, readdirSync, readlinkSync, realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { resolveCommand } from './registry.js';
+import { findJsonlContainingFingerprint, jsonlContainsFingerprint, normaliseForFingerprint } from '../../services/claude-transcript.js';
+/** Resolve cwd to its canonical (symlink-free) absolute path for project-hash
+ *  computation. Claude Code itself runs `process.cwd()` which the kernel returns
+ *  already realpath'd via getcwd(3) — so its on-disk project hash always reflects
+ *  the realpath, not the symlink we may have spawned it under. We must mirror
+ *  that here, otherwise a deployment whose `workingDir` is a symlink (e.g.
+ *  `/home/user` → `/data00/home/user`) computes the wrong project dir, the
+ *  bridge watcher tails a non-existent file, submit-confirm never sees the
+ *  user line, and the no-`botmux send` fallback never emits. realpathSync
+ *  throws on non-existent paths — fall back to the raw cwd in that case so a
+ *  pre-existence check upstream can still report a useful error. */
+function realpathCwd(cwd) {
+    try {
+        return realpathSync(cwd);
+    }
+    catch {
+        return cwd;
+    }
+}
 /** Resolve the JSONL transcript path Claude Code writes user/assistant turns to.
- *  Claude Code's project-hash scheme replaces both `/` and `.` with `-`. */
+ *  Claude Code's project-hash scheme replaces every non-[A-Za-z0-9-] char with `-`
+ *  (observed: `/foo/life_workspace` → `-foo-life-workspace`; `/`, `.`, `_` all become `-`).
+ *  Always operates on realpath(cwd) — see realpathCwd above. */
 export function claudeJsonlPathForSession(sessionId, cwd) {
-    const projectHash = cwd.replace(/[/.]/g, '-');
+    const projectHash = realpathCwd(cwd).replace(/[^A-Za-z0-9-]/g, '-');
     return join(homedir(), '.claude', 'projects', projectHash, `${sessionId}.jsonl`);
 }
-/** Substring that appears on every real user submission line and NOT on tool-result
- *  lines (those have array content: `"content":[{...}]`). */
-const USER_SUBMIT_MARKER = '"role":"user","content":"';
+/** Substrings that indicate Claude Code received our submit. We accept either:
+ *  - `"role":"user","content":"` — direct submission while idle (the canonical
+ *    user-message line; tool-result lines have array content `"content":[{...`
+ *    so they never match).
+ *  - `"operation":"enqueue"` — type-ahead submission while Claude is busy.
+ *    Claude Code logs a `{"type":"queue-operation","operation":"enqueue",...}`
+ *    line at the moment of submit and only later (after the current turn ends)
+ *    promotes it to a `queued_command` attachment — never to a `role:user`
+ *    string-content line. Without this marker, every type-ahead submit would
+ *    falsely report failure. */
+const SUBMIT_MARKERS = ['"role":"user","content":"', '"operation":"enqueue"'];
 function currentFileSize(path) {
     if (!existsSync(path))
         return 0;
@@ -21,7 +50,7 @@ function currentFileSize(path) {
         return 0;
     }
 }
-function deltaHasUserSubmit(path, fromByte) {
+function deltaHasSubmit(path, fromByte) {
     if (!existsSync(path))
         return false;
     let size;
@@ -42,108 +71,500 @@ function deltaHasUserSubmit(path, fromByte) {
     finally {
         closeSync(fd);
     }
-    return buf.toString('utf8').includes(USER_SUBMIT_MARKER);
+    const text = buf.toString('utf8');
+    return SUBMIT_MARKERS.some(m => text.includes(m));
 }
-async function waitForUserSubmit(path, baseByte, timeoutMs) {
+async function waitForSubmit(path, baseByte, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
-        if (deltaHasUserSubmit(path, baseByte))
+        if (deltaHasSubmit(path, baseByte))
             return true;
         await new Promise(r => setTimeout(r, 100));
     }
     return false;
 }
-const COMPLETION_RE = /\u2733\s*(?:Worked|Crunched|Cogitated|Cooked|Churned|Saut[eé]ed) for \d+[smh]/;
+function makeSubmitFingerprint(content, len = 30) {
+    const collapsed = normaliseForFingerprint(content);
+    return collapsed.length > 0 ? collapsed.substring(0, len) : undefined;
+}
+const SESSION_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Returns the absolute path to Claude Code's per-process session state file.
+ *  Claude writes `{pid, sessionId, cwd, procStart, status, updatedAt, ...}`
+ *  here. Empirical scope (Claude Code 2.1.123): `status` and `updatedAt`
+ *  refresh on every state change, but `sessionId` is written ONCE at
+ *  process start. `--resume` is a fresh spawn → fresh pid file with the
+ *  resumed id; in-pane `/clear` does NOT rewrite the pid file's
+ *  `sessionId` even though it rotates the on-disk jsonl. Callers that
+ *  rely on this for rotation tracking must therefore treat a "matching
+ *  sessionId" answer as "no spawn-time rotation observed", not "no
+ *  rotation at all" — the latter requires fingerprint corroboration. */
+export function claudePidStatePath(pid) {
+    return join(homedir(), '.claude', 'sessions', `${pid}.json`);
+}
+/** Linux-only: read /proc/<pid>/stat field 22 (starttime). Returns null when
+ *  /proc isn't available or the stat line is unreadable/malformed; callers
+ *  decide whether to fail closed or skip validation for their platform. */
+function readProcStarttime(pid) {
+    try {
+        const raw = readFileSync(`/proc/${pid}/stat`, 'utf8');
+        // pid (comm) state ppid pgrp ... — comm may contain spaces/parens, so
+        // anchor on the LAST ')' before splitting the remaining fields.
+        const closeParen = raw.lastIndexOf(')');
+        if (closeParen < 0)
+            return null;
+        const fields = raw.slice(closeParen + 2).trim().split(/\s+/);
+        // Post-')' field 1 is state; starttime is field 22 → index 19 here.
+        return fields[19] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Resolve Claude Code's authoritative current session id via
+ *  ~/.claude/sessions/<pid>.json. Validates pid + sessionId UUID + cwd so a
+ *  stale or unrelated pid file can't redirect us to the wrong jsonl. On Linux
+ *  also matches procStart against /proc/<pid>/stat to reject PID reuse. If
+ *  procStart is present but cannot be verified on Linux, fail closed; callers
+ *  fall back to fingerprint detection. */
+export function resolveJsonlFromPid(pid, expectedCwd) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(claudePidStatePath(pid), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    if (parsed.pid !== pid)
+        return null;
+    if (typeof parsed.sessionId !== 'string' || !SESSION_UUID_RE.test(parsed.sessionId))
+        return null;
+    if (typeof parsed.cwd !== 'string')
+        return null;
+    // Identity check: procStart matching against /proc/<pid>/stat field 22 is
+    // the strong signal that this pid file belongs to the live process (rules
+    // out pid reuse). When that holds, Claude's recorded cwd is authoritative
+    // even if it disagrees with `expectedCwd` — the worker's cliCwd can drift
+    // (e.g. a schedule resumes a session with a different workingDir than the
+    // original spawn, but Claude itself loads the session with its own cwd).
+    // When procStart is unavailable/unverifiable, fall back to cwd equality as
+    // the only remaining sanity check. Realpath both sides so a symlinked
+    // workingDir (/home/x → /data00/home/x) still matches Claude's canonical
+    // cwd from getcwd(3).
+    let procStartVerified = false;
+    if (typeof parsed.procStart === 'string') {
+        const live = readProcStarttime(pid);
+        if (live === null && process.platform === 'linux')
+            return null;
+        if (live !== null) {
+            if (live !== parsed.procStart)
+                return null;
+            procStartVerified = true;
+        }
+    }
+    if (!procStartVerified && realpathCwd(parsed.cwd) !== realpathCwd(expectedCwd))
+        return null;
+    return {
+        path: claudeJsonlPathForSession(parsed.sessionId, parsed.cwd),
+        cliSessionId: parsed.sessionId,
+    };
+}
+/** Linux-only: probe `/proc/<pid>/fd` for any signal that reveals Claude's
+ *  CURRENT sessionId — not the spawn-time one the pid file records. Two
+ *  signals are checked:
+ *    1. Direct `.jsonl` symlinks under `~/.claude/projects/...` — Claude
+ *       opens-writes-closes per event, so this only hits if the probe
+ *       lands during a write window.
+ *    2. `~/.claude/tasks/<sessionId>(/...)` symlinks — Claude holds the
+ *       tasks directory and its `.lock` file open continuously for the
+ *       duration of the active session, so this signal is reliable even
+ *       between writes. This is the path that catches in-pane `/clear`
+ *       rotations the pid file can't see (pid file's `sessionId` is set
+ *       once at process start; tasks dir tracks every rotation).
+ *  Returns deduplicated sessionIds in arbitrary order; caller picks one
+ *  (typically by mtime of the corresponding jsonl). Returns [] on
+ *  non-Linux platforms or if /proc lookup fails. */
+export function findOpenClaudeSessionIds(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return [];
+    if (process.platform !== 'linux')
+        return [];
+    let entries;
+    try {
+        entries = readdirSync(`/proc/${pid}/fd`);
+    }
+    catch {
+        return [];
+    }
+    const tasksPrefix = join(homedir(), '.claude', 'tasks') + '/';
+    const projectsInfix = '/.claude/projects/';
+    const out = new Set();
+    for (const name of entries) {
+        let target;
+        try {
+            target = readlinkSync(`/proc/${pid}/fd/${name}`);
+        }
+        catch {
+            continue;
+        }
+        if (target.startsWith(tasksPrefix)) {
+            const sid = target.slice(tasksPrefix.length).split('/')[0];
+            if (sid && SESSION_UUID_RE.test(sid))
+                out.add(sid);
+            continue;
+        }
+        if (target.endsWith('.jsonl') && target.includes(projectsInfix)) {
+            const base = target.split('/').pop() ?? '';
+            const sid = base.endsWith('.jsonl') ? base.slice(0, -'.jsonl'.length) : '';
+            if (sid && SESSION_UUID_RE.test(sid))
+                out.add(sid);
+        }
+    }
+    return [...out];
+}
+/** Fingerprint search that fans out from the pinned project dir to every
+ *  sibling under `~/.claude/projects/`. Used as the writeInput fallback
+ *  when the pinned `claudeJsonlPath` doesn't contain the submit marker —
+ *  Claude may have written to a different project hash than the worker
+ *  expected (e.g. a schedule resumed the session with a workingDir that
+ *  differs from Claude's internal cwd, so the worker computes the wrong
+ *  -project-hash- but Claude appends to the original session's hash dir).
+ *  Tries the primary dir first (fast path, unchanged behavior); only fans
+ *  out when no match is found there. Per-dir, `findJsonlContainingFingerprint`
+ *  still applies its newest-first ordering and the minMtimeMs guard, so a
+ *  stale historical match in some unrelated project can't false-positive. */
+function findJsonlAcrossProjectsRoot(searchPath, fingerprint, options) {
+    const primaryDir = dirname(searchPath);
+    const primary = findJsonlContainingFingerprint(primaryDir, fingerprint, {
+        excludePath: searchPath,
+        ...options,
+    });
+    if (primary)
+        return primary;
+    const projectsRoot = dirname(primaryDir);
+    if (!existsSync(projectsRoot))
+        return null;
+    let siblings;
+    try {
+        siblings = readdirSync(projectsRoot);
+    }
+    catch {
+        return null;
+    }
+    for (const name of siblings) {
+        const sib = join(projectsRoot, name);
+        if (sib === primaryDir)
+            continue;
+        const matched = findJsonlContainingFingerprint(sib, fingerprint, {
+            excludePath: searchPath,
+            ...options,
+        });
+        if (matched)
+            return matched;
+    }
+    return null;
+}
+const COMPLETION_RE = /\u2733\s*(?:Worked|Crunched|Cogitated|Cooked|Churned|Saut[eé]ed|Baked|Brewed) for \d+[smh]/;
 export function createClaudeCodeAdapter(pathOverride) {
     const bin = resolveCommand(pathOverride ?? 'claude');
     return {
         id: 'claude-code',
         resolvedBin: bin,
         supportsTypeAhead: true,
-        buildArgs({ sessionId, resume, botName, botOpenId }) {
+        buildResumeCommand({ sessionId, cliSessionId }) {
+            // Claude resumes by reading <id>.jsonl, so we need the most recently
+            // observed CLI-native id (rotation can happen mid-run); fall back to the
+            // botmux sessionId for the first-turn case where they coincide.
+            return `claude --resume ${cliSessionId ?? sessionId}`;
+        },
+        buildArgs({ sessionId, resume, resumeSessionId, botName, botOpenId }) {
             const args = [];
             if (resume) {
-                args.push('--resume', sessionId);
+                // Prefer Claude's most recently observed internal session id when we
+                // have one — `--resume` reads `<id>.jsonl`, and after a previous run
+                // rotated the id (which we now persist via the pid-file resolver) the
+                // botmux sessionId no longer matches Claude's actual transcript file.
+                args.push('--resume', resumeSessionId ?? sessionId);
             }
             else {
                 args.push('--session-id', sessionId);
             }
             args.push('--dangerously-skip-permissions');
             args.push('--disallowed-tools', 'EnterPlanMode,ExitPlanMode');
-            const identityLines = botName || botOpenId
+            const identityBlock = botName || botOpenId
                 ? [
                     '',
-                    '你的身份：',
-                    `- 名字：${botName ?? '(未知)'}`,
-                    `- open_id：${botOpenId ?? '(未知)'}`,
-                    '同一群里可能有多个机器人同时被 @，消息里会以 `@名字` 和 `open_id` 区分。',
-                    '判断本条消息是不是分派给你：对照上面的名字和 open_id。',
-                    '- 只执行明确分给自己的那部分，别抢别的机器人的活',
-                    '- 整条消息都指派给别的机器人时，保持沉默不要回复',
-                    '- 需要找对端协作时先用 `botmux bots list` 查 open_id，再用 `botmux send --mention <open_id>` @ 对方',
+                    '<identity>',
+                    `  <name>${botName ?? '(未知)'}</name>`,
+                    `  <open_id>${botOpenId ?? '(未知)'}</open_id>`,
+                    '  <routing_rules>',
+                    '    群里可能有多个机器人，消息里用 `@名字` 和 `open_id` 区分接收方。对照上面的 name/open_id 判断本条消息归属：',
+                    '    - 只执行明确分给自己的那部分，别抢别的机器人的活',
+                    '    - 整条消息都指派给别的机器人时，保持沉默不要回复',
+                    '    - **默认不主动拉别的 bot 进来**。除非用户明确要求、或某段任务只能由对方做，否则一个人做完自己的部分就行。',
+                    '',
+                    '    **和别的机器人协作的硬性物理事实**：飞书话题群里其他 bot **默认收不到** 你 `botmux send` 出去的消息——',
+                    '    要让某个 bot 接力干活，**必须** 显式 `--mention <对方 bot 的 open_id>`，不 --mention 对方 bot 完全不会被触发。',
+                    '    - 协作伙伴的 open_id 会列在每条用户消息附带的 `<available_bots>` 块里，也可以 `botmux bots list` 查',
+                    '    - 用法：`botmux send --mention ou_xxx "消息内容"`（多个 bot 重复 `--mention`）；正文里写 `@对方名字` 时 botmux 也会自动补上 --mention，但显式传更稳',
+                    '    - 该 --mention 的场景：用户明确要求让对方接力、把任务的某段交给对方、需要对方给最终结论或做独立操作',
+                    '    - 不必 --mention 的场景：纯状态更新/确认/感谢——尽量合并到下一次有内容的消息里再带上，避免互相 ping 触发空转',
+                    '  </routing_rules>',
+                    '</identity>',
                 ]
                 : [];
             args.push('--append-system-prompt', [
+                '<botmux_routing>',
                 '你连接到了飞书（Lark）话题群。用户在飞书上阅读，看不到你的终端输出。',
                 '想让用户看到的内容必须通过 `botmux send` 命令发送，终端输出不会到达聊天。',
                 '',
                 '使用指南：',
                 '- 用 `botmux send` 发送：关键结论、方案（等用户确认再执行）、最终结果、进度更新。',
-                '- 发送纯文本即可：`botmux send "消息"` 或用 heredoc 传多行。格式自动处理。',
+                '- 发送纯文本即可：`botmux send "消息"`。格式自动处理。',
+                '- 多行消息必须用 heredoc，禁止写成 `botmux send "第一行\\n第二行"`；否则 `\\n` 可能按字面量显示在飞书里。',
+                "  正确多行示例：\n```bash\nbotmux send <<'EOF'\n第一行\n第二行\nEOF\n```",
                 '- 附带图片：`botmux send --images /path/to/img.png "说明文字"`',
                 '- 附带文件：`botmux send --files /path/to/file.pdf "请查收"`',
-                '- 需要上下文时用 `botmux thread messages` 读取之前的对话。',
+                '- 需要上下文时用 `botmux history` 读取之前的对话。',
                 '- 查看可协作的机器人：`botmux bots list`',
-                ...identityLines,
+                '</botmux_routing>',
+                ...identityBlock,
             ].join('\n'));
             return args;
         },
         injectsSessionContext: true,
         async writeInput(pty, content) {
-            // Always use bracketed paste: Claude Code's paste-burst heuristic can
-            // swallow a trailing Enter sent via send-keys -l + send-keys Enter,
-            // leaving content in the input box. Bracketed paste marks an explicit
-            // \x1b[201~ boundary so the post-paste Enter is unambiguously submit.
-            // Past that, we still can't trust fixed-delay timing (slow disk, big
-            // paste, image loading). The robust signal is Claude Code's session
-            // JSONL: each real user submit appends a line — if no new line appears,
-            // Enter was swallowed and we re-send it.
+            // Type content like a human: literal text via send-keys -l, and each
+            // newline replaced by `\` + Enter (Claude Code's documented soft-newline
+            // idiom — keeps content in the input box without submitting). The final
+            // Enter at the bottom is the unambiguous submit. This sidesteps tmux
+            // bracketed-paste mode entirely, which was unreliable: Claude Code can
+            // toggle bracketed-paste off mid-session (after slash commands etc.),
+            // making tmux's paste-buffer drop the markers and turning embedded \r
+            // into Enters that fragment the message into multiple submits.
+            //
+            // Each tmux send-keys is throttled so the cumulative input rate stays
+            // below Claude Code's paste-burst threshold — otherwise on long messages
+            // (~1300+ chars / ~25+ lines) Ink flips into paste mode mid-stream and
+            // subsequent `\` + Enter pairs are kept as literal `\\\r` in the
+            // submitted content instead of being consumed as soft-newline markers.
+            //
+            // Trailing Enter is still subject to Claude Code's paste-burst heuristic
+            // (rapid input followed by Enter can be coalesced as paste), so we keep
+            // the JSONL retry loop below as the source of truth for "did it submit".
             const hasImagePath = /\.(jpe?g|png|gif|webp|svg|bmp)\b/i.test(content);
             const submitDelay = hasImagePath ? 800 : 500;
+            const TYPING_THROTTLE_MS = 30;
+            const tick = () => new Promise(r => setTimeout(r, TYPING_THROTTLE_MS));
             const sendEnter = () => {
                 if (pty.sendSpecialKeys)
                     pty.sendSpecialKeys('Enter');
                 else
                     pty.write('\r');
             };
-            const baseByte = pty.claudeJsonlPath ? currentFileSize(pty.claudeJsonlPath) : 0;
-            if (pty.pasteText && pty.sendSpecialKeys) {
-                pty.pasteText(content);
+            // Pid-state path resolver: ~/.claude/sessions/<pid>.json carries
+            // the spawn-time sessionId (written once at process start; see
+            // claudePidStatePath). Read it first so byte accounting locks onto
+            // the resume target right away when Claude was started with
+            // `--resume`. In-pane `/clear` won't appear here — that's covered
+            // by the fingerprint-based mid-flight rotation check below.
+            let observedCliSessionId;
+            const applyResolved = (resolved) => {
+                if (resolved.cliSessionId !== observedCliSessionId)
+                    observedCliSessionId = resolved.cliSessionId;
+                if (resolved.path !== pty.claudeJsonlPath) {
+                    pty.claudeJsonlPath = resolved.path;
+                    return true;
+                }
+                return false;
+            };
+            if (pty.cliPid && pty.cliCwd) {
+                const resolved = resolveJsonlFromPid(pty.cliPid, pty.cliCwd);
+                if (resolved)
+                    applyResolved(resolved);
+            }
+            // baseByte is recomputed at this point (after any entry-time path swap)
+            // so future writes are measured against the right transcript. Inside
+            // confirmSubmit a mid-flight rotation does NOT advance baseByte — the
+            // submit may already be in the rotated jsonl from before our re-resolve.
+            let baseByte = pty.claudeJsonlPath ? currentFileSize(pty.claudeJsonlPath) : 0;
+            const submitFingerprint = makeSubmitFingerprint(content);
+            const submitSearchMinMtime = Date.now() - 60_000;
+            if (pty.sendText && pty.sendSpecialKeys) {
+                const lines = content.split('\n');
+                for (let i = 0; i < lines.length; i++) {
+                    if (lines[i].length > 0) {
+                        pty.sendText(lines[i]);
+                        await tick();
+                    }
+                    if (i < lines.length - 1) {
+                        // Soft-newline: backslash + Enter inserts a newline in Claude
+                        // Code's input box without submitting.
+                        pty.sendText('\\');
+                        await tick();
+                        pty.sendSpecialKeys('Enter');
+                        await tick();
+                    }
+                }
             }
             else {
+                // Non-tmux fallback (raw PTY): bracketed paste is reliable here since
+                // we control the markers directly.
                 pty.write('\x1b[200~' + content + '\x1b[201~');
             }
             await new Promise(r => setTimeout(r, submitDelay));
             sendEnter();
             // Without a JSONL path we can't verify — trust the fixed delay and return.
-            if (!pty.claudeJsonlPath)
-                return;
+            // Still surface any sessionId we observed via the pid resolver so the
+            // worker can persist it even on this unverified path.
+            if (!pty.claudeJsonlPath) {
+                return observedCliSessionId ? { submitted: true, cliSessionId: observedCliSessionId } : undefined;
+            }
+            const confirmSubmit = async (timeoutMs) => {
+                const startPath = pty.claudeJsonlPath;
+                if (!startPath)
+                    return false;
+                // First check: did our submit land past baseByte on the currently
+                // pinned path? Fast path for the common case (no rotation).
+                if (await waitForSubmit(startPath, baseByte, timeoutMs))
+                    return true;
+                // Second: did Claude rotate sessionId mid-flight? The pid file
+                // is rewritten by `--resume` (fresh spawn) but NOT by in-pane
+                // `/clear` — so this catches the resume case. We re-read and
+                // check both:
+                //   a) the rotated jsonl already contains our submit (the rotation
+                //      happened between our type+Enter and this resolve — the
+                //      content lives in the new file from before we knew about it),
+                //   b) the rotated jsonl is empty / pre-existing but a fresh
+                //      append is on its way (briefly poll).
+                // We do NOT overwrite the original baseByte before the fingerprint
+                // check because (a) requires matching content that may already be in
+                // the rotated file. For (b), poll from the rotated file's own current
+                // size so an older, larger startPath cannot hide a delayed append.
+                if (pty.cliPid && pty.cliCwd) {
+                    const resolved = resolveJsonlFromPid(pty.cliPid, pty.cliCwd);
+                    if (resolved) {
+                        const switched = applyResolved(resolved);
+                        const newPath = pty.claudeJsonlPath;
+                        const rotatedBaseByte = switched && newPath ? currentFileSize(newPath) : baseByte;
+                        if (switched && newPath && submitFingerprint) {
+                            if (jsonlContainsFingerprint(newPath, submitFingerprint, { includeQueueOperations: true })) {
+                                // Sync baseByte to end-of-file so subsequent confirms in
+                                // this writeInput pass don't re-trigger on the same line.
+                                baseByte = currentFileSize(newPath);
+                                return true;
+                            }
+                        }
+                        if (newPath) {
+                            if (await waitForSubmit(newPath, rotatedBaseByte, switched ? 200 : 0)) {
+                                if (switched)
+                                    baseByte = currentFileSize(newPath);
+                                return true;
+                            }
+                        }
+                    }
+                }
+                // Final fallback when the pid file is unavailable / fails validation:
+                // scan the pinned project dir for a recently-written jsonl whose
+                // tail contains our content fingerprint. Stricter than mtime-based
+                // detection so a sibling pane in the same dir can't hijack us.
+                // Per-attempt scope is intentionally narrow (dirname only) — the
+                // cross-project fan-out only runs once at end-of-writeInput and in
+                // the recheck closure, not per retry, to keep the worst case bounded.
+                if (submitFingerprint) {
+                    const searchPath = pty.claudeJsonlPath ?? startPath;
+                    const matched = findJsonlContainingFingerprint(dirname(searchPath), submitFingerprint, {
+                        excludePath: searchPath,
+                        minMtimeMs: submitSearchMinMtime,
+                        includeQueueOperations: true,
+                    });
+                    if (matched) {
+                        pty.claudeJsonlPath = matched;
+                        return true;
+                    }
+                }
+                return false;
+            };
+            const buildResult = (submitted) => {
+                return observedCliSessionId
+                    ? { submitted, cliSessionId: observedCliSessionId }
+                    : { submitted };
+            };
             // Retry budget: up to 2 extra Enters (3 sends total), each followed by
-            // an 800ms wait for the JSONL append. If the user is concurrently typing
-            // in the web terminal, a stray Enter may submit their half-typed text —
-            // but we only retry when the JSONL is provably unchanged, so the race
-            // window is bounded to cases where submit really did fail.
+            // an 800ms wait for the JSONL to record either a direct user-submit line
+            // or a type-ahead enqueue line. If the user is concurrently typing in the
+            // web terminal, a stray Enter may submit their half-typed text — but we
+            // only retry when the JSONL is provably unchanged, so the race window is
+            // bounded to cases where submit really did fail.
             for (let attempt = 0; attempt < 3; attempt++) {
-                if (await waitForUserSubmit(pty.claudeJsonlPath, baseByte, 800))
-                    return;
+                if (await confirmSubmit(800)) {
+                    return observedCliSessionId ? buildResult(true) : undefined;
+                }
                 sendEnter();
             }
             // Final grace check.
-            if (await waitForUserSubmit(pty.claudeJsonlPath, baseByte, 800))
-                return;
-            // All retries exhausted and still no user line in JSONL. Signal failure
+            if (await confirmSubmit(800)) {
+                return observedCliSessionId ? buildResult(true) : undefined;
+            }
+            // Last-resort cross-project fan-out, run ONCE before declaring failure:
+            // catches the case where workingDir/cwd drift made every per-attempt
+            // scan look in the wrong project dir AND the pid resolver also failed
+            // (e.g. pid file missing, /proc unavailable). minMtimeMs filtering and
+            // newest-first ordering keep the cost bounded — only jsonls touched in
+            // the last 60s are actually read, which is typically a handful even
+            // across all sibling project dirs. Per-attempt scans stay narrow
+            // (dirname only) so this work doesn't repeat 4×.
+            if (submitFingerprint && pty.claudeJsonlPath) {
+                const matched = findJsonlAcrossProjectsRoot(pty.claudeJsonlPath, submitFingerprint, {
+                    minMtimeMs: submitSearchMinMtime,
+                    includeQueueOperations: true,
+                });
+                if (matched) {
+                    pty.claudeJsonlPath = matched;
+                    return observedCliSessionId ? buildResult(true) : undefined;
+                }
+            }
+            // All retries exhausted and still no submit marker in JSONL. Signal failure
             // so the worker can notify the user in Lark instead of silently dropping.
-            return { submitted: false };
+            // We still surface observedCliSessionId so the worker can persist Claude's
+            // current id even when this particular submit didn't land.
+            //
+            // Attach a recheck closure: the in-band budget (4 × 800ms) is too short
+            // for cold-start sessions and for environments where a slow third-party
+            // UserPromptSubmit / SessionStart hook (e.g. superpowers) defers Claude's
+            // jsonl append by 5–15s. The worker calls recheck() after a delay, and
+            // suppresses the user-facing warning when the line shows up by then.
+            const recheck = () => {
+                if (!submitFingerprint)
+                    return false;
+                // Latest pid → path; covers post-failure rotations (/clear, /resume).
+                if (pty.cliPid && pty.cliCwd) {
+                    const resolved = resolveJsonlFromPid(pty.cliPid, pty.cliCwd);
+                    if (resolved)
+                        applyResolved(resolved);
+                }
+                const currentPath = pty.claudeJsonlPath;
+                if (currentPath && jsonlContainsFingerprint(currentPath, submitFingerprint, { includeQueueOperations: true })) {
+                    return true;
+                }
+                // Fan out to sibling jsonls in the project dir, then across every
+                // sibling project dir under `~/.claude/projects/` (catches workingDir
+                // drift like worker thinking `-foo-bar/` while Claude actually appends
+                // to `-foo-bar-baz/`). Same minMtime guard as the in-band fingerprint
+                // fallback so a stale historical match can't suppress the warning.
+                const searchPath = currentPath ?? pty.claudeJsonlPath;
+                if (!searchPath)
+                    return false;
+                const matched = findJsonlAcrossProjectsRoot(searchPath, submitFingerprint, {
+                    minMtimeMs: submitSearchMinMtime,
+                    includeQueueOperations: true,
+                });
+                return !!matched;
+            };
+            return { ...buildResult(false), recheck };
         },
         completionPattern: COMPLETION_RE,
         readyPattern: /❯/,