@geminixiang/mikan 1.0.0-beta.44 → 1.0.0-beta.46

package/dist/web/session-view/portal.js

@@ -1,13 +1,31 @@
+import { dirname, join, resolve } from "node:path";
+import { existsSync, readdirSync } from "node:fs";
+import { SessionStore, } from "../../harness/index.js";
+import { getThreadSessionFile, resolveChannelSessionFile, tryResolveThreadSession, } from "../../sessions/store.js";
+import { isPlatformHistorySession } from "../../sessions/store.js";
 import { basename } from "node:path";
+import { InMemoryTokenStore } from "../token-store.js";
 import MarkdownIt from "markdown-it";
 import { createConversationEvent, createConversationMessage, } from "../../adapter.js";
 import { createOfficeAddress } from "../../office/index.js";
 import * as log from "../../log.js";
-import { escapeHtml, readRawBody, renderPortalShell } from "../portal-shell.js";
+import { escapeHtml, jsonResponse as json, readJsonBody, renderPortalShell, } from "../portal-shell.js";
 import { reportUserFacingError } from "../../observability/sentry.js";
 import { inferConversationKind } from "../../sessions/session-key.js";
 import { isThreadSessionKey, threadSuffixOf } from "../../sessions/session-key.js";
-import { loadSessionViewModel, resolveRequestedSessionFile, } from "./service.js";
+const SESSION_VIEW_TOKEN_TTL_MS = 24 * 60 * 60 * 1000;
+export class InMemorySessionViewTokenStore extends InMemoryTokenStore {
+    create(options) {
+        return this.createRecord(SESSION_VIEW_TOKEN_TTL_MS, {
+            platform: options.platform,
+            platformUserId: options.platformUserId,
+            ...(options.platformUserName ? { platformUserName: options.platformUserName } : {}),
+            conversationId: options.conversationId,
+            sessionKey: options.sessionKey,
+            sessionFile: options.sessionFile,
+        });
+    }
+}
 const markdown = new MarkdownIt({
     html: false,
     linkify: true,
@@ -61,75 +79,93 @@ export async function handleSessionViewRequest(req, res, url, sessionViewTokenSt
     if (req.method !== "GET" || url.pathname !== "/session") {
         return false;
     }
-    const token = url.searchParams.get("token")?.trim();
-    if (!token || !sessionViewTokenStore) {
-        res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
-        res.end(renderStatusPage("Session unavailable", "This session link is invalid or has expired."));
+    const target = await resolveSessionRequestTarget(sessionViewTokenStore, url.searchParams.get("token"), url.searchParams.get("session"));
+    if (!target.ok) {
+        res.writeHead(target.status, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(renderStatusPage("Session unavailable", target.message));
         return true;
     }
-    const entry = sessionViewTokenStore.peek(token);
-    if (!entry) {
-        res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
-        res.end(renderStatusPage("Session unavailable", "This session link is invalid or has expired."));
-        return true;
-    }
-    const requestedSession = url.searchParams.get("session");
-    let targetSessionFile;
+    const { activeSessionKey, entry, targetSessionFile } = target;
     try {
-        targetSessionFile = await resolveRequestedSessionFile(entry.sessionFile, requestedSession);
+        const model = await loadSessionViewModel(targetSessionFile);
+        const displayedSessionKey = activeSessionKey;
+        const isRunning = interactive?.handler.isRunning(createOfficeAddress(entry.platform, entry.conversationId), displayedSessionKey) ?? false;
+        res.writeHead(200, {
+            "Content-Type": "text/html; charset=utf-8",
+            "Cache-Control": "no-store",
+        });
+        res.end(renderSessionPage({
+            model,
+            token: entry.token,
+            expiresAt: entry.expiresAt,
+            isRunning,
+            displayedSessionKey,
+            conversationId: entry.conversationId,
+        }));
     }
     catch (error) {
-        log.logWarning(`[${entry.conversationId}] Corrupted session file referenced for ${entry.sessionFile}`, error instanceof Error ? error.message : String(error));
+        log.logWarning(`[${entry.conversationId}] Failed to render session ${entry.sessionFile}`, error instanceof Error ? error.message : String(error));
         reportUserFacingError(error, {
             domain: "session_view",
             surface: "session_view",
-            operation: "resolve_requested_session",
+            operation: "render_session",
             severity: "error",
             platform: entry.platform,
             context: {
                 conversationId: entry.conversationId,
                 sessionKey: entry.sessionKey,
-                sessionFile: basename(entry.sessionFile),
-                requestedSession,
+                sessionFile: basename(targetSessionFile),
             },
         });
         res.writeHead(500, { "Content-Type": "text/html; charset=utf-8" });
-        res.end(renderStatusPage("Session unavailable", "The selected session file appears to be corrupted."));
-        return true;
+        res.end(renderStatusPage("Session unavailable", "The session could not be loaded right now."));
     }
-    if (!targetSessionFile) {
-        res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
-        res.end(renderStatusPage("Session unavailable", "The selected session link is invalid."));
-        return true;
+    return true;
+}
+/**
+ * Token/session selection is shared by HTML, SSE, and message transports.
+ * Invalid or expired client capabilities are 400; missing server wiring is
+ * 503; a selected corrupt session is a server-side storage failure and is 500.
+ */
+async function resolveSessionRequestTarget(sessionViewTokenStore, rawToken, requestedSession) {
+    if (!sessionViewTokenStore) {
+        return { ok: false, status: 503, message: "Session view is not configured." };
+    }
+    const token = rawToken?.trim() ?? "";
+    const entry = token ? sessionViewTokenStore.peek(token) : undefined;
+    if (!entry) {
+        return { ok: false, status: 400, message: "This session link is invalid or has expired." };
     }
+    let targetSessionFile;
     try {
-        const model = await loadSessionViewModel(targetSessionFile);
-        const displayedSessionKey = resolveDisplayedSessionKey(entry, targetSessionFile);
-        const isRunning = interactive?.handler.isRunning(createOfficeAddress(entry.platform, entry.conversationId), displayedSessionKey) ?? false;
-        res.writeHead(200, {
-            "Content-Type": "text/html; charset=utf-8",
-            "Cache-Control": "no-store",
-        });
-        res.end(renderSessionPage(model, entry.token, entry.expiresAt, isRunning, displayedSessionKey, entry.conversationId));
+        targetSessionFile = await resolveRequestedSessionFile(entry.sessionFile, requestedSession);
     }
     catch (error) {
-        log.logWarning(`[${entry.conversationId}] Failed to render session ${entry.sessionFile}`, error instanceof Error ? error.message : String(error));
+        log.logWarning(`[${entry.conversationId}] Corrupted session file referenced for ${entry.sessionFile}`, error instanceof Error ? error.message : String(error));
         reportUserFacingError(error, {
             domain: "session_view",
             surface: "session_view",
-            operation: "render_session",
+            operation: "resolve_requested_session",
             severity: "error",
             platform: entry.platform,
             context: {
                 conversationId: entry.conversationId,
                 sessionKey: entry.sessionKey,
-                sessionFile: basename(targetSessionFile),
+                sessionFile: basename(entry.sessionFile),
+                requestedSession,
             },
         });
-        res.writeHead(500, { "Content-Type": "text/html; charset=utf-8" });
-        res.end(renderStatusPage("Session unavailable", "The session could not be loaded right now."));
+        return { ok: false, status: 500, message: "The selected session file is corrupted." };
     }
-    return true;
+    if (!targetSessionFile) {
+        return { ok: false, status: 400, message: "The selected session is invalid." };
+    }
+    return {
+        ok: true,
+        entry,
+        targetSessionFile,
+        activeSessionKey: resolveDisplayedSessionKey(entry, targetSessionFile),
+    };
 }
 function resolveDisplayedSessionKey(entry, sessionFile) {
     if (entry.platform === "slack") {
@@ -149,7 +185,8 @@ function renderTimelineItems(items, token) {
         ? items.map((item) => renderItem(item, token)).join("\n")
         : `<div class="system-event"><span class="event-dot"></span><span class="event-text">No messages yet — send one to the bot, then refresh.</span></div>`;
 }
-function renderSessionPage(model, token, expiresAt, isRunning, displayedSessionKey, conversationId) {
+function renderSessionPage(options) {
+    const { model, token, expiresAt, isRunning, displayedSessionKey, conversationId } = options;
     const items = renderTimelineItems(model.items, token);
     const relatedSections = model.parent
         ? `<section class="related-card stack">
@@ -364,47 +401,18 @@ function renderLiveSystemEvent(text, tone = "default") {
     return `<div class="system-event${cls}" data-live-item><span class="event-dot"></span><span class="event-text">${esc(text)}</span></div>`;
 }
 async function handleSessionStreamRequest(req, res, url, sessionViewTokenStore, interactive) {
-    const token = url.searchParams.get("token")?.trim() ?? "";
-    if (!token || !sessionViewTokenStore || !interactive) {
-        res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
-        res.end("Session stream unavailable");
-        return;
-    }
-    const entry = sessionViewTokenStore.peek(token);
-    if (!entry) {
-        res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
-        res.end("Invalid session token");
-        return;
-    }
-    const requestedSession = url.searchParams.get("session");
-    let targetSessionFile;
-    try {
-        targetSessionFile = await resolveRequestedSessionFile(entry.sessionFile, requestedSession);
-    }
-    catch (error) {
-        reportUserFacingError(error, {
-            domain: "session_view",
-            surface: "session_view",
-            operation: "session_stream",
-            severity: "error",
-            platform: entry.platform,
-            context: {
-                conversationId: entry.conversationId,
-                sessionKey: entry.sessionKey,
-                sessionFile: basename(entry.sessionFile),
-                requestedSession,
-            },
-        });
-        res.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
-        res.end("Session stream unavailable");
+    if (!interactive) {
+        res.writeHead(503, { "Content-Type": "text/plain; charset=utf-8" });
+        res.end("Session stream is not configured.");
         return;
     }
-    if (!targetSessionFile) {
-        res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
-        res.end("Invalid session file");
+    const target = await resolveSessionRequestTarget(sessionViewTokenStore, url.searchParams.get("token"), url.searchParams.get("session"));
+    if (!target.ok) {
+        res.writeHead(target.status, { "Content-Type": "text/plain; charset=utf-8" });
+        res.end(target.message);
         return;
     }
-    const activeSessionKey = resolveDisplayedSessionKey(entry, targetSessionFile);
+    const { activeSessionKey, entry } = target;
     const streamKey = sessionStreamKey({ ...entry, sessionKey: activeSessionKey });
     res.writeHead(200, {
         "Content-Type": "text/event-stream; charset=utf-8",
@@ -427,64 +435,43 @@ async function handleSessionStreamRequest(req, res, url, sessionViewTokenStore,
     });
 }
 async function handleSessionMessageRequest(req, res, sessionViewTokenStore, interactive) {
-    if (!sessionViewTokenStore || !interactive) {
+    if (!interactive) {
         json(res, 503, { ok: false, error: "Session chat is not configured." });
         return;
     }
-    const rawBody = await readRawBody(req, res, 1024 * 1024);
-    if (rawBody === null)
-        return;
-    let body;
-    try {
-        body = JSON.parse(rawBody);
-    }
-    catch {
-        json(res, 400, { ok: false, error: "Invalid request body." });
+    const body = await readJsonBody(req, res, 1024 * 1024);
+    if (!body)
         return;
-    }
-    const token = body.token?.trim() ?? "";
-    const text = body.text?.trim() ?? "";
-    const requestedSession = body.session?.trim() || null;
-    const requestedSessionKey = body.sessionKey?.trim() || "";
+    const token = typeof body.token === "string" ? body.token.trim() : "";
+    const text = typeof body.text === "string" ? body.text.trim() : "";
+    const requestedSession = typeof body.session === "string" ? body.session.trim() || null : null;
+    const requestedSessionKey = typeof body.sessionKey === "string" ? body.sessionKey.trim() : "";
     if (!token || !text) {
         json(res, 400, { ok: false, error: "Missing token or text." });
         return;
     }
-    const entry = sessionViewTokenStore.peek(token);
-    if (!entry) {
-        json(res, 400, { ok: false, error: "This session link is invalid or has expired." });
-        return;
-    }
-    let targetSessionFile;
-    try {
-        targetSessionFile = await resolveRequestedSessionFile(entry.sessionFile, requestedSession);
-    }
-    catch (error) {
-        reportUserFacingError(error, {
-            domain: "session_view",
-            surface: "session_view",
-            operation: "session_message",
-            severity: "error",
-            platform: entry.platform,
-            context: {
-                conversationId: entry.conversationId,
-                sessionKey: entry.sessionKey,
-                sessionFile: basename(entry.sessionFile),
-                requestedSession,
-            },
-        });
-        json(res, 500, { ok: false, error: "Session file could not be loaded." });
-        return;
-    }
-    if (!targetSessionFile) {
-        json(res, 400, { ok: false, error: "Invalid session file." });
+    const target = await resolveSessionRequestTarget(sessionViewTokenStore, token, requestedSession);
+    if (!target.ok) {
+        json(res, target.status, { ok: false, error: target.message });
         return;
     }
-    const activeSessionKey = resolveDisplayedSessionKey(entry, targetSessionFile);
+    const { activeSessionKey, entry, targetSessionFile } = target;
     if (requestedSessionKey && requestedSessionKey !== activeSessionKey) {
         json(res, 400, { ok: false, error: "Session target mismatch." });
         return;
     }
+    await dispatchSessionViewMessage({
+        res,
+        interactive,
+        token,
+        text,
+        activeSessionKey,
+        entry,
+        targetSessionFile,
+    });
+}
+async function dispatchSessionViewMessage(input) {
+    const { res, interactive, token, text, activeSessionKey, entry, targetSessionFile } = input;
     const bot = interactive.botsByPlatform[entry.platform];
     if (!bot) {
         json(res, 503, { ok: false, error: `No bot configured for ${entry.platform}.` });
@@ -541,10 +528,6 @@ async function handleSessionMessageRequest(req, res, sessionViewTokenStore, inte
     void interactive.handler
         .handleEvent(event, bot, context)
         .then(async () => {
-        if (!targetSessionFile) {
-            sessionViewStreamHub.publish(streamKey, { type: "status", running: false });
-            return;
-        }
         const model = await loadSessionViewModel(targetSessionFile);
         sessionViewStreamHub.publish(streamKey, {
             type: "refresh",
@@ -609,13 +592,6 @@ function createSessionViewResponseContext(publish) {
         },
     };
 }
-function json(res, status, body) {
-    res.writeHead(status, {
-        "Content-Type": "application/json; charset=utf-8",
-        "Cache-Control": "no-store",
-    });
-    res.end(JSON.stringify(body));
-}
 function renderStatusPage(title, message) {
     return renderHtmlDocument(title, `<section class="card stack">
       <p class="eyebrow">mikan</p>
@@ -1657,4 +1633,505 @@ const sessionViewStyles = `
     .asst-card { border-radius: 4px 14px 14px 14px; }
   }
 `;
+// ── Session view model (formerly service.ts) ──────────────────────────────────
+function entryIsoTime(entry) {
+    if (!entry || typeof entry.timestamp !== "number" || !Number.isFinite(entry.timestamp)) {
+        return undefined;
+    }
+    return new Date(entry.timestamp).toISOString();
+}
+export function resolveExistingSessionFile(conversationDir, sessionKey) {
+    if (isThreadSessionKey(sessionKey)) {
+        return tryResolveThreadSession(getThreadSessionFile(conversationDir, sessionKey));
+    }
+    return resolveChannelSessionFile(conversationDir);
+}
+export async function loadSessionViewModel(sessionFile) {
+    const resolvedFile = resolve(sessionFile);
+    const sm = await SessionStore.inspect(resolvedFile);
+    const header = sm.getHeader();
+    const entries = await sm.getEntries();
+    const updatedAt = entryIsoTime(entries.at(-1)) ?? header.timestamp;
+    const title = (await sm.getSessionName()) || `Session ${header.id.slice(0, 8)}`;
+    const parent = await resolveParentRelation(resolvedFile, header);
+    const threadCandidates = [];
+    for (const candidate of listRelatedSessionFiles(resolvedFile)) {
+        if (candidate === resolvedFile)
+            continue;
+        const relation = await buildSessionRelation(candidate, "thread", resolvedFile, header.id, entries);
+        if (relation)
+            threadCandidates.push(relation);
+    }
+    const threads = threadCandidates.toSorted((a, b) => a.updatedAt < b.updatedAt ? -1 : a.updatedAt > b.updatedAt ? 1 : 0);
+    const threadsByEntryId = new Map();
+    for (const thread of threads) {
+        if (!thread.anchorEntryId)
+            continue;
+        const bucket = threadsByEntryId.get(thread.anchorEntryId) ?? [];
+        bucket.push(thread);
+        threadsByEntryId.set(thread.anchorEntryId, bucket);
+    }
+    const items = entries.flatMap((entry) => {
+        const item = mapEntryToItem(entry);
+        if (!item)
+            return [];
+        if (item.entryId) {
+            const anchoredThreads = threadsByEntryId.get(item.entryId);
+            if (anchoredThreads) {
+                item.threads = anchoredThreads;
+            }
+        }
+        return [item];
+    });
+    return {
+        sessionId: header.id,
+        fileName: basename(resolvedFile),
+        title,
+        createdAt: header.timestamp,
+        updatedAt,
+        entryCount: entries.length,
+        items,
+        parent: parent ?? undefined,
+        threads,
+    };
+}
+async function resolveRequestedSessionFile(baseSessionFile, requestedFileName) {
+    const resolvedBase = resolve(baseSessionFile);
+    if (!requestedFileName)
+        return resolvedBase;
+    const trimmed = requestedFileName.trim();
+    if (!trimmed)
+        return resolvedBase;
+    const fileName = basename(trimmed);
+    if (fileName !== trimmed || !fileName.endsWith(".jsonl"))
+        return null;
+    const candidate = join(dirname(resolvedBase), fileName);
+    if (!existsSync(candidate))
+        return null;
+    try {
+        await SessionStore.open(candidate);
+    }
+    catch (err) {
+        throw new Error(`Session file is corrupted: ${candidate}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
+    return candidate;
+}
+function listRelatedSessionFiles(sessionFile) {
+    const dir = dirname(sessionFile);
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((name) => name.endsWith(".jsonl"))
+        .map((fileName) => join(dir, fileName));
+}
+async function buildSessionRelation(sessionFile, kind, expectedParent, expectedParentId, expectedParentEntries) {
+    let sm;
+    try {
+        sm = await SessionStore.inspect(sessionFile);
+    }
+    catch (err) {
+        log.logWarning(`Skipping corrupted session file while building ${kind} relation: ${sessionFile}`, err instanceof Error ? err.message : String(err));
+        return null;
+    }
+    const header = sm.getHeader();
+    if (kind === "thread" &&
+        !isChildThreadSession(sessionFile, header.parentSession, expectedParent, expectedParentId, header.parentSessionId)) {
+        return null;
+    }
+    const entries = await sm.getEntries();
+    const updatedAt = entryIsoTime(entries.at(-1)) ?? header.timestamp;
+    const threadId = kind === "thread" ? getFixedThreadSessionId(sessionFile) : null;
+    const anchorEntryId = kind === "thread" && expectedParent
+        ? findThreadAnchorEntryId(expectedParentEntries ??
+            (await (await SessionStore.inspect(expectedParent)).getEntries()), entries, threadId)
+        : undefined;
+    return {
+        kind,
+        fileName: basename(sessionFile),
+        sessionId: header.id,
+        title: (await sm.getSessionName()) || `Session ${header.id.slice(0, 8)}`,
+        updatedAt,
+        entryCount: entries.length,
+        summary: extractSessionSummary(entries),
+        anchorEntryId,
+    };
+}
+async function resolveParentRelation(sessionFile, header) {
+    if (header.parentSession) {
+        const parentPath = resolve(header.parentSession);
+        if (existsSync(parentPath)) {
+            return (await buildSessionRelation(parentPath, "parent")) ?? undefined;
+        }
+        // Path is stale — try UUID fallback before heuristic.
+        if (header.parentSessionId) {
+            const found = findSessionFileById(dirname(sessionFile), header.parentSessionId);
+            if (found)
+                return (await buildSessionRelation(found, "parent")) ?? undefined;
+        }
+    }
+    return buildInferredThreadParentRelation(sessionFile);
+}
+function findSessionFileById(sessionDir, targetId) {
+    if (!existsSync(sessionDir))
+        return null;
+    for (const name of readdirSync(sessionDir)) {
+        if (!name.endsWith(".jsonl"))
+            continue;
+        try {
+            const filePath = join(sessionDir, name);
+            if (SessionStore.readHeader(filePath)?.id === targetId)
+                return filePath;
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+async function buildInferredThreadParentRelation(sessionFile) {
+    if (!getFixedThreadSessionId(sessionFile))
+        return undefined;
+    const parentSession = resolveChannelSessionFile(dirname(dirname(sessionFile)));
+    if (!parentSession || parentSession === sessionFile)
+        return undefined;
+    return (await buildSessionRelation(parentSession, "parent")) ?? undefined;
+}
+function isChildThreadSession(sessionFile, parentSession, expectedParent, expectedParentId, threadParentSessionId) {
+    if (!expectedParent)
+        return false;
+    if (parentSession) {
+        const resolvedParent = resolve(parentSession);
+        if (resolvedParent === expectedParent ||
+            (isPlatformHistorySession(expectedParent) && isPlatformHistorySession(resolvedParent))) {
+            return true;
+        }
+        // Path is stale — fall back to UUID comparison.
+        if (expectedParentId && threadParentSessionId) {
+            return threadParentSessionId === expectedParentId;
+        }
+        return false;
+    }
+    if (!getFixedThreadSessionId(sessionFile))
+        return false;
+    return resolveChannelSessionFile(dirname(dirname(sessionFile))) === expectedParent;
+}
+function getFixedThreadSessionId(sessionFile) {
+    const fileName = basename(sessionFile);
+    if (!fileName.endsWith(".jsonl"))
+        return null;
+    if (/^\d{4}-\d{2}-\d{2}T.+_[0-9a-f]{8}\.jsonl$/i.test(fileName))
+        return null;
+    return fileName.slice(0, -".jsonl".length);
+}
+function findThreadAnchorEntryId(parentEntries, childEntries, threadId) {
+    const threadTimestamp = threadId ? Number(threadId) * 1000 : undefined;
+    if (threadTimestamp !== undefined && Number.isFinite(threadTimestamp)) {
+        const timestampAnchor = findEntryIdByMessageTimestamp(parentEntries, threadTimestamp);
+        if (timestampAnchor)
+            return timestampAnchor;
+    }
+    let sharedCount = 0;
+    while (sharedCount < parentEntries.length &&
+        sharedCount < childEntries.length &&
+        parentEntries[sharedCount]?.id === childEntries[sharedCount]?.id) {
+        sharedCount += 1;
+    }
+    if (sharedCount > 0) {
+        return parentEntries[sharedCount - 1]?.id;
+    }
+    const contentAnchor = findSharedContentAnchorEntryId(parentEntries, childEntries);
+    if (contentAnchor)
+        return contentAnchor;
+    const childRoot = findComparableUserMessage(childEntries);
+    if (!childRoot)
+        return undefined;
+    return findParentAnchorByRootMessage(parentEntries, childRoot);
+}
+function findEntryIdByMessageTimestamp(entries, timestamp) {
+    for (const entry of entries) {
+        if (entry.type !== "message")
+            continue;
+        const messageTimestamp = entry.message.timestamp;
+        if (messageTimestamp === timestamp)
+            return entry.id;
+    }
+    return undefined;
+}
+function findSharedContentAnchorEntryId(parentEntries, childEntries) {
+    const parentMessages = parentEntries.flatMap((entry) => {
+        const comparable = getComparableSessionMessage(entry);
+        return comparable ? [comparable] : [];
+    });
+    const childMessages = childEntries.flatMap((entry) => {
+        const comparable = getComparableSessionMessage(entry);
+        return comparable ? [comparable] : [];
+    });
+    if (parentMessages.length === 0 || childMessages.length === 0)
+        return undefined;
+    let bestParentEnd = -1;
+    let bestLength = 0;
+    for (let parentStart = 0; parentStart < parentMessages.length; parentStart++) {
+        let length = 0;
+        while (parentStart + length < parentMessages.length && length < childMessages.length) {
+            const parentMessage = parentMessages[parentStart + length];
+            const childMessage = childMessages[length];
+            if (parentMessage === undefined ||
+                childMessage === undefined ||
+                parentMessage.role !== childMessage.role ||
+                parentMessage.normalizedText !== childMessage.normalizedText) {
+                break;
+            }
+            length += 1;
+        }
+        if (length > bestLength) {
+            bestLength = length;
+            bestParentEnd = parentStart + length - 1;
+        }
+    }
+    return bestLength > 0 ? parentMessages[bestParentEnd]?.entryId : undefined;
+}
+function getComparableSessionMessage(entry) {
+    if (entry.type !== "message")
+        return null;
+    const role = entry.message.role;
+    if (role !== "user" && role !== "assistant")
+        return null;
+    const body = contentToText(entry.message.content);
+    const normalizedText = normalizeComparableSessionText(body, role);
+    if (!normalizedText)
+        return null;
+    return { entryId: entry.id, role, normalizedText };
+}
+function normalizeComparableSessionText(text, role) {
+    const normalized = role === "user" ? normalizeComparableUserText(text) : text.trim();
+    return normalized.replace(/\s+/g, " ").trim();
+}
+function findParentAnchorByRootMessage(parentEntries, childRoot) {
+    let textMatchId;
+    for (const entry of parentEntries) {
+        const comparable = getComparableUserMessage(entry);
+        if (!comparable)
+            continue;
+        if (comparable.normalizedText !== childRoot.normalizedText)
+            continue;
+        if (childRoot.messageTimestamp !== undefined &&
+            comparable.messageTimestamp !== undefined &&
+            comparable.messageTimestamp === childRoot.messageTimestamp) {
+            return entry.id;
+        }
+        textMatchId ??= entry.id;
+    }
+    return textMatchId;
+}
+function findComparableUserMessage(entries) {
+    for (const entry of entries) {
+        const comparable = getComparableUserMessage(entry);
+        if (comparable)
+            return comparable;
+    }
+    return null;
+}
+function getComparableUserMessage(entry) {
+    if (entry.type !== "message" || entry.message.role !== "user")
+        return null;
+    const body = contentToText(entry.message.content);
+    const normalizedText = normalizeComparableUserText(body);
+    if (!normalizedText)
+        return null;
+    const messageTimestamp = typeof entry.message.timestamp === "number" ? entry.message.timestamp : undefined;
+    return { normalizedText, messageTimestamp };
+}
+function normalizeComparableUserText(text) {
+    const withoutTimestamp = text.replace(/^\[[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}[+-][0-9]{2}:[0-9]{2}\]\s+(?=\[[^\]]+\](?:\s+\[in-thread:[^\]]+\])?:\s)/, "");
+    return withoutTimestamp
+        .replace(/\n*<slack_attachments>\n[\s\S]*?\n<\/slack_attachments>\s*$/g, "")
+        .trim();
+}
+function extractSessionSummary(entries) {
+    for (const entry of entries) {
+        if (entry.type !== "message")
+            continue;
+        const item = mapEntryToItem(entry);
+        if (!item?.body)
+            continue;
+        return collapseSummary(item.body);
+    }
+    return undefined;
+}
+function collapseSummary(text) {
+    const singleLine = text.replace(/\s+/g, " ").trim();
+    return singleLine.length > 96 ? `${singleLine.slice(0, 93)}…` : singleLine;
+}
+function mapEntryToItem(entry) {
+    switch (entry.type) {
+        case "message":
+            return mapMessageEntry(entry);
+        case "model_change":
+            return {
+                kind: "system",
+                title: "Model changed",
+                body: `${entry.provider} / ${entry.modelId}`,
+                meta: entryIsoTime(entry) ?? "",
+                tone: "muted",
+            };
+        case "thinking_level_change":
+            return {
+                kind: "system",
+                title: "Thinking level changed",
+                body: entry.thinkingLevel,
+                meta: entryIsoTime(entry) ?? "",
+                tone: "muted",
+            };
+        case "compaction":
+            return mapCompactionEntry(entry);
+        case "branch_summary":
+            return mapSessionSummaryEntry(entry);
+        case "custom":
+            return {
+                kind: "system",
+                title: `Custom data · ${entry.customType}`,
+                body: entry.data === undefined ? "(no data)" : JSON.stringify(entry.data, null, 2),
+                meta: entryIsoTime(entry) ?? "",
+                tone: "muted",
+            };
+        default:
+            return null;
+    }
+}
+function mapMessageEntry(entry) {
+    const message = entry.message;
+    switch (message.role) {
+        case "user":
+            return {
+                kind: "user",
+                title: "User",
+                body: contentToText(message.content),
+                meta: entryIsoTime(entry) ?? "",
+                entryId: entry.id,
+            };
+        case "assistant": {
+            const assistantBody = contentToText(message.content) || (message.errorMessage ? `_${message.errorMessage}_` : "");
+            const metaParts = [message.provider, message.model, message.stopReason].filter(Boolean);
+            return {
+                kind: "assistant",
+                title: "Assistant",
+                body: assistantBody,
+                meta: metaParts.length > 0
+                    ? `${entryIsoTime(entry) ?? ""} · ${metaParts.join(" · ")}`
+                    : (entryIsoTime(entry) ?? ""),
+                entryId: entry.id,
+            };
+        }
+        case "toolResult":
+            return {
+                kind: "tool",
+                title: `Tool result · ${String(message.toolName ?? "unknown")}`,
+                body: contentToText(message.content),
+                meta: entryIsoTime(entry) ?? "",
+                tone: message.isError ? "err" : "ok",
+                entryId: entry.id,
+            };
+        case "bashExecution": {
+            const command = String(message.command ?? "").trim();
+            const output = String(message.output ?? "").trim();
+            const details = [
+                typeof message.exitCode === "number" ? `[exitCode] ${message.exitCode}` : "",
+                message.cancelled ? `[cancelled] true` : "",
+                message.truncated ? `[truncated] true` : "",
+            ].filter(Boolean);
+            const body = [command ? `$ ${command}` : "", output, ...details].filter(Boolean).join("\n\n");
+            return {
+                kind: "tool",
+                title: "Bash execution",
+                body: body || "(no output)",
+                meta: entryIsoTime(entry) ?? "",
+                entryId: entry.id,
+            };
+        }
+        case "custom":
+            return {
+                kind: "system",
+                title: `Custom message · ${String(message.customType ?? "custom")}`,
+                body: contentToText(message.content),
+                meta: entryIsoTime(entry) ?? "",
+                tone: "muted",
+                entryId: entry.id,
+            };
+        case "branchSummary":
+            return {
+                kind: "system",
+                title: "Session summary",
+                body: String(message.summary ?? ""),
+                meta: entryIsoTime(entry) ?? "",
+                tone: "muted",
+                entryId: entry.id,
+            };
+        case "compactionSummary":
+            return {
+                kind: "system",
+                title: "Compaction summary",
+                body: String(message.summary ?? ""),
+                meta: entryIsoTime(entry) ?? "",
+                tone: "muted",
+                entryId: entry.id,
+            };
+        default:
+            return {
+                kind: "system",
+                title: `Message · ${String(message.role ?? "unknown")}`,
+                body: contentToText(message.content),
+                meta: entryIsoTime(entry) ?? "",
+                tone: "muted",
+                entryId: entry.id,
+            };
+    }
+}
+function mapCompactionEntry(entry) {
+    return {
+        kind: "system",
+        title: "Context compacted",
+        body: entry.summary,
+        meta: `${entryIsoTime(entry) ?? ""} · ${entry.tokensBefore} tokens before compaction`,
+        tone: "muted",
+    };
+}
+function mapSessionSummaryEntry(entry) {
+    return {
+        kind: "system",
+        title: "Session summary",
+        body: entry.summary,
+        meta: entryIsoTime(entry) ?? "",
+        tone: "muted",
+    };
+}
+function contentToText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const lines = [];
+    for (const block of content) {
+        if (!block || typeof block !== "object")
+            continue;
+        const value = block;
+        if (value.type === "text" && typeof value.text === "string") {
+            lines.push(value.text);
+            continue;
+        }
+        if (value.type === "thinking" && typeof value.thinking === "string") {
+            lines.push(`[thinking]\n${value.thinking}`);
+            continue;
+        }
+        if (value.type === "toolCall") {
+            const name = typeof value.name === "string" ? value.name : "tool";
+            const args = value.arguments === undefined ? "" : JSON.stringify(value.arguments, null, 2);
+            lines.push([`[toolCall] ${name}`, args].filter(Boolean).join("\n"));
+            continue;
+        }
+        if (value.type === "image") {
+            lines.push(`[image ${String(value.mimeType ?? "unknown")}]`);
+        }
+    }
+    return lines.join("\n\n");
+}
 //# sourceMappingURL=portal.js.map