@sema-agent/core 7.19.0 → 7.20.0

package/dist/core/runner/prepare-policy-chain.js

@@ -303,9 +303,9 @@ export async function preparePolicyChain(input) {
             }
             if (re.updatedInput !== undefined)
                 editArgs = re.updatedInput;
-            const judged = await judgeInheritedClassifier({ autoMode: ancestorDecider !== undefined ? { decider: ancestorDecider, denialTracking: ancestorTracker } : undefined, ask: re, req: { ...creq, args: editArgs }, signal: csignal ?? abortController.signal, subject: "the approved edit" });
+            const judged = await judgeInheritedClassifier({ autoMode: ancestorDecider !== undefined ? { decider: ancestorDecider, denialTracking: ancestorTracker } : undefined, ask: re, req: { ...creq, args: editArgs }, signal: csignal ?? abortController.signal, subject: "the approved edit", allowRewrite: editArgs });
             if (judged.kind === "allow")
-                return { action: "allow", updatedInput: editArgs };
+                return judged.result;
             if (judged.kind === "deny")
                 return judged.result;
             const { ask: editAsk, fallback: editFallback, mintedHere: editMintedHere } = judged;
@@ -371,7 +371,7 @@ export async function preparePolicyChain(input) {
                     }
                     const judged = await judgeInheritedClassifier({ autoMode: pc.autoMode, ask: first, req: creq, signal: csignal ?? abortController.signal, subject: "this call" });
                     if (judged.kind === "allow")
-                        return { action: "allow" };
+                        return judged.result;
                     if (judged.kind === "deny")
                         return judged.result;
                     const { ask: inheritedAsk, fallback, mintedHere } = judged;
@@ -439,9 +439,9 @@ export async function preparePolicyChain(input) {
                         return mandateUnreconstructibleDeny(creq);
                     }
                     const presentedArgs = decision.updatedInput !== undefined ? decision.updatedInput : creq.args;
-                    const judged = await judgeInheritedClassifier({ autoMode: pc.autoMode, ask: decision, req: { ...creq, args: presentedArgs }, signal: csignal ?? abortController.signal, subject: "this call" });
+                    const judged = await judgeInheritedClassifier({ autoMode: pc.autoMode, ask: decision, req: { ...creq, args: presentedArgs }, signal: csignal ?? abortController.signal, subject: "this call", allowRewrite: decision.updatedInput });
                     if (judged.kind === "allow")
-                        return decision.updatedInput !== undefined ? { action: "allow", updatedInput: decision.updatedInput } : { action: "allow" };
+                        return judged.result;
                     if (judged.kind === "deny")
                         return judged.result;
                     const { ask: inheritedAsk, fallback, mintedHere } = judged;

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

@@ -117,8 +117,8 @@ export interface PreparePromptInputsResult {
     tzValid: boolean;
     /** owned — the client's declared zone as given (paired with `tzValid`; unvalidated on its own). */
     userTz: string | undefined;
-    /** owned — the git-status lane's run-local state (empty on a hands-less leg); the run loop and the
-     *  checkpoint serializer mutate its fields from here on (`announced`, `pendingReceipt`, …). */
+    /** owned — the git-status lane's run-local state (empty on a hands-less leg); the run loop and the checkpoint
+     *  serializer mutate its fields from here on (`announced`, `mirrorOwed`, …; the frame's receipt rides the leg's shared `Prepared.frameReceipts`). */
     gitStatusRef: GitStatusLaneRef;
 }
 /** The M10 phase body — prepareTask's prompt-inputs stretch, verbatim (see the module header). */

package/dist/core/runner/prepare-run-refs.d.ts

@@ -28,8 +28,10 @@ export interface PrepareRunRefsInput {
      *  worktree helper). Never mutated. */
     spec: Pick<TaskSpec, "forwardSubagentEvents" | "retainSubagentSessions" | "handsReadOnly">;
     /** borrowed-readonly — the trusted spawn-side channel; only `onForwardEvent` (the deployment's display
-     *  sink) is read, once, to decide whether a forwarding wrapper exists at all. */
-    internals: Pick<RunInternals, "onForwardEvent"> | undefined;
+     *  sink) is read, to decide whether a forwarding wrapper exists at all, and `forwardScope` (the run's
+     *  forwarding containment, read by the door). The OBJECT is what the wrapper hands the door rather than
+     *  the pulled-out function: the sink keeps its receiver and the run keeps one failure count. */
+    internals: Pick<RunInternals, "onForwardEvent" | "forwardScope"> | undefined;
     /** borrowed-readonly — the run's resolved env; the worktree helper closes over it (lazy: no I/O until a
      *  delegation actually mints a worktree). */
     executionEnv: ExecutionEnv;

package/dist/core/runner/prepare-run-refs.js

@@ -1,6 +1,7 @@
 import { createSubagentWorktreeHelper } from "../../agents/subagent.js";
 import { SubagentRetainLedger } from "../../agents/retain-ledger.js";
 import { ActiveSkillScope } from "./active-skill-scope.js";
