@sema-agent/core 7.51.2 → 7.53.0

package/dist/core/runner/run-stop-and-final-verify.js

@@ -1,10 +1,12 @@
 import { openSystemReminder } from "../reminder-mint.js";
-import { formatHookFeedback, hookSeatExpiredError, runHookSeat } from "../hooks.js";
+import { formatHookFeedback } from "../hooks.js";
+import { classicEventBase, dispatchClassic, stopEventOf, stringMembersAnswer, stringMembersOf } from "../mods/stations.js";
 import { asThrownError } from "../thrown-value.js";
 const STOP_HOOK_BLOCK_CAP = 8;
 export function runStopAndFinalVerify(input) {
     const { spec, prepared, queue, rs, stats, ident, walltimeMonotonicDeadline, runner } = input;
-    const stopHook = (spec.hooks ?? runner.deps.hooks)?.stop;
+    const stopEvent = stopEventOf(prepared.hookIdentity);
+    const stopArmed = prepared.modBus.hasHandlers(stopEvent);
     const finalVerificationOn = spec.finalVerification === true;
     const finalVerifyBudgetFill = () => {
         let worst = 0;
@@ -22,7 +24,7 @@ export function runStopAndFinalVerify(input) {
     const emitFinalVerifyEcho = (body) => {
         queue.push({ type: "steering_injected", source: "final_verification", preview: body.slice(0, 220), ...ident() });
     };
-    if (stopHook || finalVerificationOn) {
+    if (stopArmed || finalVerificationOn) {
         let consecutiveBlocks = 0;
         prepared.harness.setStopGate(async () => {
             if (prepared.abortController.signal.aborted || prepared.pausedRef.current !== undefined || prepared.batchHaltRef.current !== undefined)
@@ -100,32 +102,23 @@ export function runStopAndFinalVerify(input) {
                     },
                 ];
             }
-            if (!stopHook)
+            if (!stopArmed)
                 return [];
-            let result;
-            try {
-                const stopSeat = await runHookSeat("stop", { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal, abortEnds: true }, (sig) => stopHook({
-                    stopHookActive: consecutiveBlocks > 0,
-                    consecutiveBlocks,
-                    getBranch: () => prepared.session.getBranch(),
-                    backgroundTasks: () => prepared.listBackgroundTasks(),
-                    identity: prepared.hookIdentity,
-                    permissionMode: prepared.permissionMode.observed,
-                    signal: sig,
-                }));
-                if (stopSeat.expired) {
-                    if (stopSeat.cause === "timeout") {
-                        runner.deps.onError?.(hookSeatExpiredError("stop", prepared.hookTimeoutMs, stopSeat.cause, "the run was allowed to END (the seat's own no-opinion answer); no pushback and no additional context were injected"), { phase: "hook", sessionId: prepared.sessionId });
-                    }
-                    consecutiveBlocks = 0;
-                    return [];
-                }
-                result = stopSeat.value;
-            }
-            catch (err) {
+            const outcome = await dispatchClassic(prepared.modBus, stopEvent, {
+                ...classicEventBase(prepared.hookIdentity, prepared.permissionMode.observed),
+                stopHookActive: consecutiveBlocks > 0,
+                consecutiveBlocks,
+                getBranch: () => prepared.session.getBranch(),
+                backgroundTasks: () => prepared.listBackgroundTasks(),
+            }, { signal: prepared.abortController.signal, checkAnswer: stringMembersAnswer(stopEvent, ["block", "additionalContext"]) }).catch((err) => {
                 runner.deps.onError?.(asThrownError(err), { phase: "hook", sessionId: prepared.sessionId });
+                return undefined;
+            });
+            if (outcome?.kind !== "answered") {
+                consecutiveBlocks = 0;
                 return [];
             }
+            const result = stringMembersOf(outcome.answer, ["block", "additionalContext"]);
             const messages = [];
             if (result?.additionalContext) {
                 messages.push({

package/dist/core/runner/run-terminal-adoption.d.ts

@@ -22,6 +22,7 @@ import type { PushQueue } from "../push-queue.js";
 import type { Brain, OwedUserInputAccount, TaskEvent, TaskSpec } from "../types.js";
 import { type Stats } from "./assemble-result.js";
 import type { EndOfTaskCompaction, Prepared, RunnerDepsSeat, RunState } from "./contracts.js";
+import type { CallerStopGate } from "./caller-stop-gate.js";
 export interface RunTerminalAdoptionInput<R> {
     /** borrowed-readonly — the task spec: the task id the account's notices name; `finish`'s first argument (the end-of-task pass below). */
     spec: TaskSpec;
@@ -78,6 +79,8 @@ export interface RunTerminalAdoptionInput<R> {
     abortedLive: boolean;
     /** borrowed-readonly — the leg's snapshot of `loopLatch.userInterrupted` (gates the interruption marker). */
     userInterruptedLive: boolean;
+    /** borrowed-readonly — the run's caller-stop gate: the end-of-task pass admits on it and carries it (read LIVE, never snapshot). */
+    callerStop: CallerStopGate;
     /** borrowed-readonly — the Runner's deployment deps, read LIVE (`onError`, `checkpointStore`, `onNotice`, `mediaByteCapBytes`); the one home of why it is
      *  a seat and not a captured object is {@link RunnerDepsSeat}. */
     runner: RunnerDepsSeat;

package/dist/core/runner/run-terminal-adoption.js

@@ -1,4 +1,4 @@
-import { DEFAULT_COMPACTION_INSTRUCTIONS, maybeCompact } from "../auto-compaction.js";
+import { compactionPassReport, DEFAULT_COMPACTION_INSTRUCTIONS, isCompactionManualCancel, maybeCompact } from "../auto-compaction.js";
 import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
 import { appendInterruptionMarker, reconcileInterruptedSession } from "../session-reconcile.js";
 import { emitTrace } from "../trace.js";
@@ -12,7 +12,7 @@ import { MAX_CONSECUTIVE_COMPACTION_FAILURES } from "./compaction-knobs.js";
 import { emitSettled, reconciledEnd } from "./tool-end-body.js";
 import { asThrownError, thrownText } from "../thrown-value.js";
 export async function runTerminalAdoption(input) {
-    const { spec, queue, prepared, rs, stats, ident, emitCommitted, startedToolCallIds, toolLabels, timeout, compactionBrain, compactionBreaker, windowSafetyOptions, undrainedUserAtEnd, userInputLostAtEnd, final, abortedLive, userInterruptedLive, runner, sessions, next } = input;
+    const { spec, queue, prepared, rs, stats, ident, emitCommitted, startedToolCallIds, toolLabels, timeout, compactionBrain, compactionBreaker, windowSafetyOptions, undrainedUserAtEnd, userInputLostAtEnd, final, abortedLive, userInterruptedLive, callerStop, runner, sessions, next } = input;
     let { threw } = input;
     const settled = answerSettled(final, userInputLostAtEnd.current || prepared.undeliveredContinuationRef.current.parkedSteers.length > 0 || prepared.workCutRef.continuation || prepared.workCutRef.abortedBeforeTurnEnd);
     if (threw === undefined && prepared.brainCallGuardrailRef.timedOut !== undefined) {
@@ -115,12 +115,13 @@ export async function runTerminalAdoption(input) {
     }
     const comp = await finish(spec, prepared, {
         telemetry: { tracer: rs.telemetry.tracer, taskId: rs.telemetry.taskId },
-        skipCompaction: durablyPaused || (abortedLive && settled) || compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES,
+        skipCompaction: durablyPaused || (abortedLive && settled) || callerStop.signal.aborted || compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES,
+        callerStop,
         minTokens: rs.counters.compactionFloor,
         brain: compactionBrain,
         windowSafety: windowSafetyOptions(prepared.harness.getModel()),
-        onCompactionFailed: (reason) => queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "auto", reason, ...ident() }),
-        cancelled: abortedLive,
+        passReport: compactionPassReport(queue, ident),
+        onCompactionOutcome: (outcome, reason, end) => queue.push({ type: "compaction_outcome", outcome, trigger: "auto", reason, ...end, ...ident() }),
     }, runner, sessions);
     return await next({ threw, comp, answerSettled: settled, owedUserInput });
 }
@@ -130,7 +131,7 @@ async function finish(spec, prepared, opts, runner, sessions) {
         try {
             const finishComp = await maybeCompact({
                 session: prepared.session,
-                epochDeclaredSections: prepared.epochDeclaredSections,
+                promptIdentity: prepared.promptIdentity,
                 ...centerAdoptionOption(prepared),
                 model: prepared.harness.getModel(),
                 ...legContextOverlayOption(prepared, runner),
@@ -141,6 +142,8 @@ async function finish(spec, prepared, opts, runner, sessions) {
                 thinking: prepared.thinking,
                 settings: legCompactionSettings(spec, legContextOverlayOption(prepared, runner).contextOverlay),
                 customInstructions: spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
+                signal: opts.callerStop.signal,
+                manualCancelSignal: opts.callerStop.signal,
                 minTokens: opts?.minTokens,
                 overheadTokens: prepared.promptOverheadTokens,
                 ...(prepared.activeTools.size > 0 ? { activeTools: [...prepared.activeTools] } : {}),
@@ -151,10 +154,7 @@ async function finish(spec, prepared, opts, runner, sessions) {
                 ...(prepared.onCompactionApplied ? { onApplied: prepared.onCompactionApplied } : {}),
                 ...seamCCompactionOptions(runner, prepared),
                 ...compactionRestateOptions(prepared),
-                ...compactionHookOptions(runner, spec, prepared.sessionId, "auto", prepared.hookIdentity, {
-                    timeoutMs: prepared.hookTimeoutMs,
-                    ...(opts?.cancelled === true ? { signal: prepared.abortController.signal } : {}),
-                }),
+                ...compactionHookOptions(runner, prepared, "auto", opts.callerStop.signal), onStarted: opts.passReport.onStarted,
             });
             recordCompactionReuse(runner, prepared, finishComp);
             if (finishComp.unevaluableWindow) {
@@ -163,18 +163,30 @@ async function finish(spec, prepared, opts, runner, sessions) {
             comp = finishComp;
         }
         catch (err) {
-            const failMsg = thrownText(err);
-            const failReason = failMsg.length > 512 ? `${failMsg.slice(0, 512)}…` : failMsg;
-            emitTrace(opts?.telemetry?.tracer ?? spec.tracer ?? runner.deps.tracer, () => ({
-                kind: "compaction.failed",
-                version: 1,
-                taskId: opts?.telemetry?.taskId ?? spec.taskId ?? prepared.sessionId,
-                trigger: "auto",
-                reason: failReason,
-                ts: Date.now(),
-            }));
-            opts?.onCompactionFailed?.(failReason);
-            runner.deps.onError?.(err, { phase: "compaction", sessionId: prepared.sessionId });
+            if (isCompactionManualCancel(err)) {
+                emitTrace(opts?.telemetry?.tracer ?? spec.tracer ?? runner.deps.tracer, () => ({
+                    kind: "compaction.mooted",
+                    version: 1,
+                    taskId: opts?.telemetry?.taskId ?? spec.taskId ?? prepared.sessionId,
+                    reason: "cancelled",
+                    ts: Date.now(),
+                }));
+                opts?.onCompactionOutcome?.("mooted", "cancelled", opts.passReport.end);
+            }
+            else {
+                const failMsg = thrownText(err);
+                const failReason = failMsg.length > 512 ? `${failMsg.slice(0, 512)}…` : failMsg;
+                emitTrace(opts?.telemetry?.tracer ?? spec.tracer ?? runner.deps.tracer, () => ({
+                    kind: "compaction.failed",
+                    version: 1,
+                    taskId: opts?.telemetry?.taskId ?? spec.taskId ?? prepared.sessionId,
+                    trigger: "auto",
+                    reason: failReason,
+                    ts: Date.now(),
+                }));
+                opts?.onCompactionOutcome?.("failed", failReason, opts.passReport.end);
+                runner.deps.onError?.(err, { phase: "compaction", sessionId: prepared.sessionId });
+            }
         }
     }
     try {

package/dist/core/runner/run-tool-mount-facts.js

@@ -21,11 +21,13 @@ export function runToolMountFacts(input) {
     emitTrace(rs.telemetry.tracer, () => ({ kind: "task.start", version: 1, taskId: rs.telemetry.taskId, runId: rs.telemetry.runId, model: prepared.model.id, engineVersion: engineVersion(), ts: rs.telemetry.taskStart }));
     emitTrace(rs.telemetry.tracer, () => ({
         kind: "prompt.assembled",
-        version: 1,
+        version: 3,
         taskId: rs.telemetry.taskId,
-        constitution: prepared.promptManifest.constitution,
+        identity: prepared.promptManifest.identity,
+        selectors: prepared.promptManifest.selectors,
         blocks: prepared.promptManifest.blocks,
-        ...(prepared.promptManifest.sections ? { sections: prepared.promptManifest.sections } : {}),
+        sections: prepared.promptManifest.sections,
+        ...(prepared.promptManifest.superseded ? { superseded: prepared.promptManifest.superseded } : {}),
         ...(prepared.promptManifest.tools ? { tools: prepared.promptManifest.tools } : {}),
         ...(prepared.promptManifest.snapshot ? { snapshot: prepared.promptManifest.snapshot } : {}),
         ...(prepared.promptManifest.lowering ? { lowering: prepared.promptManifest.lowering } : {}),

package/dist/core/runner/run-turn-boundary.js

@@ -1,13 +1,13 @@
 import { compactionKindOf } from "../task-notification.js";
 import { mintSystemReminder } from "../reminder-mint.js";
 import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
-import { DEFAULT_COMPACTION_INSTRUCTIONS, isCompactionManualCancel, maybeCompact, mintCompactedEvent, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill } from "../auto-compaction.js";
+import { compactionPassReport, DEFAULT_COMPACTION_INSTRUCTIONS, isCompactionManualCancel, maybeCompact, mintCompactedEvent, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill } from "../auto-compaction.js";
 import { emitTrace } from "../trace.js";
 import { redactThenCut } from "../../agents/subagent-steps.js";
 import { ATTACHMENT_BYTE_CAP, CHANGED_FILES_MAX, TOTAL_TOKENS_REMINDER_DEFAULT_MODE, attachmentEnvelopeTags, clipToBytes, collectDateChange, collectDueAttachments, collectInstructionsChange, commitAgentListing, commitInstructionsChange, commitSkillsListing, isIntactSource, rebaseCadenceWindows, renderAgentListingFrame, renderMcpDroppedTools, renderMcpInstructionsDelta, selectMcpDroppedBatch, renderSkillsListingFrame, renderToolsDelta } from "./turn-attachments.js";
 import { announceListingTruncation } from "../skill-listing-budget.js";
 import { buildWorkingFileAttachments, centerAdoptionOption, contextInstructionFilesOption, emitInputTruncated, forkContextOption, legCompactionSettings, legContextOverlayOption } from "./compaction-call-options.js";
-import { hookSeatExpiredError, runHookSeat } from "../hooks.js";
+import { classicEventBase, dispatchClassic, stringMembersAnswer, stringMembersOf } from "../mods/stations.js";
 import { sanitizeUntrustedText, SHELLED_BODY_ENVELOPE_TAGS } from "../untrusted-text.js";
 import { droppedToolDigest, withAnnounceDigests } from "./announce-once-ledger.js";
 import { formatDiagnosticsBlock, withholdListedDiagnostics } from "../lsp-diagnostics.js";
@@ -23,7 +23,7 @@ const BATCH_CONTEXT_MIN_KEEP_BYTES = 160;
 const BATCH_TRUNCATION_MARKER = "\n…[truncated]";
 export function createTurnBoundary(input) {
     const { prepared, stats, rs, deps } = input;
-    const { spec, queue, manualCompactRef, todoToolMounted, taskToolsMounted, walltimeMonotonicDeadline, timeout, ident, postToolBatchHook, batchArgs, compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions, rapidRefill, drainManualCompact, runnerHooks, runner } = deps;
+    const { spec, queue, loopLatch: { callerStop }, manualCompactRef, todoToolMounted, taskToolsMounted, walltimeMonotonicDeadline, timeout, ident, postToolBatchArmed, batchArgs, compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions, rapidRefill, drainManualCompact, runnerHooks, runner } = deps;
     let finalVerifySeenAtLastBoundary = 0;
     let legContinues = true;
     const boundaryPass = async (event) => {
@@ -464,35 +464,30 @@ export function createTurnBoundary(input) {
         let batchContextBlock;
         const finalVerifyInjectedThisTurn = rs.counters.finalVerifyInjections !== finalVerifySeenAtLastBoundary;
         finalVerifySeenAtLastBoundary = rs.counters.finalVerifyInjections;
-        if (postToolBatchHook !== undefined && rs.turn.toolBatch.length > 0) {
+        if (postToolBatchArmed && rs.turn.toolBatch.length > 0) {
             const batch = rs.turn.toolBatch;
             rs.turn.toolBatch = [];
             batchArgs?.clear();
             const injectedThisTurn = finalVerifyInjectedThisTurn ? "final_verification" : undefined;
             if (!boundarySteered && !prepared.abortController.signal.aborted) {
-                try {
-                    const batchSeat = await runHookSeat("postToolBatch", { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal }, (sig) => postToolBatchHook(batch, injectedThisTurn !== undefined ? { injectedThisTurn } : undefined, { identity: prepared.hookIdentity, permissionMode: prepared.permissionMode.observed, signal: sig }));
-                    if (batchSeat.expired) {
-                        runnerHooks.onError?.(hookSeatExpiredError("postToolBatch", prepared.hookTimeoutMs, batchSeat.cause, "the boundary observation was abandoned and its additionalContext dropped; the turn boundary itself is unchanged"), { phase: "hook", sessionId: prepared.sessionId });
-                    }
-                    const r = batchSeat.expired ? undefined : batchSeat.value;
-                    if (r?.additionalContext && injectedThisTurn === undefined) {
-                        const body = sanitizeUntrustedText(r.additionalContext, SHELLED_BODY_ENVELOPE_TAGS);
-                        const budget = ATTACHMENT_BYTE_CAP - boundaryAttachmentBytes;
-                        if (budget >= BATCH_CONTEXT_MIN_KEEP_BYTES) {
-                            const clipped = clipToBytes(body, budget) === body
-                                ? body
-                                : `${clipToBytes(body, budget - Buffer.byteLength(BATCH_TRUNCATION_MARKER, "utf8"))}${BATCH_TRUNCATION_MARKER}`;
-                            batchContextBlock = mintSystemReminder(clipped, prepared.reminderMark);
-                        }
-                    }
-                }
-                catch (err) {
+                const outcome = await dispatchClassic(prepared.modBus, "classic.PostToolBatch", { ...classicEventBase(prepared.hookIdentity, prepared.permissionMode.observed), batch, ...(injectedThisTurn !== undefined ? { injectedThisTurn } : {}) }, { signal: prepared.abortController.signal, checkAnswer: stringMembersAnswer("classic.PostToolBatch", ["additionalContext"]) }).catch((err) => {
                     try {
                         runnerHooks.onError?.(asThrownError(err), { phase: "hook", sessionId: prepared.sessionId });
                     }
                     catch {
                     }
+                    return undefined;
+                });
+                const r = outcome?.kind === "answered" ? stringMembersOf(outcome.answer, ["additionalContext"]) : undefined;
+                if (r?.additionalContext && injectedThisTurn === undefined) {
+                    const body = sanitizeUntrustedText(r.additionalContext, SHELLED_BODY_ENVELOPE_TAGS);
+                    const budget = ATTACHMENT_BYTE_CAP - boundaryAttachmentBytes;
+                    if (budget >= BATCH_CONTEXT_MIN_KEEP_BYTES) {
+                        const clipped = clipToBytes(body, budget) === body
+                            ? body
+                            : `${clipToBytes(body, budget - Buffer.byteLength(BATCH_TRUNCATION_MARKER, "utf8"))}${BATCH_TRUNCATION_MARKER}`;
+                        batchContextBlock = mintSystemReminder(clipped, prepared.reminderMark);
+                    }
                 }
             }
         }
@@ -507,6 +502,7 @@ export function createTurnBoundary(input) {
         const forceManual = manualCompactRef.requested;
         if ((!withinTaskCompaction() && !forceManual) ||
             prepared.abortController.signal.aborted ||
+            callerStop.signal.aborted ||
             prepared.pausedRef.current !== undefined) {
             if (forceManual) {
                 emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.mooted", version: 1, taskId: rs.telemetry.taskId, reason: "task_ending", ts: Date.now() }));
@@ -553,14 +549,8 @@ export function createTurnBoundary(input) {
                     w.resolve(outcome);
         };
         const claimedCancelSignals = claimedManual?.waiters.flatMap((w) => (w.signal !== undefined ? [w.signal] : [])) ?? [];
-        const manualCancelSignal = claimedCancelSignals.length === 0
-            ? undefined
-            : claimedCancelSignals.length === 1
-                ? claimedCancelSignals[0]
-                : AbortSignal.any(claimedCancelSignals);
-        const compactionPassSignal = claimedCancelSignals.length > 0
-            ? AbortSignal.any([prepared.abortController.signal, ...claimedCancelSignals])
-            : prepared.abortController.signal;
+        const manualCancelSignal = claimedCancelSignals.length === 0 ? callerStop.signal : AbortSignal.any([callerStop.signal, ...claimedCancelSignals]);
+        const compactionPassSignal = AbortSignal.any([prepared.abortController.signal, manualCancelSignal]);
         const trimPressureArmed = prepared.trimPressureRef.droppedMessages;
         if (trimPressureArmed)
             prepared.trimPressureRef.droppedMessages = false;
@@ -568,10 +558,11 @@ export function createTurnBoundary(input) {
         const passTrigger = trimPressure ? "forced" : forceManual ? "manual" : "auto";
         let manualOutcome = "failed";
         const manualInstructions = claimedManual?.instructions;
+        const passReport = compactionPassReport(queue, ident);
         try {
             const comp = await maybeCompact({
                 session: prepared.session,
-                epochDeclaredSections: prepared.epochDeclaredSections,
+                promptIdentity: prepared.promptIdentity,
                 ...centerAdoptionOption(prepared),
                 model: event.model,
                 ...legContextOverlayOption(prepared, runner),
@@ -583,7 +574,7 @@ export function createTurnBoundary(input) {
                 settings: legCompactionSettings(spec, legContextOverlayOption(prepared, runner).contextOverlay),
                 customInstructions: manualInstructions ?? spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
                 signal: compactionPassSignal,
-                ...(manualCancelSignal !== undefined ? { manualCancelSignal } : {}),
+                manualCancelSignal,
                 minTokens: forceManual ? 0 : rs.counters.compactionFloor,
                 force: forceManual,
                 onInputTruncated: emitInputTruncated(rs.telemetry.tracer, rs.telemetry.taskId),
@@ -596,7 +587,8 @@ export function createTurnBoundary(input) {
                 ...seamCCompactionOptions(runner, prepared),
                 ...compactionRestateOptions(prepared),
                 ...windowSafetyOptions(event.model),
-                ...compactionHookOptions(runner, spec, prepared.sessionId, passTrigger, prepared.hookIdentity, { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal }),
+                ...compactionHookOptions(runner, prepared, passTrigger, compactionPassSignal),
+                onStarted: passReport.onStarted,
             });
             if (comp.blocked) {
                 emitTrace(rs.telemetry.tracer, () => ({
@@ -678,10 +670,9 @@ export function createTurnBoundary(input) {
             }
         }
         catch (err) {
-            const manualCancelAbort = !prepared.abortController.signal.aborted && isCompactionManualCancel(err);
-            if (manualCancelAbort) {
+            if (isCompactionManualCancel(err)) {
                 emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.mooted", version: 1, taskId: rs.telemetry.taskId, reason: "cancelled", ts: Date.now() }));
-                queue.push({ type: "compaction_outcome", outcome: "mooted", trigger: passTrigger, reason: "cancelled", ...ident() });
+                queue.push({ type: "compaction_outcome", outcome: "mooted", trigger: passTrigger, reason: "cancelled", ...passReport.end, ...ident() });
                 manualOutcome = "mooted";
             }
             else if (!prepared.abortController.signal.aborted) {
@@ -697,11 +688,15 @@ export function createTurnBoundary(input) {
                     reason: failReason,
                     ts: Date.now(),
                 }));
-                queue.push({ type: "compaction_outcome", outcome: "failed", trigger: passTrigger, reason: failReason, ...ident() });
+                queue.push({ type: "compaction_outcome", outcome: "failed", trigger: passTrigger, reason: failReason, ...passReport.end, ...ident() });
                 manualOutcome = "failed";
             }
             else {
                 manualOutcome = "mooted";
+                if (passReport.pass !== undefined) {
+                    emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.mooted", version: 1, taskId: rs.telemetry.taskId, reason: "task_ending", ts: Date.now() }));
+                    queue.push({ type: "compaction_outcome", outcome: "mooted", trigger: passTrigger, reason: "task_ending", ...passReport.end, ...ident() });
+                }
             }
         }
         if (forceManual)

package/dist/core/runner/runtask.d.ts

@@ -88,13 +88,13 @@ export declare class Runner implements RunnerSelfSeat {
      *  followed) against the seat and catalog in force, so a `swapDeps` reaches legs already running. */
     contextOverlayOf(ref: ModelRef | undefined): ContextWindowOverlay | undefined;
     /** The deployment-level gating baseline, exposed READ-ONLY so thin
-     *  assemblers over the Runner (`runSpec`) can COMPOSE with it. The task-level engine semantic is a
-     *  WHOLE-SLOT override (`spec.toolPolicy ?? deps.toolPolicy`, same for hooks — prepare-task), so any
-     *  assembler that sets `spec.toolPolicy`/`spec.hooks` without folding these in silently shadows the
-     *  deployment baseline. Getter only — nothing here is writable from outside. */
+     *  assemblers over the Runner (`runSpec`) can COMPOSE with it. The task-level engine semantic for the policy is a
+     *  WHOLE-SLOT override (`spec.toolPolicy ?? deps.toolPolicy` — prepare-task), so any assembler that sets
+     *  `spec.toolPolicy` without folding this in silently shadows the deployment baseline. (The mods bus needs no
+     *  baseline: its two seats run side by side, so an assembler's task registrations never shadow `deps.mods`.)
+     *  Getter only — nothing here is writable from outside. */
     get gateBaseline(): {
         toolPolicy?: RunnerDeps["toolPolicy"];
-        hooks?: RunnerDeps["hooks"];
     };
     /** Acquire the lock for a sessionId; returns a release fn. The one lock every leg holds on its session, from the moment it
      *  knows the id to the leg's end (through `holdSessionLock` in `runTaskStream`, one per leg). */
@@ -122,8 +122,7 @@ export declare class Runner implements RunnerSelfSeat {
      *   engine default); a key absent is kept. `tiers` omitted beside `models` ⇒ the current bindings are
      *   re-applied over the new catalog.
      * - **Announced per seat.** `config.models_swapped` (models/tiers counts — key material only, never the
-     *   catalog itself; plus the advisory `route.base_url_changed_key_unchanged` for same-name entries
-     *   whose URL moved while the Model-visible credential fingerprint did not) and
+     *   catalog itself) and
      *   `config.read_face_swapped` / `config.write_face_swapped` (`{ from, to, occurrenceId }`, the seat's
      *   previous and new value, `null` = no declaration) — the table {@link SWAP_SEAT_NOTICE} binds every
      *   seat to its line.

package/dist/core/runner/runtask.js

@@ -7,7 +7,6 @@ import { createRapidRefillState } from "../auto-compaction.js";
 import { boundInputHashOf } from "../canonical-json.js";
 import { emitTrace } from "../trace.js";
 import { emitTaskOutcome } from "../task-outcome.js";
-import { authCarrierFingerprint, displayUrlOf, routeKeyOf } from "../../brain/route-adjudicator.js";
 import { runWithReasoningWireFacts } from "../../brain/status-sink.js";
 import { expandTiers } from "../roles.js";
 import { announceReadDenySwap, screenSwappableDeps } from "../swappable-deps.js";
@@ -142,48 +141,12 @@ export class Runner {
     }
     get gateBaseline() {
         const deps = this.deps;
-        const h = deps.hooks;
-        const hooks = h
-            ? {
-                ...(typeof h.preToolUse === "function" ? { preToolUse: (t, i, c) => h.preToolUse(t, i, c) } : {}),
-                ...(typeof h.preToolUse === "function" && h.preToolUseObservational === true ? { preToolUseObservational: true } : {}),
-                ...(typeof h.postToolUse === "function" ? { postToolUse: (t, i, o, c) => h.postToolUse(t, i, o, c) } : {}),
-                ...(typeof h.userPromptSubmit === "function" ? { userPromptSubmit: (p, c) => h.userPromptSubmit(p, c) } : {}),
-                ...(typeof h.stop === "function" ? { stop: (c) => h.stop(c) } : {}),
-                ...(typeof h.postToolUseFailure === "function"
-                    ? { postToolUseFailure: (t, i, f, c) => h.postToolUseFailure(t, i, f, c) }
-                    : {}),
-                ...(typeof h.postToolBatch === "function" ? { postToolBatch: (b, m, c) => h.postToolBatch(b, m, c) } : {}),
-                ...(typeof h.preCompact === "function" ? { preCompact: (c) => h.preCompact(c) } : {}),
-                ...(typeof h.postCompact === "function" ? { postCompact: (c) => h.postCompact(c) } : {}),
-                ...(typeof h.stopFailure === "function" ? { stopFailure: (c) => h.stopFailure(c) } : {}),
-                ...(typeof h.permissionDenied === "function" ? { permissionDenied: (p) => h.permissionDenied(p) } : {}),
-                ...(h.timeoutMs !== undefined ? { timeoutMs: h.timeoutMs } : {}),
-            }
-            : undefined;
-        const MIRRORED_HOOK_KEYS = [
-            "preToolUse",
-            "preToolUseObservational",
-            "postToolUse",
-            "userPromptSubmit",
-            "stop",
-            "postToolUseFailure",
-            "postToolBatch",
-            "preCompact",
-            "postCompact",
-            "stopFailure",
-            "permissionDenied",
-            "timeoutMs",
-        ];
-        const _mirrorIsComplete = true;
-        void _mirrorIsComplete;
         return {
             ...(deps.toolPolicy !== undefined
                 ? {
                     toolPolicy: wrapToolPolicy(deps.toolPolicy, (req, signal) => deps.toolPolicy.check(req, signal)),
                 }
                 : {}),
-            ...(hooks !== undefined ? { hooks } : {}),
         };
     }
     async acquireSessionLock(sessionId) {
@@ -210,19 +173,10 @@ export class Runner {
         const catalogSwap = seats.includes("models");
         let expanded;
         let tiers;
-        const movedEntries = [];
         if (catalogSwap) {
             const models = candidate.models;
             tiers = Object.hasOwn(candidate, "tiers") ? candidate.tiers : this.deps.tiers;
             expanded = tiers && Object.keys(tiers).length > 0 ? expandTiers({ ...models }, tiers) : { ...models };
-            for (const [name, nextModel] of Object.entries(expanded ?? {})) {
-                const prior = this.deps.models?.[name];
-                if (!prior)
-                    continue;
-                if (routeKeyOf(prior.baseUrl) !== routeKeyOf(nextModel.baseUrl) && authCarrierFingerprint(prior.headers) === authCarrierFingerprint(nextModel.headers)) {
-                    movedEntries.push({ modelId: name, from: displayUrlOf(prior.baseUrl), to: displayUrlOf(nextModel.baseUrl) });
-                }
-            }
         }
         const faceSeats = ["readFace", "writeFace"].filter((seat) => seats.includes(seat));
         const priorFaces = {
@@ -254,18 +208,6 @@ export class Runner {
                 message: `model catalog swapped: ${modelCount} model(s), ${tiers ? Object.keys(tiers).length : 0} tier binding(s); in-flight tasks finish on their resolved models, new tasks resolve against the new catalog`,
                 detail: { models: modelCount, tiers: tiers ? Object.keys(tiers).length : 0, occurrenceId: uuidv7() },
             });
-            if (movedEntries.length > 0) {
-                const RENDER_CAP = 8;
-                const rendered = movedEntries.slice(0, RENDER_CAP);
-                deliverEngineNotice(this.deps.onNotice, {
-                    code: "route.base_url_changed_key_unchanged",
-                    message: `model catalog swap moved ${movedEntries.length} entry/entries to a new baseUrl while the Model-visible credential half stayed unchanged: ` +
-                        rendered.map((e) => `"${e.modelId}" ${e.from || "(config root)"} → ${e.to || "(config root)"}`).join("; ") +
-                        (movedEntries.length > rendered.length ? `; +${movedEntries.length - rendered.length} more` : "") +
-                        " — if the provider changed (not just its domain), update the credential reference in the same step",
-                    detail: { entries: rendered, total: movedEntries.length, occurrenceId: uuidv7() },
-                });
-            }
         }
         if (seats.includes("contextSettings")) {
             const to = candidate.contextSettings;
@@ -461,27 +403,27 @@ export class Runner {
                         const { effectiveTimeoutMs, walltimeMonotonicDeadline, timeout, pushContent, ownCommittedTailRef, emitCommitted } = runClockAndContent({ spec, prepared, queue, internals, rs, ident, parentToolCallId, startedToolCallIds });
                         const toolProgress = createToolProgressLane(pushContent, ident, prepared.toolOccurrences);
                         prepared.toolProgressRef.current = toolProgress;
-                        const { withBrainSinks, withExtraBodyDroppedSink } = runBrainSinks({ queue, internals, rs, ident, observeReasoningWireFacts, notice: { onNotice: this.deps.onNotice, sessionId: prepared.sessionId, runId: prepared.runId } });
+                        const { withBrainSinks, withLegRequestSinks } = runBrainSinks({ queue, internals, rs, ident, observeReasoningWireFacts, notice: { onNotice: this.deps.onNotice, sessionId: prepared.sessionId, runId: prepared.runId } });
                         const toolLabels = new Map(prepared.tools.flatMap((t) => (t.label !== undefined && t.label !== t.name ? [[t.name, t.label]] : [])));
                         for (const orphan of prepared.wakeRecovered) {
                             emitSettled(prepared.toolOccurrences, { toolCallId: orphan.toolCallId, spelledName: orphan.toolName, ...(toolLabels.has(orphan.toolName) ? { label: toolLabels.get(orphan.toolName) } : {}), args: orphan.args }, reconciledEnd(orphan), { push: (f) => queue.push({ ...f, ...ident() }), structured: prepared.structuredProjector, mediaByteCapBytes: this.deps.mediaByteCapBytes });
                             emitCommitted(orphan.entryId, "toolResult", orphan.toolCallId);
                         }
-                        const postToolBatchHook = (spec.hooks ?? this.deps.hooks)?.postToolBatch;
-                        const batchArgs = postToolBatchHook ? new Map() : undefined;
+                        const postToolBatchArmed = prepared.modBus.hasHandlers("classic.PostToolBatch");
+                        const batchArgs = postToolBatchArmed ? new Map() : undefined;
                         rs.turn.toolBatch = [];
                         const { onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, announceWorkspaceMove } = createHarnessHandlers({
                             prepared, stats, rs,
                             deps: {
                                 spec, queue, internals, ident, mediaByteCapBytes: this.deps.mediaByteCapBytes,
                                 pushContent, emitCommitted, startedToolCallIds, toolStartAt, toolProgress, writeFamilyOf,
-                                toolLabels, postToolBatchHook, batchArgs, internalsNotifier,
+                                toolLabels, postToolBatchArmed, batchArgs, internalsNotifier,
                                 runnerHooks: { onError: (e, info) => this.deps.onError?.(e, info), onNotice: this.deps.onNotice },
                             },
                         });
-                        const { compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions } = runCompactionMachinery({ spec, prepared, rs, stats, noteUnevaluablePriceTable, runner: this.depsSeat });
+                        const { compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions } = runCompactionMachinery({ spec, prepared, rs, stats, noteUnevaluablePriceTable, modelCatalog, runner: this.depsSeat });
                         runStopAndFinalVerify({ spec, prepared, queue, rs, stats, ident, walltimeMonotonicDeadline, runner: this.depsSeat });
-                        runRecoveryLanes({ spec, prepared, queue, rs, ident, compactionBrain, compactionBreaker, windowSafetyOptions, runner: this.depsSeat });
+                        runRecoveryLanes({ spec, prepared, queue, rs, ident, compactionBrain, compactionBreaker, windowSafetyOptions, callerStop: loopLatch.callerStop, runner: this.depsSeat });
                         const rapidRefill = createRapidRefillState();
                         const drainManualCompact = (outcome) => {
                             manualCompactRef.requested = false;
@@ -493,20 +435,20 @@ export class Runner {
                             deps: {
                                 spec, queue, loopLatch, manualCompactRef, todoToolMounted, taskToolsMounted,
                                 walltimeMonotonicDeadline,
-                                timeout, ident, postToolBatchHook, batchArgs, compactionBrain, withinTaskCompaction,
+                                timeout, ident, postToolBatchArmed, batchArgs, compactionBrain, withinTaskCompaction,
                                 compactionBreaker, windowSafetyOptions, rapidRefill, drainManualCompact,
                                 runnerHooks: { onError: this.deps.onError },
                                 runner: this.depsSeat,
                             },
                         });
                         const { flushGitMirror, unsubGitRetry, unsubBoundary, unsub } = runGitLane({ prepared, queue, rs, ident, onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, onTurnBoundary, runner: this.depsSeat });
-                        return withExtraBodyDroppedSink(() => runLeg({
+                        return withLegRequestSinks(() => runLeg({
                             spec, queue, prepared, resume, rs, entryActor, effectiveTimeoutMs, timeout, pushContent, ident, emitCommitted, writeFamilyOf, startedToolCallIds,
                             announceWorkspaceMove, withBrainSinks, flushGitMirror, loopLatch, notificationLane, unsubscribeTaskNotifications, unsubGitRetry, unsubBoundary, unsub,
                             runner: this.depsSeat,
                             next: ({ final, threw, abortedLive, userInterruptedLive, strandedHumanAnswers }) => runTerminalAdoption({
                                 spec, queue, prepared, rs, stats, ident, emitCommitted, startedToolCallIds, toolLabels, timeout, compactionBrain, compactionBreaker, windowSafetyOptions,
-                                undrainedUserAtEnd, userInputLostAtEnd, final, threw, abortedLive, userInterruptedLive, runner: this.depsSeat, sessions: this.sessions,
+                                undrainedUserAtEnd, userInputLostAtEnd, final, threw, abortedLive, userInterruptedLive, callerStop: loopLatch.callerStop, runner: this.depsSeat, sessions: this.sessions,
                                 next: ({ threw, comp, answerSettled, owedUserInput }) => runSettleAndTeardown({
                                     spec, queue, prepared, resume, internals, rs, stats, ident, loopLatch, timeout, ownCommittedTailRef,
                                     emitDelegationLifecycle, taskIdRef, manualCompactRef, drainManualCompact, final, threw, abortedLive, userInterruptedLive, answerSettled, strandedHumanAnswers, reasoningResolution, comp, compactionBreaker, owedUserInput,
@@ -539,7 +481,7 @@ export class Runner {
             outcome,
             taskConfig,
             internals,
-            runner: this.depsSeat,
+            runner: this.depsSeat, sessions: this.sessions,
             parentConstraintRegistry: this.parentConstraintRegistry,
             next: (admitted) => this.resumeLadder(token, outcome, admitted),
         });
@@ -548,7 +490,7 @@ export class Runner {
         const { config, internals, store, cp, outcomeGate, resumeSignal, wakeMessage } = admitted;
         const { plainReviewOutcome, plainParkOutcome } = resumeReviewOutcome({ cp, outcome, outcomeGate, wakeMessage });
         const { plainPolicyOutcome: capturedPolicyOutcome, redeemedAnswer } = resumePolicyOutcome({ cp, outcome, config, runner: this.depsSeat });
-        const { resumeInternals } = resumeCheckpointScreen({ cp, resumeSignal, internals, runner: this.depsSeat });
+        const { resumeInternals } = resumeCheckpointScreen({ cp, resumeSignal, internals, tools: config.tools, runner: this.depsSeat });
         const { recheckGovernanceWindow, windowEntrance } = resumeInternalsAndConfig({ cp, config, internals, outcomeGate, runner: this.depsSeat });
         if (windowEntrance !== undefined)
             await windowEntrance;
@@ -556,19 +498,19 @@ export class Runner {
             cp, config, internals, outcomeGate, wakeMessage, resumeSignal, recheckGovernanceWindow,
             plainPolicyOutcome: capturedPolicyOutcome, plainReviewOutcome, plainParkOutcome,
             runner: this.depsSeat, effectiveDelegationFacts,
-            next: ({ wakeHookContext, plainPolicyOutcome, outcomeForStore }) => resumePreflight({
+            next: ({ wakeHookContext, legMods, plainPolicyOutcome, outcomeForStore }) => resumePreflight({
                 token, cp, resumeSignal, recheckGovernanceWindow, store, runner: this.depsSeat,
                 locallyClaimedTokens: this.locallyClaimedTokens, parentConstraintRegistry: this.parentConstraintRegistry, suspendedEnvReaps: this.suspendedEnvReaps,
                 next: () => resumeClaim({
                     token, cp, store, outcomeForStore,
                     locallyClaimedTokens: this.locallyClaimedTokens, parentConstraintRegistry: this.parentConstraintRegistry,
-                    next: () => this.resumeHandoff({ token, cp, store, config, internals, resumeInternals, plainPolicyOutcome, redeemedAnswer, outcomeForStore, wakeMessage, wakeHookContext, resumeSignal }),
+                    next: () => this.resumeHandoff({ token, cp, store, config, internals, resumeInternals, plainPolicyOutcome, redeemedAnswer, outcomeForStore, wakeMessage, wakeHookContext, legMods, resumeSignal }),
                 }),
             }),
         });
     }
     async resumeHandoff(claimed) {
-        const { token, cp, store, config, internals, resumeInternals, plainPolicyOutcome, redeemedAnswer, outcomeForStore, wakeMessage, wakeHookContext, resumeSignal } = claimed;
+        const { token, cp, store, config, internals, resumeInternals, plainPolicyOutcome, redeemedAnswer, outcomeForStore, wakeMessage, wakeHookContext, legMods, resumeSignal } = claimed;
         let consumeFlipDone = false;
         if (internals?.afterCheckpointResolve !== undefined) {
             await internals.afterCheckpointResolve();
@@ -616,7 +558,7 @@ export class Runner {
                     ? new CheckpointError("checkpoint.reopen_failed", "the resume was aborted before the approved action could run AND the store refused to reopen the checkpoint — the approval is terminally consumed and the suspended work was not executed; a retry needs a fresh approval")
                     : new CheckpointError("checkpoint.reopen_failed", "the resume was aborted before the approved action could run and the reopen attempt FAILED IN FLIGHT — the checkpoint's state is unprovable from here: it may already be pending again. Re-read it before deciding; do NOT issue a fresh approval on the assumption the old one is dead (the approved action did NOT run either way)");
         }
-        return this.runTaskStream(spec, { cp, outcome: outcomeForStore, onEnvRestoreFailed, recordExecutionOutcome, ...(wakeMessage !== undefined ? { wakeMessage } : {}), ...(wakeHookContext !== undefined ? { wakeMessageHookContext: wakeHookContext } : {}) }, resumeInternals);
+        return this.runTaskStream(spec, { cp, outcome: outcomeForStore, onEnvRestoreFailed, recordExecutionOutcome, ...(wakeMessage !== undefined ? { wakeMessage } : {}), ...(wakeHookContext !== undefined ? { wakeMessageHookContext: wakeHookContext } : {}), ...(legMods !== undefined ? { legMods } : {}) }, resumeInternals);
     }
 }
 export function runTask(spec, deps) {