@sema-agent/core 7.51.1 → 7.52.0

package/dist/core/runner/resume-apply.js

@@ -1,8 +1,9 @@
 import { snapshotActorAssertion } from "../../internal/llm.js";
 import { ASK_USER_QUESTION_TOOL_NAME } from "../ask-question.js";
 import { CheckpointError, remainingBudgetMicroUsd } from "../checkpoint-store.js";
-import { mintHookInvocationIdentity, resolveHookTimeoutMs, runHookSeat } from "../hooks.js";
 import { chainPolicyOnLeg, chainTopAnchors } from "./child-tree.js";
+import { mintHookInvocationIdentity } from "../hooks.js";
+import { admitLegMods, classicEventBase, failedHandlerClause, screenUserPrompt } from "../mods/stations.js";
 import { checkToolPolicyProjection, policyCannotAnswer, refuseOutOfContractDecision } from "../tool-policy.js";
 import { callFaceSeat, parkedCallFaceOf } from "../tool-roster.js";
 import { readCallTarget } from "../effective-path-target.js";
@@ -10,7 +11,7 @@ import { inlineUntrusted } from "../untrusted-text.js";
 import { deepJsonEqual, describeSuppliedValue, mintDecideRecord } from "./decide-continuation.js";
 import { orgVerdictBeforeClaim } from "./permission-rule-lanes.js";
 import { chainCannotJudge } from "./call-hook-stations.js";
-import { asThrownError, thrownText } from "../thrown-value.js";
+import { thrownText } from "../thrown-value.js";
 import { wireOf } from "../tool-name-readings.js";
 import { parkedSkillApprovalRefusal } from "../skill-grant.js";
 import { SKILL_CONTENT_MAX_CHARS, SKILL_TOOL_NAME, normalizeSkills } from "./synthetic-tools.js";
