@sema-agent/core 7.29.0 → 7.30.0

package/dist/core/runner/prepare-wiring-manifest.js

@@ -1,4 +1,5 @@
 import { bindPeerLaneDrain } from "../../agents/peer-session-drain.js";
+import { teamRoleOf } from "../../agents/team-role.js";
 import { resolveCheckpointStore } from "../checkpoint-store.js";
 import { createHookEnvCapabilities, mintHookInvocationIdentity } from "../hooks.js";
 import { wiredHookEntries } from "../hook-seats.js";
@@ -115,7 +116,7 @@ function announceDurableGateUnavailable(args) {
     });
 }
 export function prepareWiringManifest(input) {
-    const { spec, deps, internals, resume, sessionId, runId, hostTaskId, taskScope, hooks, preToolUseObservational, policyLayers, effectivePolicy, handsEnabled, taskRootFinal, mcp, irreversibleTools, egressTools, toolEffects, ownedEnv, executionEnv, offloadStore, onceLedger, usageWindows, envLifetimeSuspendAt, runtimeCaps, resolvedInteractionPosture, durableQuestionFace, liveQuestionFace, checkpointStore, sessions, modelGateManifest, autoModeArmReason, lockedPreflight, peerLaneRefs, sessionBox, harness, pausedRef, frozenOnAsk, liveInheritedGate, delegation, toolRoster, readDenyBuiltinTiersActive, lspManagerWired, shellReadStationArmed, lspDiagnosticsLive } = input;
+    const { spec, deps, internals, resume, sessionId, runId, hostTaskId, taskScope, hooks, preToolUseObservational, policyLayers, effectivePolicy, handsEnabled, taskRootFinal, mcp, irreversibleTools, egressTools, toolEffects, ownedEnv, executionEnv, offloadStore, onceLedger, usageWindows, envLifetimeSuspendAt, runtimeCaps, resolvedInteractionPosture, durableQuestionFace, liveQuestionFace, checkpointStore, sessions, modelGateManifest, autoModeArmReason, lockedPreflight, peerLaneRefs, frameSettlement, sessionBox, harness, pausedRef, frozenOnAsk, liveInheritedGate, delegation, toolRoster, readDenyBuiltinTiersActive, lspManagerWired, shellReadStationArmed, lspDiagnosticsLive } = input;
     const onAsk = spec.onAsk ?? deps.onAsk;
     const handWriteTools = toolRoster.entries.filter((e) => e.mountedBy === "hands" && (e.effect === "write" || e.effect === "idempotent")).map((e) => e.name);
     const hasEffectAwareGate = Boolean(policyLayers.length > 0 || (hooks?.preToolUse !== undefined && !preToolUseObservational));
@@ -179,6 +180,8 @@ export function prepareWiringManifest(input) {
     const wiringManifest = deriveWiringManifest({
         half: "effective",
         leg: resume !== undefined ? "resume" : internals?.isDelegatedChild === true ? "child" : "root",
+        teamRole: teamRoleOf({ isDelegatedChild: delegation.isDelegatedChild, ...(internals?.explicitAgentName !== undefined ? { spawnName: internals.explicitAgentName } : {}) }),
+        ...(spec.peerPresence !== undefined ? { peerPresence: spec.peerPresence } : {}),
         askForm: wiringAskSeam.form,
         ...(wiringAskSeam.provenance !== undefined ? { askProvenance: wiringAskSeam.provenance } : {}),
         questionWired: wiringQuestionSeam.wired,
@@ -227,9 +230,11 @@ export function prepareWiringManifest(input) {
             inject: internals.onTaskNotification,
             ownTokens: () => internals?.peerSelfRef?.current.ownTokens ?? [],
             refs: peerLaneRefs,
+            settlement: frameSettlement,
             selfName: () => internals?.explicitAgentName,
             parked: () => pausedRef.current !== undefined,
         });
+        frameSettlement.boxBacked = (payload) => peerLaneRefs.isBoxBacked?.(payload) ?? false;
     }
     const parkLaneArmed = wiringManifest.parkLane.effective === true;
     const gateMachineryActive = effectivePolicy !== undefined ||

package/dist/core/runner/retired-runner-deps.d.ts

@@ -1,3 +1,5 @@
 import type { RunnerDeps } from "../types.js";
-/** Runs in the pre-first-await config-doors phase, before any resource-bearing preparation, and pre-CAS on a resume. */
+/** Runs on the caller's own argument at `new Runner` (the only point that still sees an inherited or
+ *  non-enumerable seat — construction spreads deps into plain objects), and again in the pre-first-await
+ *  config-doors phase and pre-CAS on a resume. */
 export declare function assertNoRetiredRunnerDeps(deps: RunnerDeps): void;

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

@@ -1,6 +1,7 @@
 import { assertNoRetiredKeys } from "../retired-keys.js";
 const RETIRED_RUNNER_DEPS_KEYS = {
     legacyRewindBoundaryProbe: "the rewind refusal always names both possibilities (never existed / retired whole-tree era); a deployment that holds that era's table answers the question on its own surface",
+    peerAdmission: "the peer lane's knob table is `RunnerDeps.peerLane` (the same fields: admission gate, delivery budgets, listing window)",
 };
 export function assertNoRetiredRunnerDeps(deps) {
     assertNoRetiredKeys(deps, RETIRED_RUNNER_DEPS_KEYS, "RunnerDeps");

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

@@ -23,8 +23,10 @@ export interface RunCompactionMachineryInput {
 export interface RunCompactionMachineryResult {
     /** The accounted compaction brain — `complete` always provided, usage recorded inline. */
     compactionBrain: Brain;
-    /** Whether ROUTINE turn-boundary compaction runs for this task. */
-    withinTaskCompaction: boolean;
+    /** Whether ROUTINE turn-boundary compaction runs for this task, asked AT THE BOUNDARY. The request's own
+     *  `compaction` is fixed for the leg, but the deployment's per-model overlay is a live seat — an operator
+     *  who turns routine compaction off for a model reaches the legs already on it. */
+    withinTaskCompaction: () => boolean;
     /** §17.4: the consecutive-failure circuit breaker shared by every compaction lane of the run. */
     compactionBreaker: {
         failures: number;

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

@@ -1,5 +1,6 @@
 import { DEFAULT_COMPACTION_SETTINGS } from "../../internal/harness.js";
 import { resolveTriggerWindow } from "../context-edit.js";
+import { compactionEnabled, contextOverlayFor } from "../context-settings.js";
 import { sanitizeCompactionSettings } from "../auto-compaction.js";
 import { isModelPriced, modelCostToPricing } from "../pricing.js";
 import { emitTrace } from "../trace.js";
@@ -45,10 +46,11 @@ export function runCompactionMachinery(input) {
             return msg;
         },
     };
-    const withinTaskCompaction = (spec.compaction?.enabled ?? true) && (spec.compaction?.withinTask ?? true);
+    const legOverlay = () => contextOverlayFor(runner.deps.contextSettings, prepared.harness.getModelRef(), runner.deps);
+    const withinTaskCompaction = () => compactionEnabled(spec.compaction?.enabled, legOverlay()) && (spec.compaction?.withinTask ?? true);
     const compactionBreaker = { failures: 0 };
-    if (spec.compaction?.enabled ?? true) {
-        const prefixWindow = resolveTriggerWindow(prepared.model).window;
+    if (compactionEnabled(spec.compaction?.enabled, legOverlay())) {
+        const prefixWindow = resolveTriggerWindow(prepared.model, legOverlay()).window;
         if (Number.isFinite(prefixWindow) && prefixWindow > 0) {
             const prefixSettings = sanitizeCompactionSettings({ ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction }, prefixWindow);
             const prefixCompactAt = prefixWindow - prefixSettings.reserveTokens;

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

@@ -343,7 +343,7 @@ export function createHarnessHandlers(input) {
                 rs.degrade.degradeToModel &&
                 rs.budget.maxCostMicroUsd !== undefined &&
                 stats.costMicroUsd >= spec.limits.degrade.atCostFraction * rs.budget.maxCostMicroUsd) {
-                void prepared.harness.setModel(rs.degrade.degradeToModel);
+                void prepared.harness.setModel(rs.degrade.degradeToModel, spec.limits.degrade.to);
                 rs.degrade.recordDegraded({ from: prepared.model.id, to: rs.degrade.degradeToModel.id, reason: "budget", atTurn: stats.turns }, rs.degrade.degradeToModel);
             }
             const overAxis = rs.limits.budgetHit ? undefined : rs.budget.overBudget();

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

@@ -1,5 +1,6 @@
 import { uuidv7 } from "../../internal/harness.js";
 import { createSafeNotifier, observeThenableRejection } from "../safe-notify.js";
+import { recordFrameReceipt, toolResultReceiptKey } from "../frame-settlement.js";
 import { discloseDroppedPending, renderTaskNotificationXml, taskNotificationDedupKey } from "../task-notification.js";
 import { deliverDelegationLifecycle, deliverEngineNotice, undrainedUserInputNotices } from "../types.js";
 export function runIdentityWiring(input) {
@@ -42,8 +43,12 @@ export function runIdentityWiring(input) {
     prepared.harness.onUndrainedEngineNotes = (payloads) => {
         if (notificationLane.sessionId === undefined)
             return;
-        for (const p of payloads)
+        const boxBacked = prepared.frameSettlement.boxBacked;
+        for (const p of payloads) {
+            if (boxBacked !== undefined && boxBacked(p))
+                continue;
             pendingSessionNotifications.pend(notificationLane.sessionId, p);
+        }
     };
     prepared.harness.engineInjectionsHeld = () => prepared.batchHaltRef.current !== undefined;
     let undrainedUserAtEnd;
@@ -66,6 +71,19 @@ export function runIdentityWiring(input) {
         if (notificationLane.sessionId !== undefined && typeof payload?.task_id === "string" && typeof payload.status === "string")
             pendingSessionNotifications.markDelivered(notificationLane.sessionId, taskNotificationDedupKey(payload));
     };
+    prepared.harness.onFrameCommitted = (carrier, entryId) => {
+        const seam = prepared.frameSettlement;
+        if (seam.awaiting.size === 0)
+            return;
+        const key = carrier.kind === "tool_result"
+            ? toolResultReceiptKey(carrier.toolCallId)
+            : (() => {
+                const payload = carrier.payload;
+                return typeof payload?.task_id === "string" && typeof payload.status === "string" ? taskNotificationDedupKey(payload) : undefined;
+            })();
+        if (key !== undefined)
+            recordFrameReceipt(seam, key, carrier.kind === "tool_result" ? carrier.content : undefined, entryId);
+    };
     if (notifyRef)
         notifyRef.inject = injectTaskNotification;
     if (captureOptOutRef && prepared.memoryEngineSession?.captureOptOut !== undefined) {

package/dist/core/runner/run-leg.js

@@ -107,7 +107,7 @@ export async function runLeg(input) {
                 rs.limits.budgetAxis = "cost";
             }
             else {
-                let continuation = resumeContinuation(resume, prepared.reminderMark);
+                let continuation = resumeContinuation(resume, prepared.reminderMark, prepared.fullShellReachable);
                 const bgSnapshot = resume.cp.state.runningBackgroundTasks;
                 let orphanTasks = [];
                 if (bgSnapshot !== undefined && bgSnapshot.length > 0) {

package/dist/core/runner/run-notification-lane.js

@@ -1,9 +1,13 @@
 import { createPeerInboundChainRef, createPeerSelfRef } from "../../agents/peer-admission.js";
 import { boundInputHashOf } from "../canonical-json.js";
-import { createLiveNotificationLane, isDelegatedAgentTerminal, isTerminalTaskNotification, renderTaskNotificationXml, routeOrParkNotification, SystemInjectionQueue } from "../task-notification.js";
+import { createLiveNotificationLane, DurableAppendObligations, isDelegatedAgentTerminal, isTerminalTaskNotification, renderTaskNotificationXml, routeOrParkNotification, SystemInjectionQueue, taskNotificationDedupKey } from "../task-notification.js";
 import { ToolDetachHub } from "../tool-detach.js";
 import { pendingContentAskCallId } from "./decide-continuation.js";
-export async function runNotificationLane(input) {
+export function runNotificationLane(input) {
+    const obligations = new DurableAppendObligations();
+    return obligations.run(() => runNotificationLaneAs(input, obligations));
+}
+async function runNotificationLaneAs(input, obligations) {
     const { spec, queue, resume, internals, taskIdRef, runner, self, sessions, sessionReadStates, pendingSessionNotifications, prepareTask, next } = input;
     const prepareResume = resume
         ? {
@@ -68,6 +72,7 @@ export async function runNotificationLane(input) {
             const noteOptions = {
                 provenance: "engine-note",
                 enginePayload: item.payload,
+                engineNoteKey: taskNotificationDedupKey(item.payload),
                 ...(item.payload.task_type !== "external" && isTerminalTaskNotification(item.payload) ? { capPreferred: true } : {}),
             };
             const deliver = item.priority === "later"
@@ -153,5 +158,6 @@ export async function runNotificationLane(input) {
     finally {
         if (notificationSessionId !== undefined)
             pendingSessionNotifications.liveLanes.unregister(notificationSessionId, takeAsDestination);
+        await obligations.settle();
     }
 }

package/dist/core/runner/run-recovery-lanes.js

@@ -1,11 +1,12 @@
-import { DEFAULT_COMPACTION_SETTINGS } from "../../internal/harness.js";
+import { compactionKindOf } from "../task-notification.js";
 import { planRejectionClears } from "../context-edit.js";
 import { landStaleResultClears } from "./prepare-context-lane.js";
 import { DEFAULT_COMPACTION_INSTRUCTIONS, maybeCompact, mintCompactedEvent } from "../auto-compaction.js";
 import { emitTrace } from "../trace.js";
 import { isDegenerateCutMessage } from "../../brain/terminal-cause.js";
 import { rebaseCadenceWindows } from "./turn-attachments.js";
-import { buildWorkingFileAttachments, centerAdoptionOption, contextInstructionFilesOption, emitInputTruncated, forkContextOption } from "./compaction-call-options.js";
+import { buildWorkingFileAttachments, centerAdoptionOption, contextInstructionFilesOption, emitInputTruncated, forkContextOption, legCompactionSettings, legContextOverlayOption } from "./compaction-call-options.js";
+import { compactionEnabled } from "../context-settings.js";
 import { compactionRestateOptions } from "./compaction-restate.js";
 import { COMPACTION_FREED_EPSILON, COMPACTION_REGROWTH_FACTOR, MAX_CONSECUTIVE_COMPACTION_FAILURES } from "./compaction-knobs.js";
 import { compactionHookOptions, recordCompactionReuse, seamCCompactionOptions } from "./compaction-seams.js";
@@ -13,7 +14,7 @@ import { asThrownError, thrownText } from "../thrown-value.js";
 export function runRecoveryLanes(input) {
     const { spec, prepared, queue, rs, ident, compactionBrain, compactionBreaker, windowSafetyOptions, runner } = input;
     const runForcedCompactionPass = async (lane, turnSignal) => {
-        if (!(spec.compaction?.enabled ?? true))
+        if (!compactionEnabled(spec.compaction?.enabled, legContextOverlayOption(prepared, runner).contextOverlay))
             return false;
         if (compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES)
             return false;
@@ -24,12 +25,13 @@ export function runRecoveryLanes(input) {
                 epochDeclaredSections: prepared.epochDeclaredSections,
                 ...centerAdoptionOption(prepared),
                 model: prepared.harness.getModel(),
+                ...legContextOverlayOption(prepared, runner),
                 compactionModel: prepared.compModel,
                 ...forkContextOption(prepared, true),
                 brain: compactionBrain,
                 getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
                 thinking: prepared.thinking,
-                settings: { ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction },
+                settings: legCompactionSettings(spec, legContextOverlayOption(prepared, runner).contextOverlay),
                 customInstructions: spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
                 signal: passSignal,
                 minTokens: 0,
@@ -52,6 +54,8 @@ export function runRecoveryLanes(input) {
                     rs.counters.compactionFloor = Math.ceil(comp.postTriggerTokens * COMPACTION_REGROWTH_FACTOR);
                 }
                 queue.push(mintCompactedEvent(comp, "forced", ident()));
+                rs.counters.compactionPasses += 1;
+                rs.counters.compactionKind = compactionKindOf("forced");
                 if (comp.phaseDurations !== undefined && comp.durationMs !== undefined) {
                     const pd = comp.phaseDurations;
                     const pdDur = comp.durationMs;
@@ -112,7 +116,7 @@ export function runRecoveryLanes(input) {
                     return false;
                 if (prepared.microCompact.clearOnRejection && attempt === 1) {
                     const proj = prepared.microCompact.projectionRef.current;
-                    const compactionAvailable = (spec.compaction?.enabled ?? true) && compactionBreaker.failures < MAX_CONSECUTIVE_COMPACTION_FAILURES;
+                    const compactionAvailable = compactionEnabled(spec.compaction?.enabled, legContextOverlayOption(prepared, runner).contextOverlay) && compactionBreaker.failures < MAX_CONSECUTIVE_COMPACTION_FAILURES;
                     const declineArm = compactionAvailable ? "forced_compaction" : "none";
                     const plan = proj === undefined
                         ? { declined: "no_candidates" }

package/dist/core/runner/run-settle-and-teardown.d.ts

@@ -1,24 +1,3 @@
-/**
- * The run body's SETTLE AND TEARDOWN (R15), verbatim from `Runner.runLocked`: the end-of-task
- * compaction's frames and detector reset, the nested-stats fold, the prefix-cache observability and its loud
- * mismatch / low-hit disclosures, the cross-slice cumulative spend fold, the human-review and mechanism counters,
- * the result assembly (`assembleResult` — the one place the leg's facts become a TaskResult), the resume leg's
- * unstarted-action reopen compensation, the read-state seal and the settle-time workspace-state write, the
- * StopFailure observer, the delegation-lifecycle terminal, the reap-stash for a committed pause, the resumed-terminal
- * unpin, the memory harvest, the `task.end` trace, `setResult`, the sub-agent's terminal tick, the mooted manual
- * compaction, the forwarded-frame drain and the queue's `done` + close, the file-history boundary settle and the
- * prompt-suggestion kickoff — then, in its finally, the four teardown legs in the order they were: the shell-lane
- * children settle, the background-shell sweep, the registry clears / the background-agent abort / the retained
- * child sessions, and the owned env's teardown. The suggestion pass (`suggestNextPrompts`, with its four bounds) and the
- * owned-env teardown (`teardownOwnedEnv`) are the lane's own module-private functions since S7, verbatim from
- * the Runner's private methods: each has this one caller, and a sibling file would be a lane-to-lane reach (the S6 legs' reading).
- *
- * Async (eleven first-level awaits, all of them the same awaits at the same positions). The `queue.push("done")` and
- * the teardown legs' order are contract (the forwarded-frame drain lands before `done`; the env is torn down after
- * every reader of it); nothing here reorders them. Products: the result is PUBLISHED through `setResult` and the
- * effects are installed on the borrowed seats — nothing comes back to the driver (the same empty Result the seat
- * lanes whose products are all installations carry).
- */
 import type { AssistantMessage } from "../../internal/llm.js";
 import type { ResolvedReasoning } from "../../brain/reasoning.js";
 import type { PushQueue } from "../push-queue.js";
@@ -27,7 +6,7 @@ import { type CompactOutcome, type DelegationLifecycleEvent, type OwedUserInputA
 import { type Stats } from "./assemble-result.js";
 import type { EndOfTaskCompaction, InstallingPhaseResult, ManualCompactRef, Prepared, ResumeRun, RunInternals, RunnerDepsSeat, RunState, SuspendReap, TaskIdRef } from "./contracts.js";
 export interface RunSettleAndTeardownInput {
-    /** borrowed-readonly — the task spec: the hooks slot, the suggestion opt-in, the retain / forward flags, the task id and principal. */
+    /** borrowed-readonly — the task spec: the hooks slot, the suggestion opt-in, the retain / forward flags, the task id. */
     spec: TaskSpec;
     /** borrowed-mutable — the run's event queue: the compaction / human-input / task_progress / done frames, then CLOSED here. */
     queue: PushQueue<TaskEvent>;
@@ -94,6 +73,9 @@ export interface RunSettleAndTeardownInput {
     };
     /** borrowed-readonly — the end-of-task compaction's outcome (the terminal-adoption lane's `finish` call). */
     comp: EndOfTaskCompaction;
+    /** borrowed-readonly — the run's compaction breaker: the ONE source of `TaskResult.compaction.breakerOpen`. */ compactionBreaker: {
+        readonly failures: number;
+    };
     /** borrowed-readonly — the adoption lane's unsettled undrained-input account, closed below (after the reopen). */
     owedUserInput: OwedUserInputAccount;
     /** borrowed-readonly — the stream's result setter: the assembled TaskResult is published through it exactly once. */

package/dist/core/runner/run-settle-and-teardown.js

@@ -1,3 +1,4 @@
+import { MAX_CONSECUTIVE_COMPACTION_FAILURES } from "./compaction-knobs.js";
 import { isSyntheticApiErrorMessage } from "../../internal/harness.js";
 import { adjudicateDerivedRoute, fallbackToPrimaryNotice, sameRouteIdentity } from "../../brain/route-adjudicator.js";
 import { isDegenerateCutMessage } from "../../brain/terminal-cause.js";
@@ -23,7 +24,7 @@ import { amendTerminal, terminalProjection } from "./terminal-projection.js";
 import { mintCompactedEvent } from "../auto-compaction.js";
 import { asThrownError } from "../thrown-value.js";
 export async function runSettleAndTeardown(input) {
-    const { spec, queue, prepared, resume, internals, rs, stats, ident, parentToolCallId, subagentName, loopLatch, timeout, ownCommittedTailRef, emitDelegationLifecycle, taskIdRef, manualCompactRef, drainManualCompact, final, threw, abortedLive, userInterruptedLive, answerSettled, strandedHumanAnswers, reasoningResolution, comp, owedUserInput, setResult, onSuggestions, onSuspend, runner, sessions } = input;
+    const { spec, queue, prepared, resume, internals, rs, stats, ident, parentToolCallId, subagentName, loopLatch, timeout, ownCommittedTailRef, emitDelegationLifecycle, taskIdRef, manualCompactRef, drainManualCompact, final, threw, abortedLive, userInterruptedLive, answerSettled, strandedHumanAnswers, reasoningResolution, comp, compactionBreaker, owedUserInput, setResult, onSuggestions, onSuspend, runner, sessions } = input;
     try {
         if (comp?.compacted) {
             queue.push(mintCompactedEvent(comp, "auto", ident()));
@@ -100,6 +101,7 @@ export async function runSettleAndTeardown(input) {
             effectiveReadDenyPatterns: prepared.effectiveReadDenyPatterns,
             effectiveMemoryScopes: prepared.effectiveMemoryScopes,
             effectiveReasoning: reasoningResolution.current,
+            ...(rs.counters.compactionPasses > 0 || compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES ? { compaction: { passes: rs.counters.compactionPasses, breakerOpen: compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES, ...(rs.counters.compactionKind !== undefined ? { kind: rs.counters.compactionKind } : {}) } } : {}),
             retryAfterMs: rs.limits.platformTerminal?.retryAfterMs,
             abortedForTimeout: timeout.fired,
             abortedForTurns: rs.limits.turnsExceeded,
@@ -295,7 +297,7 @@ export async function runSettleAndTeardown(input) {
             hasDestroy(prepared.ownedEnv) &&
             isIsolated(prepared.ownedEnv) &&
             prepared.pausedRef.current === undefined;
-        await settleTeardownLeg(() => defaultTaskRegistry.settleKilledForOwner({ owner: spec.taskId ?? prepared.sessionId, scope: spec.principal ?? "default", sessionId: prepared.sessionId }, {
+        await settleTeardownLeg(() => defaultTaskRegistry.settleKilledForOwner({ ...prepared.registryAccess, sessionId: prepared.sessionId }, {
             source: abortedLive &&
                 !answerSettled &&
                 !timeout.fired &&
@@ -325,14 +327,8 @@ export async function runSettleAndTeardown(input) {
                 runner.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId });
             }
         }
-        defaultTaskRegistry.clearBackgroundForOwner({
-            owner: spec.taskId ?? prepared.sessionId,
-            scope: spec.principal ?? "default",
-        });
-        defaultTaskRegistry.abortBackgroundAgentsForOwner({
-            owner: spec.taskId ?? prepared.sessionId,
-            scope: spec.principal ?? "default",
-        }, { skipSessionScoped: true });
+        defaultTaskRegistry.clearBackgroundForOwner(prepared.registryAccess);
+        defaultTaskRegistry.abortBackgroundAgentsForOwner(prepared.registryAccess, { skipSessionScoped: true });
         if (prepared.subagentRetain) {
             await settleTeardownLeg(() => prepared.subagentRetain.disposeAll(), "subagentRetain.disposeAll", (e) => runner.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
         }

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

@@ -108,6 +108,7 @@ export function runStopAndFinalVerify(input) {
                     stopHookActive: consecutiveBlocks > 0,
                     consecutiveBlocks,
                     getBranch: () => prepared.session.getBranch(),
+                    backgroundTasks: () => prepared.listBackgroundTasks(),
                     identity: prepared.hookIdentity,
                     signal: sig,
                 }));

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

@@ -1,11 +1,10 @@
 import { DEFAULT_COMPACTION_INSTRUCTIONS, maybeCompact } from "../auto-compaction.js";
-import { DEFAULT_COMPACTION_SETTINGS } from "../../internal/harness.js";
 import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
 import { appendInterruptionMarker, reconcileInterruptedSession } from "../session-reconcile.js";
 import { emitTrace } from "../trace.js";
 import { answerSettled, errorCodeOf } from "./assemble-result.js";
 import { awaitChargeWithSlowDisclosure, discloseUnevaluableWindow } from "./clock-and-limits.js";
-import { buildWorkingFileAttachments, centerAdoptionOption, contextInstructionFilesOption, emitInputTruncated, forkContextOption } from "./compaction-call-options.js";
+import { buildWorkingFileAttachments, centerAdoptionOption, contextInstructionFilesOption, emitInputTruncated, forkContextOption, legCompactionSettings, legContextOverlayOption } from "./compaction-call-options.js";
 import { compactionHookOptions, recordCompactionReuse, seamCCompactionOptions } from "./compaction-seams.js";
 import { compactionRestateOptions } from "./compaction-restate.js";
 import { MAX_CONSECUTIVE_COMPACTION_FAILURES } from "./compaction-knobs.js";
@@ -118,7 +117,7 @@ export async function runTerminalAdoption(input) {
         skipCompaction: durablyPaused || (abortedLive && settled) || compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES,
         minTokens: rs.counters.compactionFloor,
         brain: compactionBrain,
-        windowSafety: windowSafetyOptions(prepared.model),
+        windowSafety: windowSafetyOptions(prepared.harness.getModel()),
         onCompactionFailed: (reason) => queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "auto", reason, ...ident() }),
         cancelled: abortedLive,
     }, runner, sessions);
@@ -132,13 +131,14 @@ async function finish(spec, prepared, opts, runner, sessions) {
                 session: prepared.session,
                 epochDeclaredSections: prepared.epochDeclaredSections,
                 ...centerAdoptionOption(prepared),
-                model: prepared.model,
+                model: prepared.harness.getModel(),
+                ...legContextOverlayOption(prepared, runner),
                 compactionModel: prepared.compModel,
                 ...forkContextOption(prepared, false),
                 brain: opts?.brain ?? runner.deps.brain,
                 getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
                 thinking: prepared.thinking,
-                settings: { ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction },
+                settings: legCompactionSettings(spec, legContextOverlayOption(prepared, runner).contextOverlay),
                 customInstructions: spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
                 minTokens: opts?.minTokens,
                 overheadTokens: prepared.promptOverheadTokens,

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

@@ -1,12 +1,12 @@
+import { compactionKindOf } from "../task-notification.js";
 import { mintSystemReminder } from "../reminder-mint.js";
-import { DEFAULT_COMPACTION_SETTINGS } from "../../internal/harness.js";
 import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
 import { 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 } from "./compaction-call-options.js";
+import { buildWorkingFileAttachments, centerAdoptionOption, contextInstructionFilesOption, emitInputTruncated, forkContextOption, legCompactionSettings, legContextOverlayOption } from "./compaction-call-options.js";
 import { hookSeatExpiredError, runHookSeat } from "../hooks.js";
 import { sanitizeUntrustedText, SHELLED_BODY_ENVELOPE_TAGS } from "../untrusted-text.js";
 import { droppedToolDigest, withAnnounceDigests } from "./announce-once-ledger.js";
@@ -24,7 +24,8 @@ 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;
     let finalVerifySeenAtLastBoundary = 0;
-    const onTurnBoundary = async (event) => {
+    let legContinues = true;
+    const boundaryPass = async (event) => {
         let boundarySteered = false;
         const noNextRequest = () => prepared.stopRequestedRef.current || deps.loopLatch.userHalted;
         const walltimeHit = walltimeMonotonicDeadline !== undefined && performance.now() >= walltimeMonotonicDeadline;
@@ -75,6 +76,7 @@ export function createTurnBoundary(input) {
                     rs.limits.platformTerminal = asThrownError(govErr);
                     void prepared.harness.abort();
                     prepared.abortController.abort();
+                    legContinues = false;
                     return undefined;
                 }
             }
@@ -89,6 +91,7 @@ export function createTurnBoundary(input) {
             if (committed) {
                 rs.limits.turnsExceeded = false;
                 rs.limits.budgetHit = undefined;
+                legContinues = false;
                 return undefined;
             }
             const terminal = platformLimitTerminal(platformCause, platformRetryAfterMs);
@@ -100,6 +103,7 @@ export function createTurnBoundary(input) {
             }
             void prepared.harness.abort();
             prepared.abortController.abort();
+            legContinues = false;
             return undefined;
         }
         if (prepared.suspendForResource &&
@@ -123,6 +127,7 @@ export function createTurnBoundary(input) {
                 void prepared.harness.abort();
                 prepared.abortController.abort();
             }
+            legContinues = false;
             return undefined;
         }
         if (walltimeMonotonicDeadline !== undefined &&
@@ -136,6 +141,7 @@ export function createTurnBoundary(input) {
                 void prepared.harness.abort();
                 prepared.abortController.abort();
             }
+            legContinues = false;
             return undefined;
         }
         const approachCfg = spec.limits?.approachNotice;
@@ -186,6 +192,7 @@ export function createTurnBoundary(input) {
                 prepared.pausedRef.current === undefined;
             if (honorable && prepared.suspendForReview) {
                 await prepared.suspendForReview(reason);
+                legContinues = !prepared.abortController.signal.aborted && prepared.pausedRef.current === undefined;
                 return undefined;
             }
             emitTrace(rs.telemetry.tracer, () => ({ kind: "review.dropped", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
@@ -496,7 +503,7 @@ export function createTurnBoundary(input) {
             });
         }
         const forceManual = manualCompactRef.requested;
-        if ((!withinTaskCompaction && !forceManual) ||
+        if ((!withinTaskCompaction() && !forceManual) ||
             prepared.abortController.signal.aborted ||
             prepared.pausedRef.current !== undefined) {
             if (forceManual) {
@@ -504,6 +511,7 @@ export function createTurnBoundary(input) {
                 queue.push({ type: "compaction_outcome", outcome: "mooted", trigger: "manual", reason: "task_ending", ...ident() });
                 drainManualCompact("mooted");
             }
+            legContinues = !prepared.abortController.signal.aborted && prepared.pausedRef.current === undefined;
             return undefined;
         }
         if (compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES) {
@@ -564,12 +572,13 @@ export function createTurnBoundary(input) {
                 epochDeclaredSections: prepared.epochDeclaredSections,
                 ...centerAdoptionOption(prepared),
                 model: event.model,
+                ...legContextOverlayOption(prepared, runner),
                 compactionModel: prepared.compModel,
                 ...forkContextOption(prepared, false),
                 brain: compactionBrain,
                 getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
                 thinking: prepared.thinking,
-                settings: { ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction },
+                settings: legCompactionSettings(spec, legContextOverlayOption(prepared, runner).contextOverlay),
                 customInstructions: manualInstructions ?? spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
                 signal: compactionPassSignal,
                 ...(manualCancelSignal !== undefined ? { manualCancelSignal } : {}),
@@ -644,6 +653,8 @@ export function createTurnBoundary(input) {
             recordCompactionReuse(runner, prepared, comp);
             if (comp.compacted) {
                 queue.push(mintCompactedEvent(comp, passTrigger, ident()));
+                rs.counters.compactionPasses += 1;
+                rs.counters.compactionKind = compactionKindOf(passTrigger);
                 if (!forceManual && recordCompactionAndCheckRapidRefill(rapidRefill, stats.turns)) {
                     compactionBreaker.failures = MAX_CONSECUTIVE_COMPACTION_FAILURES;
                     queue.push({ type: "compaction_outcome", outcome: "disabled", trigger: passTrigger, reason: "rapid_refill: compaction disabled for the rest of this task", ...ident() });
@@ -695,5 +706,21 @@ export function createTurnBoundary(input) {
             resolveClaimedWaiters(manualOutcome);
         return undefined;
     };
+    const onTurnBoundary = async (event) => {
+        legContinues = true;
+        try {
+            return await boundaryPass(event);
+        }
+        finally {
+            const round = prepared.peerBoundaryRound;
+            if (round !== undefined) {
+                try {
+                    await round({ continues: legContinues });
+                }
+                catch {
+                }
+            }
+        }
+    };
     return onTurnBoundary;
 }

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

@@ -4,7 +4,8 @@ import { type TaskOutcome } from "../task-outcome.js";
 import { type SwappableDeps } from "../swappable-deps.js";
 import { type SideQuerySpec, type SideQueryResult } from "../side-query.js";
 import type { SessionStore } from "../session.js";
-import type { AgentDefinition, ModelRoles, RunnerDeps, TaskEvent, TaskResult, TaskSpec, TaskStream } from "../types.js";
+import type { AgentDefinition, ModelRef, ModelRoles, RunnerDeps, TaskEvent, TaskResult, TaskSpec, TaskStream } from "../types.js";
+import { type ContextSettings, type ContextWindowOverlay } from "../context-settings.js";
 import type { ResumeRun, ResumeTaskConfig, RunInternals, RunnerSelfSeat } from "./contracts.js";
 export type { ResumeTaskConfig } from "./contracts.js";
 /**
@@ -77,6 +78,12 @@ export declare class Runner implements RunnerSelfSeat {
         models?: Record<string, Model>;
         roles?: ModelRoles;
     };
+    /** The deployment's per-model context-window overlay as declared ({@link RunnerDeps.contextSettings}); a fresh
+     *  read every call, the overlay objects frozen at their gate. */
+    get contextSettings(): ContextSettings | undefined;
+    /** The overlay a leg on `ref` reads RIGHT NOW — the one lookup ({@link contextOverlayFor}, tier aliases
+     *  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

package/dist/core/runner/runtask.js

@@ -21,6 +21,7 @@ import { PAUSE_REGISTRY } from "../pause-registry.js";
 import { toolPolicyNameSets } from "../tool-policy.js";
 import { PendingSessionNotifications } from "../task-notification.js";
 import { ToolDetachHub } from "../tool-detach.js";
+import { assertContextSettingsValue, assertContextSettingsWords, contextOverlayFor } from "../context-settings.js";
 import { createRunState } from "./initial-run-state.js";
 import { reconciledToolEndBody } from "./tool-end-body.js";
 import { answerFaceForRedeemedCall } from "./decide-continuation.js";
@@ -40,6 +41,7 @@ import { streamSteerVerb } from "./stream-steer-verb.js";
 import { streamLifecycleVerbs } from "./stream-lifecycle-verbs.js";
 import { streamHaltVerbs } from "./stream-halt-verbs.js";
 import { runNotificationLane } from "./run-notification-lane.js";
+import { assertNoRetiredRunnerDeps } from "./retired-runner-deps.js";
 import { runLeg } from "./run-leg.js";
 import { runTerminalAdoption } from "./run-terminal-adoption.js";
 import { runSettleAndTeardown } from "./run-settle-and-teardown.js";
@@ -69,12 +71,16 @@ export class Runner {
     static PARENT_CONSTRAINT_REGISTRY_CAP = 1024;
     depsSeat;
     constructor(deps) {
+        assertNoRetiredRunnerDeps(deps);
         const runner = this;
         this.depsSeat = { get deps() { return runner.deps; } };
         this.deps = deps;
         if (this.deps.tiers) {
             this.deps = { ...this.deps, models: expandTiers(this.deps.models, this.deps.tiers) };
         }
+        if (this.deps.contextSettings !== undefined) {
+            this.deps = { ...this.deps, contextSettings: assertContextSettingsWords(assertContextSettingsValue(this.deps.contextSettings, "RunnerDeps"), this.deps.models, "RunnerDeps") };
+        }
         if (this.deps.onError) {
             const rawOnError = this.deps.onError;
             const reportSinkFailure = (sinkErr, context) => {
@@ -121,6 +127,12 @@ export class Runner {
             ...(this.deps.models ? { models: { ...this.deps.models } } : {}), ...(this.deps.roles ? { roles: { ...this.deps.roles } } : {}),
         };
     }
+    get contextSettings() {
+        return this.deps.contextSettings;
+    }
+    contextOverlayOf(ref) {
+        return contextOverlayFor(this.deps.contextSettings, ref, this.deps);
+    }
     get gateBaseline() {
         const deps = this.deps;
         const h = deps.hooks;
@@ -232,6 +244,14 @@ export class Runner {
             else
                 delete writtenFaceSeats[seat];
         }
+        const priorContextSettings = this.deps.contextSettings;
+        if (seats.includes("contextSettings")) {
+            if (candidate.contextSettings !== undefined)
+                written.contextSettings = candidate.contextSettings;
+            else
+                delete written.contextSettings;
+        }
+        assertContextSettingsWords(written.contextSettings, written.models, "swapDeps");
         this.deps = written;
         if (catalogSwap) {
             const modelCount = Object.keys(candidate.models).length;
@@ -253,6 +273,17 @@ export class Runner {
                 });
             }
         }
+        if (seats.includes("contextSettings")) {
+            const to = candidate.contextSettings;
+            const words = to !== undefined ? Object.keys(to) : [];
+            deliverEngineNotice(this.deps.onNotice, {
+                code: "config.context_settings_swapped",
+                message: `deployment context-window settings swapped: ${words.length} model word(s) declared` +
+                    `${priorContextSettings !== undefined ? ` (was ${Object.keys(priorContextSettings).length})` : ""}` +
+                    "; unlike every other swappable seat this one is read LIVE — running legs measure their next boundary against the new windows, while their routing stays on the generation they prepared under",
+                detail: { words: words.slice(0, 8), declared: words.length, previousDeclared: priorContextSettings !== undefined ? Object.keys(priorContextSettings).length : 0, occurrenceId: uuidv7() },
+            });
+        }
         for (const seat of faceSeats) {
             const to = candidate[seat] ?? null;
             const from = priorFaces[seat] ?? null;
@@ -476,7 +507,7 @@ export class Runner {
                                 undrainedUserAtEnd, userInputLostAtEnd, final, threw, abortedLive, userInterruptedLive, runner: this.depsSeat, sessions: this.sessions,
                                 next: ({ threw, comp, answerSettled, owedUserInput }) => runSettleAndTeardown({
                                     spec, queue, prepared, resume, internals, rs, stats, ident, parentToolCallId, subagentName, loopLatch, timeout, ownCommittedTailRef,
-                                    emitDelegationLifecycle, taskIdRef, manualCompactRef, drainManualCompact, final, threw, abortedLive, userInterruptedLive, answerSettled, strandedHumanAnswers, reasoningResolution, comp, owedUserInput,
+                                    emitDelegationLifecycle, taskIdRef, manualCompactRef, drainManualCompact, final, threw, abortedLive, userInterruptedLive, answerSettled, strandedHumanAnswers, reasoningResolution, comp, compactionBreaker, owedUserInput,
                                     setResult, onSuggestions, onSuspend, runner: this.depsSeat, sessions: this.sessions,
                                 }),
                             }),