@sema-agent/core 7.18.0 → 7.20.0

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;
@@ -574,7 +576,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId });
             }
         }
-        const projectContext = await prepareProjectContext({ deps, spec, internals, session, sessionId, hostTaskId, taskRootFinal, handsEnabled, delegation, seedContextFiles, memoryBlockFromEngine, skillScope, roster, toolFaceSnapshot, onceLedger, memoryTools, memoryEngineSession, memorySearchToolsPlanned, memoryPairExcludedName, memoryPairOccupiedName, resume });
+        const projectContext = await prepareProjectContext({ deps, spec, internals, session, sessionId, hostTaskId, taskRootFinal, handsEnabled, delegation, seedContextFiles, memoryBlockFromEngine, skillScope, roster, toolFaceSnapshot, onceLedger, memoryTools, memoryEngineSession, memorySearchToolsPlanned, memoryPairExcludedName, memoryPairOccupiedName, resume, skillListingBudget: doors.skillListingBudget });
         const { memoryBlock: memoryBlockWithProject, instructionSources, projectInstructionContent, hasSkillManifest, skillsListing, sharedMemoryPairMounted, memoryEnginePairMounted } = projectContext;
         const { provider, featureFlags, userSystemPrompt, userAppendSystemPrompt, mcpInstructionsBlock, envFacts, tzValid, userTz, gitStatusRef } = await preparePromptInputs({ spec, deps, failClosedReason: selfOrchestrationFailClosedReason(spec, deps), lockedPreflight, selfOrchestrationActive, executionEnv, reminderMark, resolvedReadFace, resolvedWriteFace, toolFaceSnapshot, promptProfile, fableMitigations, internals, thinking, ownedEnv, delegation, resolvedRole, mcp, model, externalContentTargetActive, resume, handsEnabled, taskRootFinal, additionalRootsCanonical, additionalReadRootsCanonical, sessionId, ...(advertisedWritableDirs !== undefined ? { advertisedWritableDirs } : {}) });
         const { deferred, memoryBlock, toolSearch: toolSearchPolicy } = prepareDeferClassify({ spec, deps, roster, toolFaceSnapshot, handsEnabled, fullShellReachable, promptProfile, model, mcp, a2a, sharedMemoryPairMounted, memoryEnginePairMounted, memoryBlock: memoryBlockWithProject, memoryRecallSegment, onceLedger, sessionId });
@@ -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/resume-apply.js

@@ -2,6 +2,7 @@ import { snapshotActorAssertion } from "../../internal/llm.js";
 import { isAskOrigin } from "../ask-origin.js";
 import { ASK_USER_QUESTION_TOOL_NAME } from "../ask-question.js";
 import { CheckpointError, remainingBudgetMicroUsd } from "../checkpoint-store.js";
+import { settledByPerson } from "../gate-outcome.js";
 import { cloneObserverInput, mintHookInvocationIdentity, resolveHookTimeoutMs, runHookSeat } from "../hooks.js";
 import { checkToolPolicyProjection, refuseOutOfContractDecision } from "../tool-policy.js";
 import { callFaceSeat, parkedCallFaceOf } from "../tool-roster.js";
@@ -170,10 +171,9 @@ export async function resumeApply(input) {
             throw new CheckpointError("checkpoint.unsupported_version", "this checkpoint's pending approval carries no origin word (a row minted before the ask's origin was persisted on the park) — its settlement cannot be recorded; the checkpoint stays pending", { reason: "origin_missing" });
         }
         const facts = plainPolicyOutcome.hostDecision;
-        const approverCell = facts.approver !== undefined ? { approver: facts.approver } : {};
         const settlement = facts.decidedBy === "sla_timeout"
-            ? { kind: "park_sla_expired", who: { party: "host", ...approverCell }, when: Date.now() }
-            : { kind: plainPolicyOutcome.decision === "allow" ? "human_allowed" : "human_refused", who: { party: "person", ...approverCell }, when: Date.now(), ...(plainPolicyOutcome.decision === "deny" && plainPolicyOutcome.reason !== undefined ? { note: plainPolicyOutcome.reason } : {}) };
+            ? { kind: "park_sla_expired", who: { party: "host", ...(facts.approver !== undefined ? { approver: facts.approver } : {}) }, when: Date.now() }
+            : settledByPerson(plainPolicyOutcome.decision === "allow" ? "human_allowed" : "human_refused", facts.approver, plainPolicyOutcome.decision === "deny" ? plainPolicyOutcome.reason : undefined);
         plainPolicyOutcome = { ...plainPolicyOutcome, gateOutcome: mintGateOutcome({ ...(plainPolicyOutcome.decision === "deny" ? { deniedBy: "ask_resolution" } : {}), settled: { settlement, origin: parkedOrigin } }) };
     }
     const outcomeForStore = plainPolicyOutcome ?? plainReviewOutcome ?? plainParkOutcome;

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,7 +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 { attachmentEnvelopeTags, commitAgentListing, commitSkillsListing, reduceToolEnd, renderAgentListingDelta, renderOrphanedBackgroundTasks, renderSkillsListingDelta, 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;
@@ -233,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 };
@@ -241,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"
@@ -335,31 +338,33 @@ export async function runLeg(input) {
                 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 }),
                         });
                     }
                 }
                 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);
                             },
