@sema-agent/core 7.51.2 → 7.53.0

package/dist/core/runner/resume-internals-and-config.js

@@ -1,17 +1,12 @@
 import { CheckpointError, readPendingSteerQueue } from "../checkpoint-store.js";
+import { asResumeConfigRefusal } from "../mode-policy.js";
 import { GLOBAL_USAGE_KEY, resolveUsageWindows, usageRetryAfterMs } from "../usage-window-store.js";
 import { placementValueOrAbsent } from "./checkpoint-scope.js";
-import { assertNoRetiredResumeSeats } from "./retired-runner-deps.js";
-import { resolveMicroCompactKnob } from "./prepare-config-doors.js";
+import { assertNoRetiredInheritedConstraints } from "./retired-runner-deps.js";
 export function resumeInternalsAndConfig(input) {
     const { cp, config, internals, outcomeGate, runner } = input;
     let windowEntrance;
-    assertNoRetiredResumeSeats(runner.deps, config, internals);
-    resolveMicroCompactKnob(runner.deps.microCompact);
-    if (runner.deps.lockedConfig?.keys?.includes("toolPolicy") === true && config.basePolicyForResumeEdit !== undefined) {
-        throw new CheckpointError("checkpoint.invalid_outcome", "TaskSpec.basePolicyForResumeEdit is administratively locked by this deployment (locked key \"toolPolicy\") — a task-supplied " +
-            "resume-edit policy is refused pre-CAS (the checkpoint stays pending); remove the field or change the deployment's lock configuration");
-    }
+    asResumeConfigRefusal("deps", () => assertNoRetiredInheritedConstraints(internals));
     let recheckGovernanceWindow;
     {
         const rowPrincipal = cp.principal || undefined;

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.d.ts

@@ -1,11 +1,10 @@
 import type { RunnerDeps } from "../types.js";
-import type { ResumeTaskConfig, RunInternals } from "./contracts.js";
+import type { RunInternals } from "./contracts.js";
 /** Runs on the caller's own argument at `new Runner` (the only point that still sees an inherited seat — construction then
  *  reads every own seat once into the plain copy the Runner keeps, `retainRunnerDeps`), and again in the pre-first-await
  *  config-doors phase and pre-CAS on a resume. */
 export declare function assertNoRetiredRunnerDeps(deps: RunnerDeps): void;
-/** The resume ladder's pre-claim door: the retired seats of the deps, then the retired members of the caller policies this
- *  resume installs (the prepare's own resolution, `callerPolicySeats`) and of the inherited constraints it is handed. The edit
- *  re-check runs the resume-edit policy before the claim, and a refusal after the claim would burn the token on a store
- *  without `reopen`. */
-export declare function assertNoRetiredResumeSeats(deps: RunnerDeps, config: ResumeTaskConfig, internals: RunInternals | undefined): void;
+/** The resume ladder's pre-claim door over the inherited constraints a resume is handed: a retired member of one refuses before
+ *  the claim (a refusal after it would burn the token on a store without `reopen`). The deps' retired seats and the caller
+ *  policies' retired members are the config-door phase's, which a resume enters before the claim (`refuseResumeDoors`). */
+export declare function assertNoRetiredInheritedConstraints(internals: RunInternals | undefined): void;

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

@@ -1,19 +1,18 @@
-import { assertNoRetiredKeys, assertNoRetiredToolPolicyKeys } from "../retired-keys.js";
-import { assertCallerPoliciesCurrent, callerPolicySeats } from "../locked-config.js";
+import { assertNoRetiredKeys, assertNoRetiredToolPolicyKeys, RETIRED_HOOKS_REPLACEMENT } from "../retired-keys.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) {
     assertNoRetiredKeys(deps, RETIRED_RUNNER_DEPS_KEYS, "RunnerDeps");
 }
-export function assertNoRetiredResumeSeats(deps, config, internals) {
-    assertNoRetiredRunnerDeps(deps);
-    assertCallerPoliciesCurrent(callerPolicySeats(config, deps, deps.lockedConfig?.keys?.includes("toolPolicy") === true));
+export function assertNoRetiredInheritedConstraints(internals) {
     for (const constraint of internals?.inheritedGate?.parentConstraints ?? [])
         assertNoRetiredToolPolicyKeys(constraint.policy);
 }

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; } } };
 }