nterminal 1.3.3 → 1.3.5

package/dist/server/terminal/TmuxPtyAdapter.js

@@ -7,7 +7,7 @@ import { fileURLToPath } from 'node:url';
 import * as nodePty from 'node-pty';
 import path from 'node:path';
 import { normalizeTerminalTitle, PtySessionUnavailableError } from './PtyAdapter.js';
-import { lookupCodexTranscriptFromDaemonOrLogs, lookupCodexTranscriptFromOpenFds, resolveCodexTranscriptCandidates, processBinding, TRANSCRIPT_CANDIDATE_LIMIT } from './codexTranscriptSource.js';
+import { lookupCodexTranscriptFromDaemon, lookupCodexTranscriptFromProcessLogs, lookupCodexTranscriptFromOpenFds, resolveCodexTranscriptCandidates, processBinding, TRANSCRIPT_CANDIDATE_LIMIT } from './codexTranscriptSource.js';
 import { isSessionId } from './sessionId.js';
 import { processStartTicksToSecondsAsync, readProcessCwdAsync, readProcessEnvValuesAsync, readProcessStartTicksAsync } from './procfs.js';
 import { TtlCache } from './ttlCache.js';
@@ -26,6 +26,8 @@ const TRANSCRIPT_FILE_NEGATIVE_CACHE_TTL_MS = 20_000;
 // letting a history-paging burst (several page requests within seconds)
 // reuse one resolution instead of re-forking tmux/ps per page.
 const TRANSCRIPT_RESOLUTION_CACHE_TTL_MS = 3_000;
+// Diagnostics outlive a few status polls, not the pane's next resolution.
+const TRANSCRIPT_AMBIGUITY_TTL_MS = 90_000;
 const TRANSCRIPT_CANDIDATE_CACHE_TTL_MS = 500;
 const PROCESS_TREE_CACHE_TTL_MS = 1_000;
 const CLAUDE_TRANSCRIPT_START_SKEW_MS = 10_000;
