@pasko70/pibo 1.16.5 → 2.0.0

package/dist/sessions/sqlite-store.js

@@ -3,6 +3,26 @@ import { dirname, resolve } from "node:path";
 import { piboHomePath } from "../core/pibo-home.js";
 import { DatabaseSync } from "node:sqlite";
 import { createPiboSession, matchesFindInput, } from "./store.js";
+import { createLegacyPiRuntimeSessionBinding, nextRuntimeSessionBinding, RuntimeSessionBindingConflictError, } from "./runtime-binding.js";
+const SESSION_SELECT = `
+	SELECT
+		s.*,
+		b.pibo_session_id AS binding_pibo_session_id,
+		b.runtime_instance_id AS binding_runtime_instance_id,
+		b.runtime_adapter_id AS binding_runtime_adapter_id,
+		b.native_session_id AS binding_native_session_id,
+		b.binding_state AS binding_state,
+		b.protocol AS binding_protocol,
+		b.protocol_version AS binding_protocol_version,
+		b.adapter_version AS binding_adapter_version,
+		b.locator_json AS binding_locator_json,
+		b.metadata_json AS binding_metadata_json,
+		b.revision AS binding_revision,
+		b.created_at AS binding_created_at,
+		b.updated_at AS binding_updated_at
+	FROM pibo_sessions s
+	LEFT JOIN pibo_session_runtime_bindings b ON b.pibo_session_id = s.id
+`;
 export class SqlitePiboSessionStore {
     db;
     constructor(path) {
@@ -12,16 +32,20 @@ export class SqlitePiboSessionStore {
         }
         this.db = new DatabaseSync(resolvedPath);
         this.db.exec("PRAGMA busy_timeout = 5000");
+        this.db.exec("PRAGMA foreign_keys = ON");
         if (resolvedPath !== ":memory:")
             this.db.exec("PRAGMA journal_mode = WAL");
         this.applySchema();
         this.ensureActiveModelColumn();
+        this.ensureNullablePiSessionId();
+        this.applySchema();
+        this.applyRuntimeBindingSchema();
     }
     applySchema() {
         this.db.exec(`
 			CREATE TABLE IF NOT EXISTS pibo_sessions (
 				id TEXT PRIMARY KEY,
-				pi_session_id TEXT NOT NULL UNIQUE,
+				pi_session_id TEXT UNIQUE,
 				channel TEXT NOT NULL,
 				kind TEXT NOT NULL,
 				profile TEXT NOT NULL,
@@ -50,17 +74,124 @@ export class SqlitePiboSessionStore {
         if (!columns.has("active_model_json"))
             this.db.exec("ALTER TABLE pibo_sessions ADD COLUMN active_model_json TEXT");
     }
+    ensureNullablePiSessionId() {
+        const column = this.db.prepare("PRAGMA table_info(pibo_sessions)").all()
+            .find((candidate) => candidate.name === "pi_session_id");
+        if (!column || column.notnull === 0)
+            return;
+        this.db.exec(`
+			PRAGMA foreign_keys = OFF;
+			BEGIN IMMEDIATE;
+			ALTER TABLE pibo_sessions RENAME TO pibo_sessions_before_runtime_bindings;
+			CREATE TABLE pibo_sessions (
+				id TEXT PRIMARY KEY,
+				pi_session_id TEXT UNIQUE,
+				channel TEXT NOT NULL,
+				kind TEXT NOT NULL,
+				profile TEXT NOT NULL,
+				parent_id TEXT,
+				origin_id TEXT,
+				workspace TEXT,
+				title TEXT,
+				metadata_json TEXT,
+				active_model_json TEXT,
+				created_at TEXT NOT NULL,
+				updated_at TEXT NOT NULL,
+				FOREIGN KEY(parent_id) REFERENCES pibo_sessions(id),
+				FOREIGN KEY(origin_id) REFERENCES pibo_sessions(id)
+			);
+			INSERT INTO pibo_sessions (
+				id, pi_session_id, channel, kind, profile, parent_id, origin_id,
+				workspace, title, metadata_json, active_model_json, created_at, updated_at
+			)
+			SELECT
+				id, pi_session_id, channel, kind, profile, parent_id, origin_id,
+				workspace, title, metadata_json, active_model_json, created_at, updated_at
+			FROM pibo_sessions_before_runtime_bindings;
+			DROP TABLE pibo_sessions_before_runtime_bindings;
+			COMMIT;
+			PRAGMA foreign_keys = ON;
+		`);
+    }
+    applyRuntimeBindingSchema() {
+        this.db.exec(`
+			CREATE TABLE IF NOT EXISTS pibo_session_runtime_bindings (
+				pibo_session_id TEXT PRIMARY KEY,
+				runtime_instance_id TEXT NOT NULL,
+				runtime_adapter_id TEXT NOT NULL,
+				native_session_id TEXT,
+				binding_state TEXT NOT NULL CHECK(binding_state IN ('unbound', 'bound', 'missing', 'error'))
+					CHECK(binding_state NOT IN ('bound', 'missing') OR native_session_id IS NOT NULL),
+				protocol TEXT,
+				protocol_version TEXT,
+				adapter_version TEXT,
+				locator_json TEXT,
+				metadata_json TEXT NOT NULL DEFAULT '{}',
+				revision INTEGER NOT NULL DEFAULT 1 CHECK(revision > 0),
+				created_at TEXT NOT NULL,
+				updated_at TEXT NOT NULL,
+				FOREIGN KEY(pibo_session_id) REFERENCES pibo_sessions(id) ON DELETE CASCADE
+			);
+			CREATE UNIQUE INDEX IF NOT EXISTS idx_pibo_session_runtime_bindings_native
+				ON pibo_session_runtime_bindings(runtime_adapter_id, native_session_id)
+				WHERE native_session_id IS NOT NULL;
+			CREATE INDEX IF NOT EXISTS idx_pibo_session_runtime_bindings_instance_state
+				ON pibo_session_runtime_bindings(runtime_instance_id, binding_state, updated_at DESC);
+			CREATE TRIGGER IF NOT EXISTS trg_pibo_sessions_runtime_binding_insert
+			AFTER INSERT ON pibo_sessions
+			WHEN NOT EXISTS (
+				SELECT 1 FROM pibo_session_runtime_bindings WHERE pibo_session_id = NEW.id
+			)
+			BEGIN
+				INSERT INTO pibo_session_runtime_bindings (
+					pibo_session_id, runtime_instance_id, runtime_adapter_id, native_session_id,
+					binding_state, protocol, metadata_json, revision, created_at, updated_at
+				) VALUES (NEW.id, 'pi', 'pi', NULLIF(NEW.pi_session_id, ''), 'unbound', 'pi-sdk', '{}', 1, NEW.created_at, NEW.updated_at);
+			END;
+			CREATE TRIGGER IF NOT EXISTS trg_pibo_sessions_runtime_binding_pi_update
+			AFTER UPDATE OF pi_session_id ON pibo_sessions
+			WHEN EXISTS (
+				SELECT 1 FROM pibo_session_runtime_bindings
+				WHERE pibo_session_id = NEW.id
+					AND runtime_adapter_id = 'pi'
+					AND COALESCE(native_session_id, '') <> COALESCE(NEW.pi_session_id, '')
+			)
+			BEGIN
+				UPDATE pibo_session_runtime_bindings SET
+					native_session_id = NULLIF(NEW.pi_session_id, ''),
+					binding_state = CASE WHEN NEW.pi_session_id IS NULL OR NEW.pi_session_id = '' THEN 'unbound' ELSE 'bound' END,
+					revision = revision + 1,
+					updated_at = NEW.updated_at
+				WHERE pibo_session_id = NEW.id AND runtime_adapter_id = 'pi';
+			END;
+			INSERT OR IGNORE INTO pibo_session_runtime_bindings (
+				pibo_session_id, runtime_instance_id, runtime_adapter_id, native_session_id,
+				binding_state, protocol, metadata_json, revision, created_at, updated_at
+			)
+			SELECT
+				id, 'pi', 'pi', NULLIF(pi_session_id, ''),
+				CASE WHEN pi_session_id IS NULL OR pi_session_id = '' THEN 'unbound' ELSE 'bound' END,
+				'pi-sdk', '{"migrationSource":"legacy-session-store","nativePresenceExpected":false}', 1, created_at, updated_at
+			FROM pibo_sessions
+			WHERE NOT EXISTS (
+				SELECT 1 FROM pibo_session_runtime_bindings existing
+				WHERE existing.pibo_session_id = pibo_sessions.id
+			);
+		`);
+    }
     get(id) {
-        const row = this.db.prepare("SELECT * FROM pibo_sessions WHERE id = ?").get(id);
+        const row = this.db.prepare(`${SESSION_SELECT} WHERE s.id = ?`).get(id);
         return row ? sessionFromRow(row) : undefined;
     }
     list() {
-        return this.db.prepare("SELECT * FROM pibo_sessions ORDER BY updated_at DESC").all().map(sessionFromRow);
+        return this.db.prepare(`${SESSION_SELECT} ORDER BY s.updated_at DESC`).all().map(sessionFromRow);
     }
     create(input) {
         const session = createPiboSession(input);
-        this.db
-            .prepare(`
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            this.db
+                .prepare(`
 				INSERT INTO pibo_sessions (
 					id,
 					pi_session_id,
@@ -77,7 +208,14 @@ export class SqlitePiboSessionStore {
 					updated_at
 				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
 			`)
-            .run(session.id, session.piSessionId, session.channel, session.kind, session.profile, session.parentId ?? null, session.originId ?? null, session.workspace ?? null, session.title ?? null, JSON.stringify(session.metadata ?? {}), session.activeModel ? JSON.stringify(session.activeModel) : null, session.createdAt, session.updatedAt);
+                .run(session.id, session.piSessionId || null, session.channel, session.kind, session.profile, session.parentId ?? null, session.originId ?? null, session.workspace ?? null, session.title ?? null, JSON.stringify(session.metadata ?? {}), session.activeModel ? JSON.stringify(session.activeModel) : null, session.createdAt, session.updatedAt);
+            this.upsertRuntimeBinding(session.runtimeBinding ?? createLegacyPiRuntimeSessionBinding(session.id, session.piSessionId, session.createdAt));
+            this.db.exec("COMMIT");
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
         const created = this.get(session.id);
         if (!created)
             throw new Error(`Failed to create Pibo session "${session.id}"`);
@@ -113,7 +251,7 @@ export class SqlitePiboSessionStore {
 					updated_at = ?
 				WHERE id = ?
 			`)
-            .run(updated.piSessionId, updated.profile, updated.parentId ?? null, updated.originId ?? null, updated.workspace ?? null, updated.title ?? null, JSON.stringify(updated.metadata ?? {}), updated.activeModel ? JSON.stringify(updated.activeModel) : null, updated.updatedAt, id);
+            .run(updated.piSessionId || null, updated.profile, updated.parentId ?? null, updated.originId ?? null, updated.workspace ?? null, updated.title ?? null, JSON.stringify(updated.metadata ?? {}), updated.activeModel ? JSON.stringify(updated.activeModel) : null, updated.updatedAt, id);
         return this.get(id);
     }
     delete(id) {
@@ -126,45 +264,102 @@ export class SqlitePiboSessionStore {
         if (input.ids !== undefined) {
             if (input.ids.length === 0)
                 return [];
-            clauses.push(`id IN (${input.ids.map(() => "?").join(", ")})`);
+            clauses.push(`s.id IN (${input.ids.map(() => "?").join(", ")})`);
             values.push(...input.ids);
         }
         if (input.channel !== undefined) {
-            clauses.push("channel = ?");
+            clauses.push("s.channel = ?");
             values.push(input.channel);
         }
         if (input.kind !== undefined) {
-            clauses.push("kind = ?");
+            clauses.push("s.kind = ?");
             values.push(input.kind);
         }
         if (input.parentId !== undefined) {
             if (input.parentId === null)
-                clauses.push("parent_id IS NULL");
+                clauses.push("s.parent_id IS NULL");
             else {
-                clauses.push("parent_id = ?");
+                clauses.push("s.parent_id = ?");
                 values.push(input.parentId);
             }
         }
         if (input.originId !== undefined) {
-            clauses.push("origin_id = ?");
+            clauses.push("s.origin_id = ?");
             values.push(input.originId);
         }
         if (input.profile !== undefined) {
-            clauses.push("profile = ?");
+            clauses.push("s.profile = ?");
             values.push(input.profile);
         }
         if (input.activeModel !== undefined) {
             if (input.activeModel === null)
-                clauses.push("active_model_json IS NULL");
+                clauses.push("s.active_model_json IS NULL");
             else
-                clauses.push("active_model_json IS NOT NULL");
+                clauses.push("s.active_model_json IS NOT NULL");
         }
         const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
         const rows = this.db
-            .prepare(`SELECT * FROM pibo_sessions ${where} ORDER BY updated_at DESC`)
+            .prepare(`${SESSION_SELECT} ${where} ORDER BY s.updated_at DESC`)
             .all(...values);
         return rows.map(sessionFromRow).filter((session) => matchesFindInput(session, input));
     }
+    getRuntimeBinding(id) {
+        const session = this.get(id);
+        return session?.runtimeBinding ? structuredClone(session.runtimeBinding) : undefined;
+    }
+    updateRuntimeBinding(id, binding, options = {}) {
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            const current = this.getRuntimeBinding(id);
+            if (!current) {
+                this.db.exec("ROLLBACK");
+                return undefined;
+            }
+            const currentRevision = current.revision ?? 1;
+            const updated = nextRuntimeSessionBinding(current, { ...structuredClone(binding), piboSessionId: id }, options);
+            const result = this.db.prepare(`
+				UPDATE pibo_session_runtime_bindings SET
+					runtime_instance_id = ?, runtime_adapter_id = ?, native_session_id = ?,
+					binding_state = ?, protocol = ?, protocol_version = ?, adapter_version = ?,
+					locator_json = ?, metadata_json = ?, revision = ?, updated_at = ?
+				WHERE pibo_session_id = ? AND revision = ?
+			`).run(updated.runtimeInstanceId, updated.adapterId, updated.nativeSessionId ?? null, updated.state, updated.protocol ?? null, updated.protocolVersion ?? null, updated.adapterVersion ?? null, updated.locator ? JSON.stringify(updated.locator) : null, JSON.stringify(updated.metadata ?? {}), updated.revision, updated.updatedAt, id, currentRevision);
+            if (Number(result.changes ?? 0) === 0) {
+                const actual = this.getRuntimeBinding(id);
+                throw new RuntimeSessionBindingConflictError(id, currentRevision, actual?.revision ?? 0);
+            }
+            this.db.prepare("UPDATE pibo_sessions SET pi_session_id = ?, updated_at = ? WHERE id = ?").run(updated.adapterId === "pi" ? updated.nativeSessionId ?? null : null, updated.updatedAt, id);
+            this.db.exec("COMMIT");
+            return this.getRuntimeBinding(id);
+        }
+        catch (error) {
+            if (this.db.isTransaction)
+                this.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    upsertRuntimeBinding(binding) {
+        this.db.prepare(`
+			INSERT INTO pibo_session_runtime_bindings (
+				pibo_session_id, runtime_instance_id, runtime_adapter_id, native_session_id,
+				binding_state, protocol, protocol_version, adapter_version, locator_json,
+				metadata_json, revision, created_at, updated_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+			ON CONFLICT(pibo_session_id) DO UPDATE SET
+				runtime_instance_id = excluded.runtime_instance_id,
+				runtime_adapter_id = excluded.runtime_adapter_id,
+				native_session_id = excluded.native_session_id,
+				binding_state = excluded.binding_state,
+				protocol = excluded.protocol,
+				protocol_version = excluded.protocol_version,
+				adapter_version = excluded.adapter_version,
+				locator_json = excluded.locator_json,
+				metadata_json = excluded.metadata_json,
+				revision = excluded.revision,
+				created_at = excluded.created_at,
+				updated_at = excluded.updated_at
+		`).run(binding.piboSessionId, binding.runtimeInstanceId, binding.adapterId, binding.nativeSessionId ?? null, binding.state, binding.protocol ?? null, binding.protocolVersion ?? null, binding.adapterVersion ?? null, binding.locator ? JSON.stringify(binding.locator) : null, JSON.stringify(binding.metadata ?? {}), binding.revision ?? 1, binding.createdAt ?? new Date().toISOString(), binding.updatedAt ?? binding.createdAt ?? new Date().toISOString());
+    }
     close() {
         this.db.close();
     }
@@ -175,7 +370,8 @@ export function createDefaultPiboSessionStore(_cwd) {
 function sessionFromRow(row) {
     return {
         id: row.id,
-        piSessionId: row.pi_session_id,
+        piSessionId: row.pi_session_id ?? "",
+        runtimeBinding: runtimeBindingFromRow(row),
         channel: row.channel,
         kind: row.kind,
         profile: row.profile,
@@ -189,6 +385,31 @@ function sessionFromRow(row) {
         updatedAt: row.updated_at,
     };
 }
+function runtimeBindingFromRow(row) {
+    if (!row.binding_runtime_instance_id || !row.binding_runtime_adapter_id || !row.binding_state) {
+        return createLegacyPiRuntimeSessionBinding(row.id, row.pi_session_id ?? undefined, row.created_at);
+    }
+    return {
+        piboSessionId: row.binding_pibo_session_id ?? row.id,
+        runtimeInstanceId: row.binding_runtime_instance_id,
+        adapterId: row.binding_runtime_adapter_id,
+        nativeSessionId: row.binding_native_session_id ?? undefined,
+        state: isRuntimeBindingState(row.binding_state) ? row.binding_state : "error",
+        protocol: row.binding_protocol ?? undefined,
+        protocolVersion: row.binding_protocol_version ?? undefined,
+        adapterVersion: row.binding_adapter_version ?? undefined,
+        locator: row.binding_locator_json
+            ? parseMetadata(row.binding_locator_json)
+            : undefined,
+        metadata: parseMetadata(row.binding_metadata_json),
+        revision: row.binding_revision ?? 1,
+        createdAt: row.binding_created_at ?? row.created_at,
+        updatedAt: row.binding_updated_at ?? row.updated_at,
+    };
+}
+function isRuntimeBindingState(value) {
+    return value === "unbound" || value === "bound" || value === "missing" || value === "error";
+}
 function parseMetadata(value) {
     if (!value)
         return {};

package/dist/sessions/store.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { createInitialRuntimeSessionBinding, createLegacyPiRuntimeSessionBinding, nextRuntimeSessionBinding, } from "./runtime-binding.js";
 export function createPiboSessionId() {
     return `ps_${randomUUID()}`;
 }
@@ -6,9 +7,30 @@ export function createPiSessionId() {
     return randomUUID();
 }
 export function createPiboSession(input, now = new Date().toISOString()) {
+    const id = input.id ?? createPiboSessionId();
+    const requestedBinding = input.runtimeBinding ?? {
+        runtimeInstanceId: "pi",
+        adapterId: "pi",
+        state: "unbound",
+        protocol: "pi-sdk",
+    };
+    let piSessionId = input.piSessionId?.trim() ?? "";
+    let nativeSessionId = requestedBinding.nativeSessionId?.trim() || undefined;
+    if (requestedBinding.adapterId === "pi") {
+        if (piSessionId && nativeSessionId && piSessionId !== nativeSessionId) {
+            throw new Error(`Pi session "${piSessionId}" does not match runtime binding native session "${nativeSessionId}"`);
+        }
+        nativeSessionId = nativeSessionId ?? (piSessionId || createPiSessionId());
+        piSessionId = nativeSessionId;
+    }
+    const runtimeBinding = createInitialRuntimeSessionBinding(id, {
+        ...requestedBinding,
+        nativeSessionId,
+    }, now);
     return {
-        id: input.id ?? createPiboSessionId(),
-        piSessionId: input.piSessionId ?? createPiSessionId(),
+        id,
+        piSessionId,
+        runtimeBinding,
         channel: input.channel,
         kind: input.kind,
         profile: input.profile,
@@ -25,6 +47,7 @@ export function createPiboSession(input, now = new Date().toISOString()) {
 export class InMemoryPiboSessionStore {
     byId = new Map();
     byPiSessionId = new Map();
+    byNativeSession = new Map();
     get(id) {
         return this.byId.get(id);
     }
@@ -36,9 +59,10 @@ export class InMemoryPiboSessionStore {
         if (this.byId.has(session.id)) {
             throw new Error(`Pibo session "${session.id}" already exists`);
         }
-        if (this.byPiSessionId.has(session.piSessionId)) {
+        if (session.piSessionId && this.byPiSessionId.has(session.piSessionId)) {
             throw new Error(`Pi session "${session.piSessionId}" is already attached to a Pibo session`);
         }
+        this.assertNativeSessionAvailable(session.runtimeBinding, session.id);
         this.set(session);
         return session;
     }
@@ -52,9 +76,18 @@ export class InMemoryPiboSessionStore {
                 throw new Error(`Pi session "${input.piSessionId}" is already attached to Pibo session "${attached.id}"`);
             }
         }
+        let runtimeBinding = existing.runtimeBinding ?? createLegacyPiRuntimeSessionBinding(existing.id, existing.piSessionId, existing.createdAt);
+        if (input.piSessionId !== undefined && input.piSessionId !== existing.piSessionId && runtimeBinding.adapterId === "pi") {
+            runtimeBinding = nextRuntimeSessionBinding(runtimeBinding, {
+                ...runtimeBinding,
+                nativeSessionId: input.piSessionId,
+                state: input.piSessionId ? "bound" : "unbound",
+            }, { mode: "rebind", expectedRevision: runtimeBinding.revision });
+        }
         const updated = {
             ...existing,
             piSessionId: input.piSessionId ?? existing.piSessionId,
+            runtimeBinding,
             profile: input.profile ?? existing.profile,
             parentId: input.parentId === null ? undefined : input.parentId ?? existing.parentId,
             originId: input.originId === null ? undefined : input.originId ?? existing.originId,
@@ -64,26 +97,69 @@ export class InMemoryPiboSessionStore {
             activeModel: input.activeModel === null ? undefined : input.activeModel ? { ...input.activeModel } : existing.activeModel,
             updatedAt: new Date().toISOString(),
         };
-        this.set(updated, existing.piSessionId);
+        this.assertNativeSessionAvailable(updated.runtimeBinding, id);
+        this.set(updated, existing.piSessionId, existing.runtimeBinding);
         return updated;
     }
+    getRuntimeBinding(id) {
+        const session = this.byId.get(id);
+        if (!session)
+            return undefined;
+        return structuredClone(session.runtimeBinding ?? createLegacyPiRuntimeSessionBinding(session.id, session.piSessionId, session.createdAt));
+    }
+    updateRuntimeBinding(id, binding, options = {}) {
+        const existing = this.byId.get(id);
+        if (!existing)
+            return undefined;
+        const current = existing.runtimeBinding ?? createLegacyPiRuntimeSessionBinding(existing.id, existing.piSessionId, existing.createdAt);
+        const updatedBinding = nextRuntimeSessionBinding(current, { ...structuredClone(binding), piboSessionId: id }, options);
+        this.assertNativeSessionAvailable(updatedBinding, id);
+        const updatedSession = {
+            ...existing,
+            piSessionId: updatedBinding.adapterId === "pi" ? updatedBinding.nativeSessionId ?? "" : "",
+            runtimeBinding: updatedBinding,
+            updatedAt: updatedBinding.updatedAt,
+        };
+        this.set(updatedSession, existing.piSessionId, current);
+        return structuredClone(updatedBinding);
+    }
     delete(id) {
         const existing = this.byId.get(id);
         if (!existing)
             return false;
         this.byId.delete(id);
-        this.byPiSessionId.delete(existing.piSessionId);
+        if (existing.piSessionId)
+            this.byPiSessionId.delete(existing.piSessionId);
+        const nativeKey = runtimeBindingNativeKey(existing.runtimeBinding);
+        if (nativeKey)
+            this.byNativeSession.delete(nativeKey);
         return true;
     }
     find(input) {
         return this.sort([...this.byId.values()].filter((session) => matchesFindInput(session, input)));
     }
-    set(session, previousPiSessionId) {
+    set(session, previousPiSessionId, previousBinding) {
         this.byId.set(session.id, session);
         if (previousPiSessionId && previousPiSessionId !== session.piSessionId) {
             this.byPiSessionId.delete(previousPiSessionId);
         }
-        this.byPiSessionId.set(session.piSessionId, session);
+        if (session.piSessionId)
+            this.byPiSessionId.set(session.piSessionId, session);
+        const previousNativeKey = runtimeBindingNativeKey(previousBinding);
+        const nativeKey = runtimeBindingNativeKey(session.runtimeBinding);
+        if (previousNativeKey && previousNativeKey !== nativeKey)
+            this.byNativeSession.delete(previousNativeKey);
+        if (nativeKey)
+            this.byNativeSession.set(nativeKey, session);
+    }
+    assertNativeSessionAvailable(binding, piboSessionId) {
+        const key = runtimeBindingNativeKey(binding);
+        if (!key)
+            return;
+        const attached = this.byNativeSession.get(key);
+        if (attached && attached.id !== piboSessionId) {
+            throw new Error(`Native session "${binding?.nativeSessionId}" for adapter "${binding?.adapterId}" is already attached to Pibo session "${attached.id}"`);
+        }
     }
     sort(sessions) {
         return sessions.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
@@ -122,6 +198,9 @@ export function matchesFindInput(session, input) {
         return false;
     return true;
 }
+function runtimeBindingNativeKey(binding) {
+    return binding?.nativeSessionId ? `${binding.adapterId}\0${binding.nativeSessionId}` : undefined;
+}
 function metadataMatches(metadata, expected) {
     const actual = metadata ?? {};
     for (const [key, value] of Object.entries(expected)) {

package/dist/shared/trace-engine.js

@@ -3,26 +3,34 @@ import { applySingleEventToNodes, contentDeltaPatchNodeId, dedupeTraceEvents, ev
 import { flattenTraceNodes, mapTraceNodesById, nestTraceNodes } from "./trace-nodes.js";
 import { nestMutableCopiedTraceNodes, shareUnchangedTraceNodes } from "./trace-patch-nodes.js";
 import { mapTraceChildSessionsByParent, mapTraceSubagentSessionLinks, } from "./trace-subagent-links.js";
-import { projectTranscriptEntries, traceNodesFromEntries } from "./trace-transcript.js";
+import { projectHistoryEntries, traceNodesFromHistoryEntries } from "./trace-history.js";
 export { isRunStartToolNode } from "./trace-async-agent-runs.js";
 export { assistantMessageNodeId, dedupeTraceEvents, latestTraceStreamId, messageTurnNodeId, thinkingNodeId, traceEventDedupeKey, } from "./trace-event-projection.js";
-export { traceNodesFromEntries } from "./trace-transcript.js";
+export { traceNodesFromHistoryEntries } from "./trace-history.js";
 export { compareTraceNodes, flattenTraceNodes, mapTraceNodesById, nestTraceNodes, sortTraceNodes, } from "./trace-nodes.js";
 export function buildTraceViewFromEvents(input) {
     const sessionStatus = input.status ?? "idle";
     const events = dedupeTraceEvents(input.events);
-    const allEntries = input.transcriptEntries ?? [];
-    const openTranscriptEventIds = findOpenTranscriptEventIds(events, sessionStatus);
+    const allEntries = input.historyEntries ?? [];
+    const openHistoryEventIds = findOpenTranscriptEventIds(events, sessionStatus);
     const turnTimings = mergeMessageTurnTimings(input.turnTimings ?? [], messageTurnTimingsFromEvents(events));
-    const entries = projectTranscriptEntries(allEntries, sessionStatus, openTranscriptEventIds, turnTimings);
-    const nodes = traceNodesFromEntries(input.session.id, entries, turnTimings);
+    const entries = projectHistoryEntries(allEntries, sessionStatus, openHistoryEventIds, turnTimings);
+    const nodes = traceNodesFromHistoryEntries(input.session.id, entries, turnTimings);
     reconcileTranscriptUserMessages(nodes, events, turnTimings);
     const byId = mapTraceNodesById(nodes);
     const childByParent = mapTraceChildSessionsByParent(input.sessions ?? []);
     const linkedChildByToolCallId = mapTraceSubagentSessionLinks(events);
-    const hasPersistedTranscript = entries.some((entry) => entry.type === "message");
+    const historyMode = entries.some((entry) => entry.source === "native")
+        ? "native"
+        : entries.some((entry) => entry.type === "message") ? "product" : "none";
+    const historyNodes = flattenTraceNodes(nodes);
+    const historyCoverage = {
+        mode: historyMode,
+        eventIds: new Set(historyNodes.flatMap((node) => node.eventId ? [node.eventId] : [])),
+        toolCallIds: new Set(historyNodes.flatMap((node) => node.toolCallId ? [node.toolCallId] : [])),
+    };
     for (const storedEvent of events) {
-        applySingleEventToNodes(nodes, byId, input.session.id, storedEvent, childByParent, linkedChildByToolCallId, hasPersistedTranscript, openTranscriptEventIds, sessionStatus);
+        applySingleEventToNodes(nodes, byId, input.session.id, storedEvent, childByParent, linkedChildByToolCallId, historyCoverage, openHistoryEventIds, sessionStatus);
     }
     const nestedNodes = nestTraceNodes(nodes);
     reconcileAsyncAgentRunStatuses(nestedNodes);
@@ -69,6 +77,7 @@ export function patchTraceViewWithEvents(view, events, sessionStatus) {
     const childByParent = new Map();
     const linkedChildByToolCallId = new Map();
     const openTranscriptEventIds = new Set();
+    const emptyHistoryCoverage = { mode: "none", eventIds: new Set(), toolCallIds: new Set() };
     const appliedEvents = [];
     let contentDeltaChangedNodeIds = new Set();
     for (const event of candidateEvents) {
@@ -80,7 +89,7 @@ export function patchTraceViewWithEvents(view, events, sessionStatus) {
             contentDeltaChangedNodeIds.add(contentDeltaNodeId);
         else
             contentDeltaChangedNodeIds = undefined;
-        applySingleEventToNodes(allNodes, byId, view.piboSessionId, event, childByParent, linkedChildByToolCallId, false, openTranscriptEventIds, sessionStatus);
+        applySingleEventToNodes(allNodes, byId, view.piboSessionId, event, childByParent, linkedChildByToolCallId, emptyHistoryCoverage, openTranscriptEventIds, sessionStatus);
     }
     if (!appliedEvents.length)
         return view;