@sema-agent/core 7.19.0 → 7.20.1

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,

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

@@ -58,11 +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;
-/** The listing's budget vocabulary lives in `core/skill-listing-budget.ts` (the seat reader that lowers
- *  the two `TaskSpec` knobs to these numbers); re-exported here because this module is where every
- *  existing consumer of the cap imports it from, and the ceiling's structural reason is a property of
- *  the delivery lane rather than of the renderer. */
-export { SKILLS_BLOCK_MAX_BYTES } from "../skill-listing-budget.js";
 /** 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;
@@ -139,7 +134,7 @@ export declare function buildSkillsBlock(skills: ReadonlyArray<SkillListingEntry
  *  [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
@@ -147,42 +142,20 @@ export declare function buildSkillsBlock(skills: ReadonlyArray<SkillListingEntry
  *  budget cost, for the disclosure lane. */
 export declare function renderSkillsBlock(skills: ReadonlyArray<SkillListingEntry>, budget?: ResolvedSkillListingBudget): SkillsBlockRender | undefined;
 /**
- * The three honesty tiers over ONE set of skills, 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. A lane that folded by its own rules (or by none) renders a body the
- * bundle cap CLIPS, and a clipped body can never equal the intact-survival re-render, so the
- * announcement replays at every boundary for the life of the task — the failure
- * `@contract skills.listing_budget_ceiling` names, on whichever lane skipped the measurement.
+ * 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.
  *
- * `frame` renders the body lines into the shape its lane carries; its fixed cost is priced once, by
- * rendering it empty, so the tiers below decide against the bytes that actually ship.
- *
- * [c209-C] R2 C4① — the cap is BYTE-EXACT over the whole rendered frame (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.
- *
- * Pure: the same entries, budget and frame always render the same bytes, which is what the
- * prompt-prefix stability contract requires of the listing frames.
+ * 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. Re-clamped to {@link SKILLS_BLOCK_MAX_BYTES} here, not only in
-     *  the seat reader: this renderer is reachable from every listing lane, and the ceiling invariant
-     *  has to hold for a caller that computed its own number. */
+    /** 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;
@@ -203,3 +176,4 @@ export declare function renderSkillLinesWithin(skills: ReadonlyArray<SkillListin
  * widening, so it stays safe-by-construction.
  */
 export declare function createSkillTool(skills: SkillLike[], scope?: ActiveSkillScope): AgentTool;
+export {};

package/dist/core/runner/synthetic-tools.js

@@ -1,9 +1,10 @@
 import { Type } from "typebox";
 import { defineTool } from "../tools.js";
 import { sanitizeUntrustedText, SHELLED_BODY_ENVELOPE_TAGS } from "../untrusted-text.js";
-import { SKILLS_BLOCK_MAX_BYTES as SKILL_LISTING_CEILING_BYTES, SKILL_LISTING_DESC_MAX_CHARS_DEFAULT, } from "../skill-listing-budget.js";
+import { SKILL_LISTING_DEFAULT_BUDGET, SKILL_LISTING_DESC_MAX_CHARS_DEFAULT } from "../skill-listing-budget.js";
 import { toolFace } from "../tool-catalog-entries.js";
 import { substituteSkillRoot, substituteSkillRootBounded } from "./skill-base-dir.js";
+import { foldListingWithin } from "./listing-fold.js";
 export const OUTPUT_TOOL_NAME = "StructuredOutput";
 export const REPORT_BLOCKED_TOOL_NAME = "ReportBlocked";
 export const REPORT_FINDINGS_TOOL_NAME = "ReportFindings";
@@ -86,7 +87,6 @@ export function createReportFindingsTool() {
 }
 export const SKILL_TOOL_NAME = "Skill";
 export const SKILL_CONTENT_MAX_CHARS = 1024 * 1024;
-export { SKILLS_BLOCK_MAX_BYTES } from "../skill-listing-budget.js";
 export const SKILL_ATTACHMENTS_MAX_CHARS = 50_000;
 export const SKILL_ATTACHMENT_PATH_MAX_CHARS = 512;
 const SKILL_FILES_LIST_MAX_CHARS = 200;
@@ -130,7 +130,7 @@ const SKILLS_BLOCK_CAP_MARKER = "(block size cap reached — lower-priority skil
 export function buildSkillsBlock(skills, budget) {
     return renderSkillsBlock(skills, budget)?.text;
 }
