@memorax/memorax-code 0.1.7 → 0.1.8

package/lib/memorax-code-backend/dist/viewer/store.js

@@ -1,991 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { resolve } from "node:path";
-import { clearClaudeLocalTranscriptProjections, readClaudeLocalTranscriptHistory, } from "./history/claude-transcript.js";
-import { stripCodexPreambleSegments } from "../clients/codex/effective-prompt.js";
-import { clearIncrementalJsonlProjections, readIncrementalJsonlProjectionSnapshot, } from "../shared/incremental-jsonl-projection.js";
-import { clearMemoryViewerDataProjectionCache, clearMemoryViewerDataProjections, memoryViewerDataProjectionCacheSize, prepareMemoryViewerDataProjectionHistory, readMemoryViewerDataProjection, shareMemoryViewerDataProjectionValue, shouldCacheMemoryViewerDataProjection, writeMemoryViewerDataProjection, } from "./projection/cache.js";
-import { memoryViewerActivityProjection, memoryViewerActivitySummary, } from "./projection/activity.js";
-import { memoryViewerEventKey } from "./projection/event-identity.js";
-import { memoryViewerEventTurnIds } from "./projection/turn-reference.js";
-import { foldMemoryViewerSupersededTurnStarts, foldMemoryViewerTurnMaterializations, } from "./projection/history.js";
-import { memoryProjectFromUnknown, resolveMemoryProject, UNCLASSIFIED_PROJECT_ID, } from "../memory/project.js";
-import { sanitizeMemoryViewerDetails } from "./projection/redaction.js";
-import { earliestMemoryViewerSessionTitleCandidates, } from "./history/session-title.js";
-import { projectMemoryViewerUserData } from "./projection/user.js";
-import { completeMemoryViewerWriteback, foldMemoryViewerWritebackStatuses, memoryText, memoryViewerWritebackOutcome, nonNegativeInteger, pendingMemoryViewerWritebacks, stringArray, writebackOutcomeForStatus, } from "./projection/writeback-status.js";
-import { clientTracePaths, tracePaths } from "../trace/config.js";
-export { completeMemoryViewerWriteback, memoryViewerEventTurnIds, pendingMemoryViewerWritebacks, };
-const CAPACITY = 200;
-const TURN_CAPACITY = 50;
-export const MEMORY_VIEWER_UNSCOPED_SESSION_FILTER = "__unscoped__";
-const events = [];
-let liveEventsVersion = 0;
-const combinedTraceHistories = new Map();
-const EMPTY_MEMORY_VIEWER_HISTORY = Object.freeze([]);
-const claudeTranscriptSources = new Map();
-export function recordMemoryViewerEvent(input) {
-    const client = memoryViewerClient(input);
-    if (!client)
-        return undefined;
-    const response = record(input.response);
-    const request = record(input.request);
-    const items = arrayValue(response?.items);
-    const query = searchQuery(request);
-    const results = searchResults(items);
-    const traceSessionId = sessionId(input.traceContext?.sessionId);
-    const traceTurnId = safeMemoryViewerTurnId(input.traceContext?.turnId);
-    const turnReferences = client === "claude"
-        ? memoryViewerTurnReferences(input.relatedTurns, input.traceContext)
-        : [];
-    const projectIdentity = memoryProjectFromUnknown(input.traceContext?.memoryProject)
-        ?? resolveMemoryProject(input.traceContext?.cwd);
-    const writeback = writebackState(input.operation, response);
-    const conversation = writebackConversation(input.operation, request);
-    const id = memoryViewerEventId(client, input.eventId);
-    const event = {
-        id,
-        eventKey: memoryViewerEventKey({
-            id,
-            client,
-            ...(traceSessionId ? { sessionId: traceSessionId } : {}),
-        }),
-        client,
-        type: memoryEventType(input.source, input.operation),
-        timestamp: new Date().toISOString(),
-        source: input.source,
-        operation: input.operation,
-        ok: input.ok,
-        ...viewerProjectFields(projectIdentity),
-        ...(traceSessionId ? { sessionId: traceSessionId } : {}),
-        ...(traceTurnId ? { turnId: traceTurnId } : {}),
-        ...(turnReferences.length > 0 ? { turnReferences } : {}),
-        content: eventContent(input.operation, request, response, items, input.error),
-        ...(conversation.prompt ? { prompt: conversation.prompt } : {}),
-        ...(conversation.answer ? { answer: conversation.answer } : {}),
-        ...(query ? { query } : {}),
-        ...(results.length > 0 ? { results } : {}),
-        ...(items.length > 0 ? { itemCount: items.length } : {}),
-        ...(stringValue(response?.receiptId) ? { receiptId: stringValue(response?.receiptId) } : {}),
-        ...(writeback.taskId ? { taskId: writeback.taskId } : {}),
-        ...(writeback.status ? { writebackStatus: writeback.status } : {}),
-        ...(writeback.status ? { writebackOutcome: writebackOutcomeForStatus(writeback.status) } : {}),
-        ...(input.error ? { error: input.error.slice(0, 2000) } : {}),
-        details: sanitizeMemoryViewerDetails({ request: input.request, response: input.response }),
-    };
-    events.push(event);
-    while (events.length > CAPACITY)
-        events.shift();
-    liveEventsVersion += 1;
-    clearMemoryViewerDataProjections();
-    return event;
-}
-export function listMemoryViewerEvents() {
-    return events.map((event) => structuredClone(event));
-}
-export async function listMemoryViewerEventsWithHistory(memoraxCodeHome) {
-    return (await listMemoryViewerDataWithHistory(memoraxCodeHome)).events;
-}
-export async function listMemoryViewerDataWithHistory(memoraxCodeHome, filter = {}, dependencies = {}) {
-    const claudeProjectsRoot = claudeTranscriptRoot(dependencies.claudeProjectsRoot);
-    observeClaudeTranscriptSource(memoraxCodeHome, claudeProjectsRoot);
-    const historicalSnapshot = await readTraceHistory(memoraxCodeHome, dependencies.resolveProject ?? resolveMemoryProject, filter.client, claudeProjectsRoot);
-    const historical = historicalSnapshot.values;
-    const projectionKey = memoryViewerProjectionKey(memoraxCodeHome, filter.client);
-    prepareMemoryViewerDataProjectionHistory(projectionKey, historical);
-    const filterKey = memoryViewerHistoryFilterKey(filter);
-    const cached = readMemoryViewerDataProjection(projectionKey, filterKey, historical, liveEventsVersion);
-    if (cached)
-        return structuredClone(cached);
-    const merged = new Map();
-    const liveEvents = filter.client
-        ? events.filter((event) => event.client === filter.client)
-        : events;
-    for (const event of [...historical, ...liveEvents])
-        merged.set(event.eventKey, event);
-    const traceEvents = [...merged.values()];
-    const claudeTranscriptAdmission = admitClaudeTranscriptEvents(traceEvents, historicalSnapshot.claudeLocal);
-    const associatedEvents = associateClaudeEventsWithTranscriptTurns(coalesceClaudeTranscriptTurns(traceEvents, claudeTranscriptAdmission.events), historicalSnapshot.claudeLocal, claudeTranscriptAdmission.turnScopes);
-    const coalescedEvents = coalesceClaudeTranscriptActivities(associatedEvents);
-    const allEvents = foldMemoryViewerSupersededTurnStarts(foldMemoryViewerTurnMaterializations(foldMemoryViewerWritebackStatuses(coalescedEvents.sort(compareMemoryViewerEvents))));
-    const selectionCatalogEvents = allEvents.filter(memoryViewerEventVisible);
-    const catalogEvents = selectionCatalogEvents;
-    const catalogWindow = catalogEvents.slice(-CAPACITY);
-    const projects = projectCatalog(catalogWindow);
-    const projectSessions = projectSessionCatalog(catalogWindow);
-    const hasUnclassified = catalogWindow.some((event) => !event.projectId);
-    const selectableEvents = filter.includePendingWritebacks
-        ? allEvents.filter((event) => memoryViewerEventVisible(event)
-            || (event.operation === "writeback" && event.writebackOutcome === "pending"))
-        : catalogEvents;
-    const activitySelectionProjects = filter.includePendingWritebacks
-        ? projectCatalog(selectableEvents)
-        : projectCatalog(selectionCatalogEvents);
-    const activitySelectionHasUnclassified = filter.includePendingWritebacks
-        ? selectableEvents.some((event) => !event.projectId)
-        : selectionCatalogEvents.some((event) => !event.projectId);
-    const activityProjects = activitySelectionProjects;
-    const activityProjection = memoryViewerActivityProjection(selectableEvents);
-    const activityProjectSessions = activityProjection.projectSessions;
-    const selection = resolveProjectSelection(activitySelectionProjects, activitySelectionHasUnclassified, filter.projectId, filter.rejectProjectFilter === true);
-    const activeSessionSince = filter.activeSessionSince;
-    const scopedEvents = (selection.blockAll ? [] : selectableEvents)
-        .filter((event) => !filter.eventKey || event.eventKey === filter.eventKey)
-        .filter((event) => !filter.unscopedSession && !filter.sessionId
-        ? true
-        : filter.unscopedSession
-            ? !event.sessionId
-            : event.sessionId === filter.sessionId)
-        .filter((event) => !selection.projectId
-        ? true
-        : selection.projectId === UNCLASSIFIED_PROJECT_ID
-            ? !event.projectId
-            : event.projectId === selection.projectId);
-    const explicitSession = Boolean(filter.sessionId || filter.unscopedSession);
-    const explicitSessionHasRecentActivity = activeSessionSince !== undefined
-        && explicitSession
-        && scopedEvents.some((event) => ((activityProjection.eventActivityOrder.get(event.eventKey) ?? Number.NEGATIVE_INFINITY) >= activeSessionSince));
-    // Active scopes contain complete Turns started inside the window plus recent standalone events.
-    // Explicit stale sessions retain historical access.
-    const filteredEvents = activeSessionSince === undefined || (explicitSession && !explicitSessionHasRecentActivity)
-        ? scopedEvents
-        : scopedEvents.filter((event) => ((activityProjection.eventActivityOrder.get(event.eventKey) ?? Number.NEGATIVE_INFINITY) >= activeSessionSince));
-    const eventWindow = filteredEvents.slice(-CAPACITY);
-    const data = {
-        events: eventWindow.map((event) => structuredClone(event)),
-        turnEvents: completeTurnEventWindow(filteredEvents, TURN_CAPACITY, eventWindow)
-            .map((event) => structuredClone(event)),
-        activitySummary: memoryViewerActivitySummary(filteredEvents),
-        catalogSourceEvents: selectableEvents.slice(-CAPACITY).map((event) => structuredClone(event)),
-        sessionTitleCandidates: shareMemoryViewerDataProjectionValue(projectionKey, `session-titles:${filter.includePendingWritebacks === true}`, historical, liveEventsVersion, () => earliestMemoryViewerSessionTitleCandidates(selectableEvents)),
-        projects,
-        projectSessions,
-        hasUnclassified,
-        activityProjects,
-        activityProjectSessions,
-        ...(filter.includeUserProjection
-            ? { userProjection: projectMemoryViewerUserData(filteredEvents) }
-            : {}),
-        ...(selection.projectId ? { selectedProjectId: selection.projectId } : {}),
-        ...(selection.status ? { projectFilterStatus: selection.status } : {}),
-    };
-    if (shouldCacheMemoryViewerDataProjection(filter, data)) {
-        writeMemoryViewerDataProjection(projectionKey, filterKey, historical, liveEventsVersion, data);
-    }
-    return structuredClone(data);
-}
-function completeTurnEventWindow(allEvents, capacity, requiredEvents = []) {
-    const turns = new Map();
-    for (const event of allEvents) {
-        if (!event.sessionId)
-            continue;
-        const timestamp = Date.parse(event.timestamp);
-        const order = Number.isFinite(timestamp) ? timestamp : 0;
-        for (const turnId of memoryViewerEventTurnIds(event)) {
-            const key = `${event.client}\u0000${event.sessionId}\u0000${turnId}`;
-            const current = turns.get(key);
-            if (!current) {
-                turns.set(key, {
-                    startedAt: event.type === "turn_start" ? order : Number.NEGATIVE_INFINITY,
-                    firstSeenAt: order,
-                });
-                continue;
-            }
-            current.firstSeenAt = Math.min(current.firstSeenAt, order);
-            if (event.type === "turn_start")
-                current.startedAt = order;
-        }
-    }
-    const selected = new Set([...turns.entries()]
-        .sort((left, right) => {
-        const leftOrder = Number.isFinite(left[1].startedAt) ? left[1].startedAt : left[1].firstSeenAt;
-        const rightOrder = Number.isFinite(right[1].startedAt) ? right[1].startedAt : right[1].firstSeenAt;
-        return leftOrder - rightOrder || left[0].localeCompare(right[0]);
-    })
-        .slice(-capacity)
-        .map(([key]) => key));
-    for (const event of requiredEvents) {
-        if (!event.sessionId)
-            continue;
-        for (const turnId of memoryViewerEventTurnIds(event)) {
-            selected.add(`${event.client}\u0000${event.sessionId}\u0000${turnId}`);
-        }
-    }
-    return allEvents.filter((event) => (Boolean(event.sessionId)
-        && memoryViewerEventTurnIds(event).some((turnId) => (selected.has(`${event.client}\u0000${event.sessionId}\u0000${turnId}`)))));
-}
-export function clearMemoryViewerEvents() {
-    events.length = 0;
-    liveEventsVersion += 1;
-    combinedTraceHistories.clear();
-    claudeTranscriptSources.clear();
-    clearClaudeLocalTranscriptProjections();
-    clearIncrementalJsonlProjections();
-    clearMemoryViewerDataProjectionCache();
-}
-function claudeTranscriptRoot(configuredRoot) {
-    return typeof configuredRoot === "string" && configuredRoot.trim()
-        ? resolve(configuredRoot.trim())
-        : false;
-}
-function observeClaudeTranscriptSource(memoraxCodeHome, source) {
-    const key = resolve(memoraxCodeHome);
-    const previous = claudeTranscriptSources.get(key);
-    claudeTranscriptSources.set(key, source);
-    if (previous === undefined || previous === source)
-        return;
-    clearClaudeLocalTranscriptProjections();
-    for (const cacheKey of combinedTraceHistories.keys()) {
-        if (cacheKey === key || cacheKey.startsWith(`${key}\u0000`)) {
-            combinedTraceHistories.delete(cacheKey);
-        }
-    }
-    clearMemoryViewerDataProjections();
-}
-export function memoryViewerDataProjectionCount(memoraxCodeHome) {
-    return memoryViewerDataProjectionCacheSize(tracePaths(memoraxCodeHome).sessionsRoot);
-}
-function memoryViewerHistoryFilterKey(filter) {
-    return JSON.stringify([
-        filter.client ?? "",
-        filter.includePendingWritebacks === true,
-        filter.eventKey ?? "",
-        filter.sessionId ?? "",
-        filter.unscopedSession === true,
-        filter.projectId ?? "",
-        filter.rejectProjectFilter === true,
-        filter.activeSessionSince ?? null,
-        filter.includeUserProjection === true,
-    ]);
-}
-export function memoryViewerEventVisible(event) {
-    return isMemoryViewerEventType(event.type) && event.type !== "memory_writeback_status"
-        && event.type !== "turn_materialized";
-}
-function eventContent(operation, request, response, items, error) {
-    if (error)
-        return error;
-    if (operation === "writeback") {
-        const payload = record(request?.payload);
-        const messages = arrayValue(payload?.messages);
-        const contents = messages.map((message) => stringValue(record(message)?.content)).filter(Boolean);
-        return contents.join("\n\n") || "Memory writeback accepted.";
-    }
-    const memories = items.map(memoryText).filter(Boolean);
-    if (memories.length > 0)
-        return memories.join("\n\n");
-    const payload = record(request?.payload);
-    return stringValue(payload?.query) || "Memory retrieval completed.";
-}
-async function readTraceHistory(memoraxCodeHome, resolveProject, client, claudeProjectsRoot = false) {
-    if (client !== undefined && !isMemoryViewerClient(client)) {
-        return {
-            values: [],
-            complete: true,
-            claudeLocal: EMPTY_MEMORY_VIEWER_HISTORY,
-        };
-    }
-    const historyCacheRoot = resolve(memoraxCodeHome);
-    const projectsByCwd = new Map();
-    const resolveProjectOnce = (cwd) => {
-        const key = cwd?.trim() ?? "";
-        if (!key)
-            return undefined;
-        if (projectsByCwd.has(key))
-            return projectsByCwd.get(key);
-        const identity = resolveProject(key);
-        projectsByCwd.set(key, identity);
-        return identity;
-    };
-    const readClient = (traceClient) => readIncrementalJsonlProjectionSnapshot({
-        root: clientTracePaths(traceClient, memoraxCodeHome).sessionsRoot,
-        filename: "events.jsonl",
-        identity: resolveProject,
-        project(value, sessionDir) {
-            const event = traceEventToViewerEvent(value, sessionDir, resolveProjectOnce, traceClient);
-            if (!event)
-                return undefined;
-            const retryKey = event.projectId ? "" : traceEventProjectInput(value);
-            return { value: event, ...(retryKey ? { retryKey } : {}) };
-        },
-        refreshEntry(entry) {
-            if (!entry.retryKey)
-                return false;
-            const identity = resolveProjectOnce(entry.retryKey);
-            if (!identity)
-                return false;
-            entry.value = { ...entry.value, ...viewerProjectFields(identity) };
-            entry.retryKey = undefined;
-            return true;
-        },
-        compare: compareMemoryViewerEvents,
-    });
-    if (client === "codex" || client === "dsh" || client === "opencode") {
-        const selected = await readClient(client);
-        return { ...selected, claudeLocal: EMPTY_MEMORY_VIEWER_HISTORY };
-    }
-    const claudeLocalPromise = readClaudeLocalTranscriptHistory(claudeProjectsRoot, resolveProject);
-    if (client === "claude") {
-        const [claude, claudeLocal] = await Promise.all([
-            readClient("claude"),
-            claudeLocalPromise,
-        ]);
-        return {
-            values: combinedTraceHistory(`${historyCacheRoot}\u0000client=claude\u0000source=${claudeProjectsRoot || "disabled"}`, EMPTY_MEMORY_VIEWER_HISTORY, claude.values, EMPTY_MEMORY_VIEWER_HISTORY, EMPTY_MEMORY_VIEWER_HISTORY, claudeLocal),
-            complete: claude.complete,
-            claudeLocal,
-        };
-    }
-    const [codex, claude, dsh, opencode, claudeLocal] = await Promise.all([
-        readClient("codex"),
-        readClient("claude"),
-        readClient("dsh"),
-        readClient("opencode"),
-        claudeLocalPromise,
-    ]);
-    return {
-        values: combinedTraceHistory(`${historyCacheRoot}\u0000client=all\u0000source=${claudeProjectsRoot || "disabled"}`, codex.values, claude.values, dsh.values, opencode.values, claudeLocal),
-        complete: codex.complete && claude.complete && dsh.complete && opencode.complete,
-        claudeLocal,
-    };
-}
-function combinedTraceHistory(cacheKey, codex, claude, dsh, opencode, claudeLocal) {
-    const cached = combinedTraceHistories.get(cacheKey);
-    if (cached?.codex === codex
-        && cached.claude === claude
-        && cached.dsh === dsh
-        && cached.opencode === opencode
-        && cached.claudeLocal === claudeLocal) {
-        return cached.values;
-    }
-    // Native Claude transcripts invalidate this cached identity, but they are
-    // admitted only after retained and live Hook trace events are merged.
-    const values = [...codex, ...claude, ...dsh, ...opencode].sort(compareMemoryViewerEvents);
-    combinedTraceHistories.set(cacheKey, { codex, claude, dsh, opencode, claudeLocal, values });
-    return values;
-}
-function admitClaudeTranscriptEvents(traceEvents, localEvents) {
-    const hookProjectsByTurn = new Map();
-    for (const event of traceEvents) {
-        if (event.client !== "claude"
-            || event.type !== "turn_start"
-            || event.id.startsWith("claude-local:")
-            || !event.sessionId
-            || !event.turnId) {
-            continue;
-        }
-        const key = viewerTurnKey(event.client, event.sessionId, event.turnId);
-        const projects = hookProjectsByTurn.get(key) ?? new Set();
-        projects.add(event.projectId ?? "");
-        hookProjectsByTurn.set(key, projects);
-    }
-    const turnScopes = new Map();
-    for (const [key, projects] of hookProjectsByTurn) {
-        if (projects.size !== 1)
-            continue;
-        const projectId = projects.values().next().value;
-        turnScopes.set(key, projectId || undefined);
-    }
-    if (turnScopes.size === 0 || localEvents.length === 0) {
-        return { turnScopes, events: EMPTY_MEMORY_VIEWER_HISTORY };
-    }
-    return { turnScopes, events: localEvents.filter((event) => (claudeTranscriptEventAdmitted(event, turnScopes))) };
-}
-function claudeTranscriptEventAdmitted(event, turnScopes) {
-    if (event.client !== "claude" || !event.sessionId || !event.turnId)
-        return false;
-    const key = viewerTurnKey(event.client, event.sessionId, event.turnId);
-    if (!turnScopes.has(key))
-        return false;
-    const projectId = turnScopes.get(key);
-    return event.projectId === projectId;
-}
-function coalesceClaudeTranscriptTurns(traceEvents, localEvents) {
-    if (localEvents.length === 0)
-        return traceEvents;
-    const localByTurn = new Map();
-    for (const event of localEvents) {
-        const key = claudeTurnLifecycleKey(event);
-        if (!key)
-            continue;
-        const candidates = localByTurn.get(key) ?? [];
-        candidates.push(event);
-        localByTurn.set(key, candidates);
-    }
-    const suppressed = new Set();
-    const coalesced = traceEvents.map((event) => {
-        const key = claudeTurnLifecycleKey(event);
-        const candidates = key ? localByTurn.get(key) : undefined;
-        if (!key || !candidates)
-            return event;
-        for (const candidate of candidates)
-            suppressed.add(candidate);
-        const matching = event.projectId
-            ? candidates.filter((candidate) => candidate.projectId === event.projectId)
-            : candidates;
-        const local = matching.length === 1 ? matching[0] : undefined;
-        if (!local)
-            return event;
-        const project = event.projectId ? {} : viewerProjectFields(memoryProjectFromViewerEvent(local));
-        if (event.type === "turn_start") {
-            const prompt = local.prompt || event.prompt;
-            return {
-                ...event,
-                ...project,
-                ...(prompt ? { prompt, content: prompt } : {}),
-            };
-        }
-        const answer = local.answer || event.answer;
-        return {
-            ...event,
-            ...project,
-            ...(answer ? { answer, content: answer } : {}),
-            ...((local.turnOutcome === "interrupted" || !event.turnOutcome) && local.turnOutcome
-                ? { turnOutcome: local.turnOutcome }
-                : {}),
-        };
-    });
-    for (const event of localEvents) {
-        if (!suppressed.has(event))
-            coalesced.push(event);
-    }
-    return coalesced;
-}
-function claudeTurnLifecycleKey(event) {
-    if (event.client !== "claude"
-        || !event.sessionId
-        || !event.turnId
-        || (event.type !== "turn_start" && event.type !== "turn_end")) {
-        return "";
-    }
-    return `${event.sessionId}\u0000${event.turnId}\u0000${event.type}`;
-}
-function memoryProjectFromViewerEvent(event) {
-    return event.projectId && event.projectLabel
-        ? { projectId: event.projectId, projectLabel: event.projectLabel }
-        : undefined;
-}
-function associateClaudeEventsWithTranscriptTurns(traceEvents, transcriptEvents, admittedTurnScopes) {
-    if (transcriptEvents.length === 0)
-        return traceEvents;
-    const startsBySession = new Map();
-    const endsByTurn = new Map();
-    for (const event of transcriptEvents) {
-        if (event.client !== "claude" || !event.sessionId || !event.turnId)
-            continue;
-        if (event.type === "turn_start") {
-            const starts = startsBySession.get(event.sessionId) ?? [];
-            starts.push(event);
-            startsBySession.set(event.sessionId, starts);
-        }
-        else if (event.type === "turn_end") {
-            endsByTurn.set(viewerTurnProjectKey(event.client, event.sessionId, event.turnId, event.projectId), event);
-        }
-    }
-    for (const starts of startsBySession.values())
-        starts.sort(compareMemoryViewerEvents);
-    let changed = false;
-    const associated = traceEvents.map((event) => {
-        if (event.client !== "claude"
-            || !event.sessionId
-            || !event.projectId
-            || (event.turnId
-                && event.type !== "memory_cli_search"
-                && event.type !== "memory_cli_add")) {
-            return event;
-        }
-        const starts = startsBySession.get(event.sessionId);
-        if (!starts)
-            return event;
-        const references = event.turnReferences ?? [];
-        if (references.length === 0)
-            return event;
-        const resolvedReferences = references.map((reference) => {
-            const owner = transcriptTurnForReference(event, reference, starts, endsByTurn, admittedTurnScopes);
-            if (owner?.turnId)
-                return { ...reference, turnId: owner.turnId };
-            const { turnId: _turnId, ...unassociated } = reference;
-            return unassociated;
-        });
-        const turnIds = [...new Set(resolvedReferences
-                .map((reference) => safeMemoryViewerTurnId(reference.turnId))
-                .filter(Boolean))];
-        changed = true;
-        const { turnId: _turnId, ...unassociated } = event;
-        if (turnIds.length === 0
-            || resolvedReferences.some((reference) => !safeMemoryViewerTurnId(reference.turnId))) {
-            return { ...unassociated, turnReferences: resolvedReferences };
-        }
-        return turnIds.length === 1
-            ? { ...unassociated, turnId: turnIds[0], turnReferences: resolvedReferences }
-            : { ...unassociated, turnReferences: resolvedReferences };
-    });
-    return changed ? associated : traceEvents;
-}
-const CLAUDE_NATIVE_ACTIVITY_MATCH_WINDOW_MS = 10 * 60 * 1_000;
-function coalesceClaudeTranscriptActivities(allEvents) {
-    const nativeByTurn = new Map();
-    for (const event of allEvents) {
-        if (!isClaudeNativeMemoryActivity(event) || !event.sessionId)
-            continue;
-        for (const turnId of memoryViewerEventTurnIds(event)) {
-            const key = claudeActivityTurnKey(event.sessionId, turnId, event.type);
-            const candidates = nativeByTurn.get(key) ?? [];
-            candidates.push(event);
-            nativeByTurn.set(key, candidates);
-        }
-    }
-    if (nativeByTurn.size === 0)
-        return allEvents;
-    for (const candidates of nativeByTurn.values())
-        candidates.sort(compareMemoryViewerEvents);
-    const suppressed = new Set();
-    for (const traceEvent of allEvents) {
-        if (!isClaudeTraceMemoryActivity(traceEvent) || !traceEvent.sessionId)
-            continue;
-        const traceTimes = claudeTraceActivityTimes(traceEvent);
-        if (traceTimes.length === 0)
-            continue;
-        const candidates = memoryViewerEventTurnIds(traceEvent)
-            .flatMap((turnId) => nativeByTurn.get(claudeActivityTurnKey(traceEvent.sessionId, turnId, traceEvent.type)) ?? [])
-            .filter((candidate) => !suppressed.has(candidate));
-        const projectCandidates = traceEvent.projectId
-            ? candidates.filter((candidate) => candidate.projectId === traceEvent.projectId)
-            : candidates;
-        if (!traceEvent.projectId
-            && new Set(projectCandidates.map((candidate) => candidate.projectId ?? "")).size > 1) {
-            continue;
-        }
-        const ranked = projectCandidates
-            .map((candidate) => ({
-            candidate,
-            distance: Math.min(...traceTimes.map((traceTime) => (Math.abs(Date.parse(candidate.timestamp) - traceTime)))),
-        }))
-            .filter((entry) => Number.isFinite(entry.distance))
-            .sort((left, right) => (left.distance - right.distance
-            || compareMemoryViewerEvents(left.candidate, right.candidate)));
-        const nearest = ranked[0];
-        if (!nearest
-            || nearest.distance > CLAUDE_NATIVE_ACTIVITY_MATCH_WINDOW_MS) {
-            continue;
-        }
-        suppressed.add(nearest.candidate);
-    }
-    return suppressed.size === 0
-        ? allEvents
-        : allEvents.filter((event) => !suppressed.has(event));
-}
-function claudeTraceActivityTimes(event) {
-    return [event.timestamp, ...(event.turnReferences ?? []).map((reference) => reference.capturedAt)]
-        .map((timestamp) => Date.parse(timestamp))
-        .filter(Number.isFinite);
-}
-function isClaudeNativeMemoryActivity(event) {
-    return event.client === "claude"
-        && event.id.startsWith("claude-local:")
-        && (event.type === "memory_cli_search" || event.type === "memory_cli_add");
-}
-function isClaudeTraceMemoryActivity(event) {
-    return event.client === "claude"
-        && !event.id.startsWith("claude-local:")
-        && (event.type === "memory_cli_search" || event.type === "memory_cli_add");
-}
-function claudeActivityTurnKey(sessionId, turnId, type) {
-    return `${sessionId}\u0000${turnId}\u0000${type}`;
-}
-function transcriptTurnForReference(event, reference, starts, endsByTurn, admittedTurnScopes) {
-    const capturedAt = Date.parse(reference.capturedAt);
-    if (!Number.isFinite(capturedAt) || !event.sessionId || !event.projectId)
-        return undefined;
-    const explicitTurnId = safeMemoryViewerTurnId(reference.turnId);
-    const candidates = [];
-    for (const [index, start] of starts.entries()) {
-        if (!start.turnId || start.projectId !== event.projectId)
-            continue;
-        if (!claudeTranscriptEventAdmitted(start, admittedTurnScopes))
-            continue;
-        if (explicitTurnId && start.turnId !== explicitTurnId)
-            continue;
-        const startedAt = Date.parse(start.timestamp);
-        if (!Number.isFinite(startedAt) || capturedAt < startedAt)
-            continue;
-        const end = endsByTurn.get(viewerTurnProjectKey(event.client, event.sessionId, start.turnId, start.projectId));
-        const endedAt = end ? Date.parse(end.timestamp) : Number.NaN;
-        const nextStart = starts.slice(index + 1).find((candidate) => (candidate.projectId === event.projectId));
-        const nextStartedAt = Date.parse(nextStart?.timestamp ?? "");
-        if (Number.isFinite(endedAt) && capturedAt > endedAt)
-            continue;
-        if (!Number.isFinite(endedAt) && Number.isFinite(nextStartedAt) && capturedAt >= nextStartedAt)
-            continue;
-        candidates.push(start);
-    }
-    return candidates.length === 1 ? candidates[0] : undefined;
-}
-function memoryViewerTurnReferences(relatedTurns, traceContext) {
-    const collect = (values) => {
-        const output = [];
-        const seen = new Set();
-        for (const value of values) {
-            const raw = record(value);
-            const capturedAt = canonicalOptionalMemoryViewerTimestamp(raw?.captured_at ?? raw?.capturedAt);
-            if (!capturedAt)
-                continue;
-            const turnId = safeMemoryViewerTurnId(raw?.turn_id ?? raw?.turnId);
-            const key = `${turnId}\u0000${capturedAt}`;
-            if (seen.has(key))
-                continue;
-            seen.add(key);
-            output.push({ ...(turnId ? { turnId } : {}), capturedAt });
-        }
-        return output;
-    };
-    const related = collect(arrayValue(relatedTurns));
-    return related.length > 0 ? related : collect(traceContext ? [traceContext] : []);
-}
-function viewerTurnKey(client, sessionId, turnId) {
-    return `${client}\u0000${sessionId}\u0000${turnId}`;
-}
-function viewerTurnProjectKey(client, sessionId, turnId, projectId) {
-    return `${viewerTurnKey(client, sessionId, turnId)}\u0000${projectId ?? ""}`;
-}
-function traceEventProjectInput(value) {
-    const raw = record(value);
-    const trace = record(raw?.trace);
-    if (memoryProjectFromUnknown(trace?.memory_project) || memoryProjectFromUnknown(trace?.memoryProject))
-        return "";
-    return stringValue(trace?.cwd) || stringValue(record(raw?.request)?.cwd);
-}
-function compareMemoryViewerEvents(left, right) {
-    const leftTime = Date.parse(left.timestamp);
-    const rightTime = Date.parse(right.timestamp);
-    const leftOrder = Number.isFinite(leftTime) ? leftTime : 0;
-    const rightOrder = Number.isFinite(rightTime) ? rightTime : 0;
-    return leftOrder - rightOrder || left.eventKey.localeCompare(right.eventKey);
-}
-function traceEventToViewerEvent(value, sessionDir, resolveProject, client) {
-    const raw = record(value);
-    const type = memoryViewerEventType(raw?.type);
-    if (!raw || !type)
-        return undefined;
-    const operation = type === "turn_start"
-        ? "query"
-        : type === "turn_end" || type === "turn_materialized"
-            ? "reply"
-            : raw.operation === "writeback"
-                ? "writeback"
-                : raw.operation === "query"
-                    ? "query"
-                    : raw.operation === "retrieve"
-                        ? "retrieve"
-                        : undefined;
-    if (!operation)
-        return undefined;
-    const source = typeof raw.source === "string" ? raw.source : "unknown";
-    const request = record(raw.request);
-    const response = record(raw.response);
-    const items = arrayValue(response?.items);
-    const query = searchQuery(request);
-    const results = searchResults(items);
-    const timestamp = canonicalMemoryViewerTimestamp(raw.timestamp);
-    const error = stringValue(raw.error);
-    const trace = record(raw.trace);
-    const turnId = safeMemoryViewerTurnId(stringValue(trace?.turn_id) || stringValue(trace?.turnId));
-    const turnReferences = client === "claude"
-        ? memoryViewerTurnReferences(raw.related_turns ?? raw.relatedTurns, trace)
-        : [];
-    const persistedProjectIdentity = memoryProjectFromUnknown(trace?.memory_project)
-        ?? memoryProjectFromUnknown(trace?.memoryProject);
-    const projectCwd = stringValue(trace?.cwd) || stringValue(request?.cwd);
-    // Resolving the persisted cwd rebuilds the process-local project-root index on
-    // cold start and verifies any persisted identity before readiness uses it.
-    const resolvedProjectIdentity = resolveProject(projectCwd);
-    const projectIdentity = resolvedProjectIdentity ?? persistedProjectIdentity;
-    const rawTraceSessionId = stringValue(trace?.session_id) || stringValue(trace?.sessionId);
-    const traceSessionId = rawTraceSessionId ? sessionId(rawTraceSessionId) : sessionId(sessionDir);
-    const writeback = writebackState(operation === "reply" ? "query" : operation, response);
-    const persistedOutcome = memoryViewerWritebackOutcome(response?.outcome);
-    const savedMemoryCount = nonNegativeInteger(response?.savedMemoryCount ?? response?.saved_memory_count);
-    const savedMemoryIds = stringArray(response?.savedMemoryIds ?? response?.saved_memory_ids);
-    const savedMemories = stringArray(response?.savedMemories ?? response?.saved_memories);
-    const turnOutcome = type === "turn_end" || type === "turn_materialized"
-        ? memoryViewerTurnOutcome(raw.outcome) ?? "completed"
-        : undefined;
-    const writebackMessages = operation === "writeback"
-        ? writebackConversation(operation, request)
-        : { prompt: "", answer: "" };
-    const rawPrompt = stringValue(request?.prompt)
-        || stringValue(request?.userPrompt)
-        || stringValue(request?.user_prompt);
-    const prompt = type === "turn_start" || type === "turn_materialized"
-        ? (client === "codex" ? stripCodexPreambleSegments(rawPrompt) : rawPrompt)
-        : writebackMessages.prompt;
-    const answer = type === "turn_end" || type === "turn_materialized"
-        ? stringValue(response?.assistantMessage) || stringValue(response?.assistant_message) || stringValue(response?.answer)
-        : writebackMessages.answer;
-    const content = type === "turn_start"
-        ? prompt || "Turn started."
-        : type === "turn_end" || type === "turn_materialized"
-            ? answer || (turnOutcome === "interrupted" ? "" : "Turn ended.")
-            : eventContent(operation === "reply" ? "query" : operation, request, response, items, error || undefined);
-    const eventId = stringValue(raw.event_id) || `${traceSessionId || "unscoped"}:${type}:${timestamp}`;
-    const id = persistedMemoryViewerEventId(client, eventId);
-    const originalEventId = memoryViewerOriginalEventId(request?.original_event_id ?? request?.originalEventId, client);
-    return {
-        id,
-        eventKey: memoryViewerEventKey({
-            id,
-            client,
-            ...(traceSessionId ? { sessionId: traceSessionId } : {}),
-        }),
-        client,
-        type,
-        timestamp,
-        source,
-        operation,
-        ok: raw.ok !== false,
-        ...viewerProjectFields(projectIdentity),
-        ...(traceSessionId ? { sessionId: traceSessionId } : {}),
-        ...(turnId ? { turnId } : {}),
-        ...(turnReferences.length > 0 ? { turnReferences } : {}),
-        content,
-        ...(turnOutcome ? { turnOutcome } : {}),
-        ...(prompt ? { prompt } : {}),
-        ...(answer ? { answer } : {}),
-        ...(query ? { query } : {}),
-        ...(results.length > 0 ? { results } : {}),
-        ...(items.length > 0 ? { itemCount: items.length } : {}),
-        ...(stringValue(response?.receiptId) ? { receiptId: stringValue(response?.receiptId) } : {}),
-        ...(writeback.taskId ? { taskId: writeback.taskId } : {}),
-        ...(originalEventId ? { originalEventId } : {}),
-        ...(writeback.status ? { writebackStatus: writeback.status } : {}),
-        ...(persistedOutcome
-            ? { writebackOutcome: persistedOutcome }
-            : writeback.status ? { writebackOutcome: writebackOutcomeForStatus(writeback.status) } : {}),
-        ...(savedMemoryCount === undefined ? {} : { savedMemoryCount }),
-        ...(savedMemoryIds.length > 0 ? { savedMemoryIds } : {}),
-        ...(savedMemories.length > 0 ? { savedMemories } : {}),
-        ...(error ? { error: error.slice(0, 2000) } : {}),
-        details: sanitizeMemoryViewerDetails({ request: raw.request, response: raw.response }),
-    };
-}
-function memoryViewerTurnOutcome(value) {
-    return value === "completed" || value === "interrupted" ? value : undefined;
-}
-function memoryViewerOriginalEventId(value, client) {
-    const eventId = stringValue(value);
-    if (!eventId)
-        return "";
-    return persistedMemoryViewerEventId(client, eventId);
-}
-function viewerProjectFields(identity) {
-    if (!identity)
-        return {};
-    return {
-        projectId: identity.projectId,
-        projectLabel: identity.projectLabel,
-        project: identity.projectLabel,
-    };
-}
-function projectCatalog(allEvents) {
-    const projects = new Map();
-    for (const event of allEvents) {
-        if (!event.projectId || !event.projectLabel)
-            continue;
-        const current = projects.get(event.projectId);
-        projects.set(event.projectId, {
-            projectId: event.projectId,
-            projectLabel: event.projectLabel,
-            eventCount: (current?.eventCount ?? 0) + 1,
-            lastSeenAt: !current || Date.parse(event.timestamp) >= Date.parse(current.lastSeenAt)
-                ? event.timestamp
-                : current.lastSeenAt,
-        });
-    }
-    return [...projects.values()].sort((left, right) => (left.projectLabel.localeCompare(right.projectLabel) || left.projectId.localeCompare(right.projectId)));
-}
-function projectSessionCatalog(allEvents) {
-    const entries = new Map();
-    for (const event of allEvents) {
-        const projectId = event.projectId ?? UNCLASSIFIED_PROJECT_ID;
-        const key = `${event.client}\u0000${projectId}\u0000${event.sessionId ?? ""}`;
-        const current = entries.get(key);
-        entries.set(key, {
-            client: event.client,
-            projectId,
-            ...(event.sessionId ? { sessionId: event.sessionId } : { unscoped: true }),
-            eventCount: (current?.eventCount ?? 0) + 1,
-            lastSeenAt: !current || Date.parse(event.timestamp) >= Date.parse(current.lastSeenAt)
-                ? event.timestamp
-                : current.lastSeenAt,
-        });
-    }
-    return [...entries.values()].sort((left, right) => (left.projectId.localeCompare(right.projectId)
-        || left.client.localeCompare(right.client)
-        || Date.parse(right.lastSeenAt) - Date.parse(left.lastSeenAt)
-        || (left.sessionId ?? "").localeCompare(right.sessionId ?? "")));
-}
-function resolveProjectSelection(projects, hasUnclassified, projectId, rejectProjectFilter) {
-    if (rejectProjectFilter)
-        return { status: "invalid", blockAll: true };
-    if (projectId) {
-        const exists = projectId === UNCLASSIFIED_PROJECT_ID
-            ? hasUnclassified
-            : projects.some((project) => project.projectId === projectId);
-        return { projectId, status: exists ? "resolved" : "missing", blockAll: !exists };
-    }
-    return {};
-}
-function memoryViewerEventType(value) {
-    return isMemoryViewerEventType(value) ? value : undefined;
-}
-function isMemoryViewerEventType(value) {
-    return value === "turn_start"
-        || value === "turn_materialized"
-        || value === "memory_retrieve"
-        || value === "memory_cli_search"
-        || value === "memory_cli_add"
-        || value === "memory_writeback"
-        || value === "memory_writeback_status"
-        || value === "turn_end";
-}
-function memoryEventType(source, operation) {
-    if (source === "memory_cli")
-        return operation === "writeback" ? "memory_cli_add" : "memory_cli_search";
-    return operation === "writeback" ? "memory_writeback" : "memory_retrieve";
-}
-function searchQuery(request) {
-    return stringValue(record(request?.payload)?.query) || stringValue(request?.query);
-}
-function searchResults(items) {
-    return items
-        .map((item) => {
-        const value = record(item);
-        const content = memoryText(item);
-        if (!value || !content)
-            return undefined;
-        const score = typeof value.score === "number" && Number.isFinite(value.score) ? value.score : undefined;
-        const scoreDetails = record(value.score_details);
-        const semanticSimilarity = scoreDetails?.semantic_similarity ?? value.semantic_similarity;
-        const confidence = typeof semanticSimilarity === "number"
-            && Number.isFinite(semanticSimilarity)
-            && semanticSimilarity >= 0
-            && semanticSimilarity <= 1
-            ? semanticSimilarity
-            : undefined;
-        return {
-            content,
-            ...(score === undefined ? {} : { score }),
-            ...(confidence === undefined ? {} : { confidence }),
-        };
-    })
-        .filter((item) => Boolean(item));
-}
-function writebackConversation(operation, request) {
-    if (operation !== "writeback")
-        return { prompt: "", answer: "" };
-    const messages = arrayValue(record(request?.payload)?.messages);
-    const contentsForRole = (role) => messages
-        .map(record)
-        .filter((message) => stringValue(message?.role).toLowerCase() === role)
-        .map((message) => stringValue(message?.content))
-        .filter(Boolean)
-        .join("\n\n");
-    return {
-        prompt: contentsForRole("user"),
-        answer: contentsForRole("assistant"),
-    };
-}
-function writebackState(operation, response) {
-    if (operation !== "writeback")
-        return { taskId: "", status: "" };
-    const raw = record(response?.raw) ?? response;
-    const data = record(raw?.data);
-    return {
-        taskId: stringValue(data?.task_id) || stringValue(response?.taskId),
-        status: (stringValue(data?.status)
-            || stringValue(response?.status)
-            || stringValue(response?.addStatus)).toLowerCase(),
-    };
-}
-function record(value) {
-    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
-}
-function arrayValue(value) {
-    return Array.isArray(value) ? value : [];
-}
-function stringValue(value) {
-    return typeof value === "string" ? value.trim() : "";
-}
-function canonicalMemoryViewerTimestamp(value) {
-    if (value === undefined || value === null || value === "")
-        return new Date().toISOString();
-    return canonicalOptionalMemoryViewerTimestamp(value) ?? new Date(0).toISOString();
-}
-function canonicalOptionalMemoryViewerTimestamp(value) {
-    if (typeof value !== "string" || !value.trim() || value.length > 512)
-        return "";
-    const parsed = Date.parse(value.trim());
-    return Number.isFinite(parsed) ? new Date(parsed).toISOString() : "";
-}
-export function safeMemoryViewerSessionId(value) {
-    const candidate = typeof value === "string" ? value.trim() : "";
-    if (candidate.length > 512)
-        return "";
-    // This value is reserved by the viewer protocol to select events without a session.
-    if (!candidate || candidate === MEMORY_VIEWER_UNSCOPED_SESSION_FILTER)
-        return "";
-    if (/[\u0000-\u001f\u007f]/.test(candidate))
-        return "";
-    if (/[\\/]/.test(candidate))
-        return "";
-    return candidate;
-}
-export function safeMemoryViewerTurnId(value) {
-    const candidate = typeof value === "string" ? value.trim() : "";
-    if (!candidate || candidate.length > 512)
-        return "";
-    if (/[\u0000-\u001f\u007f\\/]/.test(candidate))
-        return "";
-    return candidate;
-}
-function sessionId(value) {
-    return safeMemoryViewerSessionId(value);
-}
-function memoryViewerClient(input) {
-    if (input.traceContext?.client !== undefined) {
-        return isMemoryViewerClient(input.traceContext.client)
-            ? input.traceContext.client
-            : undefined;
-    }
-    if (input.source === "dsh_native_retrieval" || input.source === "dsh_native_writeback") {
-        return undefined;
-    }
-    if (input.source === "claude_hook_retrieval" || input.source === "claude_hook_writeback")
-        return "claude";
-    if (input.source === "opencode_plugin_retrieval" || input.source === "opencode_plugin_writeback")
-        return "opencode";
-    return "codex";
-}
-function isMemoryViewerClient(client) {
-    return client === "codex" || client === "claude" || client === "dsh" || client === "opencode";
-}
-function memoryViewerEventId(client, eventId) {
-    if (eventId)
-        return persistedMemoryViewerEventId(client, eventId);
-    return `${client === "codex" ? "" : `${client}-`}memory-viewer:${randomUUID()}`;
-}
-function persistedMemoryViewerEventId(client, eventId) {
-    return client === "codex" ? `trace:${eventId}` : `${client}-trace:${eventId}`;
-}
-function memoryViewerProjectionKey(memoraxCodeHome, client) {
-    if (client !== undefined && !isMemoryViewerClient(client)) {
-        return `${resolve(memoraxCodeHome)}\u0000client=unsupported`;
-    }
-    if (client === "claude")
-        return clientTracePaths("claude", memoraxCodeHome).sessionsRoot;
-    if (client === "dsh")
-        return clientTracePaths("dsh", memoraxCodeHome).sessionsRoot;
-    if (client === "opencode")
-        return clientTracePaths("opencode", memoraxCodeHome).sessionsRoot;
-    const codexSessionsRoot = tracePaths(memoraxCodeHome).sessionsRoot;
-    return client === "codex" ? `${codexSessionsRoot}\u0000client=codex` : codexSessionsRoot;
-}