@pasko70/pibo 2.4.0 → 2.4.2

package/dist/loops/store.js

@@ -4,6 +4,7 @@ import { dirname, resolve } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { piboHomePath } from '../core/pibo-home.js';
 import { isPiboThinkingLevel } from '../core/thinking.js';
+import { newGoalTokenAccounting, normalizeLoopTokenAccounting } from './accounting.js';
 function nowIso(now = new Date()) { return now.toISOString(); }
 function parseJson(json) { return JSON.parse(json); }
 function defaultName(prompt) { const normalized = prompt.replace(/\s+/g, ' ').trim(); return normalized ? normalized.slice(0, 80) : 'Loop job'; }
@@ -80,7 +81,9 @@ function parseRunAccounting(json) {
         return undefined;
     try {
         const value = JSON.parse(json);
-        return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+        return value && typeof value === 'object' && !Array.isArray(value)
+            ? { ...value, tokenAccounting: normalizeLoopTokenAccounting(value.tokenAccounting) }
+            : undefined;
     }
     catch {
         return undefined;
@@ -104,7 +107,7 @@ function normalizeJobState(state, mode, enabled, createdAt) {
         return state;
     const activeTimeSeconds = Math.max(0, Math.floor(state.activeTimeSeconds ?? state.timeUsedSeconds ?? 0));
     const goalStartedAt = state.goalStartedAt ?? (enabled || (state.completedIterations ?? 0) > 0 || (state.tokensUsed ?? 0) > 0 || (state.goalStatus !== undefined && state.goalStatus !== 'paused') ? createdAt : undefined);
-    const normalized = { ...state, activeTimeSeconds, ...(goalStartedAt ? { goalStartedAt } : {}) };
+    const normalized = { ...state, tokenAccounting: normalizeLoopTokenAccounting(state.tokenAccounting), activeTimeSeconds, ...(goalStartedAt ? { goalStartedAt } : {}) };
     delete normalized.timeUsedSeconds;
     return normalized;
 }
@@ -296,7 +299,7 @@ export class PiboLoopStore {
         const enabled = input.enabled === true;
         const state = {
             completedIterations: 0,
-            ...(mode === 'goal' ? { goalStatus: enabled ? 'active' : 'paused', tokensUsed: 0, activeTimeSeconds: 0, ...(enabled ? { goalStartedAt: timestamp } : {}) } : {}),
+            ...(mode === 'goal' ? { goalStatus: enabled ? 'active' : 'paused', tokenAccounting: newGoalTokenAccounting(), tokensUsed: 0, activeTimeSeconds: 0, ...(enabled ? { goalStartedAt: timestamp } : {}) } : {}),
             ...(input.initialPiboSessionId?.trim() ? { lastPiboSessionId: input.initialPiboSessionId.trim() } : {}),
         };
         const job = { id: mode === 'ralph' ? `ralph_${randomUUID()}` : `loop_${randomUUID()}`, mode, name: (input.name ?? defaultName(input.prompt)).trim(), description: input.description?.trim() || undefined, enabled, target, profile: input.profile, prompt: input.prompt, maxIterations: normalizeMaxIterations(input.maxIterations), tokenBudget: normalizeTokenBudget(input.tokenBudget), tokenReserve: normalizeTokenReserve(input.tokenReserve), stopPolicy: normalizeLoopStopPolicy(input.stopPolicy), ...runtimeOptions, ...(resources ? { resources } : {}), state, createdAt: timestamp, updatedAt: timestamp };
@@ -422,7 +425,7 @@ export class PiboLoopStore {
             if (job?.mode === 'goal') {
                 const row = this.db.prepare('SELECT * FROM pibo_ralph_runs WHERE id = ? AND job_id = ?').get(runId, id);
                 if (row) {
-                    const accounting = parseRunAccounting(row.accounting_json) ?? {};
+                    const accounting = parseRunAccounting(row.accounting_json) ?? { tokenAccounting: normalizeLoopTokenAccounting(job.state.tokenAccounting) };
                     const turnTokens = (accounting.tokensUsed ?? 0) + Math.max(0, Math.floor(tokens));
                     const budget = accounting.tokenBudget;
                     const before = accounting.tokensUsedBefore ?? 0;
@@ -446,7 +449,7 @@ export class PiboLoopStore {
             if (job?.mode === 'goal') {
                 const row = this.db.prepare('SELECT * FROM pibo_ralph_runs WHERE id = ? AND job_id = ?').get(runId, id);
                 if (row) {
-                    const accounting = { ...(parseRunAccounting(row.accounting_json) ?? {}), activeTimeSeconds: seconds };
+                    const accounting = { ...(parseRunAccounting(row.accounting_json) ?? { tokenAccounting: normalizeLoopTokenAccounting(job.state.tokenAccounting) }), activeTimeSeconds: seconds };
                     this.db.prepare('UPDATE pibo_ralph_runs SET accounting_json = ?, updated_at = ? WHERE id = ?').run(runAccountingJson(accounting), nowIso(now), runId);
                 }
             }
@@ -481,7 +484,7 @@ export class PiboLoopStore {
         const enabled = patch.enabled ?? existing.enabled;
         let state = mode === existing.mode
             ? { ...existing.state }
-            : { completedIterations: existing.state.completedIterations ?? 0, ...(mode === 'goal' ? { goalStatus: enabled ? 'active' : 'paused', tokensUsed: 0, activeTimeSeconds: 0, ...(enabled ? { goalStartedAt: nowIso(now) } : {}) } : {}) };
+            : { completedIterations: existing.state.completedIterations ?? 0, ...(mode === 'goal' ? { goalStatus: enabled ? 'active' : 'paused', tokenAccounting: newGoalTokenAccounting(), tokensUsed: 0, activeTimeSeconds: 0, ...(enabled ? { goalStartedAt: nowIso(now) } : {}) } : {}) };
         if (mode === 'goal' && patch.enabled !== undefined) {
             const currentGoalStatus = goalStatus({ mode, enabled: existing.enabled, state: existing.state }) ?? 'paused';
             if (patch.enabled) {
@@ -633,7 +636,11 @@ export class PiboLoopStore {
         const completedIterations = (job.state.completedIterations ?? 0) + 1;
         const reachedMaxIterations = job.maxIterations !== undefined && completedIterations >= job.maxIterations;
         const currentGoalStatus = goalStatus(job);
-        const nextGoalStatus = job.mode === 'goal' ? isTerminalGoalStatus(currentGoalStatus) ? currentGoalStatus : input.goalStatus ?? currentGoalStatus : undefined;
+        const nextGoalStatus = job.mode === 'goal'
+            ? isTerminalGoalStatus(currentGoalStatus) || currentGoalStatus === 'paused'
+                ? currentGoalStatus
+                : input.goalStatus ?? currentGoalStatus
+            : undefined;
         const terminalGoalStatus = job.mode === 'goal' && isTerminalGoalStatus(nextGoalStatus);
         const shouldDisable = terminalGoalStatus || reachedMaxIterations || input.stopAfterRun === true || input.stopEvaluation?.finalAction === 'stop-after-run' || input.stopEvaluation?.finalAction === 'cancel-current-run';
         const state = {
@@ -807,6 +814,7 @@ export class PiboLoopStore {
     createRunLocked(job, timestamp) {
         const tokensUsedBefore = job.state.tokensUsed ?? 0;
         const accounting = job.mode === 'goal' ? {
+            tokenAccounting: normalizeLoopTokenAccounting(job.state.tokenAccounting),
             ...(job.tokenBudget !== undefined ? { tokenBudget: job.tokenBudget, remainingTokensBefore: Math.max(0, job.tokenBudget - tokensUsedBefore) } : {}),
             ...(job.tokenReserve !== undefined ? { tokenReserve: job.tokenReserve } : {}),
             tokensUsedBefore,
@@ -829,15 +837,23 @@ export function createLoopMessagePreflight(options = {}) {
             const job = store.getJob(jobId);
             const run = store.getRun(runId);
             const status = job?.mode === 'goal' ? goalStatus(job) ?? (job.enabled ? 'active' : 'paused') : undefined;
+            const causalReminder = event.provenance.cause === 'run-reminder';
+            const validMessageBinding = causalReminder
+                ? event.source === 'service'
+                    && event.text.startsWith('<pibo_run_notification>')
+                    && typeof event.provenance.rootEventId === 'string'
+                    && run?.messageEventId === event.provenance.rootEventId
+                : run?.messageEventId === event.id;
+            const validRunState = causalReminder
+                ? true
+                : run?.status === 'running' && Boolean(job?.state.runningAt) && job?.state.lastRunId === runId;
             const allowed = Boolean(job
                 && run
                 && run.jobId === jobId
-                && run.status === 'running'
-                && run.messageEventId === event.id
+                && validMessageBinding
+                && validRunState
                 && (!run.piboSessionId || run.piboSessionId === event.piboSessionId)
                 && job.enabled
-                && job.state.runningAt
-                && job.state.lastRunId === runId
                 && (job.mode !== 'goal' || status === 'active'));
             if (allowed)
                 return { allowed: true };

package/dist/loops/tools.js

@@ -1,7 +1,7 @@
 import { Type } from "typebox";
 import { piboStringEnum } from "../tools/schema.js";
 import { definePiboTool } from "../tools/contract.js";
-import { goalActiveTimeSeconds, goalCanStartNextTurn, goalElapsedWallClockSeconds, goalRemainingTokens } from './accounting.js';
+import { goalActiveTimeSeconds, goalCanStartNextTurn, goalElapsedWallClockSeconds, goalRemainingTokens, goalTokenAccounting } from './accounting.js';
 import { createDefaultPiboLoopStore } from './store.js';
 export const PIBO_GOAL_TOOL_NAMES = ['get_goal', 'create_goal', 'update_goal'];
 let configuredStorePath;
@@ -34,7 +34,9 @@ function resolveGoalForTurn(store, context, piboSessionId) {
     if (provenance?.kind !== 'loop-run')
         return store.getSessionGoalOwner(piboSessionId) ?? store.getLatestGoalForSession(piboSessionId);
     const run = store.getRun(provenance.runId);
-    if (!run || run.jobId !== provenance.jobId || run.piboSessionId !== piboSessionId || run.messageEventId !== activeMessage?.id) {
+    const expectedEventId = provenance.cause === 'run-reminder' ? provenance.rootEventId : activeMessage?.id;
+    const validReminder = provenance.cause !== 'run-reminder' || (activeMessage?.source === 'service' && typeof provenance.rootEventId === 'string');
+    if (!run || !validReminder || run.jobId !== provenance.jobId || run.piboSessionId !== piboSessionId || run.messageEventId !== expectedEventId) {
         throw new Error('cannot resolve goal because this turn has stale or invalid Loop provenance');
     }
     const job = store.getJob(provenance.jobId);
@@ -68,11 +70,13 @@ function nonNegativeInteger(value, field) {
 }
 function goalPayload(job) {
     const tokenBudget = job.tokenBudget;
+    const tokenAccounting = goalTokenAccounting(job);
     return {
         goalId: job.id,
         objective: job.prompt,
         status: effectiveGoalStatus(job),
         budgetType: tokenBudget === undefined ? 'unbounded' : 'soft',
+        tokenAccounting,
         tokenBudget: tokenBudget ?? null,
         tokenReserve: job.tokenReserve ?? 0,
         tokensUsed: job.state.tokensUsed ?? 0,
@@ -130,8 +134,8 @@ function createCreateGoalTool(context, options) {
         promptSnippet: 'Call create_goal only when the user or system explicitly requests a persistent goal. Do not infer a goal from an ordinary task.',
         inputSchema: Type.Object({
             objective: Type.String({ description: 'Concrete objective to pursue across automatic continuations.' }),
-            token_budget: Type.Optional(Type.Number({ description: 'Optional soft token budget. Usage arrives after each model response, so the final turn can overshoot.' })),
-            token_reserve: Type.Optional(Type.Number({ description: 'Optional non-negative minimum remaining tokens required before Pibo starts another turn.' })),
+            token_budget: Type.Optional(Type.Number({ description: 'Optional soft uncached-token budget. Cache reads and writes are excluded. Usage arrives after each model response, so the final turn can overshoot.' })),
+            token_reserve: Type.Optional(Type.Number({ description: 'Optional non-negative minimum remaining uncached tokens required before Pibo starts another turn.' })),
         }),
         async execute(_toolCallId, params) {
             try {
@@ -182,11 +186,12 @@ function createUpdateGoalTool(context, options) {
                     const job = store.updateGoalStatus(existing.id, status);
                     if (!job)
                         throw new Error('goal no longer exists');
+                    const tokenBasis = goalTokenAccounting(job).basis;
                     return toolResult({
                         ok: true,
                         goal: goalPayload(job),
                         ...(status === 'complete' && job.tokenBudget !== undefined
-                            ? { completionBudgetReport: `${job.state.tokensUsed ?? 0}/${job.tokenBudget} reported tokens consumed against a soft budget before the current model turn finishes` }
+                            ? { completionBudgetReport: `${job.state.tokensUsed ?? 0}/${job.tokenBudget} reported ${tokenBasis} tokens consumed against a soft budget before the current model turn finishes` }
                             : {}),
                     });
                 });

package/dist/mcp/config-command.js

@@ -36,8 +36,9 @@ MCP config lookup order:
   1. -c/--config <path>
   2. MCP_CONFIG_PATH
   3. ./mcp_servers.json
-  4. ~/.mcp_servers.json
-  5. ~/.config/mcp/mcp_servers.json
+  4. ~/mcp_servers.json
+  5. ~/.mcp_servers.json
+  6. ~/.config/mcp/mcp_servers.json
 `);
 }
 export function printConfigSchema() {

package/dist/mcp/config.js

@@ -5,7 +5,7 @@ import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { ErrorCode, configInvalidJsonError, configMissingFieldError, configNotFoundError, configSearchError, formatCliError, serverNotFoundError, } from './errors.js';
 export const DEFAULT_MCP_CONFIG_FILE = 'mcp_servers.json';
 // ============================================================================
@@ -306,9 +306,15 @@ export function getDefaultConfigPaths() {
     const home = homedir();
     // Current directory
     paths.push(resolve(DEFAULT_MCP_CONFIG_FILE));
-    // Home directory variants
-    paths.push(join(home, '.mcp_servers.json'));
-    paths.push(join(home, '.config', 'mcp', 'mcp_servers.json'));
+    // Home directory variants. Include the non-dot filename because `pibo mcp
+    // config` creates it when invoked from the home directory, and services can
+    // later run with a different working directory. Ignore empty or relative
+    // platform home values instead of treating them as paths below the cwd.
+    if (home && isAbsolute(home)) {
+        paths.push(join(home, DEFAULT_MCP_CONFIG_FILE));
+        paths.push(join(home, '.mcp_servers.json'));
+        paths.push(join(home, '.config', 'mcp', 'mcp_servers.json'));
+    }
     return paths;
 }
 export function getConfigSearchPaths(explicitPath) {

package/dist/mcp/errors.js

@@ -24,7 +24,7 @@ export function configSearchError() {
         code: ErrorCode.CLIENT_ERROR,
         type: 'CONFIG_NOT_FOUND',
         message: 'No mcp_servers.json found in search paths',
-        details: 'Searched: ./mcp_servers.json, ~/.mcp_servers.json, ~/.config/mcp/mcp_servers.json',
+        details: 'Searched: ./mcp_servers.json, ~/mcp_servers.json, ~/.mcp_servers.json, ~/.config/mcp/mcp_servers.json',
         suggestion: 'Create mcp_servers.json in current directory or use -c/--config to specify path',
     };
 }

package/dist/mcp/index.js

@@ -9,9 +9,8 @@
  *   mcp-cli call <server> <tool>     Call tool (reads JSON from stdin if no args)
  *   mcp-cli call <server> <tool> {}  Call tool with JSON args
  */
-import { readFileSync } from 'node:fs';
 import { configCommand } from './config-command.js';
-import { ensureConfigExists, } from './config.js';
+import { ensureConfigExists, listServerNames, loadConfigUnresolved, } from './config.js';
 import { ErrorCode, ambiguousCommandError, formatCliError, missingArgumentError, tooManyArgumentsError, unknownOptionError, unknownSubcommandError, } from './errors.js';
 import { registryCommand } from './registry.js';
 import { VERSION } from './version.js';
@@ -127,37 +126,8 @@ function parseArgs(args) {
         result.command = 'info';
         const remaining = positional.slice(1);
         const { server, tool } = parseServerTool(remaining);
-        // info requires a server argument - show available servers in error
         if (!server) {
-            // Try to load config synchronously to show available servers
-            let availableServers = [];
-            const configPaths = [
-                result.configPath,
-                process.env.MCP_CONFIG_PATH,
-                './mcp_servers.json',
-                `${process.env.HOME}/.mcp_servers.json`,
-                `${process.env.HOME}/.config/mcp/mcp_servers.json`,
-            ].filter(Boolean);
-            for (const cfgPath of configPaths) {
-                try {
-                    const content = readFileSync(cfgPath, 'utf-8');
-                    const config = JSON.parse(content);
-                    if (config.mcpServers) {
-                        availableServers = Object.keys(config.mcpServers);
-                        break;
-                    }
-                }
-                catch {
-                    // Try next path
-                }
-            }
-            const serverList = availableServers.length > 0
-                ? availableServers.join(', ')
-                : '(none found)';
-            console.error('Error [MISSING_ARGUMENT]: Missing required argument for info: server');
-            console.error(`  Available servers: ${serverList}`);
-            console.error(`  Suggestion: Use 'pibo mcp info <server>' to see server details, or just 'pibo mcp' to list all`);
-            process.exit(ErrorCode.CLIENT_ERROR);
+            return result;
         }
         result.server = server;
         result.tool = tool;
@@ -371,10 +341,26 @@ export async function runMcpCli(argv = process.argv) {
                 }
                 break;
             case 'info':
+                if (!args.server) {
+                    let availableServers = [];
+                    try {
+                        availableServers = listServerNames(await loadConfigUnresolved(args.configPath));
+                    }
+                    catch {
+                        // Keep the missing-argument error focused when no valid config exists.
+                    }
+                    const serverList = availableServers.length > 0
+                        ? availableServers.join(', ')
+                        : '(none found)';
+                    console.error('Error [MISSING_ARGUMENT]: Missing required argument for info: server');
+                    console.error(`  Available servers: ${serverList}`);
+                    console.error(`  Suggestion: Use 'pibo mcp info <server>' to see server details, or just 'pibo mcp' to list all`);
+                    process.exitCode = ErrorCode.CLIENT_ERROR;
+                    break;
+                }
                 await ensureConfigExists(args.configPath);
                 {
                     const { infoCommand } = await import('./commands/info.js');
-                    // info always has a server (validated in parseArgs)
                     await infoCommand({
                         target: buildTarget(args.server, args.tool),
                         withDescriptions: args.withDescriptions,

package/dist/reliability/store.js

@@ -149,7 +149,8 @@ export class PiboReliabilityStore {
 				timeout_at TEXT,
 				timeout_phase TEXT,
 				service_warning TEXT,
-				resource_json TEXT
+				resource_json TEXT,
+				origin_json TEXT
 			);
 			CREATE INDEX IF NOT EXISTS idx_pibo_runs_controller_updated
 				ON pibo_runs(controller_pibo_session_id, updated_at);
@@ -161,6 +162,7 @@ export class PiboReliabilityStore {
         ensurePiboRunColumn(this.db, "timeout_phase", "TEXT");
         ensurePiboRunColumn(this.db, "service_warning", "TEXT");
         ensurePiboRunColumn(this.db, "resource_json", "TEXT");
+        ensurePiboRunColumn(this.db, "origin_json", "TEXT");
         this.appendEventStatement = this.db.prepare(`
 			INSERT INTO pibo_event_stream (topic, key, event_id, idempotency_key, created_at, retention_class, payload_json)
 			VALUES (?, ?, ?, ?, ?, ?, ?)
@@ -502,10 +504,10 @@ export class PiboReliabilityStore {
 				INSERT INTO pibo_runs (
 					run_id, kind, controller_pibo_session_id, status, completion_policy, consumed, tool_name,
 					summary, result_json, error, notified_status, acknowledged_status, created_at, updated_at,
-					completed_at, job_id, retryable, max_attempts, timeout_ms, timeout_at, timeout_phase, service_warning, resource_json
-				) VALUES (?, 'tool', ?, 'running', ?, 0, ?, ?, NULL, NULL, NULL, NULL, ?, ?, NULL, ?, ?, ?, ?, ?, NULL, ?, ?)
+					completed_at, job_id, retryable, max_attempts, timeout_ms, timeout_at, timeout_phase, service_warning, resource_json, origin_json
+				) VALUES (?, 'tool', ?, 'running', ?, 0, ?, ?, NULL, NULL, NULL, NULL, ?, ?, NULL, ?, ?, ?, ?, ?, NULL, ?, ?, ?)
 			`)
-            .run(runId, input.controllerPiboSessionId, input.completionPolicy, input.toolName, `${input.toolName} run is running.`, timestamp, timestamp, job.jobId, input.retryable ? 1 : 0, maxAttempts, input.timeoutMs ?? null, timeoutAt ?? null, input.serviceWarning ?? null, input.resources ? JSON.stringify(input.resources) : null);
+            .run(runId, input.controllerPiboSessionId, input.completionPolicy, input.toolName, `${input.toolName} run is running.`, timestamp, timestamp, job.jobId, input.retryable ? 1 : 0, maxAttempts, input.timeoutMs ?? null, timeoutAt ?? null, input.serviceWarning ?? null, input.resources ? JSON.stringify(input.resources) : null, input.origin ? JSON.stringify(input.origin) : null);
         this.claimJob(job.jobId, input.workerId ?? `run-registry:${process.pid}`, 24 * 60 * 60 * 1000);
         return this.requireRun(runId);
     }
@@ -534,10 +536,11 @@ export class PiboReliabilityStore {
 					timeout_at = ?,
 					timeout_phase = ?,
 					service_warning = ?,
-					resource_json = ?
+					resource_json = ?,
+					origin_json = ?
 				WHERE run_id = ?
 			`)
-            .run(next.status, next.completionPolicy, next.consumed ? 1 : 0, next.summary ?? null, next.result ? JSON.stringify(next.result) : null, next.error ?? null, next.notifiedStatus ?? null, next.acknowledgedStatus ?? null, next.updatedAt, next.completedAt ?? null, next.jobId ?? null, next.retryable ? 1 : 0, next.maxAttempts, next.timeoutMs ?? null, next.timeoutAt ?? null, next.timeoutPhase ?? null, next.serviceWarning ?? null, next.resources ? JSON.stringify(next.resources) : null, runId);
+            .run(next.status, next.completionPolicy, next.consumed ? 1 : 0, next.summary ?? null, next.result ? JSON.stringify(next.result) : null, next.error ?? null, next.notifiedStatus ?? null, next.acknowledgedStatus ?? null, next.updatedAt, next.completedAt ?? null, next.jobId ?? null, next.retryable ? 1 : 0, next.maxAttempts, next.timeoutMs ?? null, next.timeoutAt ?? null, next.timeoutPhase ?? null, next.serviceWarning ?? null, next.resources ? JSON.stringify(next.resources) : null, next.origin ? JSON.stringify(next.origin) : null, runId);
         return this.requireRun(runId);
     }
     getRun(runId) {
@@ -810,6 +813,8 @@ function runFromRow(row) {
         output.serviceWarning = row.service_warning;
     if (row.resource_json)
         output.resources = JSON.parse(row.resource_json);
+    if (row.origin_json)
+        output.origin = JSON.parse(row.origin_json);
     return output;
 }
 function retryDelayMs(attempts, input) {

package/dist/runs/lifecycle.js

@@ -6,6 +6,18 @@ export class PiboRunExecutionTimeoutError extends Error {
         this.name = "PiboRunExecutionTimeoutError";
     }
 }
+export class PiboRunCancellationError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "PiboRunCancellationError";
+    }
+}
+export class PiboRunCancelledError extends Error {
+    constructor(message = "Yielded run was cancelled.", options) {
+        super(message, options);
+        this.name = "PiboRunCancelledError";
+    }
+}
 export function resolveRunTimeoutMs(toolName, params) {
     if (!params || typeof params !== "object" || Array.isArray(params))
         return undefined;

package/dist/runs/registry.js

@@ -7,6 +7,16 @@ function now() {
 function runTimeoutAt(createdAt, timeoutMs) {
     return timeoutMs === undefined ? undefined : new Date(Date.parse(createdAt) + timeoutMs).toISOString();
 }
+function sameOrigin(left, right) {
+    if (!left || !right)
+        return left === right;
+    return left.eventId === right.eventId
+        && left.provenance.kind === right.provenance.kind
+        && left.provenance.jobId === right.provenance.jobId
+        && left.provenance.runId === right.provenance.runId
+        && left.provenance.cause === right.provenance.cause
+        && left.provenance.rootEventId === right.provenance.rootEventId;
+}
 function formatTimeout(timeoutMs) {
     if (timeoutMs === undefined)
         return "its configured timeout";
@@ -83,6 +93,7 @@ export class PiboRunRegistry {
                 serviceWarning: input.serviceWarning,
                 resources: input.resources,
                 workerId: this.workerId,
+                origin: input.origin,
             });
             const record = recordFromStored(stored);
             this.runs.set(record.runId, record);
@@ -108,6 +119,7 @@ export class PiboRunRegistry {
             ...(input.timeoutMs !== undefined ? { timeoutMs: input.timeoutMs, timeoutAt: runTimeoutAt(timestamp, input.timeoutMs) } : {}),
             ...(input.serviceWarning ? { serviceWarning: input.serviceWarning } : {}),
             ...(input.resources ? { resources: structuredClone(input.resources) } : {}),
+            ...(input.origin ? { origin: structuredClone(input.origin) } : {}),
         };
         this.runs.set(runId, record);
         const output = snapshot(record);
@@ -245,7 +257,7 @@ export class PiboRunRegistry {
     }
     read(controllerPiboSessionId, runId) {
         const record = this.requireRunForController(controllerPiboSessionId, runId);
-        if (terminal(record.status)) {
+        if (terminal(record.status) && !record.consumed) {
             record.consumed = true;
             record.updatedAt = now();
             this.options.store?.updateRun(runId, record);
@@ -277,6 +289,9 @@ export class PiboRunRegistry {
     }
     ack(controllerPiboSessionId, runId) {
         const record = this.requireRunForController(controllerPiboSessionId, runId);
+        const consumesTerminalRun = terminal(record.status) && !record.consumed;
+        if (record.acknowledgedStatus === record.status && !consumesTerminalRun)
+            return { ...snapshot(record), changed: false };
         record.acknowledgedStatus = record.status;
         if (terminal(record.status))
             record.consumed = true;
@@ -284,7 +299,7 @@ export class PiboRunRegistry {
         this.options.store?.updateRun(runId, record);
         const output = snapshot(record);
         this.notify({ type: "run_acknowledged", run: output });
-        return output;
+        return { ...output, changed: true };
     }
     suppressNotification(controllerPiboSessionId, runId) {
         const record = this.requireRunForController(controllerPiboSessionId, runId);
@@ -306,14 +321,17 @@ export class PiboRunRegistry {
         return suppressed;
     }
     createNotification(controllerPiboSessionId, options = {}) {
-        const records = [...this.runs.values()].filter((record) => this.needsNotification(record, controllerPiboSessionId, options));
-        if (records.length === 0)
+        const pendingRecords = [...this.runs.values()].filter((record) => this.needsNotification(record, controllerPiboSessionId, options));
+        if (pendingRecords.length === 0)
             return undefined;
+        const origin = pendingRecords[0].origin;
+        const records = pendingRecords.filter((record) => sameOrigin(record.origin, origin));
         for (const record of records) {
             record.notifiedStatus = record.status;
             this.options.store?.updateRun(record.runId, record);
         }
         const notification = {
+            ...(origin ? { origin: structuredClone(origin) } : {}),
             completed: [],
             failed: [],
             timedOut: [],
@@ -461,5 +479,6 @@ function recordFromStored(record) {
         timeoutPhase: record.timeoutPhase,
         serviceWarning: record.serviceWarning,
         resources: record.resources,
+        origin: record.origin,
     };
 }

package/dist/runs/tools.js

@@ -1,7 +1,7 @@
 import { Type } from "typebox";
 import { piboStringEnum } from "../tools/schema.js";
 import { definePiboTool } from "../tools/contract.js";
-import { foregroundServiceWarning, hasMeaningfulTimeoutOutput, isConfiguredTimeoutError, PiboRunExecutionTimeoutError, resolveRunTimeoutMs } from "./lifecycle.js";
+import { foregroundServiceWarning, hasMeaningfulTimeoutOutput, isConfiguredTimeoutError, PiboRunCancellationError, PiboRunCancelledError, PiboRunExecutionTimeoutError, resolveRunTimeoutMs } from "./lifecycle.js";
 import { PiboRunResourceLimitError, prepareYieldedRunExecution } from "./resource-isolation.js";
 function resultText(prefix, value) {
     return `${prefix}\n${JSON.stringify(value, null, 2)}`;
@@ -73,6 +73,7 @@ export function createRunToolDefinitions(yieldableTools, controller) {
                     resolveExecutionSettled = resolve;
                 });
                 let observedOutput = false;
+                let cancellationFailure;
                 const run = controller.startToolRun({
                     toolName: tool.name,
                     params: params.arguments,
@@ -95,6 +96,8 @@ export function createRunToolDefinitions(yieldableTools, controller) {
                             throw processCancellationError;
                         if (executionStarted)
                             await waitForRunCancellationSettlement(executionSettled);
+                        if (cancellationFailure)
+                            throw cancellationFailure;
                     },
                     async execute() {
                         executionStarted = true;
@@ -113,8 +116,13 @@ export function createRunToolDefinitions(yieldableTools, controller) {
                             return { text, details: resultObject.details ?? result };
                         }
                         catch (error) {
-                            if (error instanceof PiboRunExecutionTimeoutError || error instanceof PiboRunResourceLimitError)
+                            if (error instanceof PiboRunCancellationError)
+                                cancellationFailure = error;
+                            if (error instanceof PiboRunExecutionTimeoutError || error instanceof PiboRunResourceLimitError || error instanceof PiboRunCancellationError)
                                 throw error;
+                            if (runAbortController.signal.aborted) {
+                                throw new PiboRunCancelledError("Yielded run was cancelled; execution ended after cancellation.", { cause: error });
+                            }
                             if (timeoutMs !== undefined && isConfiguredTimeoutError(error))
                                 throw new PiboRunExecutionTimeoutError(error instanceof Error ? error.message : String(error), observedOutput ? "lifetime" : "startup");
                             throw error;
@@ -240,8 +248,9 @@ export function createRunToolDefinitions(yieldableTools, controller) {
             }),
             async execute(_toolCallId, params) {
                 const run = controller.ackRun(params.runId);
+                const prefix = run.changed ? `Acknowledged run ${run.runId}.` : `Run ${run.runId} was already acknowledged in state ${run.status}; no state changed.`;
                 return {
-                    content: [{ type: "text", text: resultText(`Acknowledged run ${run.runId}.`, run) }],
+                    content: [{ type: "text", text: resultText(prefix, run) }],
                     details: run,
                 };
             },

package/dist/session-ui/sessionActivity.js

@@ -1,12 +1,16 @@
+import { resolveSessionSignalStatus } from "../signals/status.js";
 export function resolveSessionActivity(signal, fallback = {}) {
     if (!signal)
         return fallbackSessionActivity(fallback);
     const latestTurn = signal.latestTurn;
     const isTurnActive = latestTurn?.state === "running";
     const isTreeActive = signal.isTreeActive || isTurnActive;
-    const hasError = signal.hasError || signal.hasErrorDescendant || signal.aggregateStatus === "error";
     return {
-        status: hasError ? "error" : isTreeActive ? "running" : "idle",
+        status: resolveSessionSignalStatus({
+            isTreeActive,
+            localStatus: signal.localStatus,
+            latestTurn,
+        }),
         isTreeActive,
         isTurnActive,
         activeTurnId: isTurnActive ? latestTurn.eventId : undefined,

package/dist/signals/status.js

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

package/dist/tools/guides.js

@@ -46,7 +46,7 @@ pibo loop stop <job-id>
 pibo loop cancel <job-id>
 \`\`\`
 
-Token budgets count usage reported by completed assistant model messages. One request can overshoot because usage is known after the response returns.
+New Goals persist token-accounting version \`1\` with basis \`uncached\`: their budgets count uncached input and output usage reported by completed assistant model messages, while cache-read and cache-write tokens remain telemetry and do not consume the budget. Legacy persisted Goal jobs and runs without an accounting descriptor remain on version \`1\` basis \`total\`, including cache reads and writes, so their existing counters are neither relabeled nor numerically reconstructed without source data. Inspect \`pibo loop list --all --json\` and \`pibo loop runs --job <job-id> --json\` for the persisted basis. Both bases are soft because usage arrives after the response, so one request can overshoot.
 `,
 };
 export const RALPH_GUIDE = {

package/dist/web/channel.js

@@ -284,11 +284,17 @@ export function createWebHostChannel(options = {}) {
                 await sendResponse(nodeResponse, response ?? notFound());
                 return;
             }
-            if (url.pathname === "/" && apps[0]) {
-                await sendResponse(nodeResponse, redirect(apps[0].mountPath));
-                return;
-            }
             if (url.pathname === "/") {
+                const landingApp = options.landingAppName
+                    ? apps.find((candidate) => candidate.name === options.landingAppName)
+                    : apps[0];
+                if (options.landingAppName && !landingApp) {
+                    throw new Error(`Configured landing web app "${options.landingAppName}" is not registered`);
+                }
+                if (landingApp) {
+                    await sendResponse(nodeResponse, redirect(`${landingApp.mountPath}${url.search}`));
+                    return;
+                }
                 await sendResponse(nodeResponse, responseHtml("<!doctype html><title>Pibo</title><p>No web apps registered.</p>"));
                 return;
             }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@pasko70/pibo",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@pasko70/pibo",
-      "version": "2.4.0",
+      "version": "2.4.2",
       "workspaces": [
         "packages/workflows"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "type": "module",
   "workspaces": [
     "packages/workflows"

package/skills/builtin/loop/SKILL.md

@@ -51,7 +51,7 @@ Prefer creating the job stopped when its prompt, target, profile, or safety boun
 
 ## Token budgets
 
-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.
+Goal token budgets are soft because usage arrives after model responses, so the final turn can overshoot. New Goals use versioned `uncached` accounting: cache-read and cache-write tokens do not consume the budget. Legacy persisted Goals without an accounting descriptor remain on `total` accounting, including cache usage, because their existing counters cannot be reconstructed safely. Job status and each Goal run expose the accounting basis together with tokens used before the turn, remaining tokens, turn usage, and overshoot.
 
 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.