@pasko70/pibo 2.4.1 → 2.4.3

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, waitForRunCancellationSettlement } from "../runs/lifecycle.js";
 import { PiboRunResourceLimitError } from "../runs/resource-isolation.js";
 import { createPiboSignalRegistry } from "../signals/registry.js";
 import { createDefaultPiboReliabilityStore } from "../reliability/store.js";
@@ -29,7 +29,6 @@ import { createPiboToolPayloadWriter } from "../tools/payload-writer.js";
 import { PiboPortableToolService, } from "../tools/session-service.js";
 import { PiboRuntimeResourceService, } from "../agent-runtime/resource-service.js";
 import { PORTABLE_HISTORY_HANDOFF_METADATA_KEY, PORTABLE_HISTORY_LAST_IMPORT_METADATA_KEY, PiboDataPortableHistoryProvider, createPortableHistoryHandoffMetadata, readPortableHistoryHandoffMetadata, withoutPortableHistoryHandoffMetadata, withPortableHistoryHandoffMetadata, } from "../agent-runtime/portable-history.js";
-const DEFAULT_SUBAGENT_REPLY_TIMEOUT_MS = 10 * 60 * 1000;
 const DEFAULT_SUBAGENT_MAX_DEPTH = 1;
 const MAX_SUBAGENT_THREAD_KEY_BYTES = 512;
 const MAX_AGENT_OBSERVATIONS = 5_000;
@@ -70,6 +69,9 @@ function subagentAbortError() {
     error.name = "AbortError";
     return error;
 }
