@pasko70/pibo 2.4.1 → 2.4.3

package/dist/gateway/server.js

@@ -358,6 +358,7 @@ export class PiboGatewayServer {
             findSessions: (input) => this.requireSessionStore().find(input),
             listSessions: () => this.requireSessionStore().list?.() ?? [],
             getSessionRuntimeBinding: (piboSessionId) => this.requireRouter().getSessionRuntimeBinding(piboSessionId),
+            getSessionRuntimeProfile: (piboSessionId) => this.requireRouter().getSessionRuntimeProfile(piboSessionId),
             inspectSessionRuntimeHistory: async (piboSessionId) => {
                 const session = this.requireSessionStore().get(piboSessionId);
                 if (!session)

package/dist/loops/accounting.js

@@ -1,4 +1,84 @@
 export const LOOP_TOKEN_ACCOUNTING_VERSION = 1;
+export function emptyLoopUsageTotals() {
+    return {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        reasoningTokens: 0,
+        totalTokens: 0,
+        costUsd: 0,
+        costReportedTurns: 0,
+        assistantTurns: 0,
+    };
+}
+export function emptyLoopRecursiveUsage() {
+    return {
+        controller: emptyLoopUsageTotals(),
+        descendants: emptyLoopUsageTotals(),
+        total: emptyLoopUsageTotals(),
+        sessionIds: [],
+    };
+}
+export function assistantUsageTotals(usage) {
+    return {
+        inputTokens: normalizedTokenCount(usage.inputTokens),
+        outputTokens: normalizedTokenCount(usage.outputTokens),
+        cacheReadTokens: normalizedTokenCount(usage.cacheReadTokens),
+        cacheWriteTokens: normalizedTokenCount(usage.cacheWriteTokens),
+        reasoningTokens: normalizedTokenCount(usage.reasoningTokens),
+        totalTokens: normalizedTokenCount(usage.totalTokens),
+        costUsd: typeof usage.costUsd === 'number' && Number.isFinite(usage.costUsd) ? Math.max(0, usage.costUsd) : 0,
+        costReportedTurns: typeof usage.costUsd === 'number' && Number.isFinite(usage.costUsd) ? 1 : 0,
+        assistantTurns: 1,
+    };
+}
+function normalizeLoopUsageTotals(value) {
+    const costUsd = typeof value?.costUsd === 'number' && Number.isFinite(value.costUsd) ? Math.max(0, value.costUsd) : 0;
+    return {
+        inputTokens: normalizedTokenCount(value?.inputTokens),
+        outputTokens: normalizedTokenCount(value?.outputTokens),
+        cacheReadTokens: normalizedTokenCount(value?.cacheReadTokens),
+        cacheWriteTokens: normalizedTokenCount(value?.cacheWriteTokens),
+        reasoningTokens: normalizedTokenCount(value?.reasoningTokens),
+        totalTokens: normalizedTokenCount(value?.totalTokens),
+        costUsd,
+        costReportedTurns: value?.costReportedTurns === undefined && costUsd > 0 ? 1 : normalizedTokenCount(value?.costReportedTurns),
+        assistantTurns: normalizedTokenCount(value?.assistantTurns),
+    };
+}
+function addUsageTotals(left, right) {
+    const normalizedLeft = normalizeLoopUsageTotals(left);
+    const normalizedRight = normalizeLoopUsageTotals(right);
+    return {
+        inputTokens: normalizedLeft.inputTokens + normalizedRight.inputTokens,
+        outputTokens: normalizedLeft.outputTokens + normalizedRight.outputTokens,
+        cacheReadTokens: normalizedLeft.cacheReadTokens + normalizedRight.cacheReadTokens,
+        cacheWriteTokens: normalizedLeft.cacheWriteTokens + normalizedRight.cacheWriteTokens,
+        reasoningTokens: normalizedLeft.reasoningTokens + normalizedRight.reasoningTokens,
+        totalTokens: normalizedLeft.totalTokens + normalizedRight.totalTokens,
+        costUsd: normalizedLeft.costUsd + normalizedRight.costUsd,
+        costReportedTurns: normalizedLeft.costReportedTurns + normalizedRight.costReportedTurns,
+        assistantTurns: normalizedLeft.assistantTurns + normalizedRight.assistantTurns,
+    };
+}
+export function addLoopAssistantUsage(current, usage, input) {
+    const base = current
+        ? {
+            controller: normalizeLoopUsageTotals(current.controller),
+            descendants: normalizeLoopUsageTotals(current.descendants),
+            total: normalizeLoopUsageTotals(current.total),
+            sessionIds: Array.isArray(current.sessionIds) ? current.sessionIds.filter((id) => typeof id === 'string') : [],
+        }
+        : emptyLoopRecursiveUsage();
+    const increment = assistantUsageTotals(usage);
+    return {
+        controller: input.descendant ? { ...base.controller } : addUsageTotals(base.controller, increment),
+        descendants: input.descendant ? addUsageTotals(base.descendants, increment) : { ...base.descendants },
+        total: addUsageTotals(base.total, increment),
+        sessionIds: base.sessionIds.includes(input.piboSessionId) ? [...base.sessionIds] : [...base.sessionIds, input.piboSessionId],
+    };
+}
 function normalizedTokenCount(value) {
     return typeof value === 'number' && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
 }

package/dist/loops/service.js

@@ -519,26 +519,65 @@ export class PiboLoopService {
     getStopConditionDefinitions() { return this.options.context.getLoopStopConditionDefinitions?.() ?? this.options.context.getRalphStopConditionDefinitions?.() ?? createBuiltInLoopStopConditions(); }
     handleOutputEvent(event) {
         const eventId = 'eventId' in event ? event.eventId : undefined;
-        if (!eventId)
-            return;
-        if (event.type === 'message_queued')
-            this.store.updateRunMessageState(eventId, 'queued');
-        else if (event.type === 'message_started')
-            this.store.updateRunMessageState(eventId, 'active');
-        else if (event.type === 'message_finished')
-            this.store.updateRunMessageState(eventId, 'finished');
-        else if (event.type === 'session_error' && event.errorDetails?.code === 'loop_continuation_invalidated')
-            this.store.updateRunMessageState(eventId, 'invalidated');
+        if (eventId) {
+            if (event.type === 'message_queued')
+                this.store.updateRunMessageState(eventId, 'queued');
+            else if (event.type === 'message_started')
+                this.store.updateRunMessageState(eventId, 'active');
+            else if (event.type === 'message_finished')
+                this.store.updateRunMessageState(eventId, 'finished');
+            else if (event.type === 'session_error' && event.errorDetails?.code === 'loop_continuation_invalidated')
+                this.store.updateRunMessageState(eventId, 'invalidated');
+        }
         if (event.type !== 'assistant_usage')
             return;
-        const run = this.store.getRunByMessageEventId(eventId);
-        if (!run || run.piboSessionId !== event.piboSessionId)
+        const provenance = event.provenance;
+        const provenanceRunId = provenance?.kind === 'loop-run'
+            ? provenance.runId
+            : provenance?.kind === 'subagent-request'
+                ? provenance.loopRunId
+                : undefined;
+        const provenanceJobId = provenance?.kind === 'loop-run'
+            ? provenance.jobId
+            : provenance?.kind === 'subagent-request'
+                ? provenance.loopJobId
+                : undefined;
+        const run = provenanceRunId
+            ? this.store.getRun(provenanceRunId)
+            : eventId
+                ? this.store.getRunByMessageEventId(eventId)
+                : undefined;
+        if (!run || (provenanceJobId && run.jobId !== provenanceJobId) || !this.isRunSessionOrDescendant(run, event.piboSessionId))
+            return;
+        if (provenance?.kind === 'loop-run'
+            && provenance.cause === 'run-reminder'
+            && run.messageEventId !== provenance.rootEventId)
             return;
         const job = this.store.getJob(run.jobId);
         if (!job || job.mode !== 'goal')
             return;
         const basis = run.accounting?.tokenAccounting?.basis ?? goalTokenAccounting(job).basis;
-        this.store.recordGoalTurnUsage(job.id, run.id, goalBudgetTokens(event, basis));
+        this.store.recordGoalAssistantUsage(job.id, run.id, {
+            usage: event,
+            budgetTokens: goalBudgetTokens(event, basis),
+            piboSessionId: event.piboSessionId,
+            descendant: event.piboSessionId !== run.piboSessionId,
+        });
+    }
+    isRunSessionOrDescendant(run, piboSessionId) {
+        if (!run.piboSessionId)
+            return false;
+        if (run.piboSessionId === piboSessionId)
+            return true;
+        let current = this.options.context.getSession(piboSessionId);
+        const seen = new Set();
+        while (current?.parentId && !seen.has(current.parentId)) {
+            if (current.parentId === run.piboSessionId)
+                return true;
+            seen.add(current.parentId);
+            current = this.options.context.getSession(current.parentId);
+        }
+        return false;
     }
     handleProductEvent(event) {
         if (event.type !== 'pibo.loop.fact' && event.type !== 'loop.fact' && event.type !== 'pibo.ralph.fact' && event.type !== 'ralph.fact')

package/dist/loops/store.js

@@ -4,7 +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';
+import { addLoopAssistantUsage, 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'; }
@@ -418,29 +418,65 @@ export class PiboLoopStore {
         this.db.prepare('UPDATE pibo_ralph_jobs SET enabled = ?, state_json = ?, updated_at = ? WHERE id = ?').run(budgetLimited ? 0 : job.enabled ? 1 : 0, JSON.stringify(state), timestamp, id);
         return this.getJob(id);
     }
-    recordGoalTurnUsage(id, runId, tokens, now = new Date()) {
+    recordGoalAssistantUsage(id, runId, input, now = new Date()) {
         this.db.exec('BEGIN IMMEDIATE');
         try {
-            const job = this.recordGoalProgress(id, { tokens }, now);
-            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) ?? { 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;
-                    const nextAccounting = { ...accounting, tokensUsed: turnTokens, ...(budget !== undefined ? { overshootTokens: Math.max(0, before + turnTokens - budget) } : {}) };
-                    this.db.prepare('UPDATE pibo_ralph_runs SET accounting_json = ?, updated_at = ? WHERE id = ?').run(runAccountingJson(nextAccounting), nowIso(now), runId);
-                }
+            const job = this.getJob(id);
+            if (!job || job.mode !== 'goal') {
+                this.db.exec('COMMIT');
+                return job;
+            }
+            const tokens = Math.max(0, Math.floor(input.budgetTokens));
+            const nextTokens = (job.state.tokensUsed ?? 0) + tokens;
+            const currentStatus = goalStatus(job) ?? 'active';
+            const budgetLimited = currentStatus === 'active' && job.tokenBudget !== undefined && nextTokens >= job.tokenBudget;
+            const timestamp = nowIso(now);
+            const state = {
+                ...job.state,
+                tokensUsed: nextTokens,
+                usage: addLoopAssistantUsage(job.state.usage, input.usage, {
+                    piboSessionId: input.piboSessionId,
+                    descendant: input.descendant,
+                }),
+                goalStatus: budgetLimited ? 'budget_limited' : currentStatus,
+            };
+            if (budgetLimited)
+                state.goalEndedAt = job.state.goalEndedAt ?? timestamp;
+            this.db.prepare('UPDATE pibo_ralph_jobs SET enabled = ?, state_json = ?, updated_at = ? WHERE id = ?').run(budgetLimited ? 0 : job.enabled ? 1 : 0, JSON.stringify(state), timestamp, id);
+            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) ?? { tokenAccounting: normalizeLoopTokenAccounting(state.tokenAccounting) };
+                const turnTokens = (accounting.tokensUsed ?? 0) + tokens;
+                const budget = accounting.tokenBudget;
+                const before = accounting.tokensUsedBefore ?? 0;
+                const nextAccounting = {
+                    ...accounting,
+                    tokensUsed: turnTokens,
+                    usage: addLoopAssistantUsage(accounting.usage, input.usage, {
+                        piboSessionId: input.piboSessionId,
+                        descendant: input.descendant,
+                    }),
+                    ...(budget !== undefined ? { overshootTokens: Math.max(0, before + turnTokens - budget) } : {}),
+                };
+                this.db.prepare('UPDATE pibo_ralph_runs SET accounting_json = ?, updated_at = ? WHERE id = ?').run(runAccountingJson(nextAccounting), timestamp, runId);
             }
             this.db.exec('COMMIT');
-            return job;
+            return this.getJob(id);
         }
         catch (error) {
             this.db.exec('ROLLBACK');
             throw error;
         }
     }
+    recordGoalTurnUsage(id, runId, tokens, now = new Date()) {
+        const run = this.getRun(runId);
+        return this.recordGoalAssistantUsage(id, runId, {
+            usage: { type: 'assistant_usage', piboSessionId: run?.piboSessionId ?? 'unknown', totalTokens: Math.max(0, Math.floor(tokens)) },
+            budgetTokens: tokens,
+            piboSessionId: run?.piboSessionId ?? 'unknown',
+            descendant: false,
+        }, now);
+    }
     recordGoalRunTime(id, runId, activeTimeSeconds, now = new Date()) {
         const seconds = Math.max(0, Math.floor(activeTimeSeconds));
         this.db.exec('BEGIN IMMEDIATE');
@@ -636,7 +672,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 = {
@@ -833,15 +873,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

@@ -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);

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

@@ -1,3 +1,4 @@
+export const PIBO_RUN_CANCELLATION_SETTLEMENT_TIMEOUT_MS = 15_000;
 export class PiboRunExecutionTimeoutError extends Error {
     timeoutPhase;
     constructor(message, timeoutPhase) {
@@ -6,6 +7,34 @@ 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 async function waitForRunCancellationSettlement(settled, timeoutMs = PIBO_RUN_CANCELLATION_SETTLEMENT_TIMEOUT_MS) {
+    let timer;
+    try {
+        await Promise.race([
+            settled,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error(`Yielded run did not settle within ${timeoutMs}ms after cancellation.`)), timeoutMs);
+                timer.unref?.();
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 export function resolveRunTimeoutMs(toolName, params) {
     if (!params || typeof params !== "object" || Array.isArray(params))
         return undefined;
@@ -26,7 +55,15 @@ export function foregroundServiceWarning(toolName, params, timeoutMs) {
 }
 export function isConfiguredTimeoutError(error) {
     const message = error instanceof Error ? error.message : String(error);
-    return /(?:timed?\s*out|timeout)/i.test(message);
+    const terminalLines = message.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(-5);
+    return terminalLines.some((line) => {
+        const normalized = line.replace(/^error:\s*/i, "");
+        return /^(?:command|process|tool execution|yielded run)\s+timed?\s*out\b.*$/i.test(normalized)
+            || /^timed?\s*out(?:\s+after\s+.+)?[.!]?$/i.test(normalized)
+            || /^timeout(?:\s+error)?[.!]?$/i.test(normalized)
+            || /^timeout(?::|\s+)(?:occurred|expired|exceeded|elapsed|reached)\b.*$/i.test(normalized)
+            || /^timeout(?::|\s+)(?:after\s+)?\d+(?:\.\d+)?\s*(?:ms|milliseconds?|s|secs?|seconds?|m|mins?|minutes?|h|hours?)\b.*$/i.test(normalized);
+    });
 }
 export function hasMeaningfulTimeoutOutput(value) {
     const text = extractText(value);

package/dist/runs/registry.js

@@ -7,6 +7,25 @@ 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;
+    if (left.eventId !== right.eventId || left.provenance.kind !== right.provenance.kind)
+        return false;
+    if (left.provenance.kind === "loop-run" && right.provenance.kind === "loop-run") {
+        return left.provenance.jobId === right.provenance.jobId
+            && left.provenance.runId === right.provenance.runId
+            && left.provenance.cause === right.provenance.cause
+            && left.provenance.rootEventId === right.provenance.rootEventId;
+    }
+    if (left.provenance.kind === "subagent-request" && right.provenance.kind === "subagent-request") {
+        return left.provenance.requestId === right.provenance.requestId
+            && left.provenance.controllerPiboSessionId === right.provenance.controllerPiboSessionId
+            && left.provenance.loopJobId === right.provenance.loopJobId
+            && left.provenance.loopRunId === right.provenance.loopRunId;
+    }
+    return false;
+}
 function formatTimeout(timeoutMs) {
     if (timeoutMs === undefined)
         return "its configured timeout";
@@ -83,6 +102,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 +128,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);
@@ -206,6 +227,16 @@ export class PiboRunRegistry {
             .filter((record) => options.includeDetached || record.completionPolicy !== "detached")
             .map(snapshot);
     }
+    listActiveControllerRuns(controllerPiboSessionId) {
+        return [...this.runs.values()]
+            .filter((record) => record.controllerPiboSessionId === controllerPiboSessionId && !terminal(record.status))
+            .map(snapshot);
+    }
+    listActiveRuns() {
+        return [...this.runs.values()]
+            .filter((record) => !terminal(record.status))
+            .map(snapshot);
+    }
     status(controllerPiboSessionId, runId) {
         return snapshot(this.requireRunForController(controllerPiboSessionId, runId));
     }
@@ -245,7 +276,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);
@@ -258,25 +289,29 @@ export class PiboRunRegistry {
             output.error = record.error;
         return output;
     }
-    cancel(controllerPiboSessionId, runId) {
+    cancel(controllerPiboSessionId, runId, reason = "Run was cancelled.") {
         const record = this.requireRunForController(controllerPiboSessionId, runId);
         const previousStatus = record.status;
         if (!terminal(record.status)) {
             record.status = "cancelled";
+            record.error = reason;
             record.summary = `${record.toolName} run cancelled.`;
             this.finish(record);
             if (record.jobId)
-                this.options.store?.fail(record.jobId, this.workerId, "Run was cancelled.");
+                this.options.store?.fail(record.jobId, this.workerId, reason);
         }
         record.consumed = true;
         record.updatedAt = now();
         this.options.store?.updateRun(runId, record);
         const output = snapshot(record);
-        this.notify({ type: "run_changed", run: output, previousStatus, reason: "Run was cancelled." });
+        this.notify({ type: "run_changed", run: output, previousStatus, reason });
         return output;
     }
     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 +319,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 +341,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: [],
@@ -338,44 +376,6 @@ export class PiboRunRegistry {
     hasPendingNotification(controllerPiboSessionId, options = {}) {
         return [...this.runs.values()].some((record) => this.needsNotification(record, controllerPiboSessionId, options));
     }
-    cancelControllerRuns(controllerPiboSessionId, reason = "Controller Pibo session was disposed.") {
-        const cancelled = [];
-        for (const record of this.runs.values()) {
-            if (record.controllerPiboSessionId !== controllerPiboSessionId || terminal(record.status))
-                continue;
-            record.status = "cancelled";
-            record.error = reason;
-            record.consumed = true;
-            record.summary = `${record.toolName} run cancelled.`;
-            this.finish(record);
-            this.options.store?.updateRun(record.runId, record);
-            if (record.jobId)
-                this.options.store?.fail(record.jobId, this.workerId, reason);
-            const output = snapshot(record);
-            this.notify({ type: "run_changed", run: output, previousStatus: "running", reason });
-            cancelled.push(output);
-        }
-        return cancelled;
-    }
-    cancelAll(reason = "Run registry was disposed.") {
-        const cancelled = [];
-        for (const record of this.runs.values()) {
-            if (terminal(record.status))
-                continue;
-            record.status = "cancelled";
-            record.error = reason;
-            record.consumed = true;
-            record.summary = `${record.toolName} run cancelled.`;
-            this.finish(record);
-            this.options.store?.updateRun(record.runId, record);
-            if (record.jobId)
-                this.options.store?.fail(record.jobId, this.workerId, reason);
-            const output = snapshot(record);
-            this.notify({ type: "run_changed", run: output, previousStatus: "running", reason });
-            cancelled.push(output);
-        }
-        return cancelled;
-    }
     prune(options = {}) {
         const nowMs = options.nowMs ?? Date.now();
         const consumedTerminalTtlMs = options.consumedTerminalTtlMs ??
@@ -461,5 +461,6 @@ function recordFromStored(record) {
         timeoutPhase: record.timeoutPhase,
         serviceWarning: record.serviceWarning,
         resources: record.resources,
+        origin: record.origin,
     };
 }