@pasko70/pibo 1.16.6 → 2.0.0

package/dist/debug/pty.js

@@ -312,20 +312,21 @@ function builtinScenario(name, options) {
             PIBO_DEBUG_PTY_ASSISTANT_REPLY: "Mocked PTY assistant response",
         },
         steps: [
-            { waitFor: "Pibo CLI Sessions", timeoutMs: 20_000 },
-            { typeText: "/new" },
+            { waitFor: "select room", timeoutMs: 20_000 },
             { press: "Enter" },
-            { sleepMs: 750 },
+            { waitFor: "select session", timeoutMs: 10_000 },
+            { press: "Enter" },
+            { waitFor: "Created session", timeoutMs: 10_000 },
             { typeText: "Hi", iteration: true },
             { press: "Enter" },
             { waitFor: "Mocked PTY assistant response", timeoutMs: 10_000 },
             { typeText: "/status" },
             { press: "Enter" },
-            { waitFor: "source=", timeoutMs: 10_000 },
-            { typeText: "/quit" },
+            { waitFor: "Runtime: local", timeoutMs: 10_000 },
+            { typeText: "/exit" },
             { press: "Enter" },
         ],
-        expect: ["Pibo CLI Sessions", "Hi", "Mocked PTY assistant response"],
+        expect: ["pibo sessions", "Created session", "Hi", "Mocked PTY assistant response", "Runtime: local"],
         reject: ["UnhandledPromiseRejection", "source_closed"],
     }, options);
 }

package/dist/debug/runtime-binding.js

@@ -0,0 +1,29 @@
+export function readDebugRuntimeIdentity(db, piboSessionId) {
+    const bindingTable = db.prepare("SELECT name FROM sqlite_schema WHERE type = 'table' AND name = 'session_runtime_bindings'").get();
+    if (bindingTable) {
+        const row = db.prepare(`
+			SELECT runtime_instance_id, runtime_adapter_id, native_session_id, binding_state
+			FROM session_runtime_bindings WHERE pibo_session_id = ?
+		`).get(piboSessionId);
+        if (row) {
+            return {
+                runtimeInstanceId: row.runtime_instance_id,
+                runtimeAdapterId: row.runtime_adapter_id,
+                nativeSessionId: row.native_session_id ?? undefined,
+                runtimeBindingState: row.binding_state,
+            };
+        }
+    }
+    const sessionsTable = db.prepare("SELECT name FROM sqlite_schema WHERE type = 'table' AND name = 'sessions'").get();
+    if (!sessionsTable)
+        return {};
+    const session = db.prepare("SELECT pi_session_id FROM sessions WHERE id = ?").get(piboSessionId);
+    if (!session)
+        return {};
+    return {
+        runtimeInstanceId: "pi",
+        runtimeAdapterId: "pi",
+        nativeSessionId: session.pi_session_id ?? undefined,
+        runtimeBindingState: session.pi_session_id ? "bound" : "unbound",
+    };
+}

package/dist/debug/session.js

