@pasko70/pibo 1.9.9 → 1.9.10

package/dist/debug/tools.js

@@ -0,0 +1,168 @@
+import { DEFAULT_TOOL_BYTES, formatTruncationFooter, sliceTextByBytes } from "./detail-format.js";
+import { formatNextCommands } from "./next-commands.js";
+import { eventAttributes, eventPayload, stringifyPayloadValue } from "./payloads.js";
+import { openReadOnlyDebugDatabase, withStorePath } from "./sql.js";
+export function inspectDebugTool(piboSessionId, store, selector, options = {}) {
+    if (!store.exists)
+        throw new Error(`Debug store "chat" not found at ${store.path}`);
+    const db = openReadOnlyDebugDatabase(store);
+    try {
+        if (!tableExists(db, "event_log"))
+            return emptyTool(piboSessionId, selector);
+        const rows = db.prepare(`
+			SELECT stream_id, session_id, session_sequence, event_id, type, created_at, 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);
+        const matching = rows.filter((row) => toolCallIdFromRow(row)?.includes(selector) || row.event_id === selector);
+        if (matching.length === 0)
+            return emptyTool(piboSessionId, selector);
+        const toolCallId = toolCallIdFromRow(matching[0]) ?? selector;
+        const toolName = firstString(matching.map(toolNameFromRow));
+        const started = matching.find((row) => row.type === "tool_execution_started") ?? matching.find((row) => row.type === "tool_call");
+        const finished = [...matching].reverse().find((row) => row.type === "tool_execution_finished");
+        const args = firstDefined(matching.map(argsFromRow));
+        const output = finished ? outputFromRow(finished) : firstDefined([...matching].reverse().map(outputFromRow));
+        const error = finished ? errorFromRow(finished) : undefined;
+        const status = statusFromRows(matching, finished);
+        const argsSlice = args !== undefined ? sliceTextByBytes(stringifyPayloadValue(args), options, DEFAULT_TOOL_BYTES) : undefined;
+        const outputSlice = output !== undefined ? sliceTextByBytes(stringifyPayloadValue(options.error ? (error ?? output) : output), options, DEFAULT_TOOL_BYTES) : undefined;
+        return {
+            piboSessionId,
+            resultType: "debug.tool",
+            selector,
+            toolCallId,
+            toolName,
+            status,
+            startedAt: started?.created_at,
+            completedAt: finished?.created_at,
+            args,
+            output,
+            error,
+            argsText: argsSlice?.text,
+            outputText: outputSlice?.text,
+            argsTruncation: argsSlice,
+            outputTruncation: outputSlice,
+            events: matching.map((row) => ({ streamId: row.stream_id, type: row.type, eventId: row.event_id ?? undefined, createdAt: row.created_at })),
+            nextCommands: [
+                `pibo debug tool ${piboSessionId} ${toolCallId} --output --no-truncate`,
+                `pibo debug tool ${piboSessionId} ${toolCallId} --args --no-truncate`,
+                finished ? `pibo debug events ${piboSessionId} show ${finished.stream_id} --payload` : undefined,
+            ].filter((command) => Boolean(command)),
+        };
+    }
+    catch (error) {
+        throw withStorePath(error, store);
+    }
+    finally {
+        db.close();
+    }
+}
+export function formatDebugTool(result, options = {}) {
+    if (!result.toolCallId)
+        return [`tool: not found`, ...formatNextCommands(result.nextCommands)].join("\n");
+    const lines = [];
+    lines.push(`toolCallId: ${result.toolCallId}`);
+    if (result.toolName)
+        lines.push(`toolName: ${result.toolName}`);
+    if (result.status)
+        lines.push(`status: ${result.status}`);
+    if (result.startedAt)
+        lines.push(`startedAt: ${result.startedAt}`);
+    if (result.completedAt)
+        lines.push(`completedAt: ${result.completedAt}`);
+    lines.push("");
+    lines.push("Events:");
+    for (const event of result.events)
+        lines.push(`  ${event.streamId}\t${event.type}\t${event.eventId ?? ""}\t${event.createdAt}`);
+    if ((options.args || !options.output) && result.argsText !== undefined) {
+        lines.push("");
+        lines.push("Args:");
+        lines.push(result.argsText);
+        if (result.argsTruncation)
+            lines.push(...formatTruncationFooter(result.argsTruncation, {
+                full: `pibo debug tool ${result.piboSessionId} ${result.toolCallId} --args --no-truncate`,
+            }));
+    }
+    if ((options.output || options.error || !options.args) && result.outputText !== undefined) {
+        lines.push("");
+        lines.push(options.error ? "Error / output:" : "Output preview:");
+        lines.push(result.outputText);
+        if (result.outputTruncation)
+            lines.push(...formatTruncationFooter(result.outputTruncation, {
+                full: `pibo debug tool ${result.piboSessionId} ${result.toolCallId} --output --no-truncate`,
+            }));
+    }
+    lines.push(...formatNextCommands(result.nextCommands));
+    return lines.join("\n");
+}
+function emptyTool(piboSessionId, selector) {
+    return { piboSessionId, resultType: "debug.tool", selector, events: [], nextCommands: [`pibo debug events ${piboSessionId} --type tool_execution_finished --limit 20`] };
+}
+function toolCallIdFromRow(row) {
+    const payload = eventPayload(row);
+    const attributes = eventAttributes(row);
+    return typeof payload.toolCallId === "string" ? payload.toolCallId : typeof attributes.toolCallId === "string" ? attributes.toolCallId : undefined;
+}
+function toolNameFromRow(row) {
+    const payload = eventPayload(row);
+    const attributes = eventAttributes(row);
+    return typeof payload.toolName === "string" ? payload.toolName : typeof attributes.toolName === "string" ? attributes.toolName : row.preview_text ?? undefined;
+}
+function argsFromRow(row) {
+    const payload = eventPayload(row);
+    if ("args" in payload)
+        return payload.args;
+    if (row.type === "tool_call" || row.type === "tool_execution_started")
+        return eventAttributes(row).inlinePayload;
+    return undefined;
+}
+function outputFromRow(row) {
+    const payload = eventPayload(row);
+    if ("result" in payload)
+        return payload.result;
+    if ("partialResult" in payload)
+        return payload.partialResult;
+    if (row.type === "tool_execution_finished" || row.type === "tool_execution_updated")
+        return eventAttributes(row).inlinePayload;
+    return undefined;
+}
+function errorFromRow(row) {
+    const payload = eventPayload(row);
+    if (typeof payload.error === "string")
+        return payload.error;
+    const result = payload.result;
+    if (result && typeof result === "object" && !Array.isArray(result)) {
+        const record = result;
+        if (typeof record.error === "string")
+            return record.error;
+    }
+    return undefined;
+}
+function statusFromRows(rows, finished) {
+    if (!finished)
+        return rows.some((row) => row.type === "tool_execution_started") ? "running" : "started";
+    const payload = eventPayload(finished);
+    if (payload.isError === true)
+        return "error";
+    const result = payload.result;
+    if (result && typeof result === "object" && !Array.isArray(result)) {
+        const details = result.details;
+        if (details && typeof details === "object" && !Array.isArray(details) && typeof details.status === "string")
+            return String(details.status);
+        if (typeof result.status === "string")
+            return String(result.status);
+    }
+    return "completed";
+}
+function firstDefined(values) {
+    return values.find((value) => value !== undefined && value !== null);
+}
+function firstString(values) {
+    return values.find((value) => Boolean(value));
+}
+function tableExists(db, table) {
+    const row = db.prepare("SELECT name FROM sqlite_schema WHERE type = 'table' AND name = ?").get(table);
+    return row !== undefined;
+}

package/dist/debug/trace-render-check.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+/**
+ * Trace Render Consistency Check
+ *
+ * Loads frontend snapshots, calls the backend replay API, applies the
+ * frontend transformations, and compares the visible row ids.
+ *
+ * Usage:
+ *   npx tsx src/debug/trace-render-check.ts --snapshots snapshots.json --api http://localhost:3000/api/chat/debug/trace-at-sequence
+ */
+import { readFileSync } from "node:fs";
+import { adaptTrace } from "../apps/chat-ui/src/tracing/adapt.js";
+import { processSpanTree } from "../apps/chat-ui/src/tracing/traceTree.js";
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let snapshotsPath = "trace-snapshots.json";
+    let apiBaseUrl = "http://localhost:3000/api/chat/debug/trace-at-sequence";
+    let piboSessionId;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--snapshots" && args[i + 1])
+            snapshotsPath = args[i + 1];
+        if (args[i] === "--api" && args[i + 1])
+            apiBaseUrl = args[i + 1];
+        if (args[i] === "--session" && args[i + 1])
+            piboSessionId = args[i + 1];
+    }
+    return { snapshotsPath, apiBaseUrl, piboSessionId };
+}
+function loadSnapshots(path) {
+    const raw = readFileSync(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.piboSessionId === "string" && Array.isArray(parsed.snapshots)) {
+        return { [parsed.piboSessionId]: parsed.snapshots };
+    }
+    return parsed;
+}
+async function replayTraceAtSequence(apiBaseUrl, piboSessionId, eventSequence) {
+    const response = await fetch(apiBaseUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ piboSessionId, eventSequence }),
+    });
+    if (!response.ok) {
+        throw new Error(`Replay API error: ${response.status} ${await response.text()}`);
+    }
+    return response.json();
+}
+function filterThinking(spans, showThinking) {
+    if (showThinking)
+        return spans;
+    return spans.filter((span) => span.spanType !== "model.reasoning");
+}
+function isExpandedAtDepth(depth, expansionDepth) {
+    if (expansionDepth === "all")
+        return true;
+    return depth < expansionDepth;
+}
+function flattenVisibleSpans(spans, expansionDepth, expandThinking, expansionOverrides, depth = 0) {
+    const rows = [];
+    for (const span of spans) {
+        const defaultExpanded = isExpandedAtDepth(depth, expansionDepth);
+        const override = expansionOverrides[span.id];
+        const contentExpanded = override?.contentExpanded ?? (span.spanType === "model.reasoning" ? expandThinking : defaultExpanded);
+        const childrenExpanded = override?.childrenExpanded ?? defaultExpanded;
+        rows.push({ id: span.id, span, depth });
+        if (span.children?.length && contentExpanded && childrenExpanded) {
+            rows.push(...flattenVisibleSpans(span.children, expansionDepth, expandThinking, expansionOverrides, depth + 1));
+        }
+    }
+    return rows;
+}
+function simulateFrontend(view, expandThinking = true) {
+    const trace = adaptTrace(view.piboSessionId, view.title, view.nodes);
+    const tree = processSpanTree(filterThinking(trace.spans, expandThinking));
+    const rows = flattenVisibleSpans(tree, "all", expandThinking, {});
+    return rows.map((r) => r.id);
+}
+function findFirstMismatch(actual, expected) {
+    const len = Math.max(actual.length, expected.length);
+    for (let i = 0; i < len; i++) {
+        if (actual[i] !== expected[i]) {
+            return { index: i, actual: actual[i] ?? "<missing>", expected: expected[i] ?? "<missing>" };
+        }
+    }
+    return null;
+}
+async function checkSession(apiBaseUrl, piboSessionId, snapshots) {
+    let checked = 0;
+    let mismatches = 0;
+    let errors = 0;
+    for (const snapshot of snapshots) {
+        const visibleLayer = snapshot.layers.find((l) => l.kind === "visibleRows");
+        if (!visibleLayer)
+            continue;
+        const backendLayer = snapshot.layers.find((l) => l.kind === "backendNodes");
+        const frontendIds = visibleLayer.ids;
+        // Use the available snapshot size as a coarse replay point. This keeps
+        // the checker useful even when a snapshot trigger has no explicit
+        // event sequence.
+        try {
+            const lastEventSequence = backendLayer ? backendLayer.ids.length : frontendIds.length;
+            const replayed = await replayTraceAtSequence(apiBaseUrl, piboSessionId, lastEventSequence);
+            const simulatedIds = simulateFrontend(replayed);
+            const mismatch = findFirstMismatch(frontendIds, simulatedIds);
+            if (mismatch) {
+                mismatches++;
+                console.error(`\n[MISMATCH] ${piboSessionId} @ ${new Date(snapshot.timestamp).toISOString()}`);
+                console.error(`  Trigger: ${snapshot.trigger}`);
+                console.error(`  First diff at index ${mismatch.index}:`);
+                console.error(`    Frontend: ${mismatch.actual}`);
+                console.error(`    Backend+Sim: ${mismatch.expected}`);
+            }
+            else {
+                checked++;
+            }
+        }
+        catch (caught) {
+            errors++;
+            console.error(`\n[ERROR] ${piboSessionId} @ ${new Date(snapshot.timestamp).toISOString()}: ${caught}`);
+        }
+    }
+    return { checked, mismatches, errors };
+}
+async function main() {
+    const options = parseArgs();
+    const allSnapshots = loadSnapshots(options.snapshotsPath);
+    const sessions = options.piboSessionId ? { [options.piboSessionId]: allSnapshots[options.piboSessionId] ?? [] } : allSnapshots;
+    console.log(`Trace Render Consistency Check`);
+    console.log(`Snapshots: ${options.snapshotsPath}`);
+    console.log(`API: ${options.apiBaseUrl}`);
+    console.log(`Sessions: ${Object.keys(sessions).length}\n`);
+    let totalChecked = 0;
+    let totalMismatches = 0;
+    let totalErrors = 0;
+    for (const [piboSessionId, snapshots] of Object.entries(sessions)) {
+        if (!snapshots.length)
+            continue;
+        console.log(`Checking session ${piboSessionId} (${snapshots.length} snapshots)...`);
+        const result = await checkSession(options.apiBaseUrl, piboSessionId, snapshots);
+        totalChecked += result.checked;
+        totalMismatches += result.mismatches;
+        totalErrors += result.errors;
+        console.log(`  OK: ${result.checked}, Mismatch: ${result.mismatches}, Error: ${result.errors}`);
+    }
+    console.log(`\nTotal: ${totalChecked} OK, ${totalMismatches} mismatches, ${totalErrors} errors`);
+    process.exit(totalMismatches > 0 || totalErrors > 0 ? 1 : 0);
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/debug/trace.js

@@ -0,0 +1,370 @@
+import { buildTraceView } from "../apps/chat/trace.js";
+import { normalizeSessionErrorDetails } from "../core/session-errors.js";
+import { compareTraceOrder } from "../shared/trace-order.js";
+import { openReadOnlyDebugDatabase, withStorePath } from "./sql.js";
+import { formatNextCommands } from "./next-commands.js";
+export async function inspectDebugTrace(piboSessionId, stores, options = {}) {
+    if (!stores.sessions.exists)
+        throw new Error(`Debug store "sessions" not found at ${stores.sessions.path}`);
+    if (!stores.chat.exists)
+        throw new Error(`Debug store "chat" not found at ${stores.chat.path}`);
+    const sessionsDb = openReadOnlyDebugDatabase(stores.sessions);
+    const chatDb = stores.chat.path === stores.sessions.path ? sessionsDb : openReadOnlyDebugDatabase(stores.chat);
+    try {
+        const sessionRow = sessionsDb.prepare("SELECT * FROM sessions WHERE id = ?").get(piboSessionId);
+        if (!sessionRow)
+            throw new Error(`Pibo session "${piboSessionId}" not found`);
+        const session = sessionFromRow(sessionRow);
+        const sessions = sessionsDb.prepare("SELECT * FROM sessions").all().map(sessionFromRow);
+        const events = tableExists(chatDb, "event_log")
+            ? chatDb
+                .prepare("SELECT stream_id, session_id, session_sequence, event_id, type, created_at, preview_text, attributes_json FROM event_log WHERE session_id = ? ORDER BY stream_id ASC")
+                .all(piboSessionId).map(eventFromRow).filter((event) => event !== undefined)
+            : [];
+        const view = await buildTraceView({
+            session,
+            sessions,
+            events,
+            status: sessionRow.status === "running" || sessionRow.status === "error" ? sessionRow.status : "idle",
+        });
+        const rows = flattenTraceNodes(view.nodes);
+        const filtered = options.runningOnly ? rows.filter((node) => node.status === "running") : rows;
+        return {
+            piboSessionId: view.piboSessionId,
+            piSessionId: view.piSessionId,
+            title: view.title,
+            status: traceStatus(view),
+            nodes: filtered,
+            rawNodeCount: rows.length,
+            ...(options.check ? { checks: checkTraceView(view) } : {}),
+            nextCommands: buildTraceNextCommands(view.piboSessionId, filtered),
+        };
+    }
+    catch (error) {
+        throw withStorePath(withStorePath(error, stores.chat), stores.sessions);
+    }
+    finally {
+        sessionsDb.close();
+        if (chatDb !== sessionsDb)
+            chatDb.close();
+    }
+}
+export async function inspectDebugTraceNode(piboSessionId, stores, nodeId) {
+    const trace = await inspectDebugTrace(piboSessionId, stores, {});
+    const node = trace.nodes.find((item) => item.id === nodeId);
+    const children = trace.nodes.filter((item) => item.parentId === nodeId);
+    return {
+        piboSessionId,
+        resultType: "debug.trace.show",
+        nodeId,
+        node,
+        children,
+        nextCommands: node ? buildNodeNextCommands(piboSessionId, node) : [`pibo debug trace ${piboSessionId}`],
+    };
+}
+export function formatDebugTrace(result, options = {}) {
+    const lines = [
+        `piboSessionId: ${result.piboSessionId}`,
+        `piSessionId: ${result.piSessionId}`,
+        `title: ${result.title}`,
+        `status: ${result.status}`,
+        "",
+    ];
+    if (result.nodes.length === 0) {
+        lines.push("nodes: 0");
+        return lines.join("\n");
+    }
+    const columns = options.medium
+        ? ["status", "type", "title", "id", "runId", "toolCallId", "linkedPiboSessionId", "source", "stableKey", "order"]
+        : ["status", "type", "title", "id", "runId", "linkedPiboSessionId"];
+    lines.push(columns.join("\t"));
+    for (const node of result.nodes) {
+        const title = `${"  ".repeat(node.depth)}${node.title}`;
+        const values = {
+            status: node.status,
+            type: node.type,
+            title,
+            id: node.id,
+            runId: node.runId,
+            toolCallId: node.toolCallId,
+            linkedPiboSessionId: node.linkedPiboSessionId,
+            source: node.source,
+            stableKey: node.stableKey,
+            order: node.order,
+        };
+        lines.push(columns.map((column) => values[column] ?? "").join("\t"));
+    }
+    lines.push(`nodes: ${result.nodes.length}${result.nodes.length !== result.rawNodeCount ? ` of ${result.rawNodeCount}` : ""}`);
+    if (result.checks) {
+        lines.push("");
+        lines.push(`checks: ${result.checks.status}`);
+        for (const issue of result.checks.issues) {
+            lines.push(`${issue.severity}\t${issue.code}\t${issue.nodeId ?? ""}\t${issue.message}`);
+        }
+        if (result.checks.issues.length === 0)
+            lines.push("issues: 0");
+    }
+    lines.push(...formatNextCommands(result.nextCommands ?? []));
+    return lines.join("\n");
+}
+export function formatDebugTraceNode(result) {
+    if (!result.node)
+        return [`node: not found`, ...formatNextCommands(result.nextCommands)].join("\n");
+    const node = result.node;
+    const lines = [];
+    lines.push(`nodeId: ${node.id}`);
+    lines.push(`type: ${node.type}`);
+    lines.push(`title: ${node.title}`);
+    lines.push(`status: ${node.status}`);
+    if (node.parentId)
+        lines.push(`parentId: ${node.parentId}`);
+    if (node.startedAt)
+        lines.push(`startedAt: ${node.startedAt}`);
+    if (node.completedAt)
+        lines.push(`completedAt: ${node.completedAt}`);
+    if (node.source)
+        lines.push(`source: ${node.source}`);
+    if (node.stableKey)
+        lines.push(`stableKey: ${node.stableKey}`);
+    if (node.order)
+        lines.push(`order: ${node.order}`);
+    lines.push(`children: ${result.children.length}`);
+    if (node.linkedPiboSessionId)
+        lines.push(`linkedPiboSessionId: ${node.linkedPiboSessionId}`);
+    if (node.runId)
+        lines.push(`runId: ${node.runId}`);
+    if (node.toolCallId)
+        lines.push(`toolCallId: ${node.toolCallId}`);
+    lines.push(...formatNextCommands(result.nextCommands));
+    return lines.join("\n");
+}
+function flattenTraceNodes(nodes, depth = 0) {
+    return nodes.flatMap((node) => [
+        {
+            status: node.status,
+            type: node.type,
+            title: node.title,
+            id: node.id,
+            parentId: node.parentId,
+            runId: node.runId,
+            toolCallId: node.toolCallId,
+            linkedPiboSessionId: node.linkedPiboSessionId,
+            source: node.source,
+            stableKey: node.stableKey,
+            order: formatOrderKey(node),
+            startedAt: node.startedAt,
+            completedAt: node.completedAt,
+            childrenCount: node.children.length,
+            depth,
+        },
+        ...flattenTraceNodes(node.children, depth + 1),
+    ]);
+}
+function traceStatus(view) {
+    const rows = flattenTraceNodes(view.nodes);
+    if (rows.some((node) => node.status === "error"))
+        return "error";
+    if (rows.some((node) => node.status === "running"))
+        return "running";
+    return "done";
+}
+function checkTraceView(view) {
+    const issues = [];
+    const all = flattenPiboTraceNodes(view.nodes);
+    const ids = new Set();
+    for (const node of all) {
+        if (ids.has(node.id)) {
+            issues.push({
+                severity: "warning",
+                code: "duplicate_id",
+                nodeId: node.id,
+                message: "Trace node id appears more than once.",
+            });
+        }
+        ids.add(node.id);
+        if (!node.orderKey) {
+            issues.push({
+                severity: "warning",
+                code: "missing_order",
+                nodeId: node.id,
+                message: "Trace node has no stable order key and may fall back to timestamp ordering.",
+            });
+        }
+        if (!node.source) {
+            issues.push({
+                severity: "warning",
+                code: "missing_source",
+                nodeId: node.id,
+                message: "Trace node has no projection source.",
+            });
+        }
+        if (!node.stableKey) {
+            issues.push({
+                severity: "warning",
+                code: "missing_stable_key",
+                nodeId: node.id,
+                message: "Trace node has no conceptual stable key.",
+            });
+        }
+    }
+    for (const node of all) {
+        if (node.parentId && !ids.has(node.parentId)) {
+            issues.push({
+                severity: "warning",
+                code: "missing_parent",
+                nodeId: node.id,
+                message: `Parent "${node.parentId}" is not present in the trace tree.`,
+            });
+        }
+    }
+    checkSiblingOrder(view.nodes, issues);
+    return { status: issues.length ? "warning" : "ok", issues };
+}
+function checkSiblingOrder(nodes, issues) {
+    for (let index = 1; index < nodes.length; index += 1) {
+        if (compareOrder(nodes[index - 1], nodes[index]) > 0) {
+            issues.push({
+                severity: "warning",
+                code: "order_regression",
+                nodeId: nodes[index].id,
+                message: `Node appears before previous sibling by stable order: ${nodes[index - 1].id}`,
+            });
+        }
+    }
+    for (const node of nodes)
+        checkSiblingOrder(node.children, issues);
+}
+function compareOrder(left, right) {
+    return compareTraceOrder(left.orderKey, right.orderKey) || left.id.localeCompare(right.id);
+}
+function flattenPiboTraceNodes(nodes) {
+    return nodes.flatMap((node) => [node, ...flattenPiboTraceNodes(node.children)]);
+}
+function buildTraceNextCommands(piboSessionId, nodes) {
+    const errorNode = nodes.find((node) => node.status === "error");
+    const firstNode = nodes[0];
+    return [
+        errorNode ? `pibo debug trace ${piboSessionId} show ${errorNode.id}` : firstNode ? `pibo debug trace ${piboSessionId} show ${firstNode.id}` : undefined,
+        nodes.some((node) => node.status === "error") ? `pibo debug failures ${piboSessionId}` : undefined,
+        `pibo debug messages ${piboSessionId} list`,
+    ].filter((command) => Boolean(command));
+}
+function buildNodeNextCommands(piboSessionId, node) {
+    return [
+        node.toolCallId ? `pibo debug tool ${piboSessionId} ${node.toolCallId}` : undefined,
+        node.linkedPiboSessionId ? `pibo debug session ${node.linkedPiboSessionId}` : undefined,
+        node.linkedPiboSessionId ? `pibo debug trace ${node.linkedPiboSessionId}` : undefined,
+        `pibo debug trace ${piboSessionId} --medium`,
+        `pibo debug events ${piboSessionId} --limit 20`,
+    ].filter((command) => Boolean(command));
+}
+function formatOrderKey(node) {
+    const order = node.orderKey;
+    if (!order)
+        return undefined;
+    return [
+        `turn=${order.turnSeq}`,
+        order.transcriptIndex === undefined ? undefined : `tx=${order.transcriptIndex}`,
+        order.contentPartIndex === undefined ? undefined : `part=${order.contentPartIndex}`,
+        order.eventSequence === undefined ? undefined : `event=${order.eventSequence}`,
+        order.streamFrameIndex === undefined ? undefined : `frame=${order.streamFrameIndex}`,
+        `phase=${order.phaseRank}`,
+        `source=${order.sourceRank}`,
+    ].filter(Boolean).join(",");
+}
+function sessionFromRow(row) {
+    return {
+        id: row.id,
+        piSessionId: row.pi_session_id,
+        channel: row.channel,
+        kind: row.kind,
+        profile: row.profile,
+        parentId: row.parent_id ?? undefined,
+        originId: row.origin_id ?? undefined,
+        workspace: row.workspace ?? undefined,
+        title: row.title ?? undefined,
+        metadata: parseObject(row.metadata_json),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function eventFromRow(row) {
+    const payload = outputPayloadFromV2Row(row);
+    if (!payload)
+        return undefined;
+    return {
+        id: String(row.stream_id),
+        piboSessionId: row.session_id ?? undefined,
+        eventSequence: row.session_sequence ?? undefined,
+        eventId: row.event_id ?? undefined,
+        streamId: row.stream_id,
+        type: row.type,
+        createdAt: row.created_at,
+        payload,
+    };
+}
+function outputPayloadFromV2Row(row) {
+    const attributes = parseObject(row.attributes_json);
+    const inlinePayload = attributes.inlinePayload;
+    if (inlinePayload && typeof inlinePayload === "object" && !Array.isArray(inlinePayload) && typeof inlinePayload.type === "string") {
+        return inlinePayload;
+    }
+    const piboSessionId = row.session_id;
+    if (!piboSessionId)
+        return undefined;
+    const base = { piboSessionId, eventId: row.event_id ?? undefined };
+    if (row.type === "assistant_message")
+        return compactObject({ ...base, type: "assistant_message", text: row.preview_text ?? "" });
+    if (row.type === "message_started")
+        return compactObject({ ...base, type: "message_started", text: row.preview_text ?? "" });
+    if (row.type === "message_finished")
+        return compactObject({ ...base, type: "message_finished" });
+    if (row.type === "thinking_started")
+        return compactObject({ ...base, type: "thinking_started" });
+    if (row.type === "thinking_finished")
+        return compactObject({ ...base, type: "thinking_finished", text: row.preview_text ?? "" });
+    if (row.type === "tool_call")
+        return compactObject({ ...base, type: "tool_call", toolCallId: stringAttribute(attributes, "toolCallId") ?? row.event_id ?? `tool_${row.stream_id}`, toolName: row.preview_text ?? stringAttribute(attributes, "toolName") ?? "tool", args: inlinePayload ?? null, argsComplete: booleanAttribute(attributes, "argsComplete") ?? true });
+    if (row.type === "tool_execution_started")
+        return compactObject({ ...base, type: "tool_execution_started", toolCallId: stringAttribute(attributes, "toolCallId") ?? row.event_id ?? `tool_${row.stream_id}`, toolName: row.preview_text ?? stringAttribute(attributes, "toolName") ?? "tool", args: inlinePayload ?? null });
+    if (row.type === "tool_execution_updated")
+        return compactObject({ ...base, type: "tool_execution_updated", toolCallId: stringAttribute(attributes, "toolCallId") ?? row.event_id ?? `tool_${row.stream_id}`, toolName: row.preview_text ?? stringAttribute(attributes, "toolName") ?? "tool", args: null, partialResult: inlinePayload ?? null });
+    if (row.type === "tool_execution_finished")
+        return compactObject({ ...base, type: "tool_execution_finished", toolCallId: stringAttribute(attributes, "toolCallId") ?? row.event_id ?? `tool_${row.stream_id}`, toolName: row.preview_text ?? stringAttribute(attributes, "toolName") ?? "tool", result: inlinePayload ?? null, isError: booleanAttribute(attributes, "isError") ?? false });
+    if (row.type === "session_error") {
+        const error = stringAttribute(attributes, "error") ?? row.preview_text ?? "Error";
+        return compactObject({ ...base, type: "session_error", error, errorDetails: normalizeSessionErrorDetails(error, isRecord(attributes.errorDetails) ? attributes.errorDetails : undefined) });
+    }
+    return compactObject({ ...base, type: row.type });
+}
+function stringAttribute(attributes, key) {
+    const value = attributes[key];
+    return typeof value === "string" ? value : undefined;
+}
+function booleanAttribute(attributes, key) {
+    const value = attributes[key];
+    return typeof value === "boolean" ? value : undefined;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function compactObject(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+function tableExists(db, table) {
+    const row = db.prepare("SELECT name FROM sqlite_schema WHERE type = 'table' AND name = ?").get(table);
+    return row !== undefined;
+}
+function parseObject(value) {
+    if (!value)
+        return {};
+    try {
+        const parsed = JSON.parse(value);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}