aicodeman 1.11.0 → 1.11.2

package/dist/web/routes/session-routes.js

@@ -311,7 +311,7 @@ export function registerSessionRoutes(app, ctx) {
         //
         // For keys the caller is actively setting, strip any stale disk entry a prior
         // Codeman version may have written. Scope limited to:
-        //   - Claude mode (OpenCode/Codex/Gemini don't read .claude/settings.local.json)
+        //   - Claude mode (OpenCode/Codex/Gemini/Antigravity don't read .claude/settings.local.json)
         //   - workingDir inside CASES_DIR / the per-user case space (Codeman's managed
         //     territory — we never mutate .claude/settings.local.json in arbitrary user
         //     repos that POST /api/sessions can target, as those may have hand-authored
@@ -766,84 +766,110 @@ export function registerSessionRoutes(app, ctx) {
         return {};
     });
     // ========== Get Last Response (from transcript JSONL) ==========
-    // Resolves the most recent Claude conversation id for a session's cwd by
-    // tailing ~/.claude/history.jsonl. After `/clear`, Claude Code keeps writing
-    // to a new <uuid>.jsonl; history.jsonl is the only source-of-truth update
-    // that does not rely on project-local hooks (we intentionally don't install
-    // hooks in arbitrary user repos, see the POST /api/sessions comment).
+    // How far apart a ~/.claude/history.jsonl entry and a pane's Enter may be and
+    // still be the same submission. Claude appends to history as it accepts the
+    // prompt, so the true gap is milliseconds — this is slack for a loaded box,
+    // not a search radius.
+    const CLAUDE_SUBMIT_MATCH_MS = 10_000;
+    // history.jsonl grows forever; only the tail can hold entries near a submit.
+    const CLAUDE_HISTORY_TAIL_BYTES = 256 * 1024;
+    // Resolves the Claude conversation id THIS pane is currently on by matching
+    // ~/.claude/history.jsonl (which logs every submitted prompt as
+    // {project, sessionId, timestamp}) against the pane's last Enter. After
+    // `/clear` Claude keeps writing to a new <uuid>.jsonl, and history.jsonl is
+    // the only source-of-truth update that does not rely on project-local hooks
+    // (we intentionally don't install hooks in arbitrary user repos, see the
+    // POST /api/sessions comment).
     //