-export function renderSkillsBlock(skills, budget) {
+export function renderSkillsBlock(skills, budget = SKILL_LISTING_DEFAULT_BUDGET) {
     if (skills.length === 0)
         return undefined;
     const headerLines = [
@@ -141,66 +141,22 @@ export function renderSkillsBlock(skills, budget) {
         "",
     ];
     return renderSkillLinesWithin(skills, {
-        blockMaxBytes: budget?.blockMaxBytes ?? SKILL_LISTING_CEILING_BYTES,
-        descMaxChars: budget?.descMaxChars ?? SKILL_LISTING_DESC_MAX_CHARS_DEFAULT,
+        blockMaxBytes: budget.blockMaxBytes,
+        descMaxChars: budget.descMaxChars,
         frame: (lines) => [...headerLines, ...lines, "</skills>"].join("\n"),
     });
 }
 export function renderSkillLinesWithin(skills, opts) {
-    if (skills.length === 0)
-        return undefined;
-    const blockMaxBytes = Math.min(opts.blockMaxBytes, SKILL_LISTING_CEILING_BYTES);
-    const descMaxChars = opts.descMaxChars;
-    const bytes = (s) => Buffer.byteLength(s, "utf8");
-    const render = opts.frame;
-    const lineCost = (l) => bytes(l) + 1;
-    const bodyBudget = blockMaxBytes - bytes(render([]));
-    const fullLines = skills.map((s) => skillListingLine(s, descMaxChars));
-    const fullTotal = fullLines.reduce((acc, l) => acc + lineCost(l), 0);
-    if (fullTotal <= bodyBudget)
-        return { text: render(fullLines), nameOnly: [], dropped: [] };
-    const nameLines = skills.map((s) => `- ${sanitizeUntrustedText(s.name, SHELLED_BODY_ENVELOPE_TAGS)}`);
-    const namePrefix = new Array(nameLines.length + 1);
-    namePrefix[0] = 0;
-    for (let i = 0; i < nameLines.length; i++)
-        namePrefix[i + 1] = namePrefix[i] + lineCost(nameLines[i]);
-    const markerCost = lineCost(SKILLS_BLOCK_CAP_MARKER);
-    const floorCost = markerCost + namePrefix[nameLines.length];
-    if (floorCost <= bodyBudget) {
-        let slack = bodyBudget - floorCost;
-        const byPriority = skills
-            .map((s, i) => ({ i, rank: s.declaredRank ?? i }))
-            .toSorted((a, b) => a.rank - b.rank || a.i - b.i);
-        const withDescription = new Set();
-        for (const { i } of byPriority) {
-            const delta = lineCost(fullLines[i]) - lineCost(nameLines[i]);
-            if (delta <= slack) {
-                withDescription.add(i);
-                slack -= delta;
-            }
-        }
-        return {
-            text: render([SKILLS_BLOCK_CAP_MARKER, ...skills.map((_s, i) => (withDescription.has(i) ? fullLines[i] : nameLines[i]))]),
-            nameOnly: skills.filter((_s, i) => !withDescription.has(i)).map((s) => s.name),
-            dropped: [],
-        };
-    }
-    for (let m = skills.length - 1; m >= 0; m--) {
-        const overflowLine = `(… +${skills.length - m} more skills not listed — the ${SKILL_TOOL_NAME} tool serves them all)`;
-        const cost = markerCost + namePrefix[m] + lineCost(overflowLine);
-        if (cost <= bodyBudget) {
-            return {
-                text: render([SKILLS_BLOCK_CAP_MARKER, ...nameLines.slice(0, m), overflowLine]),
-                nameOnly: skills.slice(0, m).map((s) => s.name),
-                dropped: skills.slice(m).map((s) => s.name),
-            };
-        }
-    }
-    return {
-        text: render([SKILLS_BLOCK_CAP_MARKER, `(… +${skills.length} more skills not listed — the ${SKILL_TOOL_NAME} tool serves them all)`]),
-        nameOnly: [],
-        dropped: skills.map((s) => s.name),
-    };
+    return foldListingWithin(skills, {
+        blockMaxBytes: opts.blockMaxBytes,
+        full: (s) => skillListingLine(s, opts.descMaxChars),
+        nameOnly: (s) => `- ${sanitizeUntrustedText(s.name, SHELLED_BODY_ENVELOPE_TAGS)}`,
+        nameOf: (s) => s.name,
+        rank: (s, i) => s.declaredRank ?? i,
+        capMarker: SKILLS_BLOCK_CAP_MARKER,
+        overflowLine: (n) => `(… +${n} more skills not listed — the ${SKILL_TOOL_NAME} tool serves them all)`,
+        frame: opts.frame,
+    });
 }
 export function createSkillTool(skills, scope) {
     const byName = new Map(skills.map((s) => [s.name, s]));

package/dist/core/runner/task-root-canonical.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The task root's CANONICAL spelling — and the one loud outlet for a host that hands in another one.
+ *
+ * Containment is judged on the canonical form: the roots fence resolves every target through the same
+ * `ExecutionEnv` and compares canonical keys, the shell read boundary compares a command's words
+ * against the declared roots, and every refusal message quotes them. A deployment that hands the
+ * runner a root which is NOT its own realpath (a symlinked temp directory; `/var` → `/private/var` on
+ * macOS) therefore reasons in one spelling while the engine judges in another, and a target the
+ * deployment considers inside the root can be judged outside it. Before this seat that difference was
+ * SILENT — the engine simply canonicalized and carried on.
+ *
+ * The bad-value discipline's announcement dialect applies (announce, do not refuse): an existing
+ * deployment may well be running correctly on the non-canonical spelling, so the judgment is unchanged
+ * and only the difference is disclosed. Nothing here repairs the host's spelling either — the engine
+ * cannot know which of the two the deployment's own gates key on, and rewriting one into the other
+ * would move a fence nobody asked to move.
+ */
+import type { ExecutionEnv } from "../../internal/harness.js";
+import type { RunnerDeps } from "../runner-deps.js";
+/** The canonical root plus whether the difference was announced (the pin's observable). */
+export interface TaskRootCanonical {
+    /** The spelling every fence judges with — the env's canonical form, or the given spelling when the
+     *  env cannot resolve it (an unresolvable root narrows nothing here; the fence's own skip speaks). */
+    canonical: string;
+    /** True exactly when the given spelling differed and the notice was delivered. */
+    announced: boolean;
+}
+/**
+ * Resolve the run's task root to the spelling its fences judge with, announcing a host spelling that is
+ * not that spelling.
+ *
+ * @contract task_root.canonical_is_the_judge — the engine judges containment on the task root's
+ * CANONICAL spelling; when the root the host handed in is not its own canonical form the run announces
+ * `config.task_root_not_canonical` exactly once, carrying both spellings, and then judges by the
+ * canonical form exactly as before. The notice discloses the difference — it never repairs the host's
+ * spelling, never narrows the fence, and never fires for a root that already is its own canonical form.
+ */
+export declare function resolveTaskRootCanonical(input: {
+    env: Pick<ExecutionEnv, "canonicalPath">;
+    /** The root as the host spelled it (`deps.rootPath` / the restored workspace root). */
+    given: string;
+    onNotice: RunnerDeps["onNotice"];
+    sessionId: string;
+    runId: string;
+}): Promise<TaskRootCanonical>;

package/dist/core/runner/task-root-canonical.js

@@ -0,0 +1,18 @@
+import { deliverEngineNotice } from "../engine-notice.js";
+export async function resolveTaskRootCanonical(input) {
+    const c = await input.env.canonicalPath(input.given);
+    if (!c.ok)
+        return { canonical: input.given, announced: false };
+    if (c.value === input.given)
+        return { canonical: c.value, announced: false };
+    deliverEngineNotice(input.onNotice, {
+        code: "config.task_root_not_canonical",
+        message: `The task root handed to this run is "${input.given}", which is not its own canonical path ("${c.value}"). ` +
+            `Containment is judged on the canonical spelling — the roots fence, the shell read boundary and every ` +
+            `refusal message read it — so a target this deployment considers inside the root can be judged outside ` +
+            `it whenever the two spellings differ (a symlinked directory; /var → /private/var on macOS). The run ` +
+            `proceeds on the canonical spelling exactly as before: hand the canonical path in to make the two agree.`,
+        detail: { given: input.given, canonical: c.value, sessionId: input.sessionId, runId: input.runId },
+    });
+    return { canonical: c.value, announced: true };
+}