@pasko70/pibo 1.16.6 → 2.0.0

package/dist/apps/chat/web-app.js

@@ -2,24 +2,28 @@ import { createHash, randomUUID } from "node:crypto";
 import os from "node:os";
 import { monitorEventLoopDelay } from "node:perf_hooks";
 import { PiboSteeringUnavailableError } from "../../core/events.js";
+import { PI_AGENT_RUNTIME_CAPABILITIES } from "../../agent-runtimes/pi/adapter.js";
+import { AgentRuntimeBindingMissingError } from "../../agent-runtime/errors.js";
+import { buildPortableRuntimeContextSnapshot, profileWithRuntimeInstance, uniqueRuntimeDiagnostics, } from "../../agent-runtime/context-build.js";
+import { PiboRuntimeResourceService } from "../../agent-runtime/resource-service.js";
 import { summarizeSessionSignalStatus } from "../../signals/status.js";
 import { PiboWebHttpError, readJsonBody, responseJson } from "../../web/http.js";
 import { OutputCompactor } from "./output-compactor.js";
 import { isLiveOnlyOutputEvent, isPersistableOutputEvent } from "./output-event-policy.js";
 import { chatRoomIdFromMetadata, isDefaultPiboRoom, isPiboRoomArchived, roomWorkspaceFromMetadata, withChatRoomId, withPiboRoomWorkspace, } from "./types/rooms.js";
 import { chatStreamFramesFromOutputEvent, createChatStreamState, nextTransientChatStreamFrameId } from "./stream.js";
-import { buildSessionNodes, buildTraceView, createTraceViewVersion, loadPiSessionFastMetadata, loadPiSessionMetadata, readTailEntries, readTranscriptHistoryPage } from "./trace.js";
+import { buildSessionNodes, buildTraceView } from "./trace.js";
 import { DEFAULT_TRACE_EVENTS_PAGE_SIZE, annotateTracePage, etagForVersion, estimateTraceViewBytes, traceCacheEstimatedBytes, liveSnapshotVersion, requestMatchesVersion, setTraceCache, traceProjectionStatus, traceCacheKey, withLiveSnapshots, withRawTraceTail, } from "./chat-trace-helpers.js";
 import { TRACE_V2_DEFAULT_TIMELINE_LIMIT, TRACE_V2_MAX_TIMELINE_LIMIT, TRACE_V2_PAYLOAD_DEFAULT_LIMIT_BYTES, TRACE_V2_PAYLOAD_MAX_LIMIT_BYTES, TRACE_V2_RAW_EVENTS_DEFAULT_LIMIT, TRACE_V2_RAW_EVENTS_MAX_LIMIT, TRACE_V2_TIMELINE_HARD_BYTES, parseTracePayloadRef, readTracePayloadChunk, traceRawEventsPageFromEvents, traceTimelinePageFromView, } from "./trace-v2.js";
 import { isChatWebSessionArchived } from "./session-metadata.js";
 import { withWorkflowSessionKind } from "../../sessions/workflow-session-kind.js";
-import { CustomAgentStore, createDefaultCustomAgentStore, } from "./agent-store.js";
+import { CustomAgentStore, createDefaultCustomAgentStore, previewCustomAgentCreate, previewCustomAgentUpdate, } from "./agent-store.js";
 import { loadPiboModelDefaults, } from "../../core/model-defaults.js";
 import { inspectPiboContextBuild } from "../../core/context-build.js";
 import { loadPiboUserSettings, updateTelemetryRetentionLastPrunedAt } from "../../core/user-settings.js";
 import { isTelemetryRetentionMaintenanceDue, maybeRunTelemetryRetentionMaintenance } from "./telemetry-retention-service.js";
 import { loadModelCatalog } from "./model-catalog.js";
-import { createCustomAgentProfileDefinition } from "./agent-profiles.js";
+import { createCustomAgentProfileDefinition, createCustomAgentRuntimeValidationProfile } from "./agent-profiles.js";
 import { createDefaultPiboReliabilityStore, PiboReliabilityStore } from "../../reliability/store.js";
 import { listMcpServerInfos } from "../../mcp/agent-context.js";
 import { getDefaultPiboWorkspace } from "../../core/workspace.js";
@@ -31,6 +35,7 @@ import { ChatReadStateService } from "./data/read-state-service.js";
 import { ChatRoomService } from "./data/room-service.js";
 import { ChatSessionQueryService } from "./data/session-query-service.js";
 import { ChatTimelineQueryService } from "./data/timeline-query-service.js";
+import { ChatHistoryQueryService } from "./data/history-query-service.js";
 import { ChatProjectService } from "./data/project-service.js";
 import { PiboDataStore } from "../../data/pibo-store.js";
 import { createDefaultPiboCronStore } from "../../cron/store.js";
@@ -40,7 +45,7 @@ import { handleChatLoopApiRequest } from "./loop-api.js";
 import { prepareWebAnnotationMessageAttachments } from "../../web-annotations/attachments.js";
 import { createDefaultWebAnnotationStore } from "../../web-annotations/store.js";
 import { CHAT_WEB_MOUNT_PATH, isChatAppPath, responseBuiltChatAsset, responseBuiltChatPublicFile, responseChatAppShell, isVscodeAppPath, responseBuiltVscodeAsset, responseVscodeAppShell } from "./static-assets.js";
-import { executeProviderAuthAction, isProviderAuthAction, providerAuthActionResponse } from "./provider-auth-actions.js";
+import { executeProviderAuthAction, isProviderAuthAction, providerAuthActionResponse, readProviderAuthCatalog, } from "./provider-auth-actions.js";
 import { prepareChatFileAttachments, resolveDownloadPath, responseChatFileDownload, saveUploadedChatFiles } from "./chat-files.js";
 import { chatSettingsRoute, chatSettingsRouteInvalidatesBootstrapCatalog, chatSettingsRouteRequiresSameOrigin, handleChatSettingsRoute, } from "./chat-settings-routes.js";
 import { chatCapabilityRoute, chatCapabilityRouteRequiresSameOrigin, handleChatCapabilityRoute, } from "./chat-capability-routes.js";
@@ -331,6 +336,7 @@ function createFastTraceV2Version(input) {
             profile: input.session.profile,
             title: input.session.title ?? null,
             updatedAt: input.session.updatedAt,
+            runtimeBinding: traceRuntimeBindingFromSession(input.session),
         },
         status: input.status ?? "idle",
         events: {
@@ -338,11 +344,13 @@ function createFastTraceV2Version(input) {
             lastActivityAt: input.lastActivityAt ?? null,
             latestStreamId: input.latestStreamId ?? null,
         },
-        transcript: {
-            sessionSize: input.transcript?.sessionSize ?? null,
-            sessionMtimeMs: input.transcript?.sessionMtimeMs ?? null,
-            modified: input.transcript?.modified ?? null,
+        productHistory: {
+            messageCount: input.productHistory?.messageCount ?? 0,
+            firstEventSequence: input.productHistory?.firstEventSequence ?? null,
+            lastEventSequence: input.productHistory?.lastEventSequence ?? null,
+            lastCreatedAt: input.productHistory?.lastCreatedAt ?? null,
         },
+        nativeHistoryVersion: input.nativeHistoryVersion ?? null,
         sessions: relevantSessions,
     }))
         .digest("hex");