@@ -19,10 +20,12 @@ export async function resumeApply(input) {
     const { cp, config, internals, outcomeGate, wakeMessage, resumeSignal, recheckGovernanceWindow, plainReviewOutcome, plainParkOutcome, runner, effectiveDelegationFacts } = input;
     let plainPolicyOutcome = input.plainPolicyOutcome;
     let wakeHookContext;
+    let legMods;
     if (outcomeGate === "wake" && wakeMessage !== undefined) {
-        const resumeScreenHooks = config.hooks ?? runner.deps.hooks;
-        const screen = resumeScreenHooks?.userPromptSubmit;
-        if (screen !== undefined && resumeSignal?.aborted !== true) {
+        if (resumeSignal?.aborted !== true) {
+            legMods = await admitLegMods({ spec: config, deps: runner.deps, sessionId: cp.sessionId });
+        }
+        if (legMods !== undefined && legMods.bus.hasHandlers("classic.UserPromptSubmit")) {
             const screenedMessage = wakeMessage;
             const identity = mintHookInvocationIdentity({
                 sessionId: cp.sessionId,
@@ -35,45 +38,24 @@ export async function resumeApply(input) {
                 ...(internals?.spawnAgentType !== undefined ? { agentType: internals.spawnAgentType } : {}),
                 ...(internals?.parentToolCallId !== undefined ? { parentToolCallId: internals.parentToolCallId } : {}),
             });
-            const screenTimeoutMs = resolveHookTimeoutMs(resumeScreenHooks?.timeoutMs, (badErr) => {
-                try {
-                    runner.deps.onError?.(asThrownError(badErr), { phase: "hook", sessionId: cp.sessionId });
-                }
-                catch {
-                }
-            }, resumeScreenHooks);
-            let decision;
-            try {
-                const seat = await runHookSeat("userPromptSubmit", { timeoutMs: screenTimeoutMs, ...(resumeSignal !== undefined ? { signal: resumeSignal } : {}), abortEnds: true }, (sig) => screen(screenedMessage.text, {
-                    identity,
-                    signal: sig,
-                    source: "resume_message",
-                    ...(screenedMessage.inputId !== undefined ? { inputId: screenedMessage.inputId } : {}),
-                    ...(screenedMessage.actor !== undefined ? { actor: snapshotActorAssertion(screenedMessage.actor) } : {}),
-                }));
-                if (seat.expired) {
-                    if (seat.cause === "aborted")
-                        throw new CheckpointError("checkpoint.resume_aborted", "the resume was aborted while the deployment's userPromptSubmit hook was still screening this wake message — the checkpoint stays pending and is resumable with a live signal");
-                    throw new CheckpointError("steering.blocked_by_hook", `the deployment's userPromptSubmit hook did not answer within its ${screenTimeoutMs}ms bound while screening this wake message; the resume was refused (fail-closed) and the checkpoint stays pending`);
-                }
-                decision = seat.value;
+            const screen = await screenUserPrompt(legMods.bus, {
+                ...classicEventBase(identity),
+                prompt: screenedMessage.text,
+                source: "resume_message",
+                ...(screenedMessage.inputId !== undefined ? { inputId: screenedMessage.inputId } : {}),
+                ...(screenedMessage.actor !== undefined ? { actor: snapshotActorAssertion(screenedMessage.actor) } : {}),
+            }, resumeSignal);
+            if (screen?.kind === "aborted") {
+                throw new CheckpointError("checkpoint.resume_aborted", "the resume was aborted while the deployment's userPromptSubmit hook was still screening this wake message — the checkpoint stays pending and is resumable with a live signal");
             }
-            catch (hookErr) {
-                if (hookErr instanceof CheckpointError)
-                    throw hookErr;
-                const err = asThrownError(hookErr);
-                try {
-                    runner.deps.onError?.(err, { phase: "hook", sessionId: cp.sessionId });
-                }
-                catch {
-                }
-                throw new CheckpointError("steering.blocked_by_hook", `the deployment's userPromptSubmit hook crashed while screening this wake message (${inlineUntrusted(err.message)}); the resume was refused (fail-closed) and the checkpoint stays pending`);
+            if (screen?.kind === "failed") {
+                throw new CheckpointError("steering.blocked_by_hook", `the deployment's userPromptSubmit hook ${failedHandlerClause(screen)} while screening this wake message; the resume was refused (fail-closed) and the checkpoint stays pending`);
             }
-            if (decision?.block !== undefined && decision.block !== "") {
-                throw new CheckpointError("steering.blocked_by_hook", `the deployment's userPromptSubmit hook blocked this wake message: ${inlineUntrusted(decision.block)}`);
+            if (screen?.block !== undefined && screen.block !== "") {
+                throw new CheckpointError("steering.blocked_by_hook", `the deployment's userPromptSubmit hook blocked this wake message: ${inlineUntrusted(screen.block)}`);
             }
-            if (decision?.additionalContext !== undefined && decision.additionalContext !== "") {
-                wakeHookContext = decision.additionalContext;
+            if (screen?.additionalContext !== undefined && screen.additionalContext !== "") {
+                wakeHookContext = screen.additionalContext;
             }
             if (recheckGovernanceWindow !== undefined)
                 await recheckGovernanceWindow();
@@ -192,5 +174,5 @@ export async function resumeApply(input) {
     if (outcomeForStore === undefined) {
         throw new CheckpointError("checkpoint.invalid_outcome", `resume outcome (gate "${describeSuppliedValue(outcomeGate)}") matched the checkpoint gate but no lane captured it — refusing pre-CAS rather than passing the caller's live object to the store and the resumed run`);
     }
-    return await input.next({ wakeHookContext, plainPolicyOutcome, outcomeForStore });
+    return await input.next({ wakeHookContext, ...(legMods !== undefined ? { legMods } : {}), plainPolicyOutcome, outcomeForStore });
 }

package/dist/core/runner/resume-checkpoint-screen.d.ts

@@ -7,6 +7,7 @@ export interface ResumeCheckpointScreenInput {
     resumeSignal: AbortSignal | undefined;
     /** borrowed-readonly — the internals snapshot (the re-supplied chain, the requested cwd). */
     internals: RunInternals | undefined;
+    /** borrowed-readonly — the roster the resume hands (`ResumeTaskConfig.tools`), as the caller mounts it. */ tools: unknown;
     /** borrowed-readonly — the Runner's deployment deps, read LIVE through the Runner (reads `permissionRuleStore` and `executionEnvFactory`); the one home of why it is a
      *  seat and not a captured object is {@link RunnerDepsSeat}. */
     runner: RunnerDepsSeat;

package/dist/core/runner/resume-checkpoint-screen.js

@@ -6,8 +6,11 @@ import { judgeCheckpointRequirements } from "../checkpoint-requirements.js";
 import { constraintChainDigest, constraintChainEntryOfSuppliedLayer } from "../tool-policy.js";
 import { readFrozenSkillGrants } from "../skill-grant.js";
 import { chainInstallationGaps, chainInstallationRefusal } from "./child-tree.js";
+import { screeningInstallationsOf, unraisableGuardsOf } from "../mods/stations.js";
+import { refusePersistedToolNames, refuseRenamedDelegationMounts } from "./sub-agent-deny-lists.js";
+import { asResumeConfigRefusal } from "../mode-policy.js";
 export function resumeCheckpointScreen(input) {
-    const { cp, resumeSignal, internals, runner } = input;
+    const { cp, resumeSignal, internals, tools, runner } = input;
     const { realApproval: realApprovalRow, face: faceRow, f012: f012Row } = CHECKPOINT_FEATURES;
     if (checkpointVersionOf(cp) > MAX_SUPPORTED_CHECKPOINT_VERSION) {
         throw new CheckpointError("checkpoint.unsupported_version", `checkpoint requires reader capabilities this worker lacks (row format v${checkpointVersionOf(cp)}; this worker reads up to v${MAX_SUPPORTED_CHECKPOINT_VERSION}) — resume it on a worker at or above the version that parked it`, { reason: "version_newer" });
@@ -84,6 +87,8 @@ export function resumeCheckpointScreen(input) {
             "the restored workspace's own mount path is authoritative for the task root. Drop requestedCwd on resume legs " +
             "(the checkpoint stays pending and is resumable without it).");
     }
+    asResumeConfigRefusal("inheritedGate", () => refusePersistedToolNames((internals?.toolCeiling ?? undefined) === undefined ? cp.state.toolCeiling : undefined, cp.state.inheritedGate?.constraintChain, (internals?.ownToolLists ?? undefined) === undefined ? cp.state.ownToolLists : undefined));
+    asResumeConfigRefusal("taskConfig", () => refuseRenamedDelegationMounts(tools));
     if (cp.state.inheritedGate?.requiresParentConstraint === true) {
         const supplied = internals?.inheritedGate?.parentConstraints?.length ?? 0;
         if (supplied === 0) {
@@ -126,6 +131,9 @@ export function resumeCheckpointScreen(input) {
         if (gaps.length > 0)
             throw chainInstallationRefusal(gaps, true);
     }
+    const unraisable = unraisableGuardsOf(screeningInstallationsOf(internals?.inheritedGate?.parentConstraints ?? []));
+    if (unraisable !== undefined)
+        throw new CheckpointError("resume.parent_constraint_mismatch", `${unraisable}; rejected pre-CAS (the checkpoint stays pending)`);
     const resumeInternals = internals?.inheritedGate?.parentConstraints !== undefined
         ? {
             ...internals,

package/dist/core/runner/resume-preflight.js

@@ -1,10 +1,44 @@
 import { CheckpointError } from "../checkpoint-store.js";
-import { MAX_HOOK_TIMEOUT_MS, runHookSeat } from "../hooks.js";
+import { MAX_TIMER_MS } from "../mods/kernel/index.js";
 import { hasDestroy } from "../remote-env.js";
 import { inlineUntrusted } from "../untrusted-text.js";
 import { describeSuppliedValue } from "./decide-continuation.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
 import { asThrownError } from "../thrown-value.js";
+async function boundedPreflight(timeoutMs, signal, call) {
+    const controller = new AbortController();
+    const pending = Promise.resolve(call(controller.signal));
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (act) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            act();
+        };
+        const expire = (cause) => finish(() => {
+            void pending.then(undefined, () => {
+            });
+            resolve({ expired: true, cause });
+            queueMicrotask(() => {
+                try {
+                    controller.abort();
+                }
+                catch {
+                }
+            });
+        });
+        const onAbort = () => expire("aborted");
+        const timer = setTimeout(() => expire("timeout"), timeoutMs);
+        if (signal?.aborted === true)
+            onAbort();
+        else
+            signal?.addEventListener("abort", onAbort, { once: true });
+        pending.then((value) => finish(() => resolve({ expired: false, value })), (err) => finish(() => reject(asThrownError(err))));
+    });
+}
 const RESUME_PREFLIGHT_DEFAULT_TIMEOUT_MS = 10_000;
 export async function resumePreflight(input) {
     const { token, cp, resumeSignal, recheckGovernanceWindow, store, runner, locallyClaimedTokens, parentConstraintRegistry, suspendedEnvReaps } = input;
@@ -13,12 +47,12 @@ export async function resumePreflight(input) {
         const rawDeadline = runner.deps.resumePreflightTimeoutMs;
         let preflightTimeoutMs = RESUME_PREFLIGHT_DEFAULT_TIMEOUT_MS;
         if (rawDeadline !== undefined) {
-            if (typeof rawDeadline === "number" && Number.isFinite(rawDeadline) && rawDeadline > 0 && rawDeadline <= MAX_HOOK_TIMEOUT_MS) {
+            if (typeof rawDeadline === "number" && Number.isFinite(rawDeadline) && rawDeadline > 0 && rawDeadline <= MAX_TIMER_MS) {
                 preflightTimeoutMs = rawDeadline;
             }
             else {
                 try {
-                    runner.deps.onError?.(new Error(`RunnerDeps.resumePreflightTimeoutMs is not a positive finite number within the seat ceiling of ${MAX_HOOK_TIMEOUT_MS}ms (got ${describeSuppliedValue(rawDeadline)}) — the resume preflight falls back to its own ${RESUME_PREFLIGHT_DEFAULT_TIMEOUT_MS}ms default`), { phase: "config", sessionId: cp.sessionId });
+                    runner.deps.onError?.(new Error(`RunnerDeps.resumePreflightTimeoutMs is not a positive finite number within the timer ceiling of ${MAX_TIMER_MS}ms (got ${describeSuppliedValue(rawDeadline)}) — the resume preflight falls back to its own ${RESUME_PREFLIGHT_DEFAULT_TIMEOUT_MS}ms default`), { phase: "config", sessionId: cp.sessionId });
                 }
                 catch {
                 }
@@ -35,19 +69,7 @@ export async function resumePreflight(input) {
         const refusalTail = "; the checkpoint stays pending and the same token is redeemable once the obstacle clears";
         let verdict;
         try {
-            const seat = await runHookSeat("resumePreflight", {
-                timeoutMs: preflightTimeoutMs,
-                ...(resumeSignal !== undefined ? { signal: resumeSignal } : {}),
-                abortEnds: true,
-                onBadTimeout: (badErr) => {
-                    try {
-                        runner.deps.onError?.(asThrownError(badErr), { phase: "hook", sessionId: cp.sessionId });
-                    }
-                    catch {
-                    }
-                },
-                owner: runner.deps,
-            }, (sig) => preflight(info, sig));
+            const seat = await boundedPreflight(preflightTimeoutMs, resumeSignal, (sig) => preflight(info, sig));
             if (seat.expired) {
                 if (seat.cause === "aborted")
                     throw new CheckpointError("checkpoint.resume_aborted", "the resume was aborted while the deployment's resumePreflight was still screening it — the checkpoint stays pending and is resumable with a live signal");

package/dist/core/runner/retired-runner-deps.js

@@ -1,11 +1,13 @@
-import { assertNoRetiredKeys, assertNoRetiredToolPolicyKeys } from "../retired-keys.js";
+import { assertNoRetiredKeys, assertNoRetiredToolPolicyKeys, RETIRED_HOOKS_REPLACEMENT } from "../retired-keys.js";
 import { assertCallerPoliciesCurrent, callerPolicySeats } from "../locked-config.js";
 const RETIRED_RUNNER_DEPS_KEYS = {
+    hooks: RETIRED_HOOKS_REPLACEMENT,
     legacyRewindBoundaryProbe: "the rewind refusal always names both possibilities (never existed / retired whole-tree era); a deployment that holds that era's table answers the question on its own surface",
     peerAdmission: "the peer lane's knob table is `RunnerDeps.peerLane` (the same fields: admission gate, delivery budgets, listing window)",
     builtinWorkflows: "the engine ships no built-in named workflows — the Workflow tool's `{name}` resolves only `RunnerDeps.workflowScriptStore`; register any named workflow there",
     graderEnvFactory: "the grader env reaches the repair loop as `RepairLoopConfig.graderEnv`, minted by the trusted control plane (`assertOracleIsolation` / `GraderEnv` unchanged)",
     "hands.readCyberReminder": "a Read result carries only the reminders about that read (an empty file, an offset past the end, a file already in context) — no standing content-safety tail, so there is nothing to switch; a deployment that wants that sentence states it in its own `appendSystemPrompt`",
+    promptProvider: "a deployment changes prompt text through overlays: register a `prompt.compose` handler on `RunnerDeps.mods` answering `{ overlays }` (role base `replace`, a brand line `add` to the role band, a behavior or scenario `add`, a core-behavior `replace` / `append` / `drop`), choose the role base per task with `TaskSpec.promptRole`, and dispose of an MCP server's instructions with a `prompt.section` registration answering `{ text }` / `{ text: null }`",
     memorySessionIncarnation: "the occupant behind a session id is a cell of the session row now — `SessionMetadata.incarnation` on the metadata `Session.getMetadata()` returns (forks also `forkedFromIncarnation`), with `SessionStore.incarnationOf` for by-id readers; put the token the old seat answered on your sessions instead. A deployment that drops the seat without surfacing the cell loses the axis: records bind by session id alone",
 };
 export function assertNoRetiredRunnerDeps(deps) {

package/dist/core/runner/run-brain-sinks.d.ts

@@ -18,12 +18,13 @@ export interface RunBrainSinksInput {
     };
     /** borrowed-readonly — the reasoning lane's wire-facts consumer, the third sink the composition installs. */
     observeReasoningWireFacts: (facts: ReasoningWireFacts) => void;
-    /** borrowed-readonly — the notice sink and the leg's ids; the fourth sink's announcer is minted from them. */
+    /** borrowed-readonly — the notice sink and the leg's ids; the fourth and fifth sinks' announcers are minted from them. */
     notice: ExtraBodyDroppedSeatInput;
 }
 export interface RunBrainSinksResult {
     /** Compose the three brain ALS sinks around a brain-driving call. */
     withBrainSinks: <T>(fn: () => Promise<T>) => Promise<T>;
-    withExtraBodyDroppedSink: <T>(fn: () => Promise<T>) => Promise<T>;
+    /** Compose the two leg-wide request sinks (the extraBody strip, the credential-origin refusal) around the whole leg. */
+    withLegRequestSinks: <T>(fn: () => Promise<T>) => Promise<T>;
 }
 export declare function runBrainSinks(input: RunBrainSinksInput): RunBrainSinksResult;

package/dist/core/runner/run-brain-sinks.js

@@ -1,5 +1,6 @@
 import { runWithBrainTelemetry, runWithReasoningWireFacts, runWithStatusSink } from "../../brain/status-sink.js";
 import { createExtraBodyDroppedScope } from "./extra-body-dropped-seat.js";
+import { createCredentialOriginRefusalScope } from "./credential-origin-seat.js";
 import { createSafeNotifier, observeThenableRejection } from "../safe-notify.js";
 import { emitTrace } from "../trace.js";
 export function runBrainSinks(input) {
@@ -60,5 +61,8 @@ export function runBrainSinks(input) {
                         : { kind: "vision.placeholder", version: 1, taskId: rs.telemetry.taskId, count: t.count, ts: Date.now() });
     };
     const withBrainSinks = (fn) => runWithStatusSink(statusEmit, () => runWithBrainTelemetry(telemetryEmit, () => runWithReasoningWireFacts(observeReasoningWireFacts, fn)));
-    return { withBrainSinks, withExtraBodyDroppedSink: createExtraBodyDroppedScope(notice) };
+    const withExtraBodyDropped = createExtraBodyDroppedScope(notice);
+    const withCredentialOriginRefusals = createCredentialOriginRefusalScope(notice);
+    const withLegRequestSinks = (fn) => withExtraBodyDropped(() => withCredentialOriginRefusals(fn));
+    return { withBrainSinks, withLegRequestSinks };
 }

package/dist/core/runner/run-compaction-machinery.d.ts

@@ -1,9 +1,10 @@
 import type { Model } from "../../internal/llm.js";
 import { type MaybeCompactOptions } from "../auto-compaction.js";
 import { type ModelPricing } from "../pricing.js";
-import type { Brain, TaskSpec } from "../types.js";
+import type { Brain, RunnerDeps, TaskSpec } from "../types.js";
 import type { Stats } from "./assemble-result.js";
 import type { Prepared, RunnerDepsSeat, RunState } from "./contracts.js";
+import { type SideCallBook } from "./side-call-account.js";
 export interface RunCompactionMachineryInput {
     /** borrowed-readonly — the task spec: the compaction settings. */
     spec: TaskSpec;
@@ -17,6 +18,8 @@ export interface RunCompactionMachineryInput {
     stats: Stats;
     /** borrowed-readonly — the telemetry lane's price-table door, consulted for every summarizer table adopted. */
     noteUnevaluablePriceTable: (p: ModelPricing) => void;
+    /** borrowed-readonly — the deployment's model catalog: where a degraded side-call reply's serving model is looked up. */
+    modelCatalog: RunnerDeps["models"];
     /** borrowed-readonly — the Runner's deployment deps, read LIVE (`brain`, `pricing`, `onError`). */
     runner: RunnerDepsSeat;
 }
@@ -33,5 +36,8 @@ export interface RunCompactionMachineryResult {
     };
     /** The window-safety wiring (per call — a mid-task degrade moves the fallback target). */
     windowSafetyOptions: (mainModel: Model) => Pick<MaybeCompactOptions, "fallbackBudget" | "onWindowSafety">;
+    /** The leg's one door onto the run's usage account (the same function `Prepared.sideCallBookRef.book` holds): every
+     *  model call made beside the main loop is booked through it, once, with its lane. */
+    bookSideCall: SideCallBook;
 }
 export declare function runCompactionMachinery(input: RunCompactionMachineryInput): RunCompactionMachineryResult;

package/dist/core/runner/run-compaction-machinery.js

@@ -2,47 +2,21 @@ import { DEFAULT_COMPACTION_SETTINGS } from "../../internal/harness.js";
 import { resolveTriggerWindow } from "../context-edit.js";
 import { compactionEnabled, contextOverlayFor } from "../context-settings.js";
 import { sanitizeCompactionSettings } from "../auto-compaction.js";
-import { isModelPriced, modelCostToPricing } from "../pricing.js";
+import { modelCostToPricing } from "../pricing.js";
 import { emitTrace } from "../trace.js";
 import { runWithReasoningWireFacts, runWithStatusSink } from "../../brain/status-sink.js";
-import { cacheFamilyOf, usageCostMicroUsd } from "./usage-accounting.js";
+import { sideCallBookOf } from "./side-call-account.js";
 export function runCompactionMachinery(input) {
-    const { spec, prepared, rs, stats, noteUnevaluablePriceTable, runner } = input;
-    const recordCompactionUsage = (m, msg) => {
-        const u = msg?.usage;
-        if (!u)
-            return;
-        if (msg.usageMissing === true)
-            stats.usageMissing = true;
-        const fam = cacheFamilyOf(m);
-        const price = runner.deps.pricing?.[m.id] ?? modelCostToPricing(m.cost);
-        const priced = isModelPriced(m, runner.deps.pricing);
-        if (!priced)
-            rs.telemetry.unpricedSpend = true;
-        noteUnevaluablePriceTable(price);
-        const { totalInputTokens, uncachedInputTokens, costMicroUsd } = usageCostMicroUsd(fam, u, price);
-        stats.tokens += u.totalTokens || 0;
-        stats.promptTokens += uncachedInputTokens;
-        stats.totalInputTokens += totalInputTokens;
-        stats.cachedTokens += u.cacheRead || 0;
-        stats.cacheWriteTokens += u.cacheWrite || 0;
-        stats.outputTokens += u.output || 0;
-        stats.costMicroUsd += costMicroUsd;
-        stats.compactionMicroUsd = (stats.compactionMicroUsd ?? 0) + costMicroUsd;
-        emitTrace(rs.telemetry.tracer, () => ({
-            kind: "brain.call", version: 1, taskId: rs.telemetry.taskId, model: m.id, provider: m.provider,
-            promptTokens: uncachedInputTokens, totalInputTokens, completionTokens: u.output || 0,
-            cacheRead: u.cacheRead || 0, cacheWrite: u.cacheWrite || 0,
-            latencyMs: 0, ...(priced ? { costMicroUsd } : {}), ...(typeof msg?.stopReason === "string" ? { stopReason: msg.stopReason } : {}), ts: Date.now(),
-        }));
-    };
+    const { spec, prepared, rs, stats, noteUnevaluablePriceTable, modelCatalog, runner } = input;
+    const bookSideCall = sideCallBookOf(stats, { telemetry: rs.telemetry, pricing: () => runner.deps.pricing, noteUnevaluablePriceTable, catalog: modelCatalog });
+    prepared.sideCallBookRef.book = bookSideCall;
     const compactionBrain = {
         stream: runner.deps.brain.stream,
         complete: async (m, c, o) => {
             const msg = await runWithStatusSink(() => { }, async () => await runWithReasoningWireFacts(() => { }, async () => runner.deps.brain.complete
                 ? await runner.deps.brain.complete(m, c, o)
                 : await (await Promise.resolve(runner.deps.brain.stream(m, c, o))).result()));
-            recordCompactionUsage(m, msg);
+            bookSideCall("compaction", m, msg);
             return msg;
         },
     };
@@ -98,5 +72,5 @@ export function runCompactionMachinery(input) {
             }
         },
     });
-    return { compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions };
+    return { compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions, bookSideCall };
 }

package/dist/core/runner/run-harness-handlers.js

@@ -11,6 +11,7 @@ import { advanceCadenceClock, reduceToolEnd } from "./turn-attachments.js";
 import { gatedCallIdOf } from "./park-commit.js";
 import { hasVerifiableStructureSignal } from "./grounding-signal.js";
 import { announceToolCall, batchResponseDigest, emitSettled } from "./tool-end-body.js";
+import { stampRowNotExecuted } from "./tool-not-executed.js";
 import { createResponseModelSeat } from "./response-model-seat.js";
 import { createToolCallIdFoldSeat } from "./tool-call-id-fold-seat.js";
 import { createFinishReasonSeat } from "./finish-reason-seat.js";
@@ -23,7 +24,7 @@ export function createHarnessHandlers(input) {
     const toolCallIdFoldSeat = createToolCallIdFoldSeat(deps.runnerHooks.onNotice, { sessionId: prepared.sessionId, runId: prepared.runId });
     const toolTurnIncompleteSeat = createToolTurnIncompleteSeat(deps.runnerHooks.onNotice, { sessionId: prepared.sessionId, runId: prepared.runId });
     const finishReasonSeat = createFinishReasonSeat(deps.runnerHooks.onNotice, { sessionId: prepared.sessionId, runId: prepared.runId });
-    const { spec, queue, internals, ident, pushContent, emitCommitted, startedToolCallIds, toolStartAt, toolProgress, writeFamilyOf, toolLabels, postToolBatchHook, batchArgs, internalsNotifier, mediaByteCapBytes } = deps;
+    const { spec, queue, internals, ident, pushContent, emitCommitted, startedToolCallIds, toolStartAt, toolProgress, writeFamilyOf, toolLabels, postToolBatchArmed, batchArgs, internalsNotifier, mediaByteCapBytes } = deps;
     const frames = { push: (f) => pushContent({ ...f, ...ident() }), structured: prepared.structuredProjector, mediaByteCapBytes };
     const startOf = (e) => {
         const label = toolLabels.get(e.toolName);
@@ -235,7 +236,7 @@ export function createHarnessHandlers(input) {
             if (det !== undefined)
                 reduceToolEnd(rs.attach.attachState, det);
         }
-        if (postToolBatchHook !== undefined) {
+        if (postToolBatchArmed) {
             if (prepared.blockedToolCalls.delete(event.toolCallId) || event.notExecuted === true) {
                 batchArgs?.delete(event.toolCallId);
             }
@@ -266,6 +267,7 @@ export function createHarnessHandlers(input) {
             ...(event.notExecuted === true ? { notExecuted: true } : {}),
             ...(() => { const id = prepared.abortController.signal.aborted ? gatedCallIdOf(prepared) : undefined; return id !== undefined ? { gatedCallIdOfRun: id } : {}; })(),
         }, frames);
+        stampRowNotExecuted(event.result, settled.notExecuted === true);
         emitTrace(rs.telemetry.tracer, () => ({
             kind: "tool.call",
             version: 1,

package/dist/core/runner/run-identity-wiring.d.ts

@@ -4,6 +4,7 @@ import { type NotificationInjectionOutcome, type PendingSessionNotifications, ty
 import type { PushQueue } from "../push-queue.js";
 import type { TaskEvent, TaskSpec } from "../types.js";
 import type { Stats } from "./assemble-result.js";
+import { type CallerStopGate } from "./caller-stop-gate.js";
 import type { CaptureOptOutRef, LiveHandle, ManualCompactRef, McpRedialRef, NotificationLaneBindings, NotifyRef, Prepared, RunInternals, RunnerDepsSeat, TaskIdRef } from "./contracts.js";
 export interface RunIdentityWiringInput {
     /** borrowed-readonly — the task spec: the task id and the memory / notification seats it names. */
@@ -60,11 +61,12 @@ export interface RunIdentityWiringResult {
     };
     /** The delegation-lifecycle emission closure both phases share (spawn here, terminal in the driver). */
     emitDelegationLifecycle: (event: import("../types.js").DelegationLifecycleEvent) => void;
-    /** The loop-liveness latch and the two attribution seats (ended / userInterrupted / userHalted). */
+    /** The loop-liveness latch, the two attribution seats (ended / userInterrupted / userHalted) and the caller-stop gate. */
     loopLatch: {
         ended: boolean;
         userInterrupted: boolean;
         userHalted: boolean;
+        callerStop: CallerStopGate;
     };
     /** This leg's usage counters, zeroed here; the harness-handlers lane is their writer from the first turn on. */
     stats: Stats;

package/dist/core/runner/run-identity-wiring.js

@@ -7,6 +7,7 @@ import { discloseDroppedPending, renderTaskNotificationXml, taskNotificationDedu
 import { buildAppliedHumanInputEvent } from "../human-input-projection.js";
 import { announceAcceptance, nextHumanInputSeq } from "./steer-admission.js";
 import { deliverDelegationLifecycle, deliverEngineNotice, parentLegIds, undrainedUserInputNotices } from "../types.js";
+import { mintCallerStopGate } from "./caller-stop-gate.js";
 export function runIdentityWiring(input) {
     const { spec, queue, prepared, internals, taskIdRef, onReady, manualCompactRef, notifyRef, captureOptOutRef, mcpRedialRef, injectTaskNotification, deliveredAtTurnOpen, peerInboundChainRef, notificationLane, pendingSessionNotifications, runner } = input;
     notificationLane.harness = prepared.harness;
@@ -126,8 +127,8 @@ export function runIdentityWiring(input) {
             }
         }
     }
-    const loopLatch = { ended: false, userInterrupted: false, userHalted: false };
-    onReady({ harness: prepared.harness, abortController: prepared.abortController, loop: loopLatch, reminderMark: prepared.reminderMark, sessionId: prepared.sessionId, runId: prepared.runId, hookTimeoutMs: prepared.hookTimeoutMs, hookIdentity: prepared.hookIdentity, permissionMode: prepared.permissionMode });
+    const loopLatch = { ended: false, userInterrupted: false, userHalted: false, callerStop: mintCallerStopGate(spec.signal) };
+    onReady({ harness: prepared.harness, abortController: prepared.abortController, loop: loopLatch, reminderMark: prepared.reminderMark, sessionId: prepared.sessionId, runId: prepared.runId, hookIdentity: prepared.hookIdentity, modBus: prepared.modBus, permissionMode: prepared.permissionMode });
     const stats = { turns: 0, tokens: 0, toolCalls: 0, promptTokens: 0, totalInputTokens: 0, cachedTokens: 0, cacheWriteTokens: 0, cacheWriteTokensLong: 0, outputTokens: 0, costMicroUsd: 0 };
     return { runSourceTaskId, parentToolCallId, ident, emitDelegationLifecycle, loopLatch, stats, internalsNotifier, undrainedUserAtEnd: { get current() { return undrainedUserAtEnd; } }, userInputLostAtEnd: { get current() { return userInputLostAtEnd; } } };
 }