nterminal 1.2.80 → 1.2.81

package/dist/server/terminal/subagentSources.js

@@ -0,0 +1,801 @@
+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';
+const LIST_CACHE_TTL_MS = 4_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;
+const listCache = new TtlCache();
+const listInflight = new KeyedSingleFlight();
+const transcriptPathCache = new TtlCache();
+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();
+}
+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 () => {
+        let records;
+        try {
+            records = source.provider === 'claude'
+                ? await listClaudeSubagents(source, options)
+                : await listCodexSubagents(source, options);
+        }
+        catch {
+            records = [];
+        }
+        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.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 };
+    transcriptPathCache.set(key, child, TRANSCRIPT_PATH_CACHE_TTL_MS);
+    return child;
+}
+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 ?? '');
+}
+// --- Claude parents ---
+async function listClaudeSubagents(source, options) {
+    const [native, cross] = await Promise.all([
+        listClaudeNativeSubagents(source, options).catch(() => []),
+        listClaudeCrossCodexSubagents(source, options).catch(() => [])
+    ]);
+    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 {
+        return [];
+    }
+    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,
+            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
+    };
+}
+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,
+            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).catch(() => []),
+        listCodexSubagentsFromRollout(source, options).catch(() => [])
+    ]);
+    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,
+            description: truncateDescription(row.firstUserMessage || null),
+            model: row.model || null,
+            spawnDepth: row.depth,
+            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, depth, status) AS (',
+        `  SELECT child_thread_id, 1, status FROM thread_spawn_edges WHERE parent_thread_id = ${sqlString(threadId)}`,
+        '  UNION ALL',
+        '  SELECT e.child_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.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 < 10) {
+        return null;
+    }
+    const [id, 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,
+        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),
+            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