@pasko70/pibo 2.4.1 → 2.4.2

package/dist/agent-runtime/routed-session.js

@@ -9,6 +9,20 @@ const RUN_REMINDER_CAPABILITY_TOOLS = new Set([
     "pibo_run_cancel",
     "pibo_run_ack",
 ]);
+// Run reminders are autonomous service wakeups, so their provider/tool loop needs a deterministic boundary.
+const RUN_REMINDER_MAX_TOOL_EXECUTIONS = 64;
+const RUN_REMINDER_MAX_PROVIDER_ROUNDS = 64;
+const RUN_REMINDER_MAX_TOTAL_TOKENS = 2_000_000;
+const RUN_REMINDER_MAX_DURATION_MS = 15 * 60 * 1000;
+const RUN_REMINDER_MAX_REPEATED_TOOL_CALLS = 12;
+function serializedToolArgs(value) {
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -82,9 +96,11 @@ export class RuntimeRoutedSession {
     runtimeDisposePromise;
     forceDisposalStarted = false;
     drainPromise;
+    inFlightMessage;
     activeMessage;
     activeExecutionEvent;
     activeMessageFailed = false;
+    runReminderTurnGuard;
     activeAssistantIndex;
     nextAssistantIndex = 0;
     activeThinkingIndex;
@@ -409,6 +425,28 @@ export class RuntimeRoutedSession {
             this.notifyState();
             return true;
         }
+        const inFlight = this.inFlightMessage;
+        if (inFlight?.event.id === eventId) {
+            if (!inFlight.cancellation) {
+                inFlight.cancelled = true;
+                this.notifyMessagesInterrupted([inFlight.event], "message cancelled");
+                const active = this.activeMessage?.id === eventId;
+                inFlight.cancellation = (async () => {
+                    try {
+                        if (active)
+                            await this.runtimeSession.abort();
+                        await inFlight.settled;
+                    }
+                    catch (error) {
+                        inFlight.cancelled = false;
+                        inFlight.cancellation = undefined;
+                        throw error;
+                    }
+                })();
+            }
+            await inFlight.cancellation;
+            return true;
+        }
         if (this.activeMessage?.id === eventId) {
             this.notifyMessagesInterrupted([this.activeMessage], "message cancelled");
             await this.runtimeSession.abort();
@@ -462,6 +500,7 @@ export class RuntimeRoutedSession {
                 return;
             case "tool_execution_started":
                 this.emit(this.withActiveMessage({ ...event, type: "tool_execution_started", piboSessionId: this.piboSessionId }));
+                this.trackRunReminderTurnGuard("tool_execution_started", { toolName: event.toolName, args: event.args });
                 return;
             case "tool_execution_updated":
                 this.emit(this.withActiveMessage({ ...event, type: "tool_execution_updated", piboSessionId: this.piboSessionId }));
@@ -479,7 +518,9 @@ export class RuntimeRoutedSession {
                     cacheWriteTokens: event.usage.cacheWriteTokens,
                     reasoningTokens: event.usage.reasoningTokens,
                     totalTokens: event.usage.totalTokens,
+                    provenance: this.activeMessage?.provenance,
                 }));
+                this.trackRunReminderTurnGuard("usage", { totalTokens: event.usage.totalTokens });
                 return;
             case "compaction_start":
                 this.emit(this.withActiveMessage({
@@ -593,9 +634,10 @@ export class RuntimeRoutedSession {
         }
     }
     async processQueuedMessage(event) {
+        const inFlight = this.beginInFlightMessage(event);
         try {
             const preflight = await this.options.messagePreflight?.(event);
-            if (this.disposed)
+            if (this.disposed || inFlight.cancelled)
                 return;
             if (preflight && !preflight.allowed) {
                 this.emit({
@@ -614,6 +656,10 @@ export class RuntimeRoutedSession {
                 });
                 return;
             }
+            this.activeMessage = event;
+            this.activeMessageFailed = false;
+            this.beginRunReminderTurnGuard(event);
+            this.resetContentIndices();
             this.emit({
                 type: "message_started",
                 piboSessionId: this.piboSessionId,
@@ -622,15 +668,14 @@ export class RuntimeRoutedSession {
                 source: event.source,
                 provenance: event.provenance,
             });
-            this.activeMessage = event;
-            this.activeMessageFailed = false;
-            this.resetContentIndices();
+            if (inFlight.cancelled)
+                return;
             await this.runtimeSession.prompt({
                 text: event.text,
                 source: promptSource(event.source),
                 capabilityScope: event.capabilityScope,
             });
-            if (this.disposed)
+            if (this.disposed || inFlight.cancelled)
                 return;
             if (!this.activeMessageFailed) {
                 this.emit({
@@ -643,7 +688,7 @@ export class RuntimeRoutedSession {
             }
         }
         catch (error) {
-            if (this.disposed)
+            if (this.disposed || inFlight.cancelled)
                 return;
             if (!this.activeMessageFailed) {
                 const message = errorMessage(error);
@@ -661,7 +706,102 @@ export class RuntimeRoutedSession {
             this.activeMessage = undefined;
             this.activeMessageFailed = false;
             this.resetContentIndices();
+            this.clearRunReminderTurnGuard();
+            if (this.inFlightMessage === inFlight)
+                this.inFlightMessage = undefined;
+            inFlight.resolveSettled();
+        }
+    }
+    beginInFlightMessage(event) {
+        let resolveSettled;
+        const inFlight = {
+            event,
+            cancelled: false,
+            settled: new Promise((resolve) => { resolveSettled = resolve; }),
+            resolveSettled: () => { resolveSettled?.(); },
+        };
+        this.inFlightMessage = inFlight;
+        return inFlight;
+    }
+    beginRunReminderTurnGuard(event) {
+        this.clearRunReminderTurnGuard();
+        if (event.source !== "service" || !event.text.startsWith("<pibo_run_notification>"))
+            return;
+        const guard = {
+            eventId: event.id,
+            toolExecutions: 0,
+            providerRounds: 0,
+            totalTokens: 0,
+            toolSignatures: new Map(),
+            tripped: false,
+        };
+        guard.timer = setTimeout(() => {
+            this.tripRunReminderTurnGuard(guard, `exceeded ${RUN_REMINDER_MAX_DURATION_MS / 60_000} minutes`);
+        }, RUN_REMINDER_MAX_DURATION_MS);
+        guard.timer.unref?.();
+        this.runReminderTurnGuard = guard;
+    }
+    clearRunReminderTurnGuard() {
+        const guard = this.runReminderTurnGuard;
+        if (!guard)
+            return;
+        if (guard.timer)
+            clearTimeout(guard.timer);
+        this.runReminderTurnGuard = undefined;
+    }
+    trackRunReminderTurnGuard(type, payload) {
+        const guard = this.runReminderTurnGuard;
+        if (!guard || guard.tripped || guard.eventId !== this.activeMessage?.id)
+            return;
+        if (type === "usage") {
+            const totalTokens = payload.totalTokens ?? 0;
+            guard.totalTokens += totalTokens;
+            guard.providerRounds += 1;
+            if (guard.totalTokens > RUN_REMINDER_MAX_TOTAL_TOKENS) {
+                this.tripRunReminderTurnGuard(guard, `exceeded ${RUN_REMINDER_MAX_TOTAL_TOKENS} total tokens`);
+                return;
+            }
+            if (guard.providerRounds > RUN_REMINDER_MAX_PROVIDER_ROUNDS) {
+                this.tripRunReminderTurnGuard(guard, `exceeded ${RUN_REMINDER_MAX_PROVIDER_ROUNDS} provider rounds`);
+            }
+            return;
         }
+        const toolName = payload.toolName;
+        const args = payload.args;
+        guard.toolExecutions += 1;
+        if (guard.toolExecutions > RUN_REMINDER_MAX_TOOL_EXECUTIONS) {
+            this.tripRunReminderTurnGuard(guard, `exceeded ${RUN_REMINDER_MAX_TOOL_EXECUTIONS} tool executions`);
+            return;
+        }
+        const signature = `${String(toolName ?? "unknown")}:${serializedToolArgs(args)}`;
+        const repeated = (guard.toolSignatures.get(signature) ?? 0) + 1;
+        guard.toolSignatures.set(signature, repeated);
+        if (repeated > RUN_REMINDER_MAX_REPEATED_TOOL_CALLS) {
+            this.tripRunReminderTurnGuard(guard, `repeated the same tool call more than ${RUN_REMINDER_MAX_REPEATED_TOOL_CALLS} times`);
+        }
+    }
+    tripRunReminderTurnGuard(guard, reason) {
+        if (guard.tripped || this.runReminderTurnGuard !== guard)
+            return;
+        guard.tripped = true;
+        this.activeMessageFailed = true;
+        const error = `Run-reminder turn stopped because it ${reason}.`;
+        this.emit({
+            type: "session_error",
+            piboSessionId: this.piboSessionId,
+            eventId: guard.eventId,
+            error,
+            errorDetails: {
+                category: "runtime_abort",
+                errorClass: "runtime_abort",
+                code: "run_reminder_limit_exceeded",
+                origin: "runtime",
+                retryable: false,
+                userMessage: error,
+            },
+            provenance: this.activeMessage?.provenance,
+        });
+        void Promise.resolve(this.runtimeSession.abort()).catch(() => undefined);
     }
     async processQueuedCompact(event) {
         this.activeExecutionEvent = event;
@@ -851,7 +991,10 @@ export class RuntimeRoutedSession {
     }
     activeAndQueuedMessages() {
         const messages = this.queue.flatMap((item) => item.kind === "message" ? [item.event] : []);
-        return this.activeMessage ? [this.activeMessage, ...messages] : messages;
+        const inFlight = this.inFlightMessage?.event;
+        if (this.activeMessage)
+            return [this.activeMessage, ...messages];
+        return inFlight ? [inFlight, ...messages] : messages;
     }
     notifyMessagesInterrupted(messages, reason) {
         if (messages.length === 0)

package/dist/agent-runtimes/pi/routed-session.js

@@ -451,6 +451,7 @@ export class RoutedSession {
     runtimeDisposePromise;
     forceDisposalStarted = false;
     drainPromise;
+    inFlightMessage;
     fastMode = false;
     fastModePatchedAgents = new WeakSet();
     activeMessage;
@@ -1101,6 +1102,31 @@ export class RoutedSession {
             this.onStateChange?.({ processing: this.processing, queuedMessages: this.queue.length, disposed: this.disposed });
             return true;
         }
+        const inFlight = this.inFlightMessage;
+        if (inFlight?.event.id === eventId) {
+            if (!inFlight.cancellation) {
+                inFlight.cancelled = true;
+                this.notifyMessagesInterrupted([inFlight.event], "message cancelled");
+                const active = this.activeMessage?.id === eventId;
+                inFlight.cancellation = (async () => {
+                    try {
+                        if (active) {
+                            this.cancelProviderRecovery();
+                            this.cancelContextGuardRecovery("Context guard recovery cancelled with the active message");
+                            await this.runtime.session.abort();
+                        }
+                        await inFlight.settled;
+                    }
+                    catch (error) {
+                        inFlight.cancelled = false;
+                        inFlight.cancellation = undefined;
+                        throw error;
+                    }
+                })();
+            }
+            await inFlight.cancellation;
+            return true;
+        }
         if (this.activeMessage?.id === eventId) {
             this.notifyMessagesInterrupted([this.activeMessage], "message cancelled");
             this.cancelProviderRecovery();
@@ -1143,9 +1169,10 @@ export class RoutedSession {
         }
     }
     async processQueuedMessage(event) {
+        const inFlight = this.beginInFlightMessage(event);
         try {
             const preflight = await this.messagePreflight?.(event);
-            if (this.disposed)
+            if (this.disposed || inFlight.cancelled)
                 return;
             if (preflight && !preflight.allowed) {
                 this.emit({
@@ -1166,16 +1193,8 @@ export class RoutedSession {
             }
             const session = this.runtime.session;
             await this.resumeTranscriptIntegrityRecovery(session);
-            if (this.disposed)
+            if (this.disposed || inFlight.cancelled)
                 return;
-            this.emit({
-                type: "message_started",
-                piboSessionId: this.piboSessionId,
-                eventId: event.id,
-                text: event.text,
-                source: event.source,
-                provenance: event.provenance,
-            });
             this.activeMessage = event;
             this.providerRecoveryCancelled = false;
             this.pendingAssistantError = undefined;
@@ -1185,19 +1204,29 @@ export class RoutedSession {
             this.nextAssistantIndex = 0;
             this.activeThinkingIndex = undefined;
             this.nextThinkingIndex = 0;
+            this.emit({
+                type: "message_started",
+                piboSessionId: this.piboSessionId,
+                eventId: event.id,
+                text: event.text,
+                source: event.source,
+                provenance: event.provenance,
+            });
+            if (inFlight.cancelled)
+                return;
             this.applyMessageCapabilityScope(event, session);
             const expandedText = expandInlineSkills(event.text, session.resourceLoader.getSkills().skills);
             await session.prompt(expandedText, { source: promptSource(event.source) });
-            if (this.disposed)
+            if (this.disposed || inFlight.cancelled)
                 return;
             await this.waitForPiAgentSettlement(session);
-            if (this.disposed)
+            if (this.disposed || inFlight.cancelled)
                 return;
             await this.resumeContextGuardRecovery(session);
-            if (this.disposed)
+            if (this.disposed || inFlight.cancelled)
                 return;
             await this.recoverTransientProviderErrors(session);
-            if (this.disposed)
+            if (this.disposed || inFlight.cancelled)
                 return;
             this.flushPendingAssistantError();
             if (!this.activeMessageFailed) {
@@ -1211,7 +1240,7 @@ export class RoutedSession {
             }
         }
         catch (error) {
-            if (error instanceof PiboProviderRecoveryCancelledError || this.disposed)
+            if (error instanceof PiboProviderRecoveryCancelledError || this.disposed || inFlight.cancelled)
                 return;
             const message = errorMessage(error);
             this.emit({
@@ -1234,8 +1263,22 @@ export class RoutedSession {
             this.nextAssistantIndex = 0;
             this.activeThinkingIndex = undefined;
             this.nextThinkingIndex = 0;
+            if (this.inFlightMessage === inFlight)
+                this.inFlightMessage = undefined;
+            inFlight.resolveSettled();
         }
     }
+    beginInFlightMessage(event) {
+        let resolveSettled;
+        const inFlight = {
+            event,
+            cancelled: false,
+            settled: new Promise((resolve) => { resolveSettled = resolve; }),
+            resolveSettled: () => { resolveSettled?.(); },
+        };
+        this.inFlightMessage = inFlight;
+        return inFlight;
+    }
     applyMessageCapabilityScope(event, session) {
         if (event.capabilityScope !== "run-reminder")
             return;
@@ -1395,7 +1438,10 @@ export class RoutedSession {
     }
     activeAndQueuedMessages() {
         const messages = this.queue.flatMap((item) => item.kind === "message" ? [item.event] : []);
-        return this.activeMessage ? [this.activeMessage, ...messages] : messages;
+        const inFlight = this.inFlightMessage?.event;
+        if (this.activeMessage)
+            return [this.activeMessage, ...messages];
+        return inFlight ? [inFlight, ...messages] : messages;
     }
     notifyMessagesInterrupted(messages, reason) {
         if (messages.length === 0)

package/dist/core/session-router.js

@@ -5,7 +5,7 @@ import { RuntimeRoutedSession as RoutedSession, } from "../agent-runtime/routed-
 import { runtimeSessionErrorDetails } from "./session-errors.js";
 import { normalizePiboAgentObservationCursor, normalizePiboAgentObservationLimit, normalizePiboAgentObservationOrder, parsePiboAgentObservationTimestamp, piboAgentObservationDetails, piboAgentObservationKind, piboAgentObservationRole, piboAgentObservationSourceFromEvent, piboAgentObservationText, } from "../subagents/observations.js";
 import { PiboRunRegistry } from "../runs/registry.js";
-import { PiboRunExecutionTimeoutError } from "../runs/lifecycle.js";
+import { PiboRunCancellationError, PiboRunCancelledError, PiboRunExecutionTimeoutError } from "../runs/lifecycle.js";
 import { PiboRunResourceLimitError } from "../runs/resource-isolation.js";
 import { createPiboSignalRegistry } from "../signals/registry.js";
 import { createDefaultPiboReliabilityStore } from "../reliability/store.js";
@@ -150,7 +150,29 @@ function formatRunReminderMessage(notification) {
     ].join("\n");
 }
 function isRunReminderServiceMessage(event) {
-    return event.source === "service" && event.capabilityScope === "run-reminder";
+    return event.source === "service" && event.text.startsWith("<pibo_run_notification>");
+}
+function yieldedRunOrigin(event) {
+    if (!event?.id || event.provenance?.kind !== "loop-run")
+        return undefined;
+    return {
+        eventId: event.provenance.rootEventId ?? event.id,
+        provenance: {
+            kind: event.provenance.kind,
+            jobId: event.provenance.jobId,
+            runId: event.provenance.runId,
+        },
+    };
+}
+function runReminderProvenance(notification) {
+    const origin = notification.origin;
+    if (!origin || origin.provenance.kind !== "loop-run")
+        return undefined;
+    return {
+        ...origin.provenance,
+        cause: "run-reminder",
+        rootEventId: origin.eventId,
+    };
 }
 function isTerminalRunStatus(status) {
     return status === "completed" || status === "failed" || status === "timed_out" || status === "cancelled";
@@ -235,7 +257,7 @@ export class PiboSessionRouter {
     portableHistoryProvider;
     runtimeResourceSessions = new Map();
     runtimeAuthFingerprints = new Map();
-    activeSubagentChildren = new Map();
+    activeSubagentRequests = new Map();
     agentObservations = [];
     agentObservationEvictedThroughByParent = new Map();
     nextAgentObservationSequence = 1;
@@ -388,11 +410,24 @@ export class PiboSessionRouter {
                 teardownCompleted = true;
                 return output;
             }
-            const childAbort = event.action === "abort"
-                ? this.abortActiveSubagentSessions(event.piboSessionId)
-                : undefined;
-            const output = await session.executeAction(event);
-            await childAbort;
+            let output;
+            if (event.action === "abort") {
+                const [sessionAbort, childAbort] = await Promise.allSettled([
+                    session.executeAction(event),
+                    this.abortActiveSubagentSessions(event.piboSessionId),
+                ]);
+                if (sessionAbort.status === "rejected" && childAbort.status === "rejected") {
+                    throw new AggregateError([sessionAbort.reason, childAbort.reason], "Failed to abort the session and its active subagent requests.");
+                }
+                if (sessionAbort.status === "rejected")
+                    throw sessionAbort.reason;
+                if (childAbort.status === "rejected")
+                    throw childAbort.reason;
+                output = sessionAbort.value;
+            }
+            else {
+                output = await session.executeAction(event);
+            }
             if (event.action === "kill" || event.action === "kill_all") {
                 await this.disposeSessionSubtree(event.piboSessionId, `${event.action} action`, { cancelRuns: event.action === "kill_all" });
                 teardownCompleted = true;
@@ -837,20 +872,10 @@ export class PiboSessionRouter {
         const eventWithId = { ...event, id: event.id ?? randomUUID() };
         return await new Promise((resolve, reject) => {
             let settled = false;
-            let messageDispatched = false;
+            let dispatchPromise;
             let lastAssistantMessage;
             let timeout;
-            const abortChild = () => {
-                if (!messageDispatched)
-                    return;
-                void this.emit({
-                    type: "execution",
-                    piboSessionId: eventWithId.piboSessionId,
-                    action: "abort",
-                    id: randomUUID(),
-                }).catch(() => { });
-            };
-            const finish = (result) => {
+            const claimSettlement = () => {
                 if (settled)
                     return false;
                 settled = true;
@@ -858,16 +883,33 @@ export class PiboSessionRouter {
                     clearTimeout(timeout);
                 signal?.removeEventListener("abort", onAbort);
                 unsubscribe();
+                return true;
+            };
+            const finish = (result) => {
+                if (!claimSettlement())
+                    return;
                 if (result instanceof Error)
                     reject(result);
                 else
                     resolve(result);
-                return true;
             };
-            const onAbort = () => {
-                if (!finish(subagentAbortError()))
+            const rejectAfterMessageCancellation = (error) => {
+                if (!claimSettlement())
                     return;
-                abortChild();
+                void (async () => {
+                    try {
+                        await dispatchPromise;
+                        await this.cancelSessionMessage(eventWithId.piboSessionId, eventWithId.id);
+                    }
+                    catch (cancellationError) {
+                        reject(new PiboRunCancellationError(`Failed to cancel subagent request "${eventWithId.id}" in Pibo session "${eventWithId.piboSessionId}".`, { cause: cancellationError }));
+                        return;
+                    }
+                    reject(error);
+                })();
+            };
+            const onAbort = () => {
+                rejectAfterMessageCancellation(subagentAbortError());
             };
             const unsubscribe = this.subscribe((output) => {
                 if (output.piboSessionId !== eventWithId.piboSessionId ||
@@ -886,20 +928,25 @@ export class PiboSessionRouter {
                 }
             });
             if (signal?.aborted) {
-                onAbort();
+                finish(subagentAbortError());
                 return;
             }
             signal?.addEventListener("abort", onAbort, { once: true });
             timeout = setTimeout(() => {
-                const timeoutError = new Error(`Timed out waiting for assistant reply from Pibo session "${eventWithId.piboSessionId}"`);
-                if (!finish(timeoutError))
-                    return;
-                abortChild();
+                rejectAfterMessageCancellation(new PiboRunExecutionTimeoutError(`Timed out waiting for assistant reply from Pibo session "${eventWithId.piboSessionId}"`, "lifetime"));
             }, timeoutMs);
-            messageDispatched = true;
-            this.emit(eventWithId).catch(finish);
+            dispatchPromise = this.emit(eventWithId);
+            dispatchPromise.catch((error) => {
+                finish(error instanceof Error ? error : new Error(String(error)));
+            });
         });
     }
+    async cancelSessionMessage(piboSessionId, eventId) {
+        const session = this.sessions.get(piboSessionId);
+        if (!session || !await session.cancelMessage(eventId)) {
+            throw new Error(`Pibo session "${piboSessionId}" no longer owns message "${eventId}".`);
+        }
+    }
     async disposeAll() {
         if (this.disposePromise)
             return this.disposePromise;
@@ -946,7 +993,7 @@ export class PiboSessionRouter {
             await this.portableToolService.dispose();
             await this.runtimeResourceService.dispose();
             this.runtimeResourceSessions.clear();
-            this.activeSubagentChildren.clear();
+            this.activeSubagentRequests.clear();
             this.agentObservations.length = 0;
             this.agentObservationEvictedThroughByParent.clear();
             await this.telemetryWriter?.dispose();
@@ -1562,44 +1609,40 @@ export class PiboSessionRouter {
         this.signalRegistry.project({ type: "session_created", session: created });
         return created;
     }
-    trackActiveSubagent(parentPiboSessionId, childPiboSessionId) {
-        let children = this.activeSubagentChildren.get(parentPiboSessionId);
-        if (!children) {
-            children = new Map();
-            this.activeSubagentChildren.set(parentPiboSessionId, children);
+    trackActiveSubagent(parentPiboSessionId, request) {
+        let requests = this.activeSubagentRequests.get(parentPiboSessionId);
+        if (!requests) {
+            requests = new Set();
+            this.activeSubagentRequests.set(parentPiboSessionId, requests);
         }
-        children.set(childPiboSessionId, (children.get(childPiboSessionId) ?? 0) + 1);
+        requests.add(request);
         let active = true;
         return () => {
             if (!active)
                 return;
             active = false;
-            const current = this.activeSubagentChildren.get(parentPiboSessionId);
+            const current = this.activeSubagentRequests.get(parentPiboSessionId);
             if (!current)
                 return;
-            const remaining = (current.get(childPiboSessionId) ?? 1) - 1;
-            if (remaining > 0)
-                current.set(childPiboSessionId, remaining);
-            else
-                current.delete(childPiboSessionId);
+            current.delete(request);
             if (current.size === 0)
-                this.activeSubagentChildren.delete(parentPiboSessionId);
+                this.activeSubagentRequests.delete(parentPiboSessionId);
         };
     }
     async abortActiveSubagentSessions(parentPiboSessionId) {
-        const childIds = [...(this.activeSubagentChildren.get(parentPiboSessionId)?.keys() ?? [])];
-        if (childIds.length === 0)
-            return;
-        await Promise.allSettled(childIds.map(async (childPiboSessionId) => await this.emit({
-            type: "execution",
-            piboSessionId: childPiboSessionId,
-            action: "abort",
-            id: randomUUID(),
-        })));
+        const requests = [...(this.activeSubagentRequests.get(parentPiboSessionId) ?? [])];
+        for (const request of requests)
+            request.abortController.abort();
+        const settlements = await Promise.all(requests.map(async (request) => await request.settled));
+        const failures = settlements.flatMap((settlement) => settlement.status === "rejected" ? [settlement.reason] : []);
+        if (failures.length > 0)
+            throw new AggregateError(failures, "Failed to cancel active subagent requests.");
     }
     createAgentsController(parentPiboSessionId) {
         return {
             sendMessage: async ({ subagent, message, threadKey, toolCallId, signal }) => {
+                if (signal?.aborted)
+                    throw subagentAbortError();
                 this.assertSubagentDepth(parentPiboSessionId, subagent);
                 const child = this.resolveSubagentSession(parentPiboSessionId, subagent, threadKey);
                 const resolvedThreadKey = typeof child.metadata?.threadKey === "string" ? child.metadata.threadKey : "";
@@ -1619,9 +1662,21 @@ export class PiboSessionRouter {
                     childPiboSessionId: child.id,
                     threadKey: resolvedThreadKey,
                 });
-                const untrack = this.trackActiveSubagent(parentPiboSessionId, child.id);
+                const parentAbortController = new AbortController();
+                const requestSignal = signal
+                    ? AbortSignal.any([signal, parentAbortController.signal])
+                    : parentAbortController.signal;
+                let resolveSettled;
+                const settled = new Promise((resolve) => {
+                    resolveSettled = resolve;
+                });
+                const untrack = this.trackActiveSubagent(parentPiboSessionId, {
+                    abortController: parentAbortController,
+                    settled,
+                });
+                let settlement = { status: "fulfilled" };
                 try {
-                    const reply = await this.emitMessageAndWaitForReply(event, subagent.timeoutMs ?? DEFAULT_SUBAGENT_REPLY_TIMEOUT_MS, signal);
+                    const reply = await this.emitMessageAndWaitForReply(event, subagent.timeoutMs ?? DEFAULT_SUBAGENT_REPLY_TIMEOUT_MS, requestSignal);
                     return {
                         agentId: child.id,
                         name: subagent.name,
@@ -1631,8 +1686,17 @@ export class PiboSessionRouter {
                         reply,
                     };
                 }
+                catch (error) {
+                    const confirmedParentCancellation = parentAbortController.signal.aborted
+                        && error instanceof Error
+                        && error.name === "AbortError";
+                    if (!confirmedParentCancellation)
+                        settlement = { status: "rejected", reason: error };
+                    throw error;
+                }
                 finally {
                     untrack();
+                    resolveSettled?.(settlement);
                 }
             },
             listAgents: () => this.listManagedAgents(parentPiboSessionId),
@@ -1767,8 +1831,9 @@ export class PiboSessionRouter {
             const cancel = this.runCancellationHandlers.get(run.runId);
             if (!cancel)
                 return;
-            this.runCancellationHandlers.delete(run.runId);
             await cancel();
+            if (this.runCancellationHandlers.get(run.runId) === cancel)
+                this.runCancellationHandlers.delete(run.runId);
         }));
         const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
         if (failures.length > 0)
@@ -1796,14 +1861,32 @@ export class PiboSessionRouter {
                         timeoutMs,
                         serviceWarning,
                         resources,
+                        origin: yieldedRunOrigin(this.sessions.get(parentPiboSessionId)?.getActiveMessage?.()),
                     });
                 }
                 catch (error) {
                     admission.release();
                     throw error;
                 }
-                if (cancel)
-                    this.runCancellationHandlers.set(run.runId, cancel);
+                const cancellation = { state: "none" };
+                if (cancel) {
+                    this.runCancellationHandlers.set(run.runId, async () => {
+                        cancellation.state = "pending";
+                        let resolveDecision;
+                        cancellation.decision = new Promise((resolve) => { resolveDecision = resolve; });
+                        try {
+                            await cancel();
+                            cancellation.state = "confirmed";
+                        }
+                        catch (error) {
+                            cancellation.state = "failed";
+                            throw error;
+                        }
+                        finally {
+                            resolveDecision?.();
+                        }
+                    });
+                }
                 void (async () => {
                     try {
                         const result = await execute();
@@ -1814,6 +1897,12 @@ export class PiboSessionRouter {
                             this.handleTerminalRunReminder(parentPiboSessionId, completed.runId, reminderGeneration);
                     }
                     catch (error) {
+                        if (error instanceof PiboRunCancelledError) {
+                            if (cancellation.state === "pending")
+                                await cancellation.decision;
+                            if (cancellation.state === "confirmed")
+                                return;
+                        }
                         const message = error instanceof Error ? error.message : String(error);
                         if (resources)
                             this.runRegistry.updateResources(run.runId, resources);
@@ -1842,14 +1931,15 @@ export class PiboSessionRouter {
                 return run;
             },
             cancelRun: async (runId) => {
-                const cancelled = this.runRegistry.cancel(parentPiboSessionId, runId);
+                const current = this.runRegistry.status(parentPiboSessionId, runId);
                 try {
-                    await this.invokeRunCancellationHandlers([cancelled]);
+                    if (!isTerminalRunStatus(current.status))
+                        await this.invokeRunCancellationHandlers([current]);
+                    return this.runRegistry.cancel(parentPiboSessionId, runId);
                 }
                 finally {
                     this.refreshQueuedRunReminders(parentPiboSessionId);
                 }
-                return cancelled;
             },
             ackRun: (runId) => {
                 const run = this.runRegistry.ack(parentPiboSessionId, runId);
@@ -2067,8 +2157,8 @@ export class PiboSessionRouter {
                 piboSessionId,
                 text: formatRunReminderMessage(notification),
                 source: "service",
-                capabilityScope: "run-reminder",
                 id: randomUUID(),
+                provenance: runReminderProvenance(notification),
             });
         }
         catch (error) {

package/dist/loops/service.js

@@ -531,9 +531,13 @@ export class PiboLoopService {
             this.store.updateRunMessageState(eventId, 'invalidated');
         if (event.type !== 'assistant_usage')
             return;
-        const run = this.store.getRunByMessageEventId(eventId);
+        const provenance = event.provenance?.kind === 'loop-run' ? event.provenance : undefined;
+        const run = this.store.getRunByMessageEventId(eventId) ?? (provenance ? this.store.getRun(provenance.runId) : undefined);
         if (!run || run.piboSessionId !== event.piboSessionId)
             return;
+        if (provenance && (run.jobId !== provenance.jobId
+            || (provenance.cause === 'run-reminder' && run.messageEventId !== provenance.rootEventId)))
+            return;
         const job = this.store.getJob(run.jobId);
         if (!job || job.mode !== 'goal')
             return;

package/dist/loops/store.js

@@ -636,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 = {
@@ -833,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

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

@@ -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/npm-shrinkwrap.json

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

package/package.json

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