@@ -36,6 +36,7 @@ export function inspectDebugSession(input, stores, options = {}) {
             warnings,
             session: compactSessionRow(session),
             metadata,
+            runtimeBinding: readRuntimeBinding(sessionsDb, session),
             room: {
                 urlRoomId: parsed.roomId,
                 sessionRoomId,
@@ -74,6 +75,78 @@ export function inspectDebugSession(input, stores, options = {}) {
         sessionsDb.close();
     }
 }
+export function inspectDebugSessionRuntime(input, stores) {
+    const parsed = parseDebugSessionInput(input);
+    if (!stores.sessions.exists)
+        throw new Error(`Debug store "sessions" not found at ${stores.sessions.path}`);
+    const sessionsDb = openReadOnlyDebugDatabase(stores.sessions);
+    const chatDb = stores.chat.exists && stores.chat.path !== stores.sessions.path ? openReadOnlyDebugDatabase(stores.chat) : sessionsDb;
+    try {
+        const session = sessionsDb.prepare("SELECT * FROM sessions WHERE id = ?").get(parsed.piboSessionId);
+        if (!session)
+            throw new Error(`Pibo session "${parsed.piboSessionId}" not found`);
+        const binding = readRuntimeBinding(sessionsDb, session);
+        const eventStats = tableExists(chatDb, "event_log")
+            ? chatDb.prepare(`
+				SELECT COUNT(*) AS count, COUNT(payload_ref) AS payload_refs,
+					MIN(session_sequence) AS first_sequence, MAX(session_sequence) AS last_sequence
+				FROM event_log WHERE session_id = ?
+			`).get(parsed.piboSessionId)
+            : { count: 0, payload_refs: 0, first_sequence: null, last_sequence: null };
+        const messages = tableExists(chatDb, "chat_messages")
+            ? Number(chatDb.prepare("SELECT COUNT(*) AS count FROM chat_messages WHERE session_id = ?").get(parsed.piboSessionId).count)
+            : 0;
+        const observations = tableExists(chatDb, "observations")
+            ? Number(chatDb.prepare("SELECT COUNT(*) AS count FROM observations WHERE session_id = ?").get(parsed.piboSessionId).count)
+            : 0;
+        return {
+            piboSessionId: parsed.piboSessionId,
+            resultType: "debug.session.runtime",
+            binding,
+            productHistory: {
+                messages,
+                events: Number(eventStats.count),
+                observations,
+                payloadRefs: Number(eventStats.payload_refs),
+                firstEventSequence: eventStats.first_sequence ?? undefined,
+                lastEventSequence: eventStats.last_sequence ?? undefined,
+            },
+            nextCommands: [
+                `pibo debug trace ${parsed.piboSessionId} --check`,
+                `pibo debug trace ${parsed.piboSessionId} --native-history --check`,
+                `pibo debug events ${parsed.piboSessionId} --limit 20`,
+            ],
+        };
+    }
+    catch (error) {
+        throw withStorePath(withStorePath(error, stores.chat), stores.sessions);
+    }
+    finally {
+        sessionsDb.close();
+        if (chatDb !== sessionsDb)
+            chatDb.close();
+    }
+}
+export function formatDebugSessionRuntime(result) {
+    const lines = [
+        `piboSessionId: ${result.piboSessionId}`,
+        "",
+        "Runtime binding:",
+        ...Object.entries(result.binding).map(([key, value]) => `  ${key}: ${formatValue(value)}`),
+        "",
+        "Product history:",
+        `  messages: ${result.productHistory.messages}`,
+        `  events: ${result.productHistory.events}`,
+        `  observations: ${result.productHistory.observations}`,
+        `  payloadRefs: ${result.productHistory.payloadRefs}`,
+    ];
+    if (result.productHistory.firstEventSequence !== undefined)
+        lines.push(`  firstEventSequence: ${result.productHistory.firstEventSequence}`);
+    if (result.productHistory.lastEventSequence !== undefined)
+        lines.push(`  lastEventSequence: ${result.productHistory.lastEventSequence}`);
+    lines.push(...formatNextCommands(result.nextCommands));
+    return lines.join("\n");
+}
 export function formatDebugSessionSummary(summary) {
     const lines = [];
     lines.push(`piboSessionId: ${summary.input.piboSessionId}`);
@@ -90,6 +163,13 @@ export function formatDebugSessionSummary(summary) {
     for (const [key, value] of Object.entries(summary.session)) {
         lines.push(`  ${key}: ${formatValue(value)}`);
     }
+    if (summary.runtimeBinding) {
+        lines.push("");
+        lines.push("Runtime binding:");
+        for (const [key, value] of Object.entries(summary.runtimeBinding)) {
+            lines.push(`  ${key}: ${formatValue(value)}`);
+        }
+    }
     if (Object.keys(summary.metadata).length) {
         lines.push("");
         lines.push("Metadata:");
@@ -147,6 +227,63 @@ function listChildSessions(db, piboSessionId, limit) {
         };
     });
 }
+function readRuntimeBinding(db, session) {
+    if (!tableExists(db, "session_runtime_bindings")) {
+        return {
+            pibo_session_id: session.id,
+            runtime_instance_id: "pi",
+            runtime_adapter_id: "pi",
+            native_session_id: session.pi_session_id,
+            binding_state: session.pi_session_id ? "bound" : "unbound",
+            source: "legacy-synthesized",
+        };
+    }
+    const row = db.prepare(`
+		SELECT
+			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
+		FROM session_runtime_bindings
+		WHERE pibo_session_id = ?
+	`).get(session.id);
+    if (row) {
+        const { locator_json, metadata_json, ...safe } = row;
+        return {
+            ...safe,
+            locator: sanitizeBindingLocator(parseObject(locator_json ?? null)),
+            metadata_keys: Object.keys(parseObject(metadata_json ?? null)).sort(),
+        };
+    }
+    return {
+        pibo_session_id: session.id,
+        runtime_instance_id: "pi",
+        runtime_adapter_id: "pi",
+        native_session_id: session.pi_session_id,
+        binding_state: session.pi_session_id ? "bound" : "unbound",
+        source: "legacy-synthesized",
+    };
+}
+function sanitizeBindingLocator(locator) {
+    const kind = stringValue(locator.kind);
+    if (!kind)
+        return undefined;
+    const value = stringValue(locator.value);
+    if (!value)
+        return { kind };
+    if (kind === "local-file" || kind === "local-directory")
+        return { kind, value };
+    try {
+        const url = new URL(value);
+        url.username = "";
+        url.password = "";
+        url.search = "";
+        url.hash = "";
+        return { kind, value: url.toString() };
+    }
+    catch {
+        return { kind, value: "[redacted]" };
+    }
+}
 function readChatSession(db, piboSessionId) {
     if (!tableExists(db, "sessions"))
         return undefined;

package/dist/debug/summary.js

@@ -22,6 +22,10 @@ export async function inspectDebugSummary(input, stores) {
     }, {});
     return {
         piboSessionId: parsed.piboSessionId,
+        runtimeInstanceId: session.runtimeBinding?.runtime_instance_id,
+        runtimeAdapterId: session.runtimeBinding?.runtime_adapter_id,
+        nativeSessionId: session.runtimeBinding?.native_session_id,
+        runtimeBindingState: session.runtimeBinding?.binding_state,
         status: session.session.status,
         traceStatus,
         roomId: session.room.sessionRoomId,
@@ -45,6 +49,14 @@ export async function inspectDebugSummary(input, stores) {
 export function formatDebugSummary(result) {
     const lines = [];
     lines.push(`piboSessionId: ${result.piboSessionId}`);
+    if (result.runtimeInstanceId !== undefined)
+        lines.push(`runtimeInstanceId: ${result.runtimeInstanceId}`);
+    if (result.runtimeAdapterId !== undefined)
+        lines.push(`runtimeAdapterId: ${result.runtimeAdapterId}`);
+    if (result.nativeSessionId !== undefined)
+        lines.push(`nativeSessionId: ${result.nativeSessionId}`);
+    if (result.runtimeBindingState !== undefined)
+        lines.push(`runtimeBindingState: ${result.runtimeBindingState}`);
     if (result.status !== undefined)
         lines.push(`status: ${result.status}`);
     if (result.traceStatus)

package/dist/debug/telemetry.js

@@ -1,6 +1,7 @@
 import { DatabaseSync } from "node:sqlite";
 import { TelemetryStaleDetector } from "../core/telemetry-staleness.js";
 import { TelemetryStore as PiboTelemetryStore } from "../data/telemetry.js";
+import { readDebugRuntimeIdentity } from "./runtime-binding.js";
 import { formatRows, openReadOnlyDebugDatabase } from "./sql.js";
 const DEFAULT_TELEMETRY_CLI_LIMIT = 20;
 const MAX_TELEMETRY_CLI_LIMIT = 200;
@@ -36,6 +37,7 @@ export function inspectTelemetrySession(store, piboSessionId, options = {}) {
             return notFound(`No telemetry found for Pibo Session ${piboSessionId}.`, piboSessionId);
         return {
             available: true,
+            ...readTelemetryRuntimeIdentity(store, piboSessionId),
             command: "session",
             piboSessionId,
             limit,
@@ -59,6 +61,7 @@ export function inspectTelemetryTurn(store, turnIdOrEventId, options = {}) {
         const missingTerminalEvent = timeline.turn.status === "running" && !timeline.phases.some((phase) => phase.name === "finish" && phase.status === "ok");
         return {
             available: true,
+            ...readTelemetryRuntimeIdentity(store, timeline.turn.piboSessionId),
             command: "turn",
             turnIdOrEventId,
             limit,
@@ -82,6 +85,7 @@ export function inspectTelemetryProvider(store, providerRequestId) {
             return notFound(`No telemetry found for provider request ${providerRequestId}.`);
         return {
             available: true,
+            ...readTelemetryRuntimeIdentity(store, request.piboSessionId),
             command: "provider",
             providerRequestId,
             request,
@@ -105,6 +109,7 @@ export function inspectTelemetryProviderEvents(store, providerRequestId, options
         }));
         return {
             available: true,
+            ...readTelemetryRuntimeIdentity(store, request.piboSessionId),
             command: "provider events",
             providerRequestId,
             limit,
@@ -123,6 +128,7 @@ export function inspectTelemetryProviderPayload(store, providerRequestId, payloa
             return notFound(`No telemetry found for provider request ${providerRequestId}.`);
         return {
             available: true,
+            ...readTelemetryRuntimeIdentity(store, request.piboSessionId),
             command: "provider payload",
             providerRequestId,
             payloadRef,
@@ -138,6 +144,7 @@ export function inspectTelemetryTool(store, toolCallId) {
             return notFound(`No telemetry found for tool call ${toolCallId}.`);
         return {
             available: true,
+            ...readTelemetryRuntimeIdentity(store, tool.piboSessionId),
             command: "tool",
             toolCallId,
             tool,
@@ -236,6 +243,7 @@ export function formatTelemetrySession(result) {
     const toolCallId = firstId(detail.toolCalls, "toolCallId");
     return [
         `pibo debug telemetry session ${result.piboSessionId}`,
+        ...formatTelemetryRuntimeIdentity(result),
         `status\t${activeTurn?.status ?? "idle"}`,
         `queueDepth\t${activeTurn?.queueDepth ?? "-"}`,
         `activeTurn\t${activeTurn?.turnId ?? "-"}`,
@@ -263,6 +271,7 @@ export function formatTelemetryTurn(result) {
     return [
         `pibo debug telemetry turn ${timeline.turn.turnId}`,
         `session\t${timeline.turn.piboSessionId}`,
+        ...formatTelemetryRuntimeIdentity(result),
         `status\t${timeline.turn.status}`,
         `currentPhase\t${timeline.turn.currentPhase ?? "-"}`,
         `openPhases\t${result.openPhases}`,
@@ -285,6 +294,7 @@ export function formatTelemetryProvider(result) {
     return [
         `pibo debug telemetry provider ${result.providerRequestId}`,
         `session\t${request.piboSessionId}`,
+        ...formatTelemetryRuntimeIdentity(result),
         `turn\t${request.turnId}`,
         `phase\t${request.phaseId ?? "-"}`,
         `status\t${request.status}`,
@@ -413,6 +423,17 @@ export function formatTelemetryPrune(result) {
         ...result.nextCommands.map((command) => `  ${command}`),
     ].join("\n");
 }
+function readTelemetryRuntimeIdentity(store, piboSessionId) {
+    if (!store.exists)
+        return {};
+    const db = openReadOnlyDebugDatabase(store);
+    try {
+        return readDebugRuntimeIdentity(db, piboSessionId);
+    }
+    finally {
+        db.close();
+    }
+}
 function withTelemetryStore(store, action, options = {}) {
     if (!store.exists) {
         return {
@@ -484,6 +505,13 @@ function notFound(message, piboSessionId, turnId) {
         ].filter((command) => typeof command === "string"),
     };
 }
+function formatTelemetryRuntimeIdentity(result) {
+    return [
+        result.runtimeInstanceId ? `runtimeInstanceId\t${result.runtimeInstanceId}` : undefined,
+        result.runtimeAdapterId ? `runtimeAdapterId\t${result.runtimeAdapterId}` : undefined,
+        result.runtimeBindingState ? `runtimeBindingState\t${result.runtimeBindingState}` : undefined,
+    ].filter((value) => Boolean(value));
+}
 function formatUnavailable(result) {
     return [
         result.message,

package/dist/debug/tools.js

@@ -2,6 +2,8 @@ import { DEFAULT_TOOL_BYTES, formatTruncationFooter, sliceTextByBytes } from "./
 import { formatNextCommands } from "./next-commands.js";
 import { eventAttributes, eventPayload, stringifyPayloadValue } from "./payloads.js";
 import { openReadOnlyDebugDatabase, withStorePath } from "./sql.js";
+import { createDebugPayloadStore, hydrateDebugEventRow } from "./persisted-payloads.js";
+import { readDebugRuntimeIdentity } from "./runtime-binding.js";
 export function inspectDebugTool(piboSessionId, store, selector, options = {}) {
     if (!store.exists)
         throw new Error(`Debug store "chat" not found at ${store.path}`);
@@ -9,12 +11,13 @@ export function inspectDebugTool(piboSessionId, store, selector, options = {}) {
     try {
         if (!tableExists(db, "event_log"))
             return emptyTool(piboSessionId, selector);
+        const payloadStore = createDebugPayloadStore(db, store);
         const rows = db.prepare(`
-			SELECT stream_id, session_id, session_sequence, event_id, type, created_at, preview_text, attributes_json
+			SELECT stream_id, session_id, session_sequence, event_id, type, created_at, payload_ref, preview_text, attributes_json
 			FROM event_log
 			WHERE session_id = ? AND type IN ('tool_call', 'tool_execution_started', 'tool_execution_updated', 'tool_execution_finished')
 			ORDER BY stream_id ASC
-		`).all(piboSessionId);
+		`).all(piboSessionId).map((row) => hydrateDebugEventRow(row, payloadStore));
         const matching = rows.filter((row) => toolCallIdFromRow(row)?.includes(selector) || row.event_id === selector);
         if (matching.length === 0)
             return emptyTool(piboSessionId, selector);
@@ -30,6 +33,7 @@ export function inspectDebugTool(piboSessionId, store, selector, options = {}) {
         const outputSlice = output !== undefined ? sliceTextByBytes(stringifyPayloadValue(options.error ? (error ?? output) : output), options, DEFAULT_TOOL_BYTES) : undefined;
         return {
             piboSessionId,
+            ...readDebugRuntimeIdentity(db, piboSessionId),
             resultType: "debug.tool",
             selector,
             toolCallId,
@@ -63,6 +67,12 @@ export function formatDebugTool(result, options = {}) {
     if (!result.toolCallId)
         return [`tool: not found`, ...formatNextCommands(result.nextCommands)].join("\n");
     const lines = [];
+    if (result.runtimeInstanceId)
+        lines.push(`runtimeInstanceId: ${result.runtimeInstanceId}`);
+    if (result.runtimeAdapterId)
+        lines.push(`runtimeAdapterId: ${result.runtimeAdapterId}`);
+    if (result.runtimeBindingState)
+        lines.push(`runtimeBindingState: ${result.runtimeBindingState}`);
     lines.push(`toolCallId: ${result.toolCallId}`);
     if (result.toolName)
         lines.push(`toolName: ${result.toolName}`);