+import { forwardSafely } from "./forward-sink.js";
 import { createEditedFilesLedger } from "./edited-files-ledger.js";
 export function forwardsSubagentEvents(spec) {
     return spec.forwardSubagentEvents === true;
@@ -14,14 +15,14 @@ export function prepareRunRefs(input) {
     const harnessRef = {};
     const toolProgressRef = {};
     const skillScope = new ActiveSkillScope();
-    const forwardSink = internals?.onForwardEvent;
-    const forwardEvent = forwardSink
+    const sinkWired = internals?.onForwardEvent !== undefined;
+    const forwardEvent = sinkWired
         ? (e) => {
             if (e.type === "task_progress")
-                forwardSink(e);
+                forwardSafely(internals, e);
             else if (spec.forwardSubagentEvents === true &&
                 (e.type === "text_delta" || e.type === "text_end" || e.type === "reasoning_delta" || e.type === "tool_start" || e.type === "tool_progress" || e.type === "tool_end")) {
-                forwardSink(e);
+                forwardSafely(internals, e);
             }
         }
         : undefined;

package/dist/core/runner/prepare-task.js

@@ -78,6 +78,7 @@ import { ToolRosterDeltaSeat } from "../tool-roster.js";
 import { faceOf } from "../tool-roster.js";
 import { catalogEntriesNamed, pathTargetOf } from "../tool-registry.js";
 import { AdvertisedWritableDirs } from "./advertised-writable-dirs.js";
+import { resolveTaskRootCanonical } from "./task-root-canonical.js";
 import { createStructuredProjector } from "./tool-output-projection.js";
 function warnCompactionWindowHazard(tracer, spec, model, compModel, hostTaskId) {
     if (compModel === undefined)
@@ -365,6 +366,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         }
         const ownedEnv = ownedEnvSeat.current;
         const { taskRootFinal, rebaseRestoredPath } = await prepareWorkspaceRestore({ ownedEnv, deps, spec, internals, resume, taskRootInitial, abortController, sessionId });
+        const { canonical: taskRootCanonical } = await resolveTaskRootCanonical({ env: executionEnv, given: taskRootFinal, onNotice: deps.onNotice, sessionId, runId });
         const { trackFileEdit, fileHistoryBoundary, restoredFilePaths, rewindNotes, fileHistoryEnabled, historyScope, historyRoot, historyFs } = await prepareFileHistory({ deps, spec, internals, executionEnv, taskRootFinal, handsEnabled, sessionId, session, resumeAtBeforeParentId, abortController });
         const { noteFileEdited, editedFilesSnapshot, harnessRef, toolProgressRef, skillScope, forwardEvent, reviewRequestRef, requestReview, stopRequestedRef, requestStopAfterTurn, planModeRef, enterPlanMode, subagentRetain, worktreeIsolation } = prepareRunRefs({ spec, internals, executionEnv, taskRootFinal });
         let resolvedReadFace;
@@ -438,7 +440,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         const callIssuedAtRef = {};
         const workCutRef = { continuation: false, abortedBeforeTurnEnd: false };
         const advertisedWritableDirs = handsEnabled
-            ? new AdvertisedWritableDirs(executionEnv, (dir, reason) => deps.onError?.(new Error(`${dir.advertiser} advertised writable directory skipped (cannot canonicalize): ${dir.path} — ${reason}`), { phase: "config", sessionId }))
+            ? new AdvertisedWritableDirs(executionEnv, (dir, reason) => deps.onError?.(new Error(`${dir.advertiser} advertised writable directory skipped: ${dir.path} — ${reason}`), { phase: "config", sessionId }), taskRootCanonical, [...(spec.additionalDirectories ?? []), ...(spec.additionalReadDirectories ?? [])])
             : undefined;
         const handsWriteHalfPlanned = handsEnabled && handsWriteHalfMounts({ readOnly: spec.handsReadOnly === true });
         const memoryPairNameDomain = new Set();
@@ -508,7 +510,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         if (internals?.ownOrgAdmissionRef !== undefined && ownOrgVerdictRef.current !== undefined) {
             internals.ownOrgAdmissionRef.current = ownOrgVerdictRef.current;
         }
-        const handsReadFaceInput = { handsEnabled, executionEnv, taskRootFinal, rebaseRestoredPath, resume, session, sessionId, hostTaskId, taskScope, fullShellReachable, effectiveShellGate, toolFaceSnapshot, model, spec, deps, internals, memoryWriteGate, ...(advertisedWritableDirs !== undefined ? { advertisedWritableDirs } : {}), firstPartyOffload, roster, egressTools, irreversibilityTier, irreversibleTools, reversibilityProbes, reminderMark, reminderDisclosureCounts, ...(trackFileEdit !== undefined ? { trackFileEdit } : {}), onFileEdited: noteFileEdited, harnessRef, toolProgressRef, ...(restoredFilePaths.length > 0 ? { restoredFilePaths } : {}) };
+        const handsReadFaceInput = { handsEnabled, executionEnv, taskRootFinal, taskRootCanonical, rebaseRestoredPath, resume, session, sessionId, hostTaskId, taskScope, fullShellReachable, effectiveShellGate, toolFaceSnapshot, model, spec, deps, internals, memoryWriteGate, ...(advertisedWritableDirs !== undefined ? { advertisedWritableDirs } : {}), firstPartyOffload, roster, egressTools, irreversibilityTier, irreversibleTools, reversibilityProbes, reminderMark, reminderDisclosureCounts, ...(trackFileEdit !== undefined ? { trackFileEdit } : {}), onFileEdited: noteFileEdited, harnessRef, toolProgressRef, ...(restoredFilePaths.length > 0 ? { restoredFilePaths } : {}) };
         const handsReadFace = handsEnabled ? await prepareHandsMount(handsReadFaceInput) : resolveHandsLessReadFace(handsReadFaceInput);
         const { readFileStateForCheckpoint, seedContextFiles, handsCwdRef, workspaceStateSettle, wsSnapshot, rebaseWsPath, backgroundTaskToolsActive, additionalRootsCanonical, additionalReadRootsCanonical, attachmentRootCanonical, readDenyMatcher, envHandToolNames, sealReadStateSeat } = handsReadFace;
         resolvedReadFace = handsReadFace.resolvedReadFace;
@@ -590,7 +592,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             declaredCards: toolRoster.entries.flatMap((e) => e.renderHints?.resultCards ?? []),
             onUndeclared: (type) => deliverEngineNotice(deps.onNotice, { code: "config.tool_card_undeclared", message: `a tool minted a \`details.type\` card ${JSON.stringify(type)} its definition never declared — dropped from tool_end.structured (declare it on the definition's catalog row or the caller's renderHints.resultCards)`, detail: { type, sessionId, runId } }),
         });
