@pasko70/pibo 1.0.5 → 1.2.0

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

@@ -1,32 +1,31 @@
 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.defaultPath}`);
+        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.defaultPath}`);
+        throw new Error(`Debug store "chat" not found at ${stores.chat.path}`);
     const sessionsDb = openReadOnlyDebugDatabase(stores.sessions);
-    const chatDb = openReadOnlyDebugDatabase(stores.chat);
+    const chatDb = stores.chat.path === stores.sessions.path ? sessionsDb : openReadOnlyDebugDatabase(stores.chat);
     try {
-        const sessionRow = sessionsDb.prepare("SELECT * FROM pibo_sessions WHERE id = ?").get(piboSessionId);
+        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 pibo_sessions").all().map(sessionFromRow);
-        const chatRow = tableExists(chatDb, "web_chat_sessions")
-            ? chatDb.prepare("SELECT status FROM web_chat_sessions WHERE pibo_session_id = ?").get(piboSessionId)
-            : undefined;
-        const events = tableExists(chatDb, "web_chat_events")
+        const sessions = sessionsDb.prepare("SELECT * FROM sessions").all().map(sessionFromRow);
+        const events = tableExists(chatDb, "event_log")
             ? chatDb
-                .prepare("SELECT * FROM web_chat_events WHERE pibo_session_id = ? ORDER BY rowid ASC")
-                .all(piboSessionId).map(eventFromRow)
+                .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: chatRow?.status === "running" || chatRow?.status === "error" ? chatRow.status : "idle",
+            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;
@@ -38,6 +37,7 @@ export async function inspectDebugTrace(piboSessionId, stores, options = {}) {
             nodes: filtered,
             rawNodeCount: rows.length,
             ...(options.check ? { checks: checkTraceView(view) } : {}),
+            nextCommands: buildTraceNextCommands(view.piboSessionId, filtered),
         };
     }
     catch (error) {
@@ -45,10 +45,24 @@ export async function inspectDebugTrace(piboSessionId, stores, options = {}) {
     }
     finally {
         sessionsDb.close();
-        chatDb.close();
+        if (chatDb !== sessionsDb)
+            chatDb.close();
     }
 }
-export function formatDebugTrace(result) {
+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}`,
@@ -60,17 +74,25 @@ export function formatDebugTrace(result) {
         lines.push("nodes: 0");
         return lines.join("\n");
     }
-    lines.push("status\ttype\ttitle\tid\trunId\tlinkedPiboSessionId");
+    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}`;
-        lines.push([
-            node.status,
-            node.type,
+        const values = {
+            status: node.status,
+            type: node.type,
             title,
-            node.id,
-            node.runId ?? "",
-            node.linkedPiboSessionId ?? "",
-        ].join("\t"));
+            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) {
@@ -82,6 +104,38 @@ export function formatDebugTrace(result) {
         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) {
@@ -91,6 +145,7 @@ function flattenTraceNodes(nodes, depth = 0) {
             type: node.type,
             title: node.title,
             id: node.id,
+            parentId: node.parentId,
             runId: node.runId,
             toolCallId: node.toolCallId,
             linkedPiboSessionId: node.linkedPiboSessionId,
@@ -99,6 +154,7 @@ function flattenTraceNodes(nodes, depth = 0) {
             order: formatOrderKey(node),
             startedAt: node.startedAt,
             completedAt: node.completedAt,
+            childrenCount: node.children.length,
             depth,
         },
         ...flattenTraceNodes(node.children, depth + 1),
@@ -184,6 +240,24 @@ function compareOrder(left, right) {
 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)
@@ -205,7 +279,6 @@ function sessionFromRow(row) {
         channel: row.channel,
         kind: row.kind,
         profile: row.profile,
-        ownerScope: row.owner_scope ?? undefined,
         parentId: row.parent_id ?? undefined,
         originId: row.origin_id ?? undefined,
         workspace: row.workspace ?? undefined,
@@ -216,16 +289,68 @@ function sessionFromRow(row) {
     };
 }
 function eventFromRow(row) {
+    const payload = outputPayloadFromV2Row(row);
+    if (!payload)
+        return undefined;
     return {
-        id: row.id,
-        piboSessionId: row.pibo_session_id,
-        eventSequence: row.event_sequence ?? undefined,
+        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: JSON.parse(row.payload_json),
+        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;

package/dist/debug/web-artifacts.js

@@ -0,0 +1,63 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { getPiboHome } from "../core/pibo-home.js";
+const STDOUT_BUDGET = 12_000;
+export async function writeLastSnapshot(snapshot) {
+    if (!snapshot)
+        return;
+    const file = lastSnapshotPath();
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, JSON.stringify(snapshot, null, 2), "utf-8");
+}
+export async function readBaselineSnapshot(file) {
+    const target = file ?? lastSnapshotPath();
+    let text;
+    try {
+        text = await readFile(target, "utf-8");
+    }
+    catch {
+        throw new Error(`Baseline snapshot not found at ${target}. Run pibo debug web snapshot first or pass --from <artifact>.`);
+    }
+    const parsed = JSON.parse(text);
+    if (isSnapshot(parsed))
+        return parsed;
+    if (isRecord(parsed) && isSnapshot(parsed.snapshot))
+        return parsed.snapshot;
+    if (isRecord(parsed) && isSnapshot(parsed.current))
+        return parsed.current;
+    throw new Error(`File is not a web render snapshot: ${target}`);
+}
+export async function writeArtifact(kind, payload) {
+    return writeTextArtifact(kind, "json", JSON.stringify(payload, null, 2));
+}
+export async function writeTextArtifact(kind, extension, content) {
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const dir = path.join(getPiboHome(), "debug", "web-render", stamp);
+    await mkdir(dir, { recursive: true });
+    const file = path.join(dir, `${kind}.${extension}`);
+    await writeFile(file, content, "utf-8");
+    return file;
+}
+export async function writeReportOutput(outputPath, content) {
+    const file = path.resolve(outputPath);
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, content, "utf-8");
+    return file;
+}
+export function compactTarget(target) {
+    return { id: target.id, url: target.url, title: target.title, webSocketDebuggerUrl: target.webSocketDebuggerUrl };
+}
+export function limitStdout(value) {
+    if (value.length <= STDOUT_BUDGET)
+        return value;
+    return `${value.slice(0, STDOUT_BUDGET)}\n... truncated ${value.length - STDOUT_BUDGET} chars by stdout budget ...`;
+}
+function lastSnapshotPath() {
+    return path.join(getPiboHome(), "debug", "web-render", "last-snapshot.json");
+}
+function isSnapshot(value) {
+    return isRecord(value) && value.kind === "snapshot" && typeof value.scope === "string" && Array.isArray(value.nodes);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}