@pasko70/pibo 1.9.10 → 1.9.13

package/dist/apps/chat-ui/index.html

@@ -9,7 +9,7 @@
     <link rel="manifest" href="/apps/chat/manifest.webmanifest" />
     <link rel="apple-touch-icon" href="/apps/chat/assets/pwa-images/ios/180.png" />
     <title>Pibo Web Chat</title>
-    <script type="module" crossorigin src="/apps/chat/assets/index-Gf-Zb-P-.js"></script>
+    <script type="module" crossorigin src="/apps/chat/assets/index-DwHJfmiF.js"></script>
     <link rel="modulepreload" crossorigin href="/apps/chat/assets/rolldown-runtime-S-ySWqyJ.js">
     <link rel="modulepreload" crossorigin href="/apps/chat/assets/dist-SVPsM5Oi.js">
     <link rel="stylesheet" crossorigin href="/apps/chat/assets/index-C0x9nEcf.css">

package/dist/core/session-router.js

@@ -353,9 +353,16 @@ export class PiboSessionRouter {
         this.projectKnownSessionSignals();
         return this.signalRegistry.snapshotTree(rootPiboSessionId);
     }
+    snapshotSignalStatuses() {
+        this.projectKnownSessionSignals();
+        return this.signalRegistry.snapshotStatuses();
+    }
     subscribeSignalTree(rootPiboSessionId, listener) {
         return this.signalRegistry.subscribe(rootPiboSessionId, listener);
     }
