@pasko70/pibo 1.10.0 → 1.10.1

package/dist/shared/trace-page-merge.js

@@ -23,6 +23,21 @@ export function mergeOlderTracePage(current, older) {
         eventLimit: (current.eventLimit ?? 0) + (older.eventLimit ?? older.pageSize ?? 0),
     };
 }
+export function mergeRefreshedTracePage(current, refreshed) {
+    if (current.piboSessionId !== refreshed.piboSessionId)
+        return refreshed;
+    return {
+        ...refreshed,
+        nodes: mergeTraceNodes(current.nodes, refreshed.nodes),
+        rawEvents: current.rawEvents.length ? current.rawEvents : refreshed.rawEvents,
+        beforeCursor: current.beforeCursor,
+        firstEventSequence: current.firstEventSequence ?? refreshed.firstEventSequence,
+        nextBeforeSequence: current.nextBeforeSequence,
+        nextBeforeCursor: current.nextBeforeCursor,
+        hasOlderEvents: current.hasOlderEvents,
+        eventLimit: current.eventLimit ?? refreshed.eventLimit,
+    };
+}
 function mergeTraceNodes(olderNodes, currentNodes) {
     const byId = new Map();
     for (const node of flattenTraceNodes([...olderNodes])) {

package/dist/shared/trace-run-notifications.js

@@ -19,7 +19,7 @@ export function parseRunNotificationText(text) {
 export function createRunNotificationNode(input) {
     const runs = runNotificationRuns(input.notification);
     const singleRun = runs.length === 1 ? runs[0] : undefined;
-    const failedCount = countRunGroup(input.notification.failed);
+    const failedCount = countRunGroup(input.notification.failed) + countRunGroup(input.notification.timedOut);
     const runningCount = countRunGroup(input.notification.running);
     return {
         id: input.id,
@@ -43,6 +43,7 @@ function runNotificationRuns(notification) {
     return [
         ...runGroup(notification.completed),
         ...runGroup(notification.failed),
+        ...runGroup(notification.timedOut),
         ...runGroup(notification.cancelled),
         ...runGroup(notification.running),
     ];
@@ -57,6 +58,7 @@ function runNotificationSummary(notification) {
     const parts = [
         [countRunGroup(notification.completed), "completed"],
         [countRunGroup(notification.failed), "failed"],
+        [countRunGroup(notification.timedOut), "timed out"],
         [countRunGroup(notification.cancelled), "cancelled"],
         [countRunGroup(notification.running), "running"],
     ]

package/dist/signals/projector.js

@@ -12,7 +12,7 @@ function node(input, context) {
 function runStatus(status) {
     if (status === "completed")
         return "done";
-    if (status === "failed")
+    if (status === "failed" || status === "timed_out")
         return "error";
     return status;
 }
@@ -133,6 +133,10 @@ export const outputSignalProducer = {
             mutations.push({ type: "set_session_queue", piboSessionId, queuedMessages: event.queuedMessages });
             mutations.push({ type: "upsert_node", node: node({ id: `message:${piboSessionId}:${event.eventId ?? context.now()}`, kind: "message", status: "queued", piboSessionId, metadata: { source: event.source } }, context) });
         }
+        if (event.type === "message_steered") {
+            mutations.push({ type: "patch_node", nodeId: `session:${piboSessionId}`, patch: { status: "running" } });
+            mutations.push({ type: "upsert_node", node: node({ id: `message:${piboSessionId}:${event.eventId ?? context.now()}`, kind: "message", status: "done", piboSessionId, parentNodeId: event.activeEventId ? `turn:${piboSessionId}:${event.activeEventId}` : undefined, completedAt: context.now(), metadata: { source: event.source, delivery: "steer" } }, context) });
+        }
         if (event.type === "message_started") {
             mutations.push({ type: "patch_node", nodeId: `session:${piboSessionId}`, patch: { status: "running" } });
             if (event.eventId) {
@@ -200,7 +204,7 @@ export const runSignalProducer = {
         if (data.type !== "run_changed")
             return [];
         const run = data.run;
-        return [{ type: "upsert_node", node: node({ id: `run:${run.runId}`, kind: "yielded_run", status: runStatus(run.status), piboSessionId: run.controllerPiboSessionId, startedAt: run.createdAt, completedAt: run.completedAt, error: run.status === "failed" ? { message: run.summary ?? "Run failed.", source: "run" } : undefined, metadata: { runId: run.runId, toolName: run.toolName, completionPolicy: run.completionPolicy, consumed: run.consumed, summary: run.summary, previousStatus: data.previousStatus, reason: data.reason } }, context) }];
+        return [{ type: "upsert_node", node: node({ id: `run:${run.runId}`, kind: "yielded_run", status: runStatus(run.status), piboSessionId: run.controllerPiboSessionId, startedAt: run.createdAt, completedAt: run.completedAt, error: run.status === "failed" || run.status === "timed_out" ? { message: run.summary ?? "Run failed.", source: "run" } : undefined, metadata: { runId: run.runId, toolName: run.toolName, completionPolicy: run.completionPolicy, consumed: run.consumed, summary: run.summary, timeoutMs: run.timeoutMs, timeoutAt: run.timeoutAt, timeoutPhase: run.timeoutPhase, serviceWarning: run.serviceWarning, previousStatus: data.previousStatus, reason: data.reason } }, context) }];
     },
 };
 export function createDefaultSignalProducers() {

package/dist/tools/browser-pool.js

@@ -1,6 +1,7 @@
 import { access, mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
 const DEFAULT_MAX_BROWSER_PROCESSES = 1;
 const DEFAULT_LOCK_TIMEOUT_MS = 5_000;
 const DEFAULT_LOCK_POLL_INTERVAL_MS = 50;
@@ -239,6 +240,55 @@ export async function acquireBrowserPoolLease(paths, identity, options = {}) {
         }
     }, options.lockOptions);
 }
+export async function restartRecordedBrowserPoolChrome(state) {
+    if (!state.userDataDir)
+        throw new Error("Browser pool has no persisted user-data directory for reacquisition");
+    if (!state.cdpPort)
+        throw new Error("Browser pool has no persisted CDP port for reacquisition");
+    const candidates = [process.env.PIBO_CHROME_BIN, "/usr/bin/google-chrome", "/usr/bin/chromium", "/usr/bin/chromium-browser", "/opt/google/chrome/chrome"].filter((value) => !!value);
+    let executable;
+    for (const candidate of candidates) {
+        try {
+            await access(candidate);
+            executable = candidate;
+            break;
+        }
+        catch { /* try next */ }
+    }
+    if (!executable)
+        throw new Error("No supported Chrome/Chromium executable is available to reacquire the persisted browser profile");
+    await removeDefaultStaleBrowserFiles(state);
+    const cdpUrl = `http://127.0.0.1:${state.cdpPort}`;
+    const child = spawn(executable, [
+        `--remote-debugging-port=${state.cdpPort}`,
+        "--remote-debugging-address=127.0.0.1",
+        `--user-data-dir=${state.userDataDir}`,
+        `--profile-directory=${process.env.PIBO_BROWSER_USE_DEFAULT_PROFILE || "PIBo"}`,
+        "--headless=new",
+        "--no-sandbox",
+        "--disable-gpu",
+        "--disable-dev-shm-usage",
+        "about:blank",
+    ], { detached: true, stdio: "ignore" });
+    await new Promise((resolve, reject) => {
+        child.once("spawn", resolve);
+        child.once("error", reject);
+    });
+    child.unref();
+    if (!child.pid)
+        throw new Error("Chrome reacquisition did not return a process id");
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+        const health = await checkBrowserPoolCdpHealth(cdpUrl, { timeoutMs: 250 });
+        if (health.ok)
+            return { pid: child.pid, processGroupId: child.pid, cdpPort: state.cdpPort, cdpUrl, userDataDir: state.userDataDir };
+        await delay(100);
+    }
+    try {
+        process.kill(-child.pid, "SIGKILL");
+    }
+    catch { /* already exited */ }
+    throw new Error(`Reacquired Chrome did not expose CDP at ${cdpUrl}`);
+}
 export async function releaseBrowserPoolLease(paths, identity, options = {}) {
     const now = options.now ?? (() => new Date());
     const isPidAlive = options.isPidAlive ?? defaultIsPidAlive;

package/dist/tools/browser-use-leases.js

@@ -365,21 +365,19 @@ export async function acquireBrowserUseLease(context, options = {}) {
         }
         await writeRegistry(context.status, registry);
         if (reapedCount > 0 && !options.json) {
-            console.log(`Reaped ${reapedCount} stale lease${reapedCount === 1 ? '' : 's'}`);
+            console.error(`Reaped ${reapedCount} stale lease${reapedCount === 1 ? '' : 's'}`);
         }
         if (options.json)
             printLeaseJson(context.status, lease);
         else
             printLeaseEnv(context.status, lease);
-        if (!options.noWarmup) {
-            const warmup = await warmupBrowserUseLease(context, lease);
-            if (!warmup.success && !options.json) {
-                console.log(`Warning: Browser warm-up failed: ${warmup.error}`);
-            }
+        const warmup = await warmupBrowserUseLease(context, lease, 15000, options.headed);
+        if (!warmup.success && !options.json) {
+            console.error(`Warning: Browser warm-up failed: ${warmup.error?.trim() || 'unknown error'}`);
         }
     });
 }
-async function warmupBrowserUseLease(context, lease, timeoutMs = 15000) {
+async function warmupBrowserUseLease(context, lease, timeoutMs = 15000, headed = false) {
     const wrapperPath = join(context.status.homeDir, 'bin', 'browser-use');
     if (!existsSync(wrapperPath)) {
         return { success: false, error: 'browser-use wrapper not found' };
@@ -393,7 +391,13 @@ async function warmupBrowserUseLease(context, lease, timeoutMs = 15000) {
         ...(lease.browserPoolLeaseId ? { PIBO_BROWSER_POOL_LEASE_ID: lease.browserPoolLeaseId } : {}),
     };
     return new Promise((resolve) => {
-        const child = spawn(wrapperPath, ['--session', lease.sessionName, '--pibo-ensure-chrome'], {
+        const args = [
+            ...(headed ? ['--headed'] : []),
+            '--session',
+            lease.sessionName,
+            '--pibo-ensure-chrome',
+        ];
+        const child = spawn(wrapperPath, args, {
             env,
             stdio: ['ignore', 'pipe', 'pipe'],
         });

package/dist/tools/guides.js

@@ -376,11 +376,18 @@ browser-use close --all
 For the Pibo Chat Web App, prefer an isolated authenticated lease when multiple agents may use the browser at the same time:
 
 \`\`\`bash
+# Default headless browser
 eval "$(pibo tools browser-use lease acquire --app pibo-chat --holder "$USER")"
+
+# For headed mode, use this instead:
+# eval "$(pibo tools browser-use lease acquire --app pibo-chat --holder "$USER" --headed)"
+
 browser-use state
 \`\`\`
 
-The lease exports \`BROWSER_USE_HOME\`, \`PIBO_BROWSER_USE_SESSION\`, \`PIBO_BROWSER_USE_CHROME_USER_DATA_DIR\`, and \`PIBO_BROWSER_USE_DEFAULT_PROFILE\`. The Pibo browser-use wrapper uses \`PIBO_BROWSER_USE_SESSION\` as the default session, so later commands can omit \`--session\` in that shell.
+Acquire only one lease for the task. The warm-up fixes the mode of the managed Chrome process, so choose \`--headed\` during acquisition rather than adding it only to a later Browser Use command.
+
+The lease exports \`BROWSER_USE_HOME\`, \`PIBO_BROWSER_USE_SESSION\`, \`PIBO_BROWSER_USE_CHROME_USER_DATA_DIR\`, and \`PIBO_BROWSER_USE_DEFAULT_PROFILE\`. Stdout contains only shell-safe exports and comments so it can be evaluated; warm-up diagnostics are written to stderr. The Pibo browser-use wrapper uses \`PIBO_BROWSER_USE_SESSION\` as the default session, so later commands can omit \`--session\` in that shell.
 
 Before acquiring leases, prepare one authenticated template profile:
 

package/dist/tools/index.js

@@ -1004,6 +1004,7 @@ Commands:
         .option('--max-slots <count>', 'Maximum active slots for the app', parsePositiveInteger)
         .option('--template-dir <path>', 'Authenticated Chrome user-data-dir template to clone')
         .option('--profile-name <name>', 'Chrome profile name inside each slot')
+        .option('--headed', 'Warm up the leased Chrome browser in headed mode')
         .option('--json', 'Print machine-readable lease data')
         .action(async (options) => {
         await acquireBrowserUseLease({ status: getCliToolStatus(requireEntry('browser-use')) }, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "1.10.0",
+  "version": "1.10.1",
   "type": "module",
   "imports": {
     "vscode": "./src/apps/chat-vscode/extension/src/vscode-shim.js"
@@ -47,6 +47,7 @@
     "check:product-vocab": "node scripts/legacy-product-vocabulary-gate.mjs",
     "validate:ink-web-derived": "node scripts/ink-cli-web-derived-parity-validate.mjs",
     "compute:limited-worker-smoke": "node scripts/compute-limited-worker-smoke.mjs",
+    "validate:goal-endurance": "node scripts/goal-endurance-check.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit && npm run chat-ui:typecheck && npm run context-files-ui:typecheck && npm run vscode:typecheck",
     "clean": "node -e \"fs.rmSync('dist', { recursive: true, force: true })\"",
     "prepack": "npm run build"

package/skills/builtin/loop/SKILL.md

@@ -20,7 +20,7 @@ pibo loop conditions
 
 Goal-capable profiles expose native tools:
 
-- `get_goal`: inspect authoritative status, objective, token budget, tokens used, remaining tokens, and elapsed active time.
+- `get_goal`: inspect authoritative status, soft-budget risk, tokens used, remaining tokens, active agent time, and elapsed wall-clock time.
 - `create_goal`: create a persistent Goal only when the user or system explicitly requests one.
 - `update_goal`: mark the current Goal `complete` after a strict completion audit, or `blocked` after the same impasse repeats for at least three consecutive Goal turns.
 
@@ -34,6 +34,7 @@ pibo loop add \
   --profile <profile> \
   --prompt "<complete objective>" \
   --token-budget <optional-positive-token-count> \
+  --token-reserve <optional-pre-turn-minimum> \
   --max-iterations <optional-run-fallback> \
   --start
 ```
@@ -50,9 +51,17 @@ Prefer creating the job stopped when its prompt, target, profile, or safety boun
 
 ## Token budgets
 
-Pibo accumulates model usage reported by completed assistant model messages. A Goal becomes `budget_limited` when reported usage reaches or exceeds its budget. One provider request can overshoot because usage is known only after the response reports it.
+Goal token budgets are soft: Pibo accumulates usage reported after model responses, so the final turn can overshoot. Each Goal run records tokens used before the turn, remaining tokens before the turn, turn usage, and overshoot.
 
-Increase or clear the token budget before resuming a budget-limited Goal.
+Set `--token-reserve <n>` to require more than `n` tokens to remain before Pibo starts another turn. Increase or clear the budget, or lower the reserve, before resuming a budget-limited Goal.
+
+## Time accounting
+
+`activeAgentTimeSeconds` accumulates time spent executing Goal runs. `elapsedWallClockSeconds` starts when the Goal is first activated, includes waiting and paused periods, and freezes when the Goal enters a terminal state. A Goal created paused reports zero wall-clock elapsed time until first activation.
+
+## Managed browser leases
+
+When a Goal owns `resources.browserLeaseIds`, Pibo renews those leases before each turn and while the turn is active. The same lease is retained across non-terminal Goal turns, including gateway service restart, and is released only when the Goal stops or reaches a terminal state. If the browser process disappeared, Pibo attempts to restart Chromium from the persisted managed profile. Failure to restore authenticated access marks the Goal blocked with an operator-facing resource reason.
 
 ## Operations