@sema-agent/core 7.51.2 → 7.52.0

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

@@ -1,4 +1,4 @@
-import { DEFAULT_COMPACTION_INSTRUCTIONS, maybeCompact } from "../auto-compaction.js";
+import { 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,12 @@ 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,
+        onCompactionOutcome: (outcome, reason) => queue.push({ type: "compaction_outcome", outcome, trigger: "auto", reason, ...ident() }),
     }, runner, sessions);
     return await next({ threw, comp, answerSettled: settled, owedUserInput });
 }
@@ -130,7 +130,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 +141,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 +153,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),
             });
             recordCompactionReuse(runner, prepared, finishComp);
             if (finishComp.unevaluableWindow) {
@@ -163,18 +162,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");
+            }
+            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);
+                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

@@ -7,7 +7,7 @@ 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;
@@ -571,7 +561,7 @@ export function createTurnBoundary(input) {
         try {
             const comp = await maybeCompact({
                 session: prepared.session,
-                epochDeclaredSections: prepared.epochDeclaredSections,
+                promptIdentity: prepared.promptIdentity,
                 ...centerAdoptionOption(prepared),
                 model: event.model,
                 ...legContextOverlayOption(prepared, runner),
@@ -583,7 +573,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 +586,7 @@ 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),
             });
             if (comp.blocked) {
                 emitTrace(rs.telemetry.tracer, () => ({
@@ -678,8 +668,7 @@ 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() });
                 manualOutcome = "mooted";

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,
@@ -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) {

package/dist/core/runner/session-rule-policy.d.ts

@@ -1,7 +1,7 @@
 import type { ExecutionEnv } from "../../internal/harness-types.js";
 import type { ToolEffect } from "../types.js";
 import type { NamedToolPolicy } from "../tool-policy.js";
-import { type SessionPermissionRules, type SessionPolicyStore, type StoredSessionRules } from "../session-policy-store.js";
+import { type SessionPermissionRules, type SessionPolicyStore, type SessionRuleEntryField, type StoredSessionRules } from "../session-policy-store.js";
 import type { PathRuleBases } from "../permission-rule-model.js";
 /** The FULL path-confinable write-tool set: every catalog tool declaring a write path target — `Write` / `Edit`
  *  (target `file_path`) and `NotebookEdit`, whose write target is `notebook_path` and is extracted by the shared
@@ -91,7 +91,7 @@ export interface SessionRuleSource {
  * the turn-boundary read-visibility query reuses one synthetic id for every path it screens and for every
  * turn of the run. The entry is taken ONCE, and a claimed snapshot is served only while its `rev` still
  * stands at the enforced floor; a claim from a later adjudication, whose floor has moved on, falls through
- * to a fresh read. A real tool call's id is minted per call and never repeats.
+ * to a fresh read. A real call's id is the provider's: unique within one assistant response only (`brain/tool-call-id.ts`).
  */
 export declare function createLiveSessionRules(store: SessionPolicyStore, floor: {
     sessionId: string;
@@ -112,8 +112,8 @@ export declare function createLiveSessionRules(store: SessionPolicyStore, floor:
  *  - `toolAllow` (if set) → deny any call no entry admits (the matcher's allow reading in the `narrowing` posture: every
  *    segment of a command line named by an entry; never the allow layer's auto-mode strip), naming the uncovered segment.
  *  - an entry that reads as nothing → in no row (it guards and grants nothing; the prepare-time audit names it, or
- *    `onEarlierGrammar`, once per distinct set, when its snapshot's own earlier grammar reads it so).
- *  - a snapshot the shape reading refuses → deny every call, saying what it holds (never its text).
+ *    `onEarlierGrammar(entries, bucket, grammar)`, once per distinct set, when its snapshot's own earlier grammar reads it so).
+ *  - a snapshot that cannot be read (its shape; a `toolDeny` entry no grammar reads) → deny every call, never quoting it.
  *  - `allowDirs` (if set) → a WRITE tool must land inside one of the dirs (resolved via `canonicalizeTarget`,
  *    so a symlink can't carry across a write out); a write-capable tool that cannot be path-confined (e.g. `bash`)
  *    is DENIED while `allowDirs` is set (fail-closed).
@@ -132,5 +132,5 @@ export declare function createSessionRulePolicy(rules: SessionPermissionRules |
     rootPath?: string;
     toolEffects?: ReadonlyMap<string, ToolEffect>;
     anchors?: PathRuleBases;
-    onEarlierGrammar?: (entries: readonly string[]) => void;
+    onEarlierGrammar?: (entries: readonly string[], field: SessionRuleEntryField, grammar: number) => void;
 }): NamedToolPolicy;

package/dist/core/runner/session-rule-policy.js

@@ -1,5 +1,5 @@
 import { canonicalizeTarget, isWinFormPath, pathFamilyOf, writeTargetPath } from "../../tools/fs/safety.js";
-import { compileSessionRuleBucket, continuesLineage, earlierGrammarAnnouncer, readSessionRulesShape } from "../session-policy-store.js";
+import { SESSION_RULES_GRAMMAR, compileSessionRuleBucket, continuesLineage, earlierGrammarAnnouncer, earlierGrammarRefusalClause, readSessionRulesShape, unreadableDenyEntries } from "../session-policy-store.js";
 import { compiledEntryName, judgeAllowEntries, uncoveredCommandSegment } from "../allow-entry.js";
 import { inlineUntrusted } from "../untrusted-text.js";
 import { callTargetReadingOf, pathTargetBaseOf, readCallTarget } from "../effective-path-target.js";
@@ -104,27 +104,30 @@ export function createLiveSessionRules(store, floor, hooks) {
         return p;
     };
 }
-function compileSessionRules(rules, announceEarlier) {
+function compileSessionRules(rules) {
     const shaped = readSessionRulesShape(rules);
+    const refuseEvery = (what) => `the session rules cannot be read as rules (they hold ${what}) — every call is refused until they are rewritten`;
     if ("fault" in shaped) {
         const { field, got } = shaped.fault;
         const what = got === "not a rule bucket" ? "a key that is no rule bucket" : field === "" ? `a value that is ${got}, not an object of rule buckets` : `${field} holding ${got}`;
-        return { deny: [], allow: undefined, allowDirs: undefined, pathRows: false, names: { deny: [], allow: [] }, unreadable: `the session rules cannot be read as rules (they hold ${what}) — every call is refused until they are rewritten` };
+        return { deny: [], allow: undefined, earlier: { grammar: SESSION_RULES_GRAMMAR, toolAllow: [], toolDeny: [] }, allowDirs: undefined, pathRows: false, names: { deny: [], allow: [] }, unreadable: refuseEvery(what) };
     }
-    const { toolAllow, allowDirs } = shaped.rules;
+    const { toolAllow, allowDirs, grammar } = shaped.rules;
+    const unreadDeny = unreadableDenyEntries(shaped.rules).length;
     const denyList = compileSessionRuleBucket(shaped.rules, "toolDeny");
     const allowList = toolAllow === undefined ? undefined : compileSessionRuleBucket(shaped.rules, "toolAllow");
     const rowsOf = (behavior, list) => list.rows.map((r) => ({ behavior, entry: r.entry, compiled: r.compiled }));
     const deny = rowsOf("deny", denyList);
     const allow = allowList === undefined ? undefined : rowsOf("allow", allowList);
     const named = (list, earlier) => (list?.inert ?? []).filter((i) => (i.reason === "earlier_grammar") === earlier).map((i) => i.entry);
-    announceEarlier(named(allowList, true));
     return {
         deny,
         allow,
+        earlier: { grammar, toolAllow: named(allowList, true), toolDeny: named(denyList, true) },
         allowDirs: allowDirs !== undefined && allowDirs.length > 0 ? allowDirs : undefined,
         pathRows: [...deny, ...(allow ?? [])].some((r) => r.compiled.kind === "path"),
         names: { deny: [...deny.map((r) => compiledEntryName(r.compiled)), ...named(denyList, false)], allow: [...(allow ?? []).map((r) => compiledEntryName(r.compiled)), ...named(allowList, false)] },
+        ...(unreadDeny > 0 ? { unreadable: refuseEvery(`${unreadDeny === 1 ? "a toolDeny entry" : `${unreadDeny} toolDeny entries`} that rule grammar ${SESSION_RULES_GRAMMAR} reads as no rule`) } : {}),
     };
 }
 export function createSessionRulePolicy(rules, opts) {
@@ -138,7 +141,9 @@ export function createSessionRulePolicy(rules, opts) {
     let compiled;
     const compile = (r) => {
         if (compiled === undefined || compiledFor !== r) {
-            compiled = compileSessionRules(r, announceEarlier);
+            compiled = compileSessionRules(r);
+            for (const field of ["toolAllow", "toolDeny"])
+                announceEarlier(compiled.earlier[field], field, compiled.earlier.grammar);
             compiledFor = r;
         }
         return compiled;
@@ -147,7 +152,7 @@ export function createSessionRulePolicy(rules, opts) {
     return {
         nameSets: [{ ...(seedNames.deny.length > 0 ? { deny: seedNames.deny } : {}), ...(seedNames.allow.length > 0 ? { allow: seedNames.allow } : {}) }],
         async check(req, signal) {
-            const { deny: denyRows, allow: allowRows, allowDirs, unreadable, pathRows } = compile(await readRules(req.toolCallId, signal));
+            const { deny: denyRows, allow: allowRows, earlier, allowDirs, unreadable, pathRows } = compile(await readRules(req.toolCallId, signal));
             if (unreadable !== undefined)
                 return deny(req.toolName, unreadable);
             if (denyRows.length > 0 || allowRows !== undefined) {
@@ -159,7 +164,7 @@ export function createSessionRulePolicy(rules, opts) {
                     return deny(req.toolName);
                 if (allowRows !== undefined && judgeAllowEntries(allowRows, call, "allow", judged, "narrowing") === undefined) {
                     const segment = uncoveredCommandSegment(allowRows, call, judged, "narrowing");
-                    return deny(req.toolName, segment === undefined ? "it is not in the session-rule allowlist" : `it is not in the session-rule allowlist (no entry covers ${JSON.stringify(inlineUntrusted(segment, 200))})`);
+                    return deny(req.toolName, `it is not in the session-rule allowlist${segment === undefined ? "" : ` (no entry covers ${JSON.stringify(inlineUntrusted(segment, 200))})`}${earlierGrammarRefusalClause(earlier.toolAllow, earlier.grammar)}`);
                 }
             }
             if (allowDirs) {