@pasko70/pibo 1.16.6 → 2.1.1

package/dist/apps/chat/trace.js

@@ -1,72 +1,34 @@
 import { createHash } from "node:crypto";
-import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { parseSessionEntries, SessionManager } from "@earendil-works/pi-coding-agent";
-import { buildTraceViewFromEvents } from "../../shared/trace-engine.js";
+import { PI_HISTORY_PAGE_MAX_BYTES, PI_HISTORY_SCAN_MAX_BYTES, PI_HISTORY_TAIL_MAX_BYTES, listPiHistorySessions, loadPiHistoryFastMetadata, loadPiHistoryMetadata, piSessionEntriesToAgentRuntimeHistoryEntries, readPiTranscriptHistoryPage, readPiTranscriptTailEntries, } from "../../agent-runtimes/pi/history.js";
+import { buildTraceViewFromEvents, traceNodesFromHistoryEntries } from "../../shared/trace-engine.js";
 import { isChatWebSessionArchived } from "./session-metadata.js";
 import { workflowSessionKindFromMetadata } from "../../sessions/workflow-session-kind.js";
-export { compareTraceNodes, sortTraceNodes, nestTraceNodes, flattenTraceNodes, mapTraceNodesById, buildTraceViewFromEvents, traceNodesFromEntries, } from "../../shared/trace-engine.js";
-export const TRACE_TRANSCRIPT_TAIL_MAX_BYTES = 2 * 1024 * 1024;
-export const TRACE_TRANSCRIPT_HISTORY_PAGE_MAX_BYTES = 512 * 1024;
-export const TRACE_TRANSCRIPT_HISTORY_SCAN_MAX_BYTES = 16 * 1024 * 1024;
-export async function loadPiSessionMetadata(session, cwd = process.cwd()) {
-    const piSession = await findPiSession(session, cwd);
-    return metadataFromPiSession(piSession);
-}
-export async function loadPiSessionFastMetadata(session, cwd = process.cwd()) {
-    const piSession = findPiSessionDirectFast(session.piSessionId, cwd)
-        ?? findPiSessionDirect(session.piSessionId, cwd, { fast: true });
-    return metadataFromPiSession(piSession);
-}
-function metadataFromPiSession(piSession) {
-    if (!piSession)
-        return {};
-    let sessionSize;
-    let sessionMtimeMs;
-    try {
-        const stats = statSync(piSession.path);
-        sessionSize = stats.size;
-        sessionMtimeMs = stats.mtimeMs;
-    }
-    catch {
-        // The session list can contain a file that was removed before trace rendering.
-    }
-    return {
-        sessionPath: piSession.path,
-        sessionSize,
-        sessionMtimeMs,
-        name: piSession.name,
-        firstMessage: piSession.firstMessage,
-        modified: piSession.modified,
-    };
-}
-export async function buildSessionNodes(sessions, indexItems, cwd = process.cwd(), unreadCounts = new Map(), options = {}) {
+export { compareTraceNodes, sortTraceNodes, nestTraceNodes, flattenTraceNodes, mapTraceNodesById, buildTraceViewFromEvents, traceNodesFromHistoryEntries, } from "../../shared/trace-engine.js";
+export const TRACE_TRANSCRIPT_TAIL_MAX_BYTES = PI_HISTORY_TAIL_MAX_BYTES;
+export const TRACE_TRANSCRIPT_HISTORY_PAGE_MAX_BYTES = PI_HISTORY_PAGE_MAX_BYTES;
+export const TRACE_TRANSCRIPT_HISTORY_SCAN_MAX_BYTES = PI_HISTORY_SCAN_MAX_BYTES;
+export async function buildSessionNodes(sessions, indexItems, _cwd = process.cwd(), unreadCounts = new Map(), options = {}) {
     const indexByKey = new Map(indexItems.map((item) => [item.piboSessionId, item]));
     const nodes = new Map();
-    const piSessionsByCwd = new Map();
     for (const session of sessions) {
-        let metadata = {};
-        if (!session.title && !options.skipPiMetadataFallback) {
-            const sessionCwd = session.workspace ?? cwd;
-            let piSessions = piSessionsByCwd.get(sessionCwd);
-            if (!piSessions) {
-                piSessions = listPiSessions(sessionCwd);
-                piSessionsByCwd.set(sessionCwd, piSessions);
-            }
-            metadata = metadataFromPiSession((await piSessions).find((piSession) => piSession.id === session.piSessionId));
-        }
+        const inspection = !session.title && !options.skipPiMetadataFallback && options.loadHistoryInspection
+            ? await options.loadHistoryInspection(session)
+            : undefined;
         const indexed = indexByKey.get(session.id);
         nodes.set(session.id, {
             piboSessionId: session.id,
             piSessionId: session.piSessionId,
+            runtimeInstanceId: session.runtimeBinding?.runtimeInstanceId ?? indexed?.runtimeInstanceId,
+            runtimeAdapterId: session.runtimeBinding?.adapterId ?? indexed?.runtimeAdapterId,
+            runtimeBindingState: session.runtimeBinding?.state ?? indexed?.runtimeBindingState,
+            nativeSessionId: session.runtimeBinding?.nativeSessionId ?? indexed?.nativeSessionId,
             parentId: session.parentId,
             originId: session.originId,
             profile: session.profile,
             activeModel: session.activeModel,
             subagentName: stringValue(session.metadata?.subagentName),
             workflowSessionKind: workflowSessionKindFromMetadata(session.metadata),
-            title: createSessionTitle(session, metadata),
+            title: createSessionTitle(session, historyMetadataFromInspection(inspection)),
             subtitle: session.id,
             archived: isChatWebSessionArchived(session),
             status: sessionNodeStatus(indexed?.status),
@@ -79,12 +41,10 @@ export async function buildSessionNodes(sessions, indexItems, cwd = process.cwd(
     const roots = [];
     for (const node of nodes.values()) {
         const parent = node.parentId ? nodes.get(node.parentId) : undefined;
-        if (parent) {
+        if (parent)
             parent.children.push(node);
-        }
-        else {
+        else
             roots.push(node);
-        }
     }
     for (const node of nodes.values()) {
         if (!node.originId)
@@ -95,6 +55,9 @@ export async function buildSessionNodes(sessions, indexItems, cwd = process.cwd(
         origin.derivedSessions.push({
             piboSessionId: node.piboSessionId,
             profile: node.profile,
+            runtimeInstanceId: node.runtimeInstanceId,
+            runtimeAdapterId: node.runtimeAdapterId,
+            runtimeBindingState: node.runtimeBindingState,
             subagentName: node.subagentName,
             workflowSessionKind: node.workflowSessionKind,
             title: node.title,
@@ -116,81 +79,78 @@ function sessionNodeStatus(indexedStatus) {
     return indexedStatus ?? "idle";
 }
 export async function buildTraceView(input) {
-    const metadata = input.metadata ?? (await loadPiSessionMetadata(input.session, input.session.workspace ?? input.cwd));
-    const allEntries = input.transcriptEntries ?? (metadata.sessionPath ? readEntries(metadata.sessionPath) : []);
+    const historyMetadata = input.historyInspection
+        ? historyMetadataFromInspection(input.historyInspection)
+        : historyMetadataFromPiCompatibility(input.metadata);
+    const entries = [...(input.historyEntries ?? (input.transcriptEntries
+            ? piSessionEntriesToAgentRuntimeHistoryEntries(input.transcriptEntries)
+            : []))];
     const sessionStatus = input.status ?? "idle";
     const view = buildTraceViewFromEvents({
         session: {
             id: input.session.id,
             piSessionId: input.session.piSessionId,
-            title: createSessionTitle(input.session, metadata),
+            title: createSessionTitle(input.session, historyMetadata),
         },
         events: input.events,
         turnTimings: input.turnTimings,
-        transcriptEntries: allEntries,
-        sessions: input.sessions.map((s) => ({
-            id: s.id,
-            parentId: s.parentId ?? null,
-            originId: s.originId ?? null,
-            updatedAt: s.updatedAt,
-            title: s.title ?? null,
-            metadata: s.metadata,
+        historyEntries: entries,
+        sessions: input.sessions.map((session) => ({
+            id: session.id,
+            parentId: session.parentId ?? null,
+            originId: session.originId ?? null,
+            updatedAt: session.updatedAt,
+            title: session.title ?? null,
+            metadata: session.metadata,
         })),
         status: sessionStatus,
         latestStreamId: input.latestStreamId,
         includeRawEvents: input.includeRawEvents,
         rawEventsLimit: input.rawEventsLimit,
     });
-    if (input.transcriptOrderOffset && input.transcriptOrderOffset > 0) {
-        offsetTranscriptTraceOrder(view.nodes, input.transcriptOrderOffset);
-    }
-    annotateForkableUserMessageNodes(view.nodes, allEntries);
+    const historyOrderOffset = input.historyOrderOffset ?? input.transcriptOrderOffset;
+    if (historyOrderOffset && historyOrderOffset > 0)
+        offsetHistoryTraceOrder(view.nodes, historyOrderOffset);
+    annotateForkableUserMessageNodes(view.nodes, entries);
     return {
         ...view,
+        runtimeBinding: traceRuntimeBinding(input.session),
         version: createTraceViewVersion({
             session: input.session,
             sessions: input.sessions,
             events: input.events,
             status: sessionStatus,
-            metadata,
+            history: historyMetadata,
             latestStreamId: input.latestStreamId,
         }),
     };
 }
-export async function loadPiSessionTailEntries(session, cwd = process.cwd(), maxBytes = TRACE_TRANSCRIPT_TAIL_MAX_BYTES) {
-    const metadata = await loadPiSessionMetadata(session, cwd);
-    if (!metadata.sessionPath)
-        return { metadata, entries: [] };
-    return { metadata, entries: readTailEntries(metadata.sessionPath, maxBytes) };
-}
 export function createTraceViewVersion(input) {
-    const relevantSessions = input.sessions
-        .map((session) => ({
+    const history = input.history ?? historyMetadataFromPiCompatibility(input.metadata);
+    const relevantSessions = input.sessions.map((session) => ({
         id: session.id,
         parentId: session.parentId ?? null,
         originId: session.originId ?? null,
         updatedAt: session.updatedAt,
         title: session.title ?? null,
-    }))
-        .sort((left, right) => left.id.localeCompare(right.id));
+    })).sort((left, right) => left.id.localeCompare(right.id));
     const eventTail = input.events.at(-1);
-    return createHash("sha1")
-        .update(JSON.stringify({
-        traceProjection: "turn-timing-v2",
+    return createHash("sha1").update(JSON.stringify({
+        traceProjection: "runtime-history-v1",
         session: {
             id: input.session.id,
             piSessionId: input.session.piSessionId,
             profile: input.session.profile,
             title: input.session.title ?? null,
             updatedAt: input.session.updatedAt,
+            runtimeBinding: traceRuntimeBinding(input.session),
         },
-        metadata: {
-            sessionPath: input.metadata?.sessionPath ?? null,
-            sessionSize: input.metadata?.sessionSize ?? null,
-            sessionMtimeMs: input.metadata?.sessionMtimeMs ?? null,
-            name: input.metadata?.name ?? null,
-            firstMessage: input.metadata?.firstMessage ?? null,
-            modified: input.metadata?.modified ?? null,
+        history: {
+            version: history.version ?? null,
+            sizeBytes: history.sizeBytes ?? null,
+            updatedAt: history.updatedAt ?? null,
+            title: history.title ?? null,
+            firstMessage: history.firstMessage ?? null,
         },
         status: input.status ?? "idle",
         events: {
@@ -199,40 +159,53 @@ export function createTraceViewVersion(input) {
             latestStreamId: input.latestStreamId ?? null,
         },
         sessions: relevantSessions,
-    }))
-        .digest("hex");
+    })).digest("hex");
+}
+function traceRuntimeBinding(session) {
+    const binding = session.runtimeBinding;
+    return binding ? {
+        runtimeInstanceId: binding.runtimeInstanceId,
+        adapterId: binding.adapterId,
+        nativeSessionId: binding.nativeSessionId,
+        state: binding.state,
+        protocol: binding.protocol,
+        protocolVersion: binding.protocolVersion,
+        adapterVersion: binding.adapterVersion,
+        revision: binding.revision,
+    } : undefined;
+}
+function historyMetadataFromPiCompatibility(metadata) {
+    if (!metadata)
+        return {};
+    return {
+        title: metadata.name,
+        firstMessage: metadata.firstMessage,
+        createdAt: metadata.created,
+        updatedAt: metadata.modified,
+        sizeBytes: metadata.sessionSize,
+        version: metadata.sessionPath ? createHash("sha1").update(JSON.stringify({
+            path: metadata.sessionPath,
+            size: metadata.sessionSize ?? null,
+            mtime: metadata.sessionMtimeMs ?? null,
+        })).digest("hex") : undefined,
+        locator: metadata.sessionPath ? { kind: "local-file", value: metadata.sessionPath } : undefined,
+    };
 }
-const PI_SESSION_LIST_CACHE_TTL_MS = 5_000;
-const PI_SESSION_DIRECT_CACHE_TTL_MS = 5_000;
-const PI_SESSION_FAST_HEAD_BYTES = 64 * 1024;
-const piSessionListCache = new Map();
-const piSessionDirectCache = new Map();
-export async function listPiSessions(cwd = process.cwd()) {
-    const now = Date.now();
-    const cached = piSessionListCache.get(cwd);
-    if (cached && cached.expiresAt > now)
-        return cached.promise;
-    const promise = SessionManager.list(cwd).then((sessions) => sessions.map((session) => ({
-        path: session.path,
-        id: session.id,
-        cwd: session.cwd,
-        name: session.name,
-        parentSessionPath: session.parentSessionPath,
-        created: session.created.toISOString(),
-        modified: session.modified.toISOString(),
-        messageCount: session.messageCount,
-        firstMessage: session.firstMessage,
-    })));
-    piSessionListCache.set(cwd, { expiresAt: now + PI_SESSION_LIST_CACHE_TTL_MS, promise });
-    promise.catch(() => {
-        if (piSessionListCache.get(cwd)?.promise === promise)
-            piSessionListCache.delete(cwd);
-    });
-    return promise;
+function historyMetadataFromInspection(inspection) {
+    if (!inspection)
+        return {};
+    return {
+        title: inspection.title,
+        firstMessage: inspection.firstMessage,
+        createdAt: inspection.createdAt,
+        updatedAt: inspection.updatedAt,
+        sizeBytes: inspection.sizeBytes,
+        version: inspection.version,
+        locator: inspection.locator,
+    };
 }
 function createSessionTitle(session, metadata) {
-    const candidate = session.title || metadata.name || metadata.firstMessage || session.id;
-    return truncateTitle(candidate);
+    return truncateTitle(session.title || metadata.title || metadata.firstMessage || session.id);
 }
 function truncateTitle(title, maxLength = 56) {
     const normalized = title.replace(/\s+/g, " ").trim();
@@ -240,267 +213,9 @@ function truncateTitle(title, maxLength = 56) {
         return normalized || "Untitled Session";
     return `${normalized.slice(0, maxLength - 1)}…`;
 }
-async function findPiSession(piboSession, cwd) {
-    return (findPiSessionDirect(piboSession.piSessionId, cwd) ??
-        (await listPiSessions(cwd)).find((session) => session.id === piboSession.piSessionId));
-}
-function findPiSessionDirectFast(piSessionId, cwd) {
-    const cacheKey = `${cwd}\0${piSessionId}`;
-    const cached = piSessionDirectCache.get(cacheKey);
-    if (!cached || cached.expiresAt <= Date.now())
-        return undefined;
-    try {
-        const stats = statSync(cached.path);
-        if (stats.size === cached.size && stats.mtimeMs === cached.mtimeMs)
-            return cached.item;
-    }
-    catch {
-        piSessionDirectCache.delete(cacheKey);
-    }
-    return undefined;
-}
-function setPiSessionDirectFastCache(piSessionId, cwd, item, stats) {
-    piSessionDirectCache.set(`${cwd}\0${piSessionId}`, {
-        expiresAt: Date.now() + PI_SESSION_DIRECT_CACHE_TTL_MS,
-        path: item.path,
-        size: stats.size,
-        mtimeMs: stats.mtimeMs,
-        item,
-    });
-}
-function findPiSessionDirect(piSessionId, cwd, options = {}) {
-    const sessionDir = defaultPiSessionDir(cwd);
-    if (!existsSync(sessionDir))
-        return undefined;
-    try {
-        const file = readdirSync(sessionDir).find((candidate) => candidate.endsWith(`_${piSessionId}.jsonl`));
-        if (!file)
-            return undefined;
-        const sessionPath = join(sessionDir, file);
-        const stats = statSync(sessionPath);
-        const entries = options.fast
-            ? readHeadEntries(sessionPath, stats.size, PI_SESSION_FAST_HEAD_BYTES)
-            : parseSessionEntries(readFileSync(sessionPath, "utf8"));
-        const header = entries.find((entry) => entry.type === "session");
-        if (header?.id !== piSessionId)
-            return undefined;
-        let name;
-        let firstMessage = "";
-        let messageCount = 0;
-        for (const entry of entries) {
-            if (entry.type === "session_info")
-                name = stringValue(entry.name)?.trim() || undefined;
-            if (entry.type !== "message")
-                continue;
-            messageCount++;
-            if (firstMessage || messageRole(entry) !== "user")
-                continue;
-            firstMessage = extractMessageText(messageContent(entry));
-        }
-        const item = {
-            path: sessionPath,
-            id: piSessionId,
-            cwd: stringValue(header.cwd) ?? cwd,
-            name,
-            parentSessionPath: stringValue(header.parentSession),
-            created: stringValue(header.timestamp) ?? stats.birthtime.toISOString(),
-            modified: options.fast
-                ? stats.mtime.toISOString()
-                : sessionModifiedIso(entries.filter((entry) => entry.type !== "session"), stringValue(header.timestamp), stats.mtime),
-            messageCount,
-            firstMessage: firstMessage || "(no messages)",
-        };
-        if (options.fast)
-            setPiSessionDirectFastCache(piSessionId, cwd, item, stats);
-        return item;
-    }
-    catch {
-        return undefined;
-    }
-}
-function defaultPiSessionDir(cwd) {
-    const agentDir = process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent");
-    const safePath = `--${cwd.replace(/^[\\/]/, "").replace(/[\\/:]/g, "-")}--`;
-    return join(agentDir, "sessions", safePath);
-}
-function sessionModifiedIso(entries, headerTimestamp, statsMtime) {
-    let lastActivityTime;
-    for (const entry of entries) {
-        if (entry.type !== "message")
-            continue;
-        const timestamp = entry.message.timestamp;
-        if (typeof timestamp === "number") {
-            lastActivityTime = Math.max(lastActivityTime ?? 0, timestamp);
-            continue;
-        }
-        const entryTime = new Date(entry.timestamp).getTime();
-        if (!Number.isNaN(entryTime))
-            lastActivityTime = Math.max(lastActivityTime ?? 0, entryTime);
-    }
-    if (lastActivityTime)
-        return new Date(lastActivityTime).toISOString();
-    const headerTime = headerTimestamp ? new Date(headerTimestamp).getTime() : NaN;
-    return !Number.isNaN(headerTime) ? new Date(headerTime).toISOString() : statsMtime.toISOString();
-}
-function readEntries(path) {
-    if (!existsSync(path))
-        return [];
-    const content = readFileSync(path, "utf8");
-    return parseSessionEntries(content).filter((entry) => entry.type !== "session");
-}
-function readHeadEntries(path, fileSize, maxBytes) {
-    const length = Math.max(1, Math.min(maxBytes, fileSize));
-    const buffer = Buffer.alloc(length);
-    const fd = openSync(path, "r");
-    try {
-        const bytesRead = readSync(fd, buffer, 0, length, 0);
-        let content = buffer.subarray(0, bytesRead).toString("utf8");
-        if (bytesRead < fileSize && !content.endsWith("\n")) {
-            const lastNewline = content.lastIndexOf("\n");
-            if (lastNewline >= 0)
-                content = content.slice(0, lastNewline + 1);
-        }
-        if (!content.trim())
-            return [];
-        return parseSessionEntries(content.endsWith("\n") ? content : `${content}\n`);
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-export function readTailEntries(path, maxBytes = TRACE_TRANSCRIPT_TAIL_MAX_BYTES) {
-    if (!existsSync(path))
-        return [];
-    const stats = statSync(path);
-    if (stats.size <= maxBytes)
-        return readEntries(path);
-    const length = Math.max(1, Math.min(maxBytes, stats.size));
-    const start = stats.size - length;
-    const buffer = Buffer.alloc(length);
-    const fd = openSync(path, "r");
-    try {
-        const bytesRead = readSync(fd, buffer, 0, length, start);
-        let content = buffer.subarray(0, bytesRead).toString("utf8");
-        const firstNewline = content.indexOf("\n");
-        if (start > 0 && firstNewline >= 0)
-            content = content.slice(firstNewline + 1);
-        return parseSessionEntries(content).filter((entry) => entry.type !== "session");
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-export function readTranscriptHistoryPage(path, input = {}) {
-    if (!existsSync(path))
-        return { entries: [], hasOlder: false, scannedBytes: 0, startByte: 0, endByte: 0 };
-    const stats = statSync(path);
-    const fileSize = Math.max(0, stats.size);
-    const initialEnd = input.beforeByte === undefined
-        ? fileSize
-        : Math.max(0, Math.min(input.beforeByte, fileSize));
-    const limit = Math.max(1, Math.min(input.limit ?? 50, 500));
-    const pageBytes = Math.max(1024, Math.min(input.pageBytes ?? TRACE_TRANSCRIPT_HISTORY_PAGE_MAX_BYTES, TRACE_TRANSCRIPT_HISTORY_SCAN_MAX_BYTES));
-    const maxScanBytes = Math.max(pageBytes, Math.min(input.maxScanBytes ?? TRACE_TRANSCRIPT_HISTORY_SCAN_MAX_BYTES, 32 * 1024 * 1024));
-    const beforeTime = input.beforeTimestamp ? Date.parse(input.beforeTimestamp) : undefined;
-    const entries = [];
-    let cursorEnd = initialEnd;
-    let scannedBytes = 0;
-    let nextBeforeByte;
-    while (cursorEnd > 0 && entries.length < limit && scannedBytes < maxScanBytes) {
-        const chunkStart = Math.max(0, cursorEnd - pageBytes);
-        const chunk = readUtf8Range(path, chunkStart, cursorEnd);
-        scannedBytes += cursorEnd - chunkStart;
-        const records = transcriptLineRecords(chunk, chunkStart, cursorEnd);
-        for (let index = records.length - 1; index >= 0; index -= 1) {
-            const record = records[index];
-            const parsed = parseTranscriptLine(record.text);
-            for (let entryIndex = parsed.length - 1; entryIndex >= 0; entryIndex -= 1) {
-                const entry = parsed[entryIndex];
-                if (beforeTime !== undefined && entryTimestampMs(entry) >= beforeTime)
-                    continue;
-                entries.push({ entry, startByte: record.startByte });
-                if (entries.length >= limit) {
-                    nextBeforeByte = record.startByte;
-                    break;
-                }
-            }
-            if (entries.length >= limit)
-                break;
-        }
-        cursorEnd = chunkStart;
-    }
-    if (nextBeforeByte === undefined)
-        nextBeforeByte = cursorEnd > 0 ? cursorEnd : undefined;
-    return {
-        entries: entries.reverse().map((item) => item.entry),
-        nextBeforeByte,
-        hasOlder: nextBeforeByte !== undefined && nextBeforeByte > 0,
-        scannedBytes,
-        startByte: nextBeforeByte ?? 0,
-        endByte: initialEnd,
-    };
-}
-function readUtf8Range(path, start, end) {
-    const length = Math.max(0, end - start);
-    if (length === 0)
-        return "";
-    const buffer = Buffer.alloc(length);
-    const fd = openSync(path, "r");
-    try {
-        const bytesRead = readSync(fd, buffer, 0, length, start);
-        return buffer.subarray(0, bytesRead).toString("utf8");
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-function transcriptLineRecords(content, startByte, endByte) {
-    let text = content;
-    let byteOffset = startByte;
-    if (startByte > 0) {
-        const firstNewline = text.indexOf("\n");
-        if (firstNewline < 0)
-            return [];
-        const skipped = text.slice(0, firstNewline + 1);
-        byteOffset += Buffer.byteLength(skipped, "utf8");
-        text = text.slice(firstNewline + 1);
-    }
-    if (endByte > startByte && text && !text.endsWith("\n")) {
-        const lastNewline = text.lastIndexOf("\n");
-        if (lastNewline >= 0)
-            text = text.slice(0, lastNewline + 1);
-    }
-    const records = [];
-    const segments = text.match(/[^\n]*(?:\n|$)/g) ?? [];
-    for (const segment of segments) {
-        if (!segment)
-            continue;
-        const lineStart = byteOffset;
-        byteOffset += Buffer.byteLength(segment, "utf8");
-        const line = segment.replace(/\r?\n$/, "");
-        if (line.trim())
-            records.push({ text: line, startByte: lineStart });
-    }
-    return records;
-}
-function parseTranscriptLine(line) {
-    try {
-        return parseSessionEntries(`${line}\n`).filter((entry) => entry.type !== "session");
-    }
-    catch {
-        return [];
-    }
-}
-function entryTimestampMs(entry) {
-    const timestamp = entry.timestamp;
-    if (typeof timestamp !== "string")
-        return Number.POSITIVE_INFINITY;
-    const parsed = Date.parse(timestamp);
-    return Number.isFinite(parsed) ? parsed : Number.POSITIVE_INFINITY;
-}
-function offsetTranscriptTraceOrder(nodes, offset) {
+function offsetHistoryTraceOrder(nodes, offset) {
     for (const node of nodes) {
-        if (node.source === "transcript" && node.orderKey) {
+        if ((node.source === "transcript" || node.source === "product-history") && node.orderKey) {
             const transcriptIndex = node.orderKey.transcriptIndex;
             node.orderKey = {
                 ...node.orderKey,
@@ -508,11 +223,13 @@ function offsetTranscriptTraceOrder(nodes, offset) {
                 transcriptIndex: transcriptIndex === undefined ? undefined : transcriptIndex + offset,
             };
         }
-        offsetTranscriptTraceOrder(node.children, offset);
+        offsetHistoryTraceOrder(node.children, offset);
     }
 }
 function annotateForkableUserMessageNodes(nodes, entries) {
-    const candidates = userMessageForkCandidates(entries);
+    const candidates = entries.flatMap((entry) => entry.type === "message" && entry.role === "user" && entry.nativeEntryId
+        ? [{ entryId: entry.nativeEntryId, text: historyMessageText(entry) }]
+        : []);
     if (!candidates.length)
         return;
     const used = new Set();
@@ -538,37 +255,31 @@ function flattenTraceNodesForForkAnnotation(nodes) {
     visit(nodes);
     return flattened;
 }
-function userMessageForkCandidates(entries) {
-    const candidates = [];
-    for (const entry of entries) {
-        if (entry.type !== "message" || messageRole(entry) !== "user")
-            continue;
-        const text = extractMessageText(messageContent(entry));
-        if (text)
-            candidates.push({ entryId: entry.id, text });
-    }
-    return candidates;
+function historyMessageText(entry) {
+    if (typeof entry.content === "string")
+        return entry.content;
+    return entry.content.map((part) => part.type === "text" ? part.text : "").join("");
 }
-function messageRole(entry) {
-    return entry.type === "message" ? entry.message.role : undefined;
+function stringValue(value) {
+    return typeof value === "string" ? value : undefined;
 }
-function messageContent(entry) {
-    return entry.type === "message" ? entry.message.content : undefined;
+// Pi compatibility exports. Normal Chat Web history resolves through the selected runtime adapter.
+export async function loadPiSessionMetadata(session, cwd = process.cwd()) {
+    return await loadPiHistoryMetadata(session.runtimeBinding?.nativeSessionId ?? session.piSessionId, cwd);
 }
-function extractMessageText(content) {
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    return content
-        .map((part) => {
-        if (!part || typeof part !== "object")
-            return "";
-        const typed = part;
-        return typed.type === "text" && typeof typed.text === "string" ? typed.text : "";
-    })
-        .join("");
+export async function loadPiSessionFastMetadata(session, cwd = process.cwd()) {
+    return loadPiHistoryFastMetadata(session.runtimeBinding?.nativeSessionId ?? session.piSessionId, cwd);
 }
-function stringValue(value) {
-    return typeof value === "string" ? value : undefined;
+export async function loadPiSessionTailEntries(session, cwd = process.cwd(), maxBytes = TRACE_TRANSCRIPT_TAIL_MAX_BYTES) {
+    const metadata = await loadPiSessionMetadata(session, cwd);
+    if (!metadata.sessionPath)
+        return { metadata, entries: [] };
+    return { metadata, entries: readPiTranscriptTailEntries(metadata.sessionPath, maxBytes) };
+}
+export const listPiSessions = listPiHistorySessions;
+export const readTailEntries = readPiTranscriptTailEntries;
+export const readTranscriptHistoryPage = readPiTranscriptHistoryPage;
+/** @deprecated Pi compatibility helper. Use traceNodesFromHistoryEntries. */
+export function traceNodesFromEntries(piboSessionId, entries, turnTimings = []) {
+    return traceNodesFromHistoryEntries(piboSessionId, piSessionEntriesToAgentRuntimeHistoryEntries(entries), turnTimings);
 }