@pasko70/pibo 3.4.4 → 3.5.0

package/dist/debug/storage-backup.js

@@ -0,0 +1,33 @@
+import { parseArgs } from "node:util";
+import { createStorageBackup, readStorageBackupManifest, verifyStorageBackup, restoreStorageBackup } from "../data/storage-backup.js";
+export async function runStorageBackupCli(args) {
+    const action = args[0];
+    if (!action || args.includes("--help") || args.includes("-h")) {
+        console.log(`pibo debug backup - explicit SQLite snapshot and payload backup
+Commands:
+  create   --source <sqlite> --payload-root <dir> --destination <new-dir>
+           [--resume] [--max-bytes <n>] [--max-payloads <n>] [--max-ms <n>] [--max-wal-growth <n>]
+  inspect  --archive <dir>                    Read the manifest only
+  verify   --archive <dir>                    Verify database and all payload hashes
+  restore  --archive <dir> --destination <new-dir>
+Defaults: 1 GiB data, 100000 payloads, 60000 ms and 64 MiB extra source WAL per create attempt. Resume preserves the original snapshot.
+Each archive contains one database snapshot. Product and reliability snapshots are separate cuts.
+No source deletion, vacuum, or overwrite of an existing restore destination.`);
+        return;
+    }
+    const { values } = parseArgs({ args: args.slice(1), options: { source: { type: "string" }, "payload-root": { type: "string" }, destination: { type: "string" }, archive: { type: "string" }, resume: { type: "boolean" }, "max-bytes": { type: "string" }, "max-payloads": { type: "string" }, "max-ms": { type: "string" }, "max-wal-growth": { type: "string" }, json: { type: "boolean" } } });
+    const required = (name) => { const value = values[name]; if (typeof value !== "string" || !value)
+        throw Error(`Missing --${name}`); return value; };
+    let result;
+    if (action === "create")
+        result = await createStorageBackup({ source: required("source"), payloadRoot: required("payload-root"), destination: required("destination"), resume: values.resume, maxBytes: values["max-bytes"] ? Number(values["max-bytes"]) : undefined, maxPayloads: values["max-payloads"] ? Number(values["max-payloads"]) : undefined, maxMilliseconds: values["max-ms"] ? Number(values["max-ms"]) : undefined, maxWalGrowthBytes: values["max-wal-growth"] ? Number(values["max-wal-growth"]) : undefined });
+    else if (action === "inspect")
+        result = await readStorageBackupManifest(required("archive"));
+    else if (action === "verify")
+        result = await verifyStorageBackup(required("archive"), AbortSignal.timeout(60000));
+    else if (action === "restore")
+        result = await restoreStorageBackup(required("archive"), required("destination"), AbortSignal.timeout(60000));
+    else
+        throw Error("Unknown backup action; use backup --help");
+    console.log(JSON.stringify(result, null, 2));
+}

package/dist/debug/telemetry-capture.js

