@pasko70/pibo 3.0.2 → 3.1.1

package/dist/core/output-render-sequence.js

@@ -3,6 +3,7 @@ const RENDER_SEQUENCE_SLOTS_PER_MILLISECOND = 1_000;
 const MAX_TRACKED_SESSIONS = 1_024;
 const MAX_RECENT_SEGMENTS_PER_SESSION = 1_024;
 const MAX_RECENT_TOOL_INVOCATIONS_PER_SESSION = 1_024;
+const MAX_RECENT_OUTPUT_PARTS_PER_SESSION = 1_024;
 export function outputRenderHighWaterStore(value) {
     if (!value || typeof value !== "object")
         return undefined;
@@ -32,7 +33,8 @@ export class OutputRenderSequencer {
     position(event) {
         const state = this.sessionState(event.piboSessionId);
         this.trackActiveTurn(state, event);
-        const eventWithToolIdentity = this.positionToolInvocation(state, event);
+        const eventWithPartIdentity = this.positionOutputPart(state, event);
+        const eventWithToolIdentity = this.positionToolInvocation(state, eventWithPartIdentity);
         const key = outputRenderSegmentKey(eventWithToolIdentity, state.activeEventId);
         const supplied = validRenderSequence(eventWithToolIdentity.renderSequence)
             ? eventWithToolIdentity.renderSequence
@@ -90,11 +92,61 @@ export class OutputRenderSequencer {
             activeSegments: new Set(),
             completedSegments: new Set(),
             toolInvocations: new Map(),
+            outputParts: new Map(),
             lastSequence: 0,
         };
         this.sessions.set(piboSessionId, state);
         return state;
     }
+    positionOutputPart(state, event) {
+        const transition = outputPartTransition(event, state.activeEventId);
+        if (!transition)
+            return event;
+        const key = outputPartCounterKey(transition.eventId, transition.kind);
+        const parts = state.outputParts.get(key) ?? [];
+        if (!state.outputParts.has(key))
+            state.outputParts.set(key, parts);
+        const exact = parts.find((part) => part.fingerprints.has(transition.fingerprint));
+        const latestOpen = [...parts].reverse().find((part) => !part.closed);
+        const localMaximum = parts.reduce((maximum, part) => Math.max(maximum, part.index), -1);
+        const localIndex = exact?.index
+            ?? latestOpen?.index
+            ?? (transition.proposedIndex > localMaximum ? transition.proposedIndex : localMaximum + 1);
+        const index = validRenderSequence(event.renderSequence) || exact || latestOpen
+            ? localIndex
+            : this.highWaterStore?.claimOrAttachOutputPart?.({ ...transition, proposedIndex: localIndex }) ?? localIndex;
+        let part = parts.find((candidate) => candidate.index === index);
+        if (!part) {
+            part = { index, fingerprints: new Set(), closed: false };
+            parts.push(part);
+        }
+        part.fingerprints.add(transition.fingerprint);
+        if (transition.terminal)
+            part.closed = true;
+        this.trimOutputParts(state);
+        return withOutputPartIndex(event, transition.kind, index);
+    }
+    trimOutputParts(state) {
+        let total = 0;
+        for (const parts of state.outputParts.values())
+            total += parts.length;
+        while (total > MAX_RECENT_OUTPUT_PARTS_PER_SESSION) {
+            let removed = false;
+            for (const [key, parts] of state.outputParts) {
+                const closedIndex = parts.findIndex((part) => part.closed);
+                if (closedIndex === -1)
+                    continue;
+                parts.splice(closedIndex, 1);
+                total -= 1;
+                if (!parts.length)
+                    state.outputParts.delete(key);
+                removed = true;
+                break;
+            }
+            if (!removed)
+                break;
+        }
+    }
     positionToolInvocation(state, event) {
         if (!isToolIdentityEvent(event) || !event.toolCallId)
             return event;
@@ -243,6 +295,101 @@ function createInvocation(invocations, ordinal) {
     invocations.push(invocation);
     return invocation;
 }
+function outputPartTransition(event, activeEventId) {
+    const eventId = ("eventId" in event ? event.eventId : undefined) ?? activeEventId;
+    if (!eventId)
+        return undefined;
+    if (event.type === "assistant_delta" || event.type === "assistant_message") {
+        return {
+            piboSessionId: event.piboSessionId,
+            eventId,
+            kind: "assistant",
+            proposedIndex: event.assistantIndex ?? event.contentIndex ?? 0,
+            fingerprint: outputPartFingerprint(event),
+            identityFingerprint: outputIdentityFingerprint(event),
+            terminal: event.type === "assistant_message",
+        };
+    }
+    if (event.type === "thinking_started" || event.type === "thinking_delta" || event.type === "thinking_finished") {
+        return {
+            piboSessionId: event.piboSessionId,
+            eventId,
+            kind: "thinking",
+            proposedIndex: event.thinkingIndex ?? event.contentIndex ?? 0,
+            fingerprint: outputPartFingerprint(event),
+            identityFingerprint: outputIdentityFingerprint(event),
+            terminal: event.type === "thinking_finished",
+        };
+    }
+    if (event.type === "assistant_usage") {
+        return {
+            piboSessionId: event.piboSessionId,
+            eventId,
+            kind: "usage",
+            proposedIndex: event.usageIndex ?? 0,
+            fingerprint: outputPartFingerprint(event),
+            identityFingerprint: outputIdentityFingerprint(event),
+            terminal: true,
+        };
+    }
+    if (event.type === "compaction_start" || event.type === "compaction_end") {
+        return {
+            piboSessionId: event.piboSessionId,
+            eventId,
+            kind: "compaction",
+            proposedIndex: event.compactionIndex ?? 0,
+            fingerprint: outputPartFingerprint(event),
+            identityFingerprint: outputIdentityFingerprint(event),
+            terminal: event.type === "compaction_end",
+        };
+    }
+    return undefined;
+}
+export function outputIdentityFingerprint(event) {
+    const payload = { ...event };
+    delete payload.renderSequence;
+    return createHash("sha256").update(stableJson(payload)).digest("hex");
+}
+export function outputPartFingerprint(event) {
+    const payload = { ...event };
+    delete payload.renderSequence;
+    delete payload.assistantIndex;
+    delete payload.thinkingIndex;
+    delete payload.usageIndex;
+    delete payload.compactionIndex;
+    delete payload.contentIndex;
+    return createHash("sha256").update(stableJson(payload)).digest("hex");
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(",")}]`;
+    if (value && typeof value === "object") {
+        return `{${Object.entries(value)
+            .filter(([, entry]) => entry !== undefined)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value) ?? "null";
+}
+function outputPartCounterKey(eventId, kind) {
+    return JSON.stringify([eventId, kind]);
+}
+function withOutputPartIndex(event, kind, index) {
+    if (kind === "assistant" && (event.type === "assistant_delta" || event.type === "assistant_message")) {
+        return event.assistantIndex === index ? event : { ...event, assistantIndex: index };
+    }
+    if (kind === "thinking" && (event.type === "thinking_started" || event.type === "thinking_delta" || event.type === "thinking_finished")) {
+        return event.thinkingIndex === index ? event : { ...event, thinkingIndex: index };
+    }
+    if (kind === "usage" && event.type === "assistant_usage") {
+        return event.usageIndex === index ? event : { ...event, usageIndex: index };
+    }
+    if (kind === "compaction" && (event.type === "compaction_start" || event.type === "compaction_end")) {
+        return event.compactionIndex === index ? event : { ...event, compactionIndex: index };
+    }
+    return event;
+}
 function segmentRemainsActive(event) {
     return event.type === "message_started"
         || event.type === "assistant_delta"

package/dist/core/session-router.js

@@ -2,11 +2,12 @@ import { randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { InitialSessionContext, } from "./profiles.js";
 import { createDefaultPiboPluginRegistry, createPiboProfileFromRegistryOrDefault, resolvePiboProfileNameFromRegistryOrDefault, selectDefaultPiboProfileName } from "../plugins/builtin.js";
-import { RuntimeRoutedSession as RoutedSession, } from "../agent-runtime/routed-session.js";
+import { RUN_REMINDER_MAX_DURATION_MS, RuntimeRoutedSession as RoutedSession, } from "../agent-runtime/routed-session.js";
 import { runtimeSessionErrorDetails } from "./session-errors.js";
 import { OutputRenderSequencer, outputRenderHighWaterStore } from "./output-render-sequence.js";
 import { normalizePiboAgentSessionName, } from "../subagents/tool.js";
-import { PIBO_AGENT_OBSERVATION_DEFAULT_EVENT_TYPES, PIBO_AGENT_OBSERVATION_DEFAULT_TOOL_EVENT_TYPES, normalizePiboAgentObservationCursor, normalizePiboAgentObservationLimit, normalizePiboAgentObservationOrder, normalizePiboAgentObservationToolDetail, parsePiboAgentObservationTimestamp, piboAgentObservationDetails, piboAgentObservationKind, piboAgentObservationRole, piboAgentObservationSourceFromEvent, piboAgentObservationText, piboAgentObservationToolSummary, } from "../subagents/observations.js";
+import { piboAgentObservationDetails, piboAgentObservationKind, piboAgentObservationRole, piboAgentObservationSourceFromEvent, piboAgentObservationText, } from "../subagents/observations.js";
+import { preparePiboAgentObservationQuery, selectPiboAgentObservationPage, } from "../subagents/observation-query.js";
 import { PiboRunRegistry } from "../runs/registry.js";
 import { PiboRunCancellationError, PiboRunCancelledError, PiboRunExecutionTimeoutError, waitForRunCancellationSettlement } from "../runs/lifecycle.js";
 import { PiboRunResourceLimitError } from "../runs/resource-isolation.js";
@@ -159,7 +160,11 @@ function formatRunReminderMessage(notification) {
                 toolName: run.toolName,
                 summary: run.summary,
             })),
-            instruction: "Use pibo_run_read for completed, failed, or timed_out runs. Use pibo_run_wait, pibo_run_status, pibo_run_cancel, or pibo_run_ack for runs you still need to manage.",
+            instruction: [
+                `This autonomous run-reminder turn stops after ${RUN_REMINDER_MAX_DURATION_MS / 60_000} minutes of wall-clock time.`,
+                "Handle the listed runs promptly, then finish the turn. Do not start new subagents, yielded runs, or other long-running work from this reminder; leave larger follow-up work for a separate user-initiated or Goal continuation turn.",
+                "Use pibo_run_read for completed, failed, or timed_out runs. Use pibo_run_wait, pibo_run_status, pibo_run_cancel, or pibo_run_ack for runs you still need to manage.",
+            ].join(" "),
         }),
         "</pibo_run_notification>",
     ].join("\n");
