nterminal 1.2.80 → 1.2.82

package/dist/server/terminal/subagentSources.js

@@ -0,0 +1,1072 @@
+import { open as openFile, readFile, readdir, stat } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { StringDecoder } from 'node:string_decoder';
+import { AgentTranscriptTracker } from './agentTranscriptStatus.js';
+import { KeyedSingleFlight, mapWithConcurrency, runCommand } from './asyncCommand.js';
+import { sqlString } from './codexTranscriptSource.js';
+import { isSessionId, sessionIdPatternSource } from './sessionId.js';
+import { TtlCache } from './ttlCache.js';
+import { encodeClaudeProjectPath, findTranscriptFilesAsync } from './TmuxPtyAdapter.js';
+// The dialog polls every five seconds. Keep a small overlap so a poll that
+// lands on schedule can reuse the prior discovery instead of spawning sqlite
+// and re-statting every child on every tick.
+const LIST_CACHE_TTL_MS = 7_000;
+const LIST_LIMIT = 100;
+// A transcript that claims "working" but has not been written for this long
+// is treated as unknown: a killed CLI never appends its terminal record.
+const WORKING_STALE_MS = 10 * 60_000;
+const DESCRIPTION_LIMIT = 240;
+const STATUS_KEY_LIMIT = 256;
+const SCAN_STATE_LIMIT = 16;
+const SCAN_CHUNK_BYTES = 1024 * 1024;
+// The cross-id pattern is under 60 chars, so this overlap can never split it.
+const CROSS_SCAN_CARRY_CHARS = 160;
+// First scan of a Claude parent starts this far from the end. Banner records
+// older than this predate anything worth listing, and an uncapped scan of a
+// multi-hundred-MB transcript would sit on the request path.
+const CROSS_SCAN_INITIAL_TAIL_BYTES = 64 * 1024 * 1024;
+// First scan of a codex parent starts this far from the end; spawn events
+// deeper in the rollout than this predate anything worth listing live.
+const CODEX_SCAN_INITIAL_TAIL_BYTES = 16 * 1024 * 1024;
+const CODEX_SCAN_MAX_LINE_CHARS = 512 * 1024;
+const SESSION_META_SCAN_BYTES = 256 * 1024;
+const CROSS_VERIFY_POSITIVE_TTL_MS = 10 * 60_000;
+const CROSS_VERIFY_NEGATIVE_TTL_MS = 30_000;
+const SQLITE_TIMEOUT_MS = 1_000;
+// A child's transcript path never changes once created, so paging can skip
+// full rediscovery for far longer than the status-freshness list cache.
+const TRANSCRIPT_PATH_CACHE_TTL_MS = 10 * 60_000;
+// Codex copies the forked prefix in one burst, then the child works in real
+// time, so the seam is the first pause in an otherwise continuous timeline.
+// Measured across teammate rollouts: consecutive copied records are at most
+// 1ms apart, the copy takes ~0.7-0.9s, and the pause before the child's first
+// record is 94-117ms. The gap threshold sits between those two, and the probe
+// step stays below it so a step can never jump over the seam.
+const FORK_SEAM_GAP_MS = 50;
+const FORK_SEAM_STEP_MS = 40;
+// The step walks the burst at 40ms a time; the cap only exists so a rollout
+// with an unexpected shape cannot spin.
+const FORK_SEAM_MAX_ATTEMPTS = 256;
+const FORK_PREVIOUS_RECORD_LOOKBACK_BYTES = 1024 * 1024;
+const FORK_PROBE_BYTES = 64 * 1024;
+const listCache = new TtlCache();
+const listInflight = new KeyedSingleFlight();
+const transcriptPathCache = new TtlCache();
+const forkBoundaryCache = new Map();
+const FORK_BOUNDARY_CACHE_LIMIT = 64;
+const crossVerificationCache = new TtlCache();
+const statusTracker = new AgentTranscriptTracker();
+const statusKeys = new Set();
+const crossScanStates = new Map();
+const codexScanStates = new Map();
+export function clearSubagentCaches() {
+    listCache.clear();
+    listInflight.clear();
+    transcriptPathCache.clear();
+    crossVerificationCache.clear();
+    for (const key of statusKeys) {
+        statusTracker.reset(key);
+    }
+    statusKeys.clear();
+    crossScanStates.clear();
+    codexScanStates.clear();
+    ancestorIdCache.clear();
+    forkBoundaryCache.clear();
+}
+export function subagentSummary(record) {
+    const { filePath: _filePath, ...summary } = record;
+    return summary;
+}
+export async function listTerminalSubagents(source, options = {}) {
+    const key = `${source.provider}\0${source.sessionId}\0${source.filePath}`;
+    const cached = listCache.get(key);
+    if (cached) {
+        return cached.value;
+    }
+    return listInflight.run(key, async () => {
+        const records = source.provider === 'claude'
+            ? await listClaudeSubagents(source, options)
+            : await listCodexSubagents(source, options);
+        records.sort(compareSubagents);
+        if (records.length > LIST_LIMIT) {
+            records.length = LIST_LIMIT;
+        }
+        listCache.set(key, records, LIST_CACHE_TTL_MS);
+        return records;
+    });
+}
+// Resolve one child's transcript source for paging without re-running full
+// discovery on every page request. Falls back to the listing on a cache miss
+// and invalidates when the cached file disappeared.
+export async function resolveSubagentTranscriptSource(source, subagentId, options = {}) {
+    const key = `${source.provider}\0${source.sessionId}\0${source.filePath}\0${subagentId}`;
+    const cached = transcriptPathCache.get(key);
+    if (cached) {
+        try {
+            await stat(cached.value.source.filePath);
+            return cached.value;
+        }
+        catch {
+            transcriptPathCache.delete(key);
+        }
+    }
+    const records = await listTerminalSubagents(source, options);
+    const record = records.find((candidate) => candidate.id === subagentId);
+    if (!record?.filePath) {
+        return null;
+    }
+    const child = { provider: record.provider, sessionId: record.id, filePath: record.filePath };
+    const boundary = record.provider === 'codex'
+        ? await resolveCodexForkBoundary(child.filePath, child.sessionId)
+        : { offset: 0, settled: true };
+    const target = { source: child, startOffset: boundary.offset };
+    // An unsettled boundary belongs to a teammate that has not written past its
+    // fork burst yet; hold it only briefly so the seam is picked up as soon as
+    // the child starts working.
+    transcriptPathCache.set(key, target, boundary.settled ? TRANSCRIPT_PATH_CACHE_TTL_MS : LIST_CACHE_TTL_MS);
+    return target;
+}
+// Codex teammates start life as a fork: the rollout opens with a verbatim
+// copy of the parent thread, written in one burst stamped at fork time, and
+// only then records the child's own turns. Locating that seam lets the viewer
+// show the child's conversation instead of its inherited history.
+export async function resolveCodexForkBoundaryOffset(filePath, threadId) {
+    return (await resolveCodexForkBoundary(filePath, threadId)).offset;
+}
+async function resolveCodexForkBoundary(filePath, threadId) {
+    let fileStat;
+    try {
+        fileStat = await stat(filePath);
+    }
+    catch {
+        return { offset: 0, settled: false };
+    }
+    const cached = forkBoundaryCache.get(filePath);
+    if (cached && cached.dev === fileStat.dev && cached.ino === fileStat.ino) {
+        return { offset: cached.offset, settled: true };
+    }
+    let handle;
+    let offset = 0;
+    try {
+        handle = await openFile(filePath, 'r');
+        const forkedAtMs = await readCodexForkTimestampMs(handle, threadId);
+        if (forkedAtMs === null) {
+            // Not a fork: the whole rollout belongs to this thread, and that stays
+            // true for the life of the file.
+            rememberForkBoundary(filePath, { dev: fileStat.dev, ino: fileStat.ino, offset: 0 });
+            return { offset: 0, settled: true };
+        }
+        const seam = await findForkSeamAsync(handle, fileStat.size, forkedAtMs);
+        if (seam === null) {
+            // The child has not written past its fork burst yet. Showing inherited
+            // history for now beats caching a zero that would outlive the reason
+            // for it — the next request re-resolves.
+            return { offset: 0, settled: false };
+        }
+        offset = seam;
+        rememberForkBoundary(filePath, { dev: fileStat.dev, ino: fileStat.ino, offset });
+    }
+    catch {
+        return { offset: 0, settled: false };
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+    return { offset, settled: true };
+}
+// Steps the probe threshold forward until the record it lands on is separated
+// from its predecessor by a real pause. Inside the copied prefix consecutive
+// records are microseconds apart, so only the seam clears the gap.
+async function findForkSeamAsync(handle, fileSize, forkedAtMs) {
+    let threshold = forkedAtMs + FORK_SEAM_STEP_MS;
+    let searchFrom = 0;
+    let earliestCandidate = null;
+    for (let attempt = 0; attempt < FORK_SEAM_MAX_ATTEMPTS; attempt += 1) {
+        const crossing = await findFirstRecordAfterAsync(handle, fileSize, threshold, searchFrom);
+        if (crossing === null || crossing <= 0) {
+            return earliestCandidate;
+        }
+        if (earliestCandidate === null) {
+            earliestCandidate = crossing;
+        }
+        const crossingTimestampMs = (await readRecordTimestampAtAsync(handle, crossing, fileSize))?.timestampMs ?? null;
+        const previousTimestampMs = await readPreviousRecordTimestampMsAsync(handle, crossing);
+        if (crossingTimestampMs === null || previousTimestampMs === null) {
+            return crossing;
+        }
+        if (crossingTimestampMs - previousTimestampMs >= FORK_SEAM_GAP_MS) {
+            return crossing;
+        }
+        // Still inside the copied prefix. The record just tested is a floor for
+        // the next search, so the scanned range shrinks with every step.
+        threshold = crossingTimestampMs + FORK_SEAM_STEP_MS;
+        searchFrom = crossing;
+    }
+    // Out of attempts: fall back to the earliest cut, which can only leave some
+    // inherited history visible rather than hiding the child's own turns.
+    return earliestCandidate;
+}
+async function readPreviousRecordTimestampMsAsync(handle, offset) {
+    const start = Math.max(0, offset - FORK_PREVIOUS_RECORD_LOOKBACK_BYTES);
+    if (offset <= start) {
+        return null;
+    }
+    const buffer = await readBufferAsync(handle, start, offset - start);
+    if (!buffer || buffer.length < 2) {
+        return null;
+    }
+    // `offset` is a record start, so the final byte here closes the record
+    // before it.
+    const previousEnd = buffer[buffer.length - 1] === 0x0a ? buffer.length - 1 : buffer.length;
+    const previousStart = buffer.lastIndexOf(0x0a, previousEnd - 1) + 1;
+    if (previousStart <= 0 && start !== 0) {
+        return null;
+    }
+    return recordTimestampMs(buffer.subarray(previousStart, previousEnd));
+}
+function rememberForkBoundary(filePath, entry) {
+    forkBoundaryCache.delete(filePath);
+    forkBoundaryCache.set(filePath, entry);
+    while (forkBoundaryCache.size > FORK_BOUNDARY_CACHE_LIMIT) {
+        const oldest = forkBoundaryCache.keys().next().value;
+        if (typeof oldest !== 'string' || oldest === filePath) {
+            break;
+        }
+        forkBoundaryCache.delete(oldest);
+    }
+}
+// Returns null for a thread that was not forked, so its whole rollout shows.
+async function readCodexForkTimestampMs(handle, threadId) {
+    const buffer = Buffer.alloc(SESSION_META_SCAN_BYTES);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    for (const line of buffer.subarray(0, bytesRead).toString('utf8').split('\n')) {
+        if (!line.includes('"session_meta"')) {
+            continue;
+        }
+        const record = parseJsonLine(line);
+        const payload = readRecord(record?.payload);
+        if (!payload || payload.id !== threadId) {
+            continue;
+        }
+        if (!readNonEmptyString(payload.forked_from_id)) {
+            return null;
+        }
+        const timestamp = Date.parse(readNonEmptyString(record?.timestamp) ?? readNonEmptyString(payload.timestamp) ?? '');
+        return Number.isFinite(timestamp) ? timestamp : null;
+    }
+    return null;
+}
+// Binary search by byte offset: the rollout is append-ordered, so record
+// timestamps are non-decreasing and the first record past the fork window can
+// be found without reading the (often hundreds of MB) inherited prefix.
+// All arithmetic stays on raw bytes — decoding a window that starts or ends
+// mid-character would shift every offset derived from it.
+async function findFirstRecordAfterAsync(handle, fileSize, thresholdMs, fromOffset = 0) {
+    let low = fromOffset;
+    let high = fileSize;
+    // Remembered because a probe reports the first record at or after `middle`,
+    // which may itself be the crossing — the window below `middle` would then
+    // no longer contain it.
+    let candidate = null;
+    while (high - low > FORK_PROBE_BYTES) {
+        const middle = low + Math.floor((high - low) / 2);
+        const probe = await readRecordTimestampAtAsync(handle, middle, fileSize);
+        if (probe !== null && probe.timestampMs <= thresholdMs) {
+            // Both branches move past `middle`, so a multi-megabyte record that
+            // makes every probe in a range report the same offset cannot stall the
+            // search.
+            low = Math.min(Math.max(probe.startOffset + 1, middle + 1), high);
+            continue;
+        }
+        // A probe that cannot be read (a record larger than the largest window)
+        // searches earlier: cutting early only leaks a little inherited history,
+        // while cutting late would hide the child's own conversation.
+        if (probe !== null) {
+            candidate = probe.startOffset;
+        }
+        high = middle;
+    }
+    const buffer = await readBufferAsync(handle, low, Math.min(FORK_PROBE_BYTES * 2, fileSize - low));
+    if (!buffer) {
+        return candidate;
+    }
+    let cursor = low === 0 ? 0 : buffer.indexOf(0x0a) + 1;
+    while (cursor > 0 || low === 0) {
+        if (cursor >= buffer.length) {
+            break;
+        }
+        const end = buffer.indexOf(0x0a, cursor);
+        const timestampMs = recordTimestampMs(buffer.subarray(cursor, end === -1 ? buffer.length : end));
+        if (timestampMs !== null && timestampMs > thresholdMs) {
+            return low + cursor;
+        }
+        if (end === -1) {
+            break;
+        }
+        cursor = end + 1;
+    }
+    return candidate;
+}
+async function readRecordTimestampAtAsync(handle, offset, fileSize) {
+    // Grow the probe when a single record is larger than the window; rollouts
+    // routinely carry multi-megabyte tool outputs.
+    for (const size of [FORK_PROBE_BYTES, FORK_PROBE_BYTES * 16, FORK_PROBE_BYTES * 64]) {
+        const buffer = await readBufferAsync(handle, offset, Math.min(size, fileSize - offset));
+        if (!buffer) {
+            return null;
+        }
+        const newlineIndex = offset === 0 ? -1 : buffer.indexOf(0x0a);
+        if (offset !== 0 && newlineIndex === -1) {
+            if (buffer.length < size) {
+                return null;
+            }
+            continue;
+        }
+        const lineStart = newlineIndex + 1;
+        const end = buffer.indexOf(0x0a, lineStart);
+        const timestampMs = recordTimestampMs(buffer.subarray(lineStart, end === -1 ? buffer.length : end));
+        if (timestampMs === null) {
+            if (end === -1 && buffer.length === size) {
+                continue;
+            }
+            return null;
+        }
+        return { startOffset: offset + lineStart, timestampMs };
+    }
+    return null;
+}
+function recordTimestampMs(line) {
+    if (line.length === 0) {
+        return null;
+    }
+    const record = parseJsonLine(line.toString('utf8'));
+    const timestamp = Date.parse(readNonEmptyString(record?.timestamp) ?? '');
+    return Number.isFinite(timestamp) ? timestamp : null;
+}
+async function readBufferAsync(handle, offset, length) {
+    if (length <= 0) {
+        return null;
+    }
+    const buffer = Buffer.alloc(length);
+    let total = 0;
+    while (total < length) {
+        const { bytesRead } = await handle.read(buffer, total, length - total, offset + total);
+        if (bytesRead === 0) {
+            break;
+        }
+        total += bytesRead;
+    }
+    return total > 0 ? buffer.subarray(0, total) : null;
+}
+function compareSubagents(a, b) {
+    const aWorking = a.state === 'working' ? 0 : 1;
+    const bWorking = b.state === 'working' ? 0 : 1;
+    if (aWorking !== bWorking) {
+        return aWorking - bWorking;
+    }
+    // ISO-8601 sorts lexicographically; unknown timestamps sink to the bottom.
+    return (b.updatedAt ?? '').localeCompare(a.updatedAt ?? '');
+}
+function isMissingPathError(error) {
+    return typeof error === 'object' && error !== null &&
+        'code' in error && error.code === 'ENOENT';
+}
+// --- Claude parents ---
+async function listClaudeSubagents(source, options) {
+    const [native, cross] = await Promise.all([
+        listClaudeNativeSubagents(source, options),
+        listClaudeCrossCodexSubagents(source, options)
+    ]);
+    return [...native, ...cross];
+}
+async function listClaudeNativeSubagents(source, options) {
+    const subagentsDir = path.join(path.dirname(source.filePath), source.sessionId, 'subagents');
+    let entries;
+    try {
+        entries = await readdir(subagentsDir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (isMissingPathError(error)) {
+            return [];
+        }
+        throw error;
+    }
+    const transcripts = [];
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        const match = /^agent-([A-Za-z0-9_-]+)\.jsonl$/.exec(entry.name);
+        if (match) {
+            transcripts.push({ agentId: match[1], fileName: entry.name });
+        }
+    }
+    const records = await mapWithConcurrency(transcripts, 4, async ({ agentId, fileName }) => {
+        const filePath = path.join(subagentsDir, fileName);
+        let fileStat;
+        try {
+            fileStat = await stat(filePath);
+        }
+        catch {
+            return null;
+        }
+        const meta = await readClaudeSubagentMeta(path.join(subagentsDir, `agent-${agentId}.meta.json`));
+        const state = await readSubagentState({ provider: 'claude', sessionId: agentId, filePath }, fileStat.mtimeMs, options);
+        const record = {
+            id: agentId,
+            provider: 'claude',
+            kind: 'native',
+            name: meta?.agentType ?? 'subagent',
+            description: truncateDescription(meta?.description ?? null),
+            model: null,
+            spawnDepth: meta?.spawnDepth ?? 1,
+            parentId: meta?.parentAgentId ?? null,
+            state,
+            updatedAt: new Date(fileStat.mtimeMs).toISOString(),
+            hasTranscript: true,
+            filePath
+        };
+        return record;
+    });
+    return records.filter((record) => record !== null);
+}
+async function readClaudeSubagentMeta(metaPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(metaPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+    const record = readRecord(parsed);
+    if (!record) {
+        return null;
+    }
+    const spawnDepth = typeof record.spawnDepth === 'number' && Number.isInteger(record.spawnDepth) && record.spawnDepth > 0
+        ? record.spawnDepth
+        : null;
+    return {
+        agentType: readNonEmptyString(record.agentType),
+        description: readNonEmptyString(record.description),
+        spawnDepth,
+        parentAgentId: readNonEmptyString(record.parentAgentId)
+    };
+}
+async function listClaudeCrossCodexSubagents(source, options) {
+    const ids = await collectCrossSessionIds(source.filePath);
+    if (ids.size === 0) {
+        return [];
+    }
+    const candidates = (await mapWithConcurrency([...ids], 4, (threadId) => verifyCrossCandidate(threadId, source, options))).filter((candidate) => candidate !== null);
+    if (candidates.length === 0) {
+        return [];
+    }
+    const details = await readCodexThreadDetails(candidates.map((candidate) => candidate.threadId), options);
+    const records = await mapWithConcurrency(candidates, 4, async (candidate) => {
+        let fileStat;
+        try {
+            fileStat = await stat(candidate.filePath);
+        }
+        catch {
+            return null;
+        }
+        const state = await readSubagentState({ provider: 'codex', sessionId: candidate.threadId, filePath: candidate.filePath }, fileStat.mtimeMs, options);
+        const detail = details.get(candidate.threadId);
+        const record = {
+            id: candidate.threadId,
+            provider: 'codex',
+            kind: 'cross',
+            name: 'codex exec',
+            description: truncateDescription(detail?.firstUserMessage ?? null),
+            model: detail?.model ?? null,
+            spawnDepth: 1,
+            parentId: null,
+            state,
+            updatedAt: new Date(fileStat.mtimeMs).toISOString(),
+            hasTranscript: true,
+            filePath: candidate.filePath
+        };
+        return record;
+    });
+    return records.filter((record) => record !== null);
+}
+async function collectCrossSessionIds(parentFilePath) {
+    let fileStat;
+    try {
+        fileStat = await stat(parentFilePath);
+    }
+    catch {
+        return new Set();
+    }
+    let state = crossScanStates.get(parentFilePath);
+    if (!state || state.dev !== fileStat.dev || state.ino !== fileStat.ino || fileStat.size < state.offset) {
+        state = {
+            dev: fileStat.dev,
+            ino: fileStat.ino,
+            // The substring scan tolerates a mid-line start; the carry only needs
+            // to cover pattern-splitting at chunk boundaries.
+            offset: Math.max(0, fileStat.size - CROSS_SCAN_INITIAL_TAIL_BYTES),
+            carry: '',
+            decoder: new StringDecoder('utf8'),
+            ids: new Set()
+        };
+    }
+    touchScanState(crossScanStates, parentFilePath, state);
+    if (state.offset >= fileStat.size) {
+        return state.ids;
+    }
+    const pattern = new RegExp(`(?:session|thread) id: (${sessionIdPatternSource})`, 'g');
+    const handle = await openFile(parentFilePath, 'r');
+    try {
+        const buffer = Buffer.alloc(SCAN_CHUNK_BYTES);
+        while (state.offset < fileStat.size) {
+            const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, fileStat.size - state.offset), state.offset);
+            if (bytesRead === 0) {
+                break;
+            }
+            state.offset += bytesRead;
+            const text = state.carry + state.decoder.write(buffer.subarray(0, bytesRead));
+            for (const match of text.matchAll(pattern)) {
+                state.ids.add(match[1].toLowerCase());
+            }
+            state.carry = text.slice(-CROSS_SCAN_CARRY_CHARS);
+            await yieldToEventLoop();
+        }
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+    }
+    return state.ids;
+}
+async function verifyCrossCandidate(threadId, source, options) {
+    if (!isSessionId(threadId) || threadId === source.sessionId) {
+        return null;
+    }
+    const sessionsRoot = path.join(options.homeDir ?? os.homedir(), '.codex', 'sessions');
+    const parentProjectDir = path.basename(path.dirname(source.filePath));
+    const cacheKey = `${sessionsRoot}\0${threadId}\0${parentProjectDir}\0${source.sessionId}`;
+    const cached = crossVerificationCache.get(cacheKey);
+    if (cached) {
+        return cached.value;
+    }
+    const candidate = await verifyCrossCandidateUncached(threadId, source, sessionsRoot, parentProjectDir);
+    crossVerificationCache.set(cacheKey, candidate, candidate ? CROSS_VERIFY_POSITIVE_TTL_MS : CROSS_VERIFY_NEGATIVE_TTL_MS);
+    return candidate;
+}
+async function verifyCrossCandidateUncached(threadId, source, sessionsRoot, parentProjectDir) {
+    const matches = await findTranscriptFilesAsync('codex', threadId, sessionsRoot);
+    if (matches.length !== 1) {
+        return null;
+    }
+    const filePath = matches[0];
+    const meta = await readCodexSessionMeta(filePath, threadId);
+    // Only non-interactive `codex exec` rollouts qualify: an interactive codex
+    // session in the same project whose banner got quoted into the Claude
+    // conversation must not surface as a subagent of it.
+    if (!meta || meta.source !== 'exec' || !meta.cwd) {
+        return null;
+    }
+    const belongsToParent = encodeClaudeProjectPath(meta.cwd) === parentProjectDir || meta.cwd.includes(source.sessionId);
+    return belongsToParent ? { threadId, filePath } : null;
+}
+async function readCodexSessionMeta(filePath, threadId) {
+    let handle;
+    try {
+        handle = await openFile(filePath, 'r');
+        const buffer = Buffer.alloc(SESSION_META_SCAN_BYTES);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        const lines = buffer.subarray(0, bytesRead).toString('utf8').split('\n');
+        for (const line of lines) {
+            // Forked rollouts replay ancestor session_meta records; only the one
+            // whose id matches the filename thread describes this rollout.
+            if (!line.includes('"session_meta"')) {
+                continue;
+            }
+            const record = parseJsonLine(line);
+            const payload = readRecord(record?.payload);
+            if (!payload || payload.id !== threadId) {
+                continue;
+            }
+            return {
+                cwd: readNonEmptyString(payload.cwd),
+                source: typeof payload.source === 'string' ? payload.source : null
+            };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+// --- Codex parents ---
+async function listCodexSubagents(source, options) {
+    const [fromDb, fromRollout] = await Promise.all([
+        listCodexSubagentsFromStateDb(source, options),
+        listCodexSubagentsFromRollout(source, options)
+    ]);
+    const byId = new Map();
+    // DB rows carry richer metadata (nickname, model, prompt), but when the
+    // DB's rollout_path went stale the rollout scan may still have located the
+    // real transcript — keep that file and its snapshot-derived state.
+    for (const record of fromRollout) {
+        byId.set(record.id, record);
+    }
+    for (const record of fromDb) {
+        const fromScan = byId.get(record.id);
+        if (fromScan?.hasTranscript && !record.hasTranscript) {
+            byId.set(record.id, {
+                ...record,
+                filePath: fromScan.filePath,
+                hasTranscript: true,
+                state: fromScan.state !== 'unknown' ? fromScan.state : record.state,
+                updatedAt: fromScan.updatedAt ?? record.updatedAt
+            });
+        }
+        else {
+            byId.set(record.id, record);
+        }
+    }
+    return [...byId.values()];
+}
+async function listCodexSubagentsFromStateDb(source, options) {
+    const output = await runStateDbQuery(codexDescendantsSql(source.sessionId), options);
+    if (output === null) {
+        return [];
+    }
+    const rows = [];
+    for (const line of output.split('\n')) {
+        const row = parseCodexThreadRow(line);
+        if (row && row.id !== source.sessionId) {
+            rows.push(row);
+        }
+    }
+    const records = await mapWithConcurrency(rows, 4, async (row) => {
+        let fileStat = null;
+        if (row.rolloutPath) {
+            try {
+                fileStat = await stat(row.rolloutPath);
+            }
+            catch {
+                fileStat = null;
+            }
+        }
+        let state;
+        if (fileStat) {
+            state = await readSubagentState({ provider: 'codex', sessionId: row.id, filePath: row.rolloutPath }, fileStat.mtimeMs, options);
+        }
+        else {
+            state = 'unknown';
+        }
+        if (row.edgeStatus === 'closed' && (state === 'working' || state === 'unknown')) {
+            // The spawn edge closing is the parent-side signal that this child's
+            // run ended even when its rollout tail never recorded task_complete.
+            state = 'done';
+        }
+        const name = row.nickname || leafAgentPathSegment(row.agentPath) || 'agent';
+        const record = {
+            id: row.id,
+            provider: 'codex',
+            kind: 'native',
+            name: row.role ? `${name} (${row.role})` : name,
+            // first_user_message on a teammate row is the parent prompt it forked
+            // with, which the transcript no longer shows — describing the row by its
+            // place in the agent tree keeps the list and the conversation in sync.
+            description: truncateDescription(row.agentPath || row.firstUserMessage || null),
+            model: row.model || null,
+            spawnDepth: row.depth,
+            // A direct child's parent is the pane session itself, which is not a
+            // row in this list — report it as top level.
+            parentId: row.parentId && row.parentId !== source.sessionId ? row.parentId : null,
+            state,
+            updatedAt: fileStat
+                ? new Date(fileStat.mtimeMs).toISOString()
+                : row.updatedAtMs > 0
+                    ? new Date(row.updatedAtMs).toISOString()
+                    : null,
+            hasTranscript: fileStat !== null,
+            filePath: fileStat ? row.rolloutPath : null
+        };
+        return record;
+    });
+    return records;
+}
+function codexDescendantsSql(threadId) {
+    return [
+        'WITH RECURSIVE descendants(id, parent, depth, status) AS (',
+        `  SELECT child_thread_id, parent_thread_id, 1, status FROM thread_spawn_edges WHERE parent_thread_id = ${sqlString(threadId)}`,
+        '  UNION ALL',
+        '  SELECT e.child_thread_id, e.parent_thread_id, d.depth + 1, e.status',
+        '  FROM thread_spawn_edges e JOIN descendants d ON e.parent_thread_id = d.id',
+        '  WHERE d.depth < 6',
+        ')',
+        "SELECT t.id || char(9) || d.parent || char(9) || d.depth || char(9) || d.status || char(9) || COALESCE(t.agent_nickname, '')",
+        "  || char(9) || COALESCE(t.agent_path, '') || char(9) || COALESCE(t.agent_role, '')",
+        "  || char(9) || COALESCE(t.model, '') || char(9) || COALESCE(t.updated_at_ms, t.updated_at * 1000, 0)",
+        `  || char(9) || substr(replace(replace(COALESCE(t.first_user_message, ''), char(9), ' '), char(10), ' '), 1, ${DESCRIPTION_LIMIT})`,
+        "  || char(9) || COALESCE(t.rollout_path, '')",
+        'FROM descendants d JOIN threads t ON t.id = d.id',
+        'LIMIT 200;'
+    ].join('\n');
+}
+function parseCodexThreadRow(line) {
+    // Strip only line terminators: a full trim() would eat the trailing tab
+    // that marks an empty last field (NULL rollout_path) and drop the row.
+    const trimmed = line.replace(/[\r\n]+$/, '');
+    if (!trimmed.trim()) {
+        return null;
+    }
+    const parts = trimmed.split('\t');
+    if (parts.length < 11) {
+        return null;
+    }
+    const [id, parentId, depthRaw, edgeStatus, nickname, agentPath, role, model, updatedRaw, firstUserMessage, ...rolloutParts] = parts;
+    if (!id || !isSessionId(id)) {
+        return null;
+    }
+    const depth = Number(depthRaw);
+    const updatedAtMs = Number(updatedRaw);
+    // Empty when threads.rollout_path was NULL: the child still gets a row
+    // (metadata + edge status), just without an openable transcript.
+    const rolloutPath = rolloutParts.join('\t');
+    return {
+        id,
+        parentId: parentId ?? '',
+        depth: Number.isInteger(depth) && depth > 0 ? depth : 1,
+        edgeStatus: edgeStatus ?? '',
+        nickname: nickname ?? '',
+        agentPath: agentPath ?? '',
+        role: role ?? '',
+        model: model ?? '',
+        updatedAtMs: Number.isFinite(updatedAtMs) ? updatedAtMs : 0,
+        firstUserMessage: firstUserMessage ?? '',
+        rolloutPath
+    };
+}
+async function listCodexSubagentsFromRollout(source, options) {
+    const children = await collectCodexSubagentActivity(source.filePath);
+    if (children.size === 0) {
+        return [];
+    }
+    // sub_agent_activity also references ancestors (e.g. the /root
+    // coordinator) when this thread is itself a subagent — those are not
+    // children of this pane's conversation.
+    const ancestorIds = await readCodexAncestorIds(source.filePath);
+    const sessionsRoot = path.join(options.homeDir ?? os.homedir(), '.codex', 'sessions');
+    const records = await mapWithConcurrency([...children.entries()], 4, async ([threadId, info]) => {
+        if (threadId === source.sessionId || ancestorIds.has(threadId)) {
+            return null;
+        }
+        const matches = await findTranscriptFilesAsync('codex', threadId, sessionsRoot);
+        const filePath = matches.length === 1 ? matches[0] : null;
+        let fileStat = null;
+        if (filePath) {
+            try {
+                fileStat = await stat(filePath);
+            }
+            catch {
+                fileStat = null;
+            }
+        }
+        let state = 'unknown';
+        if (filePath && fileStat) {
+            state = await readSubagentState({ provider: 'codex', sessionId: threadId, filePath }, fileStat.mtimeMs, options);
+        }
+        if (state === 'unknown' && info.lastKind === 'interrupted') {
+            state = 'stopped';
+        }
+        const record = {
+            id: threadId,
+            provider: 'codex',
+            kind: 'native',
+            name: leafAgentPathSegment(info.agentPath) || 'agent',
+            description: info.agentPath ? truncateDescription(info.agentPath) : null,
+            model: null,
+            spawnDepth: agentPathDepth(info.agentPath),
+            // Rollout activity events only name direct children of this thread.
+            parentId: null,
+            state,
+            updatedAt: fileStat ? new Date(fileStat.mtimeMs).toISOString() : null,
+            hasTranscript: filePath !== null && fileStat !== null,
+            filePath: fileStat ? filePath : null
+        };
+        return record;
+    });
+    return records.filter((record) => record !== null);
+}
+const ancestorIdCache = new Map();
+const ANCESTOR_CACHE_LIMIT = 32;
+async function readCodexAncestorIds(filePath) {
+    const ids = new Set();
+    let handle;
+    try {
+        // Ancestor session_meta records are the first lines of the rollout and
+        // never change, so one read per file identity is enough.
+        const fileStat = await stat(filePath);
+        const cached = ancestorIdCache.get(filePath);
+        if (cached && cached.dev === fileStat.dev && cached.ino === fileStat.ino) {
+            return cached.ids;
+        }
+        handle = await openFile(filePath, 'r');
+        const buffer = Buffer.alloc(SESSION_META_SCAN_BYTES);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        for (const line of buffer.subarray(0, bytesRead).toString('utf8').split('\n')) {
+            // Forked/subagent rollouts replay every ancestor's session_meta at the
+            // top, so this single pass yields the whole ancestor chain.
+            if (!line.includes('"session_meta"')) {
+                continue;
+            }
+            const payload = readRecord(parseJsonLine(line)?.payload);
+            if (!payload) {
+                continue;
+            }
+            for (const key of ['id', 'session_id', 'parent_thread_id', 'forked_from_id']) {
+                const value = payload[key];
+                if (typeof value === 'string' && isSessionId(value)) {
+                    ids.add(value.toLowerCase());
+                }
+            }
+        }
+        ancestorIdCache.delete(filePath);
+        ancestorIdCache.set(filePath, { dev: fileStat.dev, ino: fileStat.ino, ids });
+        while (ancestorIdCache.size > ANCESTOR_CACHE_LIMIT) {
+            const oldest = ancestorIdCache.keys().next().value;
+            if (typeof oldest !== 'string' || oldest === filePath) {
+                break;
+            }
+            ancestorIdCache.delete(oldest);
+        }
+    }
+    catch {
+        // Fall through with what we collected; exclusion is best-effort.
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+    return ids;
+}
+async function collectCodexSubagentActivity(parentFilePath) {
+    let fileStat;
+    try {
+        fileStat = await stat(parentFilePath);
+    }
+    catch {
+        return new Map();
+    }
+    let state = codexScanStates.get(parentFilePath);
+    if (!state || state.dev !== fileStat.dev || state.ino !== fileStat.ino || fileStat.size < state.offset) {
+        state = {
+            dev: fileStat.dev,
+            ino: fileStat.ino,
+            offset: Math.max(0, fileStat.size - CODEX_SCAN_INITIAL_TAIL_BYTES),
+            remainder: '',
+            // A tail start lands mid-line; treat everything up to the first
+            // newline as an oversized fragment to discard.
+            skippingOversizedLine: fileStat.size > CODEX_SCAN_INITIAL_TAIL_BYTES,
+            decoder: new StringDecoder('utf8'),
+            children: new Map()
+        };
+    }
+    touchScanState(codexScanStates, parentFilePath, state);
+    if (state.offset >= fileStat.size) {
+        return state.children;
+    }
+    const handle = await openFile(parentFilePath, 'r');
+    try {
+        const buffer = Buffer.alloc(SCAN_CHUNK_BYTES);
+        while (state.offset < fileStat.size) {
+            const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, fileStat.size - state.offset), state.offset);
+            if (bytesRead === 0) {
+                break;
+            }
+            state.offset += bytesRead;
+            consumeCodexScanText(state, state.decoder.write(buffer.subarray(0, bytesRead)));
+            await yieldToEventLoop();
+        }
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+    }
+    return state.children;
+}
+function consumeCodexScanText(state, text) {
+    let cursor = 0;
+    while (cursor < text.length) {
+        const newline = text.indexOf('\n', cursor);
+        const end = newline === -1 ? text.length : newline;
+        const fragment = text.slice(cursor, end);
+        if (state.skippingOversizedLine) {
+            // Discard until the line ends; activity records are always small.
+        }
+        else if (state.remainder.length + fragment.length > CODEX_SCAN_MAX_LINE_CHARS) {
+            state.skippingOversizedLine = true;
+            state.remainder = '';
+        }
+        else {
+            state.remainder += fragment;
+        }
+        if (newline === -1) {
+            break;
+        }
+        if (!state.skippingOversizedLine && state.remainder.includes('"sub_agent_activity"')) {
+            recordCodexSubagentActivityLine(state, state.remainder);
+        }
+        state.remainder = '';
+        state.skippingOversizedLine = false;
+        cursor = newline + 1;
+    }
+}
+function recordCodexSubagentActivityLine(state, line) {
+    const record = parseJsonLine(line);
+    const payload = readRecord(record?.payload);
+    if (!payload || payload.type !== 'sub_agent_activity') {
+        return;
+    }
+    const threadId = typeof payload.agent_thread_id === 'string' ? payload.agent_thread_id.toLowerCase() : '';
+    if (!isSessionId(threadId)) {
+        return;
+    }
+    const existing = state.children.get(threadId) ?? { agentPath: null, lastKind: null };
+    existing.agentPath = readNonEmptyString(payload.agent_path) ?? existing.agentPath;
+    existing.lastKind = readNonEmptyString(payload.kind) ?? existing.lastKind;
+    state.children.set(threadId, existing);
+}
+// --- shared helpers ---
+async function readSubagentState(child, mtimeMs, options) {
+    const key = `subagent\0${child.provider}\0${child.sessionId}\0${child.filePath}`;
+    rememberStatusKey(key);
+    let state;
+    try {
+        state = (await statusTracker.readSnapshot(key, child)).status.state;
+    }
+    catch {
+        return 'unknown';
+    }
+    const now = options.now ?? Date.now();
+    if (state === 'working' && now - mtimeMs > WORKING_STALE_MS) {
+        return 'unknown';
+    }
+    return state;
+}
+function rememberStatusKey(key) {
+    if (statusKeys.has(key)) {
+        statusKeys.delete(key);
+        statusKeys.add(key);
+        return;
+    }
+    statusKeys.add(key);
+    while (statusKeys.size > STATUS_KEY_LIMIT) {
+        const oldest = statusKeys.values().next().value;
+        if (typeof oldest !== 'string') {
+            break;
+        }
+        statusKeys.delete(oldest);
+        statusTracker.reset(oldest);
+    }
+}
+async function readCodexThreadDetails(threadIds, options) {
+    const details = new Map();
+    const validIds = threadIds.filter((threadId) => isSessionId(threadId));
+    if (validIds.length === 0) {
+        return details;
+    }
+    const sql = [
+        "SELECT id || char(9) || COALESCE(model, '')",
+        `  || char(9) || substr(replace(replace(COALESCE(first_user_message, ''), char(9), ' '), char(10), ' '), 1, ${DESCRIPTION_LIMIT})`,
+        `FROM threads WHERE id IN (${validIds.map(sqlString).join(', ')});`
+    ].join('\n');
+    const output = await runStateDbQuery(sql, options);
+    if (output === null) {
+        return details;
+    }
+    for (const line of output.split('\n')) {
+        const trimmed = line.replace(/[\r\n]+$/, '');
+        if (!trimmed.trim())
+            continue;
+        const [id, model, firstUserMessage] = trimmed.split('\t');
+        if (!id || !isSessionId(id))
+            continue;
+        details.set(id, {
+            model: model || null,
+            firstUserMessage: firstUserMessage || null
+        });
+    }
+    return details;
+}
+async function runStateDbQuery(sql, options) {
+    const stateDb = path.join(options.homeDir ?? os.homedir(), '.codex', 'state_5.sqlite');
+    if (options.runSqlite) {
+        return await options.runSqlite(stateDb, sql);
+    }
+    try {
+        await stat(stateDb);
+    }
+    catch {
+        return null;
+    }
+    try {
+        return (await runCommand('sqlite3', ['-batch', '-noheader', stateDb, sql], { timeoutMs: SQLITE_TIMEOUT_MS })).stdout;
+    }
+    catch {
+        return null;
+    }
+}
+function touchScanState(states, key, state) {
+    states.delete(key);
+    states.set(key, state);
+    while (states.size > SCAN_STATE_LIMIT) {
+        const oldest = states.keys().next().value;
+        if (typeof oldest !== 'string' || oldest === key) {
+            break;
+        }
+        states.delete(oldest);
+    }
+}
+function leafAgentPathSegment(agentPath) {
+    if (!agentPath) {
+        return '';
+    }
+    const segments = agentPath.split('/').filter(Boolean);
+    return segments[segments.length - 1] ?? '';
+}
+function agentPathDepth(agentPath) {
+    if (!agentPath) {
+        return 1;
+    }
+    // agent_path is rooted at /root; each further segment is one spawn level.
+    const segments = agentPath.split('/').filter(Boolean);
+    return Math.max(1, segments.length - 1);
+}
+function truncateDescription(value) {
+    if (!value) {
+        return null;
+    }
+    const compact = value.replace(/\s+/g, ' ').trim();
+    if (!compact) {
+        return null;
+    }
+    return compact.length > DESCRIPTION_LIMIT ? `${compact.slice(0, DESCRIPTION_LIMIT - 1)}…` : compact;
+}
+function yieldToEventLoop() {
+    return new Promise((resolve) => setImmediate(resolve));
+}
+function parseJsonLine(line) {
+    if (!line) {
+        return null;
+    }
+    try {
+        return readRecord(JSON.parse(line));
+    }
+    catch {
+        return null;
+    }
+}
+function readRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function readNonEmptyString(value) {
+    return typeof value === 'string' && value.trim() ? value : null;
+}
+//# sourceMappingURL=subagentSources.js.map