@sema-agent/core 7.17.7 → 7.18.0

package/dist/engine/harness/agent-harness.d.ts

@@ -1,4 +1,5 @@
 import type { ActorAssertion, AssistantMessage, ImageContent, Model, UserMessage } from "../llm/index.js";
+import type { HaltRemainingDirective } from "../loop/types.js";
 import type { AgentMessage, AgentTool, LoopMalformedToolUseRecovery, LoopThinkingOnlyRecovery, LoopTruncatedOutputRecovery, QueueMode, ThinkingLevel } from "../loop/types.js";
 import { type EngineSegment } from "../../core/untrusted-text.js";
 import type { AbortResult, AgentHarnessEvent, AgentHarnessEventResultMap, AgentHarnessOptions, AgentHarnessOwnEvent, AgentHarnessResources, AgentHarnessStreamOptions, ExecutionEnv, PromptTemplate, Skill } from "./types.js";
@@ -24,6 +25,16 @@ export interface HaltConsumption {
         readonly sources: ReadonlyArray<StopRequestSource>;
     };
 }
+/** `prompt()` option: settle the transcript's trailing UNANSWERED tool batch through the loop's own batch pipeline
+ *  BEFORE the prompt is delivered (a resumed run whose suspended batch still holds unanswered calls). `halt` settles
+ *  every unanswered call as not-executed instead (the batch-halt form). No unanswered tail ⇒ a no-op. */
+export interface TrailingToolBatchOptions {
+    readonly halt?: HaltRemainingDirective;
+}
+/** `prompt()` option: called when the prompt and next-turn queue's messages enter the loop transcript, before
+ *  their frames are emitted and committed. Not called when a trailing-batch settlement ends the run first — the
+ *  caller then still owns whatever the prompt was carrying. */
+export type PromptDeliveredCallback = () => void;
 export interface UserMessageProvenance {
     /** Exact char length of the engine-prepended prefix on `text` (first-frame reminders etc.).
      *  Sugar for the single segment `[0, chars)` — when `engineSegments` is also supplied, segments win. */
@@ -124,6 +135,14 @@ export declare class AgentHarness<TSkill extends Skill = Skill, TPromptTemplate
     readonly env: ExecutionEnv;
     private session;
     private phase;
+    /** Can an engine injection land at a turn boundary RIGHT NOW? A producer choosing a destination
+     *  BEFORE it commits (the session notification route) needs this as a fact, not as a rejected
+     *  promise afterwards. Three conjuncts, each a condition a later stage enforces: a turn must EXIST
+     *  (`steer`/`followUp` throw while idle); the run must not be UNWINDING; it must not be STOPPING
+     *  (`halt()` / `requestStopAfterTurn()` latch a source and the loop exits at the next boundary) —
+     *  the phase reads `"turn"` through all of that. Nothing awaits between this read and the injection
+     *  it gates, so a `true` cannot go stale under its caller. */
+    get acceptsInjections(): boolean;
     /** design/74 R3-A: the one-way clean-stop latch — SET iff this set is non-empty. When set, the boundary consults
      *  answer true so the loop exits CLEANLY (emit `agent_end` + return) WITHOUT an abort/interrupt — the path a
      *  resource-slice suspend needs (an abort would trip the orphan-[INTERRUPTED] reconcile = corrupt resume). It is
@@ -136,6 +155,7 @@ export declare class AgentHarness<TSkill extends Skill = Skill, TPromptTemplate
      *  per turn, so identity carries the generation); the loop's cut-consumption report is accepted for THIS seat only. */
     private lastPublishedSeat?;
     private readonly seatCutSources;
+    private trailingBatchEndedOn?;
     private turnCutConsumed?;
     /** backlog #389 — one-way latch set by {@link abort}. Read by `drainQueuedMessages`: no boundary may
      *  hand a queued frame to the model once the run is unwinding, and — crucially — none may SPLICE one
@@ -208,6 +228,26 @@ export declare class AgentHarness<TSkill extends Skill = Skill, TPromptTemplate
      *  clearing, so they are LEFT STANDING (the durable-park migration reads them AFTER abort()
      *  returns) and the abort-side pass is the belt for an exit that never reached agent_end. */
     private sweepUndrainedEngineNotes;
+    /**
+       * How much of a PERSON's input is currently accepted-but-unserved, per lane — the one predicate behind
+       * both readers below, so "a person's input is waiting" cannot come to mean two things. Engine-AUTHORED
+       * frames are excluded, and the IN-FLIGHT slot counts (a frame spliced out of a queue and never injected
+       * is as pending as one that never left it).
+     */
+    private pendingUserInputsByLane;
+    /**
+     * Is a PERSON's input waiting for this run's NEXT TURN BOUNDARY? The live read face over
+     * {@link pendingUserInputsByLane}, for the producer that must decide whether to YIELD that boundary
+     * sooner — the shell's auto-backgrounding leg.
+     *
+       * THE STEER LANE ONLY: the follow-up lane's contract is delivery at the run's natural
+       * would-otherwise-stop seat, which backgrounding a command cannot bring forward.
+       * `announceUndrainedUserInputs` still reads both lanes.
+     *
+       * Synchronous and side-effect-free by contract, the same posture as {@link pendingInjectionCount}:
+       * nothing is awaited between the read and the action it gates. An UNWINDING run answers `false`.
+     */
+    hasPendingUserInput(): boolean;
     /** backlog #259 — what remains in the steer/follow-up queues AFTER the engine-note sweep is USER
      *  input that was accepted ("queued") and will never be consumed: the run reached agent_end first.
      *  User inputs have no redelivery semantics (unlike engine notes — a steer aimed at a finished run
@@ -320,6 +360,8 @@ export declare class AgentHarness<TSkill extends Skill = Skill, TPromptTemplate
      *  zero-assistant ending still throws (see the executeTurn tail). */
     prompt(text: string, options?: {
         images?: ImageContent[];
+        settleUnansweredToolCalls?: TrailingToolBatchOptions;
+        onDelivered?: PromptDeliveredCallback;
     } & UserMessageProvenance): Promise<AssistantMessage | undefined>;
     /** R2-③: an empty/whitespace-only injection with no images carries ZERO information — it
      *  must not mint a user frame (strict endpoints reject empty user content, and an empty follow-up would

package/dist/engine/harness/agent-harness.js

@@ -187,6 +187,9 @@ export class AgentHarness {
     env;
     session;
     phase = "idle";
+    get acceptsInjections() {
+        return this.phase !== "idle" && !this.aborting && !this.stopRequested;
+    }
     stopRequestSources = new Set();
     get stopRequested() {
         return this.stopRequestSources.size > 0;
@@ -194,6 +197,7 @@ export class AgentHarness {
     boundaryStopConsumed;
     lastPublishedSeat;
     seatCutSources = new WeakMap();
+    trailingBatchEndedOn;
     turnCutConsumed;
     aborting = false;
     drainedPendingInjection = [];
@@ -229,12 +233,20 @@ export class AgentHarness {
             }
         }
     }
-    announceUndrainedUserInputs() {
+    pendingUserInputsByLane() {
         const inFlight = (lane) => this.drainedPendingInjection.filter((m) => !engineAuthoredInjections.has(m) && drainedFromLane.get(m) === lane).length;
-        const counts = {
+        return {
             steer: this.steerQueue.filter((m) => !engineAuthoredInjections.has(m)).length + inFlight("steer"),
             followUp: this.followUpQueue.filter((m) => !engineAuthoredInjections.has(m)).length + inFlight("followUp"),
         };
+    }
+    hasPendingUserInput() {
+        if (this.aborting)
+            return false;
+        return this.pendingUserInputsByLane().steer > 0;
+    }
+    announceUndrainedUserInputs() {
+        const counts = this.pendingUserInputsByLane();
         if ((counts.steer > 0 || counts.followUp > 0) && this.onUndrainedUserInputs) {
             try {
                 this.onUndrainedUserInputs(counts);
@@ -826,29 +838,7 @@ export class AgentHarness {
     }
     async executeTurn(turnState, text, options) {
         let activeTurnState = turnState;
-        let messages = [createUserMessage(text, options?.images, options)];
-        if (this.nextTurnQueue.length > 0) {
-            const queuedMessages = this.nextTurnQueue.splice(0);
-            try {
-                await this.emitQueueUpdate();
-            }
-            catch (error) {
-                this.nextTurnQueue.unshift(...queuedMessages);
-                throw normalizeHookError(error);
-            }
-            for (const m of queuedMessages) {
-                const payload = engineNotePayloads.get(m);
-                if (payload !== undefined) {
-                    try {
-                        this.onEngineNoteConsumed?.(payload);
-                    }
-                    catch {
-                    }
-                }
-                engineNotePayloads.delete(m);
-            }
-            messages = [...queuedMessages, messages[0]];
-        }
+        const userMessage = createUserMessage(text, options?.images, options);
         const beforeResult = await this.emitHook({
             type: "before_agent_start",
             prompt: text,
@@ -856,9 +846,35 @@ export class AgentHarness {
             systemPrompt: turnState.systemPrompt,
             resources: turnState.resources,
         });
-        if (beforeResult?.messages) {
-            messages = [...messages, ...beforeResult.messages];
-        }
+        const takePrompts = async () => {
+            let messages = [userMessage];
+            if (this.nextTurnQueue.length > 0) {
+                const queuedMessages = this.nextTurnQueue.splice(0);
+                try {
+                    await this.emitQueueUpdate();
+                }
+                catch (error) {
+                    this.nextTurnQueue.unshift(...queuedMessages);
+                    throw normalizeHookError(error);
+                }
+                for (const m of queuedMessages) {
+                    const payload = engineNotePayloads.get(m);
+                    if (payload !== undefined) {
+                        try {
+                            this.onEngineNoteConsumed?.(payload);
+                        }
+                        catch {
+                        }
+                    }
+                    engineNotePayloads.delete(m);
+                }
+                messages = [...queuedMessages, messages[0]];
+            }
+            if (beforeResult?.messages) {
+                messages = [...messages, ...beforeResult.messages];
+            }
+            return messages;
+        };
         const abortController = new AbortController();
         const getTurnState = () => activeTurnState;
         const setTurnState = (nextTurnState) => {
@@ -867,7 +883,20 @@ export class AgentHarness {
         this.runAbortController = abortController;
         const runResultPromise = (async () => {
             try {
-                return await runAgentLoop(messages, this.createContext(turnState, beforeResult?.systemPrompt), this.createLoopConfig(getTurnState, setTurnState, beforeResult?.systemPrompt), (event) => this.handleAgentEvent(event, abortController.signal), abortController.signal, this.createStreamFn(getTurnState), undefined, this.loopTrace);
+                return await runAgentLoop(takePrompts, this.createContext(turnState, beforeResult?.systemPrompt), this.createLoopConfig(getTurnState, setTurnState, beforeResult?.systemPrompt), (event) => this.handleAgentEvent(event, abortController.signal), abortController.signal, this.createStreamFn(getTurnState), undefined, this.loopTrace, {
+                    ...(options?.settleUnansweredToolCalls !== undefined
+                        ? {
+                            settle: {
+                                ...(options.settleUnansweredToolCalls.halt !== undefined ? { halt: options.settleUnansweredToolCalls.halt } : {}),
+                                report: (outcome) => {
+                                    if (outcome.aborted)
+                                        this.trailingBatchEndedOn = outcome.assistantMessage;
+                                },
+                            },
+                        }
+                        : {}),
+                    ...(options?.onDelivered !== undefined ? { onPromptsDelivered: options.onDelivered } : {}),
+                });
             }
             catch (error) {
                 try {
@@ -889,6 +918,8 @@ export class AgentHarness {
             }
             if (this.stopRequested)
                 return undefined;
+            if (this.trailingBatchEndedOn !== undefined)
+                return this.trailingBatchEndedOn;
             throw new AgentHarnessError("invalid_state", "AgentHarness prompt completed without an assistant message");
         }
         finally {
@@ -904,6 +935,7 @@ export class AgentHarness {
         if (this.phase !== "idle") {
             throw new AgentHarnessError("busy", "AgentHarness is busy");
         }
+        this.trailingBatchEndedOn = undefined;
         this.stopRequestSources.clear();
         this.boundaryStopConsumed = undefined;
         this.turnCutConsumed = undefined;

package/dist/engine/loop/agent-loop.d.ts

@@ -1,5 +1,29 @@
+/**
+ * First-party agent loop (design/118 ④a — de-vendoring 4/6).
+ *
+ * Rewritten from the vendored openclaw distillation with the loop's control flow made EXPLICIT as a
+ * state machine (the CC query.ts State/transition shape, sema deps injected): every "go around again"
+ * is a named {@link LoopContinue} and every exit is a named {@link LoopTerminal}, so tests can assert
+ * WHICH path ran (test/loop-transitions.test.ts) instead of inferring it from event order. ④a is
+ * behavior-1:1 with the vendored loop — no new recovery chains; those land in ④b as new Continue
+ * reasons on this skeleton.
+ *
+ * Load-bearing invariants carried over verbatim (the VENDORED EDIT provenance comments are kept at
+ * their sites as history):
+ * - A-1 layer ② abort-before-stream guard (a mid-batch abort must never reach the next provider
+ *   request) — {@link runSingleTurn} entry guard, Terminal `aborted_before_stream`.
+ * - Durable double-execution gate (a deferred parallel tool closure must never run its side effect
+ *   after a mid-batch suspend/abort) — {@link executePreparedToolCall} entry guard.
+ * - D4 post-hook posture (afterToolCall throw must not rewrite a committed side effect into a flat
+ *   failure) — {@link finalizeExecutedToolCall}.
+ * - The TWO queue drain points (1.204 priority wiring基石): steer drains at every turn end
+ *   (Continue `steer_injected` / mid-work boundary), followUp drains only when the agent would
+ *   otherwise stop (Continue `follow_up_injected`). Never merge these into one queue.
+ * - text_delta.partial reconstruction (upstream cherry-pick 6fcc945702).
+ */
+import type { AssistantMessage, ToolResultMessage } from "../llm/index.js";
 import { type AgentCoreStreamRuntimeDeps } from "./runtime-deps.js";
-import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, StreamFn } from "./types.js";
+import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, HaltRemainingDirective, StreamFn } from "./types.js";
 /** Callback used by synchronous loop runners to publish agent lifecycle events. */
 export type AgentEventSink = (event: AgentEvent) => Promise<void> | void;
 /** Named reasons the loop goes around again. Assertable in tests via the trace sink. */