+function subagentRequestEventKey(piboSessionId, eventId) {
+    return `${piboSessionId}\u0000${eventId}`;
+}
 function profileForSession(baseProfile, runtimeInstanceId, nativeSessionId, parentNativeSessionId, subagentDepth) {
     const usesProfileRuntime = baseProfile.runtimeInstanceId === runtimeInstanceId;
     const options = {
@@ -150,7 +152,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,13 +259,15 @@ export class PiboSessionRouter {
     portableHistoryProvider;
     runtimeResourceSessions = new Map();
     runtimeAuthFingerprints = new Map();
-    activeSubagentChildren = new Map();
+    activeSubagentRequests = new Map();
+    subagentRequestIdsByEvent = new Map();
     agentObservations = [];
     agentObservationEvictedThroughByParent = new Map();
     nextAgentObservationSequence = 1;
     scheduledRunReminders = new Map();
     runReminderGenerations = new Map();
     runCancellationHandlers = new Map();
+    activeRunExecutions = new Set();
     quiescingSessions = new Set();
     disposingSessions = new Map();
     idleSessionTimers = new Map();
@@ -388,11 +414,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;
@@ -446,24 +485,24 @@ export class PiboSessionRouter {
         const failures = [];
         for (const id of ids) {
             const session = this.sessions.get(id);
-            if (session) {
-                this.signalRegistry.project({ type: "session_disposed", piboSessionId: id, reason: "kill" });
-                try {
-                    killed.push(await session.kill());
-                }
-                catch (error) {
-                    failures.push(error);
-                }
+            if (!session)
+                continue;
+            this.signalRegistry.project({ type: "session_disposed", piboSessionId: id, reason: "kill" });
+            try {
+                killed.push(await session.kill());
             }
-            if (options?.includeRuns) {
-                const runs = this.runRegistry.cancelControllerRuns(id);
-                cancelledRuns.push(...runs.map((run) => run.runId));
-                try {
-                    await this.invokeRunCancellationHandlers(runs);
-                }
-                catch (error) {
-                    failures.push(error);
-                }
+            catch (error) {
+                failures.push(error);
+            }
+        }
+        if (options?.includeRuns) {
+            const runs = ids.flatMap((id) => this.runRegistry.listActiveControllerRuns(id));
+            try {
+                const cancelled = await this.cancelRunsAfterSettlement(runs, "Pibo session subtree was killed.");
+                cancelledRuns.push(...cancelled.map((run) => run.runId));
+            }
+            catch (error) {
+                failures.push(error);
             }
         }
         try {
@@ -520,10 +559,9 @@ export class PiboSessionRouter {
         const operation = (async () => {
             await startGate;
             const runCancellationResults = options.cancelRuns
-                ? await Promise.allSettled(ids.map(async (id) => {
-                    const runs = this.runRegistry.cancelControllerRuns(id);
-                    await this.invokeRunCancellationHandlers(runs);
-                }))
+                ? await Promise.allSettled([
+                    this.cancelRunsAfterSettlement(ids.flatMap((id) => this.runRegistry.listActiveControllerRuns(id)), reason),
+                ])
                 : [];
             const pending = ids.map((id) => this.pendingSessions.get(id)).filter((value) => Boolean(value));
             if (pending.length > 0)
@@ -597,11 +635,11 @@ export class PiboSessionRouter {
             const childSession = this.sessions.get(id);
             if (childSession)
                 killed.push(await childSession.kill());
-            if (options?.includeRuns) {
-                const runs = this.runRegistry.cancelControllerRuns(id);
-                cancelledRuns.push(...runs.map((run) => run.runId));
-                await this.invokeRunCancellationHandlers(runs);
-            }
+            if (!options?.includeRuns)
+                continue;
+            const runs = this.runRegistry.listActiveControllerRuns(id);
+            const cancelled = await this.cancelRunsAfterSettlement(runs, `Child Pibo session "${id}" was killed.`);
+            cancelledRuns.push(...cancelled.map((run) => run.runId));
         }
         return { killed, cancelledRuns };
     }
@@ -652,6 +690,18 @@ export class PiboSessionRouter {
         const session = this.sessionStore.get(piboSessionId);
         return session ? structuredClone(this.resolveSessionRuntimeBinding(session)) : undefined;
     }
+    getSessionRuntimeProfile(piboSessionId) {
+        const session = this.resolvePiboSession(piboSessionId);
+        const binding = this.resolveSessionRuntimeBinding(session);
+        const parent = session.parentId ? this.resolvePiboSession(session.parentId) : undefined;
+        const parentBinding = parent ? this.resolveSessionRuntimeBinding(parent) : undefined;
+        const parentNativeSessionId = parentBinding
+            && parentBinding.runtimeInstanceId === binding.runtimeInstanceId
+            && parentBinding.adapterId === binding.adapterId
+            ? parentBinding.nativeSessionId
+            : undefined;
+        return profileForSession(createPiboProfileFromRegistryOrDefault(this.pluginRegistry, session.profile), binding.runtimeInstanceId, binding.nativeSessionId, parentNativeSessionId, this.getSubagentDepth(session.id));
+    }
     async rebindSessionRuntime(piboSessionId, input) {
         if (this.quiescingSessions.has(piboSessionId)) {
             throw new Error(`Pibo session "${piboSessionId}" is already quiescing.`);
@@ -833,24 +883,14 @@ export class PiboSessionRouter {
     subscribeSignalStatuses(listener) {
         return this.signalRegistry.subscribeAll(listener);
     }
-    async emitMessageAndWaitForReply(event, timeoutMs = 120000, signal) {
+    async emitMessageAndWaitForReply(event, timeoutMs, signal) {
         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 +898,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 +943,27 @@ 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();
-            }, timeoutMs);
-            messageDispatched = true;
-            this.emit(eventWithId).catch(finish);
+            if (timeoutMs !== undefined) {
+                timeout = setTimeout(() => {
+                    rejectAfterMessageCancellation(new PiboRunExecutionTimeoutError(`Timed out waiting for assistant reply from Pibo session "${eventWithId.piboSessionId}"`, "lifetime"));
+                }, timeoutMs);
+            }
+            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;
@@ -916,8 +980,9 @@ export class PiboSessionRouter {
             for (const timer of this.idleSessionTimers.values())
                 clearTimeout(timer);
             this.idleSessionTimers.clear();
-            const cancelledRuns = this.runRegistry.cancelAll("Pibo session router was disposed.");
-            const runCancellationResult = await Promise.allSettled([this.invokeRunCancellationHandlers(cancelledRuns)]);
+            const runCancellationResult = await Promise.allSettled([
+                this.cancelRunsAfterSettlement(this.runRegistry.listActiveRuns(), "Pibo session router was disposed."),
+            ]);
             this.scheduledRunReminders.clear();
             const closeResult = await Promise.allSettled([this.runtimeRegistry.closeAll({ force: true })]);
             const disposeResults = await Promise.allSettled(sessions.map(([id, session]) => this.disposeRoutedSession(id, session, "router disposed")));
@@ -946,7 +1011,8 @@ export class PiboSessionRouter {
             await this.portableToolService.dispose();
             await this.runtimeResourceService.dispose();
             this.runtimeResourceSessions.clear();
-            this.activeSubagentChildren.clear();
+            this.activeSubagentRequests.clear();
+            this.subagentRequestIdsByEvent.clear();
             this.agentObservations.length = 0;
             this.agentObservationEvictedThroughByParent.clear();
             await this.telemetryWriter?.dispose();
@@ -1031,19 +1097,13 @@ export class PiboSessionRouter {
         const piboSession = this.resolvePiboSession(piboSessionId);
         let session;
         this.signalRegistry.project({ type: "session_created", session: piboSession });
-        const profile = createPiboProfileFromRegistryOrDefault(this.pluginRegistry, piboSession.profile);
         let binding = this.resolveSessionRuntimeBinding(piboSession);
         const parent = piboSession.parentId ? this.resolvePiboSession(piboSession.parentId) : undefined;
         const parentBinding = parent ? this.resolveSessionRuntimeBinding(parent) : undefined;
         const parentModelScopeId = parent ? parentBinding?.nativeSessionId ?? parent.id : undefined;
-        const runtimeParentNativeSessionId = parentBinding
-            && parentBinding.runtimeInstanceId === binding.runtimeInstanceId
-            && parentBinding.adapterId === binding.adapterId
-            ? parentBinding.nativeSessionId
-            : undefined;
         const modelDefaults = this.resolveModelDefaults();
         const initialThinkingLevel = resolvePiboSessionInitialThinkingLevel(piboSession);
-        const sessionProfile = profileForSession(profile, binding.runtimeInstanceId, binding.nativeSessionId, runtimeParentNativeSessionId, this.getSubagentDepth(piboSession.id));
+        const sessionProfile = this.getSessionRuntimeProfile(piboSession.id);
         const persistedHistoryHandoff = readPortableHistoryHandoffMetadata(binding.metadata);
         if (binding.metadata?.[PORTABLE_HISTORY_HANDOFF_METADATA_KEY] !== undefined && !persistedHistoryHandoff) {
             throw new Error("The pending portable history handoff metadata is invalid; refusing to start a contextless target runtime.");
@@ -1562,77 +1622,118 @@ 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 }) => {
+            sendMessage: async ({ subagent, message, threadKey, toolCallId, requestId, parentProvenance, signal }) => {
+                if (signal?.aborted)
+                    throw subagentAbortError();
+                if (typeof requestId !== "string" || !requestId.trim())
+                    throw new Error("Delegated agent requestId is required.");
                 this.assertSubagentDepth(parentPiboSessionId, subagent);
                 const child = this.resolveSubagentSession(parentPiboSessionId, subagent, threadKey);
                 const resolvedThreadKey = typeof child.metadata?.threadKey === "string" ? child.metadata.threadKey : "";
+                const loopJobId = parentProvenance?.kind === "loop-run"
+                    ? parentProvenance.jobId
+                    : parentProvenance?.kind === "subagent-request"
+                        ? parentProvenance.loopJobId
+                        : undefined;
+                const loopRunId = parentProvenance?.kind === "loop-run"
+                    ? parentProvenance.runId
+                    : parentProvenance?.kind === "subagent-request"
+                        ? parentProvenance.loopRunId
+                        : undefined;
                 const event = {
                     type: "message",
                     piboSessionId: child.id,
                     text: message,
                     source: "actor",
                     id: randomUUID(),
+                    provenance: {
+                        kind: "subagent-request",
+                        requestId,
+                        controllerPiboSessionId: parentPiboSessionId,
+                        ...(loopJobId ? { loopJobId } : {}),
+                        ...(loopRunId ? { loopRunId } : {}),
+                    },
                 };
+                this.subagentRequestIdsByEvent.set(subagentRequestEventKey(child.id, event.id), requestId);
                 this.emitOutput({
                     type: "subagent_session",
                     piboSessionId: parentPiboSessionId,
+                    requestId,
                     toolCallId,
                     toolName: "pibo_agents_send_message",
                     subagentName: subagent.name,
                     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, undefined, requestSignal);
                     return {
+                        requestId,
                         agentId: child.id,
                         name: subagent.name,
                         profile: child.profile,
                         threadKey: resolvedThreadKey,
                         eventId: event.id,
+                        finalMessage: reply.text,
                         reply,
                     };
                 }
+                catch (error) {
+                    const confirmedParentCancellation = parentAbortController.signal.aborted
+                        && error instanceof Error
+                        && error.name === "AbortError";
+                    if (!confirmedParentCancellation)
+                        settlement = { status: "rejected", reason: error };
+                    throw error;
+                }
                 finally {
+                    this.subagentRequestIdsByEvent.delete(subagentRequestEventKey(child.id, event.id));
                     untrack();
+                    resolveSettled?.(settlement);
                 }
             },
             listAgents: () => this.listManagedAgents(parentPiboSessionId),
@@ -1680,6 +1781,7 @@ export class PiboSessionRouter {
         if (since !== undefined && until !== undefined && since > until) {
             throw new Error("Agent observation since must not be after until.");
         }
+        const requestIds = input.requestIds ? new Set(input.requestIds) : undefined;
         const agentIds = input.agentIds ? new Set(input.agentIds) : undefined;
         if (agentIds) {
             for (const agentId of agentIds)
@@ -1689,10 +1791,13 @@ export class PiboSessionRouter {
         const threadKeys = input.threadKeys ? new Set(input.threadKeys) : undefined;
         const eventTypes = input.eventTypes ? new Set(input.eventTypes) : undefined;
         const kinds = input.kinds ? new Set(input.kinds) : undefined;
+        const roles = input.roles ? new Set(input.roles) : undefined;
         const textContains = input.textContains?.toLowerCase();
         const matches = this.agentObservations.filter((observation) => {
             if (observation.managingParentId !== parentPiboSessionId)
                 return false;
+            if (requestIds && (!observation.requestId || !requestIds.has(observation.requestId)))
+                return false;
             if (agentIds && !agentIds.has(observation.agentId))
                 return false;
             if (names && !names.has(observation.name))
@@ -1703,6 +1808,8 @@ export class PiboSessionRouter {
                 return false;
             if (kinds && !kinds.has(observation.kind))
                 return false;
+            if (roles && (!observation.role || !roles.has(observation.role)))
+                return false;
             if (afterSequence !== undefined && observation.sequence <= afterSequence)
                 return false;
             const createdAt = Date.parse(observation.createdAt);
@@ -1744,9 +1851,8 @@ export class PiboSessionRouter {
         const child = this.requireManagedAgent(parentPiboSessionId, agentId);
         const ids = [agentId, ...this.descendantSessionIds(agentId)];
         const idSet = new Set(ids);
-        const cancelledRuns = this.runRegistry.listAll({ includeConsumed: true, includeDetached: true })
-            .filter((run) => idSet.has(run.controllerPiboSessionId) && !isTerminalRunStatus(run.status))
-            .map((run) => run.runId);
+        const cancellableRuns = this.runRegistry.listAll({ includeConsumed: true, includeDetached: true })
+            .filter((run) => idSet.has(run.controllerPiboSessionId) && !isTerminalRunStatus(run.status));
         await Promise.allSettled(ids.flatMap((id) => this.sessions.has(id)
             ? [this.emit({ type: "execution", piboSessionId: id, action: "abort", id: randomUUID() })]
             : []));
@@ -1760,19 +1866,42 @@ export class PiboSessionRouter {
             });
         }
         await this.disposeSessionSubtree(agentId, `killed by parent ${parentPiboSessionId}`, { cancelRuns: true });
+        const cancelledRuns = cancellableRuns.flatMap((run) => {
+            const current = this.runRegistry.status(run.controllerPiboSessionId, run.runId);
+            return current.status === "cancelled" ? [run.runId] : [];
+        });
         return { agentId, killed: ids, cancelledRuns };
     }
-    async invokeRunCancellationHandlers(runs) {
-        const results = await Promise.allSettled(runs.map(async (run) => {
-            const cancel = this.runCancellationHandlers.get(run.runId);
-            if (!cancel)
+    async invokeRunCancellationHandler(run) {
+        const cancel = this.runCancellationHandlers.get(run.runId);
+        if (!cancel) {
+            const current = this.runRegistry.status(run.controllerPiboSessionId, run.runId);
+            if (isTerminalRunStatus(current.status) || !this.activeRunExecutions.has(run.runId))
                 return;
+            throw new PiboRunCancellationError(`Yielded run "${run.runId}" has active execution but does not expose a cancellation handler.`);
+        }
+        await cancel();
+        if (this.runCancellationHandlers.get(run.runId) === cancel)
             this.runCancellationHandlers.delete(run.runId);
-            await cancel();
+    }
+    async invokeRunCancellationHandlers(runs) {
+        const results = await Promise.allSettled(runs.map((run) => this.invokeRunCancellationHandler(run)));
+        const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+        if (failures.length > 0)
+            throw new AggregateError(failures, "Failed to terminate yielded runs.");
+    }
+    async cancelRunsAfterSettlement(runs, reason) {
+        const results = await Promise.allSettled(runs.map(async (run) => {
+            await this.invokeRunCancellationHandler(run);
+            const current = this.runRegistry.status(run.controllerPiboSessionId, run.runId);
+            return isTerminalRunStatus(current.status)
+                ? current
+                : this.runRegistry.cancel(run.controllerPiboSessionId, run.runId, reason);
         }));
         const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
         if (failures.length > 0)
-            throw new AggregateError(failures, "Failed to terminate cancelled yielded runs.");
+            throw new AggregateError(failures, "Failed to terminate yielded runs before cancellation settlement.");
+        return results.flatMap((result) => result.status === "fulfilled" && result.value.status === "cancelled" ? [result.value] : []);
     }
     createRunToolController(parentPiboSessionId) {
         return {
@@ -1796,17 +1925,44 @@ 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);
+                this.activeRunExecutions.add(run.runId);
+                const cancellation = { state: "none" };
+                let resolveRunTaskSettled;
+                const runTaskSettled = new Promise((resolve) => { resolveRunTaskSettled = resolve; });
+                if (cancel) {
+                    let cancellationAttempt;
+                    this.runCancellationHandlers.set(run.runId, () => {
+                        cancellationAttempt ??= (async () => {
+                            cancellation.state = "pending";
+                            let resolveDecision;
+                            cancellation.decision = new Promise((resolve) => { resolveDecision = resolve; });
+                            try {
+                                await waitForRunCancellationSettlement(Promise.resolve().then(cancel));
+                                cancellation.state = "confirmed";
+                                resolveDecision?.();
+                                await waitForRunCancellationSettlement(runTaskSettled);
+                            }
+                            catch (error) {
+                                cancellation.state = "failed";
+                                throw error;
+                            }
+                            finally {
+                                resolveDecision?.();
+                            }
+                        })();
+                        return cancellationAttempt;
+                    });
+                }
                 void (async () => {
                     try {
-                        const result = await execute();
+                        const result = await execute(run.runId);
                         if (resources)
                             this.runRegistry.updateResources(run.runId, resources);
                         const completed = this.runRegistry.complete(run.runId, result);
@@ -1814,6 +1970,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);
@@ -1827,7 +1989,9 @@ export class PiboSessionRouter {
                     }
                     finally {
                         this.runCancellationHandlers.delete(run.runId);
+                        this.activeRunExecutions.delete(run.runId);
                         admission.release();
+                        resolveRunTaskSettled?.();
                     }
                 })();
                 return run;
@@ -1842,14 +2006,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);
@@ -1944,10 +2109,18 @@ export class PiboSessionRouter {
         const source = piboAgentObservationSourceFromEvent(event);
         const role = piboAgentObservationRole(source);
         const text = piboAgentObservationText(source);
+        const provenance = "provenance" in event ? event.provenance : undefined;
+        const eventId = "eventId" in event && typeof event.eventId === "string" ? event.eventId : undefined;
+        const requestId = provenance?.kind === "subagent-request"
+            ? provenance.requestId
+            : eventId
+                ? this.subagentRequestIdsByEvent.get(subagentRequestEventKey(session.id, eventId))
+                : undefined;
         const observation = {
             managingParentId: session.parentId,
             sequence: this.nextAgentObservationSequence++,
             createdAt: new Date().toISOString(),
+            ...(requestId ? { requestId } : {}),
             agentId: session.id,
             name,
             ...(typeof session.metadata?.threadKey === "string" ? { threadKey: session.metadata.threadKey } : {}),
@@ -2067,8 +2240,8 @@ export class PiboSessionRouter {
                 piboSessionId,
                 text: formatRunReminderMessage(notification),
                 source: "service",
-                capabilityScope: "run-reminder",
                 id: randomUUID(),
+                provenance: runReminderProvenance(notification),
             });
         }
         catch (error) {