-    // Entries from OTHER Codeman sessions in the same cwd are filtered out by
-    // their known claudeSessionIds so concurrent tabs don't shadow each other,
-    // as long as each has had its id resolved at least once.
+    // The pane's own Enter is what makes an entry OURS. `project` alone is not:
+    // a cwd is shared by every other Codeman tab on it, by tabs long since
+    // closed, and by any plain `claude` the user runs in their own terminal —
+    // adopting the newest entry for the cwd pinned the viewer to whichever of
+    // those conversations was typed in last, so the eye showed a stranger's
+    // transcript. With no correlated entry we keep the id we have; a viewer one
+    // turn behind beats a viewer showing someone else's conversation.
+    const claudeHistoryPinCache = new LRUMap({ maxSize: 1024 });
     async function resolveActiveClaudeSessionIdFromHistory(session, projectsDir) {
-        const historyPath = join(homedir(), '.claude', 'history.jsonl');
+        const submitAt = session.lastSubmitAt;
+        if (!submitAt)
+            return null; // never typed through Codeman — nothing to credit
+        const cached = claudeHistoryPinCache.get(session.id);
+        if (cached && cached.submitAt === submitAt)
+            return cached.claudeSessionId;
+        // Ids another live pane is already pinned to can never be ours, and every
+        // pane sharing this cwd competes for the entry we are about to claim —
+        // including non-Claude panes, since a shell pane can run `claude` too.
         const otherClaudeIds = new Set();
+        const otherSubmits = [];
         for (const s of ctx.sessions.values()) {
-            if (s.id !== session.id && s.workingDir === session.workingDir && s.claudeSessionId) {
+            if (s.id === session.id || s.workingDir !== session.workingDir)
+                continue;
+            if (s.claudeSessionId)
                 otherClaudeIds.add(s.claudeSessionId);
-            }
+            if (s.lastSubmitAt)
+                otherSubmits.push(s.lastSubmitAt);
         }
-        let candidateSid = null;
-        try {
-            const content = await fs.readFile(historyPath, 'utf8');
-            const lines = content.split('\n');
-            for (let i = lines.length - 1; i >= 0; i--) {
-                const line = lines[i];
-                if (!line)
-                    continue;
-                try {
-                    const entry = JSON.parse(line);
-                    if (entry.project === session.workingDir &&
-                        typeof entry.sessionId === 'string' &&
-                        !otherClaudeIds.has(entry.sessionId)) {
-                        candidateSid = entry.sessionId;
-                        break;
-                    }
-                }
-                catch {
-                    // Skip unparseable lines
-                }
+        const historyPath = join(homedir(), '.claude', 'history.jsonl');
+        const stat = await fs.stat(historyPath).catch(() => null);
+        if (!stat || stat.size === 0)
+            return null;
+        const tail = await readFileTail(historyPath, Buffer.alloc(CLAUDE_HISTORY_TAIL_BYTES), stat.size);
+        if (!tail)
+            return null;
+        let best;
+        for (const line of tail.split('\n')) {
+            if (!line)
+                continue;
+            let entry;
+            try {
+                entry = JSON.parse(line);
             }
+            catch {
+                continue; // the first tail line is usually cut mid-JSON
+            }
+            const { sessionId, timestamp } = entry;
+            if (entry.project !== session.workingDir)
+                continue;
+            if (typeof sessionId !== 'string' || !sessionId)
+                continue;
+            if (typeof timestamp !== 'number')
+                continue;
+            if (otherClaudeIds.has(sessionId))
+                continue;
+            const dist = Math.abs(timestamp - submitAt);
+            if (dist > CLAUDE_SUBMIT_MATCH_MS)
+                continue;
+            if (otherSubmits.some((other) => Math.abs(timestamp - other) < dist))
+                continue; // another pane is closer
+            if (!best || dist <= best.dist)
+                best = { sessionId, dist }; // ties: the newer entry wins
         }
-        catch {
+        if (!best)
             return null;
-        }
-        if (!candidateSid || candidateSid === session.id)
-            return candidateSid;
-        // Safety: only adopt if the candidate's jsonl is more recently written
-        // than our initial conversation's jsonl. Blocks stale ids inherited from
-        // a prior Codeman session that happened to share this cwd.
-        try {
-            const projectDirs = await fs.readdir(projectsDir);
+        // Sanity: the conversation we switch to must exist on disk and must not be
+        // staler than the one we are leaving. A `/clear` successor never is.
+        const currentSessionId = session.claudeSessionId || session.id;
+        if (best.sessionId !== currentSessionId) {
+            const projectDirs = await fs.readdir(projectsDir).catch(() => null);
+            if (!projectDirs)
+                return null;
             let candidateMtime = 0;
-            let initialMtime = 0;
+            let currentMtime = 0;
             for (const projDir of projectDirs) {
-                try {
-                    const cs = await fs.stat(join(projectsDir, projDir, `${candidateSid}.jsonl`));
-                    if (cs.mtimeMs > candidateMtime)
-                        candidateMtime = cs.mtimeMs;
-                }
-                catch {
-                    /* not in this dir */
-                }
-                try {
-                    const is = await fs.stat(join(projectsDir, projDir, `${session.id}.jsonl`));
-                    if (is.mtimeMs > initialMtime)
-                        initialMtime = is.mtimeMs;
-                }
-                catch {
-                    /* not in this dir */
-                }
+                const candidateStat = await fs.stat(join(projectsDir, projDir, `${best.sessionId}.jsonl`)).catch(() => null);
+                if (candidateStat && candidateStat.mtimeMs > candidateMtime)
+                    candidateMtime = candidateStat.mtimeMs;
+                const currentStat = await fs.stat(join(projectsDir, projDir, `${currentSessionId}.jsonl`)).catch(() => null);
+                if (currentStat && currentStat.mtimeMs > currentMtime)
+                    currentMtime = currentStat.mtimeMs;
             }
             if (candidateMtime === 0)
+                return null; // transcript not written yet — retry next poll
+            if (currentMtime > 0 && candidateMtime < currentMtime)
                 return null;
-            if (initialMtime > 0 && candidateMtime <= initialMtime)
-                return null;
-        }
-        catch {
-            return null;
         }
-        return candidateSid;
+        claudeHistoryPinCache.set(session.id, { submitAt, claudeSessionId: best.sessionId });
+        return best.sessionId;
     }
     function extractClaudeText(content, separator) {
         if (typeof content === 'string')
@@ -1022,6 +1048,11 @@ export function registerSessionRoutes(app, ctx) {
         const activeId = await resolveActiveClaudeSessionIdFromHistory(session, projectsDir);
         if (activeId && activeId !== session.claudeSessionId) {
             session.adoptClaudeSessionId(activeId);
+            // Flush the Enter that vouched for this adoption to state.json. A `/clear`
+            // emits no completion event, so without this the anchor could still be
+            // unpersisted when the server restarts — and recovery would fall back to
+            // the launch conversation.
+            ctx.persistSessionState(session);
             // Docker sessions: keep the case's resume seed following the live conversation.
             if (session.docker) {
                 void persistDockerCaseClaudeSessionId(CODEMAN_CONFIG_DIR, session.docker.containerName, activeId).catch(() => { });
@@ -1083,7 +1114,7 @@ export function registerSessionRoutes(app, ctx) {
         }
         return { cwd, originator };
     }
-    // The pane's last Enter (Session.codexLastSubmitAt) correlated against
+    // The pane's last Enter (Session.lastSubmitAt) correlated against
     // ~/.codex/history.jsonl, which logs every submitted user message as
     // {session_id, ts}. This identifies the thread the pane is ACTUALLY on and
     // is the only signal that survives /resume, /new and /fork typed inside the
@@ -1092,7 +1123,7 @@ export function registerSessionRoutes(app, ctx) {
     // can't steal the attribution.
     const codexHistoryPinCache = new LRUMap({ maxSize: 1024 });
     async function resolveCodexThreadFromHistory(session, codexHome) {
-        const submitAt = session.codexLastSubmitAt || 0;
+        const submitAt = session.lastSubmitAt || 0;
         if (!submitAt)
             return null;
         const cached = codexHistoryPinCache.get(session.id);
@@ -1108,8 +1139,8 @@ export function registerSessionRoutes(app, ctx) {
         const WINDOW_MS = 15_000;
         const otherSubmits = [];
         for (const s of ctx.sessions.values()) {
-            if (s.id !== session.id && s.mode === 'codex' && s.codexLastSubmitAt) {
-                otherSubmits.push(s.codexLastSubmitAt);
+            if (s.id !== session.id && s.mode === 'codex' && s.lastSubmitAt) {
+                otherSubmits.push(s.lastSubmitAt);
             }
         }
         let best;
@@ -1692,7 +1723,7 @@ export function registerSessionRoutes(app, ctx) {
             if (!host)
                 return createErrorResponse(ApiErrorCode.NOT_FOUND, 'Remote host not found');
             // Per-session config that is applied to the LOCAL tmux/CLI wrapper (env vars via
-            // tmux setenv, effort/model CLI args, codex/gemini/opencode config) does NOT
+            // tmux setenv, effort/model CLI args, codex/gemini/antigravity/opencode config) does NOT
             // cross ssh, so it would silently no-op. Reject rather than pretend it worked —
             // remote command/env customization goes through the per-host command override.
             if ((envOverrides && Object.keys(envOverrides).length > 0) ||
@@ -1979,7 +2010,7 @@ export function registerSessionRoutes(app, ctx) {
                 ctx.broadcast(SseEvent.SessionInteractive, { id: session.id, mode: 'shell' });
             }
             else {
-                // 'claude', 'opencode', 'codex', and 'gemini' modes use startInteractive()
+                // 'claude', 'opencode', 'codex', 'gemini', and 'antigravity' modes use startInteractive()
                 await session.startInteractive();
                 getLifecycleLog().log({
                     event: 'started',
@@ -2092,6 +2123,66 @@ export function registerSessionRoutes(app, ctx) {
         }
         return undefined;
     }
+    /**
+     * Is this `entrypoint` value an automated/SDK-driven invocation?
+     *
+     * ⚠️ Deliberately a BLOCKLIST on the SDK shape, not an allowlist on `'cli'`.
+     * The exclusion below hides rows, so an allowlist fails CLOSED on any value
+     * Claude Code has not shipped yet: the day it stamps a new interactive
+     * entrypoint (a rename, or a second interactive host), every transcript stops
+     * matching `'cli'` and the whole Past Sessions list goes blank with nothing in
+     * the UI to explain it. A blocklist fails OPEN instead — an automated
+     * entrypoint we do not recognize yet costs a few noisy rows, which is the
+     * annoyance this filter set out to fix rather than a broken feature.
+     *
+     * Observed values: `cli` (interactive), `sdk-cli` / `sdk-py` (automated).
+     */
+    function isAutomatedEntrypoint(entrypoint) {
+        return /^sdk(-|$)/.test(entrypoint);
+    }
+    /**
+     * The `entrypoint` field Claude Code stamps on its own message records:
+     * 'cli' for a real interactive session, something else (e.g. 'sdk-py') for
+     * an SDK/automated invocation. Used to exclude non-interactive transcripts
+     * (CI review bots, etc.) from the resumable history list — they were never
+     * something a user can resume into.
+     *
+     * Scans every `"type":"user"`/`"type":"assistant"` line with an entrypoint
+     * field — not just the first one — and returns 'cli' the moment ANY of them
+     * carries it. A transcript is excluded only when every entrypoint-bearing
+     * message says something else; "first field wins" would misattribute a
+     * transcript that started under an older Claude Code version (no entrypoint
+     * on its true first message) and later picked up a non-'cli' entrypoint on
+     * some later message, wrongly hiding a genuinely interactive session. This
+     * deliberately errs toward keeping a session visible: one real interactive
+     * message anywhere is enough. Returns undefined ("unknown", fail-open) only
+     * when nothing scanned carries the field at all.
+     */
+    function extractTranscriptEntrypoint(text) {
+        let start = 0;
+        let sawNonCli;
+        while (start < text.length) {
+            const end = text.indexOf('\n', start);
+            const line = end === -1 ? text.slice(start) : text.slice(start, end);
+            start = end === -1 ? text.length : end + 1;
+            if (!line.includes('"type":"user"') && !line.includes('"type":"assistant"'))
+                continue;
+            if (!line.includes('"entrypoint"'))
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                if ((entry.type === 'user' || entry.type === 'assistant') && typeof entry.entrypoint === 'string') {
+                    if (entry.entrypoint === 'cli')
+                        return 'cli';
+                    sawNonCli ??= entry.entrypoint;
+                }
+            }
+            catch {
+                // Malformed/truncated line — skip
+            }
+        }
+        return sawNonCli;
+    }
     /**
      * Extract the text of the LAST user message from a JSONL transcript chunk
      * (COD-145). Mirrors `extractFirstUserPrompt` exactly — same user-message
@@ -2314,7 +2405,7 @@ export function registerSessionRoutes(app, ctx) {
             .catch(() => false);
         return finalExists ? current : process.env.HOME || '/tmp';
     }
-    /** Read the first 16KB of a file for content sniffing. */
+    /** Read the first `buf.length` bytes of a file for content sniffing. */
     async function readFileHead(path, buf) {
         try {
             const fd = await fs.open(path, 'r');
@@ -2347,7 +2438,7 @@ export function registerSessionRoutes(app, ctx) {
     }
     // Scan a single project directory and return all valid history sessions in it.
     // Reused by both the global overview and the single-folder drill-down.
-    async function scanProjectDir(projPath, projDir, headBuf) {
+    async function scanProjectDir(projPath, projDir, smallHeadBuf, headBuf) {
         const out = [];
         const stat = await fs.stat(projPath).catch(() => null);
         if (!stat?.isDirectory())
@@ -2366,12 +2457,35 @@ export function registerSessionRoutes(app, ctx) {
                 continue;
             if (fileStat.size < 4000)
                 continue;
-            let firstPrompt;
-            const head = await readFileHead(filePath, headBuf);
             const hasConversation = (text) => text.includes('"type":"user"') || text.includes('"type":"assistant"') || text.includes('"type":"summary"');
+            // Two-tier head read: try the cheap smallHeadBuf (16KB) size first -- enough
+            // for the vast majority of transcripts -- and only escalate to the full
+            // headBuf (128KB) when that wasn't enough. Reading 128KB unconditionally for
+            // EVERY file in the directory roughly quadrupled the cost of a full scan
+            // (measured against a real ~/.claude/projects tree: ~4x both bytes read and
+            // wall time) to fix a problem only ~28% of files actually have. Escalating
+            // resolves the restart-bookkeeping case (the reason 128KB exists at all)
+            // without ever touching the tail-read fallback below for most of that 28%.
+            let head = await readFileHead(filePath, smallHeadBuf);
             let foundContent = head ? hasConversation(head) : false;
+            let firstPrompt = head ? extractFirstUserPrompt(head) : undefined;
+            if ((!foundContent || !firstPrompt) && head !== null && fileStat.size > smallHeadBuf.length) {
+                const biggerHead = await readFileHead(filePath, headBuf);
+                if (biggerHead) {
+                    head = biggerHead;
+                    if (!foundContent)
+                        foundContent = hasConversation(head);
+                    if (!firstPrompt)
+                        firstPrompt = extractFirstUserPrompt(head);
+                }
+            }
             let tail = null;
-            if (!foundContent && fileStat.size > 16384) {
+            // `head === null` (a failed read -- e.g. EMFILE while scanning hundreds of
+            // files) must also get a shot at the tail, not just "file bigger than the
+            // head buffer". Losing this dropped the session from history entirely
+            // instead of giving it a second chance, for any file at or under the head
+            // buffer size whose head read happened to fail.
+            if (!foundContent && (head === null || fileStat.size > headBuf.length)) {
                 const tailBuf = Buffer.alloc(32768);
                 tail = await readFileTail(filePath, tailBuf, fileStat.size);
                 if (tail)
@@ -2379,9 +2493,9 @@ export function registerSessionRoutes(app, ctx) {
             }
             if (!foundContent)
                 continue;
-            if (head)
-                firstPrompt = extractFirstUserPrompt(head);
-            if (!firstPrompt && fileStat.size > 65536) {
+            // firstPrompt was already attempted from head (both tiers) above; this is
+            // purely the tail fallback for whatever's left unresolved.
+            if (!firstPrompt && (head === null || fileStat.size > headBuf.length)) {
                 if (!tail) {
                     const tailBuf = Buffer.alloc(32768);
                     tail = await readFileTail(filePath, tailBuf, fileStat.size);
@@ -2391,13 +2505,34 @@ export function registerSessionRoutes(app, ctx) {
             }
             // COD-145: last (most recent) user prompt lives near the END of the file, so
             // prefer the tail. For large files where no tail was read yet, read one
-            // (mirrors the firstPrompt > 65536 block). Small files fit in `head`, which
-            // then contains the whole transcript — scan it for the last match instead.
-            if (!tail && fileStat.size > 65536) {
+            // (mirrors the firstPrompt > headBuf.length block). Small files fit in `head`,
+            // which then contains the whole transcript — scan it for the last match instead.
+            if (!tail && fileStat.size > headBuf.length) {
                 const tailBuf = Buffer.alloc(32768);
                 tail = await readFileTail(filePath, tailBuf, fileStat.size);
             }
             const lastPrompt = (tail ? extractLastUserPrompt(tail) : undefined) ?? (head ? extractLastUserPrompt(head) : undefined);
+            // Automated/SDK-driven invocations (CI review bots, etc.) write transcripts
+            // into the same ~/.claude/projects tree as interactive sessions but were
+            // never something a user can resume into — no PTY, no running process, and
+            // their "conversation" is typically a single one-shot prompt (often with a
+            // full diff embedded, which is exactly why it dwarfs this scanner's read
+            // windows and shows up above as blank or as an identical boilerplate
+            // sentence across many rows). Checked last, so it reuses whatever `head`/
+            // `tail` the prompt extraction above already read rather than triggering
+            // an extra file read. Missing entrypoint (older transcripts) reads as
+            // interactive — fail open, matching every other gating check in this
+            // codebase.
+            //
+            // head and tail are checked independently and merged with "cli wins" (not
+            // a first-truthy-value `??` chain): a large file's head might land on a
+            // non-'cli' message while a real interactive message sits in the tail (or
+            // vice versa), and either one being 'cli' is enough to keep the session.
+            const headEntrypoint = head ? extractTranscriptEntrypoint(head) : undefined;
+            const tailEntrypoint = tail ? extractTranscriptEntrypoint(tail) : undefined;
+            const entrypoint = headEntrypoint === 'cli' || tailEntrypoint === 'cli' ? 'cli' : (headEntrypoint ?? tailEntrypoint);
+            if (entrypoint && isAutomatedEntrypoint(entrypoint))
+                continue;
             out.push({
                 sessionId,
                 workingDir,
@@ -2413,7 +2548,13 @@ export function registerSessionRoutes(app, ctx) {
     app.get('/api/history/sessions', async (req) => {
         const query = req.query;
         const projectsDir = join(process.env.HOME || '/tmp', '.claude', 'projects');
-        const headBuf = Buffer.alloc(16384);
+        // scanProjectDir tries smallHeadBuf (16KB, the original size) first for every
+        // file and only escalates to headBuf (128KB) when that wasn't enough — see the
+        // comment at the escalation site in scanProjectDir for why unconditional 128KB
+        // reads were too expensive to keep. 128KB matches the existing precedent
+        // elsewhere in this file (line ~1431).
+        const smallHeadBuf = Buffer.alloc(16384);
+        const headBuf = Buffer.alloc(131072);
         // Multi-user: this scans the host-wide ~/.claude/projects tree, so a non-admin
         // must only see history whose decoded workingDir is inside their own case space.
         // Do NOT trust the caller-supplied projectKey — confine on the decoded path.
@@ -2430,7 +2571,7 @@ export function registerSessionRoutes(app, ctx) {
             const offset = Math.max(0, parseInt(query.offset || '0', 10) || 0);
             const limit = Math.min(100, Math.max(1, parseInt(query.limit || '20', 10) || 20));
             const projPath = join(projectsDir, query.projectKey);
-            let all = await scanProjectDir(projPath, query.projectKey, headBuf);
+            let all = await scanProjectDir(projPath, query.projectKey, smallHeadBuf, headBuf);
             // Confine to the caller's workspace (a projectKey maps to a single foreign cwd).
             if (scopeHistory)
                 all = all.filter((r) => isWorkingDirAllowed(user, r.workingDir));
@@ -2443,7 +2584,7 @@ export function registerSessionRoutes(app, ctx) {
             const projectDirs = await fs.readdir(projectsDir);
             for (const projDir of projectDirs) {
                 const projPath = join(projectsDir, projDir);
-                const list = await scanProjectDir(projPath, projDir, headBuf);
+                const list = await scanProjectDir(projPath, projDir, smallHeadBuf, headBuf);
                 results.push(...list);
             }
         }
@@ -2515,11 +2656,13 @@ export function registerSessionRoutes(app, ctx) {
         const history = [];
         try {
             const projectsDir = join(process.env.HOME || '/tmp', '.claude', 'projects');
-            const headBuf = Buffer.alloc(16384);
+            // See the sibling allocation above for why there are two sizes.
+            const smallHeadBuf = Buffer.alloc(16384);
+            const headBuf = Buffer.alloc(131072);
             const projectDirs = await fs.readdir(projectsDir);
             for (const projDir of projectDirs) {
                 const projPath = join(projectsDir, projDir);
-                const list = await scanProjectDir(projPath, projDir, headBuf);
+                const list = await scanProjectDir(projPath, projDir, smallHeadBuf, headBuf);
                 for (const h of list) {
                     history.push({
                         sessionId: h.sessionId,