@@ -425,9 +430,15 @@ export class PiboSessionRouter {
                 this.signalRegistry.project({ type: "session_created", session });
             this.signalRegistry.project({ type: "pibo_output", event: recovery.event });
         }
+        const recoveredRunReminderControllers = new Set();
         for (const run of this.runRegistry.listAll({ includeConsumed: true, includeDetached: true })) {
             this.signalRegistry.project({ type: "run_changed", run, reason: "recovered" });
+            if (options.recoverInterruptedRuntimeState && isTerminalRunStatus(run.status) && this.sessionStore.get(run.controllerPiboSessionId)) {
+                recoveredRunReminderControllers.add(run.controllerPiboSessionId);
+            }
         }
+        for (const piboSessionId of recoveredRunReminderControllers)
+            this.scheduleRunReminder(piboSessionId, false);
     }
     subscribe(listener) {
         this.listeners.add(listener);
@@ -923,8 +934,12 @@ export class PiboSessionRouter {
             expectedRevision: input.expectedRevision,
             mode,
         });
-        if (switchingRuntime)
-            this.sessionStore.update(piboSessionId, { activeModel: null });
+        if (switchingRuntime) {
+            this.sessionStore.update(piboSessionId, {
+                activeModel: null,
+                metadata: withPiboSessionModelFallbacksMetadata(session.metadata, []),
+            });
+        }
         return structuredClone(persisted);
     }
     getSessionRuntimeStatus(piboSessionId) {
@@ -2069,105 +2084,15 @@ export class PiboSessionRouter {
         return session;
     }
     observeManagedAgents(parentPiboSessionId, input) {
-        const order = normalizePiboAgentObservationOrder(input.order);
-        const limit = normalizePiboAgentObservationLimit(input.limit);
-        const toolDetail = normalizePiboAgentObservationToolDetail(input.toolDetail);
-        const afterSequence = normalizePiboAgentObservationCursor(input.afterSequence);
-        const since = parsePiboAgentObservationTimestamp(input.since, "since");
-        const until = parsePiboAgentObservationTimestamp(input.until, "until");
-        if (since !== undefined && until !== undefined && since > until) {
-            throw new Error("Agent observation since must not be after until.");
-        }
-        const requestIds = input.requestIds ? new Set(input.requestIds) : undefined;
-        if (input.toolCallIds && input.toolCallIds.length > 50) {
-            throw new Error("Agent observation toolCallIds must contain at most 50 entries.");
-        }
-        const toolCallIds = input.toolCallIds ? new Set(input.toolCallIds) : undefined;
-        const agentIds = input.agentIds ? new Set(input.agentIds) : undefined;
-        if (agentIds) {
-            for (const agentId of agentIds)
-                this.requireManagedAgent(parentPiboSessionId, agentId);
-        }
-        const names = input.names ? new Set(input.names) : undefined;
-        const threadKeys = input.threadKeys ? new Set(input.threadKeys) : undefined;
-        const eventTypes = input.eventTypes ? new Set(input.eventTypes) : undefined;
-        const kinds = input.kinds ? new Set(input.kinds) : undefined;
-        const roles = input.roles ? new Set(input.roles) : undefined;
-        const textContains = input.textContains?.toLowerCase();
-        const defaultMessageView = eventTypes === undefined && kinds === undefined;
-        const explicitlySelectsTools = input.eventTypes?.some((eventType) => piboAgentObservationKind(eventType) === "tool") === true
-            || input.kinds?.includes("tool") === true
-            || toolCallIds !== undefined;
-        const includeTools = input.includeTools === true || (input.includeTools === undefined && explicitlySelectsTools);
-        const defaultEventTypes = includeTools
-            ? [...PIBO_AGENT_OBSERVATION_DEFAULT_EVENT_TYPES, ...PIBO_AGENT_OBSERVATION_DEFAULT_TOOL_EVENT_TYPES]
-            : [...PIBO_AGENT_OBSERVATION_DEFAULT_EVENT_TYPES];
-        const defaultEventTypeSet = new Set(defaultEventTypes);
-        const matches = this.agentObservations.filter((observation) => {
-            if (observation.managingParentId !== parentPiboSessionId)
-                return false;
-            if (requestIds && (!observation.requestId || !requestIds.has(observation.requestId)))
-                return false;
-            if (toolCallIds && (!observation.toolCallId || !toolCallIds.has(observation.toolCallId)))
-                return false;
-            if (agentIds && !agentIds.has(observation.agentId))
-                return false;
-            if (names && !names.has(observation.name))
-                return false;
-            if (threadKeys && (!observation.threadKey || !threadKeys.has(observation.threadKey)))
-                return false;
-            if (observation.kind === "tool" && !includeTools)
-                return false;
-            if (defaultMessageView && !defaultEventTypeSet.has(observation.eventType))
-                return false;
-            if (eventTypes && !eventTypes.has(observation.eventType))
-                return false;
-            if (kinds && !kinds.has(observation.kind))
-                return false;
-            if (roles && (!observation.role || !roles.has(observation.role)))
-                return false;
-            if (afterSequence !== undefined && observation.sequence <= afterSequence)
-                return false;
-            const createdAt = Date.parse(observation.createdAt);
-            if (since !== undefined && createdAt < since)
-                return false;
-            if (until !== undefined && createdAt > until)
-                return false;
-            if (textContains && !(observation.text ?? "").toLowerCase().includes(textContains))
-                return false;
-            return true;
-        });
-        const cursorPolling = afterSequence !== undefined;
-        const ordered = cursorPolling
-            ? matches.slice(0, limit)
-            : [...matches].sort((left, right) => order === "asc" ? left.sequence - right.sequence : right.sequence - left.sequence).slice(0, limit);
-        if (cursorPolling && order === "desc")
-            ordered.reverse();
-        const selected = ordered.map((observation) => {
-            const { managingParentId: _managingParentId, details, ...visible } = observation;
-            const compact = visible.kind === "tool" && toolDetail === "summary"
-                ? { ...visible, text: piboAgentObservationToolSummary(visible.text, visible.isError, details) }
-                : visible;
-            return input.includeDetails === true && details !== undefined ? { ...compact, details } : compact;
-        });
-        const evictedThrough = this.agentObservationEvictedThroughByParent.get(parentPiboSessionId) ?? 0;
-        const retentionTruncated = afterSequence === undefined ? evictedThrough > 0 : afterSequence < evictedThrough;
-        const nextAfterSequence = selected.reduce((maximum, observation) => Math.max(maximum, observation.sequence), afterSequence === undefined ? 0 : Math.max(afterSequence, evictedThrough));
-        return {
-            filters: {
-                ...input,
-                ...(defaultMessageView ? { eventTypes: defaultEventTypes } : {}),
-                ...(afterSequence !== undefined ? { afterSequence } : {}),
-                order,
-                limit,
-                includeTools,
-                toolDetail,
-                includeDetails: input.includeDetails === true,
-            },
-            observations: selected,
-            nextAfterSequence,
-            truncated: retentionTruncated || matches.length > selected.length,
-        };
+        for (const agentId of input.agentIds ?? [])
+            this.requireManagedAgent(parentPiboSessionId, agentId);
+        const query = preparePiboAgentObservationQuery(input);
+        const ordered = query.scanOrder === "asc"
+            ? this.agentObservations
+            : [...this.agentObservations].reverse();
+        return selectPiboAgentObservationPage(ordered
+            .filter((observation) => observation.managingParentId === parentPiboSessionId)
+            .map(({ managingParentId: _managingParentId, ...observation }) => observation), query, { evictedThrough: this.agentObservationEvictedThroughByParent.get(parentPiboSessionId) ?? 0 });
     }
     async killManagedAgent(parentPiboSessionId, agentId) {
         const child = this.requireManagedAgent(parentPiboSessionId, agentId);
@@ -2615,7 +2540,10 @@ export class PiboSessionRouter {
         }
     }
     projectKnownSessionSignals() {
-        for (const session of this.sessionStore.list?.() ?? []) {
+        const sessions = this.sessionStore.list?.() ?? [];
+        const depthBySessionId = new Map(sessions.map((session) => [session.id, this.getSubagentDepth(session.id)]));
+        sessions.sort((left, right) => (depthBySessionId.get(left.id) ?? 0) - (depthBySessionId.get(right.id) ?? 0));
+        for (const session of sessions) {
             this.signalRegistry.project({ type: "session_created", session });
         }
     }

package/dist/data/ingest-service.js

@@ -1,4 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
+import { outputIdentityFingerprint, outputPartFingerprint } from "../core/output-render-sequence.js";
 import { rootSessionId } from "./session-store.js";
 export class PiboOutputIdentityCollisionError extends Error {
     idempotencyKey;
@@ -89,7 +90,8 @@ export class ChatDataIngestService {
     ingestOutputEvent(input) {
         const event = input.event;
         const idempotencyKey = outputIdempotencyKey(event);
-        const identityFingerprint = outputEventFingerprint(event);
+        const identityFingerprint = outputIdentityFingerprint(event);
+        const partFingerprint = isOutputPartEvent(event) ? outputPartFingerprint(event) : undefined;
         if (idempotencyKey) {
             const existing = this.store.eventLog.findByIdempotencyKey(idempotencyKey);
             if (existing) {
@@ -156,6 +158,7 @@ export class ChatDataIngestService {
                 previewText: previewTextForOutputEvent(event),
                 attributes: compactObject({
                     identityFingerprint,
+                    outputPartFingerprint: partFingerprint,
                     eventIdentityScoped: eventIdForOutputEvent(event) !== undefined,
                     semanticEventId: eventIdForOutputEvent(event),
                     legacyStreamId: input.legacyStreamId,
@@ -270,11 +273,6 @@ function deterministicId(prefix, value) {
 function hashJson(value) {
     return createHash("sha256").update(canonicalJson(value)).digest("hex").slice(0, 16);
 }
-function outputEventFingerprint(event) {
-    const identity = { ...event };
-    delete identity.renderSequence;
-    return createHash("sha256").update(canonicalJson(identity)).digest("hex");
-}
 function canonicalJson(value) {
     if (value === null || typeof value !== "object")
         return JSON.stringify(value) ?? "null";
@@ -470,6 +468,16 @@ function observationStatusForOutputEvent(event) {
         return "error";
     return "completed";
 }
+function isOutputPartEvent(event) {
+    return event.type === "assistant_delta"
+        || event.type === "assistant_message"
+        || event.type === "thinking_started"
+        || event.type === "thinking_delta"
+        || event.type === "thinking_finished"
+        || event.type === "assistant_usage"
+        || event.type === "compaction_start"
+        || event.type === "compaction_end";
+}
 function isTerminalOutputEvent(event) {
     return !event.type.endsWith("_started") && event.type !== "tool_call" && event.type !== "assistant_delta" && event.type !== "thinking_delta" && event.type !== "tool_execution_updated";
 }

package/dist/data/pibo-store.js

@@ -8,7 +8,7 @@ import { MessageStore } from "./message-store.js";
 import { NavigationStore } from "./navigation-store.js";
 import { ObservationStore } from "./observation-store.js";
 import { PayloadStore } from "./payload-store.js";
-import { applyPiboDataSchema } from "./schema.js";
+import { applyPiboDataSchema, assertSupportedPiboDataSchemaVersion } from "./schema.js";
 import { TelemetryStore } from "./telemetry.js";
 import { SessionStore } from "./session-store.js";
 export class PiboDataStore {
@@ -27,6 +27,13 @@ export class PiboDataStore {
         if (this.path !== ":memory:")
             mkdirSync(dirname(this.path), { recursive: true });
         this.db = new DatabaseSync(this.path);
+        try {
+            assertSupportedPiboDataSchemaVersion(this.db);
+        }
+        catch (error) {
+            this.db.close();
+            throw error;
+        }
         if (insidePiboHome)
             protectPrivateFileSync(this.path);
         this.db.exec("PRAGMA busy_timeout = 5000");

package/dist/data/schema.js

@@ -1,4 +1,104 @@
 export const PIBO_DATA_SCHEMA_VERSION = 7;
+const retiredScopeColumn = ["owner", "scope"].join("_");
+const retiredScopeTables = [
+    {
+        name: "sessions",
+        columns: [
+            "id", "pi_session_id", "room_id", "root_session_id", "parent_id", "origin_id",
+            "channel", "kind", "profile", "active_model_json", "workspace", "title",
+            "first_message_preview", "status", "archived_at", "deleted_at", "metadata_json",
+            "created_at", "updated_at", "last_activity_at",
+        ],
+        definition: `
+			id TEXT PRIMARY KEY,
+			pi_session_id TEXT UNIQUE,
+			room_id TEXT,
+			root_session_id TEXT,
+			parent_id TEXT,
+			origin_id TEXT,
+			channel TEXT NOT NULL,
+			kind TEXT NOT NULL,
+			profile TEXT NOT NULL,
+			active_model_json TEXT,
+			workspace TEXT,
+			title TEXT NOT NULL DEFAULT 'Untitled Session',
+			first_message_preview TEXT,
+			status TEXT NOT NULL DEFAULT 'idle',
+			archived_at TEXT,
+			deleted_at TEXT,
+			metadata_json TEXT NOT NULL DEFAULT '{}',
+			created_at TEXT NOT NULL,
+			updated_at TEXT NOT NULL,
+			last_activity_at TEXT NOT NULL
+		`,
+    },
+    {
+        name: "rooms",
+        columns: [
+            "id", "name", "topic", "type", "parent_room_id", "workspace", "archived_at",
+            "retention_policy_id", "metadata_json", "created_at", "updated_at",
+        ],
+        definition: `
+			id TEXT PRIMARY KEY,
+			name TEXT NOT NULL,
+			topic TEXT,
+			type TEXT NOT NULL,
+			parent_room_id TEXT,
+			workspace TEXT,
+			archived_at TEXT,
+			retention_policy_id TEXT,
+			metadata_json TEXT NOT NULL DEFAULT '{}',
+			created_at TEXT NOT NULL,
+			updated_at TEXT NOT NULL
+		`,
+    },
+    {
+        name: "session_navigation",
+        columns: [
+            "room_id", "session_id", "root_session_id", "parent_id", "origin_id", "title",
+            "profile", "status", "archived_at", "last_activity_at", "last_message_preview",
+            "child_count", "sort_key", "updated_at",
+        ],
+        definition: `
+			room_id TEXT,
+			session_id TEXT PRIMARY KEY,
+			root_session_id TEXT,
+			parent_id TEXT,
+			origin_id TEXT,
+			title TEXT NOT NULL,
+			profile TEXT NOT NULL,
+			status TEXT NOT NULL,
+			archived_at TEXT,
+			last_activity_at TEXT NOT NULL,
+			last_message_preview TEXT,
+			child_count INTEGER NOT NULL DEFAULT 0,
+			sort_key TEXT NOT NULL,
+			updated_at TEXT NOT NULL
+		`,
+    },
+];
+function retiredScopeTablesToRebuild(db) {
+    return retiredScopeTables.filter((table) => ((db.prepare(`SELECT 1 FROM pragma_table_info('${table.name}') WHERE name = ?`).get(retiredScopeColumn)) !== undefined));
+}
+function rebuildRetiredScopeTables(db, tablesToRebuild) {
+    for (const table of tablesToRebuild) {
+        const replacement = `__pibo_schema_v7_${table.name}`;
+        const columnList = table.columns.join(", ");
+        db.exec(`
+			CREATE TABLE ${replacement} (${table.definition});
+			INSERT INTO ${replacement} (${columnList}) SELECT ${columnList} FROM ${table.name};
+			DROP TABLE ${table.name};
+			ALTER TABLE ${replacement} RENAME TO ${table.name};
+		`);
+    }
+}
+export function assertSupportedPiboDataSchemaVersion(db) {
+    const version = Number(db.prepare("PRAGMA user_version").get()?.user_version ?? 0);
+    if (version > PIBO_DATA_SCHEMA_VERSION) {
+        throw new Error(`Pibo database schema version ${version} is newer than supported version ${PIBO_DATA_SCHEMA_VERSION}`);
+    }
+    return version;
+}
 export const PIBO_DATA_SCHEMA_MIGRATION_STEPS = [
     "schema",
     "runtime-bindings",
@@ -11,11 +111,27 @@ export const PIBO_DATA_SCHEMA_MIGRATION_STEPS = [
     "user-version",
 ];
 export function applyPiboDataSchema(db, hooks = {}) {
+    const previousVersion = assertSupportedPiboDataSchemaVersion(db);
+    const tablesToRebuild = retiredScopeTablesToRebuild(db);
     const ownsTransaction = !db.isTransaction;
-    if (ownsTransaction)
-        db.exec("BEGIN IMMEDIATE");
+    if (!ownsTransaction && tablesToRebuild.length > 0) {
+        throw new Error("Pibo data schema migration requires an independent transaction");
+    }
+    const foreignKeysEnabled = ownsTransaction
+        && tablesToRebuild.length > 0
+        && Number(db.prepare("PRAGMA foreign_keys").get().foreign_keys ?? 0) === 1;
+    if (foreignKeysEnabled)
+        db.exec("PRAGMA foreign_keys = OFF");
     try {
-        applyPiboDataSchemaInTransaction(db, hooks);
+        if (ownsTransaction)
+            db.exec("BEGIN IMMEDIATE");
+        applyPiboDataSchemaInTransaction(db, hooks, previousVersion, tablesToRebuild);
+        if (tablesToRebuild.length > 0) {
+            const violations = db.prepare("PRAGMA foreign_key_check").all();
+            if (violations.length > 0) {
+                throw new Error(`Pibo data schema migration would retain ${violations.length} foreign-key violation(s)`);
+            }
+        }
         if (ownsTransaction)
             db.exec("COMMIT");
     }
@@ -24,12 +140,16 @@ export function applyPiboDataSchema(db, hooks = {}) {
             db.exec("ROLLBACK");
         throw error;
     }
+    finally {
+        if (foreignKeysEnabled)
+            db.exec("PRAGMA foreign_keys = ON");
+    }
 }
-function applyPiboDataSchemaInTransaction(db, hooks) {
-    const previousVersion = Number(db.prepare("PRAGMA user_version").get()?.user_version ?? 0);
+function applyPiboDataSchemaInTransaction(db, hooks, previousVersion, tablesToRebuild) {
     const existingSessionCount = db.prepare("SELECT COUNT(*) AS count FROM sqlite_schema WHERE type = 'table' AND name = 'sessions'").get();
     const hadSessionsBeforeMigration = existingSessionCount.count > 0
         && Number(db.prepare("SELECT COUNT(*) AS count FROM sessions").get().count) > 0;
+    rebuildRetiredScopeTables(db, tablesToRebuild);
     db.exec(`
 		CREATE TABLE IF NOT EXISTS sessions (
 			id TEXT PRIMARY KEY,
@@ -79,6 +199,16 @@ function applyPiboDataSchemaInTransaction(db, hooks) {
 			FOREIGN KEY (pibo_session_id) REFERENCES sessions(id) ON DELETE CASCADE
 		);
 
+		CREATE TABLE IF NOT EXISTS session_output_part_counters (
+			pibo_session_id TEXT NOT NULL,
+			event_id TEXT NOT NULL,
+			part_kind TEXT NOT NULL CHECK(part_kind IN ('assistant', 'thinking', 'usage', 'compaction')),
+			next_index INTEGER NOT NULL CHECK(next_index >= 0),
+			updated_at TEXT NOT NULL,
+			PRIMARY KEY (pibo_session_id, event_id, part_kind),
+			FOREIGN KEY (pibo_session_id) REFERENCES sessions(id) ON DELETE CASCADE
+		);
+
 		CREATE TABLE IF NOT EXISTS session_tool_invocation_counters (
 			pibo_session_id TEXT NOT NULL,
 			event_id TEXT NOT NULL,