@@ -88,8 +112,48 @@ export type LoopStep = {
  * `next_turn`), then `next_turn`. Don't read the trace as a complete enumeration of concurrent causes.
  */
 export type LoopTraceSink = (step: LoopStep) => void;
-/** Run a prompt-started loop and emit events through a caller-owned sink. */
-export declare function runAgentLoop(prompts: AgentMessage[], context: AgentContext, config: AgentLoopConfig, emit: AgentEventSink, signal?: AbortSignal, streamFn?: StreamFn, runtime?: AgentCoreStreamRuntimeDeps, trace?: LoopTraceSink): Promise<AgentMessage[]>;
+/**
+ * A request to settle the transcript's trailing UNANSWERED tool batch before the prompts are delivered
+ * (a resumed run whose suspended batch still holds calls no tool result answers). The batch is settled
+ * as ONE turn of the loop: the live batch pipeline under a turn-scoped interrupt seat, the interrupted-
+ * turn settlement when that seat is cut, then the ordinary turn boundary (`prepareNextTurn` + the stop
+ * consult). `halt` settles every call as not-executed instead (the batch-halt form). `report` receives
+ * the outcome once; `aborted` means the run ENDED before the prompts were delivered (the run signal
+ * fired, or the boundary / the interrupt settlement stopped the run).
+ */
+export interface TrailingToolBatchSettlement {
+    halt?: HaltRemainingDirective;
+    report: (outcome: {
+        assistantMessage: AssistantMessage;
+        settled: number;
+        aborted: boolean;
+    }) => void;
+}
+/** The caller-facing seams of a prompt run beyond the prompts themselves: an optional trailing-batch
+ *  settlement, and the moment the prompts enter the loop transcript, before their frames are emitted
+ *  — delivery accounts precede the carrying messages' commits. */
+export interface RunAgentLoopSeams {
+    settle?: TrailingToolBatchSettlement;
+    onPromptsDelivered?: () => void;
+}
+/** The last assistant message of `messages` when at least one of its tool calls has no tool result after it. */
+export declare function findUnansweredToolBatch(messages: readonly AgentMessage[]): AssistantMessage | undefined;
+/**
+ * Settle the unanswered tool calls of `assistantMessage` (the batch tail a suspended run left open):
+ * ONE pipeline with the live turn — the same partition, concurrency cap, preflight gate (a call may
+ * suspend again), execution and source-ordered result commit — or, under `halt`, the same not-executed
+ * settlement a batch-halt directive applies to never-started siblings. Every unanswered call gets a
+ * tool result unless the signal fires mid-batch (the dangling remainder is the suspended batch's own shape).
+ */
+export declare function settleUnansweredToolCalls(context: AgentContext, assistantMessage: AssistantMessage, config: AgentLoopConfig, signal: AbortSignal | undefined, emit: AgentEventSink, halt?: HaltRemainingDirective): Promise<ExecutedToolCallBatch>;
+/** Run a prompt-started loop and emit events through a caller-owned sink. `prompts` may be a thunk: it is
+ *  taken only when the prompts are about to be delivered, so a caller whose prompt assembly CONSUMES queued
+ *  input (a harness draining its next-turn queue) loses nothing when a trailing-batch settlement ends the run first. */
+export declare function runAgentLoop(prompts: AgentMessage[] | (() => Promise<AgentMessage[]>), context: AgentContext, config: AgentLoopConfig, emit: AgentEventSink, signal?: AbortSignal, streamFn?: StreamFn, runtime?: AgentCoreStreamRuntimeDeps, trace?: LoopTraceSink, seams?: RunAgentLoopSeams): Promise<AgentMessage[]>;
+type ExecutedToolCallBatch = {
+    messages: ToolResultMessage[];
+    terminate: boolean;
+};
 /**
  * How many tool names an unknown-tool miss spells out. A miss is a NAME problem: seeing a couple of dozen
  * real names is what lets a model spot the one it meant, while a full listing grows with the deployment
@@ -110,3 +174,4 @@ export declare const TOOL_VALIDATION_REFUSED_CODE = "tool.validation_refused";
  *  reported on the fault seat): a validator is a precondition read, not a network call, so a single
  *  bound serves every tool; a deployment validator that needs longer is a validator doing too much. */
 export declare const TOOL_INPUT_VALIDATION_TIMEOUT_MS = 10000;
