@agentdeck/bridge 1.0.3 → 1.0.5

package/dist/passive-observer.d.ts

@@ -17,6 +17,15 @@ export interface TranscriptSummary {
     totalTokens?: number;
     contextPercent?: number;
 }
+export interface CodexRolloutSummary extends TranscriptSummary {
+    sessionId?: string;
+    cwd?: string;
+    startedAt?: number;
+    effort?: string;
+    hasPendingCalls?: boolean;
+    /** Internal companion rollouts never become top-level dashboard sessions. */
+    isSubagent: boolean;
+}
 /**
  * Condense a first user prompt into a one-line session goal: strip injected
  * tags/markup + slash-command noise, collapse whitespace, cap length. Returns ''
@@ -43,10 +52,35 @@ export interface ObservedSession extends EnrichedSession {
      *  prompt is over. Absent when no transcript could be located. */
     lastActivityAt?: number;
 }
+interface CodexRolloutFileInfo {
+    mtimeMs: number;
+    size: number;
+}
+interface CodexRolloutCacheEntry extends CodexRolloutFileInfo {
+    summary: CodexRolloutSummary;
+}
+export interface CodexRolloutCacheDependencies {
+    stat(path: string): Promise<CodexRolloutFileInfo>;
+    read(path: string, headBytes: number, tailBytes: number): Promise<string>;
+}
+/**
+ * Bounded per-rollout summary cache. A scan only stats open rollout paths;
+ * unchanged `(path, mtime, size)` entries reuse their parsed summary. Changed
+ * files are read asynchronously, and paths no longer held open are invalidated.
+ */
+export declare class CodexRolloutCache {
+    private deps;
+    private entries;
+    constructor(deps?: CodexRolloutCacheDependencies);
+    get(path: string): Promise<CodexRolloutCacheEntry | undefined>;
+    retain(paths: ReadonlySet<string>): void;
+    get size(): number;
+}
 export declare class PassiveSessionObserver {
     private lastScanAt;
     private cached;
     private scanInFlight;
+    private codexRolloutCache;
     /** Fired after a background scan changed the cached list. Wire to a
      *  debounced sessions broadcast so fresh observations reach clients
      *  without the enricher ever blocking on the scan. */
@@ -65,13 +99,7 @@ export declare class PassiveSessionObserver {
 }
 export declare function parseProcessTable(output: string): ProcInfo[];
 export declare function parseClaudeTranscript(raw: string): TranscriptSummary;
-export declare function parseCodexRollout(raw: string): TranscriptSummary & {
-    sessionId?: string;
-    cwd?: string;
-    startedAt?: number;
-    effort?: string;
-    hasPendingCalls?: boolean;
-};
+export declare function parseCodexRollout(raw: string): CodexRolloutSummary;
 /** Extract the enclosing macOS app name from an executable path, e.g.
  *  "/Applications/ChatGPT.app/Contents/Resources/codex …" → "ChatGPT". */
 export declare function appNameFromCommand(command: string): string | undefined;
@@ -79,6 +107,27 @@ export declare function appNameFromCommand(command: string): string | undefined;
  *  this process. GUI-hosted agent sessions (Claude.app, ChatGPT.app) have no
  *  tty, so the owning app is how the injector finds their UI. */
 export declare function resolveHostApp(pid: number, byPid: Map<number, ProcInfo>, maxDepth?: number): string | undefined;
+/** Testable async projection from open rollout paths to top-level sessions. */
+export declare function collectCodexSessionsFromRollouts(processes: ProcInfo[], rolloutsByPid: Map<number, string[]>, rolloutCache: CodexRolloutCache): Promise<ObservedSession[]>;
+/**
+ * A Codex process that can own a user session.
+ *
+ * `codex app-server` was excluded here originally because it was only ever an
+ * IDE extension's headless backend. The ChatGPT.app Codex desktop app now runs
+ * exactly that command for a real, user-facing session
+ * (`/Applications/ChatGPT.app/Contents/Resources/codex … app-server`), so the
+ * process shape no longer separates the two and the exclusion made every
+ * desktop-app session invisible — no session row, no creature — even though its
+ * lifecycle hooks were landing in the timeline the whole time.
+ *
+ * Admission is settled downstream instead, by whether the pid holds an open
+ * rollout file: an app-server with no conversation holds none and is dropped in
+ * `collectCodexSessions`. The Electron helpers ship a capital-`Codex` basename
+ * (`Codex (Renderer)`), so `cmdHasBinary` already excludes them.
+ */
+export declare function isCodexSessionProcessCommand(command: string): boolean;
 export declare function isAntigravityProcessCommand(command: string): boolean;
-export declare function parseLsofRollouts(output: string): Map<number, string>;
+export declare function dedupeObservedSessions(observed: ObservedSession[], managedSessions: EnrichedSession[], processes: ProcInfo[]): ObservedSession[];
+export declare function parseLsofRollouts(output: string): Map<number, string[]>;
+export {};
 //# sourceMappingURL=passive-observer.d.ts.map

package/dist/passive-observer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"passive-observer.d.ts","sourceRoot":"","sources":["../src/passive-observer.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAW/D,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,YAAY,CAAC;AAElD,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,aAAa,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2EAA2E;IAC3E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAgBD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAU7C;AASD,MAAM,WAAW,eAAgB,SAAQ,eAAe;IACtD,+EAA+E;IAC/E,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;iDAC6C;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;sEAIkE;IAClE,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAQD,qBAAa,sBAAsB;IACjC,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,YAAY,CAAS;IAE7B;;0DAEsD;IACtD,WAAW,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;IAEtC;;;;;;;;OAQG;IACH,OAAO,CAAC,eAAe,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE;YAYhD,IAAI;CAenB;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,EAAE,CAc5D;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAoFpE;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,CA6HvK;AAeD;0EAC0E;AAC1E,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGtE;AAED;;iEAEiE;AACjE,wBAAgB,cAAc,CAC5B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,EAC5B,QAAQ,SAAI,GACX,MAAM,GAAG,SAAS,CASpB;AAqKD,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAapE;AAkID,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAYrE"}
+{"version":3,"file":"passive-observer.d.ts","sourceRoot":"","sources":["../src/passive-observer.ts"],"names":[],"mappings":"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"}

package/dist/passive-observer.js

@@ -1,7 +1,8 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { open as openAsync, readdir as readdirAsync, readlink as readlinkAsync, stat as statAsync, } from 'node:fs/promises';
 const execFileAsync = promisify(execFile);
-import { closeSync, existsSync, lstatSync, openSync, readFileSync, readlinkSync, readSync, readdirSync, statSync, } from 'node:fs';
+import { closeSync, existsSync, lstatSync, openSync, readFileSync, readSync, readdirSync, statSync, } from 'node:fs';
 import { basename, join } from 'node:path';
 import { homedir } from 'node:os';
 import { resolveProjectNameFromCwdCached } from './utils/project-name.js';
@@ -44,10 +45,58 @@ const MAX_TAIL_BYTES = 512 * 1024;
 const MAX_SAMPLE_BYTES = 1024 * 1024;
 /** Rollout silence (no writes) after which an end-event-less turn is presumed dead. */
 const STALE_TURN_MS = 10 * 60 * 1000;
+const defaultCodexRolloutCacheDependencies = {
+    stat: async (path) => {
+        const info = await statAsync(path);
+        return { mtimeMs: info.mtimeMs, size: info.size };
+    },
+    read: readFileHeadAndTailAsync,
+};
+/**
+ * Bounded per-rollout summary cache. A scan only stats open rollout paths;
+ * unchanged `(path, mtime, size)` entries reuse their parsed summary. Changed
+ * files are read asynchronously, and paths no longer held open are invalidated.
+ */
+export class CodexRolloutCache {
+    deps;
+    entries = new Map();
+    constructor(deps = defaultCodexRolloutCacheDependencies) {
+        this.deps = deps;
+    }
+    async get(path) {
+        let info;
+        try {
+            info = await this.deps.stat(path);
+        }
+        catch {
+            this.entries.delete(path);
+            return undefined;
+        }
+        const cached = this.entries.get(path);
+        if (cached && cached.mtimeMs === info.mtimeMs && cached.size === info.size)
+            return cached;
+        const raw = await this.deps.read(path, 256 * 1024, MAX_SAMPLE_BYTES).catch(() => '');
+        if (!raw) {
+            this.entries.delete(path);
+            return undefined;
+        }
+        const entry = { ...info, summary: parseCodexRollout(raw) };
+        this.entries.set(path, entry);
+        return entry;
+    }
+    retain(paths) {
+        for (const path of this.entries.keys()) {
+            if (!paths.has(path))
+                this.entries.delete(path);
+        }
+    }
+    get size() { return this.entries.size; }
+}
 export class PassiveSessionObserver {
     lastScanAt = 0;
     cached = [];
     scanInFlight = false;
+    codexRolloutCache = new CodexRolloutCache();
     /** Fired after a background scan changed the cached list. Wire to a
      *  debounced sessions broadcast so fresh observations reach clients
      *  without the enricher ever blocking on the scan. */
@@ -76,7 +125,7 @@ export class PassiveSessionObserver {
         const processes = await collectProcessInfo();
         const observed = [
             ...collectClaudeSessions(processes),
-            ...(await collectCodexSessions(processes)),
+            ...(await collectCodexSessions(processes, this.codexRolloutCache)),
             ...(await collectOpenCodeSessions(processes)),
             ...(await collectAntigravitySessions(processes)),
         ];
@@ -193,6 +242,33 @@ export function parseClaudeTranscript(raw) {
             : undefined,
     };
 }
+/**
+ * Codex reports `input_tokens` INCLUSIVE of `cached_input_tokens` — the live
+ * rollouts satisfy `total_tokens === input_tokens + output_tokens`. Adding the
+ * cached count on top double-counts it, which pushed one observed session to
+ * 105% context and roughly doubled its token total. Older producers that report
+ * cached separately have no `total_tokens`, so the additive form stays the
+ * fallback and their accounting is unchanged.
+ */
+function codexCachedIsIncluded(usage) {
+    const reported = numberAt(usage, 'total_tokens');
+    if (reported <= 0)
+        return false;
+    return numberAt(usage, 'input_tokens') + numberAt(usage, 'output_tokens') === reported;
+}
+function codexCachedInput(usage) {
+    return numberAt(usage, 'cached_input_tokens') || numberAt(usage, 'cache_read_input_tokens');
+}
+/** Whole-session token spend (prompt + completion, cached counted once). */
+function codexUsageTotal(usage) {
+    const base = numberAt(usage, 'input_tokens') + numberAt(usage, 'output_tokens');
+    return codexCachedIsIncluded(usage) ? base : base + codexCachedInput(usage);
+}
+/** Context-window occupancy: the prompt side of the most recent request only. */
+function codexUsageContext(usage) {
+    const input = numberAt(usage, 'input_tokens');
+    return codexCachedIsIncluded(usage) ? input : input + codexCachedInput(usage);
+}
 export function parseCodexRollout(raw) {
     let sessionId;
     let cwd;
@@ -204,6 +280,7 @@ export function parseCodexRollout(raw) {
     let totalTokens = 0;
     let lastContextTokens = 0;
     let contextWindow = 0;
+    let isSubagent = false;
     // A turn is in flight from task_started/user_message until task_complete/
     // turn_aborted. Mid-turn events (agent_message, function_call) must NOT end
     // it: most of a working turn is the thinking gap between a tool result and
@@ -223,6 +300,8 @@ export function parseCodexRollout(raw) {
             sessionId = stringAt(payload, 'id') ?? sessionId;
             cwd = stringAt(payload, 'cwd') ?? cwd;
             startedAt = timestampMs(stringAt(payload, 'timestamp')) ?? startedAt;
+            const source = payload.source;
+            isSubagent = isSubagent || (isRecord(source) && 'subagent' in source);
         }
         else if (type === 'event_msg') {
             const payload = objectAt(value, 'payload');
@@ -262,18 +341,11 @@ export function parseCodexRollout(raw) {
                     if (!info)
                         break;
                     const total = objectAt(info, 'total_token_usage');
-                    if (total) {
-                        totalTokens =
-                            numberAt(total, 'input_tokens') +
-                                numberAt(total, 'output_tokens') +
-                                (numberAt(total, 'cached_input_tokens') || numberAt(total, 'cache_read_input_tokens'));
-                    }
+                    if (total)
+                        totalTokens = codexUsageTotal(total);
                     const last = objectAt(info, 'last_token_usage');
-                    if (last) {
-                        lastContextTokens =
-                            numberAt(last, 'input_tokens') +
-                                (numberAt(last, 'cached_input_tokens') || numberAt(last, 'cache_read_input_tokens'));
-                    }
+                    if (last)
+                        lastContextTokens = codexUsageContext(last);
                     contextWindow = numberAt(info, 'model_context_window') || contextWindow;
                     break;
                 }
@@ -317,6 +389,7 @@ export function parseCodexRollout(raw) {
     const state = turnActive || pendingCalls.size > 0 ? 'processing' : 'idle';
     return {
         hasPendingCalls: pendingCalls.size > 0,
+        isSubagent,
         sessionId,
         cwd,
         startedAt,
@@ -337,6 +410,7 @@ async function collectProcessInfo() {
             encoding: 'utf8',
             timeout: 2_000,
             maxBuffer: 2 * 1024 * 1024,
+            windowsHide: true, // git-bash ps.exe pops a console window every 5s scan on Windows without this
         });
         return parseProcessTable(stdout);
     }
@@ -404,56 +478,88 @@ function collectClaudeSessions(processes) {
     }
     return sessions;
 }
-async function collectCodexSessions(processes) {
+async function collectCodexSessions(processes, rolloutCache) {
+    const codex = processes.filter((p) => isCodexSessionProcessCommand(p.command));
+    const rolloutsByPid = await mapCodexPidsToRollouts(codex.map((p) => p.pid));
+    return collectCodexSessionsFromRollouts(processes, rolloutsByPid, rolloutCache);
+}
+/** Testable async projection from open rollout paths to top-level sessions. */
+export async function collectCodexSessionsFromRollouts(processes, rolloutsByPid, rolloutCache) {
     const byPid = new Map(processes.map((p) => [p.pid, p]));
-    const codex = processes.filter((p) => cmdHasBinary(p.command, 'codex') &&
-        !p.command.includes('app-server') &&
-        !p.command.includes('grep'));
-    const rolloutByPid = await mapCodexPidsToRollouts(codex.map((p) => p.pid));
+    const codex = processes.filter((p) => isCodexSessionProcessCommand(p.command));
+    const activeRollouts = new Set();
+    for (const paths of rolloutsByPid.values()) {
+        for (const path of paths)
+            activeRollouts.add(path);
+    }
+    rolloutCache.retain(activeRollouts);
     const sessions = [];
+    const seen = new Set();
     for (const proc of codex) {
-        const rollout = rolloutByPid.get(proc.pid);
-        if (!rollout)
-            continue;
-        const sample = readFileHeadAndTail(rollout, 256 * 1024, MAX_SAMPLE_BYTES);
-        if (!sample)
-            continue;
-        const parsed = parseCodexRollout(sample);
-        // Ghost backstop: a turn whose end event never made it into the rollout
-        // (killed mid-turn, writer race) would read as processing forever. A live
-        // turn between tool calls writes the rollout every few seconds, so a long
-        // silence with no in-flight tool means the turn is dead. In-flight tools
-        // (pending call) are exempt — a quiet 10-minute build is legitimate.
-        let state = parsed.state;
-        if (state === 'processing' && !parsed.hasPendingCalls && rolloutAgeMs(rollout) > STALE_TURN_MS) {
-            state = 'idle';
+        for (const rollout of rolloutsByPid.get(proc.pid) ?? []) {
+            // Sequential awaits deliberately bound memory/read pressure to one rollout
+            // sample at a time while still yielding the daemon event loop.
+            const snapshot = await rolloutCache.get(rollout);
+            if (!snapshot || snapshot.summary.isSubagent)
+                continue;
+            const parsed = snapshot.summary;
+            let state = parsed.state;
+            if (state === 'processing' && !parsed.hasPendingCalls && Date.now() - snapshot.mtimeMs > STALE_TURN_MS) {
+                state = 'idle';
+            }
+            const sessionId = parsed.sessionId ?? codexRolloutId(rollout);
+            if (seen.has(sessionId))
+                continue;
+            seen.add(sessionId);
+            const cwd = parsed.cwd;
+            const desktop = proc.command.includes('app-server');
+            sessions.push({
+                id: desktop ? `observed:codex-app:${sessionId}` : `observed:codex:${sessionId}`,
+                port: 0,
+                pid: proc.pid,
+                projectName: cwd ? projectNameFromCwd(cwd) : 'Codex',
+                agentType: desktop ? 'codex-app' : 'codex-cli',
+                tty: proc.tty,
+                appName: proc.tty ? undefined : resolveHostApp(proc.pid, byPid),
+                alive: true,
+                state,
+                modelName: parsed.modelName,
+                startedAt: parsed.startedAt ? new Date(parsed.startedAt).toISOString() : new Date().toISOString(),
+                controlMode: 'observed',
+                cwd,
+                currentTask: parsed.currentTask,
+                goal: parsed.goal,
+                contextPercent: parsed.contextPercent,
+                totalTokens: parsed.totalTokens,
+                lastActivityAt: snapshot.mtimeMs,
+            });
         }
-        const sessionId = parsed.sessionId ?? String(proc.pid);
-        const cwd = parsed.cwd;
-        sessions.push({
-            id: `observed:codex:${sessionId}`,
-            port: 0,
-            pid: proc.pid,
-            projectName: cwd ? projectNameFromCwd(cwd) : 'Codex',
-            agentType: 'codex-cli',
-            // Same injection targets as observed Claude: answering or dictating into
-            // a Codex session means typing into the terminal that owns it.
-            tty: proc.tty,
-            appName: proc.tty ? undefined : resolveHostApp(proc.pid, byPid),
-            alive: true,
-            state,
-            modelName: parsed.modelName,
-            startedAt: parsed.startedAt ? new Date(parsed.startedAt).toISOString() : new Date().toISOString(),
-            controlMode: 'observed',
-            cwd,
-            currentTask: parsed.currentTask,
-            goal: parsed.goal,
-            contextPercent: parsed.contextPercent,
-            totalTokens: parsed.totalTokens,
-        });
     }
     return sessions;
 }
+/**
+ * A Codex process that can own a user session.
+ *
+ * `codex app-server` was excluded here originally because it was only ever an
+ * IDE extension's headless backend. The ChatGPT.app Codex desktop app now runs
+ * exactly that command for a real, user-facing session
+ * (`/Applications/ChatGPT.app/Contents/Resources/codex … app-server`), so the
+ * process shape no longer separates the two and the exclusion made every
+ * desktop-app session invisible — no session row, no creature — even though its
+ * lifecycle hooks were landing in the timeline the whole time.
+ *
+ * Admission is settled downstream instead, by whether the pid holds an open
+ * rollout file: an app-server with no conversation holds none and is dropped in
+ * `collectCodexSessions`. The Electron helpers ship a capital-`Codex` basename
+ * (`Codex (Renderer)`), so `cmdHasBinary` already excludes them.
+ */
+export function isCodexSessionProcessCommand(command) {
+    return cmdHasBinary(command, 'codex') && !command.includes('grep');
+}
+/** Fallback session id for a rollout with no parsable `session_meta`. */
+function codexRolloutId(rolloutPath) {
+    return basename(rolloutPath).replace(/^rollout-/, '').replace(/\.jsonl$/, '');
+}
 /**
  * Surface standalone `opencode` processes (not launched via `agentdeck opencode`).
  * Unlike Claude Code / Codex, OpenCode has no lifecycle hooks, so without this a
@@ -565,9 +671,10 @@ async function cwdForPids(pids) {
     }
     return map;
 }
-function dedupeObservedSessions(observed, managedSessions, processes) {
+export function dedupeObservedSessions(observed, managedSessions, processes) {
     const byPid = new Map(processes.map((p) => [p.pid, p]));
     const managedIds = new Set(managedSessions.map((s) => s.id));
+    const managedRawIds = new Set(managedSessions.map((s) => rawSessionId(s.id)));
     const managedPids = managedSessions
         .map((s) => s.pid)
         .filter((pid) => typeof pid === 'number' && pid > 0);
@@ -575,8 +682,13 @@ function dedupeObservedSessions(observed, managedSessions, processes) {
         if (managedIds.has(session.id))
             return false;
         const rawId = rawSessionId(session.id);
-        if (managedIds.has(rawId))
+        if (managedIds.has(rawId) || managedRawIds.has(rawId))
             return false;
+        // One Desktop app-server owns many independent rollouts. A hook-observed
+        // conversation sharing that process must suppress only its matching id,
+        // not every sibling conversation under the same pid.
+        if (session.agentType === 'codex-app')
+            return true;
         return !managedPids.some((pid) => pid === session.pid || isDescendantOf(session.pid, pid, byPid));
     });
 }
@@ -633,6 +745,11 @@ function findClaudeTranscript(configDirs, cwd, sessionId) {
     }
     return null;
 }
+/**
+ * Open rollout files per pid. A terminal `codex` owns exactly one, but a desktop
+ * app-server pid owns one per open conversation — so this is 1:N and every entry
+ * becomes its own session.
+ */
 async function mapCodexPidsToRollouts(pids) {
     if (pids.length === 0)
         return new Map();
@@ -640,13 +757,14 @@ async function mapCodexPidsToRollouts(pids) {
         const map = new Map();
         for (const pid of pids) {
             try {
-                for (const fd of readdirSync(`/proc/${pid}/fd`)) {
-                    const path = readlinkSync(`/proc/${pid}/fd/${fd}`);
-                    if (isCodexRolloutPath(path)) {
-                        map.set(pid, path);
-                        break;
-                    }
+                const paths = new Set();
+                for (const fd of await readdirAsync(`/proc/${pid}/fd`)) {
+                    const path = await readlinkAsync(`/proc/${pid}/fd/${fd}`);
+                    if (isCodexRolloutPath(path))
+                        paths.add(path);
                 }
+                if (paths.size > 0)
+                    map.set(pid, [...paths]);
             }
             catch {
                 // /proc permission/race failures are normal.
@@ -676,20 +794,17 @@ export function parseLsofRollouts(output) {
         }
         else if (line.startsWith('n') && currentPid != null) {
             const path = line.slice(1);
-            if (isCodexRolloutPath(path))
-                map.set(currentPid, path);
+            if (!isCodexRolloutPath(path))
+                continue;
+            const paths = map.get(currentPid) ?? [];
+            // The same rollout can appear twice (dup'd fd); one session per file.
+            if (!paths.includes(path))
+                paths.push(path);
+            map.set(currentPid, paths);
         }
     }
     return map;
 }
-function rolloutAgeMs(path) {
-    try {
-        return Date.now() - statSync(path).mtimeMs;
-    }
-    catch {
-        return 0;
-    }
-}
 /** Epoch-ms of a file's last write, or undefined if it can't be stat'd. */
 function fileMtimeMs(path) {
     try {
@@ -725,6 +840,27 @@ function readFileHeadAndTail(path, headBytes, tailBytes) {
             closeSync(fd);
     }
 }
+async function readFileHeadAndTailAsync(path, headBytes, tailBytes) {
+    const file = await openAsync(path, 'r');
+    try {
+        const { size } = await file.stat();
+        if (size <= headBytes + tailBytes) {
+            const buffer = Buffer.alloc(size);
+            await file.read(buffer, 0, size, 0);
+            return buffer.toString('utf8');
+        }
+        const head = Buffer.alloc(headBytes);
+        await file.read(head, 0, headBytes, 0);
+        const tail = Buffer.alloc(tailBytes);
+        await file.read(tail, 0, tailBytes, size - tailBytes);
+        const tailText = tail.toString('utf8');
+        const firstNewline = tailText.indexOf('\n');
+        return `${head.toString('utf8')}\n${firstNewline >= 0 ? tailText.slice(firstNewline + 1) : ''}`;
+    }
+    finally {
+        await file.close();
+    }
+}
 function parseJsonl(raw) {
     const values = [];
     for (const line of raw.split('\n')) {