@pasko70/pibo 1.10.1 → 1.11.1

package/dist/auth/machine-session.js

@@ -0,0 +1,123 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+export const PIBO_MACHINE_SESSION_COOKIE = "pibo_machine_session";
+export const DEFAULT_MACHINE_SESSION_TTL_SECONDS = 8 * 60 * 60;
+const MACHINE_SESSION_VERSION = 1;
+const MAX_COOKIE_VALUE_LENGTH = 1024;
+function signPayload(secret, encodedPayload) {
+    return createHmac("sha256", secret).update(encodedPayload, "utf8").digest();
+}
+function encodePayload(secret, payload) {
+    const encodedPayload = Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+    const signature = signPayload(secret, encodedPayload).toString("base64url");
+    return `${encodedPayload}.${signature}`;
+}
+function decodePayload(secret, value) {
+    if (value.length === 0 || value.length > MAX_COOKIE_VALUE_LENGTH)
+        return undefined;
+    const parts = value.split(".");
+    if (parts.length !== 2 || !parts[0] || !parts[1])
+        return undefined;
+    let providedSignature;
+    try {
+        providedSignature = Buffer.from(parts[1], "base64url");
+    }
+    catch {
+        return undefined;
+    }
+    const expectedSignature = signPayload(secret, parts[0]);
+    if (providedSignature.length !== expectedSignature.length ||
+        !timingSafeEqual(providedSignature, expectedSignature)) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(Buffer.from(parts[0], "base64url").toString("utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return undefined;
+        const payload = parsed;
+        if (payload.v !== MACHINE_SESSION_VERSION ||
+            typeof payload.keyId !== "string" ||
+            !/^[a-f0-9]{16}$/.test(payload.keyId) ||
+            typeof payload.expiresAt !== "number" ||
+            !Number.isSafeInteger(payload.expiresAt)) {
+            return undefined;
+        }
+        return { v: MACHINE_SESSION_VERSION, keyId: payload.keyId, expiresAt: payload.expiresAt };
+    }
+    catch {
+        return undefined;
+    }
+}
+function cookieValue(headers) {
+    const cookieHeader = headers.get("cookie");
+    if (!cookieHeader)
+        return undefined;
+    for (const part of cookieHeader.split(";")) {
+        const separator = part.indexOf("=");
+        if (separator < 0)
+            continue;
+        const name = part.slice(0, separator).trim();
+        if (name !== PIBO_MACHINE_SESSION_COOKIE)
+            continue;
+        return part.slice(separator + 1).trim();
+    }
+    return undefined;
+}
+function sessionCookieHeader(value, expiresAt, maxAgeSeconds) {
+    return [
+        `${PIBO_MACHINE_SESSION_COOKIE}=${value}`,
+        "Path=/",
+        "HttpOnly",
+        "Secure",
+        "SameSite=Strict",
+        `Max-Age=${maxAgeSeconds}`,
+        `Expires=${expiresAt.toUTCString()}`,
+    ].join("; ");
+}
+export function createMachineSessionManager(options) {
+    const ttlSeconds = options.ttlSeconds ?? DEFAULT_MACHINE_SESSION_TTL_SECONDS;
+    if (!Number.isInteger(ttlSeconds) || ttlSeconds < 1) {
+        throw new Error("Machine session TTL must be a positive integer");
+    }
+    const now = options.now ?? (() => new Date());
+    return {
+        create(authentication) {
+            const createdAt = now();
+            const ttlExpiry = createdAt.getTime() + ttlSeconds * 1000;
+            const keyExpiry = authentication.session.expiresAt?.getTime();
+            const expiryMs = keyExpiry === undefined ? ttlExpiry : Math.min(ttlExpiry, keyExpiry);
+            if (expiryMs <= createdAt.getTime())
+                throw new Error("Machine key is expired");
+            const expiresAt = new Date(expiryMs);
+            const value = encodePayload(options.secret, {
+                v: MACHINE_SESSION_VERSION,
+                keyId: authentication.id,
+                expiresAt: expiryMs,
+            });
+            return {
+                header: sessionCookieHeader(value, expiresAt, Math.max(1, Math.floor((expiryMs - createdAt.getTime()) / 1000))),
+                expiresAt,
+                session: { ...authentication.session, expiresAt },
+            };
+        },
+        getSession(headers) {
+            const value = cookieValue(headers);
+            if (!value)
+                return undefined;
+            const payload = decodePayload(options.secret, value);
+            const currentTime = now().getTime();
+            if (!payload || payload.expiresAt <= currentTime)
+                return undefined;
+            const keySession = options.machineKeys.getSessionById(payload.keyId);
+            if (!keySession)
+                return undefined;
+            const keyExpiry = keySession.expiresAt?.getTime();
+            const effectiveExpiry = keyExpiry === undefined ? payload.expiresAt : Math.min(payload.expiresAt, keyExpiry);
+            if (effectiveExpiry <= currentTime)
+                return undefined;
+            return { ...keySession, expiresAt: new Date(effectiveExpiry) };
+        },
+        clearHeader() {
+            return sessionCookieHeader("", new Date(0), 0);
+        },
+    };
+}

package/dist/cli.js

@@ -80,6 +80,11 @@ export async function runPiboCli(argv = process.argv) {
         printPiboVersion();
         return;
     }
+    if (argv[2] === "auth") {
+        const { runAuthCli } = await import("./auth/cli.js");
+        await runAuthCli([argv[0] ?? "node", "pibo auth", ...argv.slice(3)]);
+        return;
+    }
     if (argv[2] === "mcp") {
         const { runMcpCli } = await import("./mcp/index.js");
         await runMcpCli([argv[0] ?? "node", "pibo mcp", ...argv.slice(3)]);
@@ -465,6 +470,7 @@ function printRootDiscoveryText() {
 
 Commands:
   config       Manage local pibo config
+  auth         Manage Web authentication and machine identities
   mcp          Discover and call configured MCP servers
   tools        Install and inspect curated external CLI tools
   pi-packages  Register Pi Coding Agent packages

package/dist/compute/cli.js

@@ -123,6 +123,13 @@ export function renderComputeResourceHealthText(health) {
     const lines = [`Compute resource health: ${health.severity} (read-only)`];
     lines.push(`Generated at: ${health.generatedAt}`);
     lines.push(`Browser processes: ${health.browserProcesses.totalChromiumMainProcesses} main / ${health.browserProcesses.totalChromiumProcesses} total Chromium processes`);
+    if (health.browserProcesses.exemptMainProcessDetails.length > 0) {
+        lines.push(`Explicitly exempt browser main processes: ${health.browserProcesses.exemptMainProcessDetails.length}`);
+        lines.push("PID\tUSER_DATA_DIR\tCOMMAND");
+        for (const process of health.browserProcesses.exemptMainProcessDetails.slice(0, 5)) {
+            lines.push(`${process.pid}\t${process.userDataDir ?? "-"}\t${process.commandName}`);
+        }
+    }
     if (health.browserProcesses.unassignedMainProcessDetails.length > 0) {
         lines.push(`Unmanaged browser main processes: ${health.browserProcesses.unassignedMainProcessDetails.length}`);
         lines.push("PID\tWORKER\tUSER_DATA_DIR\tCOMMAND");

package/dist/compute/resource-health.js

@@ -2,7 +2,7 @@ import { execFile } from "node:child_process";
 import { existsSync } from "node:fs";
 import { readdir, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { basename, join } from "node:path";
+import { basename, isAbsolute, join, resolve } from "node:path";
 import { promisify } from "node:util";
 import { readResourceReaperTimerStatus } from "../resources/reaper-state.js";
 import { createEmptyBrowserPoolState, normalizeBrowserPoolState } from "../tools/browser-pool.js";
@@ -43,6 +43,7 @@ export function buildComputeResourceHealth(options = {}) {
     const disk = options.disk;
     const checks = [];
     const mainProcesses = processes.filter((process) => process.isChromium && process.isMainProcess);
+    const exemptBrowserUserDataDirs = new Set(normalizeBrowserUserDataDirs(options.exemptBrowserUserDataDirs ?? readExemptBrowserUserDataDirs()));
     const perWorker = browserPools.map(({ state, statePath }) => {
         const activeLeaseCount = state.activeLeaseId ? Math.max(1, state.activeLeaseCount ?? 1) : state.activeLeaseCount ?? 0;
         const matched = mainProcesses.filter((process) => browserProcessMatchesPool(process, state));
@@ -76,8 +77,13 @@ export function buildComputeResourceHealth(options = {}) {
     const activeWorkerOwnedMainPids = new Set(mainProcesses
         .filter((process) => Boolean(findOwningActiveWorker(process, processes, workers)))
         .map((process) => process.pid));
-    const unassignedMainProcessDetails = mainProcesses
-        .filter((process) => !assignedMainPids.has(process.pid) && !activeWorkerOwnedMainPids.has(process.pid))
+    const unmatchedMainProcesses = mainProcesses
+        .filter((process) => !assignedMainPids.has(process.pid) && !activeWorkerOwnedMainPids.has(process.pid));
+    const exemptMainProcessDetails = unmatchedMainProcesses
+        .filter((process) => browserProcessMatchesExemptUserDataDir(process, exemptBrowserUserDataDirs))
+        .map((process) => describeUnassignedBrowserProcess(process, workers));
+    const unassignedMainProcessDetails = unmatchedMainProcesses
+        .filter((process) => !browserProcessMatchesExemptUserDataDir(process, exemptBrowserUserDataDirs))
         .map((process) => describeUnassignedBrowserProcess(process, workers));
     const unassignedChromiumMainProcesses = unassignedMainProcessDetails.length;
     const activePoolIds = perWorker.filter((pool) => pool.activeLeaseCount > 0).map((pool) => `${pool.workerId}/${pool.poolId}`);
@@ -121,6 +127,8 @@ export function buildComputeResourceHealth(options = {}) {
             totalChromiumMainProcesses: mainProcesses.length,
             unassignedChromiumMainProcesses,
             unassignedMainProcessDetails,
+            exemptChromiumMainProcesses: exemptMainProcessDetails.length,
+            exemptMainProcessDetails,
             perWorker,
         },
         browserLeases: { active: activePoolIds.length, activePoolIds, staleCdpFiles },
@@ -198,6 +206,21 @@ function readChromeArg(args, name) {
     const pattern = new RegExp(`(?:^|\\s)--${name}=([^\\s]+)`);
     return args.match(pattern)?.[1];
 }
+function readExemptBrowserUserDataDirs() {
+    return (process.env.PIBO_RESOURCE_REAPER_EXEMPT_BROWSER_USER_DATA_DIRS ?? "").split(",");
+}
+function normalizeBrowserUserDataDirs(values) {
+    return [...new Set([...values]
+            .map((value) => value.trim())
+            .filter((value) => value.length > 0 && isAbsolute(value))
+            .map((value) => resolve(value)))];
+}
+function browserProcessMatchesExemptUserDataDir(process, exemptions) {
+    const userDataDir = readChromeArg(process.args, "user-data-dir");
+    if (!userDataDir || !isAbsolute(userDataDir))
+        return false;
+    return exemptions.has(resolve(userDataDir));
+}
 function sanitizeArgsPreview(args) {
     const redacted = args
         .replace(/(token|access_token|refresh_token|password|passwd|cookie|secret)=([^\s]+)/gi, "$1=<redacted>")
@@ -224,6 +247,7 @@ export async function getComputeResourceHealth(options = {}) {
         browserPools,
         staleCdpFiles,
         reaperTimers: detectReaperTimerStatus(),
+        exemptBrowserUserDataDirs: options.exemptBrowserUserDataDirs,
     });
 }
 export function defaultBrowserUseHome() {

package/dist/config/config.js

@@ -43,6 +43,11 @@ export const PIBO_CONFIG_KEYS = [
         type: "string",
         description: "SQLite path for Better Auth data.",
     },
+    {
+        key: "auth.machineKeyStorePath",
+        type: "string",
+        description: "Optional path for revocable machine-key records. Default $PIBO_HOME/machine-keys.json.",
+    },
     {
         key: "auth.mode",
         type: "string",

package/dist/core/session-router.js

@@ -244,6 +244,23 @@ export class PiboSessionRouter {
             }
             return output;
         }
+        catch (error) {
+            if (event.type === "message" && event.id) {
+                this.signalRegistry.project({
+                    type: "message_rejected",
+                    piboSessionId: event.piboSessionId,
+                    eventId: event.id,
+                });
+                const status = session.getStatus();
+                this.signalRegistry.project({
+                    type: "session_processing_changed",
+                    piboSessionId: event.piboSessionId,
+                    processing: status.processing,
+                    queuedMessages: status.queuedMessages,
+                });
+            }
+            throw error;
+        }
         finally {
             this.scheduleIdleSessionEvictionIfIdle(event.piboSessionId);
         }

package/dist/data/schema.js

@@ -354,6 +354,10 @@ export function applyPiboDataSchema(db) {
 			ON sessions(channel, kind, updated_at DESC);
 		CREATE INDEX IF NOT EXISTS idx_event_log_session_stream
 			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';
 		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

package/dist/debug/trace-status.js

@@ -0,0 +1,25 @@
+export function resolveDebugTraceSessionStatus(sessionStatus, eventTypes) {
+    for (let index = eventTypes.length - 1; index >= 0; index -= 1) {
+        switch (eventTypes[index]) {
+            case "session_error":
+                return { status: "error", source: "event-log" };
+            case "message_started":
+                return { status: "running", source: "event-log" };
+            case "message_finished":
+                return { status: "idle", source: "event-log" };
+        }
+    }
+    return {
+        status: sessionStatus === "running" || sessionStatus === "error" ? sessionStatus : "idle",
+        source: "session-store",
+    };
+}
+export function summarizeDebugTraceStatus(sessionStatus, nodeStatuses) {
+    const errorNodeCount = nodeStatuses.filter((status) => status === "error").length;
+    if (sessionStatus === "error")
+        return { status: "error", errorNodeCount };
+    if (sessionStatus === "running" || nodeStatuses.some((status) => status === "running")) {
+        return { status: "running", errorNodeCount };
+    }
+    return { status: "done", errorNodeCount };
+}

package/dist/debug/trace.js

@@ -3,6 +3,7 @@ import { normalizeSessionErrorDetails } from "../core/session-errors.js";
 import { compareTraceNodes } from "../shared/trace-nodes.js";
 import { openReadOnlyDebugDatabase, withStorePath } from "./sql.js";
 import { formatNextCommands } from "./next-commands.js";
+import { resolveDebugTraceSessionStatus, summarizeDebugTraceStatus } from "./trace-status.js";
 export async function inspectDebugTrace(piboSessionId, stores, options = {}) {
     if (!stores.sessions.exists)
         throw new Error(`Debug store "sessions" not found at ${stores.sessions.path}`);
@@ -22,19 +23,23 @@ export async function inspectDebugTrace(piboSessionId, stores, options = {}) {
                 .prepare("SELECT stream_id, session_id, session_sequence, event_id, type, created_at, preview_text, attributes_json FROM event_log WHERE session_id = ? ORDER BY stream_id ASC")
                 .all(piboSessionId).map((row) => eventFromRow(row, adapterIssues)).filter((event) => event !== undefined)
             : [];
+        const sessionStatus = resolveDebugTraceSessionStatus(sessionRow.status, events.map((event) => event.type));
         const view = await buildTraceView({
             session,
             sessions,
             events,
-            status: sessionRow.status === "running" || sessionRow.status === "error" ? sessionRow.status : "idle",
+            status: sessionStatus.status,
         });
         const rows = flattenTraceNodes(view.nodes);
+        const statusSummary = summarizeDebugTraceStatus(sessionStatus.status, rows.map((node) => node.status));
         const filtered = options.runningOnly ? rows.filter((node) => node.status === "running") : rows;
         return {
             piboSessionId: view.piboSessionId,
             piSessionId: view.piSessionId,
             title: view.title,
-            status: traceStatus(view),
+            status: statusSummary.status,
+            statusSource: sessionStatus.source,
+            errorNodeCount: statusSummary.errorNodeCount,
             nodes: filtered,
             rawNodeCount: rows.length,
             ...(options.check ? { checks: checkTraceView(view, adapterIssues) } : {}),
@@ -69,6 +74,8 @@ export function formatDebugTrace(result, options = {}) {
         `piSessionId: ${result.piSessionId}`,
         `title: ${result.title}`,
         `status: ${result.status}`,
+        `statusSource: ${result.statusSource}`,
+        `nodeErrors: ${result.errorNodeCount}`,
         "",
     ];
     if (result.nodes.length === 0) {
@@ -161,14 +168,6 @@ function flattenTraceNodes(nodes, depth = 0) {
         ...flattenTraceNodes(node.children, depth + 1),
     ]);
 }
-function traceStatus(view) {
-    const rows = flattenTraceNodes(view.nodes);
-    if (rows.some((node) => node.status === "error"))
-        return "error";
-    if (rows.some((node) => node.status === "running"))
-        return "running";
-    return "done";
-}
 export function checkTraceView(view, adapterIssues = []) {
     const issues = [...adapterIssues];
     const all = flattenPiboTraceNodes(view.nodes);

package/dist/resources/cli.js

@@ -1,3 +1,4 @@
+import { isAbsolute, resolve } from "node:path";
 import { Command } from "commander";
 import { getComputeResourceHealth } from "../compute/resource-health.js";
 import { renderComputeResourceHealthText } from "../compute/cli.js";
@@ -17,6 +18,15 @@ function parsePidList(value) {
         throw new Error("PIDs must be positive integers separated by commas");
     return [...new Set(pids)];
 }
+function parseAbsolutePathList(value) {
+    const paths = value.split(",").map((item) => item.trim());
+    if (paths.some((path) => !path || !isAbsolute(path)))
+        throw new Error("Browser user-data directories must be absolute paths separated by commas");
+    return [...new Set(paths.map((path) => resolve(path)))];
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
 export function renderResourceLeasesText(leases) {
     if (leases.length === 0)
         return "No active managed browser-pool leases.\nNext: pibo resources status";
@@ -53,6 +63,10 @@ export function renderResourceReapText(value) {
         ];
         if (plan.options.includeDev)
             args.push("--include-dev");
+        if (plan.options.exemptBrowserPids.length > 0)
+            args.push(`--exempt-browser-pids ${plan.options.exemptBrowserPids.join(",")}`);
+        if (plan.options.exemptBrowserUserDataDirs.length > 0)
+            args.push(`--exempt-browser-user-data-dirs ${shellQuote(plan.options.exemptBrowserUserDataDirs.join(","))}`);
         if (plan.options.browserPoolRoot)
             args.push(`--browser-pool-root ${plan.options.browserPoolRoot}`);
         if (plan.options.browserUseHome)
@@ -118,6 +132,7 @@ export async function runResourcesCli(argv) {
         .option("--idle-timeout-minutes <n>", "Select browser pools idle for this many minutes", parseNonNegativeNumber, 10)
         .option("--unmanaged-browser-grace-minutes <n>", "Select unmanaged Chromium older than this many minutes", parseNonNegativeNumber, 10)
         .option("--exempt-browser-pids <list>", "Comma-separated browser PIDs or process groups to preserve", parsePidList)
+        .option("--exempt-browser-user-data-dirs <list>", "Comma-separated absolute browser profile directories to preserve", parseAbsolutePathList)
         .option("--browser-pool-root <path>", "Browser pool root directory to scan")
         .option("--browser-use-home <path>", "Browser-use home directory to scan for stale CDP files")
         .option("--json", "Print machine-readable cleanup plan or result")

package/dist/resources/lifecycle.js

@@ -1,7 +1,7 @@
 import { execFile } from "node:child_process";
 import { existsSync } from "node:fs";
 import { readdir, readFile, rm } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 import { promisify } from "node:util";
 import { applyComputeWorkerReapPlan, buildComputeWorkerReapPlan, planReapWorkers, } from "../compute/docker.js";
 import { defaultBrowserPoolRoot, defaultBrowserUseHome, getComputeResourceHealth, parseProcessList, } from "../compute/resource-health.js";
@@ -60,9 +60,14 @@ export async function planResourceReap(options = {}) {
         collectManagedBrowserPools(resolved.browserPoolRoot),
         planStaleCdpFiles(resolved.browserUseHome),
         planComputeReapSafely({ includeDev: resolved.includeDev, maxAgeMinutes: resolved.maxAgeMinutes, now }),
-        getComputeResourceHealth({ now, browserPoolRoot: resolved.browserPoolRoot, browserUseHome: resolved.browserUseHome }),
+        getComputeResourceHealth({
+            now,
+            browserPoolRoot: resolved.browserPoolRoot,
+            browserUseHome: resolved.browserUseHome,
+            exemptBrowserUserDataDirs: [],
+        }),
     ]);
-    const unmanagedBrowsers = buildUnmanagedBrowserPlanItems(health.browserProcesses.unassignedMainProcessDetails, resolved.unmanagedBrowserGraceMinutes, new Set(resolved.exemptBrowserPids));
+    const unmanagedBrowsers = buildUnmanagedBrowserPlanItems(health.browserProcesses.unassignedMainProcessDetails, resolved.unmanagedBrowserGraceMinutes, new Set(resolved.exemptBrowserPids), new Set(resolved.exemptBrowserUserDataDirs));
     return buildResourceReapPlan({ now, options: resolved, records, staleFiles, unmanagedBrowsers, compute });
 }
 export function buildResourceReapPlan(input) {
@@ -126,9 +131,10 @@ function resolveReapOptions(options) {
         browserPoolRoot: options.browserPoolRoot ?? defaultBrowserPoolRoot(),
         browserUseHome: options.browserUseHome ?? defaultBrowserUseHome(),
         exemptBrowserPids: options.exemptBrowserPids ?? readExemptBrowserPids(),
+        exemptBrowserUserDataDirs: normalizeBrowserUserDataDirs(options.exemptBrowserUserDataDirs ?? readExemptBrowserUserDataDirs()),
     };
 }
-export function buildUnmanagedBrowserPlanItems(processes, graceMinutes, exemptPids = new Set()) {
+export function buildUnmanagedBrowserPlanItems(processes, graceMinutes, exemptPids = new Set(), exemptUserDataDirs = new Set()) {
     const graceSeconds = graceMinutes * 60;
     return processes.map((process) => {
         let action = "terminate";
@@ -141,6 +147,10 @@ export function buildUnmanagedBrowserPlanItems(processes, graceMinutes, exemptPi
             action = "skip";
             reason = "explicitly exempted pid or process group";
         }
+        else if (browserUserDataDirIsExempt(process.userDataDir, exemptUserDataDirs)) {
+            action = "skip";
+            reason = "explicitly exempted browser user-data-dir";
+        }
         else if (process.elapsedSeconds !== undefined && process.elapsedSeconds < graceSeconds) {
             action = "skip";
             reason = `process age ${process.elapsedSeconds}s is within ${graceSeconds}s grace period`;
@@ -211,6 +221,20 @@ function readExemptBrowserPids() {
         .map((value) => Number.parseInt(value.trim(), 10))
         .filter((value) => Number.isInteger(value) && value > 0);
 }
+function readExemptBrowserUserDataDirs() {
+    return (process.env.PIBO_RESOURCE_REAPER_EXEMPT_BROWSER_USER_DATA_DIRS ?? "").split(",");
+}
+function normalizeBrowserUserDataDirs(values) {
+    return [...new Set([...values]
+            .map((value) => value.trim())
+            .filter((value) => value.length > 0 && isAbsolute(value))
+            .map((value) => resolve(value)))];
+}
+function browserUserDataDirIsExempt(userDataDir, exemptions) {
+    if (!userDataDir || !isAbsolute(userDataDir))
+        return false;
+    return exemptions.has(resolve(userDataDir));
+}
 function buildBrowserReapPlanItem(record, now, idleTimeoutMinutes) {
     const { state } = record;
     let action = "skip";

package/dist/resources/reaper.js

@@ -76,6 +76,7 @@ export class ResourceReaperService {
                 browserPoolRoot: this.options.browserPoolRoot,
                 browserUseHome: this.options.browserUseHome,
                 exemptBrowserPids: this.options.exemptBrowserPids,
+                exemptBrowserUserDataDirs: this.options.exemptBrowserUserDataDirs,
                 now: runAt,
             });
             result = await this.apply(plan);

package/dist/session-ui/terminalRows.js

@@ -205,6 +205,7 @@ function createUserMessageRow(node) {
         lines: [{ prefix: "prompt", tokens: [token(text)] }],
         sourceNodeIds: [node.id],
         forkEntryId: node.entryId,
+        pendingMessageDelivery: pendingUserMessageDelivery(node),
         startedAt: node.startedAt,
         output: text,
         payloadRefs: node.payloadRefs,
@@ -1193,6 +1194,15 @@ function delegationVerb(status) {
         return "Spawn failed";
     return "Spawned";
 }
+function pendingUserMessageDelivery(node) {
+    if (node.status !== "running")
+        return undefined;
+    if (node.id.startsWith("event:message_steered:"))
+        return "steer";
+    if (node.id.startsWith("event:message_queued:"))
+        return "queue";
+    return undefined;
+}
 function asyncVerb(status) {
     if (status === "running")
         return "Waiting for";

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

@@ -42,6 +42,14 @@ export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent,
     const node = traceNodeFromEvent(piboSessionId, payload, childByParent, linkedChildByToolCallId, sessionStatus, storedEvent.createdAt, storedEvent.eventSequence, storedEvent.streamId, storedEvent.streamFrameIndex);
     if (!node)
         return;
+    if (node.type === "user.message" &&
+        node.status === "running" &&
+        !node.parentId &&
+        payload.type === "message_steered") {
+        const activeTurn = [...byId.values()].reverse().find((candidate) => candidate.type === "agent.turn" && candidate.status === "running");
+        if (activeTurn)
+            node.parentId = activeTurn.id;
+    }
     if (node.type === "agent.turn" && node.eventId) {
         const existingTurn = [...byId.values()].find((candidate) => candidate.type === "agent.turn" && candidate.eventId === node.eventId);
         if (existingTurn) {
@@ -94,8 +102,12 @@ export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent,
     if (node.eventId) {
         const existing = byId.get(node.id);
         if (existing) {
-            if (node.type === "user.message" && node.parentId)
-                existing.parentId = node.parentId;
+            if (node.type === "user.message") {
+                existing.status = node.status;
+                existing.parentId = node.parentId ?? existing.parentId;
+                existing.summary = node.summary ?? existing.summary;
+                existing.output = node.output ?? existing.output;
+            }
             return;
         }
     }
@@ -297,7 +309,7 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
                 ...(event.type === "message_steered" && event.activeEventId ? { parentId: messageTurnNodeId(event.activeEventId) } : {}),
                 type: "user.message",
                 title: "User Message",
-                status: "done",
+                status: isOptimisticUserMessageEvent(event) ? "running" : "done",
                 summary: event.text,
                 output: event.text,
             };
@@ -538,6 +550,11 @@ function mergeReasoningEvent(target, update) {
     target.output = update.output ?? target.output;
     target.completedAt = update.completedAt ?? target.completedAt;
 }
+function isOptimisticUserMessageEvent(event) {
+    return ((event.type === "message_queued" || event.type === "message_steered") &&
+        "clientTxnId" in event &&
+        typeof event.clientTxnId === "string");
+}
 function isInternalSessionOperation(action) {
     return action === "session.fork" || action === "session.clone" || action === "session.switch";
 }

package/dist/shared/trace-transcript.js

@@ -181,6 +181,7 @@ function createAssistantTurnNodes(piboSessionId, entries, timing) {
         return [];
     const orderedNodes = [];
     const toolsByCallId = new Map();
+    let assistantIndex = 0;
     for (const { entry, index: entryIndex } of entries) {
         if (messageRole(entry) === "toolResult") {
             mergePersistedToolResult(toolsByCallId, orderedNodes, entry, piboSessionId, entryIndex);
@@ -224,6 +225,9 @@ function createAssistantTurnNodes(piboSessionId, entries, timing) {
         if (responseNode) {
             responseNode.status = responseStatus;
             responseNode.error = responseError;
+            if (timing?.eventId)
+                responseNode.stableKey = `assistant:${timing.eventId}:assistant:${assistantIndex}`;
+            assistantIndex += 1;
         }
     }
     const finalNode = orderedNodes.at(-1);

package/dist/signals/projector.js

@@ -28,7 +28,7 @@ function settleActiveSessionNodes(piboSessionId, context, status, terminalSource
 }
 export const sessionLifecycleSignalProducer = {
     name: "session-lifecycle",
-    accepts: (input) => ["session_created", "session_disposed", "session_processing_changed", "message_accepted", "queue_changed", "recovery", "session_interrupted", "signal_node_pruned"].includes(input.type),
+    accepts: (input) => ["session_created", "session_disposed", "session_processing_changed", "message_accepted", "message_rejected", "queue_changed", "recovery", "session_interrupted", "signal_node_pruned"].includes(input.type),
     project(input, context) {
         const data = input;
         if (data.type === "session_created") {
@@ -78,6 +78,15 @@ export const sessionLifecycleSignalProducer = {
             }
             return mutations;
         }
+        if (data.type === "message_rejected") {
+            const acceptedTurn = context.getNode(`turn:${data.piboSessionId}:${data.eventId}`);
+            return [
+                { type: "remove_node", nodeId: `message:${data.piboSessionId}:${data.eventId}` },
+                ...(acceptedTurn?.metadata?.accepted === true
+                    ? [{ type: "remove_node", nodeId: acceptedTurn.id }]
+                    : []),
+            ];
+        }
         if (data.type === "session_disposed") {
             return [
                 ...settleActiveSessionNodes(data.piboSessionId, context, "cancelled", "session_disposed"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "1.10.1",
+  "version": "1.11.1",
   "type": "module",
   "imports": {
     "vscode": "./src/apps/chat-vscode/extension/src/vscode-shim.js"
@@ -57,8 +57,6 @@
     "@earendil-works/pi-ai": "0.80.6",
     "@earendil-works/pi-coding-agent": "0.80.6",
     "@earendil-works/pi-tui": "0.80.6",
-    "@langchain/core": "^1.2.3",
-    "@langchain/langgraph": "^1.4.8",
     "@mdxeditor/editor": "^3.55.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@tailwindcss/vite": "^4.2.4",
@@ -79,8 +77,7 @@
     "react-markdown": "^10.1.0",
     "react-virtuoso": "^4.18.6",
     "remark-gfm": "^4.0.1",
-    "tailwindcss": "^4.2.4",
-    "zod": "4.4.1"
+    "tailwindcss": "^4.2.4"
   },
   "devDependencies": {
     "@tanstack/router-plugin": "^1.167.28",
@@ -91,6 +88,7 @@
     "@vitejs/plugin-react": "^6.0.1",
     "@vscode/vsce": "^3.6.0",
     "esbuild": "^0.27.7",
+    "react-test-renderer": "19.2.5",
     "tsx": "^4.21.0",
     "typescript": "^6.0.3",
     "vite": "^8.0.10",