spiracha 2.0.0 → 2.2.0

package/src/lib/codex-browser-export.ts

@@ -5,9 +5,10 @@ import { getThreadBrowseData } from './codex-browser-db';
 import type { CodexTranscriptRenderOptions } from './codex-thread-types';
 import { renderCodexSessionFile, writeCodexSessionFileExport } from './codex-transcript-renderer';
 import { applyPathTransforms, type PathDisplaySettings } from './path-transforms';
-import { type ExportFormat, getPortablePathBasename } from './shared';
-import { getExportMimeType, sanitizeExportFileName, zipExportDirectory, zipExportFile } from './ui-export-archive';
+import type { ExportFormat } from './shared';
+import { buildBatchExportBaseName, buildConversationExportBaseName, getExportMimeType } from './ui-export-archive';
 import { buildUiExportDownloadUrl, ensureUiExportDir } from './ui-export-files';
+import { zipExportDirectory, zipExportFile } from './ui-export-zip';
 
 type RenderCodexThreadDownloadInput = {
     dbPath: string;
@@ -42,31 +43,15 @@ export type CodexThreadDownload =
 
 const LARGE_BROWSER_EXPORT_THRESHOLD_BYTES = 128 * 1024 * 1024;
 
-const formatReadableExportDate = (value: number) => {
-    const date = new Date(value);
-    const year = date.getUTCFullYear();
-    const month = String(date.getUTCMonth() + 1).padStart(2, '0');
-    const day = String(date.getUTCDate()).padStart(2, '0');
-    const hours = String(date.getUTCHours()).padStart(2, '0');
-    const minutes = String(date.getUTCMinutes()).padStart(2, '0');
-    return `${year}-${month}-${day}-${hours}${minutes}`;
-};
-
 const buildExportBaseName = (thread: ReturnType<typeof getThreadBrowseData>['thread']) => {
-    const projectName = sanitizeExportFileName(getPortablePathBasename(thread.cwd) || 'thread') || 'thread';
-    const timestamp = thread.updated_at_ms ?? thread.updated_at * 1000;
-    return `${projectName}-${formatReadableExportDate(timestamp)}-${thread.id.slice(0, 8)}`;
-};
-
-const buildBatchExportBaseName = (threads: Array<ReturnType<typeof getThreadBrowseData>['thread']>) => {
-    const firstThread = threads[0];
-    if (!firstThread) {
-        throw new Error('No threads selected for export');
-    }
-
-    const projectName = sanitizeExportFileName(getPortablePathBasename(firstThread.cwd) || 'threads') || 'threads';
-    const latestTimestamp = Math.max(...threads.map((thread) => thread.updated_at_ms ?? thread.updated_at * 1000));
-    return `${projectName}-${formatReadableExportDate(latestTimestamp)}-threads-${threads.length}`;
+    return buildConversationExportBaseName(
+        {
+            cwd: thread.cwd,
+            id: thread.id,
+            updatedAtMs: thread.updated_at_ms ?? thread.updated_at * 1000,
+        },
+        'thread',
+    );
 };
 
 const buildUniqueArchivePath = (exportDir: string, exportBaseName: string) => {
@@ -302,7 +287,13 @@ export const renderCodexThreadsDownload = async (
     const browseEntries = threadIds.map((threadId) => getThreadBrowseData(input.dbPath, threadId));
     const threads = browseEntries.map((entry) => entry.thread);
     const exportDir = await resolvePublicExportDir(input.publicExportDir);
-    const exportBaseName = buildBatchExportBaseName(threads);
+    const exportBaseName = buildBatchExportBaseName(
+        threads.map((thread) => ({
+            cwd: thread.cwd,
+            updatedAtMs: thread.updated_at_ms ?? thread.updated_at * 1000,
+        })),
+        'threads',
+    );
     const bundleDirectory = await createExportWorkspace(exportDir, exportBaseName);
     const zipPath = buildUniqueArchivePath(exportDir, exportBaseName);
     const usedBatchEntryBaseNames = new Set<string>();

package/src/lib/codex-browser-types.ts

@@ -14,6 +14,17 @@ export type DynamicToolRow = DynamicToolDefinition & {
     threadId: string;
 };
 
+export type ThreadGoal = {
+    createdAtMs: number;
+    goalId: string;
+    objective: string;
+    status: string;
+    timeUsedSeconds: number;
+    tokenBudget: number | null;
+    tokensUsed: number;
+    updatedAtMs: number;
+};
+
 export type SessionMetaExtended = SessionMeta & {
     baseInstructions: JsonValue | null;
     dynamicTools: DynamicToolDefinition[];
@@ -165,14 +176,20 @@ export type ThreadListEntry = {
 
 export type ThreadBrowseData = {
     dynamicTools: DynamicToolRow[];
+    goals: ThreadGoal[];
     project: string;
     relations: ThreadRelations;
     thread: ThreadRow;
 };
 
+export type DashboardThreadSummary = Pick<
+    ThreadRow,
+    'cwd' | 'id' | 'model' | 'preview' | 'title' | 'tokens_used' | 'updated_at' | 'updated_at_ms'
+>;
+
 export type DashboardRecentThread = {
     project: string;
-    thread: ThreadRow;
+    thread: DashboardThreadSummary;
 };
 
 export type DashboardSummary = {
@@ -232,6 +249,7 @@ export type CodexAnalyticsSummary = {
     archivedThreads: number;
     averageTokensPerThread: number;
     distinctToolNames: number;
+    medianTokensPerThread: number;
     threadsWithWebSearch: number;
     totalProjects: number;
     totalThreads: number;
@@ -240,6 +258,8 @@ export type CodexAnalyticsSummary = {
 
 export type CodexAnalytics = {
     modelsByTokens: ModelTokenSummary[];
+    reasoningEfforts: DistributionItem[];
+    sources: DistributionItem[];
     summary: CodexAnalyticsSummary;
     toolUsage: ToolUsageSummary[];
 };

package/src/lib/codex-thread-cache.ts

@@ -1,24 +1,85 @@
 import { stat } from 'node:fs/promises';
 import path from 'node:path';
-import type { ParsedCodexTranscript } from './codex-browser-types';
+import type { ParsedCodexTranscript, ThreadTranscriptStats } from './codex-browser-types';
 import { parseCodexTranscriptFile } from './codex-thread-parser';
-import { getFileFingerprint, hashCacheKeyParts, withCachedJson } from './ui-cache';
+import type { CodexTranscriptEventFilters } from './codex-transcript-filter';
+import { shouldShowCodexTranscriptEvent } from './codex-transcript-filter';
+import { runWithTranscriptLoadLimit } from './transcript-load-limiter';
+import { getFileFingerprint, hashCacheKeyPartsIterable, withCachedJson } from './ui-cache';
 
-export const LARGE_THREAD_SIZE_BYTES = 100 * 1024 * 1024;
+// Keep initial thread payloads below sizes that make TanStack Start SSR responses unreliable.
+export const LARGE_THREAD_SIZE_BYTES = 8 * 1024 * 1024;
 export const LARGE_THREAD_PREVIEW_EVENT_LIMIT = 200;
+const CODEX_TRANSCRIPT_CACHE_VERSION = 'v3';
+const CODEX_TRANSCRIPT_STATS_CACHE_VERSION = 'v1';
+const FILE_STABILITY_ATTEMPTS = 3;
+
+type CodexTranscriptStatsLoader = (sessionFile: string) => Promise<ThreadTranscriptStats>;
 
 const isMissingFileError = (error: unknown) => {
     return error instanceof Error && 'code' in error && error.code === 'ENOENT';
 };
 
+const withStableFileCache = async <T>(
+    sessionFile: string,
+    keyForFingerprint: (fingerprint: string) => string,
+    loader: () => Promise<T>,
+): Promise<T> => {
+    for (let attempt = 0; attempt < FILE_STABILITY_ATTEMPTS; attempt += 1) {
+        const fingerprint = await getFileFingerprint(sessionFile);
+        const value = await withCachedJson(keyForFingerprint(fingerprint), loader);
+        if ((await getFileFingerprint(sessionFile)) === fingerprint) {
+            return value;
+        }
+    }
+
+    throw new Error(`Codex rollout changed repeatedly while loading: ${sessionFile}`);
+};
+
 export const getCachedParsedCodexTranscript = async (sessionFile: string): Promise<ParsedCodexTranscript> => {
-    const fingerprint = await getFileFingerprint(sessionFile);
-    const key = `thread-${hashCacheKeyParts(path.basename(sessionFile), fingerprint)}`;
+    return withStableFileCache(
+        sessionFile,
+        (fingerprint) =>
+            `thread-${hashCacheKeyPartsIterable([CODEX_TRANSCRIPT_CACHE_VERSION, path.basename(sessionFile), fingerprint])}`,
+        async () =>
+            runWithTranscriptLoadLimit(() => parseCodexTranscriptFile(sessionFile), {
+                path: sessionFile,
+                source: 'codex-full',
+            }),
+    );
+};
 
-    return withCachedJson(key, async () => parseCodexTranscriptFile(sessionFile));
+const loadCodexTranscriptStats: CodexTranscriptStatsLoader = async (sessionFile) => {
+    const transcript = await parseCodexTranscriptFile(sessionFile, {
+        includeRaw: false,
+        maxTurnContexts: 0,
+    });
+
+    return transcript.stats;
+};
+
+export const getCachedCodexTranscriptStats = async (
+    sessionFile: string,
+    loadStats: CodexTranscriptStatsLoader = loadCodexTranscriptStats,
+): Promise<ThreadTranscriptStats> => {
+    return withStableFileCache(
+        sessionFile,
+        (fingerprint) =>
+            `thread-list-stats-${hashCacheKeyPartsIterable([
+                CODEX_TRANSCRIPT_STATS_CACHE_VERSION,
+                path.basename(sessionFile),
+                fingerprint,
+            ])}`,
+        () =>
+            runWithTranscriptLoadLimit(() => loadStats(sessionFile), {
+                path: sessionFile,
+                source: 'codex-list-stats',
+            }),
+    );
 };
 
 type CachedThreadTranscriptPreviewOptions = {
+    filters?: CodexTranscriptEventFilters;
     largeTranscriptThresholdBytes?: number;
     previewEventLimit?: number;
 };
@@ -53,22 +114,44 @@ export const getCachedThreadTranscriptPreview = async (
 ): Promise<ParsedCodexTranscript> => {
     const threshold = options.largeTranscriptThresholdBytes ?? LARGE_THREAD_SIZE_BYTES;
     const previewEventLimit = options.previewEventLimit ?? LARGE_THREAD_PREVIEW_EVENT_LIMIT;
-    const fingerprint = await getFileFingerprint(sessionFile);
-    const { fileSizeBytes, shouldDeferTranscriptLoad } = await getThreadRolloutLoadState(sessionFile, threshold);
-    const key = `thread-preview-${hashCacheKeyParts(path.basename(sessionFile), fingerprint, String(threshold), String(previewEventLimit))}`;
-
-    return withCachedJson(key, async () => {
-        if (!shouldDeferTranscriptLoad) {
-            return parseCodexTranscriptFile(sessionFile, {
-                sourceFileSizeBytes: fileSizeBytes,
-            });
-        }
+    const filters = options.filters;
+    const filterKey = filters ? JSON.stringify(filters) : 'all';
+    return withStableFileCache(
+        sessionFile,
+        (fingerprint) =>
+            `thread-preview-${hashCacheKeyPartsIterable([CODEX_TRANSCRIPT_CACHE_VERSION, path.basename(sessionFile), fingerprint, String(threshold), String(previewEventLimit), filterKey])}`,
+        async () => {
+            const { fileSizeBytes, shouldDeferTranscriptLoad } = await getThreadRolloutLoadState(
+                sessionFile,
+                threshold,
+            );
+            if (!shouldDeferTranscriptLoad) {
+                return runWithTranscriptLoadLimit(
+                    () =>
+                        parseCodexTranscriptFile(sessionFile, {
+                            sourceFileSizeBytes: fileSizeBytes,
+                        }),
+                    {
+                        path: sessionFile,
+                        source: 'codex-preview-full',
+                    },
+                );
+            }
 
-        return parseCodexTranscriptFile(sessionFile, {
-            includeRaw: false,
-            maxEvents: previewEventLimit,
-            maxTurnContexts: 0,
-            sourceFileSizeBytes: fileSizeBytes,
-        });
-    });
+            return runWithTranscriptLoadLimit(
+                () =>
+                    parseCodexTranscriptFile(sessionFile, {
+                        eventFilter: filters ? (event) => shouldShowCodexTranscriptEvent(event, filters) : undefined,
+                        includeRaw: false,
+                        maxTurnContexts: 0,
+                        sourceFileSizeBytes: fileSizeBytes,
+                        tailEventLimit: previewEventLimit,
+                    }),
+                {
+                    path: sessionFile,
+                    source: 'codex-preview',
+                },
+            );
+        },
+    );
 };

package/src/lib/codex-thread-parser.ts

@@ -14,13 +14,29 @@ import type {
     TurnContextRecord,
     WebSearchEvent,
 } from './codex-browser-types';
-import { asNumber, asObject, asString, type JsonValue, readJsonlObjects } from './shared';
+import { asNumber, asObject, asString, type JsonValue, readJsonlObjects, stripCodexAppDirectiveLines } from './shared';
 
 type ParseCodexTranscriptOptions = {
+    eventFilter?: (event: ThreadEvent) => boolean;
     includeRaw?: boolean;
     maxEvents?: number;
     maxTurnContexts?: number;
     sourceFileSizeBytes?: number | null;
+    tailEventLimit?: number;
+};
+
+type ParseCodexTranscriptState = {
+    events: ThreadEvent[];
+    eventFilter: (event: ThreadEvent) => boolean;
+    includeRaw: boolean;
+    maxEvents: number;
+    maxTurnContexts: number;
+    sequence: number;
+    shouldStop: boolean;
+    tailEventCursor: number;
+    tailEventLimit: number;
+    tailEventsWrapped: boolean;
+    turnContexts: TurnContextRecord[];
 };
 
 const createEmptyStats = (): ThreadTranscriptStats => {
@@ -64,45 +80,88 @@ export const parseCodexTranscriptFile = async (
     const includeRaw = options.includeRaw ?? true;
     const maxEvents = options.maxEvents ?? Number.POSITIVE_INFINITY;
     const maxTurnContexts = options.maxTurnContexts ?? Number.POSITIVE_INFINITY;
-    let sequence = 0;
+    const tailEventLimit = options.tailEventLimit ?? Number.POSITIVE_INFINITY;
+    const eventFilter = options.eventFilter ?? (() => true);
+    const state: ParseCodexTranscriptState = {
+        eventFilter,
+        events,
+        includeRaw,
+        maxEvents,
+        maxTurnContexts,
+        sequence: 0,
+        shouldStop: false,
+        tailEventCursor: 0,
+        tailEventLimit,
+        tailEventsWrapped: false,
+        turnContexts,
+    };
 
     for await (const parsed of readJsonlObjects(sessionFile)) {
         captureSessionMeta(parsed, sessionMeta);
-        const topLevelType = asString(parsed.type);
-
-        if (topLevelType === 'turn_context') {
-            if (turnContexts.length < maxTurnContexts) {
-                captureTurnContext(parsed, turnContexts);
-            }
-            continue;
+        captureTranscriptRecord(parsed, state);
+        if (state.shouldStop) {
+            break;
         }
+    }
 
-        const event = toThreadEvent(parsed, sequence, includeRaw);
-        if (!event) {
-            continue;
-        }
+    if (state.tailEventsWrapped && events.length > 0) {
+        events.splice(
+            0,
+            events.length,
+            ...events.slice(state.tailEventCursor),
+            ...events.slice(0, state.tailEventCursor),
+        );
+    }
 
-        events.push(event);
+    for (const event of events) {
         updateTranscriptStats(stats, event);
-        sequence += 1;
-
-        if (events.length >= maxEvents) {
-            break;
-        }
     }
 
     return {
         events,
-        isPartial: Number.isFinite(maxEvents) || Number.isFinite(maxTurnContexts),
+        isPartial:
+            Number.isFinite(maxEvents) ||
+            Number.isFinite(maxTurnContexts) ||
+            Number.isFinite(tailEventLimit) ||
+            options.eventFilter !== undefined,
         rawIncluded: includeRaw,
         sessionMeta,
         sourceFileSizeBytes: options.sourceFileSizeBytes ?? null,
         stats,
-        statsArePartial: Number.isFinite(maxEvents),
+        statsArePartial:
+            Number.isFinite(maxEvents) || Number.isFinite(tailEventLimit) || options.eventFilter !== undefined,
         turnContexts,
     };
 };
 
+const captureTranscriptRecord = (parsed: Record<string, JsonValue>, state: ParseCodexTranscriptState) => {
+    if (asString(parsed.type) === 'turn_context') {
+        if (state.turnContexts.length < state.maxTurnContexts) {
+            captureTurnContext(parsed, state.turnContexts);
+        }
+        return;
+    }
+
+    const event = parseCodexTranscriptRecord(parsed, state.sequence, state.includeRaw);
+    if (!event) {
+        return;
+    }
+
+    state.sequence += 1;
+    if (!state.eventFilter(event)) {
+        return;
+    }
+
+    if (!Number.isFinite(state.tailEventLimit) || state.events.length < state.tailEventLimit) {
+        state.events.push(event);
+    } else if (state.tailEventLimit > 0) {
+        state.events[state.tailEventCursor] = event;
+        state.tailEventCursor = (state.tailEventCursor + 1) % state.tailEventLimit;
+        state.tailEventsWrapped = true;
+    }
+    state.shouldStop = state.events.length >= state.maxEvents;
+};
+
 const captureSessionMeta = (parsed: Record<string, JsonValue>, sessionMeta: SessionMetaExtended) => {
     if (parsed.type !== 'session_meta') {
         return;
@@ -161,10 +220,10 @@ const captureTurnContext = (parsed: Record<string, JsonValue>, turnContexts: Tur
     });
 };
 
-const toThreadEvent = (
+export const parseCodexTranscriptRecord = (
     parsed: Record<string, JsonValue>,
-    sequence: number,
-    includeRaw: boolean,
+    sequence = 0,
+    includeRaw = false,
 ): ThreadEvent | null => {
     const payload = asObject(parsed.payload);
     if (!payload) {
@@ -192,15 +251,7 @@ const buildEventMessage = (
     sequence: number,
     timestamp: string | null,
 ) => {
-    if (payloadType === 'task_started') {
-        return createTaskStartedEvent(payload, raw, sequence, timestamp);
-    }
-
-    if (payloadType === 'task_complete') {
-        return createTaskCompleteEvent(payload, raw, sequence, timestamp);
-    }
-
-    return null;
+    return buildSupplementalEvent(payload, payloadType, raw, sequence, timestamp);
 };
 
 const buildResponseItemEvent = (
@@ -222,11 +273,11 @@ const buildResponseItemEvent = (
         return createAgentMessageEvent(payload, raw, sequence, timestamp);
     }
 
-    if (payloadType === 'function_call') {
-        return createToolCallEvent(payload, raw, sequence, timestamp);
+    if (payloadType === 'function_call' || payloadType === 'custom_tool_call') {
+        return createToolCallEvent(payload, raw, sequence, timestamp, payloadType === 'custom_tool_call');
     }
 
-    if (payloadType === 'function_call_output') {
+    if (payloadType === 'function_call_output' || payloadType === 'custom_tool_call_output') {
         return createToolOutputEvent(payload, raw, sequence, timestamp);
     }
 
@@ -234,6 +285,16 @@ const buildResponseItemEvent = (
         return createReasoningEvent(payload, raw, sequence, timestamp);
     }
 
+    return buildSupplementalEvent(payload, payloadType, raw, sequence, timestamp);
+};
+
+const buildSupplementalEvent = (
+    payload: Record<string, JsonValue>,
+    payloadType: string | null,
+    raw: Record<string, JsonValue>,
+    sequence: number,
+    timestamp: string | null,
+) => {
     if (payloadType === 'token_count') {
         return createTokenCountEvent(payload, raw, sequence, timestamp);
     }
@@ -261,12 +322,13 @@ const createMessageEvent = (
 ): MessageEvent | null => {
     const role = asString(payload.role);
     const content = payload.content;
-    if (!role || content === undefined) {
+    const text = extractText(content);
+    if (!role || content === undefined || !text.trim()) {
         return null;
     }
 
     return {
-        isHiddenByDefault: shouldHideTranscriptText(role, extractText(content)),
+        isHiddenByDefault: shouldHideCodexTranscriptText(role, text),
         kind: 'message',
         memoryCitation: null,
         model: asString(payload.model),
@@ -274,7 +336,7 @@ const createMessageEvent = (
         raw,
         role,
         sequence,
-        text: extractText(content),
+        text,
         timestamp,
         variant: 'message',
     };
@@ -286,8 +348,9 @@ const createUserMessageEvent = (
     sequence: number,
     timestamp: string | null,
 ): MessageEvent => {
+    const text = stripCodexMemoryCitationBlocks(asString(payload.message) ?? '');
     return {
-        isHiddenByDefault: shouldHideTranscriptText('user', asString(payload.message)?.trim() ?? ''),
+        isHiddenByDefault: shouldHideCodexTranscriptText('user', text),
         kind: 'message',
         memoryCitation: null,
         model: null,
@@ -295,7 +358,7 @@ const createUserMessageEvent = (
         raw,
         role: 'user',
         sequence,
-        text: asString(payload.message)?.trim() ?? '',
+        text,
         timestamp,
         variant: 'user_message',
     };
@@ -307,8 +370,9 @@ const createAgentMessageEvent = (
     sequence: number,
     timestamp: string | null,
 ): MessageEvent => {
+    const text = stripCodexMemoryCitationBlocks(asString(payload.message) ?? '');
     return {
-        isHiddenByDefault: false,
+        isHiddenByDefault: shouldHideCodexTranscriptText('assistant', text),
         kind: 'message',
         memoryCitation: payload.memory_citation ?? null,
         model: asString(payload.model),
@@ -316,7 +380,7 @@ const createAgentMessageEvent = (
         raw,
         role: 'assistant',
         sequence,
-        text: asString(payload.message)?.trim() ?? '',
+        text,
         timestamp,
         variant: 'agent_message',
     };
@@ -327,10 +391,13 @@ const createToolCallEvent = (
     raw: Record<string, JsonValue>,
     sequence: number,
     timestamp: string | null,
+    isCustomToolCall: boolean,
 ): ToolCallEvent => {
     const name = asString(payload.name) ?? 'unknown';
-    const argumentsText = asString(payload.arguments);
-    const parsedArguments = parseExecCommandArguments(argumentsText);
+    const argumentsText = asString(isCustomToolCall ? payload.input : payload.arguments);
+    const parsedArguments = isCustomToolCall
+        ? { argumentsParseFailed: false, cmd: argumentsText, workdir: null }
+        : parseExecCommandArguments(argumentsText);
 
     return {
         argumentsParseFailed: parsedArguments.argumentsParseFailed,
@@ -352,7 +419,7 @@ const createToolOutputEvent = (
     sequence: number,
     timestamp: string | null,
 ): ToolOutputEvent => {
-    const outputText = asString(payload.output) ?? '';
+    const outputText = extractToolOutputText(payload.output);
 
     return {
         callId: asString(payload.call_id),
@@ -478,7 +545,7 @@ const updateTranscriptStats = (stats: ThreadTranscriptStats, event: ThreadEvent)
 
     if (event.kind === 'tool_call') {
         stats.toolCallCount += 1;
-        if (event.name === 'exec_command') {
+        if (event.name === 'exec' || event.name === 'exec_command') {
             stats.execCommandCount += 1;
         }
         return;
@@ -546,26 +613,52 @@ const parseExecCommandArguments = (argumentsText: string | null) => {
     }
 };
 
+const extractToolOutputText = (output: JsonValue | undefined): string => {
+    if (typeof output === 'string') {
+        return output;
+    }
+
+    if (!Array.isArray(output)) {
+        return '';
+    }
+
+    return output
+        .map((entry) => {
+            const contentBlock = asObject(entry);
+            return contentBlock ? asString(contentBlock.text) : null;
+        })
+        .filter((entry): entry is string => entry !== null)
+        .join('\n');
+};
+
 const extractText = (content: JsonValue): string => {
     if (typeof content === 'string') {
-        return content.trim();
+        return stripCodexMemoryCitationBlocks(content);
     }
 
     if (Array.isArray(content)) {
-        return content
-            .map((entry) => extractTextPart(entry))
-            .filter(Boolean)
-            .join('\n\n')
-            .trim();
+        return stripCodexMemoryCitationBlocks(
+            content
+                .map((entry) => extractTextPart(entry))
+                .filter(Boolean)
+                .join('\n\n'),
+        );
     }
 
     if (content && typeof content === 'object') {
-        return asString((content as Record<string, JsonValue>).text)?.trim() ?? '';
+        return stripCodexMemoryCitationBlocks(asString((content as Record<string, JsonValue>).text) ?? '');
     }
 
     return '';
 };
 
+export const stripCodexMemoryCitationBlocks = (text: string): string => {
+    const withoutMemoryCitations = text.includes('<oai-mem-citation>')
+        ? text.replace(/<oai-mem-citation>[\s\S]*?<\/oai-mem-citation>/gu, '')
+        : text;
+    return stripCodexAppDirectiveLines(withoutMemoryCitations);
+};
+
 const extractTextPart = (entry: JsonValue): string => {
     const objectValue = asObject(entry);
     if (!objectValue) {
@@ -582,7 +675,7 @@ const extractTextPart = (entry: JsonValue): string => {
     return text ?? '';
 };
 
-const shouldHideTranscriptText = (role: string, text: string) => {
+export const shouldHideCodexTranscriptText = (role: string, text: string) => {
     if (!text) {
         return true;
     }
@@ -593,6 +686,7 @@ const shouldHideTranscriptText = (role: string, text: string) => {
 
     return (
         text.startsWith('# AGENTS.md instructions for ') ||
+        text.startsWith('AGENTS.md instructions for ') ||
         text.startsWith('<permissions instructions>') ||
         text.startsWith('<app-context>') ||
         text.startsWith('<environment_context>') ||