-        const { agentListing, announcedListingsRef, dateChange } = prepareListings({ spec, tools, onceLedger, sessionId, toolFaceSnapshot, activeTools, resume, skillsListing, listingRideRef, renderWithDate, envFacts, tzValid, userTz });
+        const { agentListing, announcedListingsRef, dateChange } = prepareListings({ spec, tools, onceLedger, sessionId, toolFaceSnapshot, activeTools, resume, skillsListing, listingBudget: doors.skillListingBudget, listingRideRef, renderWithDate, envFacts, tzValid, userTz });
         const lastBrainContextRef = {};
         const requestLossyRef = { current: false };
         const staleOffloadWrittenRefs = new Set();
@@ -699,12 +701,12 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         const { saga } = prepareSuspendSaga({ gateMachineryActive, abortController, harness, checkpointStore, deps, sessionId, hostTaskId, taskScope, liveSpendRef, resume, nestedStats, internals, activeTools, outputRef, readFileStateForCheckpoint, faceCheckpointSection, writeFaceCheckpointSection, reminderMark, handsCwdRef, worktreeSessionRef, undeliveredContinuationRef, inheritedParentConstraints, seedInheritedGate, inheritedAncestorRules, inheritedShellGate, autoModeIntent, inheritedAdmittedOrgScopes, ownOrgVerdictRef, orgGovernedProvenance, announcedListingsRef, gitStatusRef, hookIdentity, placementRootResolved, externalContentTargetActive, remoteEnvFailures, memoryEngineSession, suspendLoopRef, ownedEnv, incompleteSuspendAdapter });
         const { suspendForResource, suspendForPlatformLimit, suspendForReview } = prepareBoundaryParks({ saga, spec, checkpointStore, abortController, harness, session, sessions, sessionId, deps, priorLedger, maxSlices, maxSuspends, resourceTotal, priorSuspendCount, suspendChainBase, humanReviewRef, liveSpendRef, now, faceCheckpointState, f012CheckpointState, orgAdmissionCheckpointState, pausedRef, remoteEnvFailures, resourceSuspendEligible, durableSuspendInfraReady, incompleteSuspendAdapter });
         const { parkAsk } = prepareParkAsk({ askLane, saga, spec, deps, sessionId, checkpointStore, toolRosterDeltas: rosterSeat, parkLaneArmed, contentAskRoutable, liveQuestionFace, mountedQuestionTool, contentAskBindings, lateStrandedAnswers, discloseStrandedAnswers, onAsk, runtimeCaps, inheritedUnavailableAsks, basePolicyForResumeEdit, budgetSnapshot, handsCwdRef, advertisedWritableDirs, offloadStore, ownedEnv, incompleteSuspendAdapter, session, sessions, suspendChainBase, maxSuspends, remoteEnvFailures, shellGatedTools, effectiveShellGate, durableApproval, priorLedger, liveSpendRef, resourceTotal, faceCheckpointState, f012CheckpointState, orgAdmissionCheckpointState, ruleOffersOf, now, humanReviewRef, abortController, harness, pausedRef });
-        prepareGateStations({ askLane, parkAsk, tools, toolRosterDeltas: rosterSeat, 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, irreversibilityTier, reversibilityProbes, abortController, shellGatedTools, autoModeDecider, autoModeDenialTracking, stopForDenialLimit, permissionRuleLane, permissionRuleOrgLane, questionToolMounted, sandboxAdmissionArmed, sandboxBoundaryCapable, emitSandboxAdmitted, delegation, notifyOwnHookCrash });
+        prepareGateStations({ askLane, parkAsk, tools, toolRosterDeltas: rosterSeat, 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, handsEnv: handsEnabled ? executionEnv : undefined, taskRootFinal, irreversibilityTier, reversibilityProbes, abortController, shellGatedTools, autoModeDecider, autoModeDenialTracking, stopForDenialLimit, permissionRuleLane, permissionRuleOrgLane, questionToolMounted, sandboxAdmissionArmed, sandboxBoundaryCapable, emitSandboxAdmitted, delegation, notifyOwnHookCrash });
         const { microCompact, charsPerToken } = prepareContextLane({ model, deps, sessionId, runId, hostTaskId, offloadStore, microCompactKnob, harness, batchHaltRef, gitStatusRef, requestLossyRef, trimPressureRef });
         const preparedHolder = {};
         const { cacheBreakDetector, cacheFingerprint, promptOverheadTokens, readTaskFile, normalizeAttachmentPath, isDedupStubResult, recentlyReadFiles, onCompactionApplied, detectExternalChanges, listBackgroundTasks, centerCompactionCandidate, effectiveReadFaceObserved, effectiveWriteFaceObserved, effectiveReadDenyObserved } = prepareTurnWiring({ deps, systemPromptSeat, harnessTools, fpRef, model, epochArtifactDigestForSnapshot, promptProfile, fableMitigations, systemBlocks, thinking, spec, sessionId, turnSnapshotRef, promptManifest, charsPerToken, handsEnabled, executionEnv, attachmentRootCanonical, additionalRootsCanonical, additionalReadRootsCanonical, readDenyMatcher, resolvedReadFace, handsCwdRef, readFileStateForCheckpoint, denyNarrowingPolicy, abortController, hostTaskId, taskScope, buildAssembleInputs, centerAdoptionRef, harnessRef, epochDeclaredSections, carrierReadFace, carrierWriteFace, readDenyAdditionsNormalized, preparedHolder });
         await onceLedger.settle(session, announcedListingsRef);
-        const buildPrepared = () => ({ harness, session, sessionId, runId, reminderMark, reminderDisclosureCounts, editedFilesSnapshot, taskRootPath: taskRootFinal, model, thinking, compModel: effectiveCompModel, mcp, ...(a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, gateOutcomes, batchHaltRef, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), ...(fileHistoryBoundary !== undefined ? { fileHistoryBoundary } : {}), ...(effectiveReadFaceObserved !== undefined ? { effectiveReadFace: effectiveReadFaceObserved, effectiveWriteFace: effectiveWriteFaceObserved } : {}), ...(effectiveReadDenyObserved !== undefined ? { effectiveReadDenyPatterns: effectiveReadDenyObserved } : {}), effectiveMemoryScopes: memoryEffectiveScopes, cwdRef: handsCwdRef, toolProgressRef, ...(advertisedWritableDirs !== undefined ? { advertisedWritableDirs } : {}), ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), ...(sealReadStateSeat !== undefined ? { sealReadStateSeat } : {}), denyNarrowingPolicy, ...(permissionRuleLane !== undefined ? { persistedRuleLane: permissionRuleLane } : {}), ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), ...(permissionRuleOrgLane !== undefined ? { permissionRuleOrg: permissionRuleOrgLane } : {}), releaseSignal, settleContentAskBindings, cacheBreakDetector, cacheFingerprint, wiringManifest, promptManifest, epochDeclaredSections, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), toolMaterializeStatic, deferDirectCall, ...(staticFaceForRef.current !== undefined ? { staticFaceFor: staticFaceForRef.current } : {}), ownedEnv, pausedRef, undeliveredContinuationRef, suspendProgressRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, workCutRef, brainCallGuardrailRef, gateStopRef, suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolRoster, toolRosterDeltas: rosterSeat, structuredProjector, toolEffects, wakeRecovered, promptOverheadTokens, lastBrainContext, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, microCompact, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit, runIdent: lspRunIdent } } : {}), planModeRef, stopRequestedRef, announcedSnapshotRecovered: onceLedger.recovered, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(projectInstructionContent !== undefined ? { projectInstructionContent } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, gitStatusRef, listBackgroundTasks, hookIdentity, hookTimeoutMs, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}), ...(toolDisclosureSeat !== undefined ? { toolDisclosure: toolDisclosureSeat } : {}) });
+        const buildPrepared = () => ({ harness, session, sessionId, runId, reminderMark, reminderDisclosureCounts, editedFilesSnapshot, taskRootPath: taskRootFinal, model, thinking, compModel: effectiveCompModel, mcp, ...(a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, gateOutcomes, batchHaltRef, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), ...(fileHistoryBoundary !== undefined ? { fileHistoryBoundary } : {}), ...(effectiveReadFaceObserved !== undefined ? { effectiveReadFace: effectiveReadFaceObserved, effectiveWriteFace: effectiveWriteFaceObserved } : {}), ...(effectiveReadDenyObserved !== undefined ? { effectiveReadDenyPatterns: effectiveReadDenyObserved } : {}), effectiveMemoryScopes: memoryEffectiveScopes, cwdRef: handsCwdRef, toolProgressRef, ...(advertisedWritableDirs !== undefined ? { advertisedWritableDirs } : {}), ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), ...(sealReadStateSeat !== undefined ? { sealReadStateSeat } : {}), denyNarrowingPolicy, ...(permissionRuleLane !== undefined ? { persistedRuleLane: permissionRuleLane } : {}), ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), ...(permissionRuleOrgLane !== undefined ? { permissionRuleOrg: permissionRuleOrgLane } : {}), releaseSignal, settleContentAskBindings, cacheBreakDetector, cacheFingerprint, wiringManifest, promptManifest, epochDeclaredSections, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), toolMaterializeStatic, deferDirectCall, ...(staticFaceForRef.current !== undefined ? { staticFaceFor: staticFaceForRef.current } : {}), ownedEnv, pausedRef, undeliveredContinuationRef, suspendProgressRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, workCutRef, brainCallGuardrailRef, gateStopRef, suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolRoster, toolRosterDeltas: rosterSeat, structuredProjector, toolEffects, wakeRecovered, promptOverheadTokens, lastBrainContext, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, microCompact, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit, runIdent: lspRunIdent } } : {}), planModeRef, stopRequestedRef, announcedSnapshotRecovered: onceLedger.recovered, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(projectInstructionContent !== undefined ? { projectInstructionContent } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, frameReceipts: { pending: [], listingSnapshotOwed: false }, gitStatusRef, listBackgroundTasks, hookIdentity, hookTimeoutMs, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}), ...(toolDisclosureSeat !== undefined ? { toolDisclosure: toolDisclosureSeat } : {}) });
         rollback.commit();
         const prepared = buildPrepared();
         preparedHolder.current = prepared;

package/dist/core/runner/run-clock-and-content.js

@@ -1,4 +1,5 @@
 import { startTimeout } from "./clock-and-limits.js";
+import { forwardSafely } from "./forward-sink.js";
 export function runClockAndContent(input) {
     const { spec, prepared, queue, internals, rs, ident, parentToolCallId, startedToolCallIds } = input;
     const effectiveTimeoutMs = spec.limits?.maxWalltimeMs;
@@ -7,13 +8,8 @@ export function runClockAndContent(input) {
     const timeout = startTimeout(prepared.harness, prepared.abortController, walltimeMonotonicDeadline !== undefined ? walltimeMonotonicDeadline - performance.now() : undefined, prepared.suspendForResource !== undefined);
     const pushContent = (e) => {
         queue.push(e);
-        if (parentToolCallId !== undefined && internals?.onForwardEvent) {
-            try {
-                internals.onForwardEvent(e);
-            }
-            catch {
-            }
-        }
+        if (parentToolCallId !== undefined)
+            forwardSafely(internals, e);
     };
     const ownCommittedTailRef = { current: undefined };
     const emitCommitted = (entryId, role, toolCallId) => {

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

@@ -1,4 +1,5 @@
 import { createSafeNotifier, observeThenableRejection } from "../safe-notify.js";
+import { forwardSafely } from "./forward-sink.js";
 import { emitTrace } from "../trace.js";
 import { primaryActivityArg } from "../arg-summary.js";
 import { readDegradation } from "../../brain/degrading.js";
@@ -58,17 +59,20 @@ export function createHarnessHandlers(input) {
         }
         if (event.entryId !== undefined && m.role === "user")
             prepared.fileHistoryBoundary?.begin(event.entryId);
-        if (event.entryId !== undefined && m.role === "user" && prepared.gitStatusRef.pendingReceipt !== undefined) {
-            const pr = prepared.gitStatusRef.pendingReceipt;
+        if (event.entryId !== undefined && m.role === "user" && prepared.frameReceipts.pending.length > 0) {
             const c = m.content;
             const text = typeof c === "string"
                 ? c
                 : Array.isArray(c) && c.length >= 1 && c[0].type === "text"
                     ? c[0].text
                     : undefined;
-            if (text === pr.text) {
-                delete prepared.gitStatusRef.pendingReceipt;
-                pr.commit(event.entryId);
+            if (text !== undefined) {
+                const settled = prepared.frameReceipts.pending.filter((r) => r.text === text);
+                if (settled.length > 0) {
+                    prepared.frameReceipts.pending = prepared.frameReceipts.pending.filter((r) => r.text !== text);
+                    for (const r of settled)
+                        r.commit(event.entryId);
+                }
             }
         }
         if (rs.degrade.degraded === undefined && m.role === "assistant") {
@@ -309,11 +313,7 @@ export function createHarnessHandlers(input) {
                 ...ident(),
             };
             queue.push(progress);
-            try {
-                internals?.onForwardEvent?.(progress);
-            }
-            catch {
-            }
+            forwardSafely(internals, progress);
         }
         emitTrace(rs.telemetry.tracer, () => ({ kind: "turn.end", version: 1, taskId: rs.telemetry.taskId, turn: stats.turns, ts: Date.now() }));
         rs.turn.turnUsage = undefined;

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

@@ -26,8 +26,9 @@ 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 { announceSkillListingTruncation } from "../skill-listing-budget.js";
-import { attachmentEnvelopeTags, commitAgentListing, commitSkillsListing, reduceToolEnd, renderAgentListingDelta, renderOrphanedBackgroundTasks, renderSkillsListingFrame, stampWriteAnchor } from "./turn-attachments.js";
+import { announceListingTruncation } from "../skill-listing-budget.js";
+import { attachmentEnvelopeTags, commitAgentListing, commitSkillsListing, reduceToolEnd, renderAgentListingFrame, renderOrphanedBackgroundTasks, renderSkillsListingFrame, stampWriteAnchor } from "./turn-attachments.js";
+import { flushOwedAnnouncedSnapshot } from "./announce-once-ledger.js";
 export async function runLeg(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;
@@ -234,7 +235,8 @@ export async function runLeg(input) {
                 if (gitResumeDelivered !== undefined) {
                     const delivered = gitResumeDelivered;
                     prepared.gitStatusRef.protectedText = delivered.wrapped;
-                    prepared.gitStatusRef.pendingReceipt = {
+                    prepared.frameReceipts.pending.push({
+                        source: "git_status",
                         text: continuation,
                         commit: (entryId) => {
                             prepared.gitStatusRef.announced = { kind: delivered.kind, hash: delivered.hash, entryId };
@@ -242,7 +244,7 @@ export async function runLeg(input) {
                             rs.attach.attachmentsInjected += 1;
                             prepared.gitStatusRef.mirrorOwed = { kind: delivered.kind, hash: delivered.hash, entryId };
                         },
-                    };
+                    });
                 }
                 const pending = resume.cp.pendingAction;
                 const rejectionHalt = pending.kind === "tool_approval" && resume.outcome.gate === "policy_ask"
@@ -332,22 +334,22 @@ 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) {
                     const listing = prepared.agentListing;
-                    const body = renderAgentListingDelta(attach, listing.entries, listing.toolName, listing.models);
-                    if (body !== undefined) {
+                    const frame = renderAgentListingFrame(attach, listing.entries, listing.toolName, listing.models, listing.budget);
+                    if (frame !== undefined) {
                         firstFrames.push({
                             source: "agent_listing",
-                            body,
+                            body: frame.text,
                             commit: () => {
                                 commitAgentListing(attach, listing.entries, listing.models);
                                 prepared.announcedListingsRef.agents = listing.entries.map((e) => e.name);
                                 if (listing.models !== undefined)
                                     prepared.announcedListingsRef.models = [...listing.models];
                             },
+                            disclose: () => announceListingTruncation(runner.deps.onNotice, { listing: "agents", total: frame.listed, nameOnly: frame.nameOnly, dropped: frame.dropped, budget: listing.budget, sessionId: prepared.sessionId }),
                         });
                     }
                 }
@@ -361,8 +363,8 @@ export async function runLeg(input) {
                             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 };
                             },
+                            disclose: () => announceListingTruncation(runner.deps.onNotice, { listing: "skills", total: frame.listed, nameOnly: frame.nameOnly, dropped: frame.dropped, budget: listing.budget, sessionId: prepared.sessionId }),
                         });
                     }
                 }
@@ -418,7 +420,8 @@ export async function runLeg(input) {
                     if (delivered.standalone)
                         await prepared.harness.nextTurn(delivered.wrapped, { engineMinted: true });
                     prepared.gitStatusRef.protectedText = delivered.wrapped;
-                    prepared.gitStatusRef.pendingReceipt = {
+                    prepared.frameReceipts.pending.push({
+                        source: "git_status",
                         text: delivered.standalone ? delivered.wrapped : effectiveObjective,
                         commit: (entryId) => {
                             prepared.gitStatusRef.announced = { kind: delivered.kind, hash: delivered.hash, entryId };
@@ -426,17 +429,20 @@ export async function runLeg(input) {
                             rs.attach.attachmentsInjected += 1;
                             prepared.gitStatusRef.mirrorOwed = { kind: delivered.kind, hash: delivered.hash, entryId };
                         },
-                    };
+                    });
                 }
                 for (const f of firstFrames) {
-                    f.commit();
-                    queue.push({ type: "steering_injected", source: f.source, preview: redactThenCut(f.body, 220), ...ident() });
-                }
-                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 });
+                    prepared.frameReceipts.pending.push({
+                        source: f.source,
+                        text: effectiveObjective,
+                        commit: () => {
+                            f.commit();
+                            queue.push({ type: "steering_injected", source: f.source, preview: redactThenCut(f.body, 220), ...ident() });
+                            rs.attach.attachmentsInjected += 1;
+                            prepared.frameReceipts.listingSnapshotOwed = true;
+                            f.disclose();
+                        },
+                    });
                 }
                 const enginePrefixChars = effectiveObjective.length - projectedObjective.length;
                 queue.push({
@@ -481,6 +487,9 @@ export async function runLeg(input) {
         timeout.clear();
         prepared.lspDiagnostics?.registry.releaseRun(prepared.lspDiagnostics.runIdent);
         prepared.toolProgressRef.current?.clear();
+        if (prepared.frameReceipts.listingSnapshotOwed) {
+            await settleTeardownLeg(() => flushOwedAnnouncedSnapshot(prepared), "announced-listing snapshot (leg exit)", (e) => runner.deps.onError?.(e, { phase: "degraded", sessionId: prepared.sessionId }));
+        }
         prepared.abortController.abort();
         prepared.releaseSignal();
         strandedHumanAnswers = prepared.settleContentAskBindings();

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

@@ -12,6 +12,7 @@ import { emitTrace } from "../trace.js";
 import { deliverEngineNotice } from "../types.js";
 import { assembleResult } from "./assemble-result.js";
 import { discloseUnconsumedHalt } from "./halt-attribution.js";
+import { forwardSafely } from "./forward-sink.js";
 import { TIMER_LATENESS_REPORT_MS } from "./clock-and-limits.js";
 import { resumeDecisionWasNegative } from "./decide-continuation.js";
 import { drainForwardedFramesBeforeDone, forwardsSubagentEvents } from "./prepare-run-refs.js";
@@ -276,11 +277,7 @@ export async function runSettleAndTeardown(input) {
                 ...ident(),
             };
             queue.push(terminalTick);
-            try {
-                internals?.onForwardEvent?.(terminalTick);
-            }
-            catch {
-            }
+            forwardSafely(internals, terminalTick);
         }
         if (manualCompactRef.waiters.length > 0) {
             queue.push({ type: "compaction_outcome", outcome: "mooted", trigger: "manual", reason: "task_ending", ...ident() });

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

@@ -4,8 +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, renderSkillsListingFrame, renderToolsDelta } from "./turn-attachments.js";
-import { announceSkillListingTruncation } from "../skill-listing-budget.js";
+import { ATTACHMENT_BYTE_CAP, CHANGED_FILES_MAX, TOTAL_TOKENS_REMINDER_DEFAULT_MODE, attachmentEnvelopeTags, clipToBytes, collectDateChange, collectDueAttachments, collectInstructionsChange, commitAgentListing, commitInstructionsChange, commitSkillsListing, isIntactSource, rebaseCadenceWindows, renderAgentListingFrame, renderMcpDroppedTools, renderMcpInstructionsDelta, selectMcpDroppedBatch, renderSkillsListingFrame, renderToolsDelta } from "./turn-attachments.js";
+import { announceListingTruncation } from "../skill-listing-budget.js";
 import { buildWorkingFileAttachments, centerAdoptionOption, contextInstructionFilesOption, emitInputTruncated, forkContextOption } from "./compaction-call-options.js";
 import { hookSeatExpiredError, runHookSeat } from "../hooks.js";
 import { sanitizeUntrustedText, SHELLED_BODY_ENVELOPE_TAGS } from "../untrusted-text.js";
@@ -203,7 +203,7 @@ export function createTurnBoundary(input) {
         }
         let boundaryAttachmentBytes = 0;
         let attachmentsPayload;
-        let skillsListingCost;
+        const listingCommits = [];
         if ((rs.attach.dateState !== undefined ||
             rs.attach.instrState !== undefined ||
             rs.attach.sizeGuidelineState !== undefined ||
@@ -215,6 +215,7 @@ export function createTurnBoundary(input) {
             !prepared.abortController.signal.aborted) {
             const due = [];
             if (rs.attach.attachState !== undefined) {
+                const attachState = rs.attach.attachState;
                 const changedFilesOn = Boolean(rs.attach.attachmentsCfg?.changedFiles);
                 let changed;
                 if (changedFilesOn && prepared.detectExternalChanges !== undefined) {
@@ -265,6 +266,10 @@ export function createTurnBoundary(input) {
                 const undiscoveredTools = toolSearchReminderOn
                     ? [...prepared.deferredToolNames].filter((n) => !prepared.activeTools.has(n)).sort()
                     : undefined;
+                const receiptPending = (source) => prepared.frameReceipts.pending.some((r) => r.source === source);
+                const agentListingDue = rs.attach.agentListingOn && prepared.agentListing !== undefined && !receiptPending("agent_listing");
+                const skillsListingDue = rs.attach.skillsListingOn && prepared.skillsListing !== undefined && !receiptPending("skills_listing");
+                const listingBudget = prepared.skillsListing?.budget ?? prepared.agentListing?.budget;
                 due.push(...collectDueAttachments(rs.attach.attachState, {
                     turn: stats.turns,
                     cadenceTurn: rs.counters.cadenceTurns,
@@ -308,16 +313,15 @@ export function createTurnBoundary(input) {
                         ? { readdedToolsSwappedUnderStatic: pendingReaddedTools.filter((n) => prepared.staticFaceFor?.(n) !== true) }
                         : {}),
                     ...(mcpToolsDelta !== undefined ? { mcpToolsDelta } : {}),
-                    ...(rs.attach.agentListingOn && prepared.agentListing !== undefined
+                    ...(agentListingDue
                         ? {
                             agentListing: prepared.agentListing.entries,
                             agentToolName: prepared.agentListing.toolName,
                             ...(prepared.agentListing.models !== undefined ? { agentModels: prepared.agentListing.models } : {}),
                         }
                         : {}),
-                    ...(rs.attach.skillsListingOn && prepared.skillsListing !== undefined
-                        ? { skillsListing: prepared.skillsListing.entries, skillsListingBudget: prepared.skillsListing.budget }
-                        : {}),
+                    ...(skillsListingDue ? { skillsListing: prepared.skillsListing.entries } : {}),
+                    ...(listingBudget !== undefined ? { listingBudget } : {}),
                     ...(mcpAdds !== undefined || mcpRemovals !== undefined
                         ? { mcpInstructions: { added: mcpAdds ?? [], removed: mcpRemovals ?? [] } }
                         : {}),
@@ -367,31 +371,36 @@ export function createTurnBoundary(input) {
                         announcedOnceDirty = true;
                     }
                 }
-                if (rs.attach.agentListingOn && prepared.agentListing !== undefined && due.some((a) => a.source === "agent_listing")) {
+                if (agentListingDue && due.some((a) => a.source === "agent_listing")) {
                     const listing = prepared.agentListing;
-                    const intactBody = renderAgentListingDelta(rs.attach.attachState, listing.entries, listing.toolName, listing.models);
-                    if (intactBody !== undefined && due.some((a) => a.source === "agent_listing" && a.body === intactBody)) {
-                        commitAgentListing(rs.attach.attachState, listing.entries, listing.models);
-                        prepared.announcedListingsRef.agents = listing.entries.map((e) => e.name);
-                        if (listing.models !== undefined)
-                            prepared.announcedListingsRef.models = [...listing.models];
-                        if (prepared.announcedSnapshotRecovered)
-                            await prepared.session.appendAnnouncedListing(prepared.announcedListingsRef).catch(() => undefined);
-                    }
+                    const frame = renderAgentListingFrame(attachState, listing.entries, listing.toolName, listing.models, listing.budget);
+                    listingCommits.push({
+                        source: "agent_listing",
+                        commit: () => {
+                            commitAgentListing(attachState, listing.entries, listing.models);
+                            prepared.announcedListingsRef.agents = listing.entries.map((e) => e.name);
+                            if (listing.models !== undefined)
+                                prepared.announcedListingsRef.models = [...listing.models];
+                            prepared.frameReceipts.listingSnapshotOwed = true;
+                            announceListingTruncation(deps.runner.deps.onNotice, { listing: "agents", total: frame.listed, nameOnly: frame.nameOnly, dropped: frame.dropped, budget: listing.budget, sessionId: prepared.sessionId });
+                        },
+                    });
                 }
-                if (rs.attach.skillsListingOn && prepared.skillsListing !== undefined && due.some((a) => a.source === "skills_listing")) {
+                if (skillsListingDue && due.some((a) => a.source === "skills_listing")) {
                     const listing = prepared.skillsListing;
-                    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);
-                    }
+                    const frame = renderSkillsListingFrame(attachState, listing.entries, listing.budget);
+                    listingCommits.push({
+                        source: "skills_listing",
+                        commit: () => {
+                            commitSkillsListing(attachState, listing.entries);
+                            prepared.announcedListingsRef.skills = listing.entries.map((e) => e.name);
+                            prepared.frameReceipts.listingSnapshotOwed = true;
+                            announceListingTruncation(deps.runner.deps.onNotice, { listing: "skills", total: frame.listed, nameOnly: frame.nameOnly, dropped: frame.dropped, budget: listing.budget, sessionId: prepared.sessionId });
+                        },
+                    });
                 }
-                if (announcedOnceDirty && prepared.announcedSnapshotRecovered)
-                    await prepared.session.appendAnnouncedListing(prepared.announcedListingsRef).catch(() => undefined);
+                if (announcedOnceDirty)
+                    prepared.frameReceipts.listingSnapshotOwed = true;
             }
             if (rs.attach.dateState !== undefined && rs.turn.lastTurnHadToolCalls) {
                 const today = prepared.dateChange.today();
@@ -434,7 +443,8 @@ export function createTurnBoundary(input) {
             if (due.length > 0) {
                 attachmentsPayload = due.map((a) => mintSystemReminder(sanitizeUntrustedText(a.body, attachmentEnvelopeTags(a.source)), prepared.reminderMark)).join("\n");
                 for (const a of due)
-                    boundaryAttachmentBytes += Buffer.byteLength(a.body, "utf8");
+                    if (!isIntactSource(a.source))
+                        boundaryAttachmentBytes += Buffer.byteLength(a.body, "utf8");
                 rs.attach.attachmentsInjected += due.length;
                 for (const a of due) {
                     queue.push({ type: "steering_injected", source: a.source, preview: redactThenCut(a.body, 220), ...ident() });
@@ -478,10 +488,11 @@ 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 });
-            }
+            for (const c of listingCommits)
+                prepared.frameReceipts.pending.push({ source: c.source, text: payload, commit: c.commit });
+            void prepared.harness.steer(payload, { engineMinted: true }).catch(() => {
+                prepared.frameReceipts.pending = prepared.frameReceipts.pending.filter((r) => r.text !== payload);
+            });
         }
         const forceManual = manualCompactRef.requested;
         if ((!withinTaskCompaction && !forceManual) ||

package/dist/core/runner/runtask.js

@@ -50,6 +50,7 @@ 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 { createForwardSinkScope } from "./forward-sink.js";
 import { runBrainSinks } from "./run-brain-sinks.js";
 import { runCompactionMachinery } from "./run-compaction-machinery.js";
 import { runStopAndFinalVerify } from "./run-stop-and-final-verify.js";
@@ -344,7 +345,7 @@ export class Runner {
                     manualCompactRef,
                     taskIdRef,
                     resume,
-                    internals: { ...(internals ?? {}), detachHub },
+                    internals: { ...(internals ?? {}), detachHub, forwardScope: createForwardSinkScope(this.deps.onNotice) },
                     notifyRef,
                     captureOptOutRef,
                     entryActor,