@sema-agent/core 7.17.7 → 7.19.0

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

@@ -16,18 +16,20 @@ 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";
+import { announceSkillListingTruncation } from "../skill-listing-budget.js";
+import { attachmentEnvelopeTags, commitAgentListing, commitSkillsListing, reduceToolEnd, renderAgentListingDelta, renderOrphanedBackgroundTasks, renderSkillsListingFrame, 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 +103,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 +131,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 +172,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 +215,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 +244,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?.();
@@ -309,6 +332,7 @@ export async function runLeg(input) {
                 }
             }
             const firstFrames = [];
+            let skillsListingCost;
             if (rs.attach.attachState !== undefined) {
                 const attach = rs.attach.attachState;
                 if (rs.attach.agentListingOn && prepared.agentListing !== undefined) {
@@ -329,14 +353,15 @@ export async function runLeg(input) {
                 }
                 if (rs.attach.skillsListingOn && prepared.skillsListing !== undefined) {
                     const listing = prepared.skillsListing;
-                    const body = renderSkillsListingDelta(attach, listing.entries);
-                    if (body !== undefined) {
+                    const frame = renderSkillsListingFrame(attach, listing.entries, listing.budget);
+                    if (frame !== undefined) {
                         firstFrames.push({
                             source: "skills_listing",
-                            body,
+                            body: frame.text,
                             commit: () => {
                                 commitSkillsListing(attach, listing.entries);
                                 prepared.announcedListingsRef.skills = listing.entries.map((e) => e.name);
+                                skillsListingCost = { total: frame.listed, nameOnly: frame.nameOnly, dropped: frame.dropped, budget: listing.budget };
                             },
                         });
                     }
@@ -410,6 +435,9 @@ export async function runLeg(input) {
                 rs.attach.attachmentsInjected += firstFrames.length;
                 if (firstFrames.length > 0 && prepared.announcedSnapshotRecovered)
                     await prepared.session.appendAnnouncedListing(prepared.announcedListingsRef).catch(() => undefined);
+                if (skillsListingCost !== undefined) {
+                    announceSkillListingTruncation(runner.deps.onNotice, { ...skillsListingCost, sessionId: prepared.sessionId });
+                }
                 const enginePrefixChars = effectiveObjective.length - projectedObjective.length;
                 queue.push({
                     ...buildHumanInputEvent({
@@ -452,6 +480,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 +492,7 @@ export async function runLeg(input) {
         notificationLane.live = false;
         unsubscribeTaskNotifications();
         prepared.toolRosterDeltas.unsubscribe();
+        prepared.toolDisclosure?.unsubscribe();
         unsubGitRetry();
         unsubBoundary();
         unsub();
@@ -491,39 +521,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 +536,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 +675,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

@@ -4,7 +4,8 @@ import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
 import { DEFAULT_COMPACTION_INSTRUCTIONS, isCompactionManualCancel, maybeCompact, 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, rebaseCadenceWindows, renderAgentListingDelta, renderMcpDroppedTools, renderMcpInstructionsDelta, selectMcpDroppedBatch, renderSkillsListingDelta, renderToolsDelta } from "./turn-attachments.js";
+import { ATTACHMENT_BYTE_CAP, CHANGED_FILES_MAX, TOTAL_TOKENS_REMINDER_DEFAULT_MODE, attachmentEnvelopeTags, clipToBytes, collectDateChange, collectDueAttachments, collectInstructionsChange, commitAgentListing, commitInstructionsChange, commitSkillsListing, rebaseCadenceWindows, renderAgentListingDelta, renderMcpDroppedTools, renderMcpInstructionsDelta, selectMcpDroppedBatch, renderSkillsListingFrame, renderToolsDelta } from "./turn-attachments.js";
+import { announceSkillListingTruncation } from "../skill-listing-budget.js";
 import { buildWorkingFileAttachments, centerAdoptionOption, contextInstructionFilesOption, emitInputTruncated, forkContextOption } from "./compaction-call-options.js";
 import { hookSeatExpiredError, runHookSeat } from "../hooks.js";
 import { sanitizeUntrustedText, SHELLED_BODY_ENVELOPE_TAGS } from "../untrusted-text.js";
@@ -15,6 +16,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) {
@@ -201,6 +203,7 @@ export function createTurnBoundary(input) {
         }
         let boundaryAttachmentBytes = 0;
         let attachmentsPayload;
+        let skillsListingCost;
         if ((rs.attach.dateState !== undefined ||
             rs.attach.instrState !== undefined ||
             rs.attach.sizeGuidelineState !== undefined ||
@@ -312,7 +315,9 @@ export function createTurnBoundary(input) {
                             ...(prepared.agentListing.models !== undefined ? { agentModels: prepared.agentListing.models } : {}),
                         }
                         : {}),
-                    ...(rs.attach.skillsListingOn && prepared.skillsListing !== undefined ? { skillsListing: prepared.skillsListing.entries } : {}),
+                    ...(rs.attach.skillsListingOn && prepared.skillsListing !== undefined
+                        ? { skillsListing: prepared.skillsListing.entries, skillsListingBudget: prepared.skillsListing.budget }
+                        : {}),
                     ...(mcpAdds !== undefined || mcpRemovals !== undefined
                         ? { mcpInstructions: { added: mcpAdds ?? [], removed: mcpRemovals ?? [] } }
                         : {}),
@@ -376,9 +381,10 @@ export function createTurnBoundary(input) {
                 }
                 if (rs.attach.skillsListingOn && prepared.skillsListing !== undefined && due.some((a) => a.source === "skills_listing")) {
                     const listing = prepared.skillsListing;
-                    const intactBody = renderSkillsListingDelta(rs.attach.attachState, listing.entries);
-                    if (intactBody !== undefined && due.some((a) => a.source === "skills_listing" && a.body === intactBody)) {
+                    const intact = renderSkillsListingFrame(rs.attach.attachState, listing.entries, listing.budget);
+                    if (intact !== undefined && due.some((a) => a.source === "skills_listing" && a.body === intact.text)) {
                         commitSkillsListing(rs.attach.attachState, listing.entries);
+                        skillsListingCost = { total: intact.listed, nameOnly: intact.nameOnly, dropped: intact.dropped, budget: listing.budget };
                         prepared.announcedListingsRef.skills = listing.entries.map((e) => e.name);
                         if (prepared.announcedSnapshotRecovered)
                             await prepared.session.appendAnnouncedListing(prepared.announcedListingsRef).catch(() => undefined);
@@ -473,6 +479,9 @@ export function createTurnBoundary(input) {
         if ((attachmentsPayload !== undefined || batchContextBlock !== undefined) && prepared.batchHaltRef.current === undefined) {
             const payload = attachmentsPayload !== undefined && batchContextBlock !== undefined ? `${attachmentsPayload}\n${batchContextBlock}` : (attachmentsPayload ?? batchContextBlock);
             void prepared.harness.steer(payload, { engineMinted: true }).catch(() => { });
+            if (skillsListingCost !== undefined) {
+                announceSkillListingTruncation(deps.runner.deps.onNotice, { ...skillsListingCost, sessionId: prepared.sessionId });
+            }
         }
         const forceManual = manualCompactRef.requested;
         if ((!withinTaskCompaction && !forceManual) ||
@@ -580,7 +589,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):

package/dist/core/runner/runtask.js

@@ -49,6 +49,7 @@ import { runAttachmentSeats } from "./run-attachment-seats.js";
 import { runToolMountFacts } from "./run-tool-mount-facts.js";
 import { runReasoningSeat } from "./run-reasoning-seat.js";
 import { runClockAndContent } from "./run-clock-and-content.js";
+import { createToolProgressLane } from "./tool-progress-lane.js";
 import { runBrainSinks } from "./run-brain-sinks.js";
 import { runCompactionMachinery } from "./run-compaction-machinery.js";
 import { runStopAndFinalVerify } from "./run-stop-and-final-verify.js";
@@ -212,18 +213,25 @@ export class Runner {
                 }
             }
         }
-        const faceSwap = seats.includes("readFace");
-        const priorFace = this.deps.readFace;
+        const faceSeats = ["readFace", "writeFace"].filter((seat) => seats.includes(seat));
+        const priorFaces = {
+            readFace: this.deps.readFace,
+            writeFace: this.deps.writeFace,
+        };
         const written = {
             ...this.deps,
             ...(expanded !== undefined ? { models: expanded } : {}),
             ...(catalogSwap && tiers !== undefined ? { tiers } : {}),
-            ...(faceSwap && candidate.readFace !== undefined ? { readFace: candidate.readFace } : {}),
         };
         if (catalogSwap && tiers === undefined)
             delete written.tiers;
-        if (faceSwap && candidate.readFace === undefined)
-            delete written.readFace;
+        const writtenFaceSeats = written;
+        for (const seat of faceSeats) {
+            if (candidate[seat] !== undefined)
+                writtenFaceSeats[seat] = candidate[seat];
+            else
+                delete writtenFaceSeats[seat];
+        }
         this.deps = written;
         if (catalogSwap) {
             const modelCount = Object.keys(candidate.models).length;
@@ -245,13 +253,15 @@ export class Runner {
                 });
             }
         }
-        if (faceSwap) {
-            const to = candidate.readFace ?? null;
-            deliverEngineNotice(this.deps.onNotice, {
-                code: "config.read_face_swapped",
-                message: `deployment read face swapped: ${priorFace ?? "(no declaration)"} → ${to ?? "(no declaration)"}; in-flight legs keep the face they prepared under, new legs resolve against the new declaration`,
-                detail: { from: priorFace ?? null, to, occurrenceId: uuidv7() },
-            });
+        for (const seat of faceSeats) {
+            const to = candidate[seat] ?? null;
+            const from = priorFaces[seat] ?? null;
+            const message = `deployment ${seat === "readFace" ? "read" : "write"} face swapped: ${from ?? "(no declaration)"} → ${to ?? "(no declaration)"}; in-flight legs keep the face they prepared under, new legs resolve against the new declaration`;
+            const detail = { from, to, occurrenceId: uuidv7() };
+            if (seat === "readFace")
+                deliverEngineNotice(this.deps.onNotice, { code: "config.read_face_swapped", message, detail });
+            else
+                deliverEngineNotice(this.deps.onNotice, { code: "config.write_face_swapped", message, detail });
         }
     }
     sideQuery(spec) {
@@ -413,6 +423,8 @@ export class Runner {
                         const { todoToolMounted, taskToolsMounted, writeFamilyOf, toolStartAt, startedToolCallIds } = runToolMountFacts({ spec, prepared, rs });
                         const { observeReasoningWireFacts, reasoningResolution } = runReasoningSeat({ prepared, rs, taskIdRef });
                         const { effectiveTimeoutMs, walltimeMonotonicDeadline, timeout, pushContent, ownCommittedTailRef, emitCommitted } = runClockAndContent({ spec, prepared, queue, internals, rs, ident, parentToolCallId, startedToolCallIds });
+                        const toolProgress = createToolProgressLane(pushContent, ident);
+                        prepared.toolProgressRef.current = toolProgress;
                         const { subagentName, withBrainSinks } = runBrainSinks({ queue, internals, rs, ident, parentToolCallId, observeReasoningWireFacts });
                         const toolLabels = new Map(prepared.tools.flatMap((t) => (t.label !== undefined && t.label !== t.name ? [[t.name, t.label]] : [])));
                         for (const orphan of prepared.wakeRecovered) {
@@ -426,7 +438,7 @@ export class Runner {
                             prepared, stats, rs,
                             deps: {
                                 spec, queue, internals, ident, parentToolCallId, subagentName,
-                                pushContent, emitCommitted, startedToolCallIds, toolStartAt, writeFamilyOf,
+                                pushContent, emitCommitted, startedToolCallIds, toolStartAt, toolProgress, writeFamilyOf,
                                 toolLabels, postToolBatchHook, batchArgs,
                                 runnerHooks: { onError: (e, info) => this.deps.onError?.(e, info) },
                             },
@@ -453,7 +465,7 @@ export class Runner {
                         });
                         const { flushGitMirror, unsubGitRetry, unsubBoundary, unsub } = runGitLane({ prepared, queue, rs, ident, onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, onTurnBoundary, runner: this.depsSeat });
                         return runLeg({
-                            spec, queue, prepared, resume, rs, entryActor, effectiveTimeoutMs, timeout, pushContent, ident, emitCommitted, writeFamilyOf, startedToolCallIds,
+                            spec, queue, prepared, resume, rs, isDelegatedChild: internals?.isDelegatedChild === true, entryActor, effectiveTimeoutMs, timeout, pushContent, ident, emitCommitted, writeFamilyOf, startedToolCallIds,
                             announceWorkspaceMove, withBrainSinks, flushGitMirror, loopLatch, notificationLane, unsubscribeTaskNotifications, unsubGitRetry, unsubBoundary, unsub,
                             runner: this.depsSeat,
                             next: ({ final, threw, abortedLive, userInterruptedLive, strandedHumanAnswers }) => runTerminalAdoption({