+    subscribeSignalStatuses(listener) {
+        return this.signalRegistry.subscribeAll(listener);
+    }
     async emitMessageAndWaitForReply(event, timeoutMs = 120000) {
         const eventWithId = { ...event, id: event.id ?? randomUUID() };
         return await new Promise((resolve, reject) => {

package/dist/data/ingest-service.js

@@ -120,6 +120,13 @@ export class ChatDataIngestService {
                 indexedAt: now,
             });
             let messageId;
+            if (event.type === "message_finished" && event.eventId) {
+                this.store.messages.completeAssistantMessagesForTurn({
+                    sessionId: input.session.id,
+                    turnId: event.eventId,
+                    completedAt: now,
+                });
+            }
             if (event.type === "assistant_message") {
                 messageId = messageIdForOutputEvent(event);
                 if (messageId && !this.store.messages.getMessage(messageId)) {

package/dist/data/message-store.js

@@ -38,6 +38,17 @@ export class MessageStore {
         const rows = this.db.prepare("SELECT * FROM chat_messages WHERE session_id = ? ORDER BY sequence ASC").all(sessionId);
         return rows.map(messageFromRow);
     }
+    completeAssistantMessagesForTurn(input) {
+        const result = this.db.prepare(`
+			UPDATE chat_messages
+			SET completed_at = ?,
+				status = ?
+			WHERE session_id = ?
+				AND turn_id = ?
+				AND role = 'assistant'
+		`).run(input.completedAt, input.status ?? "complete", input.sessionId, input.turnId);
+        return Number(result.changes ?? 0);
+    }
 }
 function messageFromRow(row) {
     return {

package/dist/data/schema.js

@@ -356,6 +356,8 @@ export function applyPiboDataSchema(db) {
 			ON event_log(session_id, stream_id);
 		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
+			ON event_log(session_id, type, session_sequence ASC, stream_id ASC);
 		CREATE INDEX IF NOT EXISTS idx_event_log_room_stream
 			ON event_log(room_id, stream_id);
 		CREATE INDEX IF NOT EXISTS idx_event_log_topic_stream

package/dist/gateway/server.js

@@ -319,7 +319,9 @@ export class PiboGatewayServer {
             listRuns: (options) => this.requireRouter().listRuns(options),
             snapshotSignalSession: (piboSessionId) => this.requireRouter().snapshotSignalSession(piboSessionId),
             snapshotSignalTree: (rootPiboSessionId) => this.requireRouter().snapshotSignalTree(rootPiboSessionId),
+            snapshotSignalStatuses: () => this.requireRouter().snapshotSignalStatuses(),
             subscribeSignalTree: (rootPiboSessionId, listener) => this.requireRouter().subscribeSignalTree(rootPiboSessionId, listener),
+            subscribeSignalStatuses: (listener) => this.requireRouter().subscribeSignalStatuses(listener),
             getGatewayActions: () => this.pluginRegistry.getGatewayActionInfos(),
             getProfiles: () => this.pluginRegistry.getProfileInfos(),
             createProfile: (name) => this.pluginRegistry.createProfile(name),

package/dist/resources/lifecycle.js

@@ -243,15 +243,13 @@ function buildBrowserReapPlanItem(record, now, idleTimeoutMinutes) {
         preservesWorktree: true,
     };
 }
-async function planComputeReapSafely(options) {
+export async function planComputeReapSafely(options, planCompute = planReapWorkers) {
     try {
-        return await planReapWorkers(options);
+        return await planCompute(options);
     }
-    catch (error) {
-        if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
-            throw error;
+    catch {
         const plan = buildComputeWorkerReapPlan([], options);
-        plan.nextCommands = ["Docker CLI is unavailable in this runtime; browser and stale-file cleanup remain active."];
+        plan.nextCommands = ["Docker compute cleanup is unavailable; browser and stale-file cleanup remain active."];
         return plan;
     }
 }

package/dist/resources/reaper-state.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
@@ -5,11 +6,37 @@ import { piboHomePath } from "../core/pibo-home.js";
 export function defaultResourceReaperStatePath() {
     return process.env.PIBO_RESOURCE_REAPER_STATE_PATH || piboHomePath("resource-reaper-state.json");
 }
-export async function writeResourceReaperState(path, state) {
+const DEFAULT_RENAME_RETRY_DELAYS_MS = [10, 25, 50, 100, 200];
+const TRANSIENT_RENAME_ERROR_CODES = new Set(["EACCES", "EBUSY", "ENOTEMPTY", "EPERM"]);
+export async function writeResourceReaperState(path, state, options = {}) {
     await mkdir(dirname(path), { recursive: true });
-    const temporaryPath = `${path}.${process.pid}.tmp`;
+    const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    const renameFile = options.rename ?? rename;
+    const wait = options.wait ?? defaultWait;
+    const retryDelaysMs = options.retryDelaysMs ?? DEFAULT_RENAME_RETRY_DELAYS_MS;
     await writeFile(temporaryPath, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
-    await rename(temporaryPath, path);
+    try {
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                await renameFile(temporaryPath, path);
+                return;
+            }
+            catch (error) {
+                if (!isTransientRenameError(error) || attempt >= retryDelaysMs.length)
+                    throw error;
+                await wait(retryDelaysMs[attempt]);
+            }
+        }
+    }
+    finally {
+        await rm(temporaryPath, { force: true }).catch(() => undefined);
+    }
+}
+function isTransientRenameError(error) {
+    return error instanceof Error && "code" in error && TRANSIENT_RENAME_ERROR_CODES.has(String(error.code));
+}
+async function defaultWait(delayMs) {
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
 }
 export async function claimResourceReaperOwnership(lockPath, pid = process.pid, isPidAlive = defaultIsPidAlive) {
     await mkdir(dirname(lockPath), { recursive: true });

package/dist/resources/reaper.js

@@ -9,6 +9,7 @@ export class ResourceReaperService {
     plan;
     apply;
     now;
+    writeState;
     timer;
     running = false;
     stopped = true;
@@ -23,6 +24,7 @@ export class ResourceReaperService {
         this.plan = options.plan ?? planResourceReap;
         this.apply = options.apply ?? applyResourceReapPlan;
         this.now = options.clock ?? (() => new Date());
+        this.writeState = options.writeState ?? writeResourceReaperState;
     }
     async start() {
         if (!this.stopped)
@@ -47,19 +49,24 @@ export class ResourceReaperService {
         if (this.timer)
             clearTimeout(this.timer);
         this.timer = undefined;
-        if (this.state && this.ownsTimer) {
-            this.state = { ...this.state, status: "stopped", nextRunAt: undefined };
-            await this.persist();
+        try {
+            if (this.state && this.ownsTimer) {
+                this.state = { ...this.state, status: "stopped", nextRunAt: undefined };
+                await this.persist();
+            }
+        }
+        finally {
+            if (this.ownsTimer)
+                await releaseResourceReaperOwnership(this.lockPath);
+            this.ownsTimer = false;
         }
-        if (this.ownsTimer)
-            await releaseResourceReaperOwnership(this.lockPath);
-        this.ownsTimer = false;
     }
     async runNow() {
         if (!this.ownsTimer || this.running)
             return undefined;
         this.running = true;
         const runAt = this.now();
+        let result;
         try {
             const plan = await this.plan({
                 includeDev: this.options.includeDev,
@@ -71,7 +78,7 @@ export class ResourceReaperService {
                 exemptBrowserPids: this.options.exemptBrowserPids,
                 now: runAt,
             });
-            const result = await this.apply(plan);
+            result = await this.apply(plan);
             this.state = {
                 ...(this.state ?? {
                     status: "running",
@@ -91,8 +98,6 @@ export class ResourceReaperService {
                 lastError: undefined,
             };
             console.error(JSON.stringify({ event: "resource_reaper_finished", at: runAt.toISOString(), ...this.state.lastResult }));
-            await this.persist();
-            return result;
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -109,12 +114,16 @@ export class ResourceReaperService {
                 lastError: message,
             };
             console.error(JSON.stringify({ event: "resource_reaper_failed", at: runAt.toISOString(), error: message }));
-            await this.persist();
-            return undefined;
         }
         finally {
-            this.running = false;
+            try {
+                await this.persist();
+            }
+            finally {
+                this.running = false;
+            }
         }
+        return result;
     }
     arm(delayMs) {
         if (this.stopped)
@@ -122,13 +131,32 @@ export class ResourceReaperService {
         if (this.timer)
             clearTimeout(this.timer);
         this.timer = setTimeout(() => {
-            void this.runNow().finally(() => this.arm(this.intervalMs));
+            void this.runNow()
+                .catch((error) => {
+                console.error(JSON.stringify({
+                    event: "resource_reaper_timer_failed",
+                    at: new Date().toISOString(),
+                    error: error instanceof Error ? error.message : String(error),
+                }));
+            })
+                .finally(() => this.arm(this.intervalMs));
         }, delayMs);
         this.timer.unref?.();
     }
     async persist() {
-        if (this.state)
-            await writeResourceReaperState(this.statePath, this.state);
+        if (!this.state)
+            return;
+        try {
+            await this.writeState(this.statePath, this.state);
+        }
+        catch (error) {
+            console.error(JSON.stringify({
+                event: "resource_reaper_state_persist_failed",
+                at: new Date().toISOString(),
+                path: this.statePath,
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        }
     }
 }
 function readPositiveInteger(value) {

package/dist/shared/trace-engine.js

@@ -1,5 +1,5 @@
 import { reconcileAsyncAgentRunStatuses } from "./trace-async-agent-runs.js";
-import { applySingleEventToNodes, contentDeltaPatchNodeId, dedupeTraceEvents, eventsCanAffectAsyncAgentRunStatus, findOpenTranscriptEventIds, isConfirmedUserMessageEcho, latestTraceStreamId, messageTurnTimingsFromEvents, reconcileTranscriptUserMessageTimestamps, traceEventDedupeKey, } from "./trace-event-projection.js";
+import { applySingleEventToNodes, contentDeltaPatchNodeId, dedupeTraceEvents, eventsCanAffectAsyncAgentRunStatus, findOpenTranscriptEventIds, isConfirmedUserMessageEcho, latestTraceStreamId, mergeMessageTurnTimings, messageTurnTimingsFromEvents, reconcileTranscriptUserMessageTimestamps, traceEventDedupeKey, } from "./trace-event-projection.js";
 import { flattenTraceNodes, mapTraceNodesById, nestTraceNodes } from "./trace-nodes.js";
 import { nestMutableCopiedTraceNodes, shareUnchangedTraceNodes } from "./trace-patch-nodes.js";
 import { mapTraceChildSessionsByParent, mapTraceSubagentSessionLinks, } from "./trace-subagent-links.js";
@@ -14,7 +14,8 @@ export function buildTraceViewFromEvents(input) {
     const allEntries = input.transcriptEntries ?? [];
     const openTranscriptEventIds = findOpenTranscriptEventIds(events, sessionStatus);
     const entries = projectTranscriptEntries(allEntries, sessionStatus, openTranscriptEventIds);
-    const nodes = traceNodesFromEntries(input.session.id, entries, messageTurnTimingsFromEvents(events));
+    const turnTimings = mergeMessageTurnTimings(input.turnTimings ?? [], messageTurnTimingsFromEvents(events));
+    const nodes = traceNodesFromEntries(input.session.id, entries, turnTimings);
     reconcileTranscriptUserMessageTimestamps(nodes, events);
     const byId = mapTraceNodesById(nodes);
     const childByParent = mapTraceChildSessionsByParent(input.sessions ?? []);

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

@@ -531,6 +531,32 @@ function shouldKeepTranscriptEchoEvent(event, openTranscriptEventIds) {
 function isStaleToolCallEchoEvent(event, sessionStatus) {
     return sessionStatus !== "running" && event.type === "tool_call";
 }
+export function mergeMessageTurnTimings(...groups) {
+    const byEventId = new Map();
+    for (const timing of groups.flat()) {
+        const existing = byEventId.get(timing.eventId);
+        if (!existing) {
+            byEventId.set(timing.eventId, timing);
+            continue;
+        }
+        const merged = {
+            eventId: timing.eventId,
+            userText: timing.userText ?? existing.userText,
+            startedAt: timing.startedAt ?? existing.startedAt,
+            completedAt: timing.completedAt ?? existing.completedAt,
+            durationMs: timing.durationMs ?? existing.durationMs,
+        };
+        if (merged.durationMs === undefined) {
+            const startedAtMs = parseTimestamp(merged.startedAt);
+            const completedAtMs = parseTimestamp(merged.completedAt);
+            if (startedAtMs !== undefined && completedAtMs !== undefined) {
+                merged.durationMs = Math.max(0, completedAtMs - startedAtMs);
+            }
+        }
+        byEventId.set(timing.eventId, merged);
+    }
+    return [...byEventId.values()];
+}
 export function messageTurnTimingsFromEvents(events) {
     const timings = new Map();
     const completedEventIds = [];

package/dist/signals/registry.js

@@ -1,6 +1,7 @@
 import { DEFAULT_TELEMETRY_STALE_THRESHOLD_MS } from "../core/telemetry-staleness.js";
 import { errorFromNode, isActiveSignalStatus, isTerminalSignalStatus, phaseForStatus, strongestStatus } from "./aggregate.js";
 import { createDefaultSignalProducers } from "./projector.js";
+import { summarizeSessionSignalStatus } from "./status.js";
 function now() { return new Date().toISOString(); }
 const DEFAULT_TERMINAL_SUCCESS_TTL_MS = 60_000;
 const DEFAULT_TERMINAL_ERROR_TTL_MS = 10 * 60_000;
@@ -226,6 +227,7 @@ export class InMemoryPiboSignalRegistry {
     sessionSnapshotById = new Map();
     queuedMessagesBySessionId = new Map();
     subscribersByRootId = new Map();
+    globalSubscribers = new Set();
     producers = createDefaultSignalProducers();
     constructor(options = {}) {
         this.options = options;
@@ -260,7 +262,7 @@ export class InMemoryPiboSignalRegistry {
             nodeCount: this.nodesById.size,
             sessionCount: this.rootSessionIdBySessionId.size,
             rootCount: this.versionByRootId.size,
-            subscriberCount: [...this.subscribersByRootId.values()].reduce((sum, listeners) => sum + listeners.size, 0),
+            subscriberCount: this.globalSubscribers.size + [...this.subscribersByRootId.values()].reduce((sum, listeners) => sum + listeners.size, 0),
             subscribersByRootId,
             stuckActiveNodes: [...this.nodesById.values()].filter((node) => isActiveSignalStatus(node.status) && nowMs - Date.parse(node.startedAt ?? node.createdAt) >= thresholdMs),
         };
@@ -322,6 +324,21 @@ export class InMemoryPiboSignalRegistry {
         }
         return { rootPiboSessionId: rootId, version, generatedAt: now(), sessions, nodes };
     }
+    snapshotStatuses() {
+        const sessions = {};
+        for (const piboSessionId of this.rootSessionIdBySessionId.keys()) {
+            const rootId = this.getSessionRoot(piboSessionId);
+            const version = this.versionByRootId.get(rootId) ?? 0;
+            const snapshot = this.sessionSnapshotById.get(piboSessionId) ?? this.computeSessionSnapshot(piboSessionId, version);
+            sessions[piboSessionId] = summarizeSessionSignalStatus(snapshot);
+        }
+        return {
+            type: "signal_status_snapshot",
+            generatedAt: now(),
+            rootVersions: Object.fromEntries(this.versionByRootId),
+            sessions,
+        };
+    }
     subscribe(rootPiboSessionId, listener) {
         const rootId = this.getSessionRoot(rootPiboSessionId);
         const listeners = this.subscribersByRootId.get(rootId) ?? new Set();
@@ -333,6 +350,10 @@ export class InMemoryPiboSignalRegistry {
                 this.subscribersByRootId.delete(rootId);
         };
     }
+    subscribeAll(listener) {
+        this.globalSubscribers.add(listener);
+        return () => this.globalSubscribers.delete(listener);
+    }
     context() {
         return {
             now,
@@ -547,6 +568,8 @@ export class InMemoryPiboSignalRegistry {
     notify(rootId, patch) {
         for (const listener of this.subscribersByRootId.get(rootId) ?? [])
             queueMicrotask(() => listener(patch));
+        for (const listener of this.globalSubscribers)
+            queueMicrotask(() => listener(patch));
     }
 }
 export function createPiboSignalRegistry(options) {

package/dist/signals/status.js

@@ -0,0 +1,12 @@
+export function summarizeSessionSignalStatus(snapshot) {
+    const isTurnActive = snapshot.latestTurn?.state === "running";
+    const hasError = snapshot.hasError || snapshot.hasErrorDescendant || snapshot.aggregateStatus === "error";
+    const isTreeActive = snapshot.isTreeActive || isTurnActive;
+    return {
+        piboSessionId: snapshot.piboSessionId,
+        rootPiboSessionId: snapshot.rootPiboSessionId,
+        updatedAt: snapshot.updatedAt,
+        status: isTreeActive ? "running" : hasError ? "error" : "idle",
+        isTreeActive,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "1.9.10",
+  "version": "1.9.13",
   "type": "module",
   "imports": {
     "vscode": "./src/apps/chat-vscode/extension/src/vscode-shim.js"