+export {};

package/dist/engine/loop/agent-loop.js

@@ -20,20 +20,110 @@ function resolveAssistantMessageUpdate(event, currentMessage) {
     }
     return currentMessage;
 }
-export async function runAgentLoop(prompts, context, config, emit, signal, streamFn, runtime, trace) {
-    const newMessages = [...prompts];
-    const currentContext = {
-        ...context,
-        messages: [...context.messages, ...prompts],
-    };
+export function findUnansweredToolBatch(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        if (m.role !== "assistant")
+            continue;
+        return unansweredToolCallsOf(m, messages.slice(i + 1)).length > 0 ? m : undefined;
+    }
+    return undefined;
+}
+function unansweredToolCallsOf(assistantMessage, after) {
+    const answered = new Set(after.filter((m) => m.role === "toolResult").map((m) => m.toolCallId));
+    const seen = new Set();
+    const unanswered = [];
+    for (const c of assistantMessage.content) {
+        if (c.type !== "toolCall" || answered.has(c.id) || seen.has(c.id))
+            continue;
+        seen.add(c.id);
+        unanswered.push(c);
+    }
+    return unanswered;
+}
+export async function settleUnansweredToolCalls(context, assistantMessage, config, signal, emit, halt) {
+    const at = context.messages.lastIndexOf(assistantMessage);
+    const toolCalls = unansweredToolCallsOf(assistantMessage, at >= 0 ? context.messages.slice(at + 1) : context.messages);
+    if (toolCalls.length === 0)
+        return { messages: [], terminate: false };
+    if (halt !== undefined) {
+        const messages = [];
+        for (const toolCall of toolCalls) {
+            if (signal?.aborted)
+                break;
+            messages.push((await settleHaltedToolCall(toolCall, halt, emit)).message);
+        }
+        return { messages, terminate: true };
+    }
+    return config.toolExecution === "sequential"
+        ? executeToolCallsSequential(context, assistantMessage, toolCalls, config, signal, emit)
+        : executeToolCallsPartitioned(context, assistantMessage, toolCalls, config, signal, emit);
+}
+export async function runAgentLoop(prompts, context, config, emit, signal, streamFn, runtime, trace, seams) {
+    const state = await createLoopState({ ...context, messages: [...context.messages] }, config, []);
     await emit({ type: "agent_start" });
     await emit({ type: "turn_start" });
-    for (const prompt of prompts) {
+    if (seams?.settle !== undefined && (await settleTrailingBatchTurn(state, signal, emit, seams.settle)) === "ended") {
+        return state.newMessages;
+    }
+    const delivered = typeof prompts === "function" ? await prompts() : prompts;
+    if (delivered.length > 0)
+        state.hasMoreToolCalls = true;
+    state.context.messages.push(...delivered);
+    state.newMessages.push(...delivered);
+    seams?.onPromptsDelivered?.();
+    for (const prompt of delivered) {
         await emit({ type: "message_start", message: prompt });
         await emit({ type: "message_end", message: prompt });
     }
-    await runLoop(currentContext, newMessages, config, signal, emit, streamFn, runtime, trace);
-    return newMessages;
+    await runLoop(state, signal, emit, streamFn, runtime, trace);
+    return state.newMessages;
+}
+async function settleTrailingBatchTurn(state, signal, emit, settle) {
+    const tail = findUnansweredToolBatch(state.context.messages);
+    if (tail === undefined)
+        return "continue";
+    const turnController = new AbortController();
+    const onRunAbort = () => turnController.abort();
+    if (signal !== undefined) {
+        if (signal.aborted)
+            turnController.abort();
+        else
+            signal.addEventListener("abort", onRunAbort, { once: true });
+    }
+    state.config.publishTurnInterruptSeat?.(turnController);
+    let batch;
+    try {
+        batch = await settleUnansweredToolCalls(state.context, tail, state.config, turnController.signal, emit, settle.halt);
+    }
+    finally {
+        state.config.publishTurnInterruptSeat?.(undefined);
+        signal?.removeEventListener("abort", onRunAbort);
+    }
+    state.context.messages.push(...batch.messages);
+    state.newMessages.push(...batch.messages);
+    let ended = signal?.aborted === true;
+    let terminalEmitted = false;
+    if (!ended && turnController.signal.aborted) {
+        state.config.noteTurnCutConsumed?.(turnController);
+        const pendingBeforeSettlement = state.pendingMessages;
+        const outcome = await settleInterruptedTurn(state, tail, new StreamToolExecutor(state.context, state.config, turnController.signal, emit), batch.messages, signal, emit);
+        ended = outcome.kind === "terminal";
+        if (!ended)
+            state.pendingMessages.unshift(...pendingBeforeSettlement);
+        terminalEmitted = ended;
+    }
+    else if (!ended) {
+        const boundary = { message: tail, toolResults: batch.messages, context: state.context, newMessages: state.newMessages };
+        adoptNextTurnSnapshot(state, await state.config.prepareNextTurn?.(boundary));
+        ended = (await state.config.shouldStopAfterTurn?.(boundary)) === true || signal?.aborted === true;
+        if (!ended)
+            state.pendingMessages.push(...((await state.config.getSteeringMessages?.()) || []));
+    }
+    settle.report({ assistantMessage: tail, settled: batch.messages.length, aborted: ended });
+    if (ended && !terminalEmitted)
+        await emit({ type: "agent_end", messages: state.newMessages });
+    return ended ? "ended" : "continue";
 }
 const PROMPT_TOO_LONG_RE = /context.{0,3}length|context_length|context window (?:limit|exceeded)|reached its context window|prompt is too long|too many tokens|maximum context|exceeds? .{0,30}(?:context|token)|input is too long|\b413\b/i;
 function isBlankFailureContent(message) {
@@ -140,21 +230,23 @@ function createContinueNudge() {
         timestamp: Date.now(),
     };
 }
-async function runLoop(initialContext, newMessages, initialConfig, signal, emit, streamFn, runtime, trace) {
-    const state = {
-        context: initialContext,
-        config: initialConfig,
+async function createLoopState(context, config, newMessages) {
+    return {
+        context,
+        config,
         newMessages,
         firstTurn: true,
-        pendingMessages: (await initialConfig.getSteeringMessages?.()) || [],
+        pendingMessages: (await config.getSteeringMessages?.()) || [],
         hasMoreToolCalls: true,
         truncatedOutputContinues: 0,
-        staticReasoningCutRecoveries: initialContext.messages.filter((m) => m.role === "assistant" && m.staticReasoningCut === true).length,
+        staticReasoningCutRecoveries: context.messages.filter((m) => m.role === "assistant" && m.staticReasoningCut === true).length,
         degenerateContinues: 0,
         malformedToolUseRetries: 0,
         thinkingOnlyRetries: 0,
         midstreamPartialContinues: 0,
     };
+}
+async function runLoop(state, signal, emit, streamFn, runtime, trace) {
     while (true) {
         if (!state.hasMoreToolCalls && state.pendingMessages.length === 0) {
             const followUpMessages = (await state.config.getFollowUpMessages?.()) || [];
@@ -489,7 +581,8 @@ async function settleInterruptedTurn(state, message, executor, committedResults,
     const toolResults = [...committedResults];
     toolResults.push(...(await harvestExecutorOnErrorFinal(executor, state, message, signal, emit)));
     const turnCalls = message.content.filter((c) => c.type === "toolCall");
-    const answered = new Set(toolResults.map((r) => r.toolCallId));
+    const priorResults = state.context.messages.slice(state.context.messages.lastIndexOf(message) + 1).filter((m) => m.role === "toolResult");
+    const answered = new Set([...priorResults, ...toolResults].map((r) => r.toolCallId));
     for (const call of turnCalls) {
         if (answered.has(call.id))
             continue;

package/dist/index.d.ts

@@ -15,15 +15,18 @@ export { SESSION_LOG_DIGEST_SCHEME, sessionEntryDigest, sessionLogDigest, sessio
 export type { ResumeTaskConfig } from "./core/runner/runtask.js";
 export { defineTool } from "./core/tools.js";
 export { SKILL_TOOL_NAME } from "./core/runner/synthetic-tools.js";
+export { TOOL_SEARCH_POLICIES, TOOL_SEARCH_DEFAULT_THRESHOLD_PERCENT, TOOL_SEARCH_INVALID_CODE, type ToolSearchSetting, type ToolSearchPolicy, } from "./core/tool-search-setting.js";
+export type { ToolDisclosureSnapshot } from "./core/runner/deferral-census.js";
 export { createSkillsFromDirectory, type SkillsDirectoryOptions, type SkillsDirectoryWarning, type SkillsDirectoryWarningCode, } from "./core/skills-directory.js";
 export { REPORT_FINDINGS_TOOL_NAME, type ReportedFinding } from "./core/runner/synthetic-tools.js";
 export { formatToolError, formatZodValidationError, formatValidationPath, truncateError, errorClassOf } from "./core/tool-errors.js";
 export type { WorkerErrorClass } from "./core/tool-errors.js";
 export { createWebFetchTool, webFetchToolSpec, htmlToText, type WebFetchConfig, createWebSearchTool, type WebSearchConfig, createSearxngSearchBackend, probeSearchBackend, type SearxngBackendOptions, createWebFetchSummarizer, WEBFETCH_SUMMARY_MAX_CONTENT, WEBFETCH_SUMMARY_GUIDELINES, } from "./tools/web.js";
 export { createTodoWriteTool } from "./tools/todo.js";
-export { ARTIFACT_ACTIONS, ARTIFACT_PLANES, ARTIFACT_PUBLISH_CONTEXTS, ARTIFACT_LIST_SCOPES, ARTIFACT_PLANE_CONTENT_ORIGIN, ARTIFACT_ACTION_HOST_METHOD, ARTIFACT_HOST_FAILURE_CODES, ARTIFACT_FAILURE_RESULT_CODE, ARTIFACT_HOST_ERROR_CODE, ARTIFACT_CARD, readArtifactHostCapabilities, type ArtifactAction, type ArtifactPlane, type ArtifactPublishContext, type ArtifactListScope, type ArtifactHostFailureCode, type ArtifactResultCode, type ArtifactHost, type ArtifactHostCapabilities, type ArtifactHostCapabilitiesVerdict, type ArtifactCallContext, type ArtifactFileContent, type ArtifactPublishRequest, type ArtifactPublishOutcome, type ArtifactConflictSnapshot, type ArtifactListOutcome, type ArtifactReadOutcome, type ArtifactFilesOutcome, type ArtifactFileOutcome, type ArtifactRef, type ArtifactListRow, } from "./core/artifact-host.js";
+export { ARTIFACT_ACTIONS, ARTIFACT_PLANES, ARTIFACT_COMMIT_CERTAINTIES, ARTIFACT_COMMIT_THROW_OUTCOME, ARTIFACT_PUBLISH_CONTEXTS, ARTIFACT_LIST_SCOPES, ARTIFACT_PLANE_CONTENT_ORIGIN, ARTIFACT_ACTION_HOST_METHOD, ARTIFACT_ACTION_CONCURRENCY_SAFE, ARTIFACT_HOST_FAILURE_CODES, ARTIFACT_FAILURE_RESULT_CODE, ARTIFACT_HOST_ERROR_CODE, ARTIFACT_CARD, readArtifactHostCapabilities, type ArtifactAction, type ArtifactPlane, type ArtifactCommitCertainty, type ArtifactPublishContext, type ArtifactListScope, type ArtifactHostFailureCode, type ArtifactResultCode, type ArtifactHost, type ArtifactHostCapabilities, type ArtifactHostCapabilitiesVerdict, type ArtifactCallContext, type ArtifactFileContent, type ArtifactPublishRequest, type ArtifactPublishOutcome, type ArtifactConflictSnapshot, type ArtifactListOutcome, type ArtifactReadOutcome, type ArtifactFilesOutcome, type ArtifactFileOutcome, type ArtifactRef, type ArtifactListRow, } from "./core/artifact-host.js";
 export { createArtifactTool, artifactAttemptId, normalizePublishedPath, mediaTypeOf, type ArtifactToolOptions, type ArtifactLocalRead } from "./tools/artifact/artifact-tool.js";
 export { localArtifactStub, LocalArtifactStub, EVAL_STUB_URL_PREFIX, LOCAL_STUB_MAX_FILE_BYTES, LOCAL_STUB_MAX_TOTAL_BYTES, type LocalArtifactStubOptions } from "./tools/artifact/local-stub.js";
+export { ARTIFACT_CONFORMANCE_VECTORS, artifactConformanceVectors, runArtifactConformance, type ArtifactConformanceHooks, type ArtifactConformanceOptions, type ArtifactConformanceStatus, type ArtifactConformanceVector, type ArtifactConformanceResult, type ArtifactConformanceReport, } from "./tools/artifact/conformance.js";
 export { createTaskListTools, createMemoryTaskListStore, assertJsonMetadata, type TaskListItem, type TaskListStore } from "./tools/task-list.js";
 export { assembleCodeTools, type CodeToolsConfig, CODE_ROLE } from "./scenarios/full-body.js";
 export { TOOL_MODEL_GATE_CLASSES, isModelGatedForClass, type ToolModelGateRule } from "./core/tool-model-gate.js";
@@ -101,7 +104,7 @@ export { bashReversibilityProbe, bashReadBoundaryProbe, BASH_READONLY_DEFAULT_AL
 export { classifyCompoundReadonlyDetailed, formatOutOfRootReadApprovalOption, type BashReadonlyRootBoundary, type CompoundReadonlyVerdict, } from "./tools/fs/index.js";
 export { resolveBashTimeoutCaps } from "./tools/fs/index.js";
 export { READ_FACE_DEFAULT_DENY_ENTRIES, READ_FACE_BUILTIN_DENY_TABLE, READ_DENY_BUILTIN_TIERS, READ_DENY_DEFAULT_TIERS, resolveReadDenyBuiltins, compileReadDeny, type ReadDenyEntry, type ReadDenyMatcher, type NormalizedReadDenyEntry, type ReadDenyBuiltinTier, type ReadDenyBuiltinRow, type ReadDenyBuiltinConfig, } from "./tools/fs/index.js";
-export { deploymentReadFaceClampNotice, resolveReadFace, type ReadFace, type ReadFaceInputs } from "./tools/fs/index.js";
+export { deploymentFaceClampNotice, resolveContainmentFace, type ContainmentFace, type ContainmentFaceInputs, type ContainmentFaceKind, type ContainmentFaceLayer, } from "./tools/fs/index.js";
 export { WRITE_PROTECTED_DEFAULT_TABLE, resolveWriteProtectedTable, compileWriteProtection, type WriteProtectedEntry, type WriteProtectedRow, type WriteProtectedKind, type WriteProtectedHit, type WriteProtectionMatcher, } from "./core/write-protect.js";
 export { InMemoryToolResultStore, OFFLOAD_TOOL_NAME, DEFAULT_TOOL_RESULT_THRESHOLD_CHARS, assertSafeToolResultRef, buildToolResultRef, toolResultContentSegment, MAX_MINTED_TOOL_RESULT_REF_CHARS, type ToolResultProvenance, assertToolResultProvenanceMatch, normalizeToolResultProvenance, toolResultProvenanceOf, ToolResultRefConflictError, TOOL_RESULT_REF_CONFLICT_CODE, type ToolResultStore, type ToolResultSlice, type ToolResultDeletionReport, } from "./core/tool-result-store.js";
 export { InMemoryCheckpointStore, CheckpointError, mintCheckpointId, mintCheckpointToken, checkpointVersionOf, CURRENT_CHECKPOINT_VERSION, MAX_SUPPORTED_CHECKPOINT_VERSION, ORG_ADMISSION_CHECKPOINT_VERSION, F012_CHECKPOINT_VERSION, REAL_APPROVAL_CHECKPOINT_VERSION, RESOURCE_CHECKPOINT_VERSION, TOKEN_CHECKPOINT_VERSION, debitLedger, remainingBudgetMicroUsd, remainingTokens, winnerFromOutcome, validatePendingSteer, readPendingSteerQueue, appendPendingSteer, MAX_PENDING_STEER_CHARS, MAX_PENDING_STEER_ENTRIES, PENDING_STEER_QUEUE_BYTE_BUDGET_BYTES, PENDING_STEER_FROZEN_FIELDS, ACTOR_ASSERTION_FROZEN_FIELDS, MAX_ACTOR_FIELD_CHARS, MAX_STEER_INPUT_ID_CHARS, type ActorAssertion, type PendingSteerEntry, type PendingSteerInput, riskSeverity, buildRiskDescriptor, summarizeCheckpoint, type RiskDescriptor, type ProbeCause, type ProbeCauseOperands, type CheckpointStore, type CheckpointSummary, type Checkpoint, type CheckpointToken, type CheckpointGate, type CheckpointState, type SerializedCheckpointState, type CheckpointFaultMode, type PendingAction, type ResumeOutcome, type ResolvedOutcome, type ReopenReason, type ResolveExpectation, type TerminalClaimIntent, type TerminalClaimOutcome, type SafetyAxis, type RealApprovalGateBit, type ResourceLedger, type ResourceLimitReason, type PlatformLimitReason, type CheckpointRow, realApprovalOrgFact, resolveCheckpointStore, checkpointStoreExecutionUndeclared, } from "./core/checkpoint-store.js";
@@ -143,7 +146,7 @@ export { parkedToolIdentity } from "./core/tool-roster.js";
 export { type ToolCallIdentity } from "./core/fs-write-gate-policy.js";
 export { type RuleFaceView, catalogRuleFaceView } from "./core/permission-rules.js";
 export { DURABLE_HISTORY_NAMES } from "./engine/compaction/utils.js";
-export { describeStaticWiring, deriveWiringManifest, deriveAskEffective, resolveDeclaredDurability, resolveSubagentTranscriptTier, type SubagentTranscriptTier, resolveAskSeamForm, resolveQuestionSeam, countElicitOptIns, AUTO_MODE_ARM_REASONS, type AutoModeArmReason, type AutoModeArmFact, type WiringManifest, type WiringManifestMcpEntry, type WiringFacts, type WiringLegKind, type AskSeamForm, type AskEffective, type QuestionChannelState, type SeamProvenance, type ParkLaneReason, type ManifestDurability, type StaticWiringDeps, type StaticWiringSpec, } from "./core/wiring-manifest.js";
+export { describeStaticWiring, deriveWiringManifest, deriveAskEffective, resolveDeclaredDurability, resolveSubagentTranscriptTier, type SubagentTranscriptTier, resolveAskSeamForm, resolveQuestionSeam, countElicitOptIns, AUTO_MODE_ARM_REASONS, type AutoModeArmReason, type AutoModeArmFact, type WiringManifest, type WiringManifestMcpEntry, LSP_LANES, type LspLane, type WiringFacts, type WiringLegKind, type AskSeamForm, type AskEffective, type QuestionChannelState, type SeamProvenance, type ParkLaneReason, type ManifestDurability, type StaticWiringDeps, type StaticWiringSpec, } from "./core/wiring-manifest.js";
 export { probeParkRoundTrip, durableParkGapOf, durableParkGapFor, PARK_SELFCHECK_SCOPE_PREFIX, type ParkSelfCheckResult, type ParkProbeFinding, type ParkProbeFindingCode, } from "./core/park-selfcheck.js";
 export { type StoreDurability } from "./core/checkpoint-store.js";
 export { type StoreFidelity } from "./core/checkpoint-store.js";
@@ -174,7 +177,7 @@ export { AUTO_MODE_DENY_SOURCES, isAutoModeDenySource, type AutoModeDenySource }
 export { SETTLEMENT_KINDS, type SettlementKind, isSettlementKind, type Settlement, SETTLEMENT_IS_REFUSAL, DENIED_BY_VALUES, type DeniedBy, isDeniedBy, DENIED_BY_MAY_VETO, CLASSIFIER_DENY_CAUSES, type ClassifierDenyCause, isClassifierDenyCause, DENIED_BY_MAY_CARRY_CAUSE, type GateDisposition, type GateOutcome, screenGateOutcome } from "./core/gate-outcome.js";
 export { type AskCarry } from "./core/hooks.js";
 export { SWAPPABLE_DEP_SEATS, SWAP_SEAT_NOTICE, isSwappableDepSeat, screenSwappableDeps, type SwappableDepSeat, type SwappableDeps } from "./core/swappable-deps.js";
-export { parseAutoModeResponse, createAutoModeDecider, AUTO_MODE_UNAVAILABLE_CAUSES, isAutoModeUnavailableCause, classifierUnavailableDenyMessage, CLASSIFIER_PARSE_FAILURE_DENY_MESSAGE, type AutoModeUnavailableCause, type AutoModeVerdict, type AutoModeDecider, type AutoModeDeciderOptions, type AutoModeClassified, type AutoModeClassifyFn, type AutoModeClassifyInput, createAutoModeDenialTracker, denialLimitFallbackMessage, denialLimitSentence, unarmedWindow, type AutoModeDenialTracker, type AutoModeDenialLimitOptions, type DenialLimitCounts, type DenialLimitFallbackFace, type UnarmedDenialLimitFallback, type DenialLimitFallback, type DenialLimitVerdict, } from "./core/auto-mode.js";
+export { parseAutoModeResponse, createAutoModeDecider, AUTO_MODE_UNAVAILABLE_CAUSES, isAutoModeUnavailableCause, classifierUnavailableDenyMessage, CLASSIFIER_PARSE_FAILURE_DENY_MESSAGE, type AutoModeUnavailableCause, AUTO_MODE_CLASSIFIER_FALLBACKS, isAutoModeClassifierFallback, AUTO_MODE_FALLBACK_CAUSES, isAutoModeFallbackCause, type AutoModeClassifierFallback, type AutoModeFallbackCause, type AutoModeClassifierRound, type AutoModeLadderRung, type AutoModeVerdict, type AutoModeDecider, type AutoModeDeciderOptions, type AutoModeClassified, type AutoModeClassifyFn, type AutoModeClassifyInput, createAutoModeDenialTracker, denialLimitFallbackMessage, denialLimitSentence, unarmedWindow, type AutoModeDenialTracker, type AutoModeDenialLimitOptions, type DenialLimitCounts, type DenialLimitFallbackFace, type UnarmedDenialLimitFallback, type DenialLimitFallback, type DenialLimitVerdict, } from "./core/auto-mode.js";
 export { AUTO_MODE_DENIAL_LIMIT_DEFAULTS, AUTO_MODE_DENIAL_AUTO_DENY_DEFAULT_MS, AUTO_MODE_CLASSIFIER_MAX_TOKENS } from "./core/auto-mode-defaults.js";
 export { buildAutoModePrompt, renderAutoModeWindow, renderAutoModeAction, AUTO_MODE_DEFAULTS_SENTINEL, type AutoModeRules, type BuildAutoModePromptOptions, type AutoModeWindowOptions, } from "./core/auto-mode-prompt.js";
 export { AUTO_MODE_BASE_PROMPT, AUTO_MODE_PERMISSIONS_EXTERNAL } from "./core/auto-mode-prompt-assets.js";
@@ -212,6 +215,7 @@ export { adoptFilePermissionRuleStore, type AdoptFileRuleStoreResult } from "./s
 export { AdoptionError, assertAdoptionBootGate, readRootAdoptionFile, writeRootAdoptionFile, ROOT_ADOPTION_FILE, type AdoptionErrorCode, type AdoptionSource, type AdoptionReport, type AdoptionReceipt, type AdoptionLegReport, type AffectedDeploymentConfig, type RootAdoptionFile, } from "./stores/file/adoption/marker.js";
 export { adoptLocalDataRoot, ackAdoptionConfig, witnessAdoptionConfig, listAdoptionQuarantine, readAdoptionStatus, type AdoptionStatus, type AdoptLocalDataRootOptions, type AdoptLocalDataRootResult, type AdoptionCarriageLeg, type AdoptionCarriageLegContext, type AdoptionConfigWitnessReceipt, } from "./stores/file/adoption/adopt.js";
 export { formatHookFeedback, runToolGate, createHookEnvCapabilities, createPreToolUseConstraintPolicy, type PersistedRuleHit, type PersistedRuleHitRule, type PersistedRuleUnreadable, type PersistedRuleCoverage, type PersistedRuleAnswer, normalizePersistedRuleHit, type Hooks, type HookToolContext, type HookInvocationIdentity, type UserPromptSubmitContext, type PostToolBatchContext, type HookEnvCapabilities, type HookToolOutput, type PreToolUseResult, type PostToolUseResult, type UserPromptSubmitResult, type HookToolFailure, type PostToolUseFailureResult, type PostToolBatchCall, type PostToolBatchResult, type PreCompactContext, type PreCompactResult, type PostCompactContext, type StopFailureContext, type PermissionDeniedPayload, } from "./core/hooks.js";
+export { HOOK_FAMILIES, HOOKS_INVALID_CODE, type HookFamily, type WiringManifestHookEntry } from "./core/hook-seats.js";
 export { InMemoryMemoryStore, composeMemoryBlock, composeLayeredMemoryBlock, normalizeMemorySpec, type NormalizedMemorySpec, type MemorySpecInput, supportsConsolidation, supportsPeriodicConsolidation, firstSentence, expandLexicalTerms, lexicalSearchMatch, type Embedder, classifyPromotable, enforcePromotableWriteGate, guardedMemoryStore, MemoryGateError, detectSecret, enforceSecretWriteGate, enforceStructuredNoteSecretGate, type UtilityGate, type MemoryStore, type MemoryVectorMode, type ScoredMemory, type MemoryNoteHeader, type MemoryNoteRecord, type MemoryNoteType, type StructuredNoteInput, } from "./core/memory.js";
 export { MemoryEngine, FileMemoryEngineBackend, memoryBackendContract, assertMemoryBackendSearchEquivalence, type MemoryBackendContractHooks, buildMemoryInstruction, writableRootOf, truncateIndex, scanEntryFiles, deriveRepoKey, deriveRepoMemoryDir, deriveControlPlaneDir, deriveRepoControlPlaneDir, resolveMemoryEngineRoot, scopeDirName, ControlPlaneCorruptError, parseEntryFile, serializeEntryFile, computeEntryRev, entryFromFile, MEMORY_ORIGIN_CAUSES, committedOriginOf, originEquals, consolidationExposedFrontmatter, ambiguousOriginRepresentation, type OriginClearanceRow, type OriginClearanceEvent, type OriginClearanceShadow, committedDistilledOf, distilledEquals, type MemoryEntryDistilled, type MemoryEntryDistilledInput, CONSOLIDATION_DEFAULTS, ConsolidationRefusedError, MEMORY_SEARCH_SUPERSEDED_TAG, consolidationTypeEligible, deriveSupersededSet, memorySupersededNote, readIntentCredentials, supersessionFuseCeiling, memoryConsolidationRecommendedNotice, memoryConsolidationCommittedNotice, memoryConsolidationConflictNotice, memoryConsolidationIncompleteNotice, memoryConsolidationRefusedNotice, memoryConsolidationWithheldNotice, type ConsolidationGateRead, type ConsolidationGateRow, type ConsolidationIntent, type ConsolidationIntentCredentialRow, type ConsolidationLeaseSeat, type ConsolidationProductProposal, type ConsolidationProposal, type MemoryConsolidationOptions, type ConsolidationCommitReceipt, type ConsolidationReconcileReport, type ConsolidationResolveReceipt, type ConsolidationPlanSummary, type ConsolidationPlanFoldEvidence, type SessionMemoryStatus, DISTILLER_DEFAULT_MAX_INPUTS_PER_PRODUCT, LLM_DISTILLER_CONTRACT, LLM_DISTILLER_CONTRACT_DL2, LLM_DISTILLER_CONTRACT_DL3, LLM_DISTILLER_CONTRACTS, MEMORY_DISTILLER_CONTRACT_V1, contractGroupingDiff, driveConsolidationToFixpoint, isAliasModelId, llmPlanDistiller, mintExposurePartitionedPlan, mintLlmConsolidationPlan, MEMORY_DISTILLER_PURITY_CONTRACT_V1, detectCleanArmVerbatimLeak, type CleanArmLeakFinding, type CleanArmLeakVerdict, type MemoryDistillerPurityContract, openAiCompatChatSeat, parseJsonAnswer, planParseRepairs, sanitizeLlmGroups, scheduleUnderFuse, type ConsolidationDistillFn, type ConsolidationDriveCycleRow, type ConsolidationDriveEngine, type ConsolidationDriveResult, type ConsolidationFoldState, type DistillerCandidate, type DistillerChatAnswer, type DistillerChatFn, type DistillerChatRequest, type FuseSchedule, type LlmConsolidationPlan, type LlmConsolidationPlanArm, type LlmConsolidationPlanProduct, type LlmDistillerContract, type MintLlmConsolidationPlanResult, type PlanParseRepairs, type SanitizedLlmGroups, CONSOLIDATION_DRIVER_PLANS_DIR, CONSOLIDATION_DRIVER_RUNS_FILE, CONSOLIDATION_RUN_STOP_REASONS, archiveDistillerPlan, readConsolidationDriverRun, runMemoryConsolidationDriver, type ConsolidationDriverEngine, type ConsolidationDriverRunRow, type ConsolidationRunReceipt, type ConsolidationRunStopReason, type RunMemoryConsolidationOptions, isInstructionEntry, type MemoryEntryOrigin, type MemoryOriginCause, MEMORY_INSTRUCTION_TEMPLATE, MEMORY_RECALL_DISCIPLINE, MEMORY_PREFERENCE_DISCIPLINE, MEMORY_READONLY_NOTICE, MEMORY_CAPTURE_OPTOUT_NOTICE, memoryCaptureOptedOutNotice, memoryCaptureOptOutUnpersistedNotice, SESSION_CAPTURE_OPTOUT_DIR, markSessionCaptureOptOut, readSessionCaptureOptOut, listSessionCaptureOptOut, fileSessionCaptureRecordStore, type SessionCaptureOptOutRecord, type SessionCaptureOptOutMarkOutcome, type SessionCaptureRecordStore, readV2HeaderHints, type V2HeaderHints, LINEAGE_FILE, CHALLENGES_FILE, CHALLENGED_HISTORY_FILE, CHALLENGE_LEDGER_MAX_EVENTS, rebuildStrictControlPlaneLedger, type ControlPlaneRebuildReceipt, type StrictControlPlaneLedger, type ChallengeAssignment, type ChallengeEvent, type ChallengedHistoryRow, type LineagePendingTxn, type LineagePromotion, MEMORY_INDEX_FILENAME, MEMORY_INDEX_MAX_LINES, MEMORY_INDEX_MAX_BYTES, MEMORY_SEARCH_TOOL_NAME, MEMORY_GET_TOOL_NAME, MEMORY_INDEX_TOOL_NAME, MEMORY_ENGINE_TOOL_NAMES, type MemorySearchDetails, type MemorySearchHit, type CleanMemorySearchHit, type ExposedMemorySearchHit, MEMORY_EXPOSURE_BANNER, MEMORY_EXPOSURE_HANDLE_TAG, memoryExposureIndexRow, type MemoryGetDetails, type MemoryIndexDetails, type MemoryIndexRow, type CleanMemoryIndexRow, type ExposedMemoryIndexRow, STUB_ARCHIVED_LINE, DEFAULT_MAX_MEMORY_FILES, DEFAULT_MAX_ENTRY_DEPTH, DEFAULT_HARVEST_DEADLINE_MS, DEFAULT_HARVEST_FILE_BUDGET, MASS_DELETION_FUSE_RATIO, scanMemoryWrite, scanMemoryFileName, scanRemediation, MEMORY_FILENAME_SEGMENT_RE, renderAnnouncements, enqueueMemoryAnnouncement, drainMemoryAnnouncements, peekMemoryAnnouncements, bumpScanFuse, scanFuseCount, clearScanFuse, ANNOUNCEMENTS_FILE, MEMORY_ANNOUNCEMENTS_MAX, SCAN_FUSE_FILE, SCAN_FUSE_THRESHOLD, type MemoryAnnouncement, type ScanFinding, type MemoryEngineOptions, type MemoryInjection, type EntryProvenanceAccount, type TransferEvidence, type CommittedBinding, type CommittedEntrySnapshot, type CommittedScopeSnapshots, type EntryCustodyReport, erasureSelectHash, type EraseMemoryEntriesInput, type ErasureSelect, type ErasedBinding, type MemoryErasureAttestation, computeMemoryBundleHash, type MemoryExportBundle, type MemoryImportReport, type MemoryExportSnapshot, type MemoryBundleImportPlan, type BundleChallengeRow, type BundleLineageRow, type BundlePollutedSession, type MemoryBackend, type MemoryEntry, type MemoryEntryFrontmatter, type MemoryEntryHeader, type MemoryScopeEnumeration, type ScoredMemoryEntry, type NotePatch, type PatchReport, type MaterializedFile, type MemorySessionHandle, type HarvestReport, type HarvestRejection, type HarvestRejectionCode, type ParsedEntryFile, type ScannedEntryFile, SCOPE_SEGMENT_MAX_ENCODED, PROJECT_MARKER_PATH, encodeScopeSegment, decodeScopeSegment, parseScopeKey, formatUserScope, formatOrgScope, formatProjScope, formatUserProjScope, isPersonalScope, assertScopeContractPlacement, formatProjectMarker, parseProjectMarker, resolveProjectId, PROJECT_ID_REGEX, type ParsedScopeKey, migrateScope, type MigrateScopeReport, materializeEntriesToFiles, harvestFilesToPatches, projectionsToWriteBack, screenInboundEntries, REMOTE_HARVEST_PER_FILE_BYTES, REMOTE_MASS_DELETION_FUSE_RATIO, type RemoteMemoryFile, type RemoteMemoryBaseline, type RemoteMaterialization, type RemoteHarvestResult, type InboundEntryFinding, deriveProjectMemoryDir, deriveProjectControlDir, recordProjectIdHint, lookupProjectIdHint, PROJECT_ID_HINTS_FILE, reconcileMemoryEntries, nextSyncBaseline, mergeRecallHits, type MemorySyncCursor, type MemorySyncConflict, type MemorySyncPlan, type RecallSource, syncMemoryScope, type MemorySyncTransport, type MemorySyncRequestBody, type MemorySyncResponseBody, type MemorySyncClientConflict, type SyncMemoryScopeOptions, type MemorySyncClientResult, } from "./core/memory-engine/index.js";
 export { SHARED_MEMORY_READ_CAP_BYTES, SHARED_MEMORY_LIST_PAGE_SIZE, SharedMemoryStoreError, type SharedMemoryStoreProvider, type SharedMemoryStoreReader, type SharedMemoryPagedList, type SharedMemoryStoreInfo, type SharedMemoryDocumentEntry, type SharedMemorySnapshot, type SharedMemoryRequestContext, type MemoryListDetails, type MemoryReadDetails, } from "./core/shared-memory/types.js";
@@ -222,7 +226,7 @@ export { runMemoryConsolidation, CONSOLIDATION_SYSTEM_PROMPT, DEFAULT_CONSOLIDAT
 export { consolidateScope, advanceCursorAfterInline, type ConsolidateScopeDeps, type ConsolidateScopeOptions, } from "./core/consolidate-scope.js";
 export { resolveMemoryConsolidationDriver, type MemoryConsolidationDriverDeps, } from "./core/runner/memory-consolidation-driver.js";
 export { DEFAULT_COMPACTION_INSTRUCTIONS } from "./core/auto-compaction.js";
-export { DEFAULT_SYSTEM_PROMPT, CODE_AGENT_PROMPT, SUBAGENT_PROMPT, CODE_SYSTEM_PROMPT, MEMORY_GUIDANCE, MEMORY_SAFETY, MEMORY_HYGIENE, NO_PERSISTENT_MEMORY_NOTICE, OUTPUT_EFFICIENCY, CYBER_RISK, HARNESS_SECTION_ANCHOR, URL_SAFETY, SUMMARIZE_TOOL_RESULTS, EXECUTION_ENVIRONMENT, EXECUTION_ENVIRONMENT_OPEN_READS, harnessContext, buildEnvironmentContext, buildGitSnapshot, buildScratchpadSection, GIT_STATUS_MAX_CHARS, formatLocalDate, type EnvironmentFacts, defaultPromptProvider, composeSystemPrompt, composeConstitution, constitutionBlocks, type PromptBlock, analyzePromptCacheFriendliness, assertPromptCacheFriendly, type PromptProvider, type StablePromptContext, type PromptCacheReport, type PromptTextDeclaration, } from "./prompts/default.js";
+export { DEFAULT_SYSTEM_PROMPT, CODE_AGENT_PROMPT, SUBAGENT_PROMPT, CODE_SYSTEM_PROMPT, MEMORY_GUIDANCE, MEMORY_SAFETY, MEMORY_HYGIENE, NO_PERSISTENT_MEMORY_NOTICE, OUTPUT_EFFICIENCY, CYBER_RISK, HARNESS_SECTION_ANCHOR, URL_SAFETY, SUMMARIZE_TOOL_RESULTS, EXECUTION_ENVIRONMENT, EXECUTION_ENVIRONMENT_OPEN_READS, executionEnvironmentBlockFor, harnessContext, buildEnvironmentContext, buildGitSnapshot, buildScratchpadSection, GIT_STATUS_MAX_CHARS, formatLocalDate, type EnvironmentFacts, defaultPromptProvider, composeSystemPrompt, composeConstitution, constitutionBlocks, type PromptBlock, analyzePromptCacheFriendliness, assertPromptCacheFriendly, type PromptProvider, type StablePromptContext, type PromptCacheReport, type PromptTextDeclaration, } from "./prompts/default.js";
 export { SUPERVISOR_PROMPT, ORCHESTRATION_GUIDANCE, ORCHESTRATION_AWARENESS, GOAL_COMPLETION_GUIDANCE } from "./prompts/supervisor.js";
 export { compose, validatePack } from "./prompt-assembly/composer.js";
 export { SEMA_DEFAULT_PACK } from "./prompt-assembly/packs/sema-default.js";
@@ -233,6 +237,7 @@ export { buildTurnPromptSnapshot, loweringRecordFor, LOWERING_VERSION, PREFIX_IN
 export { CenterPromptSource, FilePromptArtifactStore, FilePromptSourceStateStore, MemoryPromptArtifactStore, MemoryPromptSourceStateStore, type PromptArtifactSource, type PromptArtifactStore, type PromptSourceState, type PromptSourceStateStore, } from "./prompt-assembly/artifact-store.js";
 export { stripEngineMetadata } from "./internal/llm.js";
 export { EVENT_PROMPT_REGISTRY, eventDefaultOn, type CompiledEventPrompt, type EventDedupe, type EventDefaultPolicy } from "./prompt-assembly/event-registry.js";
+export { contextUsageSections, type ContextUsageSection } from "./prompt-assembly/section-usage.js";
 export type { CompiledSection, ComposedPrompt, PackSectionDeclaration, PromptCacheClass, PromptCarrier, PromptMutability, PromptOwner, PromptPack, PromptRenderCadence, PromptRuntimeFacts, PromptSlot, PromptTrust, SectionRenderInputs, } from "./prompt-assembly/types.js";
 export { type ReasoningIntensity, type ReasoningResolution, type ResolvedReasoning, type ReasoningFormat, DEFAULT_EFFORT_LEVELS, REASONING_BUDGET_SHARE, isThinkingLevel, rankOf, resolveEffort, reasoningEffortLevelsOf, resolveBinary, reasoningBudgetShare, resolveReasoning, thinkingOffExpressible, declaredOffSpelling, type OffCapabilityModel, resolveReasoningProfile, type ReasoningTier, type ReasoningProfileFlags, } from "./brain/reasoning.js";
 export { DESIGN_REVIEW_PROMPTS, CODE_REVIEW_PROMPT, SCENARIO_REGISTRY, runScenario, type ScenarioId, type CodeReviewMode, type ScenarioProfile, type RunScenarioOptions, type RunScenarioResult, } from "./scenarios/scenario-registry.js";