@@ -896,6 +904,54 @@ function serializeCustomAgent(agent, context) {
 function serializeCustomAgents(agents, context) {
     return agents.map((agent) => serializeCustomAgent(agent, context));
 }
+const RUNTIME_PROFILE_UPDATE_FIELDS = new Set([
+    "runtimeInstanceId",
+    "runtimeOptions",
+    "nativeTools",
+    "skills",
+    "contextFiles",
+    "subagents",
+    "mcpServers",
+    "piPackages",
+    "mainModel",
+    "subagentModel",
+    "thinkingLevel",
+    "mainThinkingLevel",
+    "subagentThinkingLevel",
+    "fast",
+    "mainFast",
+    "subagentFast",
+    "builtinTools",
+    "builtinToolNames",
+    "autoContextFiles",
+    "runControl",
+    "goalControl",
+]);
+function customAgentUpdateAffectsRuntime(update) {
+    return Object.keys(update).some((field) => RUNTIME_PROFILE_UPDATE_FIELDS.has(field));
+}
+async function requireValidCustomAgentRuntime(agent, context) {
+    const profile = createCustomAgentRuntimeValidationProfile(agent);
+    let diagnostics;
+    if (context.channelContext.validateAgentRuntimeProfile) {
+        diagnostics = await context.channelContext.validateAgentRuntimeProfile(profile, process.cwd());
+    }
+    else {
+        const runtimes = context.channelContext.getCapabilityCatalog?.().agentRuntimes ?? [];
+        const selected = runtimes.find((runtime) => runtime.id === agent.runtimeInstanceId);
+        if (!selected && runtimes.length === 0 && agent.runtimeInstanceId === "pi")
+            return;
+        diagnostics = selected
+            ? selected.enabled
+                ? []
+                : [{ severity: "error", code: "runtime_instance_disabled", message: `Agent runtime instance "${selected.id}" is disabled.` }]
+            : [{ severity: "error", code: "runtime_instance_unknown", message: `Unknown agent runtime instance "${agent.runtimeInstanceId}".` }];
+    }
+    const errors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+    if (errors.length === 0)
+        return;
+    throw new PiboWebHttpError(`Agent runtime selection is invalid: ${errors.map((diagnostic) => diagnostic.message).join(" ")}`, 400);
+}
 function listBrokenContextFiles(keys, context) {
     const catalog = context.channelContext.getCapabilityCatalog?.();
     if (!catalog)
@@ -923,17 +979,48 @@ function requireSharedAgent(agent) {
     return agent;
 }
 async function buildAgentCatalog(context, state) {
+    const baseCatalog = context.channelContext.getCapabilityCatalog?.() ?? {
+        agentRuntimes: [],
+        nativeTools: [],
+        skills: [],
+        subagents: [],
+        contextFiles: [],
+        packages: [],
+        piboTools: [],
+        mcpServers: [],
+        piPackages: [],
+    };
+    let agentRuntimes = (baseCatalog.agentRuntimes ?? []).map((runtime) => {
+        const diagnostics = runtime.enabled ? [] : [{
+                severity: "error",
+                code: "runtime_instance_disabled",
+                message: `Agent runtime instance "${runtime.id}" is disabled.`,
+            }];
+        return {
+            ...runtime,
+            available: runtime.enabled,
+            diagnostics,
+        };
+    });
+    if (context.channelContext.inspectAgentRuntimeInstances) {
+        try {
+            agentRuntimes = await context.channelContext.inspectAgentRuntimeInstances();
+        }
+        catch (error) {
+            agentRuntimes = agentRuntimes.map((runtime) => ({
+                ...runtime,
+                available: false,
+                diagnostics: [{
+                        severity: "error",
+                        code: "runtime_catalog_diagnostics_failed",
+                        message: error instanceof Error ? error.message : String(error),
+                    }],
+            }));
+        }
+    }
     return {
-        ...(context.channelContext.getCapabilityCatalog?.() ?? {
-            nativeTools: [],
-            skills: [],
-            subagents: [],
-            contextFiles: [],
-            packages: [],
-            piboTools: [],
-            mcpServers: [],
-            piPackages: [],
-        }),
+        ...baseCatalog,
+        agentRuntimes,
         mcpServers: await listMcpServerInfos(),
         piPackages: listPiPackages(),
         userSkills: state.userSkillManager.list(),
@@ -2036,7 +2123,7 @@ function normalizeAgentDeleteConfirmation(value) {
     }
     return value.trim();
 }
-function deleteSessionsForAgentProfile(state, context, webSession, profileNames) {
+async function deleteSessionsForAgentProfile(state, context, webSession, profileNames) {
     const deleteSession = context.channelContext.deleteSession;
     if (!deleteSession)
         throw new PiboWebHttpError("Session deletion is not available", 501);
@@ -2055,13 +2142,13 @@ function deleteSessionsForAgentProfile(state, context, webSession, profileNames)
         }
     }
     const orderedIds = [...ids].sort((left, right) => sessionDepth(sessionsById.get(right), sessionsById) - sessionDepth(sessionsById.get(left), sessionsById));
+    for (const id of orderedIds)
+        await deleteSession(id);
     state.sessionQuery.deleteSessions(orderedIds);
     state.eventCommands.deleteSessions(orderedIds);
-    for (const id of orderedIds)
-        deleteSession(id);
     return orderedIds;
 }
-function deleteSessionSubtree(state, context, webSession, rootSession) {
+async function deleteSessionSubtree(state, context, webSession, rootSession) {
     const deleteSession = context.channelContext.deleteSession;
     if (!deleteSession)
         throw new PiboWebHttpError("Session deletion is not available", 501);
@@ -2079,13 +2166,13 @@ function deleteSessionSubtree(state, context, webSession, rootSession) {
         }
     }
     const orderedIds = [...ids].sort((left, right) => sessionDepth(sessionsById.get(right), sessionsById) - sessionDepth(sessionsById.get(left), sessionsById));
+    for (const id of orderedIds)
+        await deleteSession(id);
     state.sessionQuery.deleteSessions(orderedIds);
     state.eventCommands.deleteSessions(orderedIds);
-    for (const id of orderedIds)
-        deleteSession(id);
     return orderedIds;
 }
-function deleteRoomTree(state, context, webSession, room, confirmName) {
+async function deleteRoomTree(state, context, webSession, room, confirmName) {
     if (isDefaultPiboRoom(room))
         throw new PiboWebHttpError("Default chat cannot be deleted", 400);
     if (!isPiboRoomArchived(room))
@@ -2117,11 +2204,11 @@ function deleteRoomTree(state, context, webSession, room, confirmName) {
         }
     }
     const orderedSessionIds = [...ids].sort((left, right) => sessionDepth(sessionsById.get(right), sessionsById) - sessionDepth(sessionsById.get(left), sessionsById));
+    for (const id of orderedSessionIds)
+        await deleteSession(id);
     state.sessionQuery.deleteSessions(orderedSessionIds);
     state.eventCommands.deleteSessions(orderedSessionIds);
     state.eventCommands.deleteRooms(roomIds);
-    for (const id of orderedSessionIds)
-        deleteSession(id);
     const orderedRoomIds = [...roomIds].reverse();
     state.roomService.deleteRooms(orderedRoomIds);
     return { deletedRoomIds: orderedRoomIds, deletedSessionIds: orderedSessionIds };
@@ -2142,6 +2229,29 @@ function requireSharedSession(context, piboSessionId) {
     }
     return canonicalizeSessionProfile(context, session);
 }
+function defaultRuntimeInstanceId(context, defaultProfile) {
+    if (context.channelContext.createProfile) {
+        try {
+            return context.channelContext.createProfile(defaultProfile).runtimeInstanceId;
+        }
+        catch {
+            // Fall through to the registered runtime order when the profile is unavailable.
+        }
+    }
+    return context.channelContext.getCapabilityCatalog?.().agentRuntimes?.[0]?.id;
+}
+function sessionRuntimeInstanceId(context, session) {
+    return context.channelContext.getSessionRuntimeBinding?.(session.id)?.runtimeInstanceId
+        ?? session.runtimeBinding?.runtimeInstanceId
+        ?? (() => {
+            try {
+                return context.channelContext.createProfile?.(session.profile).runtimeInstanceId;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+}
 function resolveRequestedSession(state, context, webSession, defaultProfile, piboSessionId, roomId) {
     if (!piboSessionId)
         return ensureDefaultChatSession(state, context, webSession, defaultProfile, roomId);
@@ -2162,20 +2272,125 @@ async function buildContextBuildSnapshotForRequest(input) {
     if (!input.piboSessionId)
         throw new PiboWebHttpError("piboSessionId is required", 400);
     const selectedSession = requireSharedSession(input.context, input.piboSessionId);
-    const profile = createProfile(selectedSession.profile);
+    const configuredProfile = createProfile(selectedSession.profile);
+    const runtimeInstanceId = selectedSession.runtimeBinding?.runtimeInstanceId ?? configuredProfile.runtimeInstanceId;
+    const profile = profileWithRuntimeInstance(configuredProfile, runtimeInstanceId);
+    const cwd = selectedSession.workspace ?? getDefaultPiboWorkspace();
+    const runtime = await resolveContextBuildRuntime(input.context, runtimeInstanceId);
+    const validationDiagnostics = input.context.channelContext.validateAgentRuntimeProfile
+        ? await input.context.channelContext.validateAgentRuntimeProfile(profile, cwd)
+        : [];
+    const bindingMismatchDiagnostic = selectedSession.runtimeBinding && selectedSession.runtimeBinding.adapterId !== runtime.adapterId
+        ? [{
+                severity: "error",
+                code: "runtime_binding_adapter_mismatch",
+                message: `Session binding expects adapter "${selectedSession.runtimeBinding.adapterId}", but runtime instance "${runtime.id}" uses "${runtime.adapterId}".`,
+            }]
+        : [];
+    const diagnostics = uniqueRuntimeDiagnostics([
+        ...runtime.diagnostics,
+        ...validationDiagnostics,
+        ...bindingMismatchDiagnostic,
+    ]);
+    const runtimeInfo = {
+        runtimeInstanceId: runtime.id,
+        adapterId: runtime.adapterId,
+        available: runtime.available && !diagnostics.some((diagnostic) => diagnostic.severity === "error"),
+        transport: runtime.transport,
+        bindingState: selectedSession.runtimeBinding?.state,
+        protocol: runtime.protocol,
+        capabilities: runtime.capabilities,
+        diagnostics,
+    };
     const userSettings = loadPiboUserSettings();
-    const cwd = selectedSession?.workspace ?? getDefaultPiboWorkspace();
-    return inspectPiboContextBuild({
-        cwd,
+    const resourceService = new PiboRuntimeResourceService();
+    const resources = await resourceService.createSession({
+        piboSessionId: selectedSession.id,
+        piboRoomId: chatRoomIdFromMetadata(selectedSession.metadata),
+        runtimeInstanceId: runtime.id,
+        adapterId: runtime.adapterId,
+        sessionGeneration: `inspection-${randomUUID()}`,
         profile,
-        activeModel: selectedSession?.activeModel,
-        persistSession: false,
-        sessionContext: {
-            piboSessionId: selectedSession?.id,
-            piboRoomId: selectedSession ? chatRoomIdFromMetadata(selectedSession.metadata) : undefined,
-            timezone: userSettings.timezone,
-        },
+        cwd,
+        timezone: userSettings.timezone,
+        capabilities: runtime.capabilities,
+        strict: false,
     });
+    try {
+        if (runtime.adapterId === "pi" && runtimeInfo.available) {
+            const snapshot = await inspectPiboContextBuild({
+                cwd,
+                profile,
+                activeModel: selectedSession.activeModel,
+                persistSession: false,
+                resources,
+                sessionContext: {
+                    piboSessionId: selectedSession.id,
+                    piboRoomId: chatRoomIdFromMetadata(selectedSession.metadata),
+                    timezone: userSettings.timezone,
+                },
+            });
+            const runtimeIssues = diagnostics.filter((diagnostic) => diagnostic.severity !== "info");
+            return {
+                ...snapshot,
+                runtime: runtimeInfo,
+                diagnostics: [
+                    ...snapshot.diagnostics,
+                    ...runtimeIssues.map((diagnostic) => ({ type: diagnostic.severity, message: diagnostic.message })),
+                ],
+                summary: {
+                    ...snapshot.summary,
+                    warnings: snapshot.summary.warnings + runtimeIssues.filter((diagnostic) => diagnostic.severity === "warning").length,
+                    errors: snapshot.summary.errors + runtimeIssues.filter((diagnostic) => diagnostic.severity === "error").length,
+                },
+            };
+        }
+        return buildPortableRuntimeContextSnapshot({
+            profile,
+            runtime: runtimeInfo,
+            cwd,
+            piboSessionId: selectedSession.id,
+            piboRoomId: chatRoomIdFromMetadata(selectedSession.metadata),
+            activeModel: selectedSession.activeModel,
+            resources: resources.getInspection(),
+        });
+    }
+    finally {
+        await resourceService.dispose();
+    }
+}
+async function resolveContextBuildRuntime(context, runtimeInstanceId) {
+    if (context.channelContext.inspectAgentRuntimeInstances) {
+        const runtime = (await context.channelContext.inspectAgentRuntimeInstances()).find((candidate) => candidate.id === runtimeInstanceId);
+        if (runtime)
+            return runtime;
+    }
+    const runtime = context.channelContext.getCapabilityCatalog?.().agentRuntimes?.find((candidate) => candidate.id === runtimeInstanceId);
+    if (!runtime && runtimeInstanceId === "pi") {
+        return {
+            id: "pi",
+            adapterId: "pi",
+            displayName: "Pi Coding Agent",
+            enabled: true,
+            available: true,
+            transport: "embedded",
+            capabilities: structuredClone(PI_AGENT_RUNTIME_CAPABILITIES),
+            configSchema: { type: "object", additionalProperties: false },
+            protocol: { name: "pi-sdk", supportedRange: "0.80.6" },
+            diagnostics: [],
+        };
+    }
+    if (!runtime)
+        throw new PiboWebHttpError(`Unknown agent runtime instance "${runtimeInstanceId}"`, 400);
+    return {
+        ...runtime,
+        available: runtime.enabled,
+        diagnostics: runtime.enabled ? [] : [{
+                severity: "error",
+                code: "runtime_instance_disabled",
+                message: `Agent runtime instance "${runtime.id}" is disabled.`,
+            }],
+    };
 }
 function indexSharedSessions(sessionQuery, sessions) {
     sessionQuery.upsertSessionsIfChanged(sessions);
@@ -2369,63 +2584,106 @@ function parseTimelineBeforeCursor(url) {
     const cursor = url.searchParams.get("before") ?? url.searchParams.get("cursor");
     if (!cursor || cursor === "tail")
         return { kind: "tail" };
-    const transcript = parseTranscriptTimelineCursor(cursor);
-    if (transcript)
-        return transcript;
+    const history = parseRuntimeHistoryTimelineCursor(cursor);
+    if (history)
+        return history;
     const parsed = Number.parseInt(cursor, 10);
     if (!Number.isFinite(parsed) || parsed <= 0)
-        throw new PiboWebHttpError("Trace cursor must be tail, transcript, or a positive sequence", 400);
+        throw new PiboWebHttpError("Trace cursor must be tail, runtime-history, or a positive sequence", 400);
     return { kind: "event", beforeSequence: parsed, raw: String(parsed) };
 }
-function parseTranscriptTimelineCursor(cursor) {
-    if (!cursor.startsWith("transcript:"))
-        return undefined;
-    const [, byteValue, encodedTimestamp] = cursor.split(":");
-    const beforeByte = Number.parseInt(byteValue ?? "", 10);
-    if (!Number.isFinite(beforeByte) || beforeByte < 0)
-        throw new PiboWebHttpError("Invalid transcript trace cursor", 400);
-    let beforeTimestamp;
-    if (encodedTimestamp) {
+function parseRuntimeHistoryTimelineCursor(cursor) {
+    if (cursor.startsWith("transcript:")) {
+        const [, , encodedTimestamp] = cursor.split(":");
+        let beforeTimestamp;
         try {
-            const decoded = Buffer.from(encodedTimestamp, "base64url").toString("utf8");
-            if (decoded)
-                beforeTimestamp = decoded;
+            beforeTimestamp = encodedTimestamp ? Buffer.from(encodedTimestamp, "base64url").toString("utf8") || undefined : undefined;
         }
         catch {
-            throw new PiboWebHttpError("Invalid transcript trace cursor", 400);
+            throw new PiboWebHttpError("Invalid legacy transcript trace cursor", 400);
+        }
+        return { kind: "history", providerCursor: cursor, beforeTimestamp, raw: cursor };
+    }
+    if (!cursor.startsWith("runtime-history:"))
+        return undefined;
+    try {
+        const payload = JSON.parse(Buffer.from(cursor.slice("runtime-history:".length), "base64url").toString("utf8"));
+        if (payload.v !== 1)
+            throw new Error("unsupported version");
+        for (const value of [payload.piboSessionId, payload.runtimeInstanceId, payload.adapterId, payload.providerCursor, payload.beforeTimestamp]) {
+            if (value !== undefined && typeof value !== "string")
+                throw new Error("invalid field");
         }
+        return { kind: "history", ...payload, raw: cursor };
+    }
+    catch (error) {
+        throw new PiboWebHttpError(`Invalid runtime history trace cursor: ${error instanceof Error ? error.message : String(error)}`, 400);
     }
-    return { kind: "transcript", beforeByte, beforeTimestamp, raw: cursor };
 }
-function encodeTranscriptTimelineCursor(beforeByte, beforeTimestamp) {
-    const encodedTimestamp = beforeTimestamp ? Buffer.from(beforeTimestamp, "utf8").toString("base64url") : "";
-    return `transcript:${Math.max(0, Math.floor(beforeByte))}:${encodedTimestamp}`;
+function encodeRuntimeHistoryTimelineCursor(session, input = {}) {
+    const binding = session.runtimeBinding;
+    const payload = {
+        v: 1,
+        piboSessionId: session.id,
+        runtimeInstanceId: binding?.runtimeInstanceId,
+        adapterId: binding?.adapterId,
+        providerCursor: input.providerCursor,
+        beforeTimestamp: input.beforeTimestamp,
+    };
+    return `runtime-history:${Buffer.from(JSON.stringify(payload), "utf8").toString("base64url")}`;
+}
+function validateRuntimeHistoryCursor(session, cursor) {
+    const binding = session.runtimeBinding;
+    if (cursor.piboSessionId && cursor.piboSessionId !== session.id) {
+        throw new PiboWebHttpError("Runtime history cursor belongs to a different Pibo session", 409);
+    }
+    if (cursor.runtimeInstanceId && cursor.runtimeInstanceId !== binding?.runtimeInstanceId) {
+        throw new PiboWebHttpError("Runtime history cursor belongs to a different runtime instance", 409);
+    }
+    if (cursor.adapterId && cursor.adapterId !== binding?.adapterId) {
+        throw new PiboWebHttpError("Runtime history cursor belongs to a different runtime adapter", 409);
+    }
+}
+function traceRuntimeBindingFromSession(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 requiresNativeHistoryCompatibility(session) {
+    const metadata = session.runtimeBinding?.metadata;
+    return session.originId !== undefined
+        || metadata?.nativeHistoryFallback === true
+        || typeof metadata?.migrationSource === "string";
+}
+function sessionNodeHistoryOptions(context) {
+    return {
+        loadHistoryInspection: async (session) => requiresNativeHistoryCompatibility(session) && context.channelContext.inspectSessionRuntimeHistory
+            ? await context.channelContext.inspectSessionRuntimeHistory(session.id).catch(() => undefined)
+            : undefined,
+    };
+}
+function runtimeHistorySupported(context, session) {
+    if (!context.channelContext.readSessionRuntimeHistory)
+        return false;
+    const runtimeInstanceId = session.runtimeBinding?.runtimeInstanceId;
+    if (!runtimeInstanceId)
+        return false;
+    return context.channelContext.getCapabilityCatalog?.().agentRuntimes.find((runtime) => runtime.id === runtimeInstanceId)?.capabilities.maintenance.history === true;
 }
 function compactionCutoffTimestamp(events) {
     const compaction = events.find((event) => event.type === "execution_result" && event.payload.type === "execution_result" && event.payload.action === "compact")
         ?? events.find((event) => event.type === "compaction_end" || event.type === "compaction_start");
     return compaction?.createdAt;
 }
-function originTranscriptTailCursor(input) {
-    if (!input.session.originId)
-        return undefined;
-    const sessionPath = input.metadata?.sessionPath;
-    const sessionSize = input.metadata?.sessionSize;
-    if (!sessionPath || !sessionSize || sessionSize <= 0)
-        return undefined;
-    const firstVisibleTranscript = firstVisibleTailTranscriptNode(input.trace.nodes, input.limit);
-    if (!firstVisibleTranscript?.startedAt)
-        return undefined;
-    const probe = readTranscriptHistoryPage(sessionPath, {
-        beforeByte: sessionSize,
-        beforeTimestamp: firstVisibleTranscript.startedAt,
-        limit: 1,
-    });
-    if (probe.entries.length === 0)
-        return undefined;
-    return encodeTranscriptTimelineCursor(sessionSize, firstVisibleTranscript.startedAt);
-}
-function firstVisibleTailTranscriptNode(nodes, limit) {
+function firstVisibleTailHistoryNode(nodes, limit) {
     const flat = [];
     const visit = (items) => {
         for (const item of items) {
@@ -2434,7 +2692,7 @@ function firstVisibleTailTranscriptNode(nodes, limit) {
         }
     };
     visit(nodes);
-    return flat.slice(-Math.max(1, limit)).find((node) => node.source === "transcript" && node.startedAt);
+    return flat.slice(-Math.max(1, limit)).find((node) => (node.source === "transcript" || node.source === "product-history") && node.startedAt);
 }
 function transientReplayScopeKeys(input) {
     const keys = [];
@@ -2855,7 +3113,7 @@ async function sendProjectMessage(input) {
         return responseJson({ accepted, output });
     }
     catch (error) {
-        if (error instanceof PiboSteeringUnavailableError) {
+        if (error instanceof PiboSteeringUnavailableError || error instanceof AgentRuntimeBindingMissingError) {
             throw new PiboWebHttpError(error.message, 409);
         }
         throw error;
@@ -3057,7 +3315,7 @@ async function sendChatMessage(input) {
         });
         for (const listener of input.state.liveListeners)
             listener(failed);
-        if (error instanceof PiboSteeringUnavailableError) {
+        if (error instanceof PiboSteeringUnavailableError || error instanceof AgentRuntimeBindingMissingError) {
             throw new PiboWebHttpError(error.message, 409);
         }
         throw error;
@@ -3073,6 +3331,7 @@ export function createChatWebApp(options = {}) {
     const state = {
         sessionQuery: new ChatSessionQueryService(dataStore),
         timelineQuery: new ChatTimelineQueryService(dataStore),
+        historyQuery: new ChatHistoryQueryService(dataStore),
         eventCommands: new ChatEventCommandService(dataStore),
         readState: new ChatReadStateService(dataStore),
         roomService: new ChatRoomService(dataStore),
@@ -3227,7 +3486,7 @@ export function createChatWebApp(options = {}) {
                 indexSharedSessions(state.sessionQuery, roomSessions);
                 const sessionUnreadCounts = buildSessionUnreadCounts(state, ownedSessions);
                 const [sessions, catalog] = await Promise.all([
-                    buildSessionNodes(roomSessions, sessionIndexItemsWithSignalState(context, roomSessions, state.sessionQuery.listSessions(), sessionUnreadCounts), process.cwd(), sessionUnreadCounts),
+                    buildSessionNodes(roomSessions, sessionIndexItemsWithSignalState(context, roomSessions, state.sessionQuery.listSessions(), sessionUnreadCounts), process.cwd(), sessionUnreadCounts, sessionNodeHistoryOptions(context)),
                     loadBootstrapCatalog(state, context, webSession),
                 ]);
                 const roomTree = state.roomService.listRoomTree();
@@ -3988,6 +4247,7 @@ export function createChatWebApp(options = {}) {
                 const body = await readJsonBody(request);
                 const input = createAgentInput(body);
                 requireAgentProfileNameAvailable(state, context, input.displayName);
+                await requireValidCustomAgentRuntime(previewCustomAgentCreate(input), context);
                 const agent = state.agentStore.create(input);
                 context.channelContext.upsertProfile?.(createCustomAgentProfileDefinition(agent));
                 invalidateBootstrapCatalogCache(state);
@@ -4003,6 +4263,9 @@ export function createChatWebApp(options = {}) {
                 const archived = normalizeAgentArchived(body.archived);
                 if (update.displayName)
                     requireAgentProfileNameAvailable(state, context, update.displayName, existing.id);
+                if (customAgentUpdateAffectsRuntime(update)) {
+                    await requireValidCustomAgentRuntime(previewCustomAgentUpdate(existing, update), context);
+                }
                 const updated = Object.keys(update).length ? state.agentStore.update(patchAgentId, update) : existing;
                 const afterUpdate = requireSharedAgent(updated);
                 const agent = archived === undefined ? afterUpdate : state.agentStore.setArchived(patchAgentId, archived);
@@ -4029,7 +4292,7 @@ export function createChatWebApp(options = {}) {
                 if (confirmName !== agent.profileName) {
                     throw new PiboWebHttpError(`Type "${agent.profileName}" to permanently delete this agent and its sessions.`, 400);
                 }
-                const deletedSessionIds = deleteSessionsForAgentProfile(state, context, webSession, [agent.profileName, ...agent.profileAliases]);
+                const deletedSessionIds = await deleteSessionsForAgentProfile(state, context, webSession, [agent.profileName, ...agent.profileAliases]);
                 state.agentStore.delete(agent.id);
                 context.channelContext.removeProfile?.(agent.profileName);
                 invalidateBootstrapCatalogCache(state);
@@ -4069,7 +4332,7 @@ export function createChatWebApp(options = {}) {
                     includeArchived,
                 });
                 indexSharedSessions(state.sessionQuery, roomSessions);
-                const nodes = await buildSessionNodes(roomSessions, state.sessionQuery.listSessions(), process.cwd(), new Map());
+                const nodes = await buildSessionNodes(roomSessions, state.sessionQuery.listSessions(), process.cwd(), new Map(), sessionNodeHistoryOptions(context));
                 if (!wantsPage)
                     return responseJson(nodes);
                 const page = paginateSessionNodes(nodes, { archived: archivedPage, cursor, limit });
@@ -4130,7 +4393,7 @@ export function createChatWebApp(options = {}) {
                 indexSharedSessions(state.sessionQuery, ownedSessions);
                 return responseJson({
                     room,
-                    sessions: await buildSessionNodes(ownedSessions, state.sessionQuery.listSessions(), process.cwd(), new Map()),
+                    sessions: await buildSessionNodes(ownedSessions, state.sessionQuery.listSessions(), process.cwd(), new Map(), sessionNodeHistoryOptions(context)),
                 });
             }
             if (roomResource && roomResource.child === undefined && request.method === "PATCH") {
@@ -4151,7 +4414,7 @@ export function createChatWebApp(options = {}) {
                 const webSession = await requireSession(request, context);
                 const room = requireRoom(state, roomResource.roomId, webSession, "admin");
                 const body = await readJsonBody(request);
-                const deleted = deleteRoomTree(state, context, webSession, room, normalizeRoomDeleteConfirmation(body.confirmName));
+                const deleted = await deleteRoomTree(state, context, webSession, room, normalizeRoomDeleteConfirmation(body.confirmName));
                 return responseJson(deleted);
             }
             if (roomResource && roomResource.child === "events" && request.method === "GET") {
@@ -4196,6 +4459,62 @@ export function createChatWebApp(options = {}) {
                 markSessionsRead(state, sessionSubtree(listSharedSessions(context), selectedSession.id));
                 return responseJson({ ok: true, piboSessionId: selectedSession.id });
             }
+            if (sessionAction?.action === "runtime-binding" && request.method === "GET") {
+                const webSession = await requireSession(request, context);
+                const selectedSession = resolveRequestedSession(state, context, webSession, defaultProfile, sessionAction.piboSessionId);
+                const binding = context.channelContext.getSessionRuntimeBinding?.(selectedSession.id) ?? selectedSession.runtimeBinding;
+                if (!binding)
+                    throw new PiboWebHttpError("Runtime binding not found", 404);
+                return responseJson({ binding });
+            }
+            if (sessionAction?.action === "runtime-binding" && request.method === "PATCH") {
+                requireSameOriginJsonRequest(request);
+                const webSession = await requireSession(request, context);
+                const selectedSession = resolveRequestedSession(state, context, webSession, defaultProfile, sessionAction.piboSessionId);
+                if (!context.channelContext.rebindSessionRuntime) {
+                    throw new PiboWebHttpError("Runtime binding repair is not available", 501);
+                }
+                const body = await readJsonBody(request);
+                if (typeof body.runtimeInstanceId !== "string" || !body.runtimeInstanceId.trim()) {
+                    throw new PiboWebHttpError("runtimeInstanceId is required", 400);
+                }
+                if (!Number.isInteger(body.expectedRevision) || Number(body.expectedRevision) < 1) {
+                    throw new PiboWebHttpError("expectedRevision must be a positive integer", 400);
+                }
+                if (body.nativeSessionId !== undefined && typeof body.nativeSessionId !== "string") {
+                    throw new PiboWebHttpError("nativeSessionId must be a string", 400);
+                }
+                if (body.state !== undefined && body.state !== "unbound" && body.state !== "bound") {
+                    throw new PiboWebHttpError("state must be unbound or bound", 400);
+                }
+                const locator = body.locator;
+                const locatorKinds = new Set(["local-file", "local-directory", "uri", "remote", "adapter-resolved"]);
+                if (locator !== undefined
+                    && (!isJsonObject(locator)
+                        || typeof locator.kind !== "string"
+                        || !locatorKinds.has(locator.kind)
+                        || (locator.value !== undefined && typeof locator.value !== "string"))) {
+                    throw new PiboWebHttpError("locator must contain a supported kind and optional string value", 400);
+                }
+                try {
+                    const binding = await context.channelContext.rebindSessionRuntime(selectedSession.id, {
+                        runtimeInstanceId: body.runtimeInstanceId.trim(),
+                        nativeSessionId: typeof body.nativeSessionId === "string" && body.nativeSessionId.trim() ? body.nativeSessionId.trim() : undefined,
+                        state: body.state,
+                        locator: locator,
+                        expectedRevision: Number(body.expectedRevision),
+                    });
+                    const updated = context.channelContext.getSession(selectedSession.id);
+                    if (updated)
+                        state.sessionQuery.upsertSession(updated);
+                    return responseJson({ binding });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    const status = /concurrently|idle/i.test(message) ? 409 : 400;
+                    throw new PiboWebHttpError(message, status);
+                }
+            }
             const patchSessionId = sessionResourceId(url.pathname);
             if (patchSessionId && request.method === "PATCH") {
                 requireSameOriginJsonRequest(request);
@@ -4241,7 +4560,7 @@ export function createChatWebApp(options = {}) {
                 if (confirmText !== "Delete this session") {
                     throw new PiboWebHttpError('Type "Delete this session" to permanently delete this session.', 400);
                 }
-                const deletedSessionIds = deleteSessionSubtree(state, context, webSession, selectedSession);
+                const deletedSessionIds = await deleteSessionSubtree(state, context, webSession, selectedSession);
                 return responseJson({ deletedSessionIds });
             }
             if ((sessionAction?.action === "kill" || sessionAction?.action === "kill-all") && request.method === "POST") {
@@ -4262,27 +4581,30 @@ export function createChatWebApp(options = {}) {
                 const selectedSession = resolveRequestedSession(state, context, webSession, defaultProfile, url.searchParams.get("piboSessionId") || undefined);
                 state.sessionQuery.upsertSession(selectedSession);
                 const indexedSession = state.sessionQuery.getSession(selectedSession.id);
-                const metadataStartedAt = performance.now();
-                const metadata = await loadPiSessionFastMetadata(selectedSession, selectedSession.workspace ?? process.cwd());
-                const metadataMs = performance.now() - metadataStartedAt;
+                const historyStartedAt = performance.now();
+                const productHistory = state.historyQuery.getProductHistoryCoverage(selectedSession.id);
+                const historyInspection = requiresNativeHistoryCompatibility(selectedSession) && context.channelContext.inspectSessionRuntimeHistory
+                    ? await context.channelContext.inspectSessionRuntimeHistory(selectedSession.id).catch(() => undefined)
+                    : undefined;
+                const historyMs = performance.now() - historyStartedAt;
                 const lastEventSequence = state.timelineQuery.getLatestEventSequence(selectedSession.id);
                 const latestStreamId = state.timelineQuery.getLatestStreamId({ piboSessionId: selectedSession.id });
-                const version = createTraceViewVersion({
+                const version = createFastTraceV2Version({
                     session: selectedSession,
                     sessions: listSharedSessions(context),
-                    events: lastEventSequence > 0
-                        ? [{ id: `seq:${lastEventSequence}`, eventSequence: lastEventSequence, createdAt: indexedSession?.lastActivityAt ?? "" }]
-                        : [],
+                    lastEventSequence,
+                    lastActivityAt: indexedSession?.lastActivityAt,
                     status: indexedSession?.status,
-                    metadata,
                     latestStreamId,
+                    productHistory,
+                    nativeHistoryVersion: historyInspection?.version,
                 });
                 const headers = {
                     etag: etagForVersion(version),
                     "x-pibo-trace-version": version,
                     "server-timing": [
                         `trace_summary;dur=${(performance.now() - startedAt).toFixed(1)}`,
-                        `trace_metadata;dur=${metadataMs.toFixed(1)}`,
+                        `trace_history;dur=${historyMs.toFixed(1)}`,
                         `trace_events;desc="${lastEventSequence}"`,
                     ].join(", "),
                 };
@@ -4292,7 +4614,8 @@ export function createChatWebApp(options = {}) {
                 const summary = {
                     piboSessionId: selectedSession.id,
                     piSessionId: selectedSession.piSessionId,
-                    title: selectedSession.title ?? "Untitled Session",
+                    runtimeBinding: traceRuntimeBindingFromSession(selectedSession),
+                    title: selectedSession.title ?? historyInspection?.title ?? historyInspection?.firstMessage ?? "Untitled Session",
                     version,
                     latestStreamId,
                     eventCount: lastEventSequence,
@@ -4307,10 +4630,13 @@ export function createChatWebApp(options = {}) {
                 const beforeSequence = timelineCursor.kind === "event" ? timelineCursor.beforeSequence : undefined;
                 const limit = parsePositiveIntSearchParam(url, "limit", TRACE_V2_DEFAULT_TIMELINE_LIMIT, TRACE_V2_MAX_TIMELINE_LIMIT);
                 const selectedSession = resolveRequestedSession(state, context, webSession, defaultProfile, url.searchParams.get("piboSessionId") || undefined);
+                if (timelineCursor.kind === "history")
+                    validateRuntimeHistoryCursor(selectedSession, timelineCursor);
                 state.sessionQuery.upsertSession(selectedSession);
                 const ownedSessions = listSharedSessions(context);
                 const indexedSession = state.sessionQuery.getSession(selectedSession.id);
-                let metadataMs = 0;
+                let historyMs = 0;
+                const productHistory = state.historyQuery.getProductHistoryCoverage(selectedSession.id);
                 const lastEventSequence = state.timelineQuery.getLatestEventSequence(selectedSession.id);
                 const latestStreamId = state.timelineQuery.getLatestStreamId({ piboSessionId: selectedSession.id });
                 const turnTimings = state.timelineQuery.listMessageTurnTimings(selectedSession.id);
@@ -4319,11 +4645,12 @@ export function createChatWebApp(options = {}) {
                     ? context.channelContext.getSessionRuntimeStatus(selectedSession.id) ?? null
                     : undefined;
                 const traceStatus = traceProjectionStatus(liveSnapshots, indexedSession?.status, turnTimings, runtimeStatus);
-                const metadataStartedAt = performance.now();
-                const transcriptMetadata = timelineCursor.kind === "tail" || timelineCursor.kind === "transcript"
-                    ? await loadPiSessionFastMetadata(selectedSession, selectedSession.workspace ?? process.cwd())
-                    : undefined;
-                metadataMs += performance.now() - metadataStartedAt;
+                let historyInspection;
+                if (timelineCursor.kind === "tail" && requiresNativeHistoryCompatibility(selectedSession) && context.channelContext.inspectSessionRuntimeHistory) {
+                    const historyStartedAt = performance.now();
+                    historyInspection = await context.channelContext.inspectSessionRuntimeHistory(selectedSession.id).catch(() => undefined);
+                    historyMs += performance.now() - historyStartedAt;
+                }
                 const baseVersion = createFastTraceV2Version({
                     session: selectedSession,
                     sessions: ownedSessions,
@@ -4331,7 +4658,8 @@ export function createChatWebApp(options = {}) {
                     lastActivityAt: indexedSession?.lastActivityAt,
                     status: traceStatus,
                     latestStreamId,
-                    transcript: transcriptMetadata,
+                    productHistory,
+                    nativeHistoryVersion: historyInspection?.version,
                 });
                 const snapshotVersion = liveSnapshotVersion(liveSnapshots);
                 const version = snapshotVersion ? `${baseVersion}:live:${snapshotVersion}` : baseVersion;
@@ -4354,7 +4682,7 @@ export function createChatWebApp(options = {}) {
                             ...baseHeaders,
                             "server-timing": [
                                 `trace_timeline;dur=${(performance.now() - startedAt).toFixed(1)}`,
-                                `trace_metadata;dur=${metadataMs.toFixed(1)}`,
+                                `trace_history;dur=${historyMs.toFixed(1)}`,
                                 `trace_events;desc="0"`,
                                 `trace_cache;desc="page-hit"`,
                             ].join(", "),
@@ -4364,22 +4692,32 @@ export function createChatWebApp(options = {}) {
                 let trace = cached;
                 let eventCount = 0;
                 if (!trace) {
-                    if (timelineCursor.kind === "transcript") {
-                        const history = transcriptMetadata?.sessionPath
-                            ? readTranscriptHistoryPage(transcriptMetadata.sessionPath, {
-                                beforeByte: timelineCursor.beforeByte,
+                    if (timelineCursor.kind === "history") {
+                        if (!context.channelContext.readSessionRuntimeHistory) {
+                            throw new PiboWebHttpError("Runtime history is unavailable for this gateway", 501);
+                        }
+                        const historyStartedAt = performance.now();
+                        let history;
+                        try {
+                            history = await context.channelContext.readSessionRuntimeHistory(selectedSession.id, {
+                                cursor: timelineCursor.providerCursor,
                                 beforeTimestamp: timelineCursor.beforeTimestamp,
                                 limit,
-                            })
-                            : { entries: [], hasOlder: false, scannedBytes: 0, startByte: 0, endByte: 0 };
+                            });
+                        }
+                        catch {
+                            throw new PiboWebHttpError("Runtime history could not be read for this page", 502);
+                        }
+                        historyMs += performance.now() - historyStartedAt;
+                        historyInspection = history.inspection;
                         trace = await buildTraceView({
                             session: selectedSession,
                             sessions: ownedSessions,
                             events: [],
                             status: traceStatus,
-                            metadata: transcriptMetadata ?? {},
-                            transcriptEntries: history.entries,
-                            transcriptOrderOffset: history.startByte,
+                            historyEntries: history.entries,
+                            historyInspection: history.inspection,
+                            historyOrderOffset: history.orderOffset,
                             turnTimings,
                             includeRawEvents: false,
                             latestStreamId,
@@ -4390,10 +4728,13 @@ export function createChatWebApp(options = {}) {
                             eventLimit: limit,
                             pageSize: limit,
                             beforeCursor: timelineCursor.raw,
-                            nextBeforeCursor: history.hasOlder && history.nextBeforeByte !== undefined
-                                ? encodeTranscriptTimelineCursor(history.nextBeforeByte, timelineCursor.beforeTimestamp)
+                            nextBeforeCursor: history.hasMore
+                                ? encodeRuntimeHistoryTimelineCursor(selectedSession, {
+                                    providerCursor: history.nextCursor,
+                                    beforeTimestamp: timelineCursor.beforeTimestamp,
+                                })
                                 : undefined,
-                            hasOlderEvents: history.hasOlder,
+                            hasOlderEvents: history.hasMore,
                         };
                     }
                     else {
@@ -4402,17 +4743,32 @@ export function createChatWebApp(options = {}) {
                             limit,
                             ...(beforeSequence !== undefined ? { beforeSequence } : {}),
                         });
-                        const transcriptEntries = timelineCursor.kind === "tail" && transcriptMetadata?.sessionPath
-                            ? readTailEntries(transcriptMetadata.sessionPath)
-                            : [];
                         eventCount = events.length;
+                        let nativeHistory;
+                        if (timelineCursor.kind === "tail"
+                            && requiresNativeHistoryCompatibility(selectedSession)
+                            && runtimeHistorySupported(context, selectedSession)
+                            && context.channelContext.readSessionRuntimeHistory) {
+                            const historyStartedAt = performance.now();
+                            nativeHistory = await context.channelContext.readSessionRuntimeHistory(selectedSession.id, { limit: Math.min(limit * 4, 500) }).catch(() => undefined);
+                            historyMs += performance.now() - historyStartedAt;
+                            historyInspection = nativeHistory?.inspection ?? historyInspection;
+                        }
+                        const historyEntries = nativeHistory?.entries.length
+                            ? nativeHistory.entries
+                            : state.historyQuery.listProductHistoryEntries({
+                                piboSessionId: selectedSession.id,
+                                limit: Math.min(limit * 2, 500),
+                                ...(beforeSequence !== undefined ? { beforeSequence } : {}),
+                            });
                         trace = await buildTraceView({
                             session: selectedSession,
                             sessions: ownedSessions,
                             events,
                             status: traceStatus,
-                            metadata: transcriptMetadata ?? {},
-                            transcriptEntries,
+                            historyEntries,
+                            historyInspection,
+                            historyOrderOffset: nativeHistory?.orderOffset,
                             turnTimings,
                             includeRawEvents: false,
                             latestStreamId,
@@ -4423,19 +4779,24 @@ export function createChatWebApp(options = {}) {
                             beforeSequence,
                             beforeCursor: timelineCursor.kind === "event" ? timelineCursor.raw : undefined,
                         });
-                        if (trace.hasOlderEvents !== true && events.length > 0) {
-                            const cutoff = compactionCutoffTimestamp(events);
+                        if (trace.hasOlderEvents !== true && nativeHistory?.hasMore) {
+                            trace = {
+                                ...trace,
+                                nextBeforeCursor: encodeRuntimeHistoryTimelineCursor(selectedSession, {
+                                    providerCursor: nativeHistory.nextCursor,
+                                }),
+                                hasOlderEvents: true,
+                            };
+                        }
+                        else if (trace.hasOlderEvents !== true && events.length > 0 && runtimeHistorySupported(context, selectedSession)) {
+                            const cutoff = compactionCutoffTimestamp(events)
+                                ?? (requiresNativeHistoryCompatibility(selectedSession) ? events[0]?.createdAt : undefined);
                             if (cutoff) {
-                                const metadataStartedAt = performance.now();
-                                const metadata = transcriptMetadata ?? await loadPiSessionMetadata(selectedSession, selectedSession.workspace ?? process.cwd());
-                                metadataMs += performance.now() - metadataStartedAt;
-                                if (metadata.sessionPath && metadata.sessionSize && metadata.sessionSize > 0) {
-                                    trace = {
-                                        ...trace,
-                                        nextBeforeCursor: encodeTranscriptTimelineCursor(metadata.sessionSize, cutoff),
-                                        hasOlderEvents: true,
-                                    };
-                                }
+                                trace = {
+                                    ...trace,
+                                    nextBeforeCursor: encodeRuntimeHistoryTimelineCursor(selectedSession, { beforeTimestamp: cutoff }),
+                                    hasOlderEvents: true,
+                                };
                             }
                         }
                     }
@@ -4447,21 +4808,12 @@ export function createChatWebApp(options = {}) {
                     status: traceStatus,
                 });
                 trace = { ...trace, version };
-                const transcriptTailCursor = timelineCursor.kind === "tail"
-                    ? originTranscriptTailCursor({
-                        session: selectedSession,
-                        trace,
-                        metadata: transcriptMetadata,
-                        limit,
-                    })
-                    : undefined;
                 const page = traceTimelinePageFromView({
                     trace,
                     payloadStore: state.dataStore.payloads,
                     limit,
                     byteLimit: TRACE_V2_TIMELINE_HARD_BYTES,
                     fromTail: timelineCursor.kind === "tail",
-                    transcriptTailCursor,
                 });
                 setTraceTimelinePageCache(state.traceTimelinePageCache, pageCacheKey, page);
                 return responseJson(page, {
@@ -4469,7 +4821,7 @@ export function createChatWebApp(options = {}) {
                         ...baseHeaders,
                         "server-timing": [
                             `trace_timeline;dur=${(performance.now() - startedAt).toFixed(1)}`,
-                            `trace_metadata;dur=${metadataMs.toFixed(1)}`,
+                            `trace_history;dur=${historyMs.toFixed(1)}`,
                             `trace_events;desc="${eventCount}"`,
                             `trace_cache;desc="${cached ? "hit" : "miss"}"`,
                         ].join(", "),
@@ -4493,7 +4845,7 @@ export function createChatWebApp(options = {}) {
             if (url.pathname === `${CHAT_WEB_API_PREFIX}/trace/raw-events` && request.method === "GET") {
                 const webSession = await requireSession(request, context);
                 const rawCursor = parseTimelineBeforeCursor(url);
-                if (rawCursor.kind === "transcript")
+                if (rawCursor.kind === "history")
                     throw new PiboWebHttpError("Raw event cursor must be tail or a positive sequence", 400);
                 const beforeSequence = rawCursor.kind === "event" ? rawCursor.beforeSequence : undefined;
                 const limit = parsePositiveIntSearchParam(url, "limit", TRACE_V2_RAW_EVENTS_DEFAULT_LIMIT, TRACE_V2_RAW_EVENTS_MAX_LIMIT);
@@ -4523,9 +4875,17 @@ export function createChatWebApp(options = {}) {
                 state.sessionQuery.upsertSession(selectedSession);
                 const ownedSessions = listSharedSessions(context);
                 const indexedSession = state.sessionQuery.getSession(selectedSession.id);
-                const metadataStartedAt = performance.now();
-                const metadata = await loadPiSessionMetadata(selectedSession, selectedSession.workspace ?? process.cwd());
-                const metadataMs = performance.now() - metadataStartedAt;
+                let historyMs = 0;
+                const productHistory = state.historyQuery.getProductHistoryCoverage(selectedSession.id);
+                let nativeHistory;
+                if (beforeSequence === undefined
+                    && requiresNativeHistoryCompatibility(selectedSession)
+                    && runtimeHistorySupported(context, selectedSession)
+                    && context.channelContext.readSessionRuntimeHistory) {
+                    const historyStartedAt = performance.now();
+                    nativeHistory = await context.channelContext.readSessionRuntimeHistory(selectedSession.id, { limit: Math.min(eventLimit * 4, 500) }).catch(() => undefined);
+                    historyMs += performance.now() - historyStartedAt;
+                }
                 const lastEventSequence = state.timelineQuery.getLatestEventSequence(selectedSession.id);
                 const latestStreamId = state.timelineQuery.getLatestStreamId({ piboSessionId: selectedSession.id });
                 const turnTimings = state.timelineQuery.listMessageTurnTimings(selectedSession.id);
@@ -4534,15 +4894,15 @@ export function createChatWebApp(options = {}) {
                     ? context.channelContext.getSessionRuntimeStatus(selectedSession.id) ?? null
                     : undefined;
                 const traceStatus = traceProjectionStatus(liveSnapshots, indexedSession?.status, turnTimings, runtimeStatus);
-                const baseVersion = createTraceViewVersion({
+                const baseVersion = createFastTraceV2Version({
                     session: selectedSession,
                     sessions: ownedSessions,
-                    events: lastEventSequence > 0
-                        ? [{ id: `seq:${lastEventSequence}`, eventSequence: lastEventSequence, createdAt: indexedSession?.lastActivityAt ?? "" }]
-                        : [],
+                    lastEventSequence,
+                    lastActivityAt: indexedSession?.lastActivityAt,
                     status: traceStatus,
-                    metadata,
                     latestStreamId,
+                    productHistory,
+                    nativeHistoryVersion: nativeHistory?.inspection?.version,
                 });
                 const snapshotVersion = liveSnapshotVersion(liveSnapshots);
                 const version = snapshotVersion ? `${baseVersion}:live:${snapshotVersion}` : baseVersion;
@@ -4552,7 +4912,7 @@ export function createChatWebApp(options = {}) {
                 const serverTiming = (cacheState, eventCount = 0) => ({
                     "server-timing": [
                         `trace;dur=${(performance.now() - startedAt).toFixed(1)}`,
-                        `trace_metadata;dur=${metadataMs.toFixed(1)}`,
+                        `trace_history;dur=${historyMs.toFixed(1)}`,
                         `trace_events;desc="${eventCount}"`,
                         `trace_cache;desc="${cacheState}"`,
                     ].join(", "),
@@ -4570,12 +4930,21 @@ export function createChatWebApp(options = {}) {
                         ...(beforeSequence !== undefined ? { beforeSequence } : {}),
                     });
                     eventCount = events.length;
+                    const historyEntries = nativeHistory?.entries.length
+                        ? nativeHistory.entries
+                        : state.historyQuery.listProductHistoryEntries({
+                            piboSessionId: selectedSession.id,
+                            limit: Math.min(eventLimit * 2, 1000),
+                            ...(beforeSequence !== undefined ? { beforeSequence } : {}),
+                        });
                     trace = await buildTraceView({
                         session: selectedSession,
                         sessions: ownedSessions,
                         events,
                         status: traceStatus,
-                        metadata,
+                        historyEntries,
+                        historyInspection: nativeHistory?.inspection,
+                        historyOrderOffset: nativeHistory?.orderOffset,
                         turnTimings,
                         includeRawEvents: false,
                         latestStreamId,
@@ -4637,6 +5006,11 @@ export function createChatWebApp(options = {}) {
                     session,
                     sessions: ownedSessions,
                     events: state.timelineQuery.listTraceEvents({ piboSessionId, beforeOrAtSequence: eventSequence, limit: DEFAULT_TRACE_EVENTS_PAGE_SIZE }),
+                    historyEntries: state.historyQuery.listProductHistoryEntries({
+                        piboSessionId,
+                        limit: DEFAULT_TRACE_EVENTS_PAGE_SIZE,
+                        beforeSequence: eventSequence + 1,
+                    }),
                     status: indexedSession?.status,
                     turnTimings: state.timelineQuery.listMessageTurnTimings(piboSessionId),
                 });
@@ -4654,6 +5028,34 @@ export function createChatWebApp(options = {}) {
                 const body = await readJsonBody(request);
                 return sendChatMessage({ state, context, webSession, defaultProfile, body });
             }
+            if (url.pathname === `${CHAT_WEB_API_PREFIX}/provider-auth` && request.method === "GET") {
+                await requireSession(request, context);
+                return responseJson(await readProviderAuthCatalog(context.channelContext, defaultRuntimeInstanceId(context, defaultProfile)), { headers: { "cache-control": "no-store" } });
+            }
+            if (url.pathname === `${CHAT_WEB_API_PREFIX}/provider-auth` && request.method === "POST") {
+                requireSameOriginJsonRequest(request);
+                await requireSession(request, context);
+                const body = await readJsonBody(request);
+                const action = typeof body.action === "string" ? body.action : "";
+                const mappedAction = action === "start"
+                    ? "login.start"
+                    : action === "complete"
+                        ? "login.complete"
+                        : action === "api_key"
+                            ? "login.apikey"
+                            : action === "cancel"
+                                ? "login.cancel"
+                                : action === "logout"
+                                    ? "logout"
+                                    : isProviderAuthAction(action) && action !== "login.status"
+                                        ? action
+                                        : undefined;
+                if (!mappedAction)
+                    throw new PiboWebHttpError("Unsupported provider authentication action", 400);
+                const result = await executeProviderAuthAction(context.channelContext, mappedAction, body);
+                invalidateBootstrapCatalogCache(state);
+                return responseJson({ result }, { headers: { "cache-control": "no-store" } });
+            }
             if (url.pathname === `${CHAT_WEB_API_PREFIX}/status` && request.method === "GET") {
                 const webSession = await requireSession(request, context);
                 const selectedSession = resolveRequestedSession(state, context, webSession, defaultProfile, url.searchParams.get("piboSessionId") || undefined);
@@ -4677,7 +5079,30 @@ export function createChatWebApp(options = {}) {
                 }
                 const piboSessionId = typeof body.piboSessionId === "string" ? body.piboSessionId : undefined;
                 if (isProviderAuthAction(body.action)) {
-                    return providerAuthActionResponse({ piboSessionId, action: body.action, result: await executeProviderAuthAction(body.action, body.params) });
+                    const authParams = isJsonObject(body.params) ? { ...body.params } : {};
+                    const explicitRuntimeInstanceId = typeof authParams.runtimeInstanceId === "string" && authParams.runtimeInstanceId.trim()
+                        ? authParams.runtimeInstanceId.trim()
+                        : undefined;
+                    const selectedSession = piboSessionId
+                        ? resolveRequestedSession(state, context, webSession, defaultProfile, piboSessionId)
+                        : undefined;
+                    const boundRuntimeInstanceId = selectedSession ? sessionRuntimeInstanceId(context, selectedSession) : undefined;
+                    if (explicitRuntimeInstanceId && boundRuntimeInstanceId && explicitRuntimeInstanceId !== boundRuntimeInstanceId) {
+                        throw new PiboWebHttpError("Provider authentication target conflicts with the selected session runtime", 409);
+                    }
+                    const selectedRuntimeInstanceId = explicitRuntimeInstanceId ?? boundRuntimeInstanceId;
+                    if (!selectedRuntimeInstanceId) {
+                        throw new PiboWebHttpError("Provider authentication requires an explicit runtimeInstanceId or a valid bound Pibo Session", 400);
+                    }
+                    authParams.runtimeInstanceId = selectedRuntimeInstanceId;
+                    const result = await executeProviderAuthAction(context.channelContext, body.action, authParams);
+                    if (body.action !== "login.status")
+                        invalidateBootstrapCatalogCache(state);
+                    return providerAuthActionResponse({
+                        piboSessionId: selectedSession?.id,
+                        action: body.action,
+                        result,
+                    });
                 }
                 const selectedSession = resolveRequestedSession(state, context, webSession, defaultProfile, piboSessionId);
                 const room = ensureSessionRoom(state, context, selectedSession, webSession);