@sema-agent/core 7.17.6 → 7.18.0

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

@@ -1,13 +1,14 @@
 import { bindPeerLaneDrain } from "../../agents/peer-session-drain.js";
 import { resolveCheckpointStore } from "../checkpoint-store.js";
 import { createHookEnvCapabilities, mintHookInvocationIdentity } from "../hooks.js";
+import { wiredHookEntries } from "../hook-seats.js";
 import { isRemoteExecutionEnv, missingRestoreSurface } from "../remote-env.js";
 import { isVolatileOffloadStore } from "../tool-result-store.js";
 import { durableMandateSourceOf, isLiveApproverSeat } from "../tool-policy.js";
 import { deliverEngineNotice } from "../types.js";
 import { inlineUntrusted } from "../untrusted-text.js";
 import { GLOBAL_USAGE_KEY, usageRetryAfterMs, windowsGovernCost } from "../usage-window-store.js";
-import { countElicitOptIns, deriveWiringManifest, resolveAskSeamForm, resolveDeclaredDurability, resolveElicitSeam, resolveQuestionSeam, resolveSubagentTranscriptTier } from "../wiring-manifest.js";
+import { LSP_CONTRACT_ID, countElicitOptIns, deriveLspSeam, deriveWiringManifest, resolveAskSeamForm, resolveDeclaredDurability, resolveElicitSeam, resolveQuestionSeam, resolveSubagentTranscriptTier } from "../wiring-manifest.js";
 import { DEFAULT_IRREVERSIBLE_SCOPE } from "./checkpoint-scope.js";
 export function mcpManifestEntries(entries, statuses) {
     return (entries ?? []).map((entry) => {
@@ -110,7 +111,7 @@ function announceDurableGateUnavailable(args) {
     });
 }
 export function prepareWiringManifest(input) {
-    const { spec, deps, internals, resume, sessionId, runId, hostTaskId, taskScope, hooks, preToolUseObservational, policyLayers, effectivePolicy, mcp, irreversibleTools, egressTools, toolEffects, ownedEnv, executionEnv, offloadStore, onceLedger, usageWindows, envLifetimeSuspendAt, runtimeCaps, resolvedInteractionPosture, durableQuestionFace, liveQuestionFace, checkpointStore, sessions, modelGateManifest, autoModeArmReason, lockedPreflight, peerLaneRefs, peerLaneActive, harness, pausedRef, frozenOnAsk, liveInheritedGate, delegation, toolRoster } = input;
+    const { spec, deps, internals, resume, sessionId, runId, hostTaskId, taskScope, hooks, preToolUseObservational, policyLayers, effectivePolicy, mcp, irreversibleTools, egressTools, toolEffects, ownedEnv, executionEnv, offloadStore, onceLedger, usageWindows, envLifetimeSuspendAt, runtimeCaps, resolvedInteractionPosture, durableQuestionFace, liveQuestionFace, checkpointStore, sessions, modelGateManifest, autoModeArmReason, lockedPreflight, peerLaneRefs, peerLaneActive, harness, pausedRef, frozenOnAsk, liveInheritedGate, delegation, toolRoster, lspManagerWired, 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));
@@ -204,6 +205,8 @@ export function prepareWiringManifest(input) {
         autoMode: { ...autoModeArmReason },
         mcp: mcpManifestEntries(lockedPreflight.mcp, mcp.statuses),
         tools: toolRoster,
+        hooks: wiredHookEntries(hooks, spec.hooks !== undefined ? "spec" : "deps", preToolUseObservational),
+        ...(lspManagerWired ? { lsp: deriveLspSeam(toolRoster.entries.some((e) => e.contract.contractId === LSP_CONTRACT_ID), lspDiagnosticsLive) } : {}),
     });
     peerLaneRefs.askEffective = wiringManifest.ask.effective;
     if (peerLaneActive && internals?.onTaskNotification !== undefined) {

package/dist/core/runner/resume-checkpoint-screen.js

@@ -38,6 +38,13 @@ export function resumeCheckpointScreen(input) {
                 ? `a v${checkpointVersionOf(cp)} checkpoint must carry a well-formed read-face section (state.readFace) — this row's is missing or malformed; refusing to resume a damaged read-face row (corruption / downgrade guard), the checkpoint stays pending`
                 : `a v${checkpointVersionOf(cp)} checkpoint carries a read-face section no release of that version ever minted — refusing to honor a fabricated read-face state (corruption / forgery guard), the checkpoint stays pending`, { reason: checkpointVersionOf(cp) >= FACE_CHECKPOINT_VERSION ? "read_face_damaged" : "read_face_forged" });
         }
+        const writeFaceSectionRaw = cp.state.writeFace;
+        if (writeFaceSectionRaw !== undefined) {
+            const c = typeof writeFaceSectionRaw === "object" && writeFaceSectionRaw !== null ? writeFaceSectionRaw : undefined;
+            if (c === undefined || !(c.face === "open" || c.face === "roots")) {
+                throw new CheckpointError("checkpoint.invalid_outcome", `this checkpoint carries a write-face section (state.writeFace) that is not well-formed — refusing to resume a damaged write-face row (corruption guard), the checkpoint stays pending`, { reason: "write_face_damaged" });
+            }
+        }
     }
     if (realApprovalOrgFact(preCasGateBit) !== undefined && runner.deps.permissionRuleStore?.partitions.org !== true) {
         throw new CheckpointError("checkpoint.unsupported_version", `this checkpoint's approval was minted under organization governance (org ${String(realApprovalOrgFact(preCasGateBit))}, routed as ${String(preCasGateBit?.origin)}) and this worker has no org adjudication wiring (its permission-rule store carries no org partition) — a governed approval may only be redeemed where governance can be enforced; the checkpoint stays pending, resume it on an org-wired worker`, { reason: "governed_unwired" });

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

@@ -10,7 +10,7 @@ import { hasVerifiableStructureSignal } from "./grounding-signal.js";
 import { batchResponseDigest, toolEndBodyFrom } from "./tool-end-body.js";
 export function createHarnessHandlers(input) {
     const { prepared, stats, rs, deps } = input;
-    const { spec, queue, internals, ident, parentToolCallId, subagentName, pushContent, emitCommitted, startedToolCallIds, toolStartAt, writeFamilyOf, toolLabels, postToolBatchHook, batchArgs } = deps;
+    const { spec, queue, internals, ident, parentToolCallId, subagentName, pushContent, emitCommitted, startedToolCallIds, toolStartAt, toolProgress, writeFamilyOf, toolLabels, postToolBatchHook, batchArgs } = deps;
     const internalsNotifier = createSafeNotifier({
         onError: (f) => console.warn(`[sema-core] ${f.site}: run-internals activity sink threw (contained; further failures counted, not re-disclosed): ${f.error.message}`),
     });
@@ -186,6 +186,7 @@ export function createHarnessHandlers(input) {
         const startAt = Date.now();
         toolStartAt.set(event.toolCallId, startAt);
         startedToolCallIds.add(event.toolCallId);
+        toolProgress.noteStart(event.toolCallId, event.toolName);
         batchArgs?.set(event.toolCallId, event.args);
         stats.toolCalls += 1;
         if (spec.finalVerification === true && !(rs.counters.finalVerifyInjections === 0 ? rs.counters.groundingSignalPreR9 : rs.counters.groundingSignalPostR9) && hasVerifiableStructureSignal(event.args)) {
@@ -208,6 +209,7 @@ export function createHarnessHandlers(input) {
     const onToolEnd = (event) => {
         const toolStarted = toolStartAt.get(event.toolCallId);
         toolStartAt.delete(event.toolCallId);
+        toolProgress.noteEnd(event.toolCallId);
         const toolNow = Date.now();
         if (!rs.counters.wroteThisRun && (prepared.toolEffects.get(event.toolName) ?? "write") !== "read") {
             rs.counters.wroteThisRun = true;
@@ -320,6 +322,7 @@ export function createHarnessHandlers(input) {
         rs.budget.callOutputChars = 0;
         rs.budget.lastStreamBudgetCheck = 0;
         toolStartAt.clear();
+        toolProgress.clear();
         if (rs.limits.effectiveMaxTurns !== undefined && rs.limits.effectiveMaxTurns > 0 && stats.turns >= rs.limits.effectiveMaxTurns) {
             rs.limits.turnsExceeded = true;
             if (prepared.suspendForResource === undefined) {

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

@@ -16,6 +16,7 @@ export function runIdentityWiring(input) {
     notificationLane.ident = ident;
     queue.push({ type: "wiring_manifest", manifest: prepared.wiringManifest, ...ident() });
     prepared.toolRosterDeltas.subscribe((delta) => queue.push({ type: "tool_roster_delta", delta, ...ident() }));
+    prepared.toolDisclosure?.subscribe((snapshot) => queue.push({ type: "tool_disclosure", ...snapshot, ...ident() }));
     const delegationLifecycleNotifier = createSafeNotifier({
         onError: (f) => console.warn(`[sema-core] ${f.site}: delegation-lifecycle observer threw (contained; further failures counted, not re-disclosed): ${f.error.message}`),
     });
@@ -44,7 +45,7 @@ export function runIdentityWiring(input) {
     let userInputLostAtEnd = false;
     prepared.harness.onUndrainedUserInputs = (counts) => {
         userInputLostAtEnd = counts.steer + counts.followUp > 0;
-        if (prepared.pausedRef.current !== undefined) {
+        if (prepared.pausedRef.current !== undefined || prepared.undeliveredContinuationRef.current.parkedSteers.length > 0) {
             undrainedUserAtEnd = counts;
             return;
         }
@@ -53,9 +54,12 @@ export function runIdentityWiring(input) {
         }
     };
     prepared.harness.onEngineNoteConsumed = (p) => {
-        const peer = p?.peer;
+        const payload = p;
+        const peer = payload?.peer;
         if (peer !== undefined && Array.isArray(peer.hopChain))
             peerInboundChainRef.current = [...peer.hopChain];
+        if (notificationLane.sessionId !== undefined && typeof payload?.task_id === "string" && typeof payload.status === "string")
+            pendingSessionNotifications.markDelivered(notificationLane.sessionId, taskNotificationDedupKey(payload));
     };
     if (notifyRef)
         notifyRef.inject = injectTaskNotification;

package/dist/core/runner/run-leg.d.ts

@@ -38,6 +38,8 @@ export interface RunLegInput<R> {
     resume: ResumeRun | undefined;
     /** borrowed-mutable — the run's mutable state: the limit flags and the platform terminal are written by the entrance gates. */
     rs: RunState;
+    /** borrowed-readonly — the trusted spawn-side fact the rejection boundary reads (a delegated child's bare refusal halts no batch). */
+    isDelegatedChild: boolean;
     /** borrowed-readonly — the API-boundary attribution snapshot of the objective's actor (the objective leg's speaker envelope). */
     entryActor: ActorAssertion | undefined;
     /** borrowed-readonly — the effective walltime window (undefined = unbounded): `<= 0` refuses the first turn. */

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

@@ -16,18 +16,19 @@ import { deliverEngineNotice } from "../types.js";
 import { delimitUntrusted, inlineUntrusted, REVIEWER_NOTE_MAX_BODY, sanitizeUntrustedText } from "../untrusted-text.js";
 import { errorCodeOf } from "./assemble-result.js";
 import { DEFAULT_PRECALL_OUTPUT_TOKENS, platformLimitTerminal } from "./clock-and-limits.js";
-import { deepJsonEqual, DEFERRED_REISSUE, resumeContinuation } from "./decide-continuation.js";
+import { deepJsonEqual, resumeContinuation } from "./decide-continuation.js";
 import { settleExecutionRecord } from "./execution-record.js";
 import { mintGateOutcome } from "./gate-exit.js";
 import { resolveGitLegDelivery, wrapGitFrame } from "./git-leg-delivery.js";
 import { GIT_STATUS_ECHO_PREVIEW } from "./git-status-frame.js";
 import { toImageContent } from "./image.js";
+import { maybeHumanRejectionHalt } from "./prepare-gate-stations.js";
 import { nextHumanInputSeq } from "./steer-admission.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
 import { toolEndBodyFrom, toolResultMsg } from "./tool-end-body.js";
 import { attachmentEnvelopeTags, commitAgentListing, commitSkillsListing, reduceToolEnd, renderAgentListingDelta, renderOrphanedBackgroundTasks, renderSkillsListingDelta, stampWriteAnchor } from "./turn-attachments.js";
 export async function runLeg(input) {
-    const { spec, queue, prepared, resume, rs, entryActor, effectiveTimeoutMs, timeout, pushContent, ident, emitCommitted, writeFamilyOf, startedToolCallIds, announceWorkspaceMove, withBrainSinks, flushGitMirror, loopLatch, notificationLane, unsubscribeTaskNotifications, unsubGitRetry, unsubBoundary, unsub, runner, next } = input;
+    const { spec, queue, prepared, resume, rs, isDelegatedChild, entryActor, effectiveTimeoutMs, timeout, pushContent, ident, emitCommitted, writeFamilyOf, startedToolCallIds, announceWorkspaceMove, withBrainSinks, flushGitMirror, loopLatch, notificationLane, unsubscribeTaskNotifications, unsubGitRetry, unsubBoundary, unsub, runner, next } = input;
     let final;
     let threw;
     let abortedLive = false;
@@ -101,11 +102,12 @@ export async function runLeg(input) {
             else {
                 let continuation = resumeContinuation(resume, prepared.reminderMark);
                 const bgSnapshot = resume.cp.state.runningBackgroundTasks;
+                let orphanTasks = [];
                 if (bgSnapshot !== undefined && bgSnapshot.length > 0) {
                     const alive = new Set(prepared.listBackgroundTasks().map((t) => t.id));
-                    const orphans = bgSnapshot.filter((t) => !alive.has(t.id));
-                    if (orphans.length > 0) {
-                        continuation += "\n\n" + formatHookFeedback(renderOrphanedBackgroundTasks(orphans), prepared.reminderMark);
+                    orphanTasks = bgSnapshot.filter((t) => !alive.has(t.id));
+                    if (orphanTasks.length > 0) {
+                        continuation += "\n\n" + formatHookFeedback(renderOrphanedBackgroundTasks(orphanTasks), prepared.reminderMark);
                     }
                 }
                 let gitResumeDelivered;
@@ -128,10 +130,13 @@ export async function runLeg(input) {
                     }
                 }
                 const engineSegments = continuation.length > 0 ? [{ start: 0, end: continuation.length }] : [];
+                const parkedSteers = readPendingSteerQueue(resume.cp.state);
                 const resumeFrames = [
-                    ...readPendingSteerQueue(resume.cp.state).map((entry) => ({ entry, source: "steer" })),
+                    ...parkedSteers.map((entry) => ({ entry, source: "steer" })),
                     ...(resume.wakeMessage !== undefined ? [{ entry: resume.wakeMessage, source: "wake" }] : []),
                 ];
+                const appliedEvents = [];
+                const withheldSteerIds = new Set();
                 for (const { entry: steer, source } of resumeFrames) {
                     if (source === "wake" && resume.wakeMessageHookContext !== undefined) {
                         const hookStart = continuation.length;
@@ -166,6 +171,8 @@ export async function runLeg(input) {
                                 outcome = { blocked: `the screen crashed (${inlineUntrusted(err.message)}; fail-closed)` };
                             }
                             if ("blocked" in outcome) {
+                                if (steer.inputId !== undefined)
+                                    withheldSteerIds.add(steer.inputId);
                                 deliverEngineNotice(runner.deps.onNotice, {
                                     code: "steering.parked_input_blocked",
                                     message: "a parked steering input was withheld by the deployment's userPromptSubmit screen when this resume redelivered it: " +
@@ -207,7 +214,7 @@ export async function runLeg(input) {
                             (steer.trusted ? formatHookFeedback(projected, prepared.reminderMark) : delimitUntrusted("supervisor steering message", projected));
                     if (steer.trusted)
                         engineSegments.push({ start, end: continuation.length });
-                    queue.push({
+                    appliedEvents.push({
                         ...buildHumanInputEvent({
                             carrier: source,
                             source,
@@ -236,7 +243,22 @@ export async function runLeg(input) {
                         },
                     };
                 }
-                final = await withBrainSinks(() => prepared.harness.prompt(continuation, { engineSegments }));
+                const pending = resume.cp.pendingAction;
+                const rejectionHalt = pending.kind === "tool_approval" && resume.outcome.gate === "policy_ask"
+                    ? maybeHumanRejectionHalt({ gate: resume.outcome.gateOutcome, isDelegatedChild, toolName: pending.toolName, toolCallId: pending.toolCallId })
+                    : undefined;
+                if (rejectionHalt !== undefined && pending.kind === "tool_approval")
+                    prepared.batchHaltRef.current = { rejectedToolCallId: pending.toolCallId };
+                prepared.undeliveredContinuationRef.current = { parkedSteers: resumeFrames.map(({ entry }) => entry).filter((e) => !withheldSteerIds.has(e.inputId)), orphanTasks };
+                final = await withBrainSinks(() => prepared.harness.prompt(continuation, {
+                    engineSegments,
+                    settleUnansweredToolCalls: rejectionHalt !== undefined ? { halt: rejectionHalt } : {},
+                    onDelivered: () => {
+                        prepared.undeliveredContinuationRef.current = { parkedSteers: [], orphanTasks: [] };
+                        for (const e of appliedEvents)
+                            queue.push(e);
+                    },
+                }));
                 await flushGitMirror();
                 if (prepared.gitStatusRef.announced?.pending === true)
                     await prepared.gitStatusRef.reassert?.();
@@ -452,6 +474,7 @@ export async function runLeg(input) {
     finally {
         timeout.clear();
         prepared.lspDiagnostics?.registry.releaseRun(prepared.lspDiagnostics.runIdent);
+        prepared.toolProgressRef.current?.clear();
         prepared.abortController.abort();
         prepared.releaseSignal();
         strandedHumanAnswers = prepared.settleContentAskBindings();
@@ -463,6 +486,7 @@ export async function runLeg(input) {
         notificationLane.live = false;
         unsubscribeTaskNotifications();
         prepared.toolRosterDeltas.unsubscribe();
+        prepared.toolDisclosure?.unsubscribe();
         unsubGitRetry();
         unsubBoundary();
         unsub();
@@ -491,39 +515,7 @@ async function applyResumeDecision(runner, prepared, resume, emit, emitCommitted
         e.code = "resume.tool_contract_mismatch";
         throw e;
     }
-    const completed = new Set(pendingAction.completedCallIds);
-    const deferredIds = pendingAction.batchToolCallIds.filter((id) => id !== pendingAction.toolCallId && !completed.has(id));
-    const names = new Map();
-    const deferredArgs = new Map();
-    if (deferredIds.length > 0) {
-        const { messages } = await prepared.session.buildContext();
-        for (const m of messages) {
-            if (m.role === "assistant") {
-                for (const c of m.content) {
-                    if (c.type === "toolCall") {
-                        names.set(c.id, c.name);
-                        deferredArgs.set(c.id, c.arguments);
-                    }
-                }
-            }
-        }
-    }
-    for (const id of pendingAction.batchToolCallIds) {
-        if (id === pendingAction.toolCallId) {
-            await resolvePendingCall(runner, prepared, resume, emit, emitCommitted, onResolvedToolSuccess, onExecuteStart);
-        }
-        else if (!completed.has(id)) {
-            const name = names.get(id) ?? "unknown";
-            const displayLabel = (() => {
-                const l = prepared.tools.find((t) => t.name === name)?.label;
-                return l !== undefined && l !== name ? { label: l } : {};
-            })();
-            emit({ type: "tool_start", toolCallId: id, toolName: name, ...displayLabel, args: deferredArgs.get(id) ?? {} });
-            emit({ type: "tool_end", toolCallId: id, toolName: name, ...displayLabel, isError: true, ...toolEndBodyFrom({ content: formatHookFeedback(DEFERRED_REISSUE, prepared.reminderMark) }, true, prepared.structuredProjector) });
-            const eid = await prepared.session.appendMessage(toolResultMsg(id, name, formatHookFeedback(DEFERRED_REISSUE, prepared.reminderMark), true));
-            emitCommitted(eid, "toolResult", id);
-        }
-    }
+    await resolvePendingCall(runner, prepared, resume, emit, emitCommitted, onResolvedToolSuccess, onExecuteStart);
 }
 async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted, onResolvedToolSuccess, onExecuteStart) {
     const { pendingAction } = resume.cp;
@@ -538,6 +530,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     const pendingLabel = (() => { const l = prepared.tools.find((t) => t.name === pendingAction.toolName)?.label; return l !== undefined && l !== pendingAction.toolName ? { label: l } : {}; })();
     emit({ type: "tool_start", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, ...pendingLabel, args: resolvedArgs });
     const settleEnd = async (isError, result, gate = decidedGate) => {
+        prepared.toolProgressRef.current?.noteEnd(pendingAction.toolCallId);
         emit({ type: "tool_end", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, ...pendingLabel, isError, ...toolEndBodyFrom(result, isError, prepared.structuredProjector, gate) });
         const word = await resume.recordExecutionOutcome(gate);
         settleExecutionRecord(runner.deps.onNotice, word, { toolName: pendingAction.toolName, gate, sessionId: prepared.sessionId, runId: prepared.runId, scope: resume.cp.scope, ...(resume.cp.checkpointId !== undefined ? { checkpointId: resume.cp.checkpointId } : {}) });
@@ -676,6 +669,7 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     }
     const args = resolvedArgs;
     onExecuteStart?.(pendingAction.toolCallId);
+    prepared.toolProgressRef.current?.noteStart(pendingAction.toolCallId, pendingAction.toolName);
     prepared.suspendProgressRef.executedApproved = true;
     let res;
     try {

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

@@ -1,6 +1,6 @@
 import { createPeerInboundChainRef, createPeerSelfRef } from "../../agents/peer-admission.js";
 import { boundInputHashOf } from "../canonical-json.js";
-import { isDelegatedAgentTerminal, isTerminalTaskNotification, renderTaskNotificationXml, SystemInjectionQueue, taskNotificationDedupKey } from "../task-notification.js";
+import { createLiveNotificationLane, isDelegatedAgentTerminal, isTerminalTaskNotification, renderTaskNotificationXml, routeOrParkNotification, SystemInjectionQueue } from "../task-notification.js";
 import { ToolDetachHub } from "../tool-detach.js";
 import { pendingContentAskCallId } from "./decide-continuation.js";
 export async function runNotificationLane(input) {
@@ -32,9 +32,13 @@ export async function runNotificationLane(input) {
     let notificationLaneLive = true;
     let notificationSessionId;
     let descendantAnchorDisclosed = false;
-    const parkTaskNotification = (payload, priority) => {
-        if (notificationSessionId !== undefined)
-            pendingSessionNotifications.pend(notificationSessionId, payload, priority);
+    const parkTaskNotification = (payload, priority, onDisposition) => {
+        laneSeat.handOff(payload);
+        const ownSession = notificationSessionId;
+        if (ownSession !== undefined)
+            routeOrParkNotification(pendingSessionNotifications, ownSession, payload, priority, onDisposition);
+        else
+            onDisposition?.("parked");
         if (!isDelegatedAgentTerminal(payload))
             return;
         const uplink = internals?.parentNotify;
@@ -49,12 +53,12 @@ export async function runNotificationLane(input) {
         }
         const rootAnchor = internals?.rootSessionId;
         if (rootAnchor !== undefined && rootAnchor !== notificationSessionId) {
-            pendingSessionNotifications.pend(rootAnchor, payload, priority);
+            routeOrParkNotification(pendingSessionNotifications, rootAnchor, payload, priority);
             return;
         }
         if (internals?.parentSessionId !== undefined && !descendantAnchorDisclosed) {
             descendantAnchorDisclosed = true;
-            runner.deps.onError?.(new Error(`background-agent terminal ${payload.task_id} parked on this run's own session — the delegation tree's root session is not reachable from this run (no uplink, no root anchor)`), { phase: "degraded", sessionId: notificationSessionId ?? "", classification: "descendant-terminal-unrouted" });
+            runner.deps.onError?.(new Error(`background-agent terminal ${payload.task_id} stayed on this run's own session — the delegation tree's root session is not reachable from this run (no uplink, no root anchor)`), { phase: "degraded", sessionId: notificationSessionId ?? "", classification: "descendant-terminal-unrouted" });
         }
     };
     const unsubscribeTaskNotifications = taskNotificationQueue.subscribe((item) => {
@@ -70,34 +74,33 @@ export async function runNotificationLane(input) {
                 ? notificationHarness.followUp(xml, noteOptions)
                 : notificationHarness.steer(xml, { ...noteOptions, ...(item.priority === "now" ? { immediate: true } : {}) });
             void deliver.then(() => item.onDisposition?.("queued"), () => {
-                parkTaskNotification(item.payload, item.priority);
-                item.onDisposition?.("parked");
+                parkTaskNotification(item.payload, item.priority, item.onDisposition);
             });
         }
         else {
-            parkTaskNotification(item.payload, item.priority);
-            item.onDisposition?.("parked");
+            parkTaskNotification(item.payload, item.priority, item.onDisposition);
         }
     });
     const upstreamTaskNotification = internals?.onTaskNotification;
     const deliveredAtTurnOpen = new Set();
+    const laneSeat = createLiveNotificationLane({
+        queue: taskNotificationQueue,
+        canTakeNow: () => notificationLaneLive && notificationHarness?.acceptsInjections === true,
+        isLive: () => notificationLaneLive,
+        alreadyDelivered: (key) => deliveredAtTurnOpen.has(key),
+    });
+    const takeOnThisLane = laneSeat.take;
+    const takeAsDestination = laneSeat.takeAsDestination;
     const injectTaskNotification = (notification, opts) => {
-        if (deliveredAtTurnOpen.has(taskNotificationDedupKey(notification)))
-            return Promise.resolve("dropped_duplicate");
-        if (!notificationLaneLive) {
-            parkTaskNotification(notification, opts?.priority ?? "later");
-            return Promise.resolve("parked");
-        }
+        const priority = opts?.priority ?? "later";
         return new Promise((resolve) => {
-            const accepted = taskNotificationQueue.enqueue({
-                kind: "task_notification",
-                priority: opts?.priority ?? "later",
-                dedupKey: taskNotificationDedupKey(notification),
-                payload: notification,
-                onDisposition: resolve,
-            });
-            if (!accepted)
+            const own = takeOnThisLane(notification, priority, resolve);
+            if (own === "duplicate")
+                resolve("dropped_duplicate");
+            else if (own === "pending")
                 resolve("queued");
+            else if (own === "unavailable")
+                parkTaskNotification(notification, priority, resolve);
         });
     };
     const peerSelfRef = internals?.peerSelfRef ?? createPeerSelfRef(internals?.registryScope ?? spec.principal ?? "default");
@@ -120,9 +123,34 @@ export async function runNotificationLane(input) {
     }, self, taskIdRef);
     const notificationLane = {
         get harness() { return notificationHarness; }, set harness(h) { notificationHarness = h; },
-        get sessionId() { return notificationSessionId; }, set sessionId(s) { notificationSessionId = s; },
+        get sessionId() { return notificationSessionId; },
+        set sessionId(s) {
+            if (notificationSessionId !== undefined)
+                pendingSessionNotifications.liveLanes.unregister(notificationSessionId, takeAsDestination);
+            notificationSessionId = s;
+            if (s !== undefined && notificationLaneLive)
+                pendingSessionNotifications.liveLanes.register(s, takeAsDestination);
+        },
         get ident() { return notificationIdent; }, set ident(f) { notificationIdent = f; },
-        get live() { return notificationLaneLive; }, set live(v) { notificationLaneLive = v; },
+        get live() { return notificationLaneLive; },
+        set live(v) {
+            notificationLaneLive = v;
+            if (notificationSessionId === undefined)
+                return;
+            if (v) {
+                pendingSessionNotifications.liveLanes.register(notificationSessionId, takeAsDestination);
+            }
+            else {
+                pendingSessionNotifications.liveLanes.unregister(notificationSessionId, takeAsDestination);
+                laneSeat.release();
+            }
+        },
     };
-    return await next({ prepared, injectTaskNotification, deliveredAtTurnOpen, peerInboundChainRef, modelCatalog, notificationLane, unsubscribeTaskNotifications });
+    try {
+        return await next({ prepared, injectTaskNotification, deliveredAtTurnOpen, peerInboundChainRef, modelCatalog, notificationLane, unsubscribeTaskNotifications });
+    }
+    finally {
+        if (notificationSessionId !== undefined)
+            pendingSessionNotifications.liveLanes.unregister(notificationSessionId, takeAsDestination);
+    }
 }

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

@@ -107,6 +107,7 @@ export async function runSettleAndTeardown(input) {
             strandedHumanAnswers,
             remoteEnvFailures: prepared.remoteEnvFailures,
             effectiveReadFace: prepared.effectiveReadFace,
+            effectiveWriteFace: prepared.effectiveWriteFace,
             effectiveReadDenyPatterns: prepared.effectiveReadDenyPatterns,
             effectiveMemoryScopes: prepared.effectiveMemoryScopes,
             effectiveReasoning: reasoningResolution.current,

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

@@ -3,7 +3,7 @@ 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 { deliverEngineNotice, undrainedUserInputNotices } from "../types.js";
+import { deliverEngineNotice, owedUserInputCounts, undrainedUserInputNotices } from "../types.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";
@@ -14,7 +14,7 @@ import { reconciledToolEndBody } from "./tool-end-body.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;
     let { threw } = input;
-    const settled = answerSettled(final, userInputLostAtEnd.current || prepared.workCutRef.continuation || prepared.workCutRef.abortedBeforeTurnEnd);
+    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) {
         threw = prepared.brainCallGuardrailRef.timedOut;
     }
@@ -77,16 +77,24 @@ export async function runTerminalAdoption(input) {
         }
     }
     let migratedParked = { steer: 0, followUp: 0 };
+    let carriedContinuation = 0;
     if (committedPause !== undefined && runner.deps.checkpointStore !== undefined) {
         const parkToken = committedPause.cause.token;
         const parkScope = committedPause.scope;
         const store = runner.deps.checkpointStore;
         const carried = [];
-        for (const record of prepared.harness.readParkableUserInputs()) {
+        const owed = [
+            ...prepared.undeliveredContinuationRef.current.parkedSteers.map(({ seq: _seq, ...input }) => ({ input })),
+            ...prepared.harness.readParkableUserInputs().map((record) => ({ input: record, live: record })),
+        ];
+        for (const { input, live } of owed) {
             try {
-                if (!(await store.setPendingSteer(parkToken, parkScope, record)))
+                if (!(await store.setPendingSteer(parkToken, parkScope, input)))
                     break;
-                carried.push(record);
+                if (live !== undefined)
+                    carried.push(live);
+                else
+                    carriedContinuation += 1;
             }
             catch (parkErr) {
                 runner.deps.onError?.(parkErr instanceof Error ? parkErr : new Error(String(parkErr)), {
@@ -101,14 +109,9 @@ export async function runTerminalAdoption(input) {
         }
         migratedParked = prepared.harness.dropParkedUserInputs(carried);
     }
-    if (undrainedUserAtEnd.current !== undefined) {
-        const remaining = {
-            steer: Math.max(0, undrainedUserAtEnd.current.steer - migratedParked.steer),
-            followUp: Math.max(0, undrainedUserAtEnd.current.followUp - migratedParked.followUp),
-        };
-        for (const notice of undrainedUserInputNotices(remaining, spec.taskId ?? prepared.sessionId, prepared.sessionId, prepared.runId)) {
-            deliverEngineNotice(runner.deps.onNotice, notice);
-        }
+    const owed = owedUserInputCounts(undrainedUserAtEnd.current, migratedParked, { frames: prepared.undeliveredContinuationRef.current.parkedSteers, carried: carriedContinuation, rowMayReturn: committedPause === undefined && !prepared.suspendProgressRef.executedApproved });
+    for (const notice of undrainedUserInputNotices(owed, spec.taskId ?? prepared.sessionId, prepared.sessionId, prepared.runId)) {
+        deliverEngineNotice(runner.deps.onNotice, notice);
     }
     if (rs.attach.attachState?.postCompactPending === true && (rs.attach.attachmentsCfg?.backgroundTasks ?? eventDefaultOn("background_tasks")) === true) {
         emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.announce_dropped", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));

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

@@ -15,6 +15,7 @@ import { awaitChargeWithSlowDisclosure, discloseUnevaluableWindow, ENV_DUE_GOVER
 import { gitRestateOption } from "./git-leg-delivery.js";
 import { COMPACTION_FREED_EPSILON, COMPACTION_REGROWTH_FACTOR, MAX_CONSECUTIVE_COMPACTION_FAILURES } from "./compaction-knobs.js";
 import { compactionHookOptions, recordCompactionReuse, seamCCompactionOptions } from "./compaction-seams.js";
+import { contextUsageSections } from "../../prompt-assembly/section-usage.js";
 const BATCH_CONTEXT_MIN_KEEP_BYTES = 160;
 const BATCH_TRUNCATION_MARKER = "\n…[truncated]";
 export function createTurnBoundary(input) {
@@ -580,7 +581,8 @@ export function createTurnBoundary(input) {
             }
             rs.counters.trimForceBackoff = nextTrimForceBackoff(rs.counters.trimForceBackoff, comp, trimPressure);
             if (comp.contextUsage) {
-                queue.push({ type: "context_usage", ...comp.contextUsage, ...ident() });
+                const sections = contextUsageSections(prepared.promptManifest.sections);
+                queue.push({ type: "context_usage", ...comp.contextUsage, ...(sections !== undefined ? { sections } : {}), ...ident() });
             }
             if (comp.unevaluableWindow) {
                 discloseUnevaluableWindow(comp.unevaluableWindow, prepared, rs.telemetry.tracer, rs.telemetry.taskId, runnerHooks.onError);

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

@@ -91,14 +91,14 @@ export declare class Runner implements RunnerSelfSeat {
     /**
      * Hot-swap the deployment seats a running Runner may change without a restart — the ONE door for every
      * hot-swappable seat ({@link SWAPPABLE_DEP_SEATS}: the model catalog generation `models` + its `tiers`
-     * bindings, and the deployment's read-face declaration `readFace`), and the ONLY sanctioned way to
+     * bindings, and the deployment's two containment-face declarations `readFace` / `writeFace`), and the ONLY sanctioned way to
      * change any of them after construction. It replaces the former `swapModels` verb (retired, no alias):
      * one verb per seat restated the same laws with a list of verbs as the only record of what is swappable.
      *
      * The laws, stated once (see the vocabulary module for the seat-by-seat meaning):
      * - **Screened first, written once — atomic.** The candidate is screened whole
      *   ({@link screenSwappableDeps}: the key set is the closed one, at least one seat, `tiers` rides with
-     *   `models`, each seat's own value gate — `readFace` through the very `assertReadFaceValue` every
+     *   `models`, each seat's own value gate — both face seats through the very `assertContainmentFaceValue` every
      *   prepare door applies) and the catalog is tier-expanded on the candidate (an illegal binding throws
      *   exactly like the constructor's boot error) BEFORE the deps object is replaced. On any throw the
      *   current deps stay in force, byte-identical.
@@ -108,14 +108,15 @@ export declare class Runner implements RunnerSelfSeat {
      *   redirects never re-route or re-price a task mid-run; a read-face change never re-fences a mounted
      *   band; the divergence window is exactly the in-flight legs' lifetime, by design.
      * - **Presence is the instruction.** A key present on the candidate is replaced (an explicit
-     *   `undefined` clears an optional seat: `tiers: undefined` ⇒ no bindings, `readFace: undefined` ⇒ the
+     *   `undefined` clears an optional seat: `tiers: undefined` ⇒ no bindings, a face seat `undefined` ⇒ the
      *   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
-     *   `config.read_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.
+     *   `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.
      */
     swapDeps(next: SwappableDeps): void;
     /** one-shot brain-routed utility query (see {@link runSideQuery} for the full contract):