@bbigbang/core 0.1.0

package/dist/services/codexTranscriptService.js

@@ -0,0 +1,961 @@
+import { buildAgentSessionSystemPromptText } from '@bbigbang/memory';
+import { log } from '@bbigbang/runtime-acp';
+import { readFileSync } from 'node:fs';
+import { iterateParsedNodeEvents } from '../nodeEventHistory.js';
+const MAX_INLINE_TRANSCRIPT_BYTES = 2 * 1024 * 1024;
+const HEURISTIC_TRANSCRIPT_LOOKBACK_MS = 24 * 60 * 60 * 1000;
+const MAX_SESSION_MATCH_TRANSCRIPT_FILES = 8;
+const MAX_HEURISTIC_TRANSCRIPT_FILES = 6;
+const REDACTED_NOTIFICATION_PROMPT = '[notification delivery payload redacted]';
+export const CODEX_DEBUG_UNSUPPORTED_RUNTIME_ERROR = 'Codex debug is only supported for codex_acp and codex_app_server conversations.';
+export class CodexTranscriptService {
+    rolloutCache = new Map();
+    db;
+    broker;
+    getConversationById;
+    getAgentById;
+    getAcpSessionIdByConversationId;
+    getCodexContextWindowByModel;
+    constructor(params) {
+        this.db = params.db;
+        this.broker = params.broker;
+        this.getConversationById = params.getConversationById;
+        this.getAgentById = params.getAgentById;
+        this.getAcpSessionIdByConversationId = params.getAcpSessionIdByConversationId ?? (() => null);
+        this.getCodexContextWindowByModel = params.getCodexContextWindowByModel ?? defaultGetCodexContextWindowByModel;
+    }
+    async getConversationDebug(conversationId) {
+        const conversation = this.getConversationById(conversationId);
+        if (!conversation)
+            throw new Error('Conversation not found.');
+        if (conversation.agentType !== 'codex_acp' && conversation.agentType !== 'codex_app_server') {
+            throw new Error(CODEX_DEBUG_UNSUPPORTED_RUNTIME_ERROR);
+        }
+        if (!conversation.nodeId)
+            throw new Error('Conversation is not assigned to a remote node.');
+        if (!conversation.workspacePath)
+            throw new Error('Conversation has no workspace path.');
+        const replyTarget = (conversation.replyTarget ?? '').trim();
+        if (!replyTarget)
+            throw new Error('Conversation has no reply target.');
+        const acpSessionId = this.getAcpSessionIdByConversationId(conversationId)?.trim() || undefined;
+        const heuristicTranscriptCutoff = Date.now() - HEURISTIC_TRANSCRIPT_LOOKBACK_MS;
+        const listing = await this.broker.listFiles(conversation.nodeId).catch((error) => {
+            log.warn('[codex-debug] failed to list transcripts', {
+                conversationId,
+                nodeId: conversation.nodeId,
+                error: String(error?.message ?? error),
+            });
+            return {
+                rootPath: '',
+                files: [],
+                truncated: false,
+            };
+        });
+        const exactSessionRollouts = [];
+        const heuristicRollouts = [];
+        const workspaceCandidates = listing.files.filter((file) => {
+            if (!acpSessionId && file.modifiedAt < heuristicTranscriptCutoff) {
+                return false;
+            }
+            if (file.size > MAX_INLINE_TRANSCRIPT_BYTES) {
+                return false;
+            }
+            if (file.cwd && file.cwd.trim() !== conversation.workspacePath) {
+                return false;
+            }
+            return true;
+        });
+        const filesToScan = acpSessionId
+            ? selectTranscriptCandidatesForSession(workspaceCandidates, acpSessionId, heuristicTranscriptCutoff)
+            : workspaceCandidates.slice(0, MAX_HEURISTIC_TRANSCRIPT_FILES);
+        for (const file of filesToScan) {
+            const loaded = await this.loadParsedRollout(conversationId, conversation.nodeId, file);
+            if (loaded.timedOut)
+                break;
+            const parsed = loaded.rollout;
+            if (!parsed)
+                continue;
+            applyCodexContextWindowFallback(parsed, this.getCodexContextWindowByModel);
+            const sessionCwd = parsed.cwd?.trim();
+            if (!sessionCwd || sessionCwd !== conversation.workspacePath)
+                continue;
+            const exactSessionMatch = acpSessionId != null
+                && (parsed.sessionId === acpSessionId || file.path.includes(acpSessionId));
+            let matchedTurns = parsed.turns.filter((turn) => (turn.replyTarget ?? '').trim() === replyTarget);
+            if (matchedTurns.length === 0 && exactSessionMatch) {
+                matchedTurns = parsed.turns.filter((turn) => !(turn.replyTarget ?? '').trim());
+                if (matchedTurns.length === 0) {
+                    matchedTurns = parsed.turns;
+                }
+            }
+            if (matchedTurns.length === 0)
+                continue;
+            const matchedRollout = {
+                ...parsed,
+                turns: matchedTurns,
+            };
+            if (exactSessionMatch) {
+                exactSessionRollouts.push(matchedRollout);
+            }
+            else {
+                heuristicRollouts.push(matchedRollout);
+            }
+        }
+        const sessionMatchMissed = Boolean(acpSessionId) && exactSessionRollouts.length === 0;
+        const usingExactSession = Boolean(acpSessionId) && exactSessionRollouts.length > 0;
+        const rollouts = usingExactSession ? exactSessionRollouts : heuristicRollouts;
+        rollouts.sort((a, b) => {
+            const aTime = getRolloutSortTime(a);
+            const bTime = getRolloutSortTime(b);
+            return usingExactSession ? aTime - bTime : bTime - aTime;
+        });
+        const platformInputs = listPlatformInputsForConversation(this.db, {
+            conversation,
+            getAgentById: this.getAgentById,
+            includePlatformTrace: false,
+            newestFirst: !usingExactSession,
+        });
+        const unmatchedPlatformInputs = attachPlatformInputsToTurns(rollouts, platformInputs);
+        const notificationDeliveries = listNotificationDeliveryEvidenceForConversation(this.db, conversation.id);
+        return {
+            provider: 'codex',
+            conversationId: conversation.id,
+            agentType: conversation.agentType,
+            workspacePath: conversation.workspacePath,
+            replyTarget,
+            acpSessionId,
+            matchMode: usingExactSession ? 'acp_session_id' : 'heuristic',
+            sessionMatchMissed,
+            truncated: listing.truncated,
+            rollouts,
+            unmatchedPlatformInputs,
+            notificationDeliveries,
+        };
+    }
+    async loadParsedRollout(conversationId, nodeId, file) {
+        const cacheKey = `${nodeId}:${file.path}:${file.modifiedAt}:${file.size}`;
+        const cached = this.rolloutCache.get(cacheKey);
+        if (cached) {
+            this.rolloutCache.delete(cacheKey);
+            this.rolloutCache.set(cacheKey, cached);
+            return { rollout: cached, timedOut: false };
+        }
+        let content;
+        try {
+            const result = await this.broker.readFile(nodeId, file.path);
+            content = result.content;
+        }
+        catch (error) {
+            const message = String(error?.message ?? error);
+            log.warn('[codex-debug] failed to read transcript', {
+                conversationId,
+                path: file.path,
+                error: message,
+            });
+            return { rollout: null, timedOut: isTranscriptTimeoutError(message) };
+        }
+        const parsed = parseCodexRollout(content, {
+            path: file.path,
+            modifiedAt: file.modifiedAt,
+            size: file.size,
+        });
+        setCachedRollout(this.rolloutCache, cacheKey, parsed);
+        return { rollout: parsed, timedOut: false };
+    }
+}
+let cachedCodexModelWindows = null;
+function selectTranscriptCandidatesForSession(files, acpSessionId, heuristicCutoffMs) {
+    const exactCandidates = files.filter((file) => file.sessionId === acpSessionId);
+    if (exactCandidates.length > 0)
+        return exactCandidates.slice(0, MAX_SESSION_MATCH_TRANSCRIPT_FILES);
+    const hintedCandidates = files.filter((file) => file.path.includes(acpSessionId));
+    if (hintedCandidates.length > 0)
+        return hintedCandidates.slice(0, MAX_SESSION_MATCH_TRANSCRIPT_FILES);
+    const heuristicCandidates = files.filter((file) => file.modifiedAt >= heuristicCutoffMs);
+    if (heuristicCandidates.length > 0)
+        return heuristicCandidates.slice(0, MAX_HEURISTIC_TRANSCRIPT_FILES);
+    return files.slice(0, MAX_HEURISTIC_TRANSCRIPT_FILES);
+}
+function setCachedRollout(cache, key, rollout, maxEntries = 64) {
+    cache.set(key, rollout);
+    while (cache.size > maxEntries) {
+        const oldestKey = cache.keys().next().value;
+        if (!oldestKey)
+            break;
+        cache.delete(oldestKey);
+    }
+}
+function parseCodexRollout(content, meta) {
+    const lines = content.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    let sessionId;
+    let cwd;
+    let model;
+    let baseInstructions;
+    const preludeDeveloperMessages = [];
+    const preludeUserMessages = [];
+    const turns = [];
+    let currentTurn = null;
+    const functionCallById = new Map();
+    const pushCurrentTurn = () => {
+        if (!currentTurn)
+            return;
+        turns.push(currentTurn);
+        currentTurn = null;
+        functionCallById.clear();
+    };
+    for (const line of lines) {
+        let parsedLine;
+        try {
+            parsedLine = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const timestamp = typeof parsedLine.timestamp === 'string' ? parsedLine.timestamp : new Date(meta.modifiedAt).toISOString();
+        const payload = parsedLine.payload ?? {};
+        if (parsedLine.type === 'session_meta') {
+            sessionId = stringValue(payload.id);
+            cwd = stringValue(payload.cwd);
+            const base = payload.base_instructions;
+            baseInstructions = stringValue(base?.text);
+            continue;
+        }
+        if (parsedLine.type === 'turn_context') {
+            pushCurrentTurn();
+            model = model ?? stringValue(payload.model);
+            currentTurn = {
+                turnId: stringValue(payload.turn_id) ?? `turn-${turns.length + 1}`,
+                timestamp,
+                cwd: stringValue(payload.cwd),
+                inputBlocks: [],
+                functionCalls: [],
+                assistantOutputs: [],
+                reasoningSummaries: [],
+                hasEncryptedReasoning: false,
+            };
+            continue;
+        }
+        if (!currentTurn) {
+            const preludeText = extractMessageText(payload);
+            if (!preludeText)
+                continue;
+            if (payload.type === 'message' && payload.role === 'developer')
+                preludeDeveloperMessages.push(preludeText);
+            if (payload.type === 'message' && payload.role === 'user')
+                preludeUserMessages.push(preludeText);
+            continue;
+        }
+        if (parsedLine.type === 'response_item') {
+            const payloadType = stringValue(payload.type);
+            if (payloadType === 'message') {
+                const role = stringValue(payload.role);
+                const messageText = extractMessageText(payload);
+                if (role === 'user' && messageText) {
+                    currentTurn.inputBlocks.push(...extractInputBlocks(payload));
+                    currentTurn.replyTarget = currentTurn.replyTarget ?? parseReplyTarget(messageText);
+                    currentTurn.triggerTarget = currentTurn.triggerTarget ?? parseTriggerTarget(messageText);
+                }
+                else if (role === 'assistant') {
+                    for (const text of extractAssistantOutputs(payload)) {
+                        currentTurn.assistantOutputs.push({
+                            text,
+                            phase: stringValue(payload.phase) ?? undefined,
+                            timestamp,
+                        });
+                    }
+                }
+            }
+            else if (payloadType === 'function_call') {
+                recordCodexFunctionCall(currentTurn, functionCallById, payload, timestamp);
+            }
+            else if (payloadType === 'tool_search_call') {
+                recordCodexFunctionCall(currentTurn, functionCallById, payload, timestamp, {
+                    fallbackName: 'tool_search',
+                });
+            }
+            else if (payloadType === 'function_call_output' || payloadType === 'tool_search_output') {
+                attachCodexFunctionCallOutput(functionCallById, payload, timestamp, {
+                    fallbackName: payloadType === 'tool_search_output' ? 'tool_search' : 'unknown',
+                });
+            }
+            else if (payloadType === 'reasoning') {
+                const summary = Array.isArray(payload.summary) ? payload.summary.map((item) => {
+                    if (!item || typeof item !== 'object')
+                        return '';
+                    return stringValue(item.text) ?? '';
+                }).filter(Boolean) : [];
+                currentTurn.reasoningSummaries.push(...summary);
+                if (typeof payload.encrypted_content === 'string' && payload.encrypted_content.trim()) {
+                    currentTurn.hasEncryptedReasoning = true;
+                }
+            }
+            continue;
+        }
+        if (parsedLine.type === 'event_msg') {
+            const eventType = stringValue(payload.type);
+            if (eventType === 'user_message') {
+                const combined = stringValue(payload.message);
+                if (combined) {
+                    currentTurn.combinedUserMessage = combined;
+                    currentTurn.replyTarget = currentTurn.replyTarget ?? parseReplyTarget(combined);
+                    currentTurn.triggerTarget = currentTurn.triggerTarget ?? parseTriggerTarget(combined);
+                }
+            }
+            else if (eventType === 'token_count') {
+                currentTurn.tokenUsage = parseTokenUsage(payload);
+            }
+            else if (eventType === 'agent_message') {
+                const message = stringValue(payload.message);
+                if (message) {
+                    currentTurn.assistantOutputs.push({
+                        text: message,
+                        phase: stringValue(payload.phase) ?? undefined,
+                        timestamp,
+                    });
+                }
+            }
+            else if (eventType === 'mcp_tool_call_begin' || eventType === 'tool_search_call') {
+                recordCodexFunctionCall(currentTurn, functionCallById, payload, timestamp, {
+                    fallbackName: eventType === 'tool_search_call' ? 'tool_search' : 'mcp_tool',
+                });
+            }
+            else if (eventType === 'mcp_tool_call_end'
+                || eventType === 'mcp_tool_call_result'
+                || eventType === 'tool_search_output') {
+                attachCodexFunctionCallOutput(functionCallById, payload, timestamp, {
+                    fallbackName: eventType === 'tool_search_output' ? 'tool_search' : 'mcp_tool',
+                });
+            }
+        }
+    }
+    pushCurrentTurn();
+    return {
+        path: meta.path,
+        modifiedAt: meta.modifiedAt,
+        size: meta.size,
+        sessionId,
+        cwd,
+        model,
+        baseInstructions,
+        preludeDeveloperMessages,
+        preludeUserMessages,
+        turns,
+    };
+}
+function recordCodexFunctionCall(turn, functionCallById, payload, timestamp, options) {
+    const callId = getCodexCallId(payload) ?? `call-${turn.functionCalls.length + 1}`;
+    const existing = functionCallById.get(callId);
+    if (existing) {
+        existing.name = existing.name === 'unknown'
+            ? formatCodexFunctionCallName(payload, options?.fallbackName)
+            : existing.name;
+        if (!existing.arguments) {
+            existing.arguments = formatCodexFunctionCallArguments(payload);
+        }
+        return existing;
+    }
+    const call = {
+        callId,
+        name: formatCodexFunctionCallName(payload, options?.fallbackName),
+        arguments: formatCodexFunctionCallArguments(payload),
+        timestamp,
+    };
+    functionCallById.set(callId, call);
+    turn.functionCalls.push(call);
+    return call;
+}
+function attachCodexFunctionCallOutput(functionCallById, payload, timestamp, options) {
+    const callId = getCodexCallId(payload);
+    if (!callId)
+        return;
+    let existing = functionCallById.get(callId);
+    if (!existing) {
+        existing = {
+            callId,
+            name: formatCodexFunctionCallName(payload, options?.fallbackName),
+            arguments: formatCodexFunctionCallArguments(payload),
+            timestamp,
+        };
+        functionCallById.set(callId, existing);
+    }
+    const output = formatCodexFunctionCallOutput(payload);
+    if (output == null)
+        return;
+    existing.output = output;
+    existing.outputTimestamp = timestamp;
+}
+function getCodexCallId(payload) {
+    return stringValue(payload.call_id)
+        ?? stringValue(payload.callId)
+        ?? stringValue(payload.tool_call_id)
+        ?? stringValue(payload.toolCallId)
+        ?? stringValue(payload.item_id)
+        ?? stringValue(payload.itemId)
+        ?? stringValue(payload.id);
+}
+function formatCodexFunctionCallName(payload, fallbackName = 'unknown') {
+    const name = stringValue(payload.name)
+        ?? stringValue(payload.tool)
+        ?? stringValue(payload.tool_name)
+        ?? fallbackName;
+    const namespaceParts = getCodexNamespaceParts(payload.namespace ?? payload.server);
+    if (namespaceParts.length === 0)
+        return name;
+    const prefix = namespaceParts.join('__');
+    if (name === prefix || name.startsWith(`${prefix}__`))
+        return name;
+    return `${prefix}__${name}`;
+}
+function getCodexNamespaceParts(value) {
+    if (typeof value === 'string') {
+        return value
+            .split(/__|[./]/)
+            .map((part) => part.trim())
+            .filter(Boolean);
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((part) => getCodexNamespaceParts(part));
+    }
+    return [];
+}
+function formatCodexFunctionCallArguments(payload) {
+    const direct = stringValue(payload.arguments) ?? stringValue(payload.input);
+    if (direct != null)
+        return direct;
+    if (payload.arguments != null)
+        return formatPlatformEventValue(payload.arguments) ?? '';
+    if (payload.input != null)
+        return formatPlatformEventValue(payload.input) ?? '';
+    if (payload.query != null) {
+        return formatPlatformEventValue({
+            query: payload.query,
+            action: payload.action ?? undefined,
+        }) ?? '';
+    }
+    const fallbackPayload = omitDebugCallPayloadKeys(payload, [
+        'output',
+        'result',
+        'content',
+        'contentItems',
+        'error',
+        'message',
+    ]);
+    return fallbackPayload ? formatPlatformEventValue(fallbackPayload) ?? '' : '';
+}
+function formatCodexFunctionCallOutput(payload) {
+    const direct = stringValue(payload.output)
+        ?? stringValue(payload.result)
+        ?? stringValue(payload.message)
+        ?? stringValue(payload.error?.message);
+    if (direct != null)
+        return direct;
+    if (payload.output != null)
+        return formatPlatformEventValue(payload.output);
+    if (payload.result != null)
+        return formatPlatformEventValue(payload.result);
+    if (payload.contentItems != null)
+        return formatPlatformEventValue(payload.contentItems);
+    if (payload.content != null)
+        return formatPlatformEventValue(payload.content);
+    if (payload.error != null)
+        return formatPlatformEventValue(payload.error);
+    const fallbackPayload = omitDebugCallPayloadKeys(payload, [
+        'arguments',
+        'input',
+        'query',
+        'action',
+    ]);
+    return fallbackPayload ? formatPlatformEventValue(fallbackPayload) : undefined;
+}
+function omitDebugCallPayloadKeys(payload, extraKeys) {
+    const ignored = new Set([
+        'type',
+        'call_id',
+        'callId',
+        'tool_call_id',
+        'toolCallId',
+        'item_id',
+        'itemId',
+        'id',
+        'name',
+        'namespace',
+        'server',
+        'tool',
+        'tool_name',
+        ...extraKeys,
+    ]);
+    const entries = Object.entries(payload).filter(([key, value]) => !ignored.has(key) && value !== undefined);
+    return entries.length > 0 ? Object.fromEntries(entries) : null;
+}
+export function getRolloutSortTime(rollout) {
+    const turnTimes = rollout.turns
+        .map((turn) => Date.parse(turn.timestamp))
+        .filter((value) => Number.isFinite(value));
+    if (turnTimes.length > 0) {
+        return Math.max(...turnTimes);
+    }
+    return rollout.modifiedAt;
+}
+export function attachPlatformInputsToTurns(rollouts, platformInputs) {
+    const turnRefs = [];
+    for (const rollout of rollouts) {
+        for (const turn of rollout.turns) {
+            turnRefs.push({
+                turn,
+                rolloutSessionId: rollout.sessionId,
+            });
+        }
+    }
+    const matchedTurnIndexes = new Set();
+    const matchedPlatformIndexes = new Set();
+    const chronologicalPlatformIndexes = platformInputs
+        .map((input, index) => ({ input, index }))
+        .sort((a, b) => a.input.startedAt - b.input.startedAt || a.index - b.index);
+    for (const { input, index } of chronologicalPlatformIndexes) {
+        if (!hasReliablePlatformTime(input))
+            continue;
+        const matchIndex = findBestTimedTurnMatch(turnRefs, matchedTurnIndexes, input);
+        if (matchIndex == null)
+            continue;
+        turnRefs[matchIndex].turn.platformInput = input;
+        matchedTurnIndexes.add(matchIndex);
+        matchedPlatformIndexes.add(index);
+    }
+    if (!hasReliableTimeMatchingData(turnRefs, platformInputs)) {
+        const remainingTurnIndexes = turnRefs
+            .map((_, index) => index)
+            .filter((index) => !matchedTurnIndexes.has(index));
+        const remainingPlatformIndexes = platformInputs
+            .map((_, index) => index)
+            .filter((index) => !matchedPlatformIndexes.has(index));
+        const pairCount = Math.min(remainingTurnIndexes.length, remainingPlatformIndexes.length);
+        for (let index = 0; index < pairCount; index += 1) {
+            const turnIndex = remainingTurnIndexes[index];
+            const platformIndex = remainingPlatformIndexes[index];
+            turnRefs[turnIndex].turn.platformInput = platformInputs[platformIndex];
+            matchedTurnIndexes.add(turnIndex);
+            matchedPlatformIndexes.add(platformIndex);
+        }
+    }
+    return platformInputs.filter((_, index) => !matchedPlatformIndexes.has(index));
+}
+function hasReliableTimeMatchingData(turnRefs, platformInputs) {
+    return turnRefs.some((ref) => hasReliableTimestamp(Date.parse(ref.turn.timestamp)))
+        && platformInputs.some(hasReliablePlatformTime);
+}
+function hasReliablePlatformTime(input) {
+    return hasReliableTimestamp(input.startedAt);
+}
+function hasReliableTimestamp(value) {
+    return Number.isFinite(value) && value >= Date.parse('2020-01-01T00:00:00.000Z');
+}
+function findBestTimedTurnMatch(turnRefs, matchedTurnIndexes, input) {
+    let bestIndex = null;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (let index = 0; index < turnRefs.length; index += 1) {
+        if (matchedTurnIndexes.has(index))
+            continue;
+        const ref = turnRefs[index];
+        if (!isSessionCompatible(input, ref))
+            continue;
+        const turnTime = Date.parse(ref.turn.timestamp);
+        if (!hasReliableTimestamp(turnTime))
+            continue;
+        if (!isTurnTimeInsideRun(input, turnTime))
+            continue;
+        const distance = Math.abs(turnTime - input.startedAt);
+        if (distance < bestDistance) {
+            bestIndex = index;
+            bestDistance = distance;
+        }
+    }
+    return bestIndex;
+}
+function isSessionCompatible(input, ref) {
+    if (!input.acpSessionId || !ref.rolloutSessionId)
+        return true;
+    return input.acpSessionId === ref.rolloutSessionId;
+}
+function isTurnTimeInsideRun(input, turnTime) {
+    const beforeToleranceMs = 5_000;
+    const afterToleranceMs = 5_000;
+    if (turnTime < input.startedAt - beforeToleranceMs)
+        return false;
+    if (input.endedAt != null && turnTime > input.endedAt + afterToleranceMs)
+        return false;
+    return true;
+}
+export function listPlatformInputsForConversation(db, params) {
+    const rows = db.prepare(`SELECT r.run_id as runId,
+            r.prompt_text as runPromptText,
+            r.started_at as startedAt,
+            r.ended_at as endedAt,
+            r.stop_reason as stopReason,
+            r.error,
+            d.acp_session_id as acpSessionId,
+            d.is_fresh_session as isFreshSession,
+            d.is_exact as isExact,
+            d.dispatch_mode as dispatchMode,
+            d.system_prompt_text as snapshotSystemPromptText,
+            d.context_text as snapshotContextText,
+            d.prompt_text as snapshotPromptText,
+            d.dispatched_prompt_text as snapshotDispatchedPromptText
+       FROM conversations c
+       JOIN runs r ON r.session_key = c.session_key
+       LEFT JOIN run_debug_inputs d ON d.run_id = r.run_id
+      WHERE c.id = ?
+      ORDER BY r.started_at ${params.newestFirst ? 'DESC' : 'ASC'}`).all(params.conversation.id);
+    const agent = params.conversation.agentId ? params.getAgentById(params.conversation.agentId) : null;
+    const reconstructedSystemPrompt = agent && params.conversation.workspacePath
+        ? buildAgentSessionSystemPromptText({
+            agentName: agent.name,
+            agentBio: agent.description || undefined,
+            agentDescription: agent.systemPrompt || undefined,
+            workspacePath: params.conversation.workspacePath,
+        })
+        : undefined;
+    return rows.map((row) => {
+        const promptText = row.snapshotPromptText ?? row.runPromptText;
+        const dispatchedPromptText = row.snapshotDispatchedPromptText ?? undefined;
+        return {
+            runId: row.runId,
+            startedAt: row.startedAt,
+            endedAt: row.endedAt,
+            stopReason: row.stopReason ?? undefined,
+            error: row.error ?? undefined,
+            dispatchMode: row.dispatchMode ?? undefined,
+            acpSessionId: row.acpSessionId ?? undefined,
+            isFreshSession: row.isFreshSession == null ? undefined : Boolean(row.isFreshSession),
+            source: row.isExact ? 'exact_snapshot' : 'reconstructed',
+            systemPromptText: row.isExact
+                ? row.snapshotSystemPromptText ?? undefined
+                : row.snapshotSystemPromptText ?? reconstructedSystemPrompt,
+            contextText: row.snapshotContextText ?? undefined,
+            promptText,
+            dispatchedPromptText,
+            runtimeInputText: joinDebugText(row.snapshotContextText, dispatchedPromptText ?? promptText),
+            platformTrace: params.includePlatformTrace ? buildPlatformTraceForRun(db, row.runId) : undefined,
+        };
+    });
+}
+export function listNotificationDeliveryEvidenceForConversation(db, conversationId) {
+    const rows = db.prepare(`SELECT round_id as roundId,
+            target_agent_id as targetAgentId,
+            channel_id as channelId,
+            surface_thread_key as surfaceThreadKey,
+            conversation_id as conversationId,
+            status,
+            delivery_mode as deliveryMode,
+            from_seq_exclusive as fromSeqExclusive,
+            to_seq_inclusive as toSeqInclusive,
+            message_count as messageCount,
+            delivered_at as deliveredAt,
+            acked_at as ackedAt,
+            superseded_at as supersededAt,
+            failed_at as failedAt,
+            first_message_id as firstMessageId,
+            last_message_id as lastMessageId,
+            delivery_payload_json as deliveryPayloadJson
+       FROM agent_notification_rounds
+      WHERE conversation_id = ?
+      ORDER BY created_at ASC`).all(conversationId);
+    return rows.map((row) => {
+        let payload = {};
+        try {
+            payload = JSON.parse(row.deliveryPayloadJson);
+        }
+        catch {
+            payload = {};
+        }
+        const referencesDeletedMessage = notificationDeliveryReferencesDeletedMessage(db, row, payload.activationMetadata);
+        const promptText = typeof payload.promptText === 'string'
+            && payload.promptText !== REDACTED_NOTIFICATION_PROMPT
+            && !referencesDeletedMessage
+            ? payload.promptText
+            : undefined;
+        const activationMetadata = referencesDeletedMessage
+            ? redactNotificationActivationMetadata(payload.activationMetadata)
+            : payload.activationMetadata;
+        return {
+            roundId: row.roundId,
+            targetAgentId: row.targetAgentId,
+            channelId: row.channelId,
+            surfaceThreadKey: row.surfaceThreadKey,
+            conversationId: row.conversationId,
+            status: row.status,
+            deliveryMode: row.deliveryMode ?? undefined,
+            fromSeqExclusive: row.fromSeqExclusive,
+            toSeqInclusive: row.toSeqInclusive,
+            messageCount: row.messageCount,
+            deliveredAt: row.deliveredAt ?? undefined,
+            ackedAt: row.ackedAt ?? undefined,
+            supersededAt: row.supersededAt ?? undefined,
+            failedAt: row.failedAt ?? undefined,
+            promptText,
+            activationMetadata,
+        };
+    });
+}
+function redactNotificationActivationMetadata(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const redacted = { ...value };
+    delete redacted.promptContextSections;
+    delete redacted.slashCommand;
+    delete redacted.attachments;
+    delete redacted.attachmentIds;
+    return Object.keys(redacted).length > 0 ? redacted : undefined;
+}
+function notificationDeliveryReferencesDeletedMessage(db, row, activationMetadata) {
+    const directDeletedRow = db.prepare(`SELECT 1
+     FROM channel_messages
+     WHERE channel_id = ?
+       AND COALESCE(thread_root_id, '') = ?
+       AND deleted_at IS NOT NULL
+       AND (
+         message_id = ?
+         OR message_id = ?
+         OR (seq > ? AND seq <= ?)
+       )
+     LIMIT 1`).get(row.channelId, row.surfaceThreadKey, row.firstMessageId, row.lastMessageId, row.fromSeqExclusive, row.toSeqInclusive);
+    if (directDeletedRow)
+        return true;
+    const referencedMessageIds = extractNotificationActivationMessageIds(activationMetadata);
+    if (referencedMessageIds.length === 0)
+        return false;
+    const deletedByMessageId = db.prepare(`SELECT 1
+     FROM channel_messages
+     WHERE message_id = ?
+       AND deleted_at IS NOT NULL
+     LIMIT 1`);
+    return referencedMessageIds.some((messageId) => Boolean(deletedByMessageId.get(messageId)));
+}
+function extractNotificationActivationMessageIds(value) {
+    if (!value || typeof value !== 'object')
+        return [];
+    const metadata = value;
+    const ids = new Set();
+    const triggerMessage = metadata.triggerMessage;
+    if (triggerMessage && typeof triggerMessage === 'object') {
+        const messageId = triggerMessage.messageId;
+        if (typeof messageId === 'string' && messageId.trim())
+            ids.add(messageId);
+    }
+    const taskPeerUpdate = metadata.taskPeerUpdate;
+    if (taskPeerUpdate && typeof taskPeerUpdate === 'object') {
+        const record = taskPeerUpdate;
+        for (const key of ['firstMessageId', 'lastMessageId']) {
+            const messageId = record[key];
+            if (typeof messageId === 'string' && messageId.trim())
+                ids.add(messageId);
+        }
+    }
+    const peerInboxAggregate = metadata.peerInboxAggregate;
+    if (peerInboxAggregate && typeof peerInboxAggregate === 'object') {
+        const itemMessageIds = peerInboxAggregate.itemMessageIds;
+        if (Array.isArray(itemMessageIds)) {
+            for (const messageId of itemMessageIds) {
+                if (typeof messageId === 'string' && messageId.trim())
+                    ids.add(messageId);
+            }
+        }
+    }
+    const sharedCollaboration = metadata.sharedCollaboration;
+    if (sharedCollaboration && typeof sharedCollaboration === 'object') {
+        const messageId = sharedCollaboration.originMessageId;
+        if (typeof messageId === 'string' && messageId.trim())
+            ids.add(messageId);
+    }
+    return [...ids];
+}
+function buildPlatformTraceForRun(db, runId) {
+    let assistantText = '';
+    let thinkingText = '';
+    const toolCalls = [];
+    const toolCallById = new Map();
+    let sawReplayEvent = false;
+    for (const row of iterateParsedNodeEvents(db, {
+        runId,
+        types: ['content.delta', 'thinking.delta', 'tool.call', 'tool.result'],
+    })) {
+        const parsed = row.event;
+        if (!parsed)
+            continue;
+        sawReplayEvent = true;
+        if (parsed.type === 'content.delta') {
+            assistantText += parsed.text;
+            continue;
+        }
+        if (parsed.type === 'thinking.delta') {
+            thinkingText += parsed.text;
+            continue;
+        }
+        if (parsed.type === 'tool.call') {
+            const toolCall = upsertPlatformToolCall(toolCallById, toolCalls, parsed.toolCallId, {
+                name: parsed.name || 'tool',
+            });
+            toolCall.name = parsed.name || toolCall.name;
+            toolCall.inputText = formatPlatformEventValue(parsed.input) ?? toolCall.inputText;
+            toolCall.startedAt = parsed.startedAt ?? toolCall.startedAt ?? row.createdAt;
+            continue;
+        }
+        if (parsed.type === 'tool.result') {
+            const toolCall = upsertPlatformToolCall(toolCallById, toolCalls, parsed.toolCallId, {
+                name: 'tool',
+            });
+            toolCall.outputText = parsed.output;
+            toolCall.error = Boolean(parsed.error);
+            toolCall.status = parsed.status ?? (parsed.error ? 'failed' : 'completed');
+            toolCall.endedAt = parsed.endedAt ?? toolCall.endedAt ?? row.createdAt;
+        }
+    }
+    if (!sawReplayEvent)
+        return undefined;
+    if (!assistantText && !thinkingText && toolCalls.length === 0)
+        return undefined;
+    return {
+        assistantText: assistantText || undefined,
+        thinkingText: thinkingText || undefined,
+        toolCalls,
+    };
+}
+function upsertPlatformToolCall(toolCallById, toolCalls, toolCallId, seed) {
+    const existing = toolCallById.get(toolCallId);
+    if (existing)
+        return existing;
+    const created = {
+        callId: toolCallId,
+        name: seed.name,
+    };
+    toolCallById.set(toolCallId, created);
+    toolCalls.push(created);
+    return created;
+}
+function formatPlatformEventValue(value) {
+    if (value == null)
+        return undefined;
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function joinDebugText(...parts) {
+    const visibleParts = parts
+        .map((part) => part?.trim())
+        .filter((part) => Boolean(part));
+    return visibleParts.length > 0 ? visibleParts.join('\n\n') : undefined;
+}
+function extractInputBlocks(payload) {
+    const content = Array.isArray(payload.content) ? payload.content : [];
+    return content.flatMap((block) => {
+        if (!block || typeof block !== 'object')
+            return [];
+        const typed = block;
+        if (typed.type !== 'input_text')
+            return [];
+        const text = stringValue(typed.text);
+        return text ? [text] : [];
+    });
+}
+function extractAssistantOutputs(payload) {
+    const content = Array.isArray(payload.content) ? payload.content : [];
+    return content.flatMap((block) => {
+        if (!block || typeof block !== 'object')
+            return [];
+        const typed = block;
+        if (typed.type !== 'output_text')
+            return [];
+        const text = stringValue(typed.text);
+        return text ? [text] : [];
+    });
+}
+function extractMessageText(payload) {
+    const blocks = extractInputBlocks(payload);
+    if (blocks.length > 0)
+        return blocks.join('\n\n');
+    const assistantOutputs = extractAssistantOutputs(payload);
+    if (assistantOutputs.length > 0)
+        return assistantOutputs.join('\n\n');
+    return undefined;
+}
+export function parseReplyTarget(text) {
+    const match = /\[(?:Current conversation target|Handoff metadata)\][\s\S]*?reply_target:\s*([^\n]+)/.exec(text);
+    return match?.[1]?.trim() || undefined;
+}
+export function parseTriggerTarget(text) {
+    const match = /\[Triggered message metadata\][\s\S]*?target:\s*([^\n]+)/.exec(text);
+    return match?.[1]?.trim() || undefined;
+}
+function parseTokenUsage(payload) {
+    const info = payload.info;
+    const total = info?.total_token_usage;
+    const last = info?.last_token_usage;
+    const contextWindow = numberValue(info?.model_context_window);
+    if (!total && !last && contextWindow === undefined)
+        return undefined;
+    return {
+        currentInputTokens: numberValue(last?.input_tokens) ?? numberValue(total?.input_tokens),
+        inputTokens: numberValue(total?.input_tokens),
+        cachedInputTokens: numberValue(total?.cached_input_tokens),
+        currentCachedInputTokens: numberValue(last?.cached_input_tokens) ?? numberValue(total?.cached_input_tokens),
+        outputTokens: numberValue(total?.output_tokens),
+        reasoningOutputTokens: numberValue(total?.reasoning_output_tokens),
+        totalTokens: numberValue(total?.total_tokens),
+        modelContextWindow: contextWindow,
+    };
+}
+function applyCodexContextWindowFallback(rollout, getCodexContextWindowByModel) {
+    const fallbackWindow = getCodexContextWindowByModel(rollout.model);
+    if (fallbackWindow == null)
+        return;
+    for (const turn of rollout.turns) {
+        if (!turn.tokenUsage)
+            continue;
+        turn.tokenUsage.modelContextWindow = turn.tokenUsage.modelContextWindow ?? fallbackWindow;
+    }
+}
+function defaultGetCodexContextWindowByModel(model) {
+    if (!model)
+        return undefined;
+    const windows = loadCodexModelWindows();
+    return windows.get(model);
+}
+function loadCodexModelWindows() {
+    if (cachedCodexModelWindows)
+        return cachedCodexModelWindows;
+    const windows = new Map();
+    try {
+        const raw = readFileSync('/root/.codex/models_cache.json', 'utf8');
+        const parsed = JSON.parse(raw);
+        for (const model of parsed.models ?? []) {
+            const slug = stringValue(model.slug);
+            const contextWindow = numberValue(model.context_window);
+            if (!slug || contextWindow == null)
+                continue;
+            const effectivePercent = numberValue(model.effective_context_window_percent);
+            const effectiveWindow = effectivePercent != null
+                ? Math.round(contextWindow * (effectivePercent / 100))
+                : contextWindow;
+            windows.set(slug, effectiveWindow);
+        }
+    }
+    catch {
+        // Best-effort fallback only.
+    }
+    cachedCodexModelWindows = windows;
+    return windows;
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.trim() ? value : undefined;
+}
+function numberValue(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function isTranscriptTimeoutError(message) {
+    return message.toLowerCase().includes('timed out');
+}