npm - @pasko70/pibo - Versions diffs - 3.5.0 → 3.5.1 - Mend

@pasko70/pibo 3.5.0 → 3.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (46) hide show

package/dist/agent-runtime/routed-session.js +80 -19
package/dist/agent-runtimes/codex-native/turn.js +27 -3
package/dist/apps/chat/data/chat-data-mappers.js +8 -1
package/dist/apps/chat/data/read-state-service.js +24 -3
package/dist/apps/chat/message-command-dispatcher.js +16 -1
package/dist/apps/chat/web-app.js +40 -19
package/dist/apps/chat-ui/assets/{dist-D79vyxSX.js → dist-B-auLrzD.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-DFZ8cwh0.js → dist-BA_dsINH.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-D6TjFhAm.js → dist-eJZar_0-.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-BG0n7zLd.js → dist-wNNR2Bci.js} +1 -1
package/dist/apps/chat-ui/assets/{dist-cOjokPrK.js → dist-zcmEsIEp.js} +1 -1
package/dist/apps/chat-ui/assets/{index-RMHUTJ62.js → index-DEkbN5Vo.js} +43 -43
package/dist/apps/chat-ui/assets/index-DZK6Tzil.css +1 -0
package/dist/apps/chat-ui/index.html +2 -2
package/dist/apps/chat-vscode-web/assets/{index-xacbCyTx.js → index-DZgW1fCB.js} +11 -11
package/dist/apps/chat-vscode-web/index.html +1 -1
package/dist/cli-session/localSessionSource.js +3 -2
package/dist/core/output-render-sequence.js +63 -6
package/dist/core/session-router.js +99 -11
package/dist/data/async-chat-storage.js +7 -2
package/dist/data/bounded-worker-client.js +1 -1
package/dist/data/chat-read-projections.js +4 -4
package/dist/data/chat-storage-worker.js +24 -3
package/dist/data/ingest-service.js +73 -4
package/dist/data/message-command-store.js +153 -11
package/dist/data/schema.js +24 -3
package/dist/data/storage-maintenance.js +344 -0
package/dist/data/storage-verification-worker.js +25 -0
package/dist/debug/index.js +155 -1
package/dist/debug/message-queue.js +108 -0
package/dist/debug/output-collision-repair.js +140 -0
package/dist/debug/output-integrity.js +38 -2
package/dist/debug/output-repair.js +1 -0
package/dist/debug/storage-backup.js +12 -4
package/dist/debug/storage-maintenance.js +78 -0
package/dist/gateway/cli.js +71 -7
package/dist/gateway/server.js +1 -0
package/dist/reliability/store.js +119 -23
package/dist/session-ui/terminalRows.js +7 -8
package/dist/sessions/pibo-data-store.js +18 -14
package/dist/shared/trace-event-projection.js +13 -3
package/dist/web/channel.js +114 -12
package/dist/web/http.js +105 -44
package/npm-shrinkwrap.json +2 -2
package/package.json +1 -1
package/dist/apps/chat-ui/assets/index-hEkrlRk-.css +0 -1

package/dist/apps/chat-vscode-web/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
 		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
 		<meta name="theme-color" content="#101d22" />
 		<title>Pibo</title>
-		<script type="module" crossorigin src="/apps/chat-vscode/assets/index-xacbCyTx.js"></script>
+		<script type="module" crossorigin src="/apps/chat-vscode/assets/index-DZgW1fCB.js"></script>
 		<link rel="stylesheet" crossorigin href="/apps/chat-vscode/assets/index-b18ZkEo0.css">
 	</head>
 	<body>

package/dist/cli-session/localSessionSource.js CHANGED Viewed