@@ -0,0 +1,66 @@
+import { parseArgs } from "node:util";
+import { join, dirname } from "node:path";
+import { opendir } from "node:fs/promises";
+import { resolveDebugStore } from "./stores.js";
+import { startTelemetryCapture, inspectTelemetryCapture, finalizeTelemetryCapture, readTelemetryCapturePage } from "../data/telemetry-capture.js";
+export async function runTelemetryCaptureCli(args) {
+    const action = args[0];
+    if (!action || args.includes("--help") || args.includes("-h")) {
+        console.log(`pibo debug telemetry capture - scoped provider metadata in isolated stores
+Commands:
+  start --session <ps_...> --owner <name> --duration-ms <n> --max-bytes <n> --max-rows <n>
+  stop <capture-id>       Fence appends and finalize an independent closed archive
+  list                   List up to 100 manifests without opening databases
+  inspect <capture-id>   Read one manifest without opening its database
+  page <capture-id> [--after <sequence>] [--limit <1..100>]
+Limits: one active capture, at most one hour, 64 MiB logical data and 100000 rows per run.
+Detail is allow-listed provider metadata only. Arbitrary provider bodies, credentials and prompts are excluded.
+Stopping/finalizing is explicit; archived data is never opened by normal gateway reads.`);
+        return;
+    }
+    const { values, positionals } = parseArgs({ args: args.slice(1), allowPositionals: true, options: { session: { type: "string" }, owner: { type: "string" }, "duration-ms": { type: "string" }, "max-bytes": { type: "string" }, "max-rows": { type: "string" }, after: { type: "string" }, limit: { type: "string" }, json: { type: "boolean" } } });
+    const root = join(dirname(resolveDebugStore("pibo-data").path), "telemetry-captures");
+    let result;
+    if (action === "start")
+        result = startTelemetryCapture(root, { sessionId: values.session ?? "", owner: values.owner ?? "", durationMs: Number(values["duration-ms"]), maxBytes: Number(values["max-bytes"]), maxRows: Number(values["max-rows"]) });
+    else if (action === "list") {
+        const entries = [];
+        let scanned = 0, truncated = false;
+        try {
+            const directory = await opendir(root);
+            for await (const entry of directory) {
+                if (++scanned > 1000 || entries.length >= 100) {
+                    truncated = true;
+                    break;
+                }
+                if (!entry.isDirectory() || !entry.name.startsWith("capture_"))
+                    continue;
+                try {
+                    entries.push(inspectTelemetryCapture(root, entry.name));
+                }
+                catch {
+                    entries.push({ id: entry.name, status: "manifest_unavailable" });
+                }
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        result = { entries, truncated };
+    }
+    else {
+        const id = positionals[0];
+        if (!id)
+            throw Error("Capture id is required");
+        if (action === "stop")
+            result = await finalizeTelemetryCapture(root, id);
+        else if (action === "inspect")
+            result = inspectTelemetryCapture(root, id);
+        else if (action === "page")
+            result = await readTelemetryCapturePage(root, id, Number(values.after ?? 0), Number(values.limit ?? 50));
+        else
+            throw Error("Unknown capture action; use capture --help");
+    }
+    console.log(JSON.stringify(result, null, 2));
+}

package/dist/gateway/server.js

@@ -360,6 +360,7 @@ export class PiboGatewayServer {
             },
             findSessions: (input) => this.requireSessionStore().find(input),
             listSessions: () => this.requireSessionStore().list?.() ?? [],
+            getSessionStructureRevision: () => this.requireSessionStore().getStructureRevision?.(),
             getSessionRuntimeBinding: (piboSessionId) => this.requireRouter().getSessionRuntimeBinding(piboSessionId),
             getSessionRuntimeProfile: (piboSessionId) => this.requireRouter().getSessionRuntimeProfile(piboSessionId),
             inspectSessionRuntimeHistory: async (piboSessionId) => {
@@ -424,6 +425,7 @@ export class PiboGatewayServer {
             getSessionStatusSnapshot: (piboSessionId, options) => this.requireRouter().getSessionStatusSnapshot(piboSessionId, options),
             getSessionForkCandidates: (piboSessionId) => this.requireRouter().getSessionForkCandidates(piboSessionId),
             listSessionRuntimeStatuses: () => this.requireRouter().listSessionRuntimeStatuses(),
+            getRuntimeCapacityStatus: () => this.requireRouter().getRuntimeCapacityStatus(),
             listRuns: (options) => this.requireRouter().listRuns(options),
             snapshotSignalSession: (piboSessionId) => this.requireRouter().snapshotSignalSession(piboSessionId),
             snapshotSignalTree: (rootPiboSessionId) => this.requireRouter().snapshotSignalTree(rootPiboSessionId),

package/dist/providers/openai-gpt56.js

@@ -38,6 +38,9 @@ export const OPENAI_CODEX_GPT_6_ASTRA_MODEL = {
     name: "GPT-6-Astra",
     cost: { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 },
 };
+// Codex serves the Reserve quota alias from the Luna-class model, so Reserve borrows Luna's metadata.
+export const OPENAI_CODEX_RESERVE_MODEL = { id: "gpt-reserve", name: "Luna Reserve" };
+const OPENAI_CODEX_RESERVE_BASE_MODEL_ID = "gpt-5.6-luna";
 const OPENAI_GPT_56_MODEL_IDS = new Set(OPENAI_GPT_56_MODELS.map((model) => model.id));
 export function getBuiltInOpenAiModels() {
     return getBuiltInProviderModels(OPENAI_PROVIDER_ID);
@@ -69,6 +72,10 @@ export function buildOpenAiCodexGpt56Models(baseModels = getBuiltInOpenAiCodexMo
 }
 export function buildOpenAiCodexSupplementalModels(baseModels = getBuiltInOpenAiCodexModels()) {
     const models = buildOpenAiCodexGpt56Models(baseModels);
+    const reserveBase = models.find((model) => model.id === OPENAI_CODEX_RESERVE_BASE_MODEL_ID);
+    if (reserveBase && !models.some((model) => model.id === OPENAI_CODEX_RESERVE_MODEL.id)) {
+        models.push({ ...cloneModel(reserveBase), ...OPENAI_CODEX_RESERVE_MODEL });
+    }
     if (models.some((model) => model.id === OPENAI_CODEX_GPT_6_ASTRA_MODEL.id))
         return models;
     return [...models, openAiCodexAstraModelToRegistryModel()];
@@ -76,7 +83,7 @@ export function buildOpenAiCodexSupplementalModels(baseModels = getBuiltInOpenAi
 export function registerOpenAiSupplementalModels(modelRegistry, options = {}) {
     const baseOpenAiModels = options.baseOpenAiModels ?? getBuiltInOpenAiModels();
     const openAiModels = buildOpenAiGpt56Models(baseOpenAiModels);
-    const openAiAdded = countMissingGpt56Models(baseOpenAiModels, OPENAI_PROVIDER_ID);
+    const openAiAdded = countAddedModels(baseOpenAiModels, OPENAI_PROVIDER_ID, openAiModels);
     modelRegistry.registerProvider(OPENAI_PROVIDER_ID, {
         baseUrl: OPENAI_BASE_URL,
         api: OPENAI_RESPONSES_API,
@@ -85,9 +92,7 @@ export function registerOpenAiSupplementalModels(modelRegistry, options = {}) {
     });
     const baseOpenAiCodexModels = options.baseOpenAiCodexModels ?? getBuiltInOpenAiCodexModels();
     const openAiCodexModels = buildOpenAiCodexSupplementalModels(baseOpenAiCodexModels);
-    const hasBuiltInAstra = baseOpenAiCodexModels.some((model) => model.provider === OPENAI_CODEX_PROVIDER_ID && model.id === OPENAI_CODEX_GPT_6_ASTRA_MODEL.id);
-    const openAiCodexAdded = countMissingGpt56Models(baseOpenAiCodexModels, OPENAI_CODEX_PROVIDER_ID)
-        + (hasBuiltInAstra ? 0 : 1);
+    const openAiCodexAdded = countAddedModels(baseOpenAiCodexModels, OPENAI_CODEX_PROVIDER_ID, openAiCodexModels);
     modelRegistry.registerProvider(OPENAI_CODEX_PROVIDER_ID, {
         baseUrl: OPENAI_CODEX_BASE_URL,
         api: OPENAI_CODEX_RESPONSES_API,
@@ -128,9 +133,9 @@ function buildProviderGpt56Models(options) {
         .map((model) => openAiGpt56ModelToRegistryModel(model, options));
     return [...providerBaseModels, ...additions];
 }
-function countMissingGpt56Models(baseModels, providerId) {
+function countAddedModels(baseModels, providerId, registeredModels) {
     const existingIds = new Set(baseModels.filter((model) => model.provider === providerId).map((model) => model.id));
-    return OPENAI_GPT_56_MODELS.filter((model) => !existingIds.has(model.id)).length;
+    return registeredModels.filter((model) => !existingIds.has(model.id)).length;
 }
 function cloneModel(model) {
     return {

package/dist/session-ui/terminalRows.js

@@ -16,13 +16,14 @@ export function buildCompactTerminalRows(traceView, options) {
     if (!traceView)
         return [];
     const turnById = mapTurnNodes(traceView.nodes);
+    const showToolDebugMetrics = Boolean(options.debugMode && (options.debugFeatures?.toolMetrics ?? true));
     const flatNodes = flattenTraceNodes(traceView.nodes)
         .sort((left, right) => compareTraceNodes(left.node, right.node))
         .filter((item) => item.node.type !== "agent.turn" && (options.showThinking || item.node.type !== "model.reasoning"));
     const candidates = syncThinkingToolRows(flatNodes.map((item) => createRowCandidate(item.node, item.turnId)));
     applyCompletedTurnTiming(candidates, turnById);
     const reconciled = reconcileConceptualRowCandidates(candidates);
-    const rows = !options.debugMode && (options.toolDisplayMode ?? "default") === "default"
+    const rows = !showToolDebugMetrics && (options.toolDisplayMode ?? "default") === "default"
         ? groupRelatedToolCandidates(reconciled).map((candidate) => candidate.row)
         : reconciled.map((candidate) => candidate.row);
     return applyToolDisplayMode(rows, options.toolDisplayMode ?? "default");
@@ -159,18 +160,34 @@ function createRowCandidate(node, turnId) {
             };
             break;
     }
+    const isToolCall = node.type === "tool.call" || node.type === "tool.result" || (node.type === "agent.delegation" && Boolean(node.toolCallId));
+    const reference = isToolCall ? toolCallReference(node) : undefined;
     return {
         ...candidate,
         row: {
             ...candidate.row,
             id: compactTerminalRowIdentity(node),
             intent: node.intent,
-            isToolCall: node.type === "tool.call" || node.type === "tool.result" || (node.type === "agent.delegation" && Boolean(node.toolCallId)),
+            isToolCall,
+            toolCallReference: reference,
+            expandable: reference || Object.values(node.payloadRefs ?? {}).some(Boolean) ? true : candidate.row.expandable,
             toolMetrics: node.toolMetrics,
+            modelInferences: node.modelInferences,
             ...debugFields(node),
         },
     };
 }
+function toolCallReference(node) {
+    if (!node.toolCallId)
+        return undefined;
+    const parsed = parseTraceToolNodeIdentity(node.id);
+    return {
+        traceNodeId: node.id,
+        toolCallId: node.toolCallId,
+        eventId: node.eventId ?? parsed?.qualifier?.eventId,
+        invocationOrdinal: node.toolInvocationOrdinal ?? parsed?.qualifier?.invocationOrdinal,
+    };
+}
 export function compactTerminalRowIdentity(node) {
     if (node.type === "tool.call" || node.type === "tool.result" || node.type === "agent.delegation") {
         if (node.toolCallId) {
@@ -226,6 +243,7 @@ function reconcileConceptualRowCandidates(candidates) {
                 output: candidate.row.output ?? existing.row.output,
                 error: candidate.row.error ?? existing.row.error,
                 payloadRefs: { ...existing.row.payloadRefs, ...candidate.row.payloadRefs },
+                modelInferences: mergeModelInferences(existing.row.modelInferences, candidate.row.modelInferences),
                 imagePreviews: mergeImagePreviews(existing.row.imagePreviews, candidate.row.imagePreviews),
             },
         };
@@ -310,6 +328,16 @@ function assistantPartIndex(rowId) {
     const index = Number(match[1]);
     return Number.isSafeInteger(index) ? index : undefined;
 }
+function mergeModelInferences(existing, candidate) {
+    if (!existing?.length)
+        return candidate;
+    if (!candidate?.length)
+        return existing;
+    const merged = new Map(existing.map((record) => [record.id, record]));
+    for (const record of candidate)
+        merged.set(record.id, record);
+    return [...merged.values()];
+}
 function mergeImagePreviews(existing, candidate) {
     if (!existing?.length)
         return candidate?.slice(0, MAX_COMPACT_TERMINAL_IMAGE_PREVIEWS);
@@ -329,6 +357,9 @@ function applyCompletedTurnTiming(candidates, turnById) {
             continue;
         const turnCandidates = candidates.filter((candidate) => candidate.turnId === turn.id);
         const finalCandidate = turnCandidates.at(-1);
+        if (finalCandidate && turn.modelInferences?.length) {
+            finalCandidate.row.modelInferences = mergeModelInferences(finalCandidate.row.modelInferences, turn.modelInferences);
+        }
         if (finalCandidate?.row.kind !== "message.assistant" || finalCandidate.row.status === "running")
             continue;
         finalCandidate.row.startedAt = turn.startedAt;
@@ -362,7 +393,8 @@ function createUserMessageRow(node) {
         lines: [{ prefix: "prompt", tokens: [token(text)] }],
         sourceNodeIds: [node.id],
         forkEntryId: node.entryId,
-        pendingMessageDelivery: pendingUserMessageDelivery(node),
+        pendingMessageDelivery: pendingUserMessageDelivery(node) ?? (node.status === "running" && node.messageDeliveryState ? "queue" : undefined),
+        messageDeliveryState: node.messageDeliveryState,
         startedAt: node.startedAt,
         output: text,
         payloadRefs: node.payloadRefs,
@@ -657,9 +689,16 @@ function createCompactionRow(node) {
         input: node.input,
         output: node.output,
         error: node.error,
-        expandable: node.input !== undefined || node.output !== undefined || Boolean(node.error),
+        compactionStats: node.compactionStats,
+        compactionMarkdown: compactionMarkdown(node.output),
+        expandable: node.status === "error" && (node.input !== undefined || node.output !== undefined || Boolean(node.error)),
     };
 }
+function compactionMarkdown(value) {
+    if (!isRecord(value))
+        return undefined;
+    return stringValue(value.summary);
+}
 function createExecutionCommandRow(node) {
     if (node.title === "status") {
         return createStatusToolRow(node);
@@ -966,13 +1005,14 @@ function createExploringGroup(candidates) {
                 }] : []),
         ],
         sourceNodeIds: candidates.flatMap((candidate) => candidate.row.sourceNodeIds),
+        modelInferences: candidates.reduce((records, candidate) => mergeModelInferences(records, candidate.row.modelInferences), undefined),
         eventId: firstRow?.eventId,
         runId: firstRow?.runId,
         orderSource: firstRow?.orderSource,
         orderStreamId: firstRow?.orderStreamId,
         orderStreamFrameIndex: firstRow?.orderStreamFrameIndex,
         detailItems,
-        expandable: detailItems.some((item) => item.input !== undefined || item.output !== undefined || Boolean(item.error)),
+        expandable: detailItems.some((item) => item.toolCallReference || item.input !== undefined || item.output !== undefined || Boolean(item.error)),
         previewOmission: omittedDetailCount > 0 ? {
             source: "details",
             visibleLineCount: visibleDetailItems.length,
@@ -1014,13 +1054,14 @@ function createImageGroup(candidates) {
                 }] : []),
         ],
         sourceNodeIds: candidates.flatMap((candidate) => candidate.row.sourceNodeIds),
+        modelInferences: candidates.reduce((records, candidate) => mergeModelInferences(records, candidate.row.modelInferences), undefined),
         eventId: firstRow?.eventId,
         runId: firstRow?.runId,
         orderSource: firstRow?.orderSource,
         orderStreamId: firstRow?.orderStreamId,
         orderStreamFrameIndex: firstRow?.orderStreamFrameIndex,
         detailItems,
-        expandable: detailItems.some((item) => item.input !== undefined || item.output !== undefined || Boolean(item.error)),
+        expandable: detailItems.some((item) => item.toolCallReference || item.input !== undefined || item.output !== undefined || Boolean(item.error)),
         imagePreviews: detailItems.flatMap((item) => item.imagePreviews ?? []).slice(0, MAX_COMPACT_TERMINAL_IMAGE_PREVIEWS),
         previewOmission: omittedDetailCount > 0 ? {
             source: "details",
@@ -1043,6 +1084,7 @@ function detailItemsForGroup(candidates, kind) {
             error: candidate.row.error,
             payloadRefs: candidate.row.payloadRefs,
             linkedPiboSessionId: candidate.row.linkedPiboSessionId,
+            toolCallReference: candidate.row.toolCallReference,
             previewOmission: candidate.row.previewOmission,
             imagePreviews: candidate.row.imagePreviews,
         };

package/dist/sessions/pibo-data-store.js

@@ -49,6 +49,7 @@ export class PiboDataSessionStore {
         const row = this.db.prepare(`${SESSION_SELECT} WHERE s.id = ? AND s.deleted_at IS NULL`).get(id);
         return row ? sessionFromRow(row) : undefined;
     }
+    getStructureRevision() { return this.db.prepare("SELECT revision FROM chat_navigation_clock WHERE id=1").get().revision; }
     list() {
         return this.db.prepare(`${SESSION_SELECT} WHERE s.deleted_at IS NULL ORDER BY s.updated_at DESC`).all().map(sessionFromRow);
     }

package/dist/shared/debug-features.js

@@ -0,0 +1,4 @@
+export const DEFAULT_DEBUG_FEATURE_SETTINGS = {
+    toolMetrics: true,
+    modelInferenceMetrics: true,
+};

package/dist/shared/model-inference-metrics.js

@@ -0,0 +1,23 @@
+export function modelInferenceInputTokens(metrics) {
+    const total = tokenCount(metrics?.totalTokens);
+    const output = tokenCount(metrics?.outputTokens);
+    if (total !== undefined && output !== undefined)
+        return Math.max(0, total - output);
+    return tokenCount(metrics?.inputTokens);
+}
+export function modelInferenceCachedInputTokens(metrics) {
+    const cacheRead = tokenCount(metrics?.cacheReadTokens);
+    const cacheWrite = tokenCount(metrics?.cacheWriteTokens);
+    if (cacheRead === undefined && cacheWrite === undefined)
+        return undefined;
+    return (cacheRead ?? 0) + (cacheWrite ?? 0);
+}
+export function modelInferenceUncachedInputTokens(metrics) {
+    const input = modelInferenceInputTokens(metrics);
+    if (input === undefined)
+        return undefined;
+    return Math.max(0, input - (modelInferenceCachedInputTokens(metrics) ?? 0));
+}
+function tokenCount(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : undefined;
+}

package/dist/shared/trace-event-projection.js

@@ -6,6 +6,10 @@ import { findLikelyTraceChildSession, isSubagentToolName, } from "./trace-subage
 import { qualifiedToolNodeId } from "./trace-tool-identity.js";
 export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent, childByParent, linkedChildByToolCallId, historyCoverage, openTranscriptEventIds, sessionStatus) {
     const payload = storedEvent.payload;
+    if (payload.type === "assistant_usage") {
+        attachModelInferenceToLatestOutput(nodes, byId, payload, storedEvent);
+        return;
+    }
     if (payload.type === "message_started" && payload.source === "user" && payload.eventId) {
         const persistedUser = flattenTraceNodes([...nodes]).find((node) => node.type === "user.message"
             && isPersistedHistorySource(node.source)
@@ -42,6 +46,7 @@ export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent,
     }
     if (payload.type === "assistant_message") {
         const node = assistantMessageNodeFromEvent(piboSessionId, payload, storedEvent.createdAt, storedEvent.eventSequence, storedEvent.streamId, storedEvent.streamFrameIndex, storedEvent.traceSource, storedEvent.id);
+        applyStoredPayloadRef(node, payload, storedEvent.storedPayloadRef);
         const existing = byId.get(node.id) ?? findMatchingContentNode(byId, node);
         if (existing) {
             mergeAssistantMessageEvent(existing, node);
@@ -153,8 +158,12 @@ function applyRenderSequenceToHistoryNode(byId, storedEvent, event) {
             && typeof event.toolCallId === "string"
             && node.toolCallId === event.toolCallId
             && (!eventId || !node.eventId || node.eventId === eventId)));
-    if (target)
-        applyRenderSequence(target, storedEvent, event);
+    if (!target)
+        return;
+    applyRenderSequence(target, storedEvent, event);
+    if (event.type === "tool_execution_finished" && event.toolMetrics) {
+        target.toolMetrics = event.toolMetrics;
+    }
 }
 function applyRenderSequence(node, storedEvent, event) {
     const renderSequence = storedEvent.renderSequence ?? event.renderSequence;
@@ -171,6 +180,9 @@ function applyRenderSequence(node, storedEvent, event) {
 function applyStoredPayloadRef(node, event, storedPayloadRef) {
     if (!storedPayloadRef)
         return;
+    if (event.type === "assistant_message" || event.type === "thinking_finished") {
+        node.payloadRefs = { ...node.payloadRefs, [storedPayloadRef.payloadKind ?? "output"]: storedPayloadRef };
+    }
     if (event.type === "tool_call" || event.type === "tool_execution_started") {
         node.payloadRefs = { ...node.payloadRefs, input: storedPayloadRef };
     }
@@ -524,6 +536,47 @@ export function latestTraceStreamId(events, initial) {
     }
     return latest;
 }
+function attachModelInferenceToLatestOutput(nodes, byId, event, storedEvent) {
+    const eventId = event.eventId;
+    const candidates = flattenTraceNodes(nodes)
+        .filter((node) => node.eventId === eventId && traceNodeStartedBeforeInference(node, storedEvent) && (node.type === "assistant.message"
+        || node.type === "model.reasoning"
+        || node.type === "tool.call"
+        || node.type === "agent.delegation"))
+        .sort(compareTraceNodes);
+    const target = candidates.at(-1) ?? (eventId ? byId.get(messageTurnNodeId(eventId)) : undefined);
+    if (!target)
+        return;
+    const id = eventId ? `${eventId}:usage:${event.usageIndex ?? 0}` : storedEvent.id;
+    const record = {
+        id,
+        completedAt: storedEvent.createdAt,
+        metrics: {
+            ...(event.inputTokens === undefined ? {} : { inputTokens: event.inputTokens }),
+            ...(event.outputTokens === undefined ? {} : { outputTokens: event.outputTokens }),
+            ...(event.cacheReadTokens === undefined ? {} : { cacheReadTokens: event.cacheReadTokens }),
+            ...(event.cacheWriteTokens === undefined ? {} : { cacheWriteTokens: event.cacheWriteTokens }),
+            ...(event.reasoningTokens === undefined ? {} : { reasoningTokens: event.reasoningTokens }),
+            totalTokens: event.totalTokens,
+            ...(event.costUsd === undefined ? {} : { costUsd: event.costUsd }),
+        },
+    };
+    target.modelInferences = [...(target.modelInferences ?? []).filter((item) => item.id !== id), record];
+}
+function traceNodeStartedBeforeInference(node, storedEvent) {
+    const inferenceRenderSequence = storedEvent.renderSequence;
+    const nodeRenderSequence = node.orderKey?.renderSequence;
+    if (inferenceRenderSequence !== undefined && nodeRenderSequence !== undefined) {
+        return nodeRenderSequence <= inferenceRenderSequence;
+    }
+    const inferenceSequence = storedEvent.eventSequence ?? storedEvent.streamId;
+    const nodeSequence = node.orderKey?.eventSequence ?? node.orderKey?.streamId;
+    if (inferenceSequence !== undefined && nodeSequence !== undefined)
+        return nodeSequence <= inferenceSequence;
+    const inferenceTime = Date.parse(storedEvent.createdAt);
+    const nodeTime = Date.parse(node.startedAt ?? node.completedAt ?? "");
+    return !Number.isFinite(inferenceTime) || !Number.isFinite(nodeTime) || nodeTime <= inferenceTime;
+}
 // ── event → node helpers ─────────────────────────────────────────
 function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByToolCallId, sessionStatus, createdAt, eventSequence, streamId, streamFrameIndex, traceSource, storedInstanceId) {
     const eventId = "eventId" in event && typeof event.eventId === "string" ? event.eventId : undefined;
@@ -562,6 +615,7 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
                 type: "user.message",
                 title: "User Message",
                 status: isOptimisticUserMessageEvent(event) ? "running" : "done",
+                messageDeliveryState: isOptimisticUserMessageEvent(event) ? "sending" : undefined,
                 summary: event.text,
                 output: event.text,
             };
@@ -711,6 +765,7 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
                 input: { reason: event.reason },
                 output: event.result,
                 error: event.errorMessage,
+                compactionStats: event.compactionStats,
                 stableKey: `compaction:${eventInstanceKey}`,
             };
         }
@@ -768,6 +823,7 @@ function findMatchingContentNode(byId, update) {
     return [...byId.values()].find((candidate) => candidate.type === update.type && candidate.stableKey === update.stableKey);
 }
 function mergeAssistantMessageEvent(target, update) {
+    target.payloadRefs = { ...target.payloadRefs, ...update.payloadRefs };
     target.status = update.status;
     target.summary = update.summary ?? target.summary;
     target.output = update.output ?? target.output;
@@ -1163,6 +1219,7 @@ function mergeCompactionEvent(target, update) {
     target.input = update.input ?? target.input;
     target.output = update.output ?? target.output;
     target.error = update.error ?? target.error;
+    target.compactionStats = update.compactionStats ?? target.compactionStats;
     target.completedAt = update.completedAt ?? target.completedAt;
 }
 function hasVisibleText(value) {

package/dist/shared/trace-history.js

@@ -710,6 +710,7 @@ function createUserMessageNode(piboSessionId, entry, entryIndex, timing, fallbac
         startedAt: entry.createdAt,
         summary: text,
         output: text,
+        payloadRefs: historyContentPayloadRef(entry),
         error: entry.error,
         source,
         stableKey: eventIdentity ?? historyEntryStableKey(entry),
@@ -902,6 +903,7 @@ function createAssistantMessageNode(input) {
         completedAt: input.completedAt,
         summary: input.text,
         output: input.text,
+        payloadRefs: historyContentPayloadRef(input.entry),
         error: input.error,
         source,
         stableKey: eventIdentity ? `assistant:${eventIdentity}` : `${historyEntryStableKey(input.entry)}:response:${input.contentPartIndex}`,
@@ -909,6 +911,13 @@ function createAssistantMessageNode(input) {
         children: input.children ?? [],
     };
 }
+/** Preserve a stored full body when the bounded history page contains its preview. */
+function historyContentPayloadRef(entry) {
+    const ref = entry.source === "product" ? entry.metadata?.tracePayloadRef : undefined;
+    if (!ref || typeof ref !== "object" || Array.isArray(ref) || typeof ref.ref !== "string" || typeof ref.byteLength !== "number" || typeof ref.preview !== "string")
+        return undefined;
+    return { output: ref };
+}
 function historyMessageParts(entry) {
     return typeof entry.content === "string" ? [{ type: "text", text: entry.content }] : [...entry.content];
 }

package/dist/shared/trace-live-reducer.js

@@ -165,6 +165,7 @@ function makeStored(streamEvent, piboSessionId, type, payload, nextSequence, now
         streamId: typeof streamEvent.streamId === "number" ? streamEvent.streamId : undefined,
         streamFrameIndex,
         traceSource: "live",
+        storedPayloadRef: streamEvent.storedPayloadRef,
         eventId: typeof positionedPayload.eventId === "string" ? positionedPayload.eventId : undefined,
         type,
         createdAt: streamEventCreatedAt(streamEvent) ?? now(),

package/dist/shared/trace-patch-nodes.js

@@ -64,6 +64,7 @@ function traceNodeShallowEqual(left, right) {
         left.toolMetrics?.inputTokens === right.toolMetrics?.inputTokens &&
         left.toolMetrics?.outputTokens === right.toolMetrics?.outputTokens &&
         left.toolMetrics?.tokenBasis === right.toolMetrics?.tokenBasis &&
+        modelInferenceRecordsEqual(left.modelInferences, right.modelInferences) &&
         left.summary === right.summary &&
         left.input === right.input &&
         left.output === right.output &&
@@ -73,6 +74,24 @@ function traceNodeShallowEqual(left, right) {
         left.stableKey === right.stableKey &&
         traceOrderKeyEqual(left.orderKey, right.orderKey));
 }
+function modelInferenceRecordsEqual(left, right) {
+    if (left === right)
+        return true;
+    if (!left || !right || left.length !== right.length)
+        return false;
+    return left.every((item, index) => {
+        const other = right[index];
+        return item.id === other?.id
+            && item.completedAt === other.completedAt
+            && item.metrics.inputTokens === other.metrics.inputTokens
+            && item.metrics.outputTokens === other.metrics.outputTokens
+            && item.metrics.cacheReadTokens === other.metrics.cacheReadTokens
+            && item.metrics.cacheWriteTokens === other.metrics.cacheWriteTokens
+            && item.metrics.reasoningTokens === other.metrics.reasoningTokens
+            && item.metrics.totalTokens === other.metrics.totalTokens
+            && item.metrics.costUsd === other.metrics.costUsd;
+    });
+}
 function traceOrderKeyEqual(left, right) {
     if (left === right)
         return true;

package/dist/web/channel.js

@@ -199,6 +199,7 @@ function createGatewayStatusResponse(channelContext, options, generation) {
         generation,
         health: { status: "ok", mode },
         runtimeStatuses: createGatewayRuntimeStatuses(channelContext),
+        ...(channelContext.getRuntimeCapacityStatus ? { runtimeCapacity: channelContext.getRuntimeCapacityStatus() } : {}),
         activeRuns: collectActiveRuns(channelContext),
     });
 }
@@ -401,6 +402,8 @@ export function createWebHostChannel(options = {}) {
                 return;
             shuttingDown = false;
             context = channelContext;
+            for (const app of channelContext.getWebApps())
+                await app.initialize?.(createAppContext(channelContext));
             server = createServer((request, response) => {
                 void handleRequest(request, response);
             });

package/dist/web/http.js

@@ -107,11 +107,11 @@ export async function sendWebResponse(response, webResponse, options = {}) {
     }
     const reader = webResponse.body.getReader();
     const cancel = () => {
-        void reader.cancel();
+        void reader.cancel().catch(() => undefined);
     };
     const abort = () => {
         const socket = response.socket;
-        void reader.cancel();
+        void reader.cancel().catch(() => undefined);
         if (!response.writableEnded)
             response.end();
         socket?.end();
@@ -125,7 +125,20 @@ export async function sendWebResponse(response, webResponse, options = {}) {
             const { done, value } = await reader.read();
             if (done)
                 break;
-            response.write(Buffer.from(value));
+            const bytes = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+            for (let offset = 0; offset < bytes.length; offset += 64 * 1024) {
+                if (response.destroyed || response.writableEnded)
+                    return;
+                if (!response.write(bytes.subarray(offset, offset + 64 * 1024))) {
+                    const drained = await waitForResponseDrain(response, (webResponse.headers.get("content-type") ?? "").startsWith("text/event-stream") ? 5000 : undefined, options.signal);
+                    if (!drained) {
+                        void reader.cancel().catch(() => undefined);
+                        if (!response.destroyed)
+                            response.destroy();
+                        return;
+                    }
+                }
+            }
         }
         if (!response.writableEnded)
             response.end();
@@ -206,3 +219,23 @@ function appendVary(existing, value) {
 function appendServerTiming(existing, value) {
     return existing ? `${existing}, ${value}` : value;
 }
+/** Honor socket pressure before pulling another application frame. */
+function waitForResponseDrain(response, maximumAgeMs, signal) {
+    if (response.destroyed || response.writableEnded || signal?.aborted)
+        return Promise.resolve(false);
+    return new Promise(resolve => {
+        let timer;
+        const finish = (ready) => { if (timer)
+            clearTimeout(timer); response.off("drain", drain); response.off("close", close); response.off("error", close); signal?.removeEventListener("abort", close); resolve(ready); };
+        const drain = () => finish(true);
+        const close = () => finish(false);
+        response.once("drain", drain);
+        response.once("close", close);
+        response.once("error", close);
+        signal?.addEventListener("abort", close, { once: true });
+        if (maximumAgeMs !== undefined) {
+            timer = setTimeout(close, maximumAgeMs);
+            timer.unref();
+        }
+    });
+}

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@pasko70/pibo",
-  "version": "3.4.4",
+  "version": "3.5.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@pasko70/pibo",
-      "version": "3.4.4",
+      "version": "3.5.0",
       "workspaces": [
         "packages/workflows"
       ],