@sema-agent/core 7.28.1 → 7.30.0

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

@@ -47,7 +47,7 @@ import type { SystemInjectionPriority, TaskNotificationPayload } from "../task-n
 import type { OnAsk, PermissionResult, ResolvedAsk, ToolCallRequest, ToolPolicy } from "../tool-policy.js";
 import type { RemoteExecutionEnv, SnapshotId, WorkspaceHandle } from "../remote-env.js";
 import type { ToolDisclosureManifest } from "../trace.js";
-import type { AgentDefinition, ApproverPosture, Brain, CompactOutcome, ModelRoles, NestedUsageAccum, RunnerDeps, ShellGateDoctrine, TaskEvent, TaskEventIdentity, TaskResult, TaskSpec, TaskStream, ToolActivity, ToolEffect } from "../types.js";
+import type { AgentDefinition, ApproverPosture, Brain, CompactOutcome, ModelRef, ModelRoles, NestedUsageAccum, RunnerDeps, ShellGateDoctrine, TaskEvent, TaskEventIdentity, TaskResult, TaskSpec, TaskStream, ToolActivity, ToolEffect } from "../types.js";
 import type { WiringManifest } from "../wiring-manifest.js";
 import type { ActiveSkillFrame } from "./active-skill-scope.js";
 import type { BudgetAxis } from "./assemble-result.js";
@@ -248,6 +248,11 @@ export interface Prepared {
      * prepare emits run-scoped disclosures of its own and each must have a terminal that names it.
      */
     runId: string;
+    /** The (owner, scope) key this run's registry-facing tools register rows under — (host task id, mount domain), minted once at prepare; the teardown sweeps read it and never re-derive it. */
+    registryAccess: {
+        readonly owner: string;
+        readonly scope: string;
+    };
     /** The session's reminder provenance mark this run mints under (adopted
      *  through the prepare adoption ladder: checkpoint seed → trusted fork channel → session entry →
      *  fresh mint). Every engine-authored `<system-reminder>` open tag in the run carries it, and the
@@ -257,6 +262,8 @@ export interface Prepared {
      *  disclosure outlets at tool-execute time; read once at result assembly into
      *  `stats.mechanisms.reminderDisclosures` when any key is non-zero). Always present. */
     reminderDisclosureCounts: import("../reminder-disclosure.js").ReminderDisclosureCounts;
+    /** Whether the full shell is on this leg's roster (the inherited-gate phase's bit, asserted against the mount). */
+    fullShellReachable: boolean;
     /** The run's RESOLVED approval-posture facts — the auto-mode intent and the declared approver posture,
      *  folded once by the chain assembly. The first user turn renders them into the engine's own marked
      *  reminder; nothing else reads them, and no gate decision keys on either. */
@@ -471,6 +478,28 @@ export interface Prepared {
      * drains — one mount judgment, the drain and the park read it alike. Absent ⇒ in-process parking.
      */
     sessionBox?: import("../task-notification.js").SessionBoxBinding;
+    /**
+     * #1036 — the leg's TWO SETTLEMENT LEDGERS, one cell shared by the three beats that fill and
+     * read them: the harness's transcript-append sink writes receipts, the compaction commit beat
+     * writes effects, and the session-box drain's settlement half-pass reads both and clears what it
+     * consumed. Always present (the cell is minted with the leg); empty on a run with no session box,
+     * because nothing registers an interest and the receipt sink only records awaited keys.
+     */
+    frameSettlement: import("../frame-settlement.js").FrameSettlement;
+    /**
+     * #1036 — the session-box drain's BOUNDARY PASS, called by the turn-boundary lane as its tail
+     * (in a `finally`, so every early exit of the boundary still settles). Present iff this leg bound
+     * the drain. `continues` = this leg will issue another request after this boundary, which is what
+     * decides whether the pass's NEW-delivery half runs; the settlement half runs either way.
+     *
+     * It is a tail call and not a `turn_boundary` hook of the drain's own because the ORDER matters and
+     * a hook's position is registration-order luck: settlement must run AFTER this boundary's
+     * compaction, or a record whose frame the compaction just summarized away is already acked (deleted
+     * from the box) by the time anyone could notice.
+     */
+    peerBoundaryRound?: (o: {
+        continues: boolean;
+    }) => Promise<void>;
     /**
      * The per-invocation TIME BOUND every hook seat of this leg runs under (`Hooks.timeoutMs`, already
      * validated — a garbage value was refused to the default and disclosed ONCE, here, rather than on
@@ -1699,6 +1728,19 @@ export interface RunInternals {
      * TRUSTED run-scoped channel (NOT a {@link TaskSpec} field), mirroring `insideFork`.
      */
     defaultSystemPrompt?: string;
+    /**
+     * The catalog WORD that chose the model this engine-spawned child was handed on its spec.
+     *
+     * The two halves of one fact travel on two channels on purpose: the spec carries the RESOLVED `Model`
+     * object, so nothing re-resolves between the spawn's judgement and this child's prepare (the model the
+     * spawn frames name is the model that runs); this carries the word that object came from, so the child
+     * is not PINNED by having been handed an object — its own children inherit the word in turn, and the
+     * deployment's per-model window overlay (keyed by word) still reaches it. Absent ⇒ no word exists for
+     * this child's model (a caller-pinned object, a `select` criteria), and such a leg is deliberately never
+     * re-resolved and never overlaid. Trusted channel, never a `TaskSpec` field: it is the engine's own
+     * statement about a model the engine itself resolved, and a caller cannot author it.
+     */
+    inheritedModelRef?: ModelRef;
     /**
      * GOAL MODE flag, a TRUSTED internal channel set ONLY by `runGoal` (a core caller),
      * NEVER a {@link TaskSpec} field. It drives `featureFlags.goalEnabled` → injects `GOAL_COMPLETION_GUIDANCE`.
@@ -2105,7 +2147,7 @@ export interface RunInternals {
      * `leg` is the LEG IDENTITY, and the engine mints NONE of it. It is present only where a
      * composition labelled the leg it dispatched: the verify entries hand each leg a per-dispatch
      * copy of this object whose sink closes over that leg's identity, so a consumer can tell the
-     * implementation leg from round 2's verifier without inferring it from arrival order (the
+     * implementation leg from pass 2's verifier without inferring it from arrival order (the
      * ordering is all the sibling sinks have — see the attribution paragraph on `verifyCompleted`).
      * ABSENT therefore means "nobody labelled this leg", never "implementation": a plain `runTask`,
      * a workflow agent call and a cascade rung all reach this sink with no identity, and reading one
@@ -2113,13 +2155,13 @@ export interface RunInternals {
      * OWN `leg` field ({@link WiringManifest.leg}, `root` / `child` / `resume`), which is a fact about
      * how the ENGINE reached this run; this one is a fact about the composition that dispatched it, and
      * a resumed fix leg carries both at once — `manifest.leg.kind === "resume"` and `leg.kind === "fix"`
-     * are both true of it. `round` is 1-based over the gate's verification rounds: a `verifier` leg
+     * are both true of it. `pass` is 1-based over the gate's verification rounds: a `verifier` leg
      * carries the one it verifies, a `fix` leg the one whose findings it answers, and the entry
      * implementation leg carries 0 — before the first. The axis is relative to the gate INVOCATION,
      * not to the session's history: a resume entry's work leg is THAT invocation's implementation leg
-     * (`impl`, round 0) even when the checkpoint it resumes was minted inside a previous invocation's
-     * fix round, because the invocation's own round counter (`VerificationResult.rounds`) restarts with
-     * it — one axis for both fields, rather than a leg that reads "fix round 1" inside a result whose
+     * (`impl`, pass 0) even when the checkpoint it resumes was minted inside a previous invocation's
+     * fix pass, because the invocation's own pass counter (`VerificationResult.rounds`) restarts with
+     * it — one axis for both fields, rather than a leg that reads "fix pass 1" inside a result whose
      * rounds begin at 1 again.
      *
      * Observe-only and failure-isolated through the SAME per-run notifier as {@link onActivity} (one
@@ -2340,6 +2382,10 @@ export interface RunState {
         } | undefined;
         turnUsageMissing: boolean;
         turnStopReason: string | undefined;
+        /** The PROVIDER-REPORTED model name of this turn's LAST assistant message, when it differed from the
+         *  requested id — surfaced on `turn_end.responseModel`, reset with the rest of the per-turn
+         *  bookkeeping. Same shape as `turnStopReason`: last-message-wins, absent by default. */
+        turnResponseModel: string | undefined;
         lastTurnHadToolCalls: boolean;
         /** B15 三期使能:postToolBatch 的本回合聚集批(每回合边界消费并重置 — 回合语义,故归 turn)。 */
         toolBatch: PostToolBatchCall[];
@@ -2353,6 +2399,9 @@ export interface RunState {
         /** B15 三期终件补遗:压缩地板/背压 latch — rs.counters.compactionFloor 跨 drainManualCompact(写)/R9(读写)/收尾(读)三方共享,rs.counters.trimForceBackoff 为 R9 跨调用 latch(同款只改绑定不改时机)。 */
         compactionFloor: number;
         trimForceBackoff: boolean;
+        /** Landed compactions (boundary + prompt-too-long lanes) and the last one's kind — the `TaskResult.compaction` source (the breaker state is read off the breaker itself). */
+        compactionPasses: number;
+        compactionKind?: import("../task-notification.js").CompactionKind;
         repetitionCuts: number;
         repetitionSpared: number;
         repetitionEvents: Array<{
@@ -2540,7 +2589,7 @@ export interface TurnBoundaryDeps {
     }, ctx?: import("../hooks.js").PostToolBatchContext) => PostToolBatchResult | undefined | Promise<PostToolBatchResult | undefined>) | undefined;
     batchArgs: Map<string, unknown> | undefined;
     compactionBrain: Brain;
-    withinTaskCompaction: boolean;
+    withinTaskCompaction: () => boolean;
     compactionBreaker: {
         failures: number;
     };
@@ -2608,6 +2657,7 @@ export interface HarnessHandlersDeps {
     batchArgs: Map<string, unknown> | undefined;
     runnerHooks: {
         onError: RunnerDeps["onError"];
+        onNotice: RunnerDeps["onNotice"];
     };
     /** The run's ONE isolation scope for the {@link RunInternals} observation sinks, minted by the
      *  identity-wiring lane (which calls the first of them) and shared with these handlers, so the
@@ -2653,6 +2703,10 @@ export interface RunnerSelfSeat {
         models?: Record<string, Model>;
         roles?: ModelRoles;
     };
+    /** The context-window overlay a leg on `ref` reads RIGHT NOW (`RunnerDeps.contextSettings`, tier aliases followed
+     *  against the catalog in force): prepare hands its leg a call-time reader over it, because this is the one seat a
+     *  running leg re-reads (geometry, not route — see `context-settings.ts`). */
+    contextOverlayOf?(ref: import("../model-seat.js").ModelRef | undefined): import("../context-settings.js").ContextWindowOverlay | undefined;
     /** The deployment-level gating baseline (deps toolPolicy / hooks) as delegate wrappers — for assemblers that compose with it. */
     readonly gateBaseline: {
         toolPolicy?: RunnerDeps["toolPolicy"];

package/dist/core/runner/decide-continuation.d.ts

@@ -92,5 +92,6 @@ export declare function assertOutcomeText(value: string | undefined, field: "edi
  * `prompt(text)` (it always appends a user message — there is no "continue from tool results" entry), so
  * resume re-enters via a `<system-reminder>`-wrapped user message that tells the model the gated decision
  * was applied. The "user message wart" is accepted (API-valid, and clearer than a silent continuation).
+ * `fullShellReachable` is the resumed leg's own roster fact, read by {@link reorientClause}.
  */
-export declare function resumeContinuation(resume: ResumeRun, mark: string | undefined): string;
+export declare function resumeContinuation(resume: ResumeRun, mark: string | undefined, fullShellReachable: boolean): string;

package/dist/core/runner/decide-continuation.js

@@ -74,24 +74,25 @@ export function assertOutcomeText(value, field) {
         throw new CheckpointError("checkpoint.invalid_outcome", `resume \`${field}\` is not a plain string (got ${typeof value}) — a decide's text payload is an operator's plain data, not a live object; refusing pre-CAS, the checkpoint stays pending`);
     }
 }
-export function resumeContinuation(resume, mark) {
+function reorientClause(fullShellReachable) {
+    const source = fullShellReachable
+        ? "re-orient from the workspace: run `git status` and review your recent changes / last commits"
+        : "re-orient from the conversation: re-read your most recent messages and tool results";
+    return `Before continuing, ${source} to confirm what is already done, then continue the remaining work. ` +
+        "Do NOT restart the task or re-run work that is already committed.";
+}
+export function resumeContinuation(resume, mark, fullShellReachable) {
     if (resume.outcome.gate === "wake") {
-        return formatHookFeedback("You were WOKEN from a parked pause by an operator. Before continuing, re-orient from the workspace: " +
-            "run `git status` and review your recent changes / last commits to confirm what is already done, then " +
-            "continue the remaining work. Do NOT restart the task or re-run work that is already committed.", mark);
+        return formatHookFeedback(`You were WOKEN from a parked pause by an operator. ${reorientClause(fullShellReachable)}`, mark);
     }
     if (resume.outcome.gate === "resource_limit") {
-        return formatHookFeedback("You were resumed after a pause. Before continuing, re-orient from the workspace: run `git status` and " +
-            "review your recent changes / last commits to confirm what is already done, then continue the " +
-            "remaining work. Do NOT restart the task or re-run work that is already committed.", mark);
+        return formatHookFeedback(`You were resumed after a pause. ${reorientClause(fullShellReachable)}`, mark);
     }
     if (resume.outcome.gate === "dry_run_review") {
         const verdict = resume.outcome.decision === "approve"
             ? "Your predicted change was REVIEWED and APPROVED; it has been applied"
             : `Your predicted change was REVIEWED and REJECTED${resume.outcome.reason ? `: ${delimitUntrusted("reviewer note", resume.outcome.reason, REVIEWER_NOTE_MAX_BODY)}` : ""}; it was NOT applied`;
-        return formatHookFeedback(`You were resumed after a dry-run review. ${verdict}. Before continuing, re-orient from the workspace ` +
-            "(run `git status` and review your recent changes) to confirm the current state, then continue the " +
-            "remaining work. Do NOT restart the task or re-run work that is already done.", mark);
+        return formatHookFeedback(`You were resumed after a dry-run review. ${verdict}. ${reorientClause(fullShellReachable)}`, mark);
     }
     if (resume.outcome.gate === "plan_review") {
         if (resume.outcome.decision === "approve") {

package/dist/core/runner/initial-run-state.js

@@ -4,8 +4,8 @@ export function createRunState() {
         degrade: { degradeToModel: undefined, degraded: undefined, outputErrorStreak: 0, outputInvalid: false, recordDegraded: () => { } },
         limits: { turnsExceeded: false, budgetHit: undefined, budgetAxis: undefined, platformTerminal: undefined, outputRetryCap: 0, effectiveMaxTurns: undefined },
         budget: { remainingMicroUsd: undefined, maxCostMicroUsd: undefined, remainingTokens: undefined, maxTokensWindow: undefined, overBudget: () => undefined, streamCancel: false, callOutputChars: 0, lastStreamBudgetCheck: 0, projectedOverBudget: () => undefined },
-        turn: { callStartAt: undefined, firstTokenAt: undefined, turnUsage: undefined, turnUsageMissing: false, turnStopReason: undefined, lastTurnHadToolCalls: false, toolBatch: [] },
-        counters: { approachNoticesSent: 0, walltimeSyncBackstopFired: false, compactionFloor: 0, trimForceBackoff: false, repetitionCuts: 0, repetitionSpared: 0, repetitionEvents: [], REPETITION_EVENTS_CAP: 0, preemptIgnoredReported: false, wroteThisRun: false, finalVerifyInjections: 0, groundingSignalPreR9: false, groundingSignalPostR9: false, cadenceTurns: 0 },
+        turn: { callStartAt: undefined, firstTokenAt: undefined, turnUsage: undefined, turnUsageMissing: false, turnStopReason: undefined, turnResponseModel: undefined, lastTurnHadToolCalls: false, toolBatch: [] },
+        counters: { approachNoticesSent: 0, walltimeSyncBackstopFired: false, compactionFloor: 0, trimForceBackoff: false, compactionPasses: 0, repetitionCuts: 0, repetitionSpared: 0, repetitionEvents: [], REPETITION_EVENTS_CAP: 0, preemptIgnoredReported: false, wroteThisRun: false, finalVerifyInjections: 0, groundingSignalPreR9: false, groundingSignalPostR9: false, cadenceTurns: 0 },
         attach: { attachmentsCfg: undefined, agentListingOn: false, skillsListingOn: false, attachState: undefined, dateState: undefined, instrProbe: undefined, instrState: undefined, sizeGuidelineState: undefined, attachmentsInjected: 0 },
     };
 }

package/dist/core/runner/prepare-caps-and-workflow.js

@@ -1,6 +1,7 @@
 import { isSyntheticApiErrorMessage } from "../../internal/harness.js";
 import { createHash } from "node:crypto";
 import { childThinkingSeat, deploymentSubagentThinking, deploymentSubagentTierModel, forkGovernanceDenial } from "../../agents/subagent.js";
+import { inheritedParentModel } from "../../agents/child-model-seat.js";
 import { CROSS_SESSION_CLASSIFIER_RULE } from "../../agents/cross-session-envelope.js";
 import { createRunWorkflowTool } from "../../orchestration/run-workflow-tool.js";
 import { isSelfOrchestrationActive } from "../../orchestration/workflow-script-runner.js";
@@ -287,7 +288,14 @@ export async function prepareCapsAndWorkflow(input) {
             taskOwner: hostTaskId,
             limits: deps.workflowLimits,
             sourceTaskId: hostTaskId,
-            parentModel: () => deploymentSubagentTierModel(runnerSelf.agentCatalog) ?? harnessRef.current?.getModel(),
+            parentModel: () => {
+                const stated = deploymentSubagentTierModel(runnerSelf.agentCatalog);
+                if (stated !== undefined)
+                    return stated;
+                const ref = harnessRef.current?.getModelRef();
+                const model = inheritedParentModel(ref, runnerSelf.agentCatalog.models);
+                return model === undefined ? undefined : { model, ...(typeof ref === "string" ? { modelRef: ref } : {}) };
+            },
             ...(spec.getApiKeyAndHeaders !== undefined ? { parentGetApiKeyAndHeaders: spec.getApiKeyAndHeaders } : {}),
             ...(frozenOnAsk !== undefined ? { parentOnAsk: frozenOnAsk } : {}),
             ...(spec.durableApproval !== undefined ? { parentDurableApproval: { ...spec.durableApproval } } : {}),

package/dist/core/runner/prepare-config-doors.js

@@ -13,6 +13,7 @@ import { describeRejectedValue } from "../tool-search-setting.js";
 import { applyToolModelGate, assertRestoreGatedToolsValue, modelIdTail } from "../tool-model-gate.js";
 import { resolveUsageWindows } from "../usage-window-store.js";
 import { deriveAskEffective, resolveAskSeamForm, resolveQuestionSeam } from "../wiring-manifest.js";
+import { assertPeerPresenceValue } from "../../agents/peer-directory.js";
 import { TOTAL_TOKENS_REMINDER_MODES } from "./turn-attachments.js";
 const TASK_LIMIT_KEY_DICT = {
     maxTokens: true,
@@ -144,6 +145,7 @@ export function prepareConfigDoors(input) {
     const { deps, sessions, resume, internals } = input;
     let spec = input.spec;
     assertNoRetiredRunnerDeps(deps);
+    assertPeerPresenceValue(spec.peerPresence);
     assertRestoreGatedToolsValue(spec.restoreGatedTools);
     const microCompactKnob = resolveMicroCompactKnob(deps.microCompact);
     const assertToolNameListValue = (value, seat) => {
@@ -368,7 +370,8 @@ export function prepareConfigDoors(input) {
             }),
         };
     }
-    const resolvedRole = resolveTaskModel(spec, deps);
+    const resolvedRoleRaw = resolveTaskModel(spec, deps);
+    const resolvedRole = internals?.inheritedModelRef !== undefined ? { ...resolvedRoleRaw, modelRef: internals.inheritedModelRef } : resolvedRoleRaw;
     const model = resolvedRole.model;
     if (usageWindows !== undefined && deps.usageWindowStore !== undefined) {
         const costed = usageWindows.find((w) => w.maxCostUsd !== undefined);

package/dist/core/runner/prepare-context-lane.d.ts

@@ -18,6 +18,7 @@
 import { type AgentHarness, type AgentMessage } from "../../internal/harness.js";
 import type { Model } from "../../internal/llm.js";
 import { type ClearedProjectionLedger, type MicroCompactMachine, type OccurrenceFingerprint, type OccurrenceIndex } from "../context-edit.js";
+import type { ContextWindowOverlay } from "../context-settings.js";
 import { type ToolResultStore } from "../tool-result-store.js";
 import { type RunnerDeps } from "../types.js";
 import type { Prepared, PreparedMicroCompact } from "./contracts.js";
@@ -72,13 +73,19 @@ export interface PrepareContextLaneInput {
     trimPressureRef: {
         droppedMessages: boolean;
     };
+    /** borrowed-readonly — a CALL-TIME getter for the deployment's per-model window overlay in force for this
+     *  leg ({@link RunnerDeps.contextSettings} keyed by the leg's catalog word). A getter and not a value: this
+     *  is the one deployment seat an in-flight leg re-reads, and the request-layer frontiers below are asked
+     *  per request. Absent (a standalone prepare exercise, no Runner behind it) ⇒ no overlay, ever. */
+    contextOverlay?: () => ContextWindowOverlay | undefined;
 }
 export interface PrepareContextLaneResult {
     /** owned — the per-run microCompact machine state (`Prepared.microCompact`): machine, MC-R flag, ledger, the projection
      *  and in-turn-compaction seats the handler and the runtask arms fill. */
     microCompact: PreparedMicroCompact;
-    /** owned — the model's structural coefficient (`charsPerToken ?? DEFAULT`), the ONE coordinate the request-layer
-     *  defenses here and the prompt-overhead term downstream share with the compaction trigger estimate. */
+    /** owned — the PREPARE-time model's structural coefficient (`charsPerToken ?? DEFAULT`), the coordinate the
+     *  prompt-overhead term downstream is computed in. The per-REQUEST defenses read the CURRENT model's
+     *  instead (`requestGeometry`), beside the window they compare against — one snapshot, one coordinate. */
     charsPerToken: number;
 }
 /** The M21 phase body — prepareTask's context-lane stretch, verbatim (see the module header). */

package/dist/core/runner/prepare-context-lane.js

@@ -10,14 +10,19 @@ import { applyGitFrameGuard } from "./git-status-frame.js";
 import { applyContextShrinkToReadFileState } from "../../tools/fs/index.js";
 export function prepareContextLane(input) {
     const { model, deps, sessionId, runId, hostTaskId, offloadStore, microCompactKnob, harness, batchHaltRef, gitStatusRef, postureFrameRef, requestLossyRef, trimPressureRef, readFileState } = input;
-    const editAt = editBudget(model);
-    const guardAt = guardBudget(model);
-    const microCompact = buildMicroCompactState(deps, model, sessionId, runId, offloadStore, microCompactKnob);
+    const contextOverlay = input.contextOverlay ?? (() => undefined);
+    const requestGeometry = () => {
+        const current = harness.getModel();
+        const overlay = contextOverlay();
+        return { editAt: editBudget(current, overlay), guardAt: guardBudget(current, overlay), charsPerToken: current.charsPerToken ?? DEFAULT_CHARS_PER_TOKEN };
+    };
+    const microCompact = buildMicroCompactState(deps, model, sessionId, runId, offloadStore, microCompactKnob, contextOverlay());
     const charsPerToken = model.charsPerToken ?? DEFAULT_CHARS_PER_TOKEN;
     harness.on("context", async ({ messages, recheck, signal }) => {
         batchHaltRef.current = undefined;
         const pendingProjectionObservations = [];
         try {
+            const { editAt, guardAt, charsPerToken: cpt } = requestGeometry();
             const healed = dropEmptyFailureAssistants(messages);
             const replay = replayClearedProjection(healed, microCompact.ledger);
             const replayed = replay.messages;
@@ -47,8 +52,8 @@ export function prepareContextLane(input) {
                 budgetTokens: editAt,
                 clearSource: replayed,
                 onCleared: (pass) => { ccPass = pass; },
-                anchoredTotalTokens: estimateContextTokens(mediaCapped, charsPerToken).tokens,
-                charsPerToken,
+                anchoredTotalTokens: estimateContextTokens(mediaCapped, cpt).tokens,
+                charsPerToken: cpt,
                 ...(offloadStore
                     ? {
                         offload: {
@@ -61,7 +66,7 @@ export function prepareContextLane(input) {
                 recordFrontierClears({ pass: ccPass, index: replay.index, edited, ledger: microCompact.ledger, tracer: deps.tracer, taskId: hostTaskId, trigger: "frontier", ...(readFileState !== undefined ? { readFileState } : {}) });
             }
             const chain = await runGuardChain({
-                edited, replayed, index: replay.index, microCompact, guardAt, charsPerToken, offloadStore,
+                edited, replayed, index: replay.index, microCompact, guardAt, charsPerToken: cpt, offloadStore,
                 sessionId, taskId: hostTaskId, deps, trimPressureRef, recheck, signal,
                 pendingProjectionObservations,
                 ...(readFileState !== undefined ? { readFileState } : {}),
@@ -76,7 +81,7 @@ export function prepareContextLane(input) {
                 trimmed,
                 budgetTokens: guardAt,
                 ref: gitStatusRef,
-                charsPerToken,
+                charsPerToken: cpt,
                 onDegrade: (message) => {
                     try {
                         deps.onError?.(new Error(message), { phase: "degraded", sessionId, classification: "env-git-snapshot" });
@@ -86,7 +91,7 @@ export function prepareContextLane(input) {
                 },
             });
             if (postureFrameRef.protectedText !== undefined) {
-                const kept = protectGitFrame(working, trimmed, guardAt, { protectedText: postureFrameRef.protectedText }, charsPerToken);
+                const kept = protectGitFrame(working, trimmed, guardAt, { protectedText: postureFrameRef.protectedText }, cpt);
                 if (kept.action === "kept" || kept.action === "reinserted")
                     trimmed = kept.messages;
             }
@@ -119,8 +124,8 @@ export function prepareContextLane(input) {
     });
     return { microCompact, charsPerToken };
 }
-function buildMicroCompactState(deps, model, sessionId, runId, offloadStore, knob) {
-    const triggerWindow = resolveTriggerWindow(model);
+function buildMicroCompactState(deps, model, sessionId, runId, offloadStore, knob, overlay) {
+    const triggerWindow = resolveTriggerWindow(model, overlay);
     if (triggerWindow.clamped) {
         deliverEngineNotice(deps.onNotice, {
             code: "config.autocompact_window_clamped",

package/dist/core/runner/prepare-delegation-surface.d.ts

@@ -14,9 +14,9 @@ export interface PrepareDelegationSurfaceInput {
      *  `handsReadOnly` is NOT read here (the hands mount decided the surface). Never mutated. */
     spec: Pick<TaskSpec, "tools" | "oneShot" | "retainBackgroundProcesses">;
     /** borrowed-readonly — the deployment seats the mounts read: `workflowRunStore` / `backgroundAgentStore` / `mailboxStore` (the
-     *  read/kill faces and the tier-3 revival seams), `rosterStore`, `peerAdmission`, `peerDirectory`, `onNotice`,
+     *  read/kill faces and the tier-3 revival seams), `rosterStore`, `peerLane`, `peerDirectory`, `onNotice`,
      *  `onBackgroundChildEvent`, `tracer`. */
-    deps: Pick<RunnerDeps, "workflowRunStore" | "backgroundAgentStore" | "mailboxStore" | "rosterStore" | "peerAdmission" | "peerDirectory" | "onNotice" | "onBackgroundChildEvent" | "tracer">;
+    deps: Pick<RunnerDeps, "workflowRunStore" | "backgroundAgentStore" | "mailboxStore" | "rosterStore" | "peerLane" | "peerDirectory" | "onNotice" | "onBackgroundChildEvent" | "tracer">;
     /** borrowed-readonly — the trusted spawn-side channel: `parentNotify` (the delegated-child door), the uplink / sibling /
      *  identity seats the SendMessage mount forwards, `onTaskNotification`, `onSubagentSpawn`. Never mutated. */
     internals: Pick<RunInternals, "parentNotify" | "parentPeerRef" | "uplinkSessionId" | "parentRetainLedger" | "explicitAgentName" | "parentTaskId" | "parentSessionId" | "peerSelfRef" | "peerInboundChainRef" | "onTaskNotification" | "onSubagentSpawn"> | undefined;
@@ -52,6 +52,7 @@ export interface PrepareDelegationSurfaceInput {
     /** borrowed-mutable — the lane's late-bound facts; the SendMessage mount hands the SAME object to its peer seats (identity is
      *  the contract: the wiring station fills `askEffective` later). Not written here. */
     peerLaneRefs: PeerLaneRefs;
+    /** borrowed-readonly — the session-box drain's mount judgment (the `ReadInbox` door: a box drained by this leg). */ sessionBox?: import("../task-notification.js").SessionBoxBinding | undefined;
     /** borrowed-mutable — the run's roster builder (`Prepared.tools` is its read face; the writer table is on that field).
      *  Writers here: the eight mounts (TaskOutput, TaskStop, SendMessage, AgentTranscript, ListAgents, Monitor, the worktree
      *  pair, the offload reader), every one a `mount`. */

package/dist/core/runner/prepare-delegation-surface.js

@@ -2,6 +2,8 @@ import { randomBytes } from "node:crypto";
 import { createAgentTranscriptTool, AGENT_TRANSCRIPT_TOOL_NAME } from "../../agents/agent-transcript-tool.js";
 import { createSendMessageTool, SEND_MESSAGE_TOOL_NAME } from "../../agents/send-message-tool.js";
 import { listAgentsMountable, mountListAgents, peerLaneSendMessageSeats } from "../../agents/peer-session-drain.js";
+import { resolvePeerLaneConfig } from "../../agents/peer-admission.js";
+import { createReadInboxTool, READ_INBOX_TOOL_NAME } from "../../agents/read-inbox-tool.js";
 import { createMonitorTool } from "../../tools/monitor.js";
 import { createWorktreeTools } from "../../tools/worktree.js";
 import { createTaskOutputTool, createTaskStopTool, defaultTaskRegistry } from "../task-registry.js";
@@ -30,7 +32,7 @@ function buildTier3ReviveSpawn(delegationForRevive, enrichSpecToolCtx) {
     };
 }
 export function prepareDelegationSurface(input) {
-    const { spec, deps, internals, resume, sessionId, hostTaskId, taskScope, taskRootFinal, taskRootCanonical, executionEnv, runnerSelf, backgroundTaskToolsActive, workflowToolsActive, peerLaneActive, peerSendMessageBuiltIn, peerLaneRefs, roster, toolEffects, axisExplicitNegatives, envHandToolNames, toolFaceSnapshot, firstPartyOffload, offloadStore, subagentRetain, enrichSpecToolCtx, handsCwdRef, wsSnapshot, rebaseWsPath, rebaseRestoredPath, workspaceStateSettle } = input;
+    const { spec, deps, internals, resume, sessionId, hostTaskId, taskScope, taskRootFinal, taskRootCanonical, executionEnv, runnerSelf, backgroundTaskToolsActive, workflowToolsActive, peerLaneActive, peerSendMessageBuiltIn, peerLaneRefs, sessionBox, roster, toolEffects, axisExplicitNegatives, envHandToolNames, toolFaceSnapshot, firstPartyOffload, offloadStore, subagentRetain, enrichSpecToolCtx, handsCwdRef, wsSnapshot, rebaseWsPath, rebaseRestoredPath, workspaceStateSettle } = input;
     let worktreeSessionRef;
     const delegationSurfaceActive = backgroundTaskToolsActive || workflowToolsActive;
     if (delegationSurfaceActive || internals?.parentNotify !== undefined || peerLaneActive) {
@@ -63,7 +65,7 @@ export function prepareDelegationSurface(input) {
                 ...(internals?.parentSessionId !== undefined ? { parentSessionId: internals.parentSessionId } : {}),
                 enrichCtx: enrichSpecToolCtx,
                 ...(deps.rosterStore !== undefined ? { roster: deps.rosterStore } : {}),
-                ...(deps.peerAdmission !== undefined ? { admission: deps.peerAdmission } : {}),
+                ...(deps.peerLane !== undefined ? { lane: deps.peerLane } : {}),
                 ...(deps.onNotice !== undefined ? { onNotice: deps.onNotice } : {}),
                 ...(internals?.peerSelfRef !== undefined ? { peerSelf: internals.peerSelfRef } : {}),
                 ...(internals?.peerInboundChainRef !== undefined ? { peerInbound: internals.peerInboundChainRef } : {}),
@@ -97,7 +99,11 @@ export function prepareDelegationSurface(input) {
             }
         }
     }
-    const listAgents = peerLaneActive && peerSendMessageBuiltIn && listAgentsMountable({ exclude: toolFaceSnapshot.exclude, specTools: spec.tools ?? [] }) ? mountListAgents({ peerDirectory: deps.peerDirectory, sessionId, scope: taskScope, hostTaskId, ...(internals?.parentTaskId !== undefined ? { parentTaskId: internals.parentTaskId } : {}), ...(internals?.parentSessionId !== undefined ? { parentSessionId: internals.parentSessionId } : {}), registry: defaultTaskRegistry, ...(deps.rosterStore !== undefined ? { roster: deps.rosterStore } : {}), specTools: spec.tools ?? [], toolEffects }) : undefined;
+    if (sessionBox !== undefined && internals?.onTaskNotification !== undefined && !(toolFaceSnapshot.exclude ?? []).includes(READ_INBOX_TOOL_NAME) && !(spec.tools ?? []).some((t) => t.name === READ_INBOX_TOOL_NAME)) {
+        toolEffects.set(READ_INBOX_TOOL_NAME, "read");
+        roster.mount(firstPartyOffload(createReadInboxTool({ pull: () => peerLaneRefs.pull })), { source: "builtin", mountedBy: "peerLane" });
+    }
+    const listAgents = (peerLaneActive || delegationSurfaceActive) && peerSendMessageBuiltIn && listAgentsMountable({ exclude: toolFaceSnapshot.exclude, specTools: spec.tools ?? [] }) ? mountListAgents({ ...(peerLaneActive ? { peerDirectory: deps.peerDirectory } : {}), freshWindowMs: resolvePeerLaneConfig(deps.peerLane, deps.onNotice).listingFreshWindowMs, sessionId, scope: taskScope, hostTaskId, ...(internals?.parentTaskId !== undefined ? { parentTaskId: internals.parentTaskId } : {}), ...(internals?.parentSessionId !== undefined ? { parentSessionId: internals.parentSessionId } : {}), registry: defaultTaskRegistry, ...(deps.rosterStore !== undefined ? { roster: deps.rosterStore } : {}), specTools: spec.tools ?? [], toolEffects }) : undefined;
     if (listAgents !== undefined)
         roster.mount(firstPartyOffload(listAgents), { source: "builtin", mountedBy: "peerLane" });
     if (backgroundTaskToolsActive) {

package/dist/core/runner/prepare-file-history.js

@@ -10,7 +10,8 @@ export async function prepareFileHistory(input) {
         e.code = "config.invalid_on_track_failure";
         throw e;
     }
-    const fileHistoryStore = resolveWiredFileHistoryStore(deps.fileHistoryStore);
+    const wiredSeat = resolveWiredFileHistoryStore(deps.fileHistoryStore);
+    const fileHistoryStore = wiredSeat === "disabled" ? undefined : wiredSeat;
     const legacyRewindFiles = spec.rewindFiles;
     if (legacyRewindFiles === true) {
         if (spec.resumeAt !== undefined) {
@@ -43,12 +44,13 @@ export async function prepareFileHistory(input) {
         });
     }
     const fileHistoryEnabled = fileHistoryStore !== undefined && handsEnabled;
-    if (!fileHistoryEnabled && (handsEnabled || fileHistoryStore !== undefined) && deps.onError !== undefined && !toldAlready(deps.onError, fileHistoryStore === undefined ? "no-store" : "no-env")) {
-        const reason = fileHistoryStore === undefined
-            ? `this deployment wired no RunnerDeps.fileHistoryStore, so NOTHING is recorded: no first-touch snapshot before an edit, no turn boundary, and a later restoreFiles / rewindFilesTo has nothing to restore from and will refuse (rewind.store_unconfigured). Supply a store, or accept an unrecoverable working tree knowingly`
+    const livenessArm = fileHistoryStore === undefined ? "file-history-no-store" : "file-history-no-env";
+    if (!fileHistoryEnabled && wiredSeat !== "disabled" && (handsEnabled || fileHistoryStore !== undefined) && deps.onError !== undefined && !toldAlready(deps.onError, livenessArm)) {
+        const reason = livenessArm === "file-history-no-store"
+            ? `this deployment wired no RunnerDeps.fileHistoryStore, so NOTHING is recorded: no first-touch snapshot before an edit, no turn boundary, and a later restoreFiles / rewindFilesTo has nothing to restore from and will refuse (rewind.store_unconfigured). Supply a store, or accept an unrecoverable working tree knowingly (fileHistoryStore: "disabled" says so and silences this line)`
             : `RunnerDeps.fileHistoryStore is wired but this run mounts no filesystem-capable ExecutionEnv, so the store is INERT: there is no working tree to snapshot and nothing will ever be written to it. Wire RunnerDeps.executionEnv, or drop the store from this deployment shape`;
         try {
-            deps.onError(new Error(`file history is not live for this run — ${reason}.`), { phase: "config", sessionId });
+            deps.onError(new Error(`file history is not live for this run — ${reason}.`), { phase: "config", sessionId, classification: livenessArm });
         }
         catch {
         }
@@ -180,8 +182,8 @@ function restoredAbsPathsOf(restored, root) {
     return out;
 }
 function resolveWiredFileHistoryStore(candidate) {
-    if (candidate === undefined)
-        return undefined;
+    if (candidate === undefined || candidate === "disabled")
+        return candidate;
     const verbs = ["trackEdit", "annulTrack", "snapshot", "restore", "canRestore", "reap", "adoptScope"];
     const verbOf = (v) => {
         try {
@@ -195,7 +197,7 @@ function resolveWiredFileHistoryStore(candidate) {
     const missing = probeable ? verbs.filter((v) => typeof verbOf(v) !== "function") : [...verbs];
     if (missing.length > 0) {
         const shape = candidate === null ? "null" : probeable ? "a value that is not a FileHistoryStore" : `a ${typeof candidate}`;
-        const e = new Error(`RunnerDeps.fileHistoryStore was wired with ${shape} — missing contract verbs: ${missing.join(", ")}. Refusing prepare rather than half-wiring the rewind seat (a present-but-unusable store makes every Edit/Write/NotebookEdit fail its first-touch backup while restore requests report "no store wired"). Omit the key to run without file history.`);
+        const e = new Error(`RunnerDeps.fileHistoryStore was wired with ${shape} — missing contract verbs: ${missing.join(", ")}. Refusing prepare rather than half-wiring the rewind seat (a present-but-unusable store makes every Edit/Write/NotebookEdit fail its first-touch backup while restore requests report "no store wired"). Write "disabled" (or omit the key) to run without file history.`);
         e.code = "config.invalid_file_history_store";
         throw e;
     }

package/dist/core/runner/prepare-gate-stations.d.ts

@@ -36,6 +36,7 @@ import type { CwdRef } from "../../tools/fs/fs-shared.js";
 import type { AskLane, IrreversibilityTier, ParkAsk, Prepared, ReversibilityProbes, StopForDenialLimit } from "./contracts.js";
 import type { PermissionRuleLanes } from "./permission-rule-lanes.js";
 import { type ToolRosterDeltaSeat } from "../tool-roster.js";
+import { type FrameSettlement } from "../frame-settlement.js";
 /**
  * The parent-thread human-rejection boundary — judged ONCE here, from the pass's own record (CC parity:
  * the reference CLI's reject path aborts exactly when there is no feedback and the run is not a
@@ -201,6 +202,9 @@ export interface PrepareGateStationsInput {
     };
     /** borrowed-readonly — the own hook-crash reporter (an expired post seat is reported through it). */
     notifyOwnHookCrash: (err: unknown) => void;
+    /** borrowed-mutable — the leg's settlement seam. Writer here: the `tool_result` station marks a carrier whose output
+     *  a host hook rewrote (`noteHostRewrite`), so a frame the rewrite removed settles as the host's decision. */
+    frameSettlement: FrameSettlement;
 }
 export interface PrepareGateStationsResult {
     /** owned — whether the `tool_call` station registered (the arming predicate's value; observation seat only). */

package/dist/core/runner/prepare-gate-stations.js

@@ -9,6 +9,7 @@ import { deliverEngineNotice } from "../engine-notice.js";
 import { askUnresolvableNotice } from "../ask-unresolvable-notice.js";
 import { PATH_CONFINABLE_WRITE_TOOLS } from "./session-rule-policy.js";
 import { toolCallFaceOf } from "../tool-roster.js";
+import { noteHostRewrite } from "../frame-settlement.js";
 function screenGateResult(result) {
     if (result.suspend !== undefined)
         return { defects: [] };
@@ -41,7 +42,7 @@ export function maybeHumanRejectionHalt(input) {
     };
 }
 export function prepareGateStations(input) {
-    const { askLane, parkAsk, tools, toolRosterDeltas, toolEffects, deps, toolCallGateArmedRef, effectivePolicy, hooks, egressTools, irreversibleTools, spec, complianceDenies, harness, blockedToolCalls, inheritedAskGrants, inheritedUnavailableAsks, foldAskClasses, ancestorSandboxAdmissions, preToolContexts, gateOutcomes, batchHaltRef, blockedTracked, hookIdentity, reminderMark, planModeRef, hostTaskId, sessionId, ownGatePreToolUse, hookTimeoutMs, handsCwdRef, hookEnvFace, writeProtectionCheck, shellReadCheck, irreversibilityTier, reversibilityProbes, abortController, shellGatedTools, autoModeDecider, autoModeDenialTracking, stopForDenialLimit, permissionRuleLane, permissionRuleOrgLane, questionToolMounted, sandboxAdmissionArmed, sandboxBoundaryCapable, emitSandboxAdmitted, delegation, notifyOwnHookCrash } = input;
+    const { askLane, parkAsk, tools, toolRosterDeltas, toolEffects, deps, toolCallGateArmedRef, effectivePolicy, hooks, egressTools, irreversibleTools, spec, complianceDenies, harness, blockedToolCalls, inheritedAskGrants, inheritedUnavailableAsks, foldAskClasses, ancestorSandboxAdmissions, preToolContexts, gateOutcomes, batchHaltRef, blockedTracked, hookIdentity, reminderMark, planModeRef, hostTaskId, sessionId, ownGatePreToolUse, hookTimeoutMs, handsCwdRef, hookEnvFace, writeProtectionCheck, shellReadCheck, irreversibilityTier, reversibilityProbes, abortController, shellGatedTools, autoModeDecider, autoModeDenialTracking, stopForDenialLimit, permissionRuleLane, permissionRuleOrgLane, questionToolMounted, sandboxAdmissionArmed, sandboxBoundaryCapable, emitSandboxAdmitted, delegation, notifyOwnHookCrash, frameSettlement } = input;
     if (askLane !== undefined && parkAsk !== undefined) {
         const { adjudicate, resolveAskBound, notifyPermissionDenied, notifyHookError } = askLane;
         const { resolveContentAsk, suspendAsk } = parkAsk;
@@ -261,6 +262,7 @@ export function prepareGateStations(input) {
                 if (patch?.updatedOutput) {
                     content = patch.updatedOutput;
                     changed = true;
+                    noteHostRewrite(frameSettlement, e.toolCallId);
                 }
                 if (patch?.additionalContext) {
                     content = [...content, { type: "text", text: formatHookFeedback(patch.additionalContext, reminderMark) }];

package/dist/core/runner/prepare-inherited-gate.js

@@ -194,6 +194,7 @@ export function prepareInheritedGate(input) {
             delegationEntryCaps: delegationEntryCapsResolved,
             reportUsage,
             model: harnessRef.current?.getModel(),
+            modelRef: harnessRef.current?.getModelRef(),
             thinkingLevel: harnessRef.current?.getThinkingLevel(),
             principal: spec.principal,
             ...(frozenOnAsk !== undefined ? { onAsk: frozenOnAsk } : {}),

package/dist/core/runner/prepare-prompt-inputs.d.ts

@@ -30,6 +30,7 @@ import type { RunnerDeps, TaskSpec } from "../types.js";
 import type { PrepareResume, PromptFeatureFlags, RunInternals, ToolFaceSnapshot } from "./contracts.js";
 import type { AdvertisedWritableDirs } from "./advertised-writable-dirs.js";
 import { type GitStatusLaneRef } from "./git-status-frame.js";
+import { type ContextWindowOverlay } from "../context-settings.js";
 export interface PreparePromptInputsInput {
     /** borrowed-readonly — the REBOUND spec (`spec′`). Read: `promptProvider`, `hooks` (flag), `systemPrompt`
      *  / `appendSystemPrompt` (the user prompt sources), `clientContext` (zone, email), `envFacts` (the
@@ -98,6 +99,11 @@ export interface PreparePromptInputsInput {
     advertisedWritableDirs?: AdvertisedWritableDirs;
     /** borrowed-readonly — the acquired session's id (operator-line context). */
     sessionId: string;
+    /** borrowed-readonly — the deployment's window overlay for this leg, as it reads at PREPARE. The prompt's
+     *  context-management sentence must not claim mid-task summarization a deployment has turned off for this
+     *  model; the seat is live, so a later swap's effect on the SENTENCE lands at the next prepare while its
+     *  effect on the BEHAVIOR lands at the next boundary — stated, not sworn away. */
+    contextOverlay?: ContextWindowOverlay;
 }
 export interface PreparePromptInputsResult {
     /** owned — the prompt provider in force (`spec` ?? `deps` ?? the default). */

package/dist/core/runner/prepare-prompt-inputs.js

@@ -3,6 +3,7 @@ import { isIsolated } from "../remote-env.js";
 import { probeGitStatusLane } from "./git-status-frame.js";
 import { fenceMcpServerInstructions } from "./turn-attachments.js";
 const ULTRA_REASONING_TIERS = new Set(["xhigh", "max"]);
+import { compactionEnabled } from "../context-settings.js";
 export async function preparePromptInputs(input) {
     const { spec, deps, failClosedReason, lockedPreflight, selfOrchestrationActive, executionEnv, reminderMark, resolvedReadFace, resolvedWriteFace, toolFaceSnapshot, promptProfile, fableMitigations, internals, thinking, ownedEnv, delegation, resolvedRole, mcp, model, externalContentTargetActive, resume, handsEnabled, taskRootFinal, additionalRootsCanonical, additionalReadRootsCanonical, sessionId, advertisedWritableDirs } = input;
     const provider = spec.promptProvider ?? deps.promptProvider ?? defaultPromptProvider;
@@ -26,7 +27,7 @@ export async function preparePromptInputs(input) {
         goalEnabled: internals?.goalMode === true,
         awarenessEnabled: thinking !== undefined && ULTRA_REASONING_TIERS.has(thinking),
         worktreeIsolated: internals?.isolation === "worktree" && ownedEnv !== undefined,
-        withinTaskCompactionEnabled: (spec.compaction?.enabled ?? true) && (spec.compaction?.withinTask ?? true),
+        withinTaskCompactionEnabled: compactionEnabled(spec.compaction?.enabled, input.contextOverlay) && (spec.compaction?.withinTask ?? true),
         isSubagent: delegation.isNonForkChild,
     };
     const userSystemPrompt = spec.systemPrompt ?? resolvedRole.systemPrompt ?? internals?.defaultSystemPrompt;