@astrosheep/keiyaku 2.9.4 → 2.9.6

package/build/agents/call-terms.js

@@ -15,6 +15,7 @@ export function buildCallTerms(snapshot, prompt, cwd, options) {
         prompt,
         sessionContinuationPromptPrefix,
         idleTimeoutMs: options.idleTimeoutMs ?? runtimeConfig.subagent.execIdleTimeoutMs,
+        executionTimeoutMs: options.executionTimeoutMs ?? runtimeConfig.subagent.execMaxDurationMs,
         maxCaptureChars: registration.maxCaptureChars(runtimeConfig),
         signal: options.signal,
         ...(options.initialTurn !== undefined ? { initialTurn: options.initialTurn } : {}),

package/build/agents/harness/execution-handle.js

@@ -167,5 +167,6 @@ export function createProjectionDriver(input) {
             })();
             await gracefulAbort;
         },
+        ...(input.probe ? { probe: input.probe } : {}),
     };
 }

package/build/agents/harness/outcome.js

@@ -3,13 +3,17 @@ import { SUBAGENT_SESSION_VERSION, } from "../session.js";
 import { OUTCOME_ERROR_VERSION, SubagentFailure, } from "../types.js";
 import { isProviderTerminalError, } from "./provider-adapter.js";
 import { renderCapturedText } from "./runtime.js";
-export function createOutcomeState(maxCaptureChars) {
+export function createOutcomeState(maxCaptureChars, admittedSession) {
     return {
         outputBuffer: new StringTailBuffer(maxCaptureChars),
         diagnosticsBuffer: new StringTailBuffer(maxCaptureChars),
         warnings: [],
+        ...(admittedSession ? { session: admittedSession } : {}),
     };
 }
+export function recordSessionAdmission(state, session) {
+    state.session = session;
+}
 function mintOutcome(draft) {
     return draft;
 }
@@ -29,7 +33,6 @@ export function processEvent(state, event) {
             return;
         case "done":
             state.doneEvent = event;
-            state.session = event.session;
             if (event.finalMessage !== undefined) {
                 state.finalMessageCandidate = event.finalMessage;
             }
@@ -64,7 +67,15 @@ export function failFromFailEvent(shared, state, failEvent) {
         exitCode: failEvent.exitCode ?? null,
     }, state.finalMessageCandidate, failEvent.diagnostics ?? diagnostics);
 }