@@ -641,7 +641,7 @@ export class LocalCliSessionSource {
             if (delivery.persisted)
                 continue;
             try {
-                this.ingestOutputEvent(session, delivery.event);
+                this.ingestOutputEvent(session, delivery.event, retryContext.attempt > 1 ? "durable-replay" : "live");
             }
             catch (error) {
                 errors.push(error instanceof Error ? error : new Error(String(error)));
@@ -753,7 +753,7 @@ export class LocalCliSessionSource {
             // Persistence is best-effort; live local rendering still proceeds through router events.
         }
     }
-    ingestOutputEvent(session, event) {
+    ingestOutputEvent(session, event, phase) {
         if (!this.ingestService)
             return;
         this.ingestService.ingestOutputEvent({
@@ -762,6 +762,7 @@ export class LocalCliSessionSource {
             actorId: session.profile,
             event,
             createdAt: this.now(),
+            persistenceProvenance: { producer: "local-cli", projection: "product-history", phase },
         });
     }
     buildStatus(session) {

package/dist/core/output-render-sequence.js CHANGED Viewed

@@ -109,9 +109,10 @@ export class OutputRenderSequencer {
         const suppliedPart = transition.suppliedIndex === undefined
             ? undefined
             : parts.find((part) => part.index === transition.suppliedIndex);
-        if (transition.suppliedIndex !== undefined && (transition.canonicalIndex || suppliedPart)) {
+        if (transition.suppliedIndex !== undefined && (transition.canonicalIndex
+            || (suppliedPart && (!suppliedPart.closed || suppliedPart.identityFingerprint === transition.identityFingerprint)))) {
             this.highWaterStore?.observeOutputPart?.({ ...transition, index: transition.suppliedIndex });
-            this.recordOutputPart(parts, transition.suppliedIndex, transition.terminal);
+            this.recordOutputPart(parts, transition.suppliedIndex, transition.terminal, transition.identityFingerprint);
             this.trimOutputParts(state);
             return event;
         }
@@ -122,18 +123,20 @@ export class OutputRenderSequencer {
         const index = latestOpen
             ? localIndex
             : this.highWaterStore?.claimOrAttachOutputPart?.({ ...transition, proposedIndex: localIndex }) ?? localIndex;
-        this.recordOutputPart(parts, index, transition.terminal);
+        this.recordOutputPart(parts, index, transition.terminal, transition.identityFingerprint);
         this.trimOutputParts(state);
         return withOutputPartIndex(event, transition.kind, index);
     }
-    recordOutputPart(parts, index, terminal) {
+    recordOutputPart(parts, index, terminal, identityFingerprint) {
         let part = parts.find((candidate) => candidate.index === index);
         if (!part) {
-            part = { index, closed: false };
+            part = { index, closed: false, identityFingerprint };
             parts.push(part);
         }
-        if (terminal)
+        if (terminal) {
             part.closed = true;
+            part.identityFingerprint = identityFingerprint;
+        }
     }
     trimOutputParts(state) {
         let total = 0;
@@ -380,12 +383,66 @@ function outputPartTransition(event, activeEventId) {
 function validOutputPartIndex(value) {
     return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
+export const OUTPUT_IDENTITY_FINGERPRINT_VERSION = 2;
 export function outputIdentityFingerprint(event) {
+    return createHash("sha256").update(stableJson(outputIdentityPayload(event))).digest("hex");
+}
+/** Exact v1 algorithm retained only for comparing pre-v2 persisted fingerprints. */
+export function legacyOutputIdentityFingerprint(event) {
     const payload = { ...event };
     delete payload.renderSequence;
     delete payload.compactionStats;
     return createHash("sha256").update(stableJson(payload)).digest("hex");
 }
+export function legacyOutputIdentityFingerprintCandidates(event) {
+    const variants = [{ ...event }];
+    const assistant = event.type === "assistant_delta" || event.type === "assistant_message";
+    const thinking = event.type === "thinking_started" || event.type === "thinking_delta" || event.type === "thinking_finished";
+    const index = assistant ? event.assistantIndex ?? event.contentIndex : thinking ? event.thinkingIndex ?? event.contentIndex : undefined;
+    if (index !== undefined && (assistant || thinking)) {
+        for (const attribute of assistant ? ["assistantIndex", "contentIndex"] : ["thinkingIndex", "contentIndex"]) {
+            const variant = { ...event };
+            delete variant.assistantIndex;
+            delete variant.thinkingIndex;
+            delete variant.contentIndex;
+            variant[attribute] = index;
+            variants.push(variant);
+        }
+    }
+    for (const variant of [...variants]) {
+        if ("provenance" in variant) {
+            const withoutProvenance = { ...variant };
+            delete withoutProvenance.provenance;
+            variants.push(withoutProvenance);
+        }
+    }
+    return [...new Set(variants.map((variant) => legacyOutputIdentityFingerprint(variant)))];
+}
+/** Redacted, bounded evidence for diagnosing a fingerprint mismatch without retaining values. */
+export function outputIdentityFieldDigests(event) {
+    return Object.fromEntries(Object.entries(outputIdentityPayload(event))
+        .slice(0, 64)
+        .map(([field, value]) => [field, createHash("sha256").update(stableJson(value)).digest("hex").slice(0, 16)]));
+}
+function outputIdentityPayload(event) {
+    const payload = { ...event };
+    delete payload.renderSequence;
+    delete payload.compactionStats;
+    // Delivery provenance describes how equivalent output reached persistence; it
+    // is diagnostic metadata rather than semantic message content.
+    delete payload.provenance;
+    if (event.type === "assistant_delta" || event.type === "assistant_message") {
+        delete payload.assistantIndex;
+        delete payload.contentIndex;
+        payload.outputPartIndex = event.assistantIndex ?? event.contentIndex ?? 0;
+    }
+    else if (event.type === "thinking_started" || event.type === "thinking_delta" || event.type === "thinking_finished") {
+        delete payload.thinkingIndex;
+        delete payload.contentIndex;
+        payload.outputPartIndex = event.thinkingIndex ?? event.contentIndex ?? 0;
+    }
+    return payload;
+}
 export function outputPartFingerprint(event) {
     const payload = { ...event };
     delete payload.renderSequence;

package/dist/core/session-router.js CHANGED Viewed

@@ -175,6 +175,39 @@ function formatRunReminderMessage(notification) {
 function isRunReminderServiceMessage(event) {
     return event.source === "service" && event.text.startsWith("<pibo_run_notification>");
 }
+const RUNTIME_QUEUE_CAPACITY_DIMENSIONS = new Set([
+    "message_bytes",
+    "queue_count",
+    "queue_bytes",
+    "oldest_wait_age",
+]);
+function runReminderAdmissionDiagnostic(error) {
+    if (!error || typeof error !== "object" || !("code" in error) || error.code !== "runtime_capacity_unavailable") {
+        return {
+            code: "run_reminder_delivery_unavailable",
+            warning: "Run reminder deferred: internal delivery is temporarily unavailable; pending run state is retained.",
+        };
+    }
+    const candidate = error;
+    const dimension = typeof candidate.dimension === "string"
+        && RUNTIME_QUEUE_CAPACITY_DIMENSIONS.has(candidate.dimension)
+        ? candidate.dimension
+        : undefined;
+    const current = candidate.current
+        && ["messageBytes", "queueCount", "queueBytes", "oldestWaitMs"].every((key) => (typeof candidate.current?.[key] === "number" && Number.isFinite(candidate.current[key]) && candidate.current[key] >= 0))
+        ? candidate.current
+        : undefined;
+    const limit = typeof candidate.limit === "number" && Number.isFinite(candidate.limit) && candidate.limit >= 0
+        ? candidate.limit
+        : undefined;
+    return {
+        code: "runtime_capacity_unavailable",
+        warning: `Run reminder deferred: runtime queue${dimension ? ` ${dimension}` : ""} capacity is unavailable; pending run state is retained.`,
+        ...(dimension ? { dimension } : {}),
+        ...(current ? { current } : {}),
+        ...(limit !== undefined ? { limit } : {}),
+    };
+}
 function isRunReminderContextPressureError(event) {
     return event.errorDetails?.category === "context_overflow"
         || event.errorDetails?.code === "context_length_exceeded"
@@ -365,6 +398,7 @@ export class PiboSessionRouter {
     deferredRunReminders = new Map();
     runReminderRecoveries = new Map();
     runReminderGenerations = new Map();
+    runReminderAdmissionWarnings = new Map();
     runCancellationHandlers = new Map();
     activeRunExecutions = new Set();
     quiescingSessions = new Set();
@@ -1038,6 +1072,13 @@ export class PiboSessionRouter {
     listRuns(options = {}) {
         return this.runRegistry.listAll(options);
     }
+    getRunJobReliabilityStatus() {
+        return this.reliabilityStore?.getRunJobReliabilityStatus() ?? {
+            status: "ok",
+            expiredOrphanRunJobs: 0,
+            orphanRunDeadLetters: 0,
+        };
+    }
     getSignalRegistry() {
         return this.signalRegistry;
     }
@@ -1630,6 +1671,7 @@ export class PiboSessionRouter {
             },
             statusResources,
             getToolMetricTokenCalculation: () => loadPiboUserSettings().toolMetrics.tokenCalculation,
+            now: this.options.runtimeQueueNow,
         });
         this.sessions.set(piboSession.id, session);
         return session;
@@ -2661,6 +2703,7 @@ export class PiboSessionRouter {
             this.runRegistry.suppressNotification(delivery.piboSessionId, run.runId);
         this.clearRunReminderRecovery(delivery);
         this.deferredRunReminders.delete(delivery.piboSessionId);
+        this.clearRunReminderAdmissionWarning(delivery.piboSessionId, delivery.generation);
         this.sessions.get(delivery.piboSessionId)?.removeQueuedMessages(isRunReminderServiceMessage);
         this.scheduleRunReminder(delivery.piboSessionId, false, delivery.generation);
     }
@@ -2750,6 +2793,7 @@ export class PiboSessionRouter {
             this.scheduledRunReminders.delete(piboSessionId);
             this.deferredRunReminders.delete(piboSessionId);
             this.runReminderRecoveries.delete(piboSessionId);
+            this.clearRunReminderAdmissionWarning(piboSessionId);
             for (const [eventId, delivery] of this.runReminderDeliveries) {
                 if (delivery.piboSessionId === piboSessionId)
                     this.runReminderDeliveries.delete(eventId);
@@ -2787,8 +2831,18 @@ export class PiboSessionRouter {
             return;
         if (deferredGeneration !== undefined)
             this.deferredRunReminders.delete(piboSessionId);
-        if (!this.runRegistry.hasPendingNotification(piboSessionId, { includeAlreadyNotified }))
+        if (!this.runRegistry.hasPendingNotification(piboSessionId, { includeAlreadyNotified })) {
+            this.clearRunReminderAdmissionWarning(piboSessionId, expectedGeneration);
             return;
+        }
+        if (includeAlreadyNotified) {
+            const status = this.sessions.get(piboSessionId)?.getStatus?.();
+            const effectiveEventIds = new Set([status?.activeEventId, ...(status?.queuedEventIds ?? [])].filter((id) => Boolean(id)));
+            if ([...this.runReminderDeliveries.entries()].some(([eventId, delivery]) => (effectiveEventIds.has(eventId)
+                && delivery.piboSessionId === piboSessionId
+                && delivery.generation === expectedGeneration)))
+                return;
+        }
         const previous = this.scheduledRunReminders.get(piboSessionId);
         if (previous?.generation === expectedGeneration) {
             this.scheduledRunReminders.set(piboSessionId, {
@@ -2804,8 +2858,33 @@ export class PiboSessionRouter {
     }
     refreshQueuedRunReminders(piboSessionId) {
         const removed = this.sessions.get(piboSessionId)?.removeQueuedMessages(isRunReminderServiceMessage) ?? 0;
-        if (removed > 0)
+        if (removed > 0) {
             this.scheduleRunReminder(piboSessionId, true);
+        }
+        else if (!this.runRegistry.hasPendingNotification(piboSessionId, { includeAlreadyNotified: true })) {
+            this.clearRunReminderAdmissionWarning(piboSessionId);
+        }
+    }
+    clearRunReminderAdmissionWarning(piboSessionId, generation) {
+        if (generation !== undefined && this.runReminderAdmissionWarnings.get(piboSessionId) !== generation)
+            return;
+        this.runReminderAdmissionWarnings.delete(piboSessionId);
+        this.sessions.get(piboSessionId)?.setRunReminderDeferredWarning?.(undefined);
+    }
+    deferRunReminderAdmission(piboSessionId, generation, error) {
+        const diagnostic = runReminderAdmissionDiagnostic(error);
+        this.sessions.get(piboSessionId)?.setRunReminderDeferredWarning?.(diagnostic.warning);
+        if (this.runReminderAdmissionWarnings.get(piboSessionId) === generation)
+            return;
+        this.runReminderAdmissionWarnings.set(piboSessionId, generation);
+        console.warn("[pibo] run reminder deferred", {
+            piboSessionId,
+            generation,
+            code: diagnostic.code,
+            ...(diagnostic.dimension ? { dimension: diagnostic.dimension } : {}),
+            ...(diagnostic.current ? { current: diagnostic.current } : {}),
+            ...(diagnostic.limit !== undefined ? { limit: diagnostic.limit } : {}),
+        });
     }
     async deliverRunReminder(piboSessionId, expectedGeneration) {
         const scheduled = this.scheduledRunReminders.get(piboSessionId);
@@ -2820,9 +2899,21 @@ export class PiboSessionRouter {
             const session = await this.getOrCreateSession(piboSessionId);
             if (this.closing || this.quiescingSessions.has(piboSessionId) || expectedGeneration !== this.runReminderGeneration(piboSessionId))
                 return;
-            notification = this.runRegistry.createNotification(piboSessionId, { includeAlreadyNotified: scheduled.includeAlreadyNotified });
-            if (!notification)
+            // Release the queued snapshot before reserving its replacement. The
+            // interruption callback restores every unconsumed run to pending state.
+            const replaced = session.removeQueuedMessages?.((event) => {
+                if (!isRunReminderServiceMessage(event) || !event.id)
+                    return false;
+                const delivery = this.runReminderDeliveries.get(event.id);
+                return delivery?.piboSessionId === piboSessionId && delivery.generation === expectedGeneration;
+            }) ?? 0;
+            notification = this.runRegistry.createNotification(piboSessionId, {
+                includeAlreadyNotified: scheduled.includeAlreadyNotified || replaced > 0,
+            });
+            if (!notification) {
+                this.clearRunReminderAdmissionWarning(piboSessionId, expectedGeneration);
                 return;
+            }
             eventId = randomUUID();
             this.runReminderDeliveries.set(eventId, { piboSessionId, generation: expectedGeneration, notification });
             session.enqueueMessage({
@@ -2833,6 +2924,7 @@ export class PiboSessionRouter {
                 id: eventId,
                 provenance: runReminderProvenance(notification),
             });
+            this.clearRunReminderAdmissionWarning(piboSessionId, expectedGeneration);
         }
         catch (error) {
             if (eventId)
@@ -2841,13 +2933,9 @@ export class PiboSessionRouter {
                 this.runRegistry.releaseNotification(piboSessionId, notification);
             if (this.closing || this.quiescingSessions.has(piboSessionId) || expectedGeneration !== this.runReminderGeneration(piboSessionId))
                 return;
-            const message = error instanceof Error ? error.message : String(error);
-            this.emitOutput({
-                type: "session_error",
-                piboSessionId,
-                error: message,
-                errorDetails: runtimeSessionErrorDetails(message),
-            });
+            // Reminder delivery is internal recovery work. Preserve it for the next
+            // bounded state transition instead of emitting an unscoped fatal error.
+            this.deferRunReminderAdmission(piboSessionId, expectedGeneration, error);
         }
     }
 }

package/dist/data/async-chat-storage.js CHANGED Viewed

@@ -69,8 +69,12 @@ export class AsyncChatStorage {
     ingestUser(input) {
         return this.writer.request({ type: "ingestUser", input });
     }
-    ingestOutput(input) {
-        return this.writer.request({ type: "ingestOutput", input }, { priority: "output", fairnessKey: input.roomId });
+    async ingestOutput(input) {
+        const result = await this.writer.request({ type: "ingestOutput", input }, { priority: "output", fairnessKey: input.roomId });
+        if (input.event.type === "compaction_end" && result.enrichment?.compactionStats) {
+            input.event.compactionStats = result.enrichment.compactionStats;
+        }
+        return result;
     }
     cancelPendingCommands(sessionId) { return this.writer.request({ type: "cancelPendingCommands", sessionId }, { priority: "control" }); }
     commandReceiptPage(sessionId) { return this.writer.request({ type: "commandReceiptPage", sessionId }, { priority: "control" }); }
@@ -79,6 +83,7 @@ export class AsyncChatStorage {
     claimCommand(owner, leaseMs) { return this.writer.request({ type: "claimCommand", owner, leaseMs }, { priority: "background" }); }
     transitionCommand(id, owner, token, state, error) { return this.writer.request({ type: "transitionCommand", id, owner, token, state, error }, { priority: "control" }); }
     heartbeatCommand(id, owner, token, leaseMs) { return this.writer.request({ type: "heartbeatCommand", id, owner, token, leaseMs }, { priority: "control" }); }
+    durableQueueHealth() { return this.writer.request({ type: "durableQueueHealth" }, { priority: "control", timeoutMs: 500 }); }
     status() {
         const writer = this.writer.status();
         const reader = this.reader?.status();

package/dist/data/bounded-worker-client.js CHANGED Viewed

@@ -112,7 +112,7 @@ export class BoundedWorkerClient {
                 pending.settled = true;
                 if (message.error) {
                     this.rejected++;
-                    pending.reject(Object.assign(new Error(message.error.message ?? "Storage operation failed."), { code: message.error.code ?? "storage_operation_failed" }));
+                    pending.reject(Object.assign(new Error(message.error.message ?? "Storage operation failed."), { code: message.error.code ?? "storage_operation_failed", ...message.error.details }));
                 }
                 else {
                     try {

package/dist/data/chat-read-projections.js CHANGED Viewed

@@ -12,7 +12,7 @@ END;
 CREATE TRIGGER IF NOT EXISTS chat_trace_delete AFTER DELETE ON event_log WHEN OLD.session_id IS NOT NULL BEGIN
  INSERT INTO chat_trace_revisions VALUES(OLD.session_id,1) ON CONFLICT(session_id) DO UPDATE SET revision=revision+1;
 END;
-CREATE INDEX IF NOT EXISTS idx_event_log_unread_stream ON event_log(stream_id) WHERE (retention_class='chat_message' AND type IN ('user.message.accepted','assistant_message')) OR type='session_error';
+CREATE INDEX IF NOT EXISTS idx_event_log_unread_stream ON event_log(stream_id) WHERE type='message_finished';
 CREATE TABLE IF NOT EXISTS chat_unread_index(stream_id INTEGER PRIMARY KEY,session_id TEXT NOT NULL);
 CREATE INDEX IF NOT EXISTS idx_chat_unread_session_stream ON chat_unread_index(session_id,stream_id);
 CREATE TABLE IF NOT EXISTS chat_unread_counts(session_id TEXT PRIMARY KEY,unread_count INTEGER NOT NULL DEFAULT 0);
@@ -23,13 +23,13 @@ END;
 CREATE TRIGGER IF NOT EXISTS chat_unread_count_delete AFTER DELETE ON chat_unread_index BEGIN
  UPDATE chat_unread_counts SET unread_count=MAX(0,unread_count-CASE WHEN OLD.stream_id>COALESCE((SELECT last_read_stream_id FROM app_session_read_state WHERE session_id=OLD.session_id),0) THEN 1 ELSE 0 END) WHERE session_id=OLD.session_id;
 END;
-CREATE TRIGGER IF NOT EXISTS chat_unread_event_insert AFTER INSERT ON event_log WHEN NEW.session_id IS NOT NULL AND ((NEW.retention_class='chat_message' AND NEW.type IN ('user.message.accepted','assistant_message')) OR NEW.type='session_error') BEGIN
+CREATE TRIGGER IF NOT EXISTS chat_unread_event_insert AFTER INSERT ON event_log WHEN NEW.session_id IS NOT NULL AND NEW.type='message_finished' BEGIN
  INSERT OR IGNORE INTO chat_unread_index VALUES(NEW.stream_id,NEW.session_id);
 END;
 CREATE TRIGGER IF NOT EXISTS chat_unread_event_delete AFTER DELETE ON event_log BEGIN DELETE FROM chat_unread_index WHERE stream_id=OLD.stream_id; END;
 CREATE TRIGGER IF NOT EXISTS chat_unread_event_update AFTER UPDATE ON event_log BEGIN
  DELETE FROM chat_unread_index WHERE stream_id=OLD.stream_id;
- INSERT OR IGNORE INTO chat_unread_index SELECT NEW.stream_id,NEW.session_id WHERE NEW.session_id IS NOT NULL AND ((NEW.retention_class='chat_message' AND NEW.type IN ('user.message.accepted','assistant_message')) OR NEW.type='session_error');
+ INSERT OR IGNORE INTO chat_unread_index SELECT NEW.stream_id,NEW.session_id WHERE NEW.session_id IS NOT NULL AND NEW.type='message_finished';
 END;
 CREATE TRIGGER IF NOT EXISTS chat_unread_mark_insert AFTER INSERT ON app_session_read_state BEGIN
  INSERT INTO chat_unread_counts(session_id,unread_count) SELECT NEW.session_id,COUNT(*) FROM chat_unread_index WHERE session_id=NEW.session_id AND stream_id>NEW.last_read_stream_id
@@ -103,7 +103,7 @@ export class ChatReadProjectionStore {
                 return { ...current, processed: 0 };
             }
             if (current.historyComplete) {
-                const rows = this.db.prepare("SELECT stream_id,session_id FROM event_log INDEXED BY idx_event_log_unread_stream WHERE stream_id>? AND stream_id<=? AND ((retention_class='chat_message' AND type IN ('user.message.accepted','assistant_message')) OR type='session_error') ORDER BY stream_id LIMIT ?").all(current.event_cursor, current.event_target, limit);
+                const rows = this.db.prepare("SELECT stream_id,session_id FROM event_log INDEXED BY idx_event_log_unread_stream WHERE stream_id>? AND stream_id<=? AND type='message_finished' ORDER BY stream_id LIMIT ?").all(current.event_cursor, current.event_target, limit);
                 const insert = this.db.prepare("INSERT OR IGNORE INTO chat_unread_index VALUES(?,?)");
                 let processed = 0;
                 const started = performance.now();

package/dist/data/chat-storage-worker.js CHANGED Viewed

@@ -19,6 +19,15 @@ const ingest = new ChatDataIngestService(store);
 const rooms = new ChatRoomService(store);
 const sessions = new ChatSessionQueryService(store);
 const messageCommands = new MessageCommandStore(store);
+// Startup repair is bounded and conservative: terminal evidence may settle a receipt,
+// but ambiguous work is retained and never replayed. A damaged row must not stop the worker.
+let startupReconciliation;
+try {
+    startupReconciliation = messageCommands.reconcileInterrupted();
+}
+catch (error) {
+    startupReconciliation = { error: error instanceof Error ? error.message.slice(0, 500) : "Unknown reconciliation error" };
+}
 let active = false;
 let operations = 0;
 let busyRetries = 0;
@@ -32,6 +41,7 @@ function execute(command) {
         case "claimCommand": return messageCommands.claim(command.owner, command.leaseMs);
         case "transitionCommand": return messageCommands.transition(command.id, command.owner, command.token, command.state, command.error);
         case "heartbeatCommand": return messageCommands.heartbeat(command.id, command.owner, command.token, command.leaseMs);
+        case "durableQueueHealth": return messageCommands.health();
         case "resolveRoom": {
             const room = command.roomId ? rooms.getRoom(command.roomId) : undefined;
             if (room)
@@ -54,6 +64,8 @@ function execute(command) {
                 throw Object.assign(new Error("Transaction belongs to the legacy admission contract."), { code: "command_conflict" });
             if (existing)
                 return { event: commands.findByClientTxn(room.id, command.input.actorId, command.input.clientTxnId), created: false, receipt };
+            if (command.durableCommand)
+                messageCommands.assertAdmissionUnblocked(command.session.id, command.durableCommand.delivery);
             const preparedCommand = commandInput ? messageCommands.prepare(commandInput) : undefined;
             const createdAt = command.input.createdAt ?? new Date().toISOString();
             const preparedPayload = ingest.prepareUserMessagePayload(command.text, createdAt);
@@ -65,6 +77,8 @@ function execute(command) {
                         throw Object.assign(new Error("Transaction belongs to the legacy admission contract."), { code: "command_conflict" });
                     return { event: commands.findByClientTxn(room.id, command.input.actorId, command.input.clientTxnId), created: false, receipt };
                 }
+                if (command.durableCommand)
+                    messageCommands.assertAdmissionUnblocked(command.session.id, command.durableCommand.delivery);
                 const event = commands.appendEvent({ ...command.input, createdAt });
                 sessions.upsertSession(command.session, command.durableCommand ? sessions.getSession(command.session.id)?.status ?? "idle" : "idle", command.session.updatedAt, { preserveRuntimeBinding: true });
                 ingest.ingestUserMessageAccepted({ session: command.session, roomId: room.id, actorId: command.input.actorId ?? "", text: command.text, clientTxnId: command.input.clientTxnId, eventId: command.durableCommand?.eventId, legacyEvent: event, preparedPayload });
@@ -85,10 +99,14 @@ function execute(command) {
         case "ingestOutput": {
             const result = ingest.ingestOutputEvent(command.input);
             messageCommands.recordOutput(command.input.session.id, "eventId" in command.input.event ? command.input.event.eventId : undefined, command.input.event.type);
-            const row = store.db.prepare("SELECT created_at, event_id FROM event_log WHERE stream_id = ?").get(result.streamId);
+            const row = store.db.prepare("SELECT created_at, event_id, attributes_json FROM event_log WHERE stream_id = ?").get(result.streamId);
             if (!row)
                 throw new Error(`Missing output event ${result.streamId} after ingest.`);
-            return { ...result, stored: { createdAt: row.created_at, eventId: row.event_id ?? String(result.streamId) } };
+            const attributes = JSON.parse(row.attributes_json);
+            const enrichment = command.input.event.type === "compaction_end" && attributes.compactionStats
+                ? { compactionStats: attributes.compactionStats }
+                : undefined;
+            return { ...result, stored: { createdAt: row.created_at, eventId: row.event_id ?? String(result.streamId) }, enrichment };
         }
         case "status": return { operations, busyRetries, lastOperationMs, pid: process.pid, synchronous: store.db.prepare("PRAGMA synchronous").get(), journalMode: store.db.prepare("PRAGMA journal_mode").get() };
     }
@@ -122,7 +140,9 @@ function attempt(request) {
         }
         const domainCode = error && typeof error === "object" && "code" in error ? String(error.code) : "";
         if (domainCode === "room_not_found" || domainCode === "room_read_only" || (domainCode.startsWith("storage_") || domainCode.startsWith("command_")) || domainCode === "pibo_output_identity_collision") {
-            respond(request, { error: { code: domainCode, message } });
+            const source = error;
+            const details = Object.fromEntries(["retryable", "scope", "blockingCommandId", "blockedSince", "oldestWaitAgeMs", "nextAction"].flatMap(key => source[key] === undefined ? [] : [[key, source[key]]]));
+            respond(request, { error: { code: domainCode, message, ...(Object.keys(details).length ? { details } : {}) } });
             return;
         }
         respond(request, { error: { code: /database is (?:locked|busy)/i.test(message) ? "storage_busy" : "storage_operation_failed", message: "Storage operation failed; reconcile the transaction ID before retrying." } });
@@ -142,5 +162,6 @@ port.postMessage({
         ...workerStatus(),
         journalMode: store.db.prepare("PRAGMA journal_mode").get(),
         synchronous: store.db.prepare("PRAGMA synchronous").get(),
+        startupReconciliation,
     },
 });

package/dist/data/ingest-service.js CHANGED Viewed

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
-import { outputIdentityFingerprint, outputPartFingerprint } from "../core/output-render-sequence.js";
+import { legacyOutputIdentityFingerprintCandidates, OUTPUT_IDENTITY_FINGERPRINT_VERSION, outputIdentityFieldDigests, outputIdentityFingerprint, outputPartFingerprint } from "../core/output-render-sequence.js";
 import { rootSessionId } from "./session-store.js";
 export class PiboOutputIdentityCollisionError extends Error {
     idempotencyKey;
@@ -26,6 +26,7 @@ export function outputPersistenceErrorIsRetryable(error) {
 }
 const INLINE_MESSAGE_PAYLOAD_THRESHOLD_BYTES = 16 * 1024;
 const INLINE_JSON_PAYLOAD_THRESHOLD_BYTES = 16 * 1024;
+const MAX_FINGERPRINT_FIELD_DIFFERENCES = 24;
 export class ChatDataIngestService {
     store;
     constructor(store) {
@@ -106,15 +107,30 @@ export class ChatDataIngestService {
         const event = input.event;
         const idempotencyKey = outputIdempotencyKey(event);
         const identityFingerprint = outputIdentityFingerprint(event);
+        const identityFieldDigests = outputIdentityFieldDigests(event);
+        const incomingProvenance = input.persistenceProvenance ?? {
+            producer: "direct-ingest",
+            projection: "product-history",
+            phase: "direct",
+        };
         const partFingerprint = isOutputPartEvent(event) ? outputPartFingerprint(event) : undefined;
         if (idempotencyKey) {
-            const existing = this.store.eventLog.findByIdempotencyKey(idempotencyKey);
+            const directExisting = this.store.eventLog.findByIdempotencyKey(idempotencyKey);
+            const legacyExisting = !directExisting && event.type === "execution_result"
+                ? this.store.eventLog.findByIdempotencyKey(legacyOutputIdempotencyKey(event))
+                : undefined;
+            const legacyPhaseMatches = legacyExisting && event.type === "execution_result"
+                ? legacyExecutionResultPhase(legacyExisting.attributes) === executionResultPhase(event)
+                : false;
+            const existing = directExisting ?? (legacyExisting && (storedFingerprintMatches(legacyExisting.attributes, event, identityFingerprint) || legacyPhaseMatches) ? legacyExisting : undefined);
             if (existing) {
                 const existingFingerprint = typeof existing.attributes.identityFingerprint === "string"
                     ? existing.attributes.identityFingerprint
                     : undefined;
-                if (existingFingerprint && existingFingerprint !== identityFingerprint) {
+                if (existingFingerprint && !storedFingerprintMatches(existing.attributes, event, identityFingerprint)) {
                     const now = input.createdAt ?? new Date().toISOString();
+                    const existingFieldDigests = stringMap(existing.attributes.identityFieldDigests);
+                    const fieldDifferences = diffFieldDigests(existingFieldDigests, identityFieldDigests);
                     this.store.eventLog.appendEvent({
                         sessionId: input.session.id,
                         sessionSequence: this.nextEventSequence(input.session.id),
@@ -133,6 +149,10 @@ export class ChatDataIngestService {
                             existingFingerprint,
                             incomingFingerprint: identityFingerprint,
                             incomingType: event.type,
+                            existingProvenance: redactedPersistenceProvenance(existing.attributes.persistenceProvenance),
+                            incomingProvenance,
+                            fieldDifferences,
+                            fieldDifferencesTruncated: fieldDifferences.length >= MAX_FINGERPRINT_FIELD_DIFFERENCES,
                         },
                         createdAt: now,
                         indexedAt: now,
@@ -177,6 +197,9 @@ export class ChatDataIngestService {
                 previewText: previewTextForOutputEvent(event),
                 attributes: compactObject({
                     identityFingerprint,
+                    identityFingerprintVersion: OUTPUT_IDENTITY_FINGERPRINT_VERSION,
+                    identityFieldDigests,
+                    persistenceProvenance: incomingProvenance,
                     outputPartFingerprint: partFingerprint,
                     eventIdentityScoped: eventIdForOutputEvent(event) !== undefined,
                     semanticEventId: eventIdForOutputEvent(event),
@@ -340,6 +363,43 @@ function nonNegativeFiniteNumber(value) {
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function stringMap(value) {
+    if (!isRecord(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string").slice(0, 64));
+}
+function diffFieldDigests(existing, incoming) {
+    return [...new Set([...Object.keys(existing), ...Object.keys(incoming)])]
+        .sort()
+        .filter((field) => existing[field] !== incoming[field])
+        .slice(0, MAX_FINGERPRINT_FIELD_DIFFERENCES)
+        .map((field) => ({
+        field,
+        change: existing[field] === undefined ? "added" : incoming[field] === undefined ? "removed" : "changed",
+    }));
+}
+function redactedPersistenceProvenance(value) {
+    if (!isRecord(value))
+        return { producer: "unknown", projection: "product-history", phase: "unknown" };
+    const bounded = (field) => typeof value[field] === "string" ? value[field].slice(0, 64) : "unknown";
+    return { producer: bounded("producer"), projection: bounded("projection"), phase: bounded("phase") };
+}
+function executionResultPhase(event) {
+    return isRecord(event.result) && event.result.queued === true ? "queued" : "complete";
+}
+function legacyExecutionResultPhase(attributes) {
+    return isRecord(attributes.inlinePayload) && attributes.inlinePayload.queued === true ? "queued" : "complete";
+}
+function storedFingerprintMatches(attributes, event, currentFingerprint) {
+    const fingerprint = attributes.identityFingerprint;
+    if (typeof fingerprint !== "string")
+        return true;
+    if (attributes.identityFingerprintVersion === OUTPUT_IDENTITY_FINGERPRINT_VERSION)
+        return fingerprint === currentFingerprint;
+    // Versionless fingerprints were produced by v1. Compare with the exact old
+    // algorithm instead of comparing incompatible hash formats.
+    return legacyOutputIdentityFingerprintCandidates(event).includes(fingerprint);
+}
 function deterministicId(prefix, value) {
     return `${prefix}_${createHash("sha256").update(value).digest("hex").slice(0, 32)}`;
 }
@@ -378,6 +438,13 @@ export function outputPersistenceDeliveryKey(event) {
     return outputIdempotencyKey(event)
         ?? `pibo.output:${event.piboSessionId}:${event.type}:render:${event.renderSequence ?? "unpositioned"}`;
 }
+/** Accepted only while recovering pre-phase execution-result envelopes. */
+export function legacyOutputIdempotencyKey(event) {
+    if (event.type !== "execution_result")
+        return outputIdempotencyKey(event);
+    const base = event.eventId;
+    return base ? `pibo.output:${event.piboSessionId}:${event.type}:${base}:${event.action}` : undefined;
+}
 function outputPartKey(event) {
     if (event.type === "tool_call")
         return `${event.toolCallId}:${event.toolInvocationOrdinal ?? 0}:${event.argsComplete ? "complete" : "partial"}:${hashJson(event.args)}`;
@@ -394,7 +461,7 @@ function outputPartKey(event) {
     if (event.type === "compaction_start" || event.type === "compaction_end")
         return String(event.compactionIndex ?? 0);
     if (event.type === "execution_result")
-        return event.action;
+        return `${event.action}:${executionResultPhase(event)}`;
     return "main";
 }
 function messageIdForOutputEvent(event) {
@@ -479,6 +546,8 @@ function specificAttributesForOutputEvent(event) {
     if (event.type === "assistant_usage")
         return {
             usageIndex: event.usageIndex,
+            inferenceId: event.inferenceId,
+            inferenceTarget: event.inferenceTarget,
             inputTokens: event.inputTokens,
             outputTokens: event.outputTokens,
             cacheReadTokens: event.cacheReadTokens,