@myagentroam/node 0.11.14 → 0.11.16

package/dist/native-session-history.js

@@ -1,23 +1,16 @@
 import { createHash } from 'node:crypto';
-import { readFile, readdir, stat, unlink } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { basename, join, resolve } from 'node:path';
-import { forEachJsonlRecord, listJsonlFiles, mapConcurrent, readJsonlBackwardWindow, readJsonlFileAnchor, readJsonlWindow } from './native-jsonl-reader.js';
+import { basename } from 'node:path';
+import { stat, unlink } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { listJsonlFiles, mapConcurrent, readJsonlBackwardWindow, readJsonlFileAnchor } from './native-jsonl-reader.js';
+import { nativeTranscriptAdapter } from './native-transcript-adapters.js';
 import { nodeLog } from './operational.js';
-import { stripClaudePlanTag } from './runner-command-engine.js';
-import { stripGoalStartPrompt } from './service/goal-runtime.js';
-import { parseCodexComposerImageMarkers } from './runner/codex/composer-image-markers.js';
-import { codexTranscriptSourceItemId } from './runner/codex/conversation-parser.js';
-import { claudeAssistantBlocks, extractClaudeThinkingText } from './runner/claude/conversation-parser.js';
-import { extractClaudeToolResults } from './runner/claude/tool-normalizer.js';
 const DISCOVERY_READ_BYTES = 32 * 1024;
 const TRANSCRIPT_HEADER_READ_BYTES = 32 * 1024;
 const TRANSCRIPT_READ_MAX_BYTES = 16 * 1024 * 1024;
 const TRANSCRIPT_MIN_LINES = 256;
 const TRANSCRIPT_MAX_LINES = 4096;
 const TRANSCRIPT_LINES_PER_TURN = 32;
-const CONTEXT_USAGE_READ_BYTES = 256 * 1024;
-const CLAUDE_CONTEXT_USAGE_READ_BYTES = [CONTEXT_USAGE_READ_BYTES, 1024 * 1024, 4 * 1024 * 1024];
 const TRANSCRIPT_INDEX_TTL_MS = 60 * 60_000;
 const DISCOVERY_SNAPSHOT_TTL_MS = 15_000;
 const TRANSCRIPT_DETAIL_CACHE_TTL_MS = 60_000;
@@ -29,8 +22,6 @@ const transcriptDetailReads = new Map();
 const discoveryReads = new Map();
 const discoverySnapshots = new Map();
 const discoveryGenerations = new Map();