-export function classifyFailure(shared, state, error, idleTimedOut) {
+export function classifyFailure(shared, state, error, idleTimedOut, transportFailure, policyBudgetExceeded = false) {
+    if (policyBudgetExceeded) {
+        return failWithError(shared, state, {
+            code: "SUBAGENT_POLICY_BUDGET",
+            message: `${shared.terms.provider} execution policy budget expired`,
+            timeoutMs: shared.terms.executionTimeoutMs,
+            exitCode: null,
+        }, state.finalMessageCandidate);
+    }
     if (shared.dismissed || shared.externallyAborted) {
         return mintOutcome({
             status: "dismissed",
@@ -75,6 +86,18 @@ export function classifyFailure(shared, state, error, idleTimedOut) {
             warnings: [...state.warnings],
         });
     }
+    if (transportFailure) {
+        const message = transportFailure instanceof Error ? transportFailure.message : `${shared.terms.provider} session transport probe failed`;
+        const timeoutMs = isProviderTerminalError(transportFailure) && transportFailure.fact.kind === "failed"
+            ? transportFailure.fact.timeoutMs
+            : shared.terms.idleTimeoutMs;
+        return failWithError(shared, state, {
+            code: "SUBAGENT_TRANSPORT_ERROR",
+            message,
+            timeoutMs,
+            exitCode: null,
+        }, state.finalMessageCandidate);
+    }
     if (idleTimedOut) {
         return failWithError(shared, state, {
             code: "SUBAGENT_TIMEOUT",
@@ -153,13 +176,16 @@ export function failWithError(shared, state, error, finalMessage, diagnostics =
         warnings: [...state.warnings],
     });
 }
-export function completeOutcome(shared, state, finalMessage, session) {
+export function completeOutcome(state, finalMessage) {
+    if (!state.session) {
+        throw new Error("Cannot complete an outcome before session admission");
+    }
     return mintOutcome({
         status: "completed",
         finalMessage,
         output: renderCapturedText(state.outputBuffer),
         diagnostics: renderCapturedText(state.diagnosticsBuffer),
-        session,
+        session: state.session,
         warnings: [...state.warnings],
     });
 }

package/build/agents/harness/projection.js

@@ -2,9 +2,10 @@ import { randomUUID } from "node:crypto";
 import { FlowError } from "../../flow-error.js";
 import { createEventChannel } from "./event-channel.js";
 import { overflowMarkerFromDropped, prepareAgentEventForPersistence, } from "./execution-handle.js";
-import { classifyFailure, classifySettlementFailure, completeOutcome, createOutcomeState, failFromFailEvent, failWithError, processEvent, renderOutcomeCapturedText, } from "./outcome.js";
+import { classifyFailure, classifySettlementFailure, completeOutcome, createOutcomeState, failFromFailEvent, failWithError, processEvent, recordSessionAdmission, renderOutcomeCapturedText, } from "./outcome.js";
 import { startLiveProjection } from "./router.js";
 import { createAbortError } from "./runtime.js";
+const POLICY_BUDGET_CLEANUP_GRACE_MS = 5_000;
 export function call(terms, options) {
     return createProjection(terms, undefined, options);
 }
@@ -154,7 +155,21 @@ function requestControlledGracefulAbort(shared, reason) {
     shared.gracefulAbort.catch(() => undefined);
     return shared.gracefulAbort;
 }
-function deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, observerEnabled) {
+function requestPolicyBudgetCleanup(shared, reason) {
+    const graceful = requestControlledGracefulAbort(shared, reason);
+    const force = () => {
+        void shared.live?.abort("force").catch(() => undefined);
+    };
+    const cleanupTimeout = setTimeout(force, POLICY_BUDGET_CLEANUP_GRACE_MS);
+    cleanupTimeout.unref?.();
+    void graceful.then(() => clearTimeout(cleanupTimeout), () => {
+        clearTimeout(cleanupTimeout);
+        force();
+    });
+}
+function deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, knownActiveTools, observerEnabled) {
+    if (shared.terminal)
+        return;
     const prepared = prepareAgentEventForPersistence(event);
     if (observerEnabled.value && shared.observer) {
         try {
@@ -173,25 +188,63 @@ function deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, obse
         }
     }
     shared.publicEvents.push(event);
+    if (event.type === "activity") {
+        if (event.phase === "started")
+            knownActiveTools.add(event.id);
+        if (event.phase === "completed")
+            knownActiveTools.delete(event.id);
+    }
     refreshIdleTimeout();
     processEvent(state, event);
 }
 async function settleProjection(shared) {
-    const state = createOutcomeState(shared.terms.maxCaptureChars);
+    const state = createOutcomeState(shared.terms.maxCaptureChars, shared.reviveTerms?.session);
     let idleTimedOut = false;
+    let transportFailure;
+    let policyBudgetExceeded = false;
+    const knownActiveTools = new Set();
     let abortRequested = false;
     const observerEnabled = { value: shared.observer !== undefined };
     let idleTimeout;
+    let executionTimeout;
+    let liveDriver;
+    let probeInFlight;
+    let resolvePolicyBudget;
+    const policyBudget = new Promise((resolve) => {
+        resolvePolicyBudget = resolve;
+    });
     const refreshIdleTimeout = () => {
+        if (shared.terminal)
+            return;
         if (idleTimeout)
             clearTimeout(idleTimeout);
         idleTimeout = setTimeout(() => {
+            if (knownActiveTools.size > 0) {
+                if (!liveDriver?.probe || probeInFlight)
+                    return;
+                probeInFlight = liveDriver.probe()
+                    .then(() => refreshIdleTimeout())
+                    .catch((error) => {
+                    transportFailure = error;
+                    return requestControlledGracefulAbort(shared, error);
+                })
+                    .finally(() => {
+                    probeInFlight = undefined;
+                });
+                probeInFlight.catch(() => undefined);
+                return;
+            }
             idleTimedOut = true;
             requestControlledGracefulAbort(shared, createAbortError(`${shared.terms.provider} exec idle timed out`));
         }, shared.terms.idleTimeoutMs);
         idleTimeout.unref?.();
     };
-    refreshIdleTimeout();
+    executionTimeout = setTimeout(() => {
+        policyBudgetExceeded = true;
+        requestPolicyBudgetCleanup(shared, createAbortError(`${shared.terms.provider} execution policy budget expired`));
+        resolvePolicyBudget();
+    }, shared.terms.executionTimeoutMs);
+    executionTimeout.unref?.();
     const requestLiveAbort = () => {
         if (shared.explicitlyAborted)
             return;
@@ -201,90 +254,110 @@ async function settleProjection(shared) {
         requestControlledGracefulAbort(shared, shared.lifecycleAbort.signal.reason);
     };
     shared.lifecycleAbort.signal.addEventListener("abort", requestLiveAbort, { once: true });
-    try {
-        const live = await startLiveProjection(shared.terms, shared.lifecycleAbort.signal, shared.reviveTerms, refreshIdleTimeout, shared.observer);
-        shared.onLive(live);
-        resolveForceWaiters(shared, live);
-        if (shared.lifecycleAbort.signal.aborted) {
-            requestLiveAbort();
-        }
+    const providerSettlement = (async () => {
         try {
-            for await (const event of live.events) {
-                deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, observerEnabled);
+            const live = await startLiveProjection(shared.terms, shared.lifecycleAbort.signal, shared.reviveTerms, refreshIdleTimeout, shared.observer, (admission) => {
+                recordSessionAdmission(state, admission.session);
+                refreshIdleTimeout();
+            });
+            liveDriver = live;
+            shared.onLive(live);
+            resolveForceWaiters(shared, live);
+            if (shared.lifecycleAbort.signal.aborted) {
+                requestLiveAbort();
             }
-        }
-        catch (error) {
-            if (error instanceof Error && error.code === "PROJECTION_STATE_ERROR") {
-                const event = live.mintEvent({
-                    type: "fail",
-                    code: "PROJECTION_STATE_ERROR",
-                    message: error.message,
-                });
-                if (event)
-                    deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, observerEnabled);
+            try {
+                for await (const event of live.events) {
+                    deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, knownActiveTools, observerEnabled);
+                }
             }
-            else {
-                const event = live.mintEvent({
-                    type: "diagnostic",
-                    text: `pump error: ${String(error)}`,
-                });
-                if (event)
-                    deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, observerEnabled);
+            catch (error) {
+                if (error instanceof Error && error.code === "PROJECTION_STATE_ERROR") {
+                    const event = live.mintEvent({
+                        type: "fail",
+                        code: "PROJECTION_STATE_ERROR",
+                        message: error.message,
+                    });
+                    if (event)
+                        deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, knownActiveTools, observerEnabled);
+                }
+                else {
+                    const event = live.mintEvent({
+                        type: "diagnostic",
+                        text: `pump error: ${String(error)}`,
+                    });
+                    if (event)
+                        deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, knownActiveTools, observerEnabled);
+                }
             }
+            const completionResult = await live.completion.then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
+            const completionOutcome = completionResult.ok ? completionResult.value : undefined;
+            // Outcome classification is the terminal publication boundary. A
+            // controlled abort may let the provider run settle before its graceful
+            // cleanup promise does, so prove that shared settlement before publishing
+            // dismissed, failed-for-another-reason, or completed truth.
+            const gracefulResult = shared.gracefulAbort
+                ? await shared.gracefulAbort.then(() => ({ ok: true }), (error) => ({ ok: false, error }))
+                : undefined;
+            if (gracefulResult && !gracefulResult.ok && !transportFailure) {
+                return classifySettlementFailure(shared, state, gracefulResult.error);
+            }
+            if (policyBudgetExceeded || transportFailure) {
+                return classifyFailure(shared, state, completionResult.ok ? undefined : completionResult.error, idleTimedOut, transportFailure, policyBudgetExceeded);
+            }
+            if (state.failEvent) {
+                return failFromFailEvent(shared, state, state.failEvent);
+            }
+            if (!completionResult.ok) {
+                return classifyFailure(shared, state, completionResult.error, idleTimedOut, transportFailure, policyBudgetExceeded);
+            }
+            if (shared.lifecycleAbort.signal.aborted) {
+                return classifyFailure(shared, state, shared.lifecycleAbort.signal.reason, idleTimedOut, transportFailure, policyBudgetExceeded);
+            }
+            if (!state.doneEvent && !completionOutcome) {
+                return failWithError(shared, state, {
+                    code: "SUBAGENT_EXEC_ERROR",
+                    message: `${shared.terms.provider} exec ended before completion`,
+                    timeoutMs: null,
+                    exitCode: null,
+                }, state.finalMessageCandidate);
+            }
+            const finalMessage = state.doneEvent?.finalMessage ??
+                completionOutcome?.finalMessage ??
+                state.finalMessageCandidate ??
+                renderOutcomeCapturedText(state.outputBuffer).trim();
+            if (!state.session) {
+                return failWithError(shared, state, {
+                    code: "SUBAGENT_EXEC_ERROR",
+                    message: `${shared.terms.provider} exec ended without a session handle`,
+                    timeoutMs: null,
+                    exitCode: null,
+                }, finalMessage);
+            }
+            return completeOutcome(state, finalMessage);
         }
-        const completionResult = await live.completion.then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
-        const completionOutcome = completionResult.ok ? completionResult.value : undefined;
-        // Outcome classification is the terminal publication boundary. A
-        // controlled abort may let the provider run settle before its graceful
-        // cleanup promise does, so prove that shared settlement before publishing
-        // dismissed, failed-for-another-reason, or completed truth.
-        const gracefulResult = shared.gracefulAbort
-            ? await shared.gracefulAbort.then(() => ({ ok: true }), (error) => ({ ok: false, error }))
-            : undefined;
-        if (gracefulResult && !gracefulResult.ok) {
-            return classifySettlementFailure(shared, state, gracefulResult.error);
-        }
-        if (state.failEvent) {
-            return failFromFailEvent(shared, state, state.failEvent);
-        }
-        if (!completionResult.ok) {
-            return classifyFailure(shared, state, completionResult.error, idleTimedOut);
-        }
-        if (shared.lifecycleAbort.signal.aborted) {
-            return classifyFailure(shared, state, shared.lifecycleAbort.signal.reason, idleTimedOut);
-        }
-        if (!state.doneEvent && !completionOutcome) {
-            return failWithError(shared, state, {
-                code: "SUBAGENT_EXEC_ERROR",
-                message: `${shared.terms.provider} exec ended before completion`,
-                timeoutMs: null,
-                exitCode: null,
-            }, state.finalMessageCandidate);
-        }
-        const finalMessage = state.doneEvent?.finalMessage ??
-            completionOutcome?.finalMessage ??
-            state.finalMessageCandidate ??
-            renderOutcomeCapturedText(state.outputBuffer).trim();
-        const session = state.doneEvent?.session ?? completionOutcome?.session;
-        if (!session) {
-            return failWithError(shared, state, {
-                code: "SUBAGENT_EXEC_ERROR",
-                message: `${shared.terms.provider} exec ended without a session handle`,
-                timeoutMs: null,
-                exitCode: null,
-            }, finalMessage);
-        }
-        return completeOutcome(shared, state, finalMessage, session);
-    }
-    catch (error) {
-        if (error instanceof FlowError) {
-            throw error;
+        catch (error) {
+            if (error instanceof FlowError) {
+                throw error;
+            }
+            return classifyFailure(shared, state, error, idleTimedOut, transportFailure, policyBudgetExceeded);
         }
-        return classifyFailure(shared, state, error, idleTimedOut);
+    })();
+    providerSettlement.catch(() => undefined);
+    try {
+        const settled = await Promise.race([
+            providerSettlement.then((outcome) => ({ kind: "provider", outcome })),
+            policyBudget.then(() => ({ kind: "policy-budget" })),
+        ]);
+        return settled.kind === "provider"
+            ? settled.outcome
+            : classifyFailure(shared, state, undefined, idleTimedOut, transportFailure, true);
     }
     finally {
         if (idleTimeout)
             clearTimeout(idleTimeout);
+        if (executionTimeout)
+            clearTimeout(executionTimeout);
         shared.lifecycleAbort.signal.removeEventListener("abort", requestLiveAbort);
         shared.terminal = true;
         resolveForceWaiters(shared, undefined);

package/build/agents/harness/router.js

@@ -1,5 +1,5 @@
 import { getProviderRegistration } from "../providers/registry.js";
-export async function startLiveProjection(terms, signal, reviveTerms, onIngress, observer) {
+export async function startLiveProjection(terms, signal, reviveTerms, onIngress, observer, onSessionAdmission) {
     const onSyncCheckpoint = observer
         ? (control, checkpoint) => {
             observer.onCheckpoint(control, checkpoint);
@@ -19,6 +19,7 @@ export async function startLiveProjection(terms, signal, reviveTerms, onIngress,
         reviveTerms,
         onSyncCheckpoint,
         onDeliveryOpportunity,
+        onSessionAdmission,
         onIngress,
         observer,
     });

package/build/agents/providers/claude-agent-sdk/adapter.js

@@ -198,6 +198,7 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                 queryActive = true;
                 notifyActive();
                 let resumedSessionId = sessionId;
+                let admittedSessionId;
                 let finalMessage;
                 let latestAssistantMessageModel;
                 // Provider acceptance / pre-terminal retry evidence for no-turn classification.
@@ -207,7 +208,18 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                 const seenToolUses = new Map();
                 for await (const event of query) {
                     builder.ingress(CLAUDE_AGENT_SDK_PROVIDER, event.type, event, claudeIngressDisposition(event.type), () => {
-                        resumedSessionId = extractResumeToken(event) ?? resumedSessionId;
+                        const providerSessionId = extractResumeToken(event);
+                        resumedSessionId = providerSessionId ?? resumedSessionId;
+                        if (providerSessionId && providerSessionId !== admittedSessionId) {
+                            admittedSessionId = providerSessionId;
+                            options.onSessionAdmission?.({
+                                session: {
+                                    provider: CLAUDE_AGENT_SDK_PROVIDER,
+                                    version: SUBAGENT_SESSION_VERSION,
+                                    handle: { sessionId: providerSessionId },
+                                },
+                            });
+                        }
                         if (isClaudeApiRetryEvent(event)) {
                             lastPreTerminalEvidenceWasRetry = true;
                             builder.emit({ type: "warning", warning: mapClaudeApiRetryWarning(event) });

package/build/agents/providers/claude-agent-sdk/registration.js

@@ -179,7 +179,7 @@ export const claudeAgentSdkRegistration = {
         return loader ? { ...terms, loader } : terms;
     },
     nativePolicyOwnership: () => null,
-    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onIngress }) => {
+    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onSessionAdmission, onIngress }) => {
         if (terms.provider !== CLAUDE_AGENT_SDK_PROVIDER) {
             throw new Error(`startLive expected ${CLAUDE_AGENT_SDK_PROVIDER}`);
         }
@@ -197,6 +197,7 @@ export const claudeAgentSdkRegistration = {
             systemPrompt: claudeTerms.systemPrompt,
             onSyncCheckpoint,
             onEvidence: claudeTerms.onEvidence,
+            onSessionAdmission,
             onIngress,
             initialTurn: claudeTerms.initialTurn,
             loader: claudeTerms.loader,

package/build/agents/providers/codex-app-server/adapter.js

@@ -13,6 +13,7 @@ function toCodexAppServerEffort(effort) {
 }
 export { codexAppServerSessionSchema } from "./session-schema.js";
 const MINIMUM_CODEX_APP_SERVER_VERSION = { major: 0, minor: 143, patch: 0 };
+const CODEX_APP_SERVER_PROBE_TIMEOUT_MS = 1_000;
 /** Non-interactive defaults for turn/start (faye #316 policy A). */
 export const CODEX_APP_SERVER_TURN_APPROVAL_POLICY = "never";
 export { buildCodexAppServerWorkspaceWriteSandboxPolicy, configOwnsApprovalPolicy, configOwnsSandboxPolicy, } from "./policy.js";
@@ -172,10 +173,41 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
             void drainPendingTells();
         });
     };
+    const probe = async () => {
+        if (!server || !activeThreadId) {
+            throw createProviderFailure(`${CODEX_APP_SERVER_PROVIDER} session probe has no active thread`, {
+                code: "SUBAGENT_TRANSPORT_ERROR",
+                timeoutMs: CODEX_APP_SERVER_PROBE_TIMEOUT_MS,
+            });
+        }
+        let timer;
+        const deadline = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error("session probe timed out")), CODEX_APP_SERVER_PROBE_TIMEOUT_MS);
+            timer.unref?.();
+        });
+        try {
+            await Promise.race([
+                server.request("thread/read", { threadId: activeThreadId }),
+                deadline,
+            ]);
+        }
+        catch (error) {
+            throw createProviderFailure(`${CODEX_APP_SERVER_PROVIDER} session transport probe failed`, {
+                code: "SUBAGENT_TRANSPORT_ERROR",
+                timeoutMs: CODEX_APP_SERVER_PROBE_TIMEOUT_MS,
+                cause: error,
+            });
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    };
     return createProjectionDriver({
         steerMode: "mid-execution",
         initialTurn: options.initialTurn,
         enqueue,
+        probe,
         onIngress: options.onIngress,
         async abort(mode) {
             interruptRequested = true;
@@ -272,6 +304,15 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
                     builder.emit({ type: "fail", message });
                     throw createProviderFailure(message);
                 }
+                const admittedSession = {
+                    provider: "codex-app-server",
+                    version: SUBAGENT_SESSION_VERSION,
+                    handle: {
+                        threadId: activeThreadId,
+                        ...(serverCodexHome ? { codexHome: serverCodexHome } : {}),
+                    },
+                };
+                options.onSessionAdmission?.({ session: admittedSession });
                 if (options.onEvidence)
                     emitProviderEvidence(options.onEvidence, { type: "session", provider: CODEX_APP_SERVER_PROVIDER, threadId: activeThreadId }, builderDiagnostic);
                 // Policy A defaults, but omit when config.* already owns that surface (thread/start config wins).
@@ -319,17 +360,9 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
                     throw createProviderFailure(message);
                 }
                 // Successful turn/completed is consumption evidence; interrupt ack alone is not terminal proof.
-                const session = {
-                    provider: "codex-app-server",
-                    version: SUBAGENT_SESSION_VERSION,
-                    handle: {
-                        threadId: activeThreadId,
-                        ...(serverCodexHome ? { codexHome: serverCodexHome } : {}),
-                    },
-                };
                 const finalMessage = turnState.lastAgentMessage;
-                builder.emit({ type: "done", finalMessage, session });
-                return { finalMessage, session };
+                builder.emit({ type: "done", finalMessage, session: admittedSession });
+                return { finalMessage, session: admittedSession };
             }
             finally {
                 activeTurnCompletion = undefined;

package/build/agents/providers/codex-app-server/events.js

@@ -22,6 +22,11 @@ export function codexAppServerNotificationDisposition(method, params) {
         return "acknowledged-unpersisted";
     if (CODEX_APP_SERVER_NOTIFICATION_MAPPED.has(method))
         return "mapped";
+    if (method === "item/started") {
+        const item = appServerRecord(appServerRecord(params)?.item);
+        if (item && typeof item.type === "string" && isCodexAppServerActivityItemType(item.type))
+            return "mapped";
+    }
     if (method === "account/rateLimits/updated" && codexAppServerRateLimitCause(params))
         return "mapped";
     return "unknown";
@@ -303,6 +308,24 @@ export function createCodexAppServerTurnMonitor(options) {
                             });
                         }
                     }
+                    if (notification.method === "item/started") {
+                        const item = notification.params?.item;
+                        if (!item)
+                            throw new Error(`${CODEX_APP_SERVER_PROVIDER} item/started lacked required item`);
+                        const id = coerceString(item.id);
+                        const itemType = coerceString(item.type);
+                        if (!id || !itemType)
+                            throw new Error(`${CODEX_APP_SERVER_PROVIDER} item/started lacked required item id or type`);
+                        if (isCodexAppServerActivityItemType(itemType)) {
+                            builder.emit({
+                                type: "activity",
+                                phase: "started",
+                                id,
+                                tool: itemType,
+                                call: appServerActivityCall(itemType, item),
+                            });
+                        }
+                    }
                     if (notification.method === "turn/started") {
                         const turn = notification.params?.turn;
                         const turnId = recordActiveTurnId(state, turn?.id, "notification");

package/build/agents/providers/codex-app-server/registration.js

@@ -212,7 +212,7 @@ export const codexAppServerRegistration = {
             webSearch: Object.freeze(webSearch),
         });
     },
-    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onDeliveryOpportunity, onIngress, }) => {
+    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onDeliveryOpportunity, onSessionAdmission, onIngress, }) => {
         if (terms.provider !== CODEX_APP_SERVER_PROVIDER) {
             throw new Error(`startLive expected ${CODEX_APP_SERVER_PROVIDER}`);
         }
@@ -231,6 +231,7 @@ export const codexAppServerRegistration = {
             onSyncCheckpoint,
             onDeliveryOpportunity,
             onEvidence: codexTerms.onEvidence,
+            onSessionAdmission,
             onIngress,
             initialTurn: codexTerms.initialTurn,
         };

package/build/agents/providers/opencode-sdk/adapter.js

@@ -264,6 +264,13 @@ export async function startOpencode(prompt, cwd, options = {}) {
                     builder.emit({ type: "fail", message });
                     throw createProviderFailure(message);
                 }
+                options.onSessionAdmission?.({
+                    session: {
+                        provider: OPENCODE_SDK_PROVIDER,
+                        version: SUBAGENT_SESSION_VERSION,
+                        handle: { sessionId: activeSessionId },
+                    },
+                });
                 idleMonitor = new OpencodeIdleMonitor(sdk.client.v2.session, activeSessionId, combined.signal);
                 eventController = createOpencodeEventController({
                     builder,

package/build/agents/providers/opencode-sdk/registration.js

@@ -104,7 +104,7 @@ export const opencodeSdkRegistration = {
         return loader ? { ...terms, loader } : terms;
     },
     nativePolicyOwnership: () => null,
-    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onDeliveryOpportunity, onIngress, }) => {
+    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onDeliveryOpportunity, onSessionAdmission, onIngress, }) => {
         if (terms.provider !== OPENCODE_SDK_PROVIDER) {
             throw new Error(`startLive expected ${OPENCODE_SDK_PROVIDER}`);
         }
@@ -118,6 +118,7 @@ export const opencodeSdkRegistration = {
             onSyncCheckpoint,
             onDeliveryOpportunity,
             onEvidence: opencodeTerms.onEvidence,
+            onSessionAdmission,
             onIngress,
             initialTurn: opencodeTerms.initialTurn,
             loader: opencodeTerms.loader,

package/build/agents/providers/pi/adapter.js

@@ -1,5 +1,6 @@
 import { FlowError } from "../../../flow-error.js";
 import { appendDebugLog } from "../../../telemetry/debug-log.js";
+import { SUBAGENT_SESSION_VERSION, } from "../../session.js";
 import { createProjectionDriver } from "../../harness/execution-handle.js";
 import { createProviderFailure, toProviderTerminalError, } from "../../harness/provider-adapter.js";
 import { createAbortError, emitProviderEvidence, sha256Utf8 } from "../../harness/runtime.js";
@@ -103,6 +104,15 @@ async function openPiProjectionDriver(prompt, cwd, options) {
         ...(resourceLoader ? { resourceLoader } : {}),
     });
     const session = created.session;
+    if (session.sessionFile) {
+        options.onSessionAdmission?.({
+            session: {
+                provider: PI_PROVIDER,
+                version: SUBAGENT_SESSION_VERSION,
+                handle: { sessionId: session.sessionId, sessionFile: session.sessionFile },
+            },
+        });
+    }
     if (options.onEvidence)
         emitProviderEvidence(options.onEvidence, { type: "session", provider: PI_PROVIDER, sessionId: session.sessionId, ...(session.sessionFile ? { sessionFile: session.sessionFile } : {}) }, reportEvidenceDiagnostic);
     session.setSteeringMode("one-at-a-time");

package/build/agents/providers/pi/events.js

@@ -142,14 +142,15 @@ function piUsageBody(event) {
     if (message?.role !== "assistant")
         return undefined;
     const usage = message.usage;
-    if (!usage || typeof usage.input !== "number" || typeof usage.output !== "number")
+    if (!usage || typeof usage.input !== "number" || !Number.isFinite(usage.input)
+        || typeof usage.output !== "number" || !Number.isFinite(usage.output))
         return undefined;
     return {
         type: "usage",
         inputTokens: usage.input,
         outputTokens: usage.output,
-        ...(typeof usage.cacheRead === "number" ? { cachedInputTokens: usage.cacheRead } : {}),
-        ...(typeof usage.cost?.total === "number" ? { costUsd: usage.cost.total } : {}),
+        ...(typeof usage.cacheRead === "number" && Number.isFinite(usage.cacheRead) ? { cachedInputTokens: usage.cacheRead } : {}),
+        ...(typeof usage.cost?.total === "number" && Number.isFinite(usage.cost.total) ? { costUsd: usage.cost.total } : {}),
         ...(typeof message.responseModel === "string"
             ? { model: message.responseModel }
             : typeof message.model === "string"