@pasko70/pibo 2.4.2 → 2.5.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 { PiboRunCancellationError, PiboRunCancelledError, 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 = {
@@ -258,12 +260,14 @@ export class PiboSessionRouter {
     runtimeResourceSessions = new Map();
     runtimeAuthFingerprints = 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();
@@ -481,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 {
@@ -555,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)
@@ -632,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 };
     }
@@ -687,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.`);
@@ -868,7 +883,7 @@ 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;
@@ -932,9 +947,11 @@ export class PiboSessionRouter {
                 return;
             }
             signal?.addEventListener("abort", onAbort, { once: true });
-            timeout = setTimeout(() => {
-                rejectAfterMessageCancellation(new PiboRunExecutionTimeoutError(`Timed out waiting for assistant reply from Pibo session "${eventWithId.piboSessionId}"`, "lifetime"));
-            }, timeoutMs);
+            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)));
@@ -963,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")));
@@ -994,6 +1012,7 @@ export class PiboSessionRouter {
             await this.runtimeResourceService.dispose();
             this.runtimeResourceSessions.clear();
             this.activeSubagentRequests.clear();
+            this.subagentRequestIdsByEvent.clear();
             this.agentObservations.length = 0;
             this.agentObservationEvictedThroughByParent.clear();
             await this.telemetryWriter?.dispose();
@@ -1078,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.");
@@ -1640,22 +1653,43 @@ export class PiboSessionRouter {
     }
     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,
@@ -1676,13 +1710,15 @@ export class PiboSessionRouter {
                 });
                 let settlement = { status: "fulfilled" };
                 try {
-                    const reply = await this.emitMessageAndWaitForReply(event, subagent.timeoutMs ?? DEFAULT_SUBAGENT_REPLY_TIMEOUT_MS, requestSignal);
+                    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,
                     };
                 }
@@ -1695,6 +1731,7 @@ export class PiboSessionRouter {
                     throw error;
                 }
                 finally {
+                    this.subagentRequestIdsByEvent.delete(subagentRequestEventKey(child.id, event.id));
                     untrack();
                     resolveSettled?.(settlement);
                 }
@@ -1744,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)
@@ -1753,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))
@@ -1767,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);
@@ -1808,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() })]
             : []));
@@ -1824,20 +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 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);
+    }
     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) => {
-            const cancel = this.runCancellationHandlers.get(run.runId);
-            if (!cancel)
-                return;
-            await cancel();
-            if (this.runCancellationHandlers.get(run.runId) === cancel)
-                this.runCancellationHandlers.delete(run.runId);
+            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 {
@@ -1868,28 +1932,37 @@ export class PiboSessionRouter {
                     admission.release();
                     throw error;
                 }
+                this.activeRunExecutions.add(run.runId);
                 const cancellation = { state: "none" };
+                let resolveRunTaskSettled;
+                const runTaskSettled = new Promise((resolve) => { resolveRunTaskSettled = resolve; });
                 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?.();
-                        }
+                    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);
@@ -1916,7 +1989,9 @@ export class PiboSessionRouter {
                     }
                     finally {
                         this.runCancellationHandlers.delete(run.runId);
+                        this.activeRunExecutions.delete(run.runId);
                         admission.release();
+                        resolveRunTaskSettled?.();
                     }
                 })();
                 return run;
@@ -2034,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 } : {}),

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,30 +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 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)
+        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 && (run.jobId !== provenance.jobId
-            || (provenance.cause === 'run-reminder' && run.messageEventId !== provenance.rootEventId)))
+        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')