-const DEFAULT_CLAUDE_CONTEXT_WINDOW_TOKENS = 200_000;
-const CLAUDE_CONTEXT_WINDOW_ENV = 'MAR_CLAUDE_CONTEXT_WINDOW_TOKENS';
 /**
  * Read-only adapter for the supported vendor JSONL stores.  It requires an
  * explicit cwd on the record and returns normalized visible messages and tool
@@ -76,7 +67,7 @@ async function performNativeSessionDiscovery(runner, previous) {
     const startedAt = performance.now();
     const found = new Map();
     nodeLog('native.session.discovery.started', { runner });
-    const files = (await listJsonlFiles(transcriptRoot(runner))).filter((path) => runner !== 'claude-code' || !path.split(/[\\/]/u).includes('subagents'));
+    const files = (await listJsonlFiles(transcriptRoot(runner))).filter((path) => nativeTranscriptAdapter(runner).includesPath(path));
     nodeLog('native.session.discovery.files-listed', {
         runner,
         files: files.length,
@@ -261,110 +252,6 @@ function pruneTranscriptDetailCache() {
         transcriptDetailCache.delete(oldest);
     }
 }
-/**
- * Codex records the most recent prompt token count alongside the model context
- * window in `event_msg/token_count`.  Read only the tail of an already
- * discovered transcript: the count is append-only and never needs a costly
- * full-history scan.
- */
-export async function readCodexNativeContextUsage(workspacePath, externalSessionId) {
-    const wanted = canonical(workspacePath);
-    let path = getTranscriptIndex(indexKey('codex', wanted, externalSessionId));
-    if (path === undefined) {
-        await discoverNativeSessions('codex', workspacePath);
-        path = getTranscriptIndex(indexKey('codex', wanted, externalSessionId));
-    }
-    if (path === undefined)
-        return undefined;
-    const window = await readJsonlWindow(path, { tailBytes: CONTEXT_USAGE_READ_BYTES });
-    if (window === undefined)
-        return undefined;
-    let usage;
-    forEachJsonlRecord(window.content, (record) => {
-        const next = codexContextUsage(record);
-        if (next !== undefined)
-            usage = next;
-    });
-    return usage;
-}
-/** Reads the latest actual Claude prompt occupancy without starting a CLI/SDK control stream. */
-export async function readClaudeNativeContextUsage(workspacePath, externalSessionId, options = {}) {
-    const wanted = canonical(workspacePath);
-    let path = getTranscriptIndex(indexKey('claude-code', wanted, externalSessionId));
-    path ??= await locateClaudeTranscript(wanted, externalSessionId);
-    if (path === undefined) {
-        await discoverNativeSessions('claude-code', workspacePath);
-        path = getTranscriptIndex(indexKey('claude-code', wanted, externalSessionId));
-    }
-    if (path === undefined)
-        return undefined;
-    const latest = await readLatestClaudeContextUsage(path);
-    if (latest === undefined)
-        return undefined;
-    return {
-        ...latest,
-        maxTokens: await claudeContextWindowTokens(options)
-    };
-}
-async function readLatestClaudeContextUsage(path) {
-    for (const tailBytes of CLAUDE_CONTEXT_USAGE_READ_BYTES) {
-        const window = await readJsonlWindow(path, { tailBytes });
-        if (window === undefined)
-            return undefined;
-        let latest;
-        forEachJsonlRecord(window.content, (record) => {
-            const usage = claudeContextUsage(record);
-            if (usage !== undefined)
-                latest = usage;
-        });
-        if (latest !== undefined)
-            return latest;
-        if (!window.truncated)
-            return undefined;
-    }
-    return undefined;
-}
-/** Claude main transcripts use the native session ID as their filename. */
-async function locateClaudeTranscript(wantedCwd, externalSessionId) {
-    const root = transcriptRoot('claude-code');
-    let entries;
-    try {
-        entries = await readdir(root, { withFileTypes: true });
-    }
-    catch {
-        return undefined;
-    }
-    const candidates = entries
-        .filter((entry) => entry.isDirectory())
-        .map((entry) => join(root, entry.name, `${externalSessionId}.jsonl`));
-    const parsed = await mapConcurrent(candidates, 16, async (path) => ({
-        path,
-        history: await readTranscript(path, 'claude-code', DISCOVERY_READ_BYTES)
-    }));
-    const match = parsed.find(({ history }) => history?.externalSessionId === externalSessionId && canonical(history.cwd) === wantedCwd);
-    if (match === undefined)
-        return undefined;
-    setTranscriptIndex(indexKey('claude-code', wantedCwd, externalSessionId), match.path);
-    return match.path;
-}
-export async function claudeContextWindowTokens(options = {}) {
-    const environment = options.environment ?? process.env;
-    const direct = positiveInteger(environment[CLAUDE_CONTEXT_WINDOW_ENV]);
-    if (direct !== undefined)
-        return direct;
-    try {
-        const settings = JSON.parse(await readFile(options.settingsPath ?? join(homedir(), '.claude', 'settings.json'), 'utf8'));
-        if (isRecord(settings) && isRecord(settings.env)) {
-            const configured = positiveInteger(settings.env[CLAUDE_CONTEXT_WINDOW_ENV]);
-            if (configured !== undefined)
-                return configured;
-        }
-    }
-    catch {
-        // Missing or malformed optional Claude settings use the stable default.
-    }
-    return DEFAULT_CLAUDE_CONTEXT_WINDOW_TOKENS;
-}
 /**
  * Permanently removes exactly one previously discovered transcript. The
  * caller supplies no path: the in-process discovery index resolves it, then
@@ -406,9 +293,7 @@ export async function removeNativeSession(runner, workspacePath, externalSession
     invalidateNativeDiscovery(runner);
 }
 function transcriptRoot(runner) {
-    return runner === 'codex'
-        ? join(homedir(), '.codex', 'sessions')
-        : join(homedir(), '.claude', 'projects');
+    return nativeTranscriptAdapter(runner).transcriptRoot();
 }
 function discoveryKey(runner) {
     return `${runner}\u0000${transcriptRoot(runner)}`;
@@ -428,102 +313,16 @@ async function readTranscript(path, runner, byteLimit, page, targetLines = Numbe
     });
     if (window === undefined)
         return undefined;
-    const { content, truncated } = window;
-    let cwd;
-    let id;
-    let derivedSession = false;
-    const items = [];
-    const toolIndexes = new Map();
-    const metaRecordIds = new Set();
-    const claudeCompactCommandIds = new Set();
-    let codexTurnId;
-    forEachJsonlRecord(content, (value) => {
-        if (derivedTranscriptRecord(runner, value))
-            derivedSession = true;
-        cwd ??= workspacePath(value);
-        id ??= sessionId(value);
-        if (runner === 'claude-code' &&
-            typeof value['uuid'] === 'string' &&
-            isClaudeCompactCommand(value))
-            claudeCompactCommandIds.add(value['uuid']);
-    });
-    forEachJsonlRecord(truncated ? window.pageContent : content, (value) => {
-        if (runner === 'codex' && value['type'] === 'event_msg' && isRecord(value['payload'])) {
-            const payload = value['payload'];
-            if (payload['type'] === 'task_started')
-                codexTurnId = typeof payload['turn_id'] === 'string' ? payload['turn_id'] : undefined;
-            else if (payload['type'] === 'task_complete')
-                codexTurnId = undefined;
-        }
-        const recordId = typeof value['uuid'] === 'string' ? value['uuid'] : undefined;
-        const parentId = typeof value['parentUuid'] === 'string' ? value['parentUuid'] : undefined;
-        if (value['isMeta'] === true && recordId !== undefined)
-            metaRecordIds.add(recordId);
-        if (runner === 'claude-code' &&
-            parentId !== undefined &&
-            claudeCompactCommandIds.has(parentId) &&
-            isClaudeCompactSuccess(value)) {
-            items.push({
-                kind: 'context_compaction',
-                phase: 'COMPLETED',
-                summary: null,
-                createdAt: timestampOf(value),
-                nativeId: parentId
-            });
-            return;
-        }
-        if (isHiddenTranscriptRecord(value) ||
-            (parentId !== undefined && metaRecordIds.has(parentId))) {
-            return;
-        }
-        const generatedImage = codexGeneratedImageEvent(value);
-        if (generatedImage !== undefined)
-            items.push(generatedImage);
-        const sourceItemId = runner === 'codex' ? codexTranscriptSourceItemId(value, codexTurnId) : undefined;
-        for (const parsedItem of transcriptItems(runner, value)) {
-            const item = {
-                ...parsedItem,
-                ...(sourceItemId === undefined ? {} : { sourceItemId }),
-                ...(recordId === undefined ? {} : { nativeId: recordId }),
-                ...(runner === 'codex' &&
-                    parsedItem.kind === 'message' &&
-                    parsedItem.role === 'USER' &&
-                    codexTurnId !== undefined
-                    ? { nativeTurnId: codexTurnId }
-                    : {})
-            };
-            if (item.kind === 'tool_result') {
-                const toolIndex = toolIndexes.get(item.toolUseId);
-                if (toolIndex !== undefined)
-                    items[toolIndex] = withToolResult(items[toolIndex], item);
-                continue;
-            }
-            if (item.kind === 'tool_call') {
-                toolIndexes.set(item.toolUseId, items.length);
-                items.push(item);
-                continue;
-            }
-            items.push(item);
-        }
-    });
-    if (derivedSession)
-        return undefined;
-    if (cwd === undefined)
+    const parsed = nativeTranscriptAdapter(runner)?.parse(path, window);
+    if (parsed === undefined)
         return undefined;
-    const title = items.find((item) => item.kind === 'message' && item.role === 'USER')?.text;
-    // Tagged Plan Mode instruction labels do not form a session title.
-    const strippedTitle = title === undefined ? undefined : stripClaudePlanTag(stripGoalStartPrompt(title));
     return {
+        ...parsed,
         runner,
-        externalSessionId: id ?? basename(path, '.jsonl'),
-        cwd,
-        ...(strippedTitle === undefined || strippedTitle.length === 0
-            ? {}
-            : { title: compact(strippedTitle) }),
-        digest: createHash('sha256').update(content).digest('hex'),
-        items,
-        lastActivityAt: Math.max(0, ...items.map((item) => item.createdAt ?? 0)),
-        truncated,
+        externalSessionId: parsed.externalSessionId ?? basename(path, '.jsonl'),
+        digest: createHash('sha256').update(window.content).digest('hex'),
+        lastActivityAt: Math.max(0, ...parsed.items.map((item) => item.createdAt ?? 0)),
+        truncated: window.truncated,
         windowStart: window.start,
         windowEnd: window.end,
         snapshotEnd: window.snapshotEnd,
@@ -531,621 +330,6 @@ async function readTranscript(path, runner, byteLimit, page, targetLines = Numbe
         anchorBytes: window.anchorBytes
     };
 }
-function derivedTranscriptRecord(runner, value) {
-    if (runner === 'claude-code')
-        return value['isSidechain'] === true;
-    if (runner !== 'codex' || value['type'] !== 'session_meta')
-        return false;
-    const payload = isRecord(value['payload']) ? value['payload'] : undefined;
-    if (payload === undefined)
-        return false;
-    if (payload['thread_source'] === 'subagent')
-        return true;
-    const source = payload['source'];
-    return (source === 'subagent' ||
-        (isRecord(source) && (source['kind'] === 'subagent' || isRecord(source['subagent']))));
-}
-function workspacePath(record) {
-    return (firstString(record, ['cwd', 'working_directory', 'workspacePath']) ??
-        nestedString(record, ['payload', 'cwd']) ??
-        nestedString(record, ['message', 'cwd']));
-}
-function sessionId(record) {
-    // A Codex sub-agent transcript records its own thread in `payload.id`, but
-    // retains the parent thread in `payload.session_id`.  Treating the latter
-    // as this file's identity makes the child file overwrite the parent thread
-    // in the discovery index, which then shows unrelated messages for the
-    // parent Chat.
-    if (record['type'] === 'session_meta') {
-        const transcriptId = nestedString(record, ['payload', 'id']);
-        if (transcriptId !== undefined)
-            return transcriptId;
-    }
-    return (firstString(record, ['sessionId', 'session_id', 'thread_id', 'conversationId']) ??
-        nestedString(record, ['payload', 'id']) ??
-        nestedString(record, ['payload', 'session_id']) ??
-        nestedString(record, ['payload', 'thread_id']));
-}
-function codexContextUsage(value) {
-    if (!isRecord(value) || value.type !== 'event_msg' || !isRecord(value.payload))
-        return undefined;
-    const payload = value.payload;
-    if (payload.type !== 'token_count' || !isRecord(payload.info))
-        return undefined;
-    const promptUsage = payload.info.last_token_usage;
-    const maxTokens = payload.info.model_context_window;
-    if (!isRecord(promptUsage) ||
-        typeof promptUsage.input_tokens !== 'number' ||
-        typeof maxTokens !== 'number')
-        return undefined;
-    if (!Number.isFinite(promptUsage.input_tokens) ||
-        !Number.isInteger(promptUsage.input_tokens) ||
-        !Number.isFinite(maxTokens) ||
-        !Number.isInteger(maxTokens) ||
-        maxTokens <= 0 ||
-        promptUsage.input_tokens < 0)
-        return undefined;
-    return { usedTokens: promptUsage.input_tokens, maxTokens };
-}
-function claudeContextUsage(value) {
-    if (value.type !== 'assistant' || !isRecord(value.message))
-        return undefined;
-    const model = value.message.model;
-    const usage = value.message.usage;
-    if (typeof model !== 'string' ||
-        model.length === 0 ||
-        model === '<synthetic>' ||
-        !isRecord(usage))
-        return undefined;
-    const inputTokens = nonNegativeInteger(usage.input_tokens);
-    const cacheCreationTokens = optionalNonNegativeInteger(usage.cache_creation_input_tokens);
-    const cacheReadTokens = optionalNonNegativeInteger(usage.cache_read_input_tokens);
-    if (inputTokens === undefined ||
-        cacheCreationTokens === undefined ||
-        cacheReadTokens === undefined)
-        return undefined;
-    return { model, usedTokens: inputTokens + cacheCreationTokens + cacheReadTokens };
-}
-function optionalNonNegativeInteger(value) {
-    return value === undefined ? 0 : nonNegativeInteger(value);
-}
-function nonNegativeInteger(value) {
-    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
-}
-function positiveInteger(value) {
-    if (typeof value !== 'string' || !/^\d+$/.test(value.trim()))
-        return undefined;
-    const parsed = Number(value);
-    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
-}
-function transcriptItems(runner, record) {
-    if (runner === 'claude-code' && record.type === 'assistant') {
-        return claudeAssistantBlocks(record).flatMap(({ record: blockRecord, blockIndex, sourceItemId }) => {
-            const block = contentBlocks(blockRecord)[0];
-            if (block?.type === 'thinking') {
-                const text = extractClaudeThinkingText(blockRecord)[0] ?? '';
-                return text.length === 0
-                    ? []
-                    : [
-                        {
-                            kind: 'reasoning_summary',
-                            representation: 'visible_thinking',
-                            sections: [{ index: blockIndex, text }],
-                            createdAt: timestampOf(record),
-                            ...(sourceItemId === undefined ? {} : { sourceItemId })
-                        }
-                    ];
-            }
-            return transcriptRecordItems(runner, blockRecord).map((item) => ({
-                ...item,
-                ...(sourceItemId === undefined ? {} : { sourceItemId })
-            }));
-        });
-    }
-    return transcriptRecordItems(runner, record);
-}
-function transcriptRecordItems(runner, record) {
-    const createdAt = timestampOf(record);
-    const results = [...toolResultsOf(record, createdAt), ...codexToolResultsOf(record, createdAt)];
-    if (results.length > 0)
-        return results;
-    const values = [
-        ...toolUsesOf(record, createdAt),
-        ...codexToolUsesOf(record, createdAt),
-        ...codexReasoningSummariesOf(record, createdAt),
-        ...unsupportedCodexResponseItems(record, createdAt),
-        ...unsupportedTranscriptItems(record, createdAt)
-    ];
-    const role = roleOf(record);
-    if (role === undefined)
-        return values;
-    const rawText = messageText(textOf(record) ?? '');
-    if (rawText.length === 0)
-        return values;
-    // Codex transcripts can contain the host's injected AGENTS.md and runtime
-    // context as a `user` item before the first actual prompt.  It is neither a
-    // user-visible chat turn nor a meaningful session title.
-    if (role === 'USER' && isInjectedContextPrompt(rawText))
-        return values;
-    const message = role === 'USER' && runner === 'codex'
-        ? parseCodexComposerImageMarkers(rawText)
-        : { text: rawText, images: [] };
-    values.unshift({
-        kind: 'message',
-        role,
-        text: message.text,
-        ...(message.images.length === 0
-            ? {}
-            : {
-                imageAttachments: message.images.map((image) => ({
-                    name: `Image #${image.index}`,
-                    mime: imageMime(image.localPath),
-                    localPath: image.localPath
-                }))
-            }),
-        createdAt
-    });
-    return values;
-}
-function unsupportedCodexResponseItems(record, createdAt) {
-    const payload = codexToolPayload(record);
-    const type = typeof payload?.type === 'string' ? payload.type : undefined;
-    if (type === undefined ||
-        typeof payload?.role === 'string' ||
-        type === 'reasoning' ||
-        type === 'custom_tool_call' ||
-        type === 'custom_tool_call_output' ||
-        type === 'function_call' ||
-        type === 'function_call_output')
-        return [];
-    return [
-        {
-            kind: 'unknown',
-            sourceEventType: `codex:${type}`,
-            label: `Codex ${compact(type).slice(0, 128)}`,
-            createdAt
-        }
-    ];
-}
-function codexReasoningSummariesOf(record, createdAt) {
-    const payload = codexToolPayload(record);
-    if (payload?.type !== 'reasoning')
-        return [];
-    const sections = Array.isArray(payload.summary)
-        ? payload.summary.flatMap((value, index) => {
-            if (typeof value !== 'string')
-                return [];
-            const text = compact(value).slice(0, 10_000);
-            return text.length === 0 ? [] : [{ index, text }];
-        })
-        : [];
-    return [{ kind: 'reasoning_summary', representation: 'summary', sections, createdAt }];
-}
-function unsupportedTranscriptItems(record, createdAt) {
-    return contentBlocks(record).flatMap((block) => {
-        const type = typeof block.type === 'string' ? block.type : undefined;
-        if (type === undefined ||
-            type === 'text' ||
-            type === 'input_text' ||
-            type === 'output_text' ||
-            type === 'image' ||
-            type === 'input_image' ||
-            type === 'thinking' ||
-            type === 'redacted_thinking' ||
-            type === 'encrypted_thinking' ||
-            type === 'tool_use' ||
-            type === 'tool_result')
-            return [];
-        return [
-            {
-                kind: 'unknown',
-                sourceEventType: `transcript:${type}`,
-                label: `Agent ${compact(type).slice(0, 128)}`,
-                createdAt
-            }
-        ];
-    });
-}
-function toolUsesOf(record, createdAt) {
-    return contentBlocks(record).flatMap((block) => {
-        if (block['type'] !== 'tool_use' ||
-            typeof block['id'] !== 'string' ||
-            typeof block['name'] !== 'string')
-            return [];
-        const input = block['input'];
-        const summary = compactValue(input, 10_000);
-        return [
-            {
-                kind: 'tool_call',
-                toolUseId: block['id'],
-                toolName: compact(block['name']).slice(0, 128),
-                input,
-                inputSummary: summary.text || null,
-                inputTruncated: summary.truncated,
-                outputSummary: null,
-                outputTruncated: false,
-                failed: false,
-                createdAt
-            }
-        ];
-    });
-}
-function toolResultsOf(record, createdAt) {
-    return extractClaudeToolResults(record).map((result) => ({
-        ...result,
-        kind: 'tool_result',
-        createdAt
-    }));
-}
-/**
- * Codex persists custom and standard function tools as paired `response_item`
- * records. Their record IDs differ, while `call_id` is the stable identifier
- * shared by invocation and result. Normalize on that key so JSONL fallback
- * history has the same single-card shape as live events.
- */
-function codexToolUsesOf(record, createdAt) {
-    const payload = codexToolPayload(record);
-    if (payload?.['type'] !== 'custom_tool_call' && payload?.['type'] !== 'function_call')
-        return [];
-    const toolUseId = firstString(payload, ['call_id', 'id']);
-    const toolName = firstString(payload, ['name', 'tool']);
-    if (toolUseId === undefined || toolName === undefined)
-        return [];
-    const input = payload['input'] ?? payload['arguments'];
-    const summary = compactValue(input, 10_000);
-    return [
-        {
-            kind: 'tool_call',
-            toolUseId,
-            toolName: compact(toolName).slice(0, 128),
-            input,
-            inputSummary: summary.text || null,
-            inputTruncated: summary.truncated,
-            outputSummary: null,
-            outputTruncated: false,
-            failed: false,
-            createdAt
-        }
-    ];
-}
-function codexToolResultsOf(record, createdAt) {
-    const payload = codexToolPayload(record);
-    if (payload?.['type'] !== 'custom_tool_call_output' &&
-        payload?.['type'] !== 'function_call_output')
-        return [];
-    const toolUseId = firstString(payload, ['call_id', 'id']);
-    if (toolUseId === undefined)
-        return [];
-    const output = compactValue(codexToolOutput(payload['output'] ?? payload['contentItems']), 10_000);
-    const imageAttachments = codexImagePlaceholders(payload['output'] ?? payload['contentItems']);
-    return [
-        {
-            kind: 'tool_result',
-            toolUseId,
-            output: output.text,
-            failed: payload['status'] === 'failed' || payload['error'] !== undefined,
-            truncated: output.truncated,
-            ...(imageAttachments.length === 0 ? {} : { imageAttachments }),
-            createdAt
-        }
-    ];
-}
-function codexToolPayload(record) {
-    return record['type'] === 'response_item' && isRecord(record['payload'])
-        ? record['payload']
-        : undefined;
-}
-function codexGeneratedImageEvent(record) {
-    if (record['type'] !== 'event_msg' || !isRecord(record['payload']))
-        return undefined;
-    const payload = record['payload'];
-    if (payload['type'] !== 'image_generation_end' ||
-        typeof payload['call_id'] !== 'string' ||
-        typeof payload['saved_path'] !== 'string')
-        return undefined;
-    const localPath = payload['saved_path'];
-    if (!localPath.includes('/.codex/generated_images/') || !/\.(?:png|jpe?g|webp)$/i.test(localPath))
-        return undefined;
-    return {
-        kind: 'tool_call',
-        toolUseId: payload['call_id'],
-        toolName: 'imagegen',
-        input: null,
-        inputSummary: null,
-        inputTruncated: false,
-        outputSummary: payload['status'] === 'completed' ? 'Image generation completed' : 'Image generation failed',
-        outputTruncated: false,
-        toolCategory: 'IMAGE_GENERATION',
-        imageAttachments: [{ name: basename(localPath), mime: imageMime(localPath), localPath }],
-        failed: payload['status'] !== 'completed',
-        createdAt: timestampOf(record)
-    };
-}
-/** Extract Codex output text blocks instead of rendering their JSON envelopes. */
-function codexToolOutput(value) {
-    if (!Array.isArray(value))
-        return value;
-    const text = value.flatMap((block) => {
-        if (typeof block === 'string')
-            return [block];
-        if (!isRecord(block))
-            return [];
-        const direct = firstString(block, ['text', 'content']);
-        return direct === undefined ? [] : [codexVisibleToolText(direct)];
-    });
-    return text.length > 0 ? text.join('') : value;
-}
-function codexVisibleToolText(value) {
-    const marker = 'data:image/';
-    let cursor = 0;
-    let visible = '';
-    while (cursor < value.length) {
-        const start = value.indexOf(marker, cursor);
-        if (start < 0)
-            return visible + value.slice(cursor);
-        visible += `${value.slice(cursor, start)}[Image content filtered]`;
-        const doubleQuote = value.indexOf('"', start);
-        const singleQuote = value.indexOf("'", start);
-        const end = doubleQuote < 0
-            ? singleQuote
-            : singleQuote < 0
-                ? doubleQuote
-                : Math.min(doubleQuote, singleQuote);
-        if (end < 0)
-            return visible;
-        cursor = end;
-    }
-    return visible;
-}
-/** Extract only image placeholder metadata from native Codex output. */
-function codexImagePlaceholders(value) {
-    const attachments = [];
-    let visited = 0;
-    const visit = (current, depth) => {
-        if (attachments.length >= 5 || visited >= 128 || depth > 5 || current == null)
-            return;
-        visited += 1;
-        if (typeof current === 'string') {
-            const paths = [];
-            collectGeneratedImagePaths(current, paths);
-            for (const localPath of paths) {
-                if (attachments.some((attachment) => attachment.localPath === localPath))
-                    continue;
-                attachments.push({ name: basename(localPath), mime: imageMime(localPath), localPath });
-            }
-            return;
-        }
-        if (Array.isArray(current)) {
-            for (const entry of current)
-                visit(entry, depth + 1);
-            return;
-        }
-        if (!isRecord(current))
-            return;
-        const type = typeof current['type'] === 'string' ? current['type'] : '';
-        if (type === 'input_text' && typeof current['text'] === 'string') {
-            const mime = /["']image_url["']\s*:\s*["']data:(image\/[^;,"']+)[;,]/.exec(current['text'])?.[1];
-            if (mime !== undefined)
-                attachments.push({ name: `image-${attachments.length + 1}.${imageExtension(mime)}`, mime });
-        }
-        const imageUrl = isRecord(current['image_url'])
-            ? firstString(current['image_url'], ['url'])
-            : typeof current['image_url'] === 'string'
-                ? current['image_url']
-                : undefined;
-        const data = typeof current['data'] === 'string' ? current['data'] : imageUrl;
-        if ((type === 'image' || type === 'input_image' || type === 'output_image') &&
-            data?.startsWith('data:image/')) {
-            const mime = /^data:([^;,]+)[;,]/.exec(data)?.[1] ?? 'image/png';
-            attachments.push({ name: `image-${attachments.length + 1}.${imageExtension(mime)}`, mime });
-        }
-        for (const child of Object.values(current))
-            visit(child, depth + 1);
-    };
-    visit(value, 0);
-    return attachments;
-}
-function collectGeneratedImagePaths(value, paths) {
-    const marker = '/.codex/generated_images/';
-    let cursor = 0;
-    while (paths.length < 5) {
-        const markerIndex = value.indexOf(marker, cursor);
-        if (markerIndex < 0)
-            return;
-        let start = markerIndex;
-        while (start > 0 && !/[\s"']/.test(value[start - 1]))
-            start -= 1;
-        let end = markerIndex + marker.length;
-        while (end < value.length && !/[\s"']/.test(value[end]))
-            end += 1;
-        const path = value.slice(start, end).replace(/[),.;:]+$/, '');
-        if (/\.(?:png|jpe?g|webp)$/i.test(path) && !paths.includes(path))
-            paths.push(path);
-        cursor = end;
-    }
-}
-function imageMime(path) {
-    const extension = path.slice(path.lastIndexOf('.') + 1).toLowerCase();
-    if (extension === 'jpg' || extension === 'jpeg')
-        return 'image/jpeg';
-    if (extension === 'webp')
-        return 'image/webp';
-    return 'image/png';
-}
-function imageExtension(mime) {
-    if (mime === 'image/jpeg')
-        return 'jpg';
-    if (mime === 'image/webp')
-        return 'webp';
-    if (mime === 'image/gif')
-        return 'gif';
-    return 'png';
-}
-function withToolResult(call, result) {
-    const viewedImagePath = codexViewedImagePath(call);
-    const imageAttachments = result.imageAttachments?.map((attachment) => attachment.localPath !== undefined || viewedImagePath === undefined
-        ? attachment
-        : {
-            name: basename(viewedImagePath),
-            mime: imageMime(viewedImagePath),
-            localPath: viewedImagePath
-        });
-    return {
-        ...call,
-        outputSummary: result.output,
-        outputTruncated: result.truncated,
-        ...(result.claudeResult === undefined ? {} : { claudeResult: result.claudeResult }),
-        ...(imageAttachments === undefined ? {} : { imageAttachments }),
-        failed: result.failed
-    };
-}
-function codexViewedImagePath(call) {
-    const toolName = call.toolName.toLowerCase();
-    if (toolName === 'view_image' || toolName === 'imageview') {
-        return isRecord(call.input) && typeof call.input['path'] === 'string'
-            ? call.input['path']
-            : undefined;
-    }
-    if (toolName !== 'exec' || typeof call.input !== 'string')
-        return undefined;
-    if (!/tools\.view_image\s*\(/.test(call.input))
-        return undefined;
-    const encodedPath = /["']path["']\s*:\s*("(?:\\.|[^"\\])*")/.exec(call.input)?.[1];
-    if (encodedPath === undefined)
-        return undefined;
-    try {
-        const path = JSON.parse(encodedPath);
-        return typeof path === 'string' ? path : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function isInjectedContextPrompt(text) {
-    const normalized = text.replace(/\s+/g, ' ').trim();
-    if (normalized.startsWith('<codex_internal_context'))
-        return true;
-    if (/^<(?:environment_context|subagent_notification|turn_aborted)(?:\s|>)/u.test(normalized))
-        return true;
-    return (normalized.startsWith('# AGENTS.md instructions') &&
-        (normalized.includes('<INSTRUCTIONS>') || normalized.includes('<environment_context>')));
-}
-function isClaudeCompactCommand(record) {
-    return textOf(record)?.trim() === '<command-name>/compact</command-name>';
-}
-function isClaudeCompactSuccess(record) {
-    return textOf(record)?.trim() === '<local-command-stdout>Compacted</local-command-stdout>';
-}
-function isHiddenTranscriptRecord(record) {
-    if (contentBlocks(record).some((block) => block['type'] === 'tool_result'))
-        return false;
-    if (record['interruptedByShutdown'] === true ||
-        record['isMeta'] === true ||
-        record['isVisibleInTranscriptOnly'] === true ||
-        record['isCompactSummary'] === true)
-        return true;
-    const text = textOf(record)?.trim() ?? '';
-    return (text.startsWith('<local-command-') ||
-        text.startsWith('<command-name>') ||
-        text.startsWith('<command-message>'));
-}
-function roleOf(record) {
-    const candidates = [
-        firstString(record, ['role']),
-        nestedString(record, ['message', 'role']),
-        nestedString(record, ['payload', 'role']),
-        firstString(record, ['type']),
-        nestedString(record, ['payload', 'type'])
-    ];
-    if (candidates.some((value) => value === 'user' || value === 'human' || value === 'input'))
-        return 'USER';
-    if (candidates.some((value) => value === 'assistant' || value === 'agent' || value === 'output'))
-        return 'ASSISTANT';
-    return undefined;
-}
-function textOf(record) {
-    return (firstString(record, ['content', 'text']) ??
-        nestedText(record['message']) ??
-        nestedText(record['payload']));
-}
-function nestedText(value) {
-    if (typeof value === 'string')
-        return value;
-    if (!isRecord(value))
-        return undefined;
-    const direct = firstString(value, ['content', 'text', 'message']);
-    if (direct !== undefined)
-        return direct;
-    if (Array.isArray(value['content'])) {
-        const parts = value['content'].flatMap((part) => {
-            if (typeof part === 'string')
-                return [part];
-            if (!isRecord(part))
-                return [];
-            return [firstString(part, ['text', 'content'])].filter((text) => text !== undefined);
-        });
-        return parts.join('\n');
-    }
-    return undefined;
-}
-function contentBlocks(record) {
-    const values = [record['message'], record['payload']];
-    for (const value of values)
-        if (isRecord(value) && Array.isArray(value['content']))
-            return value['content'].filter(isRecord);
-    return [];
-}
-function compactValue(value, limit) {
-    if (value === undefined || value === null)
-        return { text: '', truncated: false };
-    let text;
-    if (typeof value === 'string')
-        text = value;
-    else {
-        try {
-            text = JSON.stringify(value);
-        }
-        catch {
-            return { text: '(Unable to display)', truncated: false };
-        }
-    }
-    return {
-        text: text.length <= limit ? text : `${text.slice(0, Math.max(0, limit - 1))}…`,
-        truncated: text.length > limit
-    };
-}
-function timestampOf(record) {
-    const raw = record['timestamp'] ?? record['created_at'] ?? record['createdAt'];
-    if (typeof raw === 'number' && Number.isFinite(raw))
-        return raw < 10_000_000_000 ? raw * 1_000 : raw;
-    if (typeof raw === 'string') {
-        const value = Date.parse(raw);
-        return Number.isNaN(value) ? null : value;
-    }
-    return null;
-}
-function firstString(value, keys) {
-    for (const key of keys)
-        if (typeof value[key] === 'string' && value[key].length > 0)
-            return value[key];
-    return undefined;
-}
-function nestedString(value, keys) {
-    let current = value;
-    for (const key of keys) {
-        if (!isRecord(current))
-            return undefined;
-        current = current[key];
-    }
-    return typeof current === 'string' && current.length > 0 ? current : undefined;
-}
-function compact(value) {
-    return value.replace(/\s+/g, ' ').trim().slice(0, 16_000);
-}
-/** Conversation content can be Markdown, so its internal whitespace must not be collapsed like a title. */
-function messageText(value) {
-    return value.trim().slice(0, 16_000);
-}
 function canonical(value) {
     try {
         const normalized = resolve(value).replace(/[\\/]+$/, '');
@@ -1177,6 +361,25 @@ function deleteTranscriptIndex(key) {
     transcriptIndexTimers.delete(key);
     transcriptIndex.delete(key);
 }
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
+/** Context-only location: history and deletion keep their existing discovery/index paths. */
+export async function locateNativeSessionPath(runner, workspacePath, externalSessionId) {
+    const wanted = canonical(workspacePath);
+    const key = indexKey(runner, wanted, externalSessionId);
+    let path = getTranscriptIndex(key);
+    if (path !== undefined)
+        return path;
+    const candidates = await nativeTranscriptAdapter(runner)?.locateCandidates?.(externalSessionId);
+    if (candidates !== undefined) {
+        const parsed = await mapConcurrent(candidates, 16, async (path) => ({
+            path,
+            history: await readTranscript(path, runner, DISCOVERY_READ_BYTES)
+        }));
+        const match = parsed.find(({ history }) => history?.externalSessionId === externalSessionId && canonical(history.cwd) === wanted);
+        if (match !== undefined) {
+            setTranscriptIndex(key, match.path);
+            return match.path;
+        }
+    }
+    await discoverNativeSessions(runner, workspacePath);
+    return getTranscriptIndex(key);
 }