@@ -75,6 +77,9 @@ export class TmuxPtyAdapter {
     commandRunner;
     ptySpawner;
     transcriptResolutionCache = new TtlCache();
+    transcriptResolutionGeneration = new Map();
+    // Last discovery outcome per pane, for status reporting only (bounded by panes).
+    transcriptAmbiguity = new Map();
     transcriptResolutionInflight = new KeyedSingleFlight();
     transcriptCandidateInflight = new KeyedSingleFlight();
     processTreeCache = new TtlCache();
@@ -397,6 +402,8 @@ export class TmuxPtyAdapter {
         this.historyOutputGenerationBySession.delete(sessionId);
         this.historyOutputUnreliableSessions.delete(sessionId);
         this.transcriptResolutionCache.delete(sessionId);
+        this.transcriptResolutionGeneration.delete(sessionId);
+        this.transcriptAmbiguity.delete(sessionId);
     }
     isInflightFinalCreation(sessionId, marker) {
         const inflightMarker = this.inflightFinalCreationMarkers.get(sessionId);
@@ -1039,16 +1046,50 @@ export class TmuxPtyAdapter {
         }
     }
     async resolveTranscriptSource(sessionId) {
+        return (await this.resolveTranscriptSourceEvidence(sessionId))?.source ?? null;
+    }
+    async resolveTranscriptSourceEvidence(sessionId, options = {}) {
+        const resolved = options.fresh ? await this.resolveTranscriptSourceUncached(sessionId, true)
+            : await this.resolveTranscriptSourceCached(sessionId);
+        if (!resolved)
+            return null;
+        const { evidence = 'inferred', client, ...source } = resolved;
+        return { source, evidence, ...(client ? { client } : {}) };
+    }
+    getTranscriptAmbiguity(sessionId) {
+        const entry = this.transcriptAmbiguity.get(sessionId);
+        if (!entry)
+            return null;
+        if (Date.now() - entry.at > TRANSCRIPT_AMBIGUITY_TTL_MS) {
+            this.transcriptAmbiguity.delete(sessionId);
+            return null;
+        }
+        return entry.reason;
+    }
+    noteTranscriptAmbiguity(sessionId, ambiguous) {
+        if (ambiguous)
+            this.transcriptAmbiguity.set(sessionId, { reason: 'codex_shared_daemon_same_cwd', at: Date.now() });
+        else
+            this.transcriptAmbiguity.delete(sessionId);
+    }
+    async resolveTranscriptSourceCached(sessionId) {
         const cached = this.transcriptResolutionCache.get(sessionId);
         if (cached) {
             return cached.value;
         }
-        return this.transcriptResolutionInflight.run(sessionId, async () => {
+        const generation = this.transcriptResolutionGeneration.get(sessionId) ?? 0;
+        return this.transcriptResolutionInflight.run(`${sessionId}:${generation}`, async () => {
             const source = await this.resolveTranscriptSourceUncached(sessionId);
-            this.transcriptResolutionCache.set(sessionId, source, TRANSCRIPT_RESOLUTION_CACHE_TTL_MS);
+            if ((this.transcriptResolutionGeneration.get(sessionId) ?? 0) === generation) {
+                this.transcriptResolutionCache.set(sessionId, source, TRANSCRIPT_RESOLUTION_CACHE_TTL_MS);
+            }
             return source;
         });
     }
+    invalidateTranscriptSource(sessionId) {
+        this.transcriptResolutionCache.delete(sessionId);
+        this.transcriptResolutionGeneration.set(sessionId, (this.transcriptResolutionGeneration.get(sessionId) ?? 0) + 1);
+    }
     async resolveTranscriptCandidates(sessionId) {
         return this.transcriptCandidateInflight.run(sessionId, async () => {
             const result = await this.resolveTranscriptCandidatesUncached(sessionId);
@@ -1071,6 +1112,10 @@ export class TmuxPtyAdapter {
         await mapWithConcurrency(processes, 8, async ({ pid }) => argsByPid.set(pid, await readProcessArgsAsync(pid)));
         const discoveries = [];
         for (const { pid, depth } of processes) {
+            // Breadth-first traversal: deeper workers cannot affect the selected
+            // owner, including a worker exiting while its procfs identity is read.
+            if (discoveries.length && depth > discoveries[0].depth)
+                continue;
             const args = argsByPid.get(pid);
             if (findCommandArg(args, 'claude') !== -1) {
                 if (isNonInteractiveClaudeInvocation(args))
@@ -1111,11 +1156,17 @@ export class TmuxPtyAdapter {
             }
         }
         return {
-            binding: `pane:${panePid}:${paneStart}|${discoveries.map(({ result }) => result.binding).sort().join('|')}`,
+            binding: `pane:${panePid}:${paneStart}|${discoveries.filter(({ depth }) => depth === closest).map(({ result }) => result.binding).sort().join('|')}`,
             candidates: [...candidates.values()].slice(0, TRANSCRIPT_CANDIDATE_LIMIT)
         };
     }
-    async resolveTranscriptSourceUncached(sessionId) {
+    async resolveTranscriptSourceUncached(sessionId, fresh = false) {
+        const state = { daemonAmbiguous: false };
+        const resolved = await this.resolveTranscriptSourceUncachedInner(sessionId, fresh, state);
+        this.noteTranscriptAmbiguity(sessionId, !resolved && state.daemonAmbiguous);
+        return resolved;
+    }
+    async resolveTranscriptSourceUncachedInner(sessionId, fresh, state) {
         const panePid = this.panePidBySession.get(sessionId) ?? await this.readPanePidAsync(sessionId);
         if (panePid === null) {
             return null;
@@ -1136,6 +1187,7 @@ export class TmuxPtyAdapter {
             }
         });
         let entries = [];
+        const pendingCodexDepths = [];
         let claudeSessionPending = false;
         for (const [pid, args] of argsByPid) {
             const processDepth = processDepthByPid.get(pid);
@@ -1166,8 +1218,10 @@ export class TmuxPtyAdapter {
                     entries.push({ candidate: live.source, rank: 'live', processDepth });
                     continue;
                 }
-                if (live.status === 'pending' || live.status === 'ambiguous')
-                    return null;
+                if (live.status === 'pending' || live.status === 'ambiguous') {
+                    pendingCodexDepths.push(processDepth);
+                    continue;
+                }
                 // Launcher pids (the npm node wrapper) merely relay the binary's
                 // argv; after /new their stale `resume <id>` args would conflict
                 // with the live session the binary itself reports, so only the
@@ -1177,13 +1231,21 @@ export class TmuxPtyAdapter {
                 }
                 // A connected daemon is authoritative, even when its current
                 // thread is pending/ambiguous. Never replace that with stale argv.
-                const lookup = await lookupCodexTranscriptFromDaemonOrLogs(pid);
-                if (lookup.status === 'pending' || lookup.status === 'ambiguous')
-                    return null;
+                const daemon = await lookupCodexTranscriptFromDaemon(pid, fresh ? { bypassCache: true } : undefined);
+                const lookup = daemon.status === 'absent' || daemon.status === 'unavailable'
+                    ? await lookupCodexTranscriptFromProcessLogs(pid) : daemon;
+                if (lookup.status === 'pending' || lookup.status === 'ambiguous') {
+                    if (daemon.status === 'ambiguous')
+                        state.daemonAmbiguous = true;
+                    pendingCodexDepths.push(processDepth);
+                    continue;
+                }
                 const stated = lookup.status === 'matched' ? lookup.source
                     : lookup.status === 'absent' ? extractCodexArgsCandidate(args) : null;
                 if (stated) {
-                    entries.push({ candidate: stated, rank: 'stated', processDepth });
+                    const client = daemon.status === 'matched' ? await describeTranscriptClient(pid, args) : null;
+                    entries.push({ candidate: stated, rank: daemon.status === 'matched' ? 'daemon' : 'stated', processDepth,
+                        ...(client ? { client } : {}) });
                 }
             }
         }
@@ -1194,15 +1256,23 @@ export class TmuxPtyAdapter {
             // other session's file) is wrong by construction.
             entries = entries.filter((entry) => entry.candidate.provider !== 'claude' || entry.rank === 'live');
         }
-        const candidate = selectTranscriptCandidate(entries);
-        if (!candidate) {
+        // Uncertain child jobs cannot veto a closer write-open TUI owner. At
+        // the same or shallower depth uncertainty still blocks all fallback.
+        const closestLiveCodex = Math.min(...entries.filter(entry => entry.rank === 'live' && entry.candidate.provider === 'codex')
+            .map(entry => entry.processDepth ?? Infinity));
+        if (pendingCodexDepths.some(depth => depth <= closestLiveCodex))
+            return null;
+        const selected = selectTranscriptCandidateEntry(entries);
+        if (!selected) {
             return null;
         }
+        const candidate = selected.candidate;
         const matches = candidate.filePath ? [candidate.filePath] : await findTranscriptFilesAsync(candidate.provider, candidate.sessionId);
         if (matches.length !== 1) {
             return null;
         }
-        return { provider: candidate.provider, sessionId: candidate.sessionId, filePath: matches[0] };
+        return { provider: candidate.provider, sessionId: candidate.sessionId, filePath: matches[0], evidence: selected.rank,
+            ...(selected.client ? { client: selected.client } : {}) };
     }
     async readPaneMetricsAsync(sessionId) {
         try {
@@ -1292,6 +1362,10 @@ export class TmuxPtyAdapter {
             return false;
         }
     }
+    getSessionPid(sessionId) {
+        const cached = this.panePidBySession.get(sessionId);
+        return cached ? Promise.resolve(cached) : this.readPanePidAsync(sessionId);
+    }
     async readPanePidAsync(sessionId) {
         try {
             const result = await this.commandRunner('tmux', [
@@ -1714,6 +1788,17 @@ async function readProcessArgsAsync(pid) {
         return [];
     }
 }
+// Launch facts for the TUI behind a daemon association. Missing facts stay
+// missing (never guessed), so corroboration fails closed.
+async function describeTranscriptClient(pid, args) {
+    const startTicks = await readProcessStartTicksAsync(pid);
+    if (startTicks === null)
+        return null;
+    const startedAtSeconds = await processStartTicksToSecondsAsync(startTicks);
+    const stated = extractCodexArgsCandidate(args)?.sessionId;
+    return { pid, startTicks, startedAtMs: startedAtSeconds === null ? null : Math.round(startedAtSeconds * 1000),
+        ...(stated ? { statedSessionId: stated } : {}) };
+}
 function extractCodexArgsCandidate(args) {
     const codexIndex = findCommandArg(args, 'codex');
     if (codexIndex === -1) {
@@ -1822,7 +1907,10 @@ function hasCodexDescendant(tree, root, argsByPid) {
 // tier returns null — falling back to a lower tier would resolve precisely
 // when the best information says the answer is uncertain.
 export function selectTranscriptCandidate(entries) {
-    for (const rank of ['live', 'stated', 'inferred']) {
+    return selectTranscriptCandidateEntry(entries)?.candidate ?? null;
+}
+function selectTranscriptCandidateEntry(entries) {
+    for (const rank of ['live', 'daemon', 'stated', 'inferred']) {
         let pool = entries.filter((entry) => entry.rank === rank);
         if (pool.length === 0) {
             continue;
@@ -1848,7 +1936,7 @@ export function selectTranscriptCandidate(entries) {
         if (unique.size !== 1) {
             return null;
         }
-        return [...unique.values()][0];
+        return { candidate: [...unique.values()][0], rank };
     }
     return null;
 }