@pasko70/pibo 3.5.0 → 3.5.1

package/dist/data/message-command-store.js

@@ -15,10 +15,32 @@ CREATE INDEX IF NOT EXISTS message_commands_recent ON message_commands(session_i
 CREATE INDEX IF NOT EXISTS message_commands_pending ON message_commands(state,created_at,id);
 CREATE INDEX IF NOT EXISTS message_commands_session ON message_commands(session_id,state,created_at,id);
 CREATE INDEX IF NOT EXISTS message_commands_lease ON message_commands(lease_until) WHERE owner IS NOT NULL;
+CREATE INDEX IF NOT EXISTS message_commands_health_scope ON message_commands(state,delivery,room_id,session_id,stream_id,created_at);
+CREATE INDEX IF NOT EXISTS event_log_message_command_terminal ON event_log(session_id,event_id,type,stream_id)
+ WHERE event_id IS NOT NULL AND type IN ('message_finished','session_error','message_steered');
+CREATE TABLE IF NOT EXISTS message_command_stats (
+ state TEXT NOT NULL, delivery TEXT NOT NULL, command_count INTEGER NOT NULL, payload_bytes INTEGER NOT NULL,
+ PRIMARY KEY(state,delivery)
+);
+CREATE TRIGGER IF NOT EXISTS message_command_stats_insert AFTER INSERT ON message_commands BEGIN
+ INSERT INTO message_command_stats(state,delivery,command_count,payload_bytes) VALUES(NEW.state,NEW.delivery,1,NEW.payload_bytes)
+ ON CONFLICT(state,delivery) DO UPDATE SET command_count=command_count+1,payload_bytes=payload_bytes+NEW.payload_bytes;
+END;
+CREATE TRIGGER IF NOT EXISTS message_command_stats_delete AFTER DELETE ON message_commands BEGIN
+ UPDATE message_command_stats SET command_count=command_count-1,payload_bytes=payload_bytes-OLD.payload_bytes WHERE state=OLD.state AND delivery=OLD.delivery;
+END;
+CREATE TRIGGER IF NOT EXISTS message_command_stats_update AFTER UPDATE OF state,delivery,payload_bytes ON message_commands
+ WHEN OLD.state<>NEW.state OR OLD.delivery<>NEW.delivery OR OLD.payload_bytes<>NEW.payload_bytes BEGIN
+ UPDATE message_command_stats SET command_count=command_count-1,payload_bytes=payload_bytes-OLD.payload_bytes WHERE state=OLD.state AND delivery=OLD.delivery;
+ INSERT INTO message_command_stats(state,delivery,command_count,payload_bytes) VALUES(NEW.state,NEW.delivery,1,NEW.payload_bytes)
+ ON CONFLICT(state,delivery) DO UPDATE SET command_count=command_count+1,payload_bytes=payload_bytes+NEW.payload_bytes;
+END;
 CREATE TABLE IF NOT EXISTS message_dispatch_clock (id INTEGER PRIMARY KEY CHECK(id=1), sequence INTEGER NOT NULL);
 INSERT OR IGNORE INTO message_dispatch_clock VALUES (1,0);
 CREATE TABLE IF NOT EXISTS message_dispatch_rooms (room_id TEXT PRIMARY KEY, sequence INTEGER NOT NULL);
-
+INSERT INTO message_command_stats(state,delivery,command_count,payload_bytes)
+ SELECT state,delivery,count(*),COALESCE(sum(payload_bytes),0) FROM message_commands
+ WHERE NOT EXISTS (SELECT 1 FROM message_command_stats) GROUP BY state,delivery;
 `;
 export const MESSAGE_COMMAND_LIMITS = Object.freeze({
     queue: { count: 1000, roomCount: 256, sessionCount: 64, bytes: 64 * 1024 * 1024, roomBytes: 16 * 1024 * 1024, sessionBytes: 4 * 1024 * 1024, ageMs: 60 * 60 * 1000, roomAgeMs: 15 * 60 * 1000, sessionAgeMs: 10 * 60 * 1000 },
@@ -26,6 +48,12 @@ export const MESSAGE_COMMAND_LIMITS = Object.freeze({
     dispatch: { queue: 10, roomQueue: 5, steer: 2, roomSteer: 1 },
 });
 const active = "'accepted','waiting_slot','initializing','session_queue','running'";
+const unstarted = "'accepted','waiting_slot'";
+const terminalEvidenceSql = `(SELECT CASE
+	WHEN count(DISTINCT CASE WHEN e.type='session_error' THEN 'failed' ELSE 'completed' END)=1
+	THEN max(CASE WHEN e.type='session_error' THEN 'failed' ELSE 'completed' END) END
+ FROM event_log e WHERE e.session_id=message_commands.session_id AND e.event_id=message_commands.event_id
+ AND e.type IN ('message_finished','session_error','message_steered'))`;
 /** Durable receipts are independent of optional trace/telemetry retention. Only the storage worker owns this store. */
 export class MessageCommandStore {
     store;
@@ -56,36 +84,109 @@ export class MessageCommandStore {
     }
     queueStatus(sessionId) {
         const rows = this.store.db.prepare(`SELECT state,delivery,payload_bytes,created_at FROM message_commands WHERE session_id=? AND state IN (${active}) LIMIT 69`).all(sessionId);
+        const blocker = this.store.db.prepare("SELECT id,created_at FROM message_commands WHERE session_id=? AND state='interrupted' ORDER BY stream_id LIMIT 1").get(sessionId);
         const summarize = (delivery) => {
             const scoped = rows.filter(row => row.delivery === delivery), limits = MESSAGE_COMMAND_LIMITS[delivery];
             return { count: scoped.length, bytes: scoped.reduce((sum, row) => sum + row.payload_bytes, 0), oldestWaitMs: Math.max(0, ...scoped.filter(row => row.state === "accepted" || row.state === "waiting_slot").map(row => Date.now() - row.created_at)), limits: { count: limits.sessionCount, bytes: limits.sessionBytes, waitMs: limits.sessionAgeMs } };
         };
-        return { queue: summarize("queue"), steer: summarize("steer") };
+        return { queue: summarize("queue"), steer: summarize("steer"), ...(blocker ? { reconciliation: { required: true, retryable: false, scope: "session", blockingCommandId: blocker.id, blockedSince: blocker.created_at, nextAction: `pibo debug message-queue inspect --session ${sessionId}` } } : {}) };
     }
     get(id) {
         const row = this.store.db.prepare("SELECT * FROM message_commands WHERE id = ?").get(id);
         return row && receipt(row);
     }
+    terminalOutcome(sessionId, eventId) {
+        const row = this.store.db.prepare(`SELECT CASE WHEN count(DISTINCT CASE WHEN type='session_error' THEN 'failed' ELSE 'completed' END)=1 THEN max(CASE WHEN type='session_error' THEN 'failed' ELSE 'completed' END) END state FROM event_log WHERE session_id=? AND event_id=? AND type IN ('message_finished','session_error','message_steered')`).get(sessionId, eventId);
+        return row?.state;
+    }
+    terminalEvidence(sessionId, eventId) {
+        return this.store.db.prepare(`SELECT stream_id,type,CASE WHEN type='session_error' THEN 'failed' ELSE 'completed' END state FROM event_log
+		 WHERE session_id=? AND event_id=? AND type IN ('message_finished','session_error','message_steered') ORDER BY stream_id LIMIT 8`).all(sessionId, eventId)
+            .map(row => ({ streamId: row.stream_id, type: row.type, state: row.state }));
+    }
+    assertAdmissionUnblocked(sessionId, delivery, beforeStreamId = Number.MAX_SAFE_INTEGER) {
+        if (delivery !== "queue")
+            return;
+        const blocker = this.store.db.prepare("SELECT id,created_at FROM message_commands WHERE session_id=? AND state='interrupted' AND stream_id<? ORDER BY stream_id LIMIT 1").get(sessionId, beforeStreamId);
+        if (blocker)
+            throw domainError("command_reconciliation_required", "A previous interrupted message requires operator review before this session can accept more messages.", { retryable: false, scope: "session", blockingCommandId: blocker.id, blockedSince: blocker.created_at, oldestWaitAgeMs: Math.max(0, Date.now() - blocker.created_at), nextAction: `pibo debug message-queue inspect --session ${sessionId}` });
+    }
     insert(input) {
         const prior = this.find(input.key, input.fingerprint);
         if (prior)
             return prior;
+        this.assertAdmissionUnblocked(input.sessionId, input.delivery, input.streamId);
         const limit = MESSAGE_COMMAND_LIMITS[input.delivery];
-        const rows = this.store.db.prepare(`SELECT session_id, room_id, payload_bytes, created_at, state FROM message_commands WHERE state IN (${active}) AND delivery=? LIMIT ?`).all(input.delivery, limit.count + 1);
+        const rows = this.store.db.prepare(`SELECT c.session_id,c.room_id,c.payload_bytes,c.created_at,c.state,
+		 NOT EXISTS(SELECT 1 FROM message_commands p WHERE p.session_id=c.session_id AND p.state='interrupted' AND p.stream_id<c.stream_id) dispatchable
+		 FROM message_commands c WHERE c.state IN (${active}) AND c.delivery=? LIMIT ?`).all(input.delivery, limit.count + 1);
         const now = Date.now();
         const exceeds = (scope, count, bytes, ageMs) => scope.length >= count
             || scope.reduce((n, r) => n + r.payload_bytes, input.payload.byteSize) > bytes
-            || scope.some(r => (r.state === "accepted" || r.state === "waiting_slot") && now - r.created_at >= ageMs);
+            || scope.some(r => r.dispatchable === 1 && (r.state === "accepted" || r.state === "waiting_slot") && now - r.created_at >= ageMs);
         if (exceeds(rows, limit.count, limit.bytes, limit.ageMs)
             || exceeds(rows.filter(r => r.room_id === input.roomId), limit.roomCount, limit.roomBytes, limit.roomAgeMs)
             || exceeds(rows.filter(r => r.session_id === input.sessionId), limit.sessionCount, limit.sessionBytes, limit.sessionAgeMs)) {
-            throw domainError("command_overloaded", "Durable message queue count, byte or wait-age capacity reached; retry the same transaction later.");
+            throw domainError("command_overloaded", "Durable message queue count, byte or dispatchable wait-age capacity reached; retry the same transaction later.", { retryable: true });
         }
         const id = `cmd_${randomUUID()}`;
         const payload = this.store.payloads.commitPreparedPayload(input.payload);
         this.store.db.prepare(`INSERT INTO message_commands (id,request_key,fingerprint,session_id,room_id,event_id,stream_id,payload_ref,payload_bytes,delivery,state,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,'accepted',?,?)`).run(id, input.key, input.fingerprint, input.sessionId, input.roomId, input.eventId, input.streamId, payload.id, payload.byteSize, input.delivery, now, now);
         return this.get(id);
     }
+    terminalizeBlockedSuccessors(now, limit = 100) {
+        const bounded = Math.max(1, Math.min(1000, Math.trunc(limit) || 1));
+        return Number(this.store.db.prepare(`UPDATE message_commands SET state='failed',error='Not dispatched: an earlier interrupted message requires reconciliation.',owner = NULL,lease_until=0,updated_at=?
+		 WHERE id IN (SELECT c.id FROM message_commands c WHERE c.state IN (${unstarted}) AND c.delivery='queue' AND c.owner IS NULL AND EXISTS(
+		 SELECT 1 FROM message_commands p WHERE p.session_id=c.session_id AND p.state='interrupted' AND p.stream_id<c.stream_id
+		 ) ORDER BY c.created_at,c.id LIMIT ?)`).run(now, bounded).changes);
+    }
+    /** Bounded, idempotent startup repair. Ambiguous rows cannot starve later evidence-backed rows. */
+    reconcileInterrupted(limit = 1000) {
+        const bounded = Math.max(1, Math.min(1000, Math.trunc(limit) || 1));
+        let rows = [];
+        try {
+            rows = this.store.db.prepare(`SELECT id FROM message_commands WHERE state='interrupted' AND ${terminalEvidenceSql} IN ('completed','failed') ORDER BY updated_at,id LIMIT ?`).all(bounded);
+        }
+        catch {
+            return { examined: 0, reconciled: 0, blockedSuccessorsFailed: 0, ambiguous: 0, errors: 1 };
+        }
+        let reconciled = 0, errors = 0;
+        for (const row of rows) {
+            try {
+                reconciled += this.store.transaction(() => Number(this.store.db.prepare(`UPDATE message_commands SET state=${terminalEvidenceSql},error=NULL,owner = NULL,lease_until=0,updated_at=? WHERE id=? AND state='interrupted' AND ${terminalEvidenceSql} IN ('completed','failed')`).run(Date.now(), row.id).changes));
+            }
+            catch {
+                errors++;
+            }
+        }
+        let blockedSuccessorsFailed = 0;
+        try {
+            blockedSuccessorsFailed = this.store.transaction(() => this.terminalizeBlockedSuccessors(Date.now(), bounded));
+        }
+        catch {
+            errors++;
+        }
+        const ambiguous = Number(this.store.db.prepare("SELECT count(*) n FROM message_commands WHERE state='interrupted'").get().n);
+        return { examined: rows.length, reconciled, blockedSuccessorsFailed, ambiguous, errors };
+    }
+    recoverExpiredLeasesInTransaction(now, afterSelection) {
+        const rows = this.store.db.prepare("SELECT id FROM message_commands WHERE owner IS NOT NULL AND lease_until<=? ORDER BY lease_until,id LIMIT 100").all(now);
+        afterSelection?.();
+        let changed = 0;
+        for (const row of rows) {
+            changed += Number(this.store.db.prepare(`UPDATE message_commands SET
+			 state=CASE WHEN ${terminalEvidenceSql} IN ('completed','failed') THEN ${terminalEvidenceSql} WHEN state='waiting_slot' THEN 'accepted' ELSE 'interrupted' END,
+			 error=CASE WHEN ${terminalEvidenceSql} IN ('completed','failed') OR state='waiting_slot' THEN NULL ELSE 'Runtime ownership expired; execution requires reconciliation.' END,
+			 owner = NULL,lease_until=0,updated_at=? WHERE id=? AND owner IS NOT NULL AND lease_until<=? AND state IN (${active})`).run(now, row.id, now).changes);
+        }
+        this.terminalizeBlockedSuccessors(now);
+        return changed;
+    }
+    /** Public for deterministic recovery tests; production callers use claim(). */
+    recoverExpiredLeases(now = Date.now(), barrier) {
+        return this.store.transaction(() => this.recoverExpiredLeasesInTransaction(now, barrier));
+    }
     claim(owner, leaseMs) {
         const limits = MESSAGE_COMMAND_LIMITS.dispatch;
         const candidateSql = `WITH occupied AS (
@@ -96,13 +197,11 @@ export class MessageCommandStore {
 		 AND (SELECT count(*) FROM occupied o WHERE o.delivery=c.delivery AND o.room_id=c.room_id) < CASE c.delivery WHEN 'steer' THEN ${limits.roomSteer} ELSE ${limits.roomQueue} END
 		 AND NOT EXISTS (SELECT 1 FROM message_commands p WHERE p.session_id=c.session_id AND p.state IN (${active},'interrupted') AND p.stream_id<c.stream_id AND (c.delivery='queue' OR p.delivery='steer'))
 		 ORDER BY CASE c.delivery WHEN 'steer' THEN 0 ELSE 1 END,COALESCE(r.sequence,0),c.stream_id LIMIT 1`;
-        // Idle polling must not take the SQLite writer lock. The claim transaction rechecks.
         if (!this.store.db.prepare(candidateSql).get() && !this.store.db.prepare("SELECT 1 FROM message_commands WHERE owner IS NOT NULL AND lease_until <= ? LIMIT 1").get(Date.now()))
             return undefined;
         const row = this.store.transaction(() => {
             const now = Date.now();
-            // Never replay an expired command that may already have reached a provider or tool.
-            this.store.db.prepare(`UPDATE message_commands SET state=CASE WHEN state='waiting_slot' THEN 'accepted' ELSE 'interrupted' END, error=CASE WHEN state='waiting_slot' THEN NULL ELSE 'Runtime ownership expired; execution requires reconciliation.' END, owner = NULL,lease_until=0,updated_at=? WHERE id IN (SELECT id FROM message_commands WHERE owner IS NOT NULL AND lease_until <= ? ORDER BY lease_until LIMIT 100)`).run(now, now);
+            this.recoverExpiredLeasesInTransaction(now);
             const candidate = this.store.db.prepare(candidateSql).get();
             if (!candidate)
                 return undefined;
@@ -126,7 +225,7 @@ export class MessageCommandStore {
         return Number(this.store.db.prepare("UPDATE message_commands SET state='failed',error='Cancelled before runtime dispatch.',owner = NULL,lease_until=0,updated_at=? WHERE session_id=? AND state IN ('accepted','waiting_slot')").run(Date.now(), sessionId).changes);
     }
     transition(id, owner, token, state, error) {
-        return Number(this.store.db.prepare(`UPDATE message_commands SET state=?,error=?,updated_at=?,owner = CASE WHEN ? IN ('completed','failed','interrupted') THEN NULL ELSE owner END WHERE id=? AND owner = ? AND token=? AND lease_until>? AND state IN (${active})`).run(state, error?.slice(0, 500) ?? null, Date.now(), state, id, owner, token, Date.now()).changes) === 1;
+        return Number(this.store.db.prepare(`UPDATE message_commands SET state=?,error=?,updated_at=?,owner = CASE WHEN ? IN ('completed','failed','interrupted') THEN NULL ELSE owner END,lease_until=CASE WHEN ? IN ('completed','failed','interrupted') THEN 0 ELSE lease_until END WHERE id=? AND owner = ? AND token=? AND lease_until>? AND state IN (${active})`).run(state, error?.slice(0, 500) ?? null, Date.now(), state, state, id, owner, token, Date.now()).changes) === 1;
     }
     heartbeat(id, owner, token, leaseMs) {
         return Number(this.store.db.prepare(`UPDATE message_commands SET lease_until=? WHERE id=? AND owner = ? AND token=? AND lease_until>? AND state IN (${active})`).run(Date.now() + leaseMs, id, owner, token, Date.now()).changes) === 1;
@@ -139,10 +238,53 @@ export class MessageCommandStore {
         if (!state)
             return;
         const eligible = state === "session_queue" ? "'initializing','waiting_slot'" : state === "running" ? "'initializing','waiting_slot','session_queue'" : `${active},'interrupted'`;
-        this.store.db.prepare(`UPDATE message_commands SET state=?,error=NULL,updated_at=?,owner = CASE WHEN ? IN ('completed','failed') THEN NULL ELSE owner END WHERE session_id=? AND event_id=? AND state IN (${eligible})`).run(state, Date.now(), state, sessionId, eventId);
+        this.store.db.prepare(`UPDATE message_commands SET state=?,error=NULL,updated_at=?,owner = CASE WHEN ? IN ('completed','failed') THEN NULL ELSE owner END,lease_until=CASE WHEN ? IN ('completed','failed') THEN 0 ELSE lease_until END WHERE session_id=? AND event_id=? AND state IN (${eligible})`).run(state, Date.now(), state, state, sessionId, eventId);
+    }
+    health(now = Date.now(), scopeLimit = 20) {
+        const bounded = Math.max(1, Math.min(100, Math.trunc(scopeLimit) || 20));
+        const activeRowsLimit = MESSAGE_COMMAND_LIMITS.queue.count + MESSAGE_COMMAND_LIMITS.steer.count + 1;
+        const counts = this.store.db.prepare("SELECT state,delivery,command_count count,payload_bytes bytes FROM message_command_stats WHERE command_count>0 ORDER BY state,delivery").all();
+        const interrupted = Number(this.store.db.prepare("SELECT count(*) n FROM message_commands WHERE state='interrupted'").get().n);
+        const expired = Number(this.store.db.prepare("SELECT count(*) n FROM message_commands WHERE owner IS NOT NULL AND lease_until<=?").get(now).n);
+        const blockedRows = this.store.db.prepare(`SELECT c.session_id,c.room_id,c.created_at,p.id blocking_id,p.created_at blocked_since
+		 FROM message_commands c JOIN message_commands p ON p.id=(SELECT p2.id FROM message_commands p2 WHERE p2.session_id=c.session_id AND p2.state='interrupted' AND p2.stream_id<c.stream_id ORDER BY p2.stream_id LIMIT 1)
+		 WHERE c.state IN (${unstarted}) AND c.delivery='queue' ORDER BY c.created_at,c.id LIMIT ?`).all(bounded);
+        const blockedCount = Number(this.store.db.prepare(`SELECT count(*) n FROM message_commands c WHERE c.state IN (${unstarted}) AND c.delivery='queue' AND EXISTS(SELECT 1 FROM message_commands p WHERE p.session_id=c.session_id AND p.state='interrupted' AND p.stream_id<c.stream_id)`).get().n);
+        const oldestDispatchable = this.store.db.prepare(`SELECT created_at FROM message_commands c WHERE c.state IN (${unstarted}) AND NOT EXISTS(SELECT 1 FROM message_commands p WHERE p.session_id=c.session_id AND p.state='interrupted' AND p.stream_id<c.stream_id) ORDER BY created_at LIMIT 1`).get();
+        const scopes = new Map();
+        for (const row of blockedRows) {
+            const prior = scopes.get(row.session_id);
+            if (prior)
+                prior.blockedSuccessors++;
+            else
+                scopes.set(row.session_id, { sessionId: row.session_id, roomId: row.room_id, blockingCommandId: row.blocking_id, blockedSince: row.blocked_since, blockedSuccessors: 1 });
+        }
+        if (interrupted > 0) {
+            for (const row of this.store.db.prepare("SELECT session_id,room_id,id,created_at FROM message_commands WHERE state='interrupted' ORDER BY created_at LIMIT ?").all(bounded)) {
+                if (!scopes.has(row.session_id))
+                    scopes.set(row.session_id, { sessionId: row.session_id, roomId: row.room_id, blockingCommandId: row.id, blockedSince: row.created_at, blockedSuccessors: 0 });
+            }
+        }
+        const activeRows = this.store.db.prepare(`SELECT session_id,room_id,delivery,payload_bytes,created_at,state,NOT EXISTS(SELECT 1 FROM message_commands p WHERE p.session_id=c.session_id AND p.state='interrupted' AND p.stream_id<c.stream_id) dispatchable FROM message_commands c WHERE state IN (${active}) ORDER BY created_at,id LIMIT ?`).all(activeRowsLimit);
+        const capacityReasons = [];
+        const activeStates = new Set(["accepted", "waiting_slot", "initializing", "session_queue", "running"]);
+        const globalTotals = (delivery) => counts.filter(row => row.delivery === delivery && activeStates.has(row.state)).reduce((total, row) => ({ count: total.count + row.count, bytes: total.bytes + row.bytes }), { count: 0, bytes: 0 });
+        const summarizeCapacity = (rows, delivery, scope) => { const selected = rows.filter(row => row.delivery === delivery), limits = MESSAGE_COMMAND_LIMITS[delivery], countLimit = scope === "global" ? limits.count : scope === "room" ? limits.roomCount : limits.sessionCount, byteLimit = scope === "global" ? limits.bytes : scope === "room" ? limits.roomBytes : limits.sessionBytes, ageLimit = scope === "global" ? limits.ageMs : scope === "room" ? limits.roomAgeMs : limits.sessionAgeMs, totals = scope === "global" ? globalTotals(delivery) : { count: selected.length, bytes: selected.reduce((sum, row) => sum + row.payload_bytes, 0) }, count = totals.count, bytes = totals.bytes, oldestDispatchableWaitMs = Math.max(0, ...selected.filter(row => row.dispatchable === 1 && (row.state === "accepted" || row.state === "waiting_slot")).map(row => now - row.created_at)), reasons = [...(count >= countLimit ? [`count ${count}/${countLimit}`] : []), ...(bytes >= byteLimit ? [`bytes ${bytes}/${byteLimit}`] : []), ...(oldestDispatchableWaitMs >= ageLimit ? [`dispatchable wait ${oldestDispatchableWaitMs}ms/${ageLimit}ms`] : [])]; return { delivery, count, bytes, oldestDispatchableWaitMs, available: reasons.length === 0, degradedReasons: reasons }; };
+        const globalCapacity = ["queue", "steer"].map(delivery => summarizeCapacity(activeRows, delivery, "global"));
+        const roomKeys = [...new Set(activeRows.map(row => row.room_id))], sessionKeys = [...new Set(activeRows.map(row => row.session_id))];
+        const roomCapacity = roomKeys.flatMap(roomId => ["queue", "steer"].map(delivery => ({ roomId, ...summarizeCapacity(activeRows.filter(row => row.room_id === roomId), delivery, "room") }))).filter(row => !row.available).slice(0, bounded);
+        const sessionCapacity = sessionKeys.flatMap(sessionId => ["queue", "steer"].map(delivery => ({ sessionId, roomId: activeRows.find(row => row.session_id === sessionId)?.room_id ?? "unknown", ...summarizeCapacity(activeRows.filter(row => row.session_id === sessionId), delivery, "session") }))).filter(row => !row.available).slice(0, bounded);
+        for (const row of globalCapacity.filter(row => !row.available))
+            capacityReasons.push(`global ${row.delivery} admission degraded: ${row.degradedReasons.join(", ")}`);
+        for (const row of roomCapacity)
+            capacityReasons.push(`room ${row.roomId} ${row.delivery} admission degraded: ${row.degradedReasons.join(", ")}`);
+        for (const row of sessionCapacity)
+            capacityReasons.push(`session ${row.sessionId} ${row.delivery} admission degraded: ${row.degradedReasons.join(", ")}`);
+        const degradedReasons = [...(interrupted ? [`${interrupted} interrupted predecessor(s) require reconciliation`] : []), ...(blockedCount ? [`${blockedCount} successor(s) are blocked by FIFO`] : []), ...(expired ? [`${expired} owned lease(s) are expired`] : []), ...capacityReasons];
+        return { status: degradedReasons.length ? "degraded" : "healthy", storage: { available: true }, counts, interruptedPredecessors: interrupted, blockedSuccessors: blockedCount, expiredOwnedLeases: expired, oldestDispatchableWaitMs: oldestDispatchable ? Math.max(0, now - oldestDispatchable.created_at) : 0, oldestBlockedWaitMs: blockedRows.length ? Math.max(...blockedRows.map(row => Math.max(0, now - row.created_at))) : 0, affectedScopes: [...scopes.values()].slice(0, bounded), limits: MESSAGE_COMMAND_LIMITS, degradedReasons, admissionCapacity: { global: globalCapacity, rooms: roomCapacity, sessions: sessionCapacity }, bounded: { scopeLimit: bounded, activeRowsLimit, activeRowsTruncated: activeRows.length === activeRowsLimit, affectedScopesTruncated: interrupted > bounded || scopes.size > bounded || blockedCount > blockedRows.length } };
     }
 }
 function receipt(row) {
     return { id: row.id, sessionId: row.session_id, roomId: row.room_id, eventId: row.event_id, streamId: row.stream_id, state: row.state, createdAt: row.created_at, updatedAt: row.updated_at, ...(row.error ? { error: row.error } : {}) };
 }
-function domainError(code, message) { return Object.assign(new Error(message), { code }); }
+function domainError(code, message, details = {}) { return Object.assign(new Error(message), { code, ...details }); }

package/dist/data/schema.js

@@ -1,8 +1,9 @@
 import { CHAT_READ_PROJECTION_SCHEMA, CHAT_NAVIGATION_REVISION_SCHEMA } from "./chat-read-projections.js";
 import { TELEMETRY_MAINTENANCE_SCHEMA } from "./telemetry-maintenance.js";
 import { MESSAGE_COMMAND_SCHEMA } from "./message-command-store.js";
-export const PIBO_DATA_SCHEMA_VERSION = 13;
+export const PIBO_DATA_SCHEMA_VERSION = 14;
 const NATIVE_HISTORY_FALLBACK_SCHEMA_VERSION = 5;
+const TERMINAL_MESSAGE_UNREAD_SCHEMA_VERSION = 14;
 const retiredScopeColumn = ["owner", "scope"].join("_");
 const payloadTableDefinition = `
 	id TEXT PRIMARY KEY,
@@ -201,6 +202,14 @@ function applyPiboDataSchemaInTransaction(db, hooks, previousVersion, tablesToRe
     if (rebuildPayloadTable)
         rebuildPayloadTableForMetadataIdentity(db);
     hooks.afterStep?.("payload-metadata-identity");
+    if (previousVersion < TERMINAL_MESSAGE_UNREAD_SCHEMA_VERSION) {
+        db.exec(`
+			DROP TRIGGER IF EXISTS chat_unread_event_insert;
+			DROP TRIGGER IF EXISTS chat_unread_event_update;
+			DROP INDEX IF EXISTS idx_event_log_unread_stream;
+			DROP INDEX IF EXISTS idx_event_log_unread_session_stream;
+		`);
+    }
     db.exec(`
 		CREATE TABLE IF NOT EXISTS sessions (
 			id TEXT PRIMARY KEY,
@@ -663,8 +672,10 @@ function applyPiboDataSchemaInTransaction(db, hooks, previousVersion, tablesToRe
 			ON event_log(session_id, stream_id);
 		CREATE INDEX IF NOT EXISTS idx_event_log_unread_session_stream
 			ON event_log(session_id, stream_id)
-			WHERE (retention_class = 'chat_message' AND type IN ('user.message.accepted', 'assistant_message'))
-				OR type = 'session_error';
+			WHERE type = 'message_finished';
+		CREATE INDEX IF NOT EXISTS idx_event_log_unread_error_session_stream
+			ON event_log(session_id, stream_id)
+			WHERE type = 'session_error';
 		CREATE INDEX IF NOT EXISTS idx_event_log_session_sequence_stream
 			ON event_log(session_id, session_sequence DESC, stream_id DESC);
 		CREATE INDEX IF NOT EXISTS idx_event_log_session_type_sequence_stream
@@ -769,6 +780,16 @@ function applyPiboDataSchemaInTransaction(db, hooks, previousVersion, tablesToRe
 			ON telemetry_tool_calls(retention_class, updated_at);
 	`);
     db.exec(CHAT_READ_PROJECTION_SCHEMA);
+    if (previousVersion < TERMINAL_MESSAGE_UNREAD_SCHEMA_VERSION) {
+        db.exec(`
+			DELETE FROM chat_unread_counts;
+			DELETE FROM chat_unread_index;
+			UPDATE chat_read_backfill
+			SET event_cursor = 0,
+				event_target = (SELECT COALESCE(MAX(stream_id), 0) FROM event_log)
+			WHERE id = 1;
+		`);
+    }
     db.exec(CHAT_NAVIGATION_REVISION_SCHEMA);
     db.exec(TELEMETRY_MAINTENANCE_SCHEMA);
     hooks.afterStep?.("schema");