+                            disclose: () => announceListingTruncation(runner.deps.onNotice, { listing: "skills", total: frame.listed, nameOnly: frame.nameOnly, dropped: frame.dropped, budget: listing.budget, sessionId: prepared.sessionId }),
                         });
                     }
                 }
@@ -415,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 };
@@ -423,15 +429,21 @@ 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() });
+                    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();
+                        },
+                    });
                 }
-                rs.attach.attachmentsInjected += firstFrames.length;
-                if (firstFrames.length > 0 && prepared.announcedSnapshotRecovered)
-                    await prepared.session.appendAnnouncedListing(prepared.announcedListingsRef).catch(() => undefined);
                 const enginePrefixChars = effectiveObjective.length - projectedObjective.length;
                 queue.push({
                     ...buildHumanInputEvent({
@@ -475,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,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, 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";
@@ -202,6 +203,7 @@ export function createTurnBoundary(input) {
         }
         let boundaryAttachmentBytes = 0;
         let attachmentsPayload;
+        const listingCommits = [];
         if ((rs.attach.dateState !== undefined ||
             rs.attach.instrState !== undefined ||
             rs.attach.sizeGuidelineState !== undefined ||
@@ -213,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) {
@@ -263,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,
@@ -306,14 +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 } : {}),
+                    ...(skillsListingDue ? { skillsListing: prepared.skillsListing.entries } : {}),
+                    ...(listingBudget !== undefined ? { listingBudget } : {}),
                     ...(mcpAdds !== undefined || mcpRemovals !== undefined
                         ? { mcpInstructions: { added: mcpAdds ?? [], removed: mcpRemovals ?? [] } }
                         : {}),
@@ -363,30 +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 intactBody = renderSkillsListingDelta(rs.attach.attachState, listing.entries);
-                    if (intactBody !== undefined && due.some((a) => a.source === "skills_listing" && a.body === intactBody)) {
-                        commitSkillsListing(rs.attach.attachState, listing.entries);
-                        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();
@@ -429,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() });
@@ -473,7 +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(() => { });
+            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,

package/dist/core/runner/synthetic-tools.d.ts

@@ -1,6 +1,7 @@
 import { type TSchema } from "typebox";
 import type { AgentTool } from "../../internal/harness-types.js";
 import type { SkillManifest } from "../types.js";
+import { type ResolvedSkillListingBudget } from "../skill-listing-budget.js";
 import type { ActiveSkillScope } from "./active-skill-scope.js";
 /** Reserved name of the injected structured-output tool (CC 2.1.187 `StructuredOutput`; batch-A rename — old
  *  "submit_output" is canonicalized for pre-rename durable state). */
@@ -57,15 +58,6 @@ export declare const SKILL_TOOL_NAME = "Skill";
  *  an oversized skill is excluded from the disclosure block and the tool, with an operator-visible config error. The compaction-time retention caps are a
  *  different door, deliberately. */
 export declare const SKILL_CONTENT_MAX_CHARS: number;
-/** Total listing-block cap in UTF-8 BYTES — [c209-C] R2 C4①: the old 8000-CHAR cap measured a
- *  different coordinate than the bundle's `ATTACHMENT_BYTE_CAP` (8192 UTF-8 bytes) and counted only
- *  the description lines (fence framing + name-only tail rode free), so a near-cap frame could
- *  exceed the bundle cap, get clip-mangled every boundary, never pass the intact-survival commit
- *  predicate, and REPLAY FOREVER. The cap is now enforced byte-exact over the WHOLE rendered block
- *  (fences, headers, markers, joiners included), so `buildSkillsBlock` output always fits the
- *  bundle cap solo and an intact commit is always reachable. MUST stay ≤ ATTACHMENT_BYTE_CAP
- *  (turn-attachments.ts; not imported here — that module imports this one — pinned by test instead). */
-export declare const SKILLS_BLOCK_MAX_BYTES = 8000;
 /** Total per-invoke cap for a skill's inlined attachments (`SkillSpec.files`) — an ATTACHMENT-face budget, distinct from the (gone) body truncation door:
  *  the body is delivered untruncated at invoke time (CC parity), while attachments ride along bounded and truncation-disclosed. */
 export declare const SKILL_ATTACHMENTS_MAX_CHARS = 50000;
@@ -123,31 +115,51 @@ export declare const SKILLS_LISTING_PROBE_HEADER = "The following skills are ava
 /** [c209-C] One skill's disclosure line — `- name: description[(files 尾缀)]` with the per-skill
  *  description cap. Single-sourced so the skills_listing DELTA frame (turn-attachments) renders adds
  *  with byte-identical line shape to the initial `<skills>` block. */
-export declare function skillListingLine(s: SkillListingEntry): string;
+export declare function skillListingLine(s: SkillListingEntry, descMaxChars?: number): string;
+/** What one {@link renderSkillsBlock} call produced: the block, and which skills the budget degraded. */
+export interface SkillsBlockRender {
+    /** The rendered block — what {@link buildSkillsBlock} returns. */
+    text: string;
+    /** Skills listed WITHOUT their description (tier B's unspent candidates, or every listed name under
+     *  tier C), in display order. Raw names: this is host-facing structured data, not prompt text. */
+    nameOnly: readonly string[];
+    /** Skills the block could not list at all (tier C's overflow tail). The `Skill` tool still serves them. */
+    dropped: readonly string[];
+}
+/** The text-only face of {@link renderSkillsBlock} — the `<skills>` BLOCK's face, not the listing
+ *  family's: the drift frame renders its own arms through the shared tier engine
+ *  ({@link renderSkillLinesWithin}), which is where "one ruler for every frame" lives. */
+export declare function buildSkillsBlock(skills: ReadonlyArray<SkillListingEntry>, budget?: ResolvedSkillListingBudget): string | undefined;
 /** Render the `<skills>` disclosure block (metadata only — bodies stay behind the tool).
  *  [c209-C] REVERSAL: no longer composed into the stable system prompt — this is now the RENDERER for
  *  the `skills_listing` initial frame (first-user-turn reminder / boundary re-announce), so the
  *  cached prefix carries zero skill bytes (design/C §2.3; CC 209 classic ships the same listing as a
- *  first-turn reminder; Q6: 8KB cap ≈ CC's observed 5.9KB listing).
+ *  first-turn reminder). `budget` absent ⇒ the seat reader's no-knob answer ({@link SKILL_LISTING_DEFAULT_BUDGET}).
+ *
+ *  The fence and its four header lines are this lane's frame; the budget arithmetic and the three
+ *  degradation tiers belong to {@link renderSkillLinesWithin}, which the drift frame renders through
+ *  as well. {@link buildSkillsBlock} is the text-only face; this one additionally reports what the
+ *  budget cost, for the disclosure lane. */
+export declare function renderSkillsBlock(skills: ReadonlyArray<SkillListingEntry>, budget?: ResolvedSkillListingBudget): SkillsBlockRender | undefined;
+/**
+ * The skills VOCABULARY of the one folding engine (`listing-fold.ts` `foldListingWithin`): the full
+ * `- name: description` line, the name-only line, the block's cap marker and its overflow count line,
+ * measured byte-exact inside a caller-supplied FRAME — the engine both {@link renderSkillsBlock} and
+ * the drift frame's ADD arm render through, so the initial `<skills>` block and a later "new skills are
+ * now available" announcement degrade by the same rules against the same number — the number the seat
+ * reader resolved (`@contract skills.listing_budget_enforced_as_declared`), which is the frame's whole
+ * bound: the listing is an intact-class attachment, so no delivery lane measures it a second time.
  *
- *  [c209-C] R2 C4① — the cap is BYTE-EXACT over the whole rendered block (see
- *  {@link SKILLS_BLOCK_MAX_BYTES}): three honesty tiers, each chosen with the LATER tiers' fixed
- *  overhead (cap marker / name-only tail / overflow count line) already reserved so the final
- *  render can never blow the budget it was sized against —
- *    A. everything fits → every skill gets its full `- name: description` line (byte-identical to
- *       the pre-C4 render for every block that was legal under the old cap);
- *    B. (CC 220 `sbs` @317547-317586) — reserve the cap marker + EVERY skill's name-only line
- *       first, then spend the remaining slack on descriptions in PRIORITY order
- *       ({@link SkillListingEntry.declaredRank}), admitting each description whose incremental cost
- *       still fits and skipping (not stopping at) the ones that do not. Every skill stays listed;
- *       the ones that lose their description are the low-priority ones, not the alphabetically late
- *       ones. This replaces the prior "longest full-line PREFIX" cut, which had two defects the
- *       anchor does not: the surviving set was decided by name sort order (a skill named `zip-deploy`
- *       lost its description to `aardvark-lint` for no reason connected to either skill), and one
- *       oversized description truncated the block at itself instead of being skipped over;
- *    C. even all-name-only overflows (pathological name census) → list what fits and close with an
- *       honest `(… +N more skills …)` count line — the tool still serves all of them. */
-export declare function buildSkillsBlock(skills: ReadonlyArray<SkillListingEntry>): string | undefined;
+ * Tier B follows CC 220 `sbs` @317547-317586 (reserve the marker + every name-only line, then spend
+ * the slack on descriptions in {@link SkillListingEntry.declaredRank} order); tier C closes with an
+ * honest `(… +N more skills …)` count line — the tool still serves all of them.
+ */
+export declare function renderSkillLinesWithin(skills: ReadonlyArray<SkillListingEntry>, opts: {
+    /** The whole frame's byte budget — honoured as given; the seat reader is the one place that decides it. */
+    blockMaxBytes: number;
+    descMaxChars: number;
+    frame: (lines: readonly string[]) => string;
+}): SkillsBlockRender | undefined;
 /**
  * The injected `skill` tool: returns a skill's full body as a tool result.
  *