@pasko70/pibo 1.10.0 → 1.11.0

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-session/localSessionSource.js

@@ -29,6 +29,8 @@ export class LocalCliSessionSource {
     listeners = new Map();
     openHandles = new Set();
     closed = false;
+    closing = false;
+    closePromise;
     constructor(options = {}) {
         this.sessionStore =
             options.sessionStore ?? createDefaultPiboDataSessionStore();
@@ -349,19 +351,39 @@ export class LocalCliSessionSource {
         };
     }
     async close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closePromise = this.closeUnsafe();
+        return this.closePromise;
+    }
+    async closeUnsafe() {
         if (this.closed)
             return;
-        this.closed = true;
-        for (const handle of [...this.openHandles])
-            handle.close();
-        this.listeners.clear();
-        this.unsubscribeRouter?.();
-        if (this.ownsRouter)
-            await this.router?.disposeAll?.();
-        if (this.ownsSessionStore)
-            this.sessionStore.close?.();
-        if (this.ownsDataStore)
-            this.dataStore?.close();
+        this.closing = true;
+        let routerError;
+        try {
+            if (this.ownsRouter)
+                await this.router?.disposeAll?.();
+        }
+        catch (error) {
+            routerError = error;
+        }
+        try {
+            this.closed = true;
+            for (const handle of [...this.openHandles])
+                handle.close();
+            this.listeners.clear();
+            this.unsubscribeRouter?.();
+            if (this.ownsSessionStore)
+                this.sessionStore.close?.();
+            if (this.ownsDataStore)
+                this.dataStore?.close();
+        }
+        finally {
+            this.closing = false;
+        }
+        if (routerError)
+            throw routerError;
     }
     listenerCount(sessionId) {
         if (sessionId)
@@ -825,7 +847,7 @@ export class LocalCliSessionSource {
             listener(update);
     }
     assertOpen() {
-        if (this.closed)
+        if (this.closed || this.closing)
             throw new CliSourceError("source_closed", "Local CLI session source is closed");
     }
 }

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));
@@ -73,8 +74,16 @@ export function buildComputeResourceHealth(options = {}) {
             if (browserProcessMatchesPool(process, pool.state))
                 assignedMainPids.add(process.pid);
     }
-    const unassignedMainProcessDetails = mainProcesses
-        .filter((process) => !assignedMainPids.has(process.pid))
+    const activeWorkerOwnedMainPids = new Set(mainProcesses
+        .filter((process) => Boolean(findOwningActiveWorker(process, processes, workers)))
+        .map((process) => 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}`);
@@ -118,6 +127,8 @@ export function buildComputeResourceHealth(options = {}) {
             totalChromiumMainProcesses: mainProcesses.length,
             unassignedChromiumMainProcesses,
             unassignedMainProcessDetails,
+            exemptChromiumMainProcesses: exemptMainProcessDetails.length,
+            exemptMainProcessDetails,
             perWorker,
         },
         browserLeases: { active: activePoolIds.length, activePoolIds, staleCdpFiles },
@@ -148,6 +159,28 @@ function browserLeakMessage(unassignedCount) {
         return `${unassignedCount} unmanaged Chromium main process(es) are not associated with a managed browser pool.`;
     return "Chromium main-process count exceeds managed pool expectations.";
 }
+function findOwningActiveWorker(process, processes, workers) {
+    const containerId = process.containerId;
+    if (containerId && containerId.length >= 12) {
+        const byContainer = workers.find((worker) => worker.state === "running" && (worker.id === containerId || worker.id.startsWith(containerId) || containerId.startsWith(worker.id)));
+        if (byContainer)
+            return byContainer;
+    }
+    const activeWorkersByPid = new Map(workers
+        .filter((worker) => worker.state === "running" && worker.hostPid !== undefined && worker.hostPid > 1)
+        .map((worker) => [worker.hostPid, worker]));
+    const processByPid = new Map(processes.map((candidate) => [candidate.pid, candidate]));
+    const visited = new Set();
+    let current = process;
+    while (current && current.pid > 1 && !visited.has(current.pid)) {
+        visited.add(current.pid);
+        const direct = activeWorkersByPid.get(current.pid) ?? activeWorkersByPid.get(current.ppid);
+        if (direct)
+            return direct;
+        current = processByPid.get(current.ppid);
+    }
+    return undefined;
+}
 function describeUnassignedBrowserProcess(process, workers) {
     const worker = workers.find((candidate) => candidate.hostPid !== undefined && candidate.hostPid > 0 && candidate.hostPid === process.ppid);
     const userDataDir = readChromeArg(process.args, "user-data-dir");
@@ -173,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>")
@@ -199,6 +247,7 @@ export async function getComputeResourceHealth(options = {}) {
         browserPools,
         staleCdpFiles,
         reaperTimers: detectReaperTimerStatus(),
+        exemptBrowserUserDataDirs: options.exemptBrowserUserDataDirs,
     });
 }
 export function defaultBrowserUseHome() {
@@ -248,7 +297,12 @@ async function collectWorkers() {
 async function collectProcesses() {
     try {
         const { stdout } = await execFileAsync("ps", ["-eo", "pid=,ppid=,pgid=,etimes=,comm=,args="], { maxBuffer: 10 * 1024 * 1024 });
-        return { processes: parseProcessList(stdout) };
+        const processes = parseProcessList(stdout);
+        await Promise.all(processes.filter((process) => process.isChromium && process.isMainProcess).map(async (process) => {
+            const cgroup = await readFile(`/proc/${process.pid}/cgroup`, "utf8").catch(() => "");
+            process.containerId = parseDockerContainerIdFromCgroup(cgroup);
+        }));
+        return { processes };
     }
     catch (error) {
         return { processes: [], error: error instanceof Error ? error.message : String(error) };
@@ -299,6 +353,9 @@ function detectReaperTimerStatus() {
     }
     return readResourceReaperTimerStatus();
 }
+export function parseDockerContainerIdFromCgroup(value) {
+    return value.match(/(?:^|\/)docker[-/]([a-f0-9]{12,64})(?:\.scope|\/|$)/im)?.[1];
+}
 function browserProcessMatchesPool(process, state) {
     if (state.pid && process.pid === state.pid)
         return true;

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/events.js

@@ -1 +1,6 @@
-export {};
+export class PiboSteeringUnavailableError extends Error {
+    constructor(message = "The active session cannot accept steering right now.", options) {
+        super(message, options);
+        this.name = "PiboSteeringUnavailableError";
+    }
+}

package/dist/core/routed-session.js

@@ -1,4 +1,5 @@
 import { SessionManager, shouldCompact } from "@earendil-works/pi-coding-agent";
+import { PiboSteeringUnavailableError } from "./events.js";
 import { getOpenAiCodexProviderUsageForActiveModel } from "../auth/openai-codex-usage.js";
 import { normalizeSessionErrorDetails, runtimeSessionErrorDetails } from "./session-errors.js";
 import { expandInlineSkills } from "./skill-expansion.js";
@@ -422,6 +423,8 @@ export class RoutedSession {
     queue = [];
     processing = false;
     disposed = false;
+    disposePromise;
+    drainPromise;
     fastMode = false;
     fastModePatchedAgents = new WeakSet();
     activeMessage;
@@ -683,7 +686,32 @@ export class RoutedSession {
         };
         this.emit(output);
         this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: this.disposed });
-        void this.drain();
+        this.startDrain();
+        return output;
+    }
+    async steerMessage(event) {
+        this.assertActive();
+        const activeMessage = this.activeMessage;
+        if (!activeMessage || !this.processing || !this.runtime.session.isStreaming) {
+            throw new PiboSteeringUnavailableError();
+        }
+        const session = this.runtime.session;
+        const expandedText = expandInlineSkills(event.text, session.resourceLoader.getSkills().skills);
+        try {
+            await session.steer(expandedText);
+        }
+        catch (error) {
+            throw new PiboSteeringUnavailableError(`The active session could not accept steering: ${errorMessage(error)}`, { cause: error });
+        }
+        const output = {
+            type: "message_steered",
+            piboSessionId: this.piboSessionId,
+            eventId: event.id,
+            activeEventId: activeMessage.id,
+            text: event.text,
+            source: event.source,
+        };
+        this.emit(output);
         return output;
     }
     async executeAction(event) {
@@ -875,9 +903,26 @@ export class RoutedSession {
         return await this.runtime.session.compact(customInstructions);
     }
     async dispose() {
+        if (this.disposePromise)
+            return this.disposePromise;
+        this.disposePromise = this.disposeUnsafe();
+        return this.disposePromise;
+    }
+    async disposeUnsafe() {
         if (this.disposed)
             return;
+        const activeMessage = this.activeMessage;
         this.notifyMessagesInterrupted(this.activeAndQueuedMessages(), "session disposed");
+        if (activeMessage) {
+            const error = "Session disposed while a message was active.";
+            this.emit({
+                type: "session_error",
+                piboSessionId: this.piboSessionId,
+                eventId: activeMessage.id,
+                error,
+                errorDetails: runtimeSessionErrorDetails(error),
+            });
+        }
         this.cancelProviderRecovery();
         this.queue.length = 0;
         this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: true });
@@ -888,7 +933,15 @@ export class RoutedSession {
             this.recoverySession = undefined;
         }
         this.disposed = true;
-        await this.runtime.dispose();
+        const abort = this.runtime.session.abort;
+        if (abort)
+            await Promise.allSettled([abort.call(this.runtime.session)]);
+        try {
+            await this.drainPromise;
+        }
+        finally {
+            await this.runtime.dispose();
+        }
     }
     async kill() {
         this.notifyMessagesInterrupted(this.activeAndQueuedMessages(), "session killed");
@@ -918,6 +971,16 @@ export class RoutedSession {
         }
         return false;
     }
+    startDrain() {
+        if (this.drainPromise)
+            return;
+        const drain = this.drain();
+        this.drainPromise = drain;
+        void drain.finally(() => {
+            if (this.drainPromise === drain)
+                this.drainPromise = undefined;
+        });
+    }
     async drain() {
         if (this.processing || this.disposed)
             return;
@@ -974,7 +1037,7 @@ export class RoutedSession {
             }
         }
         catch (error) {
-            if (error instanceof PiboProviderRecoveryCancelledError)
+            if (error instanceof PiboProviderRecoveryCancelledError || this.disposed)
                 return;
             const message = errorMessage(error);
             this.emit({
@@ -1030,7 +1093,7 @@ export class RoutedSession {
         };
         this.emit(output);
         this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: this.disposed });
-        void this.drain();
+        this.startDrain();
         return output;
     }
     async runAction(event) {

package/dist/core/session-router.js

@@ -6,6 +6,7 @@ import { RoutedSession } from "./routed-session.js";
 import { runtimeSessionErrorDetails } from "./session-errors.js";
 import { createSubagentToolName } from "../subagents/tool.js";
 import { PiboRunRegistry } from "../runs/registry.js";
+import { PiboRunExecutionTimeoutError } from "../runs/lifecycle.js";
 import { createPiboSignalRegistry } from "../signals/registry.js";
 import { createDefaultPiboReliabilityStore } from "../reliability/store.js";
 import { InMemoryPiboSessionStore, } from "../sessions/store.js";
@@ -85,6 +86,15 @@ function formatRunReminderMessage(notification) {
                 toolName: run.toolName,
                 summary: run.summary,
             })),
+            timedOut: notification.timedOut.map((run) => ({
+                runId: run.runId,
+                kind: run.kind,
+                status: run.status,
+                toolName: run.toolName,
+                summary: run.summary,
+                timeoutMs: run.timeoutMs,
+                timeoutPhase: run.timeoutPhase,
+            })),
             cancelled: notification.cancelled.map((run) => ({
                 runId: run.runId,
                 kind: run.kind,
@@ -99,7 +109,7 @@ function formatRunReminderMessage(notification) {
                 toolName: run.toolName,
                 summary: run.summary,
             })),
-            instruction: "Use pibo_run_read for completed or failed runs. Use pibo_run_wait, pibo_run_status, pibo_run_cancel, or pibo_run_ack for runs you still need to manage.",
+            instruction: "Use pibo_run_read for completed, failed, or timed_out runs. Use pibo_run_wait, pibo_run_status, pibo_run_cancel, or pibo_run_ack for runs you still need to manage.",
         }),
         "</pibo_run_notification>",
     ].join("\n");
@@ -108,7 +118,7 @@ function isRunReminderServiceMessage(event) {
     return event.source === "service" && event.text.startsWith("<pibo_run_notification>");
 }
 function isTerminalRunStatus(status) {
-    return status === "completed" || status === "failed" || status === "cancelled";
+    return status === "completed" || status === "failed" || status === "timed_out" || status === "cancelled";
 }
 function asJsonObject(value) {
     return value ?? {};
@@ -212,7 +222,9 @@ export class PiboSessionRouter {
         this.clearIdleSessionTimer(event.piboSessionId);
         try {
             if (event.type === "message") {
-                return session.enqueueMessage(event);
+                return event.delivery === "steer"
+                    ? await session.steerMessage(event)
+                    : session.enqueueMessage(event);
             }
             if (event.action === "abort") {
                 this.signalRegistry.project({ type: "session_interrupted", piboSessionId: event.piboSessionId, reason: "abort action" });
@@ -232,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);
         }
@@ -667,7 +696,7 @@ export class PiboSessionRouter {
     }
     createRunToolController(parentPiboSessionId) {
         return {
-            startToolRun: ({ toolName, params, completionPolicy, retryable, maxAttempts, execute }) => {
+            startToolRun: ({ toolName, params, completionPolicy, retryable, maxAttempts, timeoutMs, serviceWarning, execute }) => {
                 assertGatewayResourceAvailableForWork(`yielded run ${toolName}`);
                 const run = this.runRegistry.startToolRun({
                     controllerPiboSessionId: parentPiboSessionId,
@@ -676,6 +705,8 @@ export class PiboSessionRouter {
                     completionPolicy,
                     retryable,
                     maxAttempts,
+                    timeoutMs,
+                    serviceWarning,
                 });
                 void (async () => {
                     try {
@@ -685,8 +716,11 @@ export class PiboSessionRouter {
                             this.scheduleRunReminder(parentPiboSessionId, false);
                     }
                     catch (error) {
-                        const failed = this.runRegistry.fail(run.runId, error instanceof Error ? error.message : String(error));
-                        if (failed)
+                        const message = error instanceof Error ? error.message : String(error);
+                        const terminalRun = error instanceof PiboRunExecutionTimeoutError
+                            ? this.runRegistry.timeOut(run.runId, message, error.timeoutPhase)
+                            : this.runRegistry.fail(run.runId, message);
+                        if (terminalRun)
                             this.scheduleRunReminder(parentPiboSessionId, false);
                     }
                 })();

package/dist/data/ingest-service.js

@@ -303,7 +303,7 @@ function payloadForOutputEvent(event) {
 function previewTextForOutputEvent(event) {
     if (event.type === "assistant_message" || event.type === "assistant_delta" || event.type === "thinking_delta" || event.type === "thinking_finished")
         return previewText(event.text ?? "");
-    if (event.type === "message_queued" || event.type === "message_started")
+    if (event.type === "message_queued" || event.type === "message_steered" || event.type === "message_started")
         return previewText(event.text);
     if (event.type === "tool_call" || event.type === "tool_execution_started" || event.type === "tool_execution_updated" || event.type === "tool_execution_finished")
         return event.toolName;
@@ -320,6 +320,8 @@ function previewTextForOutputEvent(event) {
 function attributesForOutputEvent(event) {
     if (event.type === "message_queued")
         return { inlineText: event.text, source: event.source, queuedMessages: event.queuedMessages };
+    if (event.type === "message_steered")
+        return { inlineText: event.text, source: event.source, activeEventId: event.activeEventId };
     if (event.type === "assistant_message" || event.type === "assistant_delta")
         return { assistantIndex: event.assistantIndex, contentIndex: event.contentIndex };
     if (event.type === "thinking_started" || event.type === "thinking_delta" || event.type === "thinking_finished")

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/index.js

@@ -985,6 +985,10 @@ function compactRunRow(run) {
         policy: run.completionPolicy,
         consumed: run.consumed,
         updatedAt: run.updatedAt,
+        timeoutMs: run.timeoutMs,
+        timeoutAt: run.timeoutAt,
+        timeoutPhase: run.timeoutPhase,
+        serviceWarning: run.serviceWarning,
         summary: run.summary,
     };
 }