@pasko70/pibo 3.4.4 → 3.5.0

package/dist/apps/chat/data/timeline-query-service.js

@@ -1,12 +1,15 @@
 import { createHash } from "node:crypto";
+import { boundedMessageBytes } from "../../../data/bounded-worker-client.js";
 import { messageTurnTimingsFromEvents } from "../../../shared/trace-event-projection.js";
 import { storedChatEventFromV2Row, storedPiboEventFromV2Row } from "./chat-data-mappers.js";
 import { TRACE_RECONCILIATION_ENTRY_CAP, TRACE_RECONCILIATION_TIMING_CAP } from "../../../shared/trace-limits.js";
 import { parseTraceToolNodeIdentity } from "../../../shared/trace-tool-identity.js";
 export class ChatTimelineQueryService {
     store;
-    constructor(store) {
+    hydrationBytes;
+    constructor(store, hydrationBytes = 1024 * 1024) {
         this.store = store;
+        this.hydrationBytes = hydrationBytes;
     }
     listEvents(input = {}) {
         const clauses = [];
@@ -25,8 +28,17 @@ export class ChatTimelineQueryService {
         }
         const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
         const limit = Math.max(1, Math.min(input.limit ?? 1000, 5000));
-        const rows = this.store.db.prepare(`SELECT * FROM event_log ${where} ORDER BY stream_id ASC LIMIT ?`).all(...values, limit);
-        return rows.map((row) => storedChatEventFromV2Row(row, this.store.payloads));
+        const rows = this.store.db.prepare(`SELECT * FROM event_log ${where} ORDER BY stream_id ASC LIMIT ?`).iterate(...values, limit);
+        const events = [];
+        let remainingBytes = 4 * 1024 * 1024 - 16;
+        for (const row of rows) {
+            const event = storedChatEventFromV2Row(row, this.store.payloads, this.hydrationBytes);
+            // Stop hydration as soon as the page exceeds IPC capacity. Callers can retry a
+            // smaller page without first allocating every large body in the requested range.
+            remainingBytes -= boundedMessageBytes(event, remainingBytes - 32) + 32;
+            events.push(event);
+        }
+        return events;
     }
     listSessionEvents(piboSessionId, limit = 1000) {
         return this.listTraceEvents({ piboSessionId, limit, includeLive: true });
@@ -39,7 +51,7 @@ export class ChatTimelineQueryService {
     }
     scanMessageTurnTimings(piboSessionId) {
         const rows = this.store.db.prepare(`
-			SELECT * FROM event_log
+			SELECT * FROM event_log INDEXED BY idx_event_log_timing_sequence
 			WHERE session_id = ?
 				AND type IN ('message_queued', 'message_steered', 'message_started', 'message_finished', 'session_error', 'thinking_finished', 'assistant_message')
 			ORDER BY session_sequence ASC, stream_id ASC
@@ -47,7 +59,7 @@ export class ChatTimelineQueryService {
 		`).all(piboSessionId, TRACE_RECONCILIATION_TIMING_CAP + 1);
         if (rows.length > TRACE_RECONCILIATION_TIMING_CAP)
             return { timings: [], overflow: true };
-        const events = rows.map((row) => storedPiboEventFromV2Row(row, this.store.payloads)).filter((event) => event !== undefined);
+        const events = rows.map((row) => storedPiboEventFromV2Row(row, this.store.payloads, this.hydrationBytes)).filter((event) => event !== undefined);
         return { timings: messageTurnTimingsFromEvents(events), overflow: false };
     }
     listTraceEvents(input) {
@@ -70,14 +82,14 @@ export class ChatTimelineQueryService {
         }
         const rows = this.store.db.prepare(`
 			SELECT * FROM (
-				SELECT * FROM event_log
+				SELECT * FROM event_log ${includeLive ? "" : "INDEXED BY idx_event_log_semantic_sequence"}
 				WHERE ${clauses.join(" AND ")}
 				ORDER BY session_sequence DESC, stream_id DESC
 				LIMIT ?
 			)
 			ORDER BY session_sequence ASC, stream_id ASC
 		`).all(...values, limit);
-        return rows.map((row) => storedPiboEventFromV2Row(row, this.store.payloads)).filter((event) => event !== undefined);
+        return rows.map((row) => storedPiboEventFromV2Row(row, this.store.payloads, this.hydrationBytes)).filter((event) => event !== undefined);
     }
     isPayloadAttachedToTraceNode(input) {
         const nodeIdentity = parseTraceToolNodeIdentity(input.nodeId);

package/dist/apps/chat/message-command-dispatcher.js

@@ -0,0 +1,134 @@
+import { PiboSteeringUnavailableError } from "../../core/events.js";
+import { randomUUID } from "node:crypto";
+/** Owns bounded dispatches; durable claims, not this map, own accepted work. */
+export class MessageCommandDispatcher {
+    storage;
+    context;
+    owner = `message-dispatch:${randomUUID()}`;
+    claims = new Map();
+    lastRenewed = new Map();
+    timer;
+    disposed = false;
+    pumping;
+    wakePending = false;
+    lastFailureReportAt = 0;
+    leaseMs = 30_000;
+    constructor(storage, context) {
+        this.storage = storage;
+        this.context = context;
+        this.wake();
+    }
+    wake() {
+        if (this.disposed)
+            return;
+        if (this.pumping) {
+            this.wakePending = true;
+            return;
+        }
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+        let nextPollMs = 50;
+        this.pumping = this.pump().catch(error => {
+            nextPollMs = 1000;
+            this.wakePending = false;
+            if (Date.now() - this.lastFailureReportAt >= 5000) {
+                this.lastFailureReportAt = Date.now();
+                console.warn("[pibo] durable message dispatcher unavailable", { code: error && typeof error === "object" && "code" in error ? String(error.code) : "dispatch_failed" });
+            }
+        }).finally(() => {
+            this.pumping = undefined;
+            if (!this.disposed) {
+                if (this.wakePending) {
+                    this.wakePending = false;
+                    queueMicrotask(() => this.wake());
+                }
+                else {
+                    this.timer = setTimeout(() => this.wake(), nextPollMs);
+                    this.timer.unref?.();
+                }
+            }
+        });
+    }
+    outputPersisted(event) {
+        if (event.type !== "message_finished" && event.type !== "session_error" && event.type !== "message_steered")
+            return;
+        if (!event.eventId)
+            return;
+        for (const [id, claim] of this.claims)
+            if (claim.sessionId === event.piboSessionId && claim.eventId === event.eventId)
+                this.forget(id);
+        this.wake();
+    }
+    forget(id) { this.claims.delete(id); this.lastRenewed.delete(id); }
+    async pump() {
+        for (const [id, claim] of this.claims) {
+            if (this.disposed)
+                return;
+            if (Date.now() - (this.lastRenewed.get(id) ?? 0) < this.leaseMs / 3)
+                continue;
+            if (!await this.storage.heartbeatCommand(id, this.owner, claim.token, this.leaseMs))
+                this.forget(id);
+            else
+                this.lastRenewed.set(id, Date.now());
+        }
+        while (!this.disposed && this.claims.size < 12) {
+            const claim = await this.storage.claimCommand(this.owner, this.leaseMs);
+            if (!claim)
+                break;
+            this.claims.set(claim.id, claim);
+            this.lastRenewed.set(claim.id, Date.now());
+            // A slow cold runtime must not serialize unrelated session admission or dispatch.
+            void this.dispatch(claim);
+        }
+    }
+    async dispatch(claim) {
+        try {
+            if (this.disposed)
+                return;
+            if (!this.context.getSession(claim.sessionId)) {
+                await this.storage.transitionCommand(claim.id, this.owner, claim.token, "failed", "Target session no longer exists.");
+                this.forget(claim.id);
+                this.wake();
+                return;
+            }
+            if (!await this.storage.transitionCommand(claim.id, this.owner, claim.token, "initializing")) {
+                this.forget(claim.id);
+                this.wake();
+                return;
+            }
+            if (this.disposed)
+                return;
+            const output = await this.context.emit({ type: "message", piboSessionId: claim.sessionId, id: claim.eventId, text: claim.text, delivery: claim.delivery, source: "user" });
+            if (output.type === "session_error") {
+                await this.storage.transitionCommand(claim.id, this.owner, claim.token, "failed", "Runtime rejected the accepted message.");
+                this.forget(claim.id);
+                this.wake();
+            }
+            // Output ingest advances queued/running/terminal state. No late emit result may downgrade it.
+        }
+        catch (error) {
+            if (!this.disposed) {
+                const cancelled = Boolean(error && typeof error === "object" && "code" in error && error.code === "runtime_start_cancelled");
+                const steering = error instanceof PiboSteeringUnavailableError;
+                const capacity = Boolean(error && typeof error === "object" && "code" in error && error.code === "runtime_capacity_unavailable");
+                try {
+                    await this.storage.transitionCommand(claim.id, this.owner, claim.token, cancelled || steering || capacity ? "failed" : "interrupted", cancelled ? "Message cancelled before runtime dispatch." : capacity ? "Runtime capacity was unavailable before dispatch; the message did not run." : steering ? "Steering is unavailable; the message was not queued as a normal turn." : "Runtime dispatch outcome is unclear; inspect the session before retrying.");
+                }
+                catch { /* Lease expiry retains the uncertain outcome. */ }
+                this.forget(claim.id);
+                this.wake();
+            }
+        }
+    }
+    async dispose() {
+        this.disposed = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+        await this.pumping;
+        this.claims.clear();
+        this.lastRenewed.clear();
+        // Do not release dispatched claims for replay: the router may still own side effects.
+    }
+}

package/dist/apps/chat/output-compactor.js

@@ -1,6 +1,9 @@
 import { assistantOutputKey, isLiveOnlyOutputEvent, thinkingOutputKey, toolOutputKey } from "./output-event-policy.js";
 const MAX_TRACKED_COMPACTOR_SESSIONS = 1_024;
 export class OutputCompactor {
+    liveVersion = 0;
+    liveVersions = new Map();
+    versionForSession(id) { return this.liveVersions.get(id) ?? this.liveVersion; }
     assistantBuffers = new Map();
     thinkingBuffers = new Map();
     toolSnapshots = new Map();
@@ -100,6 +103,10 @@ export class OutputCompactor {
             settled = true;
             for (const mutate of mutations)
                 mutate();
+            this.liveVersions.delete(event.piboSessionId);
+            this.liveVersions.set(event.piboSessionId, ++this.liveVersion);
+            while (this.liveVersions.size > MAX_TRACKED_COMPACTOR_SESSIONS)
+                this.liveVersions.delete(this.liveVersions.keys().next().value);
             this.touchSession(event.piboSessionId);
         };
         return {
@@ -148,8 +155,10 @@ export class OutputCompactor {
         }
         this.sessionBufferCounts.delete(piboSessionId);
         this.sessionRecency.delete(piboSessionId);
+        this.liveVersions.delete(piboSessionId);
     }
     disposeAll() {
+        this.liveVersions.clear();
         this.assistantBuffers.clear();
         this.thinkingBuffers.clear();
         this.toolSnapshots.clear();

package/dist/apps/chat/output-event-policy.js

@@ -84,7 +84,8 @@ export function isPiboOutputEvent(value) {
             return typeof value.reason === "string"
                 && typeof value.aborted === "boolean"
                 && isOptionalNonNegativeSafeInteger(value.compactionIndex)
-                && isOptionalString(value.errorMessage);
+                && isOptionalString(value.errorMessage)
+                && (value.compactionStats === undefined || isCompactionStats(value.compactionStats));
         case "approval_requested":
             return isApprovalRequest(value.request);
         case "approval_resolved":
@@ -117,6 +118,13 @@ function isOptionalFiniteNumber(value) {
 function isOptionalString(value) {
     return value === undefined || typeof value === "string";
 }
+function isCompactionStats(value) {
+    if (!isRecord(value) || !isNonNegativeSafeInteger(value.toolCallCount))
+        return false;
+    if (!isOptionalFiniteNumber(value.maxToolOutputTokens) || !isOptionalFiniteNumber(value.compactionTokens))
+        return false;
+    return value.maxToolOutputTokenBasis === undefined || typeof value.maxToolOutputTokenBasis === "string";
+}
 function isOptionalNonNegativeSafeInteger(value) {
     return value === undefined || isNonNegativeSafeInteger(value);
 }

package/dist/apps/chat/stream.js

@@ -1,8 +1,26 @@
+class BoundedStreamIdentitySet extends Set {
+    bytes = 0;
+    add(key) {
+        if (this.has(key))
+            return this;
+        const bytes = key.length * 2;
+        if (bytes > 256 * 1024)
+            return this;
+        super.add(key);
+        this.bytes += bytes;
+        while (this.size > 2048 || this.bytes > 256 * 1024)
+            this.delete(this.values().next().value);
+        return this;
+    }
+    delete(key) { if (!super.delete(key))
+        return false; this.bytes -= key.length * 2; return true; }
+    clear() { super.clear(); this.bytes = 0; }
+}
 export function createChatStreamState() {
     return {
-        textMessageIds: new Set(),
-        reasoningMessageIds: new Set(),
-        toolCallIds: new Set(),
+        textMessageIds: new BoundedStreamIdentitySet(),
+        reasoningMessageIds: new BoundedStreamIdentitySet(),
+        toolCallIds: new BoundedStreamIdentitySet(),
         transientFrameIndex: 0,
     };
 }

package/dist/apps/chat/telemetry-retention-service.js

@@ -1,3 +1,5 @@
+import { AsyncTelemetryMaintenance } from "../../data/async-telemetry-maintenance.js";
+import { TelemetryMaintenance } from "../../data/telemetry-maintenance.js";
 import { telemetryRetentionCutoff, } from "../../core/telemetry-retention-settings.js";
 export const TELEMETRY_RETENTION_CLASSES = [
     "live",
@@ -7,14 +9,33 @@ export const TELEMETRY_RETENTION_CLASSES = [
     "incident",
 ];
 export const DEFAULT_TELEMETRY_RETENTION_MAINTENANCE_INTERVAL_MS = 24 * 60 * 60 * 1000;
+/** Bounded recovery: back off a failing maintenance job, then leave it visible instead of respawning. */
+export const TELEMETRY_RETENTION_MAINTENANCE_FAILURE_LIMIT = 8;
+export const TELEMETRY_RETENTION_MAINTENANCE_MAX_RETRY_MS = 30_000;
+export async function disposeTelemetryRetentionMaintenance(state) {
+    state.disposed = true;
+    if (state.timer)
+        clearTimeout(state.timer);
+    state.timer = undefined;
+    state.running = false;
+    await state.worker?.close();
+    state.worker = undefined;
+}
 export function pruneTelemetryOlderThan(input) {
     const cutoff = telemetryRetentionCutoff(input.days, input.now);
-    const results = TELEMETRY_RETENTION_CLASSES.map((retentionClass) => input.dataStore.telemetry.prune({ retentionClass, before: cutoff, apply: input.apply }));
+    const results = [];
+    for (const retentionClass of TELEMETRY_RETENTION_CLASSES) {
+        const result = input.dataStore.telemetry.prune({ retentionClass, before: cutoff, apply: input.apply });
+        results.push(result);
+        if (result.completed === false)
+            break;
+    }
     return {
         cutoff,
         days: input.days,
         applied: input.apply === true,
         results,
+        completed: results.every(result => result.completed !== false),
         rowsDeleted: results.reduce((sum, result) => sum + result.rowsDeleted, 0),
         bytesMatched: results.reduce((sum, result) => sum + result.bytesMatched, 0),
     };
@@ -27,6 +48,8 @@ export function isTelemetryRetentionMaintenanceDue(input) {
     return !(input.state.lastCheckedAt && now.getTime() - input.state.lastCheckedAt < intervalMs);
 }
 export function maybeRunTelemetryRetentionMaintenance(input) {
+    if (input.state.disposed)
+        return;
     if (!input.settings.enabled)
         return;
     if (input.state.running)
@@ -39,19 +62,70 @@ export function maybeRunTelemetryRetentionMaintenance(input) {
         input.state.lastCheckedAt = now.getTime();
         return;
     }
-    if (hasActiveRuntimeWork(input.context))
-        return;
     input.state.lastCheckedAt = now.getTime();
     input.state.running = true;
-    setTimeout(() => {
+    const cutoff = telemetryRetentionCutoff(input.settings.days, now);
+    const local = input.dataStore.path === ":memory:" ? new TelemetryMaintenance(input.dataStore.db) : undefined;
+    let consecutiveFailures = 0;
+    const run = async () => {
+        let failed = false;
         try {
-            pruneTelemetryOlderThan({ dataStore: input.dataStore, days: input.settings.days, now, apply: true });
-            input.onPruned?.(now.toISOString());
+            if (input.state.disposed)
+                return;
+            if (local) {
+                if (!local.status() || local.status()?.status === "completed" || local.status()?.status === "cancelled")
+                    local.start(cutoff);
+                local.step();
+            }
+            else if (!input.state.worker) {
+                input.state.worker = new AsyncTelemetryMaintenance(input.dataStore.path);
+                await input.state.worker.command("start", cutoff);
+            }
+            const status = local?.status() ?? await input.state.worker.command("status");
+            if (input.state.disposed)
+                return;
+            if (status?.status === "completed") {
+                input.onPruned?.(now.toISOString());
+                input.state.running = false;
+                await input.state.worker?.close();
+                input.state.worker = undefined;
+                return;
+            }
+            if (status?.status === "cancelled" || status?.status === "paused") {
+                input.state.running = false;
+                await input.state.worker?.close();
+                input.state.worker = undefined;
+                return;
+            }
+        }
+        catch {
+            failed = true;
+            input.state.failures = (input.state.failures ?? 0) + 1;
+            await input.state.worker?.close();
+            input.state.worker = undefined;
+        }
+        if (input.state.disposed)
+            return;
+        if (!failed) {
+            consecutiveFailures = 0;
+            input.state.timer = setTimeout(() => { input.state.timer = undefined; void run(); }, local ? 25 : 250);
+            input.state.timer.unref?.();
+            return;
         }
-        finally {
+        // A persistent failure must not respawn a worker thread every 250 ms forever. Back off, then stop
+        // with the failure count visible so a later due check retries instead of burning one worker per attempt.
+        consecutiveFailures++;
+        if (consecutiveFailures >= TELEMETRY_RETENTION_MAINTENANCE_FAILURE_LIMIT) {
             input.state.running = false;
+            input.state.timer = undefined;
+            return;
         }
-    }, 0).unref?.();
+        const backoffMs = Math.min(TELEMETRY_RETENTION_MAINTENANCE_MAX_RETRY_MS, 250 * 2 ** (consecutiveFailures - 1));
+        input.state.timer = setTimeout(() => { input.state.timer = undefined; void run(); }, backoffMs);
+        input.state.timer.unref?.();
+    };
+    input.state.timer = setTimeout(() => { input.state.timer = undefined; void run(); }, 0);
+    input.state.timer.unref?.();
 }
 export function isPersistentRetentionDue(lastPrunedAt, now, intervalMs) {
     if (!lastPrunedAt)
@@ -67,3 +141,34 @@ export function hasActiveRuntimeWork(context) {
         ?? [];
     return statuses.some((status) => Boolean(status?.processing || status?.streaming || (status?.queuedMessages ?? 0) > 0));
 }
+/** Explicit HTTP maintenance keeps SQL off the gateway and yields between every bounded batch. */
+export async function pruneTelemetryOlderThanAsync(input) {
+    if (input.dataStore.path === ":memory:")
+        return pruneTelemetryOlderThan(input);
+    const cutoff = telemetryRetentionCutoff(input.days), worker = new AsyncTelemetryMaintenance(input.dataStore.path);
+    const abort = () => { void worker.close(); };
+    input.signal?.addEventListener("abort", abort, { once: true });
+    try {
+        if (input.signal?.aborted)
+            throw Error("Maintenance request cancelled");
+        if (!input.apply) {
+            const results = await worker.preview(cutoff);
+            return { cutoff, days: input.days, applied: false, results, rowsDeleted: 0, bytesMatched: results.reduce((n, r) => n + r.bytesMatched, 0), completed: true };
+        }
+        let status = await worker.command("start", cutoff);
+        if (status?.status === "paused")
+            status = await worker.command("resume");
+        const until = Date.now() + 30000;
+        while (status?.status === "running" && Date.now() < until) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+            status = await worker.command("status");
+        }
+        if (status?.status === "running")
+            status = await worker.command("pause");
+        return { cutoff: status?.cutoff ?? cutoff, days: input.days, applied: true, results: [], rowsDeleted: status?.deleted ?? 0, bytesMatched: 0, completed: status?.status === "completed" };
+    }
+    finally {
+        input.signal?.removeEventListener("abort", abort);
+        await worker.close();
+    }
+}

package/dist/apps/chat/trace-response-cache.js

@@ -0,0 +1,46 @@
+/** Exact encoded responses; bounded independently from reconstructed trace caches. */
+export class TraceResponseCache {
+    maximumBytes;
+    maximumEntries;
+    entries = new Map();
+    bytes = 0;
+    constructor(maximumBytes = 8 * 1024 * 1024, maximumEntries = 32) {
+        this.maximumBytes = maximumBytes;
+        this.maximumEntries = maximumEntries;
+    }
+    get(key, request) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return;
+        this.entries.delete(key);
+        this.entries.set(key, entry);
+        const headers = new Headers(entry.headers);
+        headers.set("server-timing", 'trace_cache;desc="watermark-hit"');
+        const etag = headers.get("etag");
+        const requested = request.headers.get("if-none-match");
+        if (etag && requested?.split(',').some(v => v.trim() === '*' || v.trim() === etag || v.trim() === 'W/' + etag))
+            return new Response(null, { status: 304, headers });
+        return new Response(entry.body.slice(), { status: entry.status, headers });
+    }
+    async set(key, response) {
+        if (response.status !== 200 || !response.headers.get("content-type")?.includes("json"))
+            return;
+        const body = new Uint8Array(await response.clone().arrayBuffer());
+        const bytes = body.byteLength + Buffer.byteLength(key);
+        if (bytes > Math.min(this.maximumBytes, 1024 * 1024))
+            return;
+        const previous = this.entries.get(key);
+        if (previous)
+            this.bytes -= previous.bytes;
+        this.entries.delete(key);
+        this.entries.set(key, { body, headers: [...response.headers.entries()], status: response.status, bytes });
+        this.bytes += bytes;
+        while (this.bytes > this.maximumBytes || this.entries.size > this.maximumEntries) {
+            const oldest = this.entries.keys().next().value;
+            this.bytes -= this.entries.get(oldest).bytes;
+            this.entries.delete(oldest);
+        }
+    }
+    clear() { this.entries.clear(); this.bytes = 0; }
+    status() { return { entries: this.entries.size, bytes: this.bytes, maximumBytes: this.maximumBytes, maximumEntries: this.maximumEntries }; }
+}

package/dist/apps/chat/trace-v2.js

@@ -148,17 +148,21 @@ export function looksLikeImagePayloadPreview(value) {
     return /"type"\s*:\s*"(?:image|input_image|output_image|image_url)"/i.test(value)
         || /"mime(?:Type|_type)"\s*:\s*"image\//i.test(value);
 }
-export function readTracePayloadChunk(input) {
+export async function readTracePayloadChunk(input) {
     const parsed = parseTracePayloadRef(input.ref);
     if (!parsed)
         return undefined;
     const payload = input.payloadStore.getPayload(parsed.payloadId);
     if (!payload)
         return undefined;
-    const bytes = Buffer.from(input.payloadStore.readPayloadBytes(parsed.payloadId));
-    const offset = Math.max(0, Math.min(input.offset, bytes.byteLength));
+    const offset = Math.max(0, Math.min(input.offset, payload.byteSize));
     const limit = Math.max(1, Math.min(input.limit, TRACE_V2_PAYLOAD_MAX_LIMIT_BYTES));
-    const chunk = bytes.subarray(offset, Math.min(bytes.byteLength, offset + limit));
+    const bytes = await input.payloadStore.readPayloadRange(parsed.payloadId, offset, limit + 3);
+    let length = Math.min(limit, bytes.length);
+    // Include a complete UTF-8 code point at the boundary; cursors remain byte offsets.
+    while (length < bytes.length && (bytes[length] & 0xc0) === 0x80)
+        length++;
+    const chunk = bytes.subarray(0, length);
     const preview = payload.previewText ?? "";
     const traceRef = {
         ref: input.ref,
@@ -168,7 +172,7 @@ export function readTracePayloadChunk(input) {
         truncatedPreview: Buffer.byteLength(preview, "utf8") < payload.byteSize,
         hash: payload.sha256,
     };
-    const nextOffset = offset + chunk.byteLength < bytes.byteLength ? offset + chunk.byteLength : undefined;
+    const nextOffset = offset + chunk.byteLength < payload.byteSize ? offset + chunk.byteLength : undefined;
     return {
         ref: traceRef,
         offset,
@@ -248,6 +252,8 @@ function compactTraceNode(node, payloadStore, piboSessionId, depth) {
         completedAt: node.completedAt,
         durationMs: node.durationMs,
         toolMetrics: node.toolMetrics,
+        modelInferences: node.modelInferences,
+        compactionStats: node.compactionStats,
         orderKey: node.orderKey,
         depth,
         hasChildren: node.children.length > 0,
@@ -268,7 +274,7 @@ function compactTraceNode(node, payloadStore, piboSessionId, depth) {
     });
 }
 function inlinePayloadForNodeValue(node, kind, value) {
-    return inlinePayloadForValue(value, inlinePayloadByteLimit(node, kind));
+    return node.payloadRefs?.[kind] ? undefined : inlinePayloadForValue(value, inlinePayloadByteLimit(node, kind));
 }
 function inlinePayloadByteLimit(node, kind) {
     if ((node.type === "user.message" || node.type === "assistant.message" || node.type === "model.reasoning") && kind !== "error") {

package/dist/apps/chat/trace.js

@@ -5,7 +5,7 @@ import { isBuiltInHistoryReconciliationProof } from "../../agent-runtimes/histor
 import { buildTraceViewFromEvents, traceNodesFromHistoryEntries } from "../../shared/trace-engine.js";
 import { chatWebSessionSidebarOrder, isChatWebSessionArchived, isChatWebSessionPinned } from "./session-metadata.js";
 import { workflowSessionKindFromMetadata } from "../../sessions/workflow-session-kind.js";
-export const TRACE_PROJECTION_VERSION = "runtime-history-v2-incomplete-status";
+export const TRACE_PROJECTION_VERSION = "runtime-history-v2-debug-metrics";
 export { compareTraceNodes, sortTraceNodes, nestTraceNodes, flattenTraceNodes, mapTraceNodesById, buildTraceViewFromEvents, traceNodesFromHistoryEntries, } from "../../shared/trace-engine.js";
 export const TRACE_TRANSCRIPT_TAIL_MAX_BYTES = PI_HISTORY_TAIL_MAX_BYTES;
 export const TRACE_TRANSCRIPT_HISTORY_PAGE_MAX_BYTES = PI_HISTORY_PAGE_MAX_BYTES;