@pasko70/pibo 3.4.3 → 3.5.0

package/dist/apps/chat/data/event-command-service.js

@@ -1,6 +1,9 @@
 import { randomUUID } from "node:crypto";
 import { isLiveOnlyOutputEvent } from "../output-event-policy.js";
 import { compactObject, nextSessionSequence, previewForPayload, storedChatEventFromV2Row } from "./chat-data-mappers.js";
+export function chatClientTransactionKey(roomId, actorId, clientTxnId) {
+    return `chat:user.accepted:${roomId ?? ""}:${actorId ?? ""}:${clientTxnId}`;
+}
 export class ChatEventCommandService {
     store;
     constructor(store) {
@@ -9,10 +12,7 @@ export class ChatEventCommandService {
     appendEvent(input) {
         const createdAt = input.createdAt ?? new Date().toISOString();
         const eventId = input.eventId ?? `ce_${randomUUID()}`;
-        const idempotencyKey = input.clientTxnId ? `chat:user.accepted:${input.roomId ?? ""}:${input.actorId ?? ""}:${input.clientTxnId}` : `chat:event:${eventId}`;
-        const existing = input.clientTxnId ? this.findByClientTxn(input.roomId, input.actorId, input.clientTxnId) : undefined;
-        if (existing)
-            return existing;
+        const idempotencyKey = input.clientTxnId ? chatClientTransactionKey(input.roomId, input.actorId, input.clientTxnId) : `chat:event:${eventId}`;
         const stored = this.store.eventLog.appendEvent({
             sessionId: input.piboSessionId,
             sessionSequence: input.piboSessionId ? nextSessionSequence(this.store, input.piboSessionId) : undefined,
@@ -30,21 +30,7 @@ export class ChatEventCommandService {
             createdAt,
             indexedAt: createdAt,
         });
-        return storedChatEventFromV2Row({
-            stream_id: stored.streamId,
-            session_id: stored.sessionId ?? null,
-            session_sequence: stored.sessionSequence ?? null,
-            room_id: stored.roomId ?? null,
-            type: stored.type,
-            actor_type: stored.actorType ?? null,
-            actor_id: stored.actorId ?? null,
-            event_id: stored.eventId ?? null,
-            idempotency_key: stored.idempotencyKey ?? null,
-            retention_class: stored.retentionClass,
-            preview_text: stored.previewText ?? null,
-            attributes_json: JSON.stringify(stored.attributes),
-            created_at: stored.createdAt,
-        });
+        return chatEventFromStoredRow(stored);
     }
     appendOutputEvent(event, _input = {}) {
         // Runtime output ingestion is owned by ChatDataIngestService. Avoid a second event_log insert here.
@@ -55,8 +41,14 @@ export class ChatEventCommandService {
     findByClientTxn(roomId, actorId, clientTxnId) {
         if (!roomId || !actorId)
             return undefined;
-        const row = this.store.db.prepare("SELECT * FROM event_log WHERE room_id = ? AND actor_id = ? AND json_extract(attributes_json, '$.clientTxnId') = ? ORDER BY stream_id ASC LIMIT 1").get(roomId, actorId, clientTxnId);
-        return row ? storedChatEventFromV2Row(row) : undefined;
+        // Empty IDs are not valid HTTP transaction keys. Retain the legacy direct-call
+        // lookup contract without adding a scan fallback to ordinary indexed misses.
+        if (clientTxnId === "") {
+            const row = this.store.db.prepare("SELECT * FROM event_log WHERE room_id = ? AND actor_id = ? AND json_extract(attributes_json, '$.clientTxnId') = ? ORDER BY stream_id ASC LIMIT 1").get(roomId, actorId, clientTxnId);
+            return row ? storedChatEventFromV2Row(row) : undefined;
+        }
+        const row = this.store.eventLog.findByIdempotencyKey(chatClientTransactionKey(roomId, actorId, clientTxnId));
+        return row ? chatEventFromStoredRow(row) : undefined;
     }
     deleteSessions(piboSessionIds) {
         if (!piboSessionIds.length)
@@ -73,3 +65,20 @@ export class ChatEventCommandService {
         return Number(result.changes ?? 0);
     }
 }
+function chatEventFromStoredRow(stored) {
+    return storedChatEventFromV2Row({
+        stream_id: stored.streamId,
+        session_id: stored.sessionId ?? null,
+        session_sequence: stored.sessionSequence ?? null,
+        room_id: stored.roomId ?? null,
+        type: stored.type,
+        actor_type: stored.actorType ?? null,
+        actor_id: stored.actorId ?? null,
+        event_id: stored.eventId ?? null,
+        idempotency_key: stored.idempotencyKey ?? null,
+        retention_class: stored.retentionClass,
+        preview_text: stored.previewText ?? null,
+        attributes_json: JSON.stringify(stored.attributes),
+        created_at: stored.createdAt,
+    });
+}

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

@@ -1,7 +1,11 @@
+import { tracePayloadRefForStoredPayload } from "../trace-v2.js";
+import { ChatReadProjectionStore } from "../../../data/chat-read-projections.js";
 export class ChatHistoryQueryService {
     store;
-    constructor(store) {
+    pageByteBudget;
+    constructor(store, pageByteBudget = Number.POSITIVE_INFINITY) {
         this.store = store;
+        this.pageByteBudget = pageByteBudget;
     }
     listProductHistoryEntries(input) {
         const limit = Math.max(1, Math.min(input.limit ?? 200, 1000));
@@ -11,7 +15,12 @@ export class ChatHistoryQueryService {
             clauses.push("COALESCE(e.session_sequence, m.sequence) < ?");
             values.push(input.beforeSequence);
         }
-        const rows = this.store.db.prepare(`
+        const complete = new ChatReadProjectionStore(this.store.db).status().historyComplete;
+        const rows = complete ? this.store.db.prepare(`
+          SELECT m.*,h.event_sequence FROM chat_history_index h JOIN chat_messages m ON m.id=h.message_id
+          WHERE h.session_id=? AND h.role IN ('user','assistant','system') ${input.beforeSequence !== undefined ? "AND h.event_sequence < ?" : ""}
+          ORDER BY h.event_sequence DESC,h.message_id DESC LIMIT ?
+        `).all(input.piboSessionId, ...(input.beforeSequence !== undefined ? [input.beforeSequence] : []), limit) : this.store.db.prepare(`
 			SELECT m.*, e.session_sequence AS event_sequence
 			FROM chat_messages m
 			LEFT JOIN event_log e ON e.stream_id = m.source_stream_id
@@ -24,7 +33,9 @@ export class ChatHistoryQueryService {
             if (!role)
                 return [];
             const attributes = parseObject(row.attributes_json);
-            const text = this.readMessageText(row, attributes);
+            const text = this.readMessageText(row, attributes, Math.min(64 * 1024, Math.floor(this.pageByteBudget / limit)));
+            const contentBytes = row.content_payload_ref ? this.store.payloads.getPayload(row.content_payload_ref)?.byteSize : typeof attributes.inlineText === "string" ? Buffer.byteLength(attributes.inlineText) : Buffer.byteLength(row.content_preview ?? "");
+            const contentTruncated = contentBytes !== undefined && Buffer.byteLength(text) < contentBytes;
             return [{
                     id: `product:${row.id}`,
                     type: "message",
@@ -42,42 +53,40 @@ export class ChatHistoryQueryService {
                         sourceStreamId: row.source_stream_id ?? undefined,
                         completedAt: row.completed_at ?? undefined,
                         payloadRef: row.content_payload_ref ?? undefined,
+                        tracePayloadRef: contentTruncated && row.content_payload_ref ? tracePayloadRefForStoredPayload({ payloadStore: this.store.payloads, piboSessionId: row.session_id, payloadId: row.content_payload_ref, nodeId: `product:${row.id}`, payloadKind: "output" }) : undefined,
+                        contentTruncated: contentTruncated || undefined,
+                        contentBytes: contentTruncated ? contentBytes : undefined,
                     }),
                 }];
         });
     }
     getProductHistoryCoverage(piboSessionId) {
-        const row = this.store.db.prepare(`
-			SELECT
-				COUNT(*) AS message_count,
-				MIN(e.session_sequence) AS first_event_sequence,
-				MAX(e.session_sequence) AS last_event_sequence,
-				MIN(m.created_at) AS first_created_at,
-				MAX(m.created_at) AS last_created_at
-			FROM chat_messages m
-			LEFT JOIN event_log e ON e.stream_id = m.source_stream_id
-			WHERE m.session_id = ?
-		`).get(piboSessionId);
-        return {
-            messageCount: Number(row.message_count ?? 0),
-            firstEventSequence: row.first_event_sequence ?? undefined,
-            lastEventSequence: row.last_event_sequence ?? undefined,
-            firstCreatedAt: row.first_created_at ?? undefined,
-            lastCreatedAt: row.last_created_at ?? undefined,
-        };
+        const complete = new ChatReadProjectionStore(this.store.db).status().historyComplete;
+        const count = this.store.db.prepare("SELECT message_count,revision FROM chat_history_counts WHERE session_id=?").get(piboSessionId);
+        const edge = (column, order) => this.store.db.prepare(`SELECT ${column} AS value FROM chat_history_index WHERE session_id=? ORDER BY ${column} ${order},message_id ${order} LIMIT 1`).get(piboSessionId);
+        return { messageCount: count?.message_count ?? 0, revision: count?.revision ?? 0, complete,
+            firstEventSequence: edge("event_sequence", "ASC")?.value,
+            lastEventSequence: edge("event_sequence", "DESC")?.value,
+            firstCreatedAt: edge("created_at", "ASC")?.value,
+            lastCreatedAt: edge("created_at", "DESC")?.value };
     }
-    readMessageText(row, attributes) {
+    readMessageText(row, attributes, maximum) {
         if (row.content_payload_ref) {
             try {
-                return this.store.payloads.readPayloadText(row.content_payload_ref);
+                if (!Number.isFinite(this.pageByteBudget))
+                    return this.store.payloads.readPayloadText(row.content_payload_ref);
+                const payload = this.store.payloads.getPayload(row.content_payload_ref);
+                if (!payload || payload.byteSize > maximum)
+                    return (row.content_preview ?? "").slice(0, Math.min(2048, maximum / 4));
+                return Buffer.from(this.store.payloads.readPayloadBytesBounded(row.content_payload_ref, maximum)).toString("utf8");
             }
             catch {
                 // Retain the durable preview if the external payload was removed or corrupted.
             }
         }
         if (typeof attributes.inlineText === "string")
-            return attributes.inlineText;
-        return row.content_preview ?? "";
+            return Number.isFinite(this.pageByteBudget) ? attributes.inlineText.slice(0, Math.floor(maximum / 4)) : attributes.inlineText;
+        return Number.isFinite(this.pageByteBudget) ? (row.content_preview ?? "").slice(0, Math.floor(maximum / 4)) : (row.content_preview ?? "");
     }
 }
 function historyRole(role) {

package/dist/apps/chat/data/read-state-service.js

@@ -1,3 +1,5 @@
+import { ChatSessionQueryService } from "./session-query-service.js";
+import { ChatReadProjectionStore } from "../../../data/chat-read-projections.js";
 export class ChatReadStateService {
     store;
     constructor(store) {
@@ -14,11 +16,22 @@ export class ChatReadStateService {
 				updated_at = excluded.updated_at
 		`).run(piboSessionId, lastReadStreamId, now, now);
     }
+    sessionIndexPage(input) { return new ChatSessionQueryService(this.store).listSessionIndexPage(input); }
+    unreadCountsPage(input) { return [...this.countUnreadMessagesBySession(input)]; }
     countUnreadMessagesBySession(input) {
         const counts = new Map();
         const uniqueIds = [...new Set(input.piboSessionIds)];
         if (!uniqueIds.length)
             return counts;
+        if (new ChatReadProjectionStore(this.store.db).status().unreadComplete) {
+            for (let offset = 0; offset < uniqueIds.length; offset += 400) {
+                const ids = uniqueIds.slice(offset, offset + 400);
+                const rows = this.store.db.prepare(`SELECT session_id,unread_count FROM chat_unread_counts WHERE session_id IN (${ids.map(() => "?").join(",")}) AND unread_count>0`).all(...ids);
+                for (const row of rows)
+                    counts.set(row.session_id, row.unread_count);
+            }
+            return counts;
+        }
         for (let offset = 0; offset < uniqueIds.length; offset += 400) {
             const ids = uniqueIds.slice(offset, offset + 400);
             const requested = ids.map(() => "(?)").join(", ");

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

@@ -6,20 +6,21 @@ export class ChatSessionQueryService {
     constructor(store) {
         this.store = store;
     }
-    upsertSession(session, status = "idle", lastActivityAt = session.updatedAt) {
+    upsertSession(session, status = "idle", lastActivityAt = session.updatedAt, options = {}) {
         const roomId = chatRoomIdFromMetadata(session.metadata) ?? "room_default";
-        this.store.sessions.upsertSession({ session, roomId, status, lastActivityAt });
+        this.store.sessions.upsertSession({ session, roomId, status, lastActivityAt, preserveRuntimeBinding: options.preserveRuntimeBinding });
         this.upsertNavigation(session, roomId, status, lastActivityAt);
     }
     upsertSessionsIfChanged(sessions) {
         let written = 0;
         let skipped = 0;
         for (const session of sessions) {
-            if (this.sessionIndexMatches(session)) {
+            const status = this.getSession(session.id)?.status ?? "idle";
+            if (this.sessionIndexMatches(session, status)) {
                 skipped++;
                 continue;
             }
-            this.upsertSession(session);
+            this.upsertSession(session, status);
             written++;
         }
         return { checked: sessions.length, written, skipped };
@@ -28,7 +29,7 @@ export class ChatSessionQueryService {
         if (session) {
             const status = statusFromOutputEvent(event);
             if (status)
-                this.upsertSession(session, status, createdAt);
+                this.upsertSession(session, status, createdAt, { preserveRuntimeBinding: true });
             else
                 this.touchSession(session, createdAt);
         }
@@ -36,7 +37,7 @@ export class ChatSessionQueryService {
     }
     touchSession(session, lastActivityAt) {
         const roomId = chatRoomIdFromMetadata(session.metadata) ?? "room_default";
-        this.store.sessions.upsertSession({ session, roomId, lastActivityAt });
+        this.store.sessions.upsertSession({ session, roomId, lastActivityAt, preserveRuntimeBinding: true });
         this.store.navigation.upsertSession({
             roomId,
             sessionId: session.id,
@@ -50,19 +51,26 @@ export class ChatSessionQueryService {
             updatedAt: lastActivityAt,
         });
     }
-    listSessions() {
+    listSessions(roomId) {
         const rows = this.store.db.prepare(`
-			SELECT s.*, b.runtime_instance_id, b.runtime_adapter_id, b.native_session_id, b.binding_state
+			SELECT s.id,s.pi_session_id,s.parent_id,s.channel,s.kind,s.profile,s.created_at,s.updated_at,s.last_activity_at,s.status,b.runtime_instance_id,b.runtime_adapter_id,b.native_session_id,b.binding_state
 			FROM sessions s
 			LEFT JOIN session_runtime_bindings b ON b.pibo_session_id = s.id
-			WHERE s.deleted_at IS NULL
+			WHERE s.deleted_at IS NULL ${roomId ? "AND s.room_id=?" : ""}
 			ORDER BY s.last_activity_at DESC, s.created_at DESC
-		`).all();
+		`).all(...(roomId ? [roomId] : []));
+        return rows.map(sessionFromRow);
+    }
+    listSessionIndexPage(input) {
+        const limit = Math.max(1, Math.min(input.limit ?? 500, 500));
+        const rows = this.store.db.prepare(`SELECT s.id,s.pi_session_id,s.parent_id,s.channel,s.kind,s.profile,s.created_at,s.updated_at,s.last_activity_at,s.status,b.runtime_instance_id,b.runtime_adapter_id,b.native_session_id,b.binding_state
+		FROM sessions s LEFT JOIN session_runtime_bindings b ON b.pibo_session_id=s.id
+		WHERE s.deleted_at IS NULL AND s.room_id=? AND s.id>? ORDER BY s.id LIMIT ?`).all(input.roomId, input.afterId ?? "", limit);
         return rows.map(sessionFromRow);
     }
     getSession(piboSessionId) {
         const row = this.store.db.prepare(`
-			SELECT s.*, b.runtime_instance_id, b.runtime_adapter_id, b.native_session_id, b.binding_state
+			SELECT s.id,s.pi_session_id,s.parent_id,s.channel,s.kind,s.profile,s.created_at,s.updated_at,s.last_activity_at,s.status,b.runtime_instance_id,b.runtime_adapter_id,b.native_session_id,b.binding_state
 			FROM sessions s
 			LEFT JOIN session_runtime_bindings b ON b.pibo_session_id = s.id
 			WHERE s.id = ? AND s.deleted_at IS NULL

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,
     };
 }