agentfootprint 13.0.0 → 14.0.0

package/dist/types/core/agent/stages/toolCalls/batch/completion.d.ts

@@ -0,0 +1,19 @@
+import type { buildDispatchContext } from './dispatchContext.js';
+import type { buildToolEffectsOperations } from '../routing/effectsOperations.js';
+import type { TypedScope } from 'footprintjs';
+import type { AgentState } from '../../../types.js';
+import type { DispatchCall } from '../contracts/batchCall.js';
+type DispatchContext = ReturnType<ReturnType<typeof buildDispatchContext>['prepareDispatchContext']>;
+interface CompleteToolBatchFrame {
+    readonly askAnswered?: boolean;
+    readonly inputsLayer?: boolean;
+    readonly newHistory: DispatchContext['newHistory'];
+    readonly emitTransitionConflict: ReturnType<typeof buildToolEffectsOperations>['emitTransitionConflict'];
+    readonly iteration: number;
+    readonly transitionState: DispatchContext['transitionState'];
+    readonly toolCalls: readonly DispatchCall[];
+}
+/** The existing synchronous batchCompletion phase; no new await or checkpoint carrier. */
+export declare function completeToolBatch(scope: TypedScope<AgentState>, frame: CompleteToolBatchFrame): void;
+export {};
+//# sourceMappingURL=completion.d.ts.map

package/dist/types/core/agent/stages/toolCalls/batch/completion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/batch/completion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAE9D,KAAK,eAAe,GAAG,UAAU,CAC/B,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,wBAAwB,CAAC,CAClE,CAAC;AAEF,UAAU,sBAAsB;IAC9B,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC,YAAY,CAAC,CAAC;IACnD,QAAQ,CAAC,sBAAsB,EAAE,UAAU,CACzC,OAAO,0BAA0B,CAClC,CAAC,wBAAwB,CAAC,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC,iBAAiB,CAAC,CAAC;IAC7D,QAAQ,CAAC,SAAS,EAAE,SAAS,YAAY,EAAE,CAAC;CAC7C;AAED,0FAA0F;AAC1F,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,EAC7B,KAAK,EAAE,sBAAsB,GAC5B,IAAI,CAsBN"}

package/dist/types/core/agent/stages/toolCalls/batch/dispatchContext.d.ts

@@ -0,0 +1,37 @@
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { TypedScope } from 'footprintjs';
+import type { AgentState } from '../../../types.js';
+import type { LLMMessage } from '../../../../../provider-contract/types.js';
+import type { ToolArgs } from '../../../../../tools/runChain.js';
+import type { ToolResultStatus } from '../../../../../semantics/toolEffects.js';
+import type { TransitionBatchState } from '../contracts/callFacts.js';
+import type { DispatchCall } from '../contracts/batchCall.js';
+/** Compose the existing synchronous dispatchContext phase; no additional await or checkpoint state. */
+export declare function buildDispatchContext(deps: Pick<ToolCallsHandlerDeps, 'allowedSkillIds' | 'engagementPlan' | 'resultsLayer' | 'findings' | 'evidenceGate'>): {
+    prepareDispatchContext: (scope: TypedScope<AgentState>, toolCalls: readonly DispatchCall[], iteration: number) => {
+        newHistory: LLMMessage[];
+        frozenTurn: LLMMessage | undefined;
+        callbackHistory: () => LLMMessage[];
+        frozenArgsAt: (at: number) => ToolArgs | undefined;
+        batchResults: {
+            toolName: string;
+            result: string;
+            toolCallId: string;
+            status?: ToolResultStatus | undefined;
+        }[];
+        towers: {
+            readonly gate: import("../../../evidence/types.js").ResolvedEvidenceGate;
+            readonly corpus: import("../../../evidence/evidenceIndex.js").EvidenceCorpus;
+            readonly exempt: ReadonlySet<string>;
+            readonly standingOf: ReadonlyMap<string, import("../../../findings/types.js").StandingRow>;
+        } | undefined;
+        transitionState: TransitionBatchState;
+        runIdentity: {
+            tenant?: string | undefined;
+            principal?: string | undefined;
+            conversationId: string;
+        } | undefined;
+        env: Readonly<import("footprintjs").ExecutionEnv>;
+    };
+};
+//# sourceMappingURL=dispatchContext.d.ts.map

package/dist/types/core/agent/stages/toolCalls/batch/dispatchContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatchContext.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/batch/dispatchContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2CAA2C,CAAC;AAK5E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAEhF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAE9D,uGAAuG;AACvG,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,IAAI,CACR,oBAAoB,EACpB,iBAAiB,GAAG,gBAAgB,GAAG,cAAc,GAAG,UAAU,GAAG,cAAc,CACpF;oCAGQ,WAAW,UAAU,CAAC,aAClB,SAAS,YAAY,EAAE,aACvB,MAAM;;;+BA6CW,UAAU,EAAE;2BAMd,MAAM,KAAG,QAAQ,GAAG,SAAS;;sBAiC3C,MAAM;oBACR,MAAM;wBACF,MAAM;;;;;;;;;;;;;4BAgCuC,MAAM;;;;EAgBpE"}

package/dist/types/core/agent/stages/toolCalls/batch/execute.d.ts

@@ -0,0 +1,8 @@
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { PausableHandler, TypedScope } from 'footprintjs';
+import type { AgentState } from '../../../types.js';
+import type { ToolCallOperations } from '../compose.js';
+import type { DispatchCallRunner } from '../contracts/dispatchCall.js';
+/** The existing native batch handler: original waits, one serial call loop, and defined pause propagation. */
+export declare function buildToolBatchExecution(deps: ToolCallsHandlerDeps, operations: ToolCallOperations, dispatchCall: DispatchCallRunner): PausableHandler<TypedScope<AgentState>>['execute'];
+//# sourceMappingURL=execute.d.ts.map

package/dist/types/core/agent/stages/toolCalls/batch/execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/batch/execute.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAIpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAEvE,8GAA8G;AAC9G,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,oBAAoB,EAC1B,UAAU,EAAE,kBAAkB,EAC9B,YAAY,EAAE,kBAAkB,GAC/B,eAAe,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAuJpD"}

package/dist/types/core/agent/stages/toolCalls/batch/findingsAdmission.d.ts

@@ -0,0 +1,19 @@
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { TypedScope } from 'footprintjs';
+import type { AgentState } from '../../../types.js';
+import type { LLMMessage } from '../../../../../provider-contract/types.js';
+import type { ToolCatalogOperations } from '../contracts/operations/catalog.js';
+/** Compose the existing synchronous findingsAdmission phase; no additional await or checkpoint state. */
+export declare function buildFindingsAdmission(deps: Pick<ToolCallsHandlerDeps, 'findings'>, links: Pick<ToolCatalogOperations, 'peelCall' | 'turnStampOf'>): {
+    admitFindingsBatch: (scope: TypedScope<AgentState>) => {
+        toolCalls: {
+            readonly id: string;
+            readonly name: string;
+            readonly args: Readonly<Record<string, unknown>>;
+            readonly argumentsFailure?: LLMMessage['toolArgumentsFailure'];
+        }[];
+        iteration: number;
+        findingsRefusals: (string | undefined)[];
+    };
+};
+//# sourceMappingURL=findingsAdmission.d.ts.map

package/dist/types/core/agent/stages/toolCalls/batch/findingsAdmission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findingsAdmission.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/batch/findingsAdmission.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2CAA2C,CAAC;AAO5E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAEhF,yGAAyG;AACzG,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,CAAC,oBAAoB,EAAE,UAAU,CAAC,EAC5C,KAAK,EAAE,IAAI,CAAC,qBAAqB,EAAE,UAAU,GAAG,aAAa,CAAC;gCAE3B,WAAW,UAAU,CAAC;;yBAUtC,MAAM;2BACJ,MAAM;2BACN,SAAS,OAAO,MAAM,EAAE,OAAO,CAAC,CAAC;wCACpB,UAAU,CAAC,sBAAsB,CAAC;;;;;EA8DrE"}

package/dist/types/core/agent/stages/toolCalls/batch/inputResolutions.d.ts

@@ -0,0 +1,7 @@
+import type { TypedScope } from 'footprintjs';
+import type { AgentState } from '../../../types.js';
+import type { InputsDispatch } from '../contracts/inputsDispatch.js';
+import type { DispatchCall } from '../contracts/batchCall.js';
+/** Read this iteration's fills and consume only the already-used kept answers. */
+export declare function readBatchResolutions(scope: TypedScope<AgentState>, inputs: InputsDispatch | undefined, iteration: number, toolCalls: readonly Pick<DispatchCall, 'id' | 'name'>[], findingsRefusals: readonly unknown[]): ReadonlyMap<string, import("../../../arguments/resolve.js").ArgumentResolution> | undefined;
+//# sourceMappingURL=inputResolutions.d.ts.map

package/dist/types/core/agent/stages/toolCalls/batch/inputResolutions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputResolutions.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/batch/inputResolutions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAE9D,kFAAkF;AAClF,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,EAC7B,MAAM,EAAE,cAAc,GAAG,SAAS,EAClC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,SAAS,IAAI,CAAC,YAAY,EAAE,IAAI,GAAG,MAAM,CAAC,EAAE,EACvD,gBAAgB,EAAE,SAAS,OAAO,EAAE,+FAkBrC"}

package/dist/types/core/agent/stages/toolCalls/batch/paused.d.ts

@@ -0,0 +1,66 @@
+import type { TypedScope } from 'footprintjs';
+import type { AgentState } from '../../../types.js';
+import type { LLMMessage } from '../../../../../provider-contract/types.js';
+/**
+ * The args a `pauseHere` / `askHuman` call was running with, read back on the
+ * far side of the pause (8.13.0).
+ *
+ * Normally `scope.pausedToolArgs`: written at pause time from `callArgs`, so it
+ * is the post-transform args `ToolResultContext.args` promises.
+ *
+ * A checkpoint written BEFORE 8.13.0 does not carry the field — a real case
+ * during a rolling deploy. Those args are recovered from the assistant turn in
+ * `history` by `toolCallId`: real values the model proposed, identical to the
+ * running args unless a before-tool middleware transformed them, and that one
+ * difference is not recoverable from a checkpoint that never recorded it.
+ *
+ * `{}` is the last resort and only when the turn is gone (a window strategy
+ * folded it away). It is returned rather than skipping the after-tool moment,
+ * because a rule that never runs is the bug this release is fixing — but it is
+ * genuinely "we do not know", never a claim that the tool ran with none.
+ *
+ * `peel` (9.101.0, `.findings()`): the history fallback recovers the
+ * EMISSION — `toolCalls[].args` keep the reserved `_findings` argument by
+ * design — so under the arm it is peeled here exactly as the dispatch loop
+ * peeled it; `pausedToolArgs` was set from `callArgs` and is already peeled.
+ */
+export declare function argsForPausedCall(scope: TypedScope<AgentState>, toolCallId: string, peel?: boolean): Readonly<Record<string, unknown>>;
+/** One call the model proposed on an assistant turn (`LLMMessage.toolCalls`). */
+export type ProposedCall = NonNullable<LLMMessage['toolCalls']>[number];
+/**
+ * THE PAUSED BATCH (9.113.0) — the turn that proposed the paused call, and
+ * the calls on it that a pause left un-dispatched.
+ *
+ * The batch loop in `execute` dispatches a turn's calls one at a time, in the
+ * order the model proposed them, and every pause RETURNS from inside it: the
+ * checkpoint is taken on call k, and calls k+1..N were never reached — no
+ * gate judged them, no tool ran, no bracket opened. The resume paths used to
+ * answer call k and stop, so the next request carried N `tool_use` blocks and
+ * fewer `tool_result`s (a provider builds results only from `role: 'tool'`
+ * messages), and `iteration_end` counted one call.
+ *
+ * READ FROM `history`, NEVER CARRIED. Every pause site commits
+ * `scope.history = newHistory` before it returns, so the assistant turn that
+ * proposed the batch is on the checkpoint — and it is the very message a
+ * provider turns into the `tool_use` blocks the settlement must answer. It is
+ * therefore the one owner of "which calls does the next request carry", and
+ * the checkpoint gains no key: a checkpoint written before this release
+ * settles the same way. The window never removes the turn holding the paused
+ * call (`../../../window/turns.ts` · `refusalFor`, its `paused-tool` arm).
+ *
+ * The LATEST turn proposing the id is the paused one — the pause site commits
+ * that turn last, and a provider may reuse an id across turns. No such turn:
+ * `size: 0` and nothing to settle, the only answer a missing turn supports.
+ *
+ * A call after the paused one that history ALREADY answers — a `role: 'tool'`
+ * message for its id after that turn — is not un-dispatched, whoever wrote
+ * the answer. No library door writes one before the resume; a checkpoint is
+ * data, though, and an app may have patched results into a stored one.
+ * Settling such a call again would put a second result for its id on the
+ * next request, a shape a provider rejects.
+ */
+export declare function pausedBatchOf(history: readonly LLMMessage[], pausedToolCallId: string): {
+    readonly size: number;
+    readonly undispatched: readonly ProposedCall[];
+};
+//# sourceMappingURL=paused.d.ts.map

package/dist/types/core/agent/stages/toolCalls/batch/paused.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paused.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/batch/paused.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2CAA2C,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,EAC7B,UAAU,EAAE,MAAM,EAClB,IAAI,UAAQ,GACX,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAYnC;AAED,iFAAiF;AACjF,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,SAAS,UAAU,EAAE,EAC9B,gBAAgB,EAAE,MAAM,GACvB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,SAAS,YAAY,EAAE,CAAA;CAAE,CAgB3E"}

package/dist/types/core/agent/stages/toolCalls/batch/refusal.d.ts

@@ -0,0 +1,6 @@
+import type { TypedScope } from 'footprintjs';
+import type { AgentState } from '../../../types.js';
+import type { ToolBatchFailure } from '../../toolCallShape.js';
+/** Malformed protocol IDs cannot acquire fabricated tool-result correlations. */
+export declare function refuseToolBatch(scope: TypedScope<AgentState>, reason: ToolBatchFailure): void;
+//# sourceMappingURL=refusal.d.ts.map

package/dist/types/core/agent/stages/toolCalls/batch/refusal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refusal.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/batch/refusal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAIpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,iFAAiF;AACjF,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,gBAAgB,GAAG,IAAI,CA6B7F"}

package/dist/types/core/agent/stages/toolCalls/batch/settle.d.ts

@@ -0,0 +1,67 @@
+import type { TypedScope } from 'footprintjs';
+import type { AgentState } from '../../../types.js';
+import type { ToolResultStatus } from '../../../../../semantics/toolEffects.js';
+import type { LLMMessage } from '../../../../../provider-contract/types.js';
+/**
+ * Build the pausable tool-call handler for the agent's chart.
+ */
+/**
+ * Append one landed result to the iteration's tool-result batch (9.16.0).
+ *
+ * The execute path resets `scope.toolResults` before its dispatch loop and
+ * appends per call; the four RESUME paths go through here instead — the
+ * paused iteration's partial batch (every sibling that ran before the pause)
+ * is already committed on scope, and the answered call joins it in call
+ * order rather than erasing it. Spread first: a TypedScope array read is a
+ * live proxy view, and the batch must stay plain data.
+ */
+export declare function appendBatchResult(scope: TypedScope<AgentState>, entry: {
+    toolName: string;
+    result: string;
+    toolCallId: string;
+    status?: ToolResultStatus;
+}): void;
+/**
+ * What a call the paused batch never dispatched gets back (9.113.0) — ONE
+ * fixed sentence, on all four resume paths.
+ *
+ * Every clause is a past fact about one finished event, anchored by name: the
+ * call this result answers ("that call"), the call the run paused on (by id
+ * and by tool), and the resume. It names no destination. The design page's draft
+ * (`docs/design/2026-09-honest-answer-ledger.md`, § 5.5, "The batch
+ * settlement") ended "propose it again if still needed" — an instruction about a LATER call,
+ * re-read on every call after this one, the tool-less wrap-up included.
+ * Whether the call is still needed is the model's to judge from the facts;
+ * the surfaces recomposed per request (the tool list, the system prompt) own
+ * the present tense. Precedents: the 9.86.1 resumed-call refusal in this file
+ * ("was not executed on that call, and the resumed dispatch had no second
+ * checkpoint…") and `../../../selfCallNotice.ts` · `selfCallNotice`.
+ *
+ * "The run paused ON call …", never "call … paused the run": on two of the
+ * four doors the pause was a gate's, not the call's — a middleware's `ask`, a
+ * credential's consent need — and on all four the run paused AT that call.
+ *
+ * The sentence is for the MODEL. The same fact as data rides the settled
+ * message as `LLMMessage.notDispatched` and both of its brackets as
+ * `notDispatched` (`notDispatchedMarker`), and a reader asking "did this call
+ * run?" reads that — never this text.
+ *
+ * Exported for the producer registry (`test/modelFacingSurfaces.test.ts`).
+ */
+export declare function notDispatchedResult(toolName: string, paused: {
+    readonly toolName: string;
+    readonly toolCallId: string;
+}): string;
+/**
+ * The same fact as DATA (9.113.0) — the ONE composer of the settlement's
+ * marker, `{ pausedCall: { toolCallId, toolName } }`. The settled call's
+ * history message (`LLMMessage.notDispatched`) and both of its brackets
+ * (`ToolStartPayload.notDispatched`, `ToolEndPayload.notDispatched`) each take
+ * a fresh copy from here, so the three carriers can never disagree and no
+ * reader holds an object another reader holds.
+ */
+export declare function notDispatchedMarker(paused: {
+    readonly toolName: string;
+    readonly toolCallId: string;
+}): NonNullable<LLMMessage['notDispatched']>;
+//# sourceMappingURL=settle.d.ts.map

package/dist/types/core/agent/stages/toolCalls/batch/settle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settle.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/batch/settle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAChF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2CAA2C,CAAC;AAE5E;;GAEG;AACH;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,EAC7B,KAAK,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,gBAAgB,CAAA;CAAE,GACzF,IAAI,CAEN;AAKD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE;IAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GACjE,MAAM,CAMR;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,GAAG,WAAW,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,CAE3C"}

package/dist/types/core/agent/stages/toolCalls/batch/settlementOperations.d.ts

@@ -0,0 +1,18 @@
+import type { buildToolResolver } from '../../toolResolver.js';
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { ToolSettlementOperations } from '../contracts/operations/settlement.js';
+import type { ToolScriptsOperations } from '../contracts/operations/scripts.js';
+import type { ToolCatalogOperations } from '../contracts/operations/catalog.js';
+import type { ToolObservationsOperations } from '../contracts/operations/observations.js';
+interface ToolSettlementOperationsLinks {
+    readonly fileScript: ToolScriptsOperations['fileScript'];
+    readonly resolveTool: ReturnType<typeof buildToolResolver>;
+    readonly programOfCall: ToolScriptsOperations['programOfCall'];
+    readonly peelCall: ToolCatalogOperations['peelCall'];
+    readonly emitToolStart: ToolObservationsOperations['emitToolStart'];
+    readonly emitToolEnd: ToolObservationsOperations['emitToolEnd'];
+}
+/** Compose the existing settlement callbacks once for this handler. */
+export declare function buildToolSettlementOperations(deps: Pick<ToolCallsHandlerDeps, 'scriptRecord'>, links: ToolSettlementOperationsLinks): ToolSettlementOperations;
+export {};
+//# sourceMappingURL=settlementOperations.d.ts.map

package/dist/types/core/agent/stages/toolCalls/batch/settlementOperations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settlementOperations.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/batch/settlementOperations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AASxE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACtF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAChF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAChF,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AAE1F,UAAU,6BAA6B;IACrC,QAAQ,CAAC,UAAU,EAAE,qBAAqB,CAAC,YAAY,CAAC,CAAC;IACzD,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC3D,QAAQ,CAAC,aAAa,EAAE,qBAAqB,CAAC,eAAe,CAAC,CAAC;IAC/D,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAC,UAAU,CAAC,CAAC;IACrD,QAAQ,CAAC,aAAa,EAAE,0BAA0B,CAAC,eAAe,CAAC,CAAC;IACpE,QAAQ,CAAC,WAAW,EAAE,0BAA0B,CAAC,aAAa,CAAC,CAAC;CACjE;AAED,uEAAuE;AACvE,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,IAAI,CAAC,oBAAoB,EAAE,cAAc,CAAC,EAChD,KAAK,EAAE,6BAA6B,GACnC,wBAAwB,CAsH1B"}

package/dist/types/core/agent/stages/toolCalls/compose.d.ts

@@ -0,0 +1,240 @@
+import type { ToolCallsHandlerDeps } from './contracts/handlerDeps.js';
+import type { AuthorizationRequiredMode } from '../../../../identity/consent.js';
+/** Compose the existing callback families once per handler, preserving their construction order. */
+export declare function composeToolCallOperations(deps: ToolCallsHandlerDeps): {
+    resourceFactsOf: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>) => import("../../componentResources.js").ResourceFacts;
+    admitFindingsBatch: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>) => {
+        toolCalls: {
+            readonly id: string;
+            readonly name: string;
+            readonly args: Readonly<Record<string, unknown>>;
+            readonly argumentsFailure?: {
+                readonly reason: "invalid-json" | "invalid-argument-shape" | "incomplete-stream";
+            } | undefined;
+        }[];
+        iteration: number;
+        findingsRefusals: (string | undefined)[];
+    };
+    resolveTool: import("../toolResolver.js").ToolResolver;
+    runFactsOf: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>) => {
+        readonly runContext?: import("../../../../index.js").RunContext | undefined;
+        readonly runId: string;
+        readonly sessionId?: string | undefined;
+        readonly identity?: import("../../../../memory/index.js").MemoryIdentity | undefined;
+    } | undefined;
+    prepareDispatchContext: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, toolCalls: readonly import("./contracts/batchCall.js").DispatchCall[], iteration: number) => {
+        newHistory: import("../../../../index.js").LLMMessage[];
+        frozenTurn: import("../../../../index.js").LLMMessage | undefined;
+        callbackHistory: () => import("../../../../index.js").LLMMessage[];
+        frozenArgsAt: (at: number) => Readonly<Record<string, unknown>> | undefined;
+        batchResults: {
+            toolName: string;
+            result: string;
+            toolCallId: string;
+            status?: import("../../../../index.js").ToolResultStatus | undefined;
+        }[];
+        towers: {
+            readonly gate: import("../../evidence/types.js").ResolvedEvidenceGate;
+            readonly corpus: import("../../evidence/evidenceIndex.js").EvidenceCorpus;
+            readonly exempt: ReadonlySet<string>;
+            readonly standingOf: ReadonlyMap<string, import("../../findings/types.js").StandingRow>;
+        } | undefined;
+        transitionState: import("./contracts/callFacts.js").TransitionBatchState;
+        runIdentity: {
+            tenant?: string | undefined;
+            principal?: string | undefined;
+            conversationId: string;
+        } | undefined;
+        env: Readonly<import("footprintjs").ExecutionEnv>;
+    };
+    beginDispatchCall: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, tc: import("./contracts/batchCall.js").DispatchCall, iteration: number, towers: {
+        readonly gate: import("../../evidence/types.js").ResolvedEvidenceGate;
+        readonly corpus: import("../../evidence/evidenceIndex.js").EvidenceCorpus;
+        readonly exempt: ReadonlySet<string>;
+        readonly standingOf: ReadonlyMap<string, import("../../findings/types.js").StandingRow>;
+    } | undefined, callIndex: number, toolCalls: readonly import("./contracts/batchCall.js").DispatchCall[], findingsRefusals: readonly (string | undefined)[], frozenTurn: import("../../../../index.js").LLMMessage | undefined, callbackHistory: () => import("../../../../index.js").LLMMessage[], frozenArgsAt: (at: number) => Readonly<Record<string, unknown>> | undefined) => {
+        emitSecurity: import("../../toolSecurityEvents.js").ToolSecurityEmitter;
+        resolved: import("../toolResolver.js").ToolResolution;
+        tool: import("../../../../index.js").Tool<Record<string, unknown>, unknown> | undefined;
+        args: Readonly<Record<string, unknown>>;
+        proposedProgram: unknown;
+        viewOf: (source: Readonly<Record<string, unknown>>) => Readonly<Record<string, unknown>> | undefined;
+        historyForCallbacks: () => import("../../../../index.js").LLMMessage[];
+        startMs: number;
+        findingsRefusal: string | undefined;
+        invalidateViews: () => void;
+    };
+    permissionChecker: import("../../../../index.js").PermissionChecker | undefined;
+    unmountedRules: (tool: import("../../../../index.js").Tool<Record<string, unknown>, unknown> | undefined, toolName: string) => Promise<string> | undefined;
+    warnUnmountedToolPeriod: (tool: import("../../../../index.js").Tool<Record<string, unknown>, unknown> | undefined, toolName: string) => void;
+    decisionLedger: import("../../../consentRequest.js").DecisionLedger;
+    assertComponentDeliverable: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, toolName: string, component: unknown, door: string) => Promise<import("../../../../index.js").AskComponent>;
+    fileScript: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, call: {
+        readonly tool: import("../../../../index.js").Tool<Record<string, unknown>, unknown> | undefined;
+        readonly toolName: string;
+        readonly toolCallId: string;
+        readonly iteration: number;
+        readonly proposed: unknown;
+        readonly submitted?: unknown;
+        readonly settlement: import("../../scripts/label.js").CallSettlement;
+        readonly facts?: import("../../../codeRunnerTool.js").CodeRunFacts | undefined;
+        readonly withheld?: boolean | undefined;
+        readonly paused?: boolean | undefined;
+        readonly dispatch?: number | undefined;
+    }) => number | undefined;
+    programOfCall: (tool: import("../../../../index.js").Tool<Record<string, unknown>, unknown> | undefined, args: Readonly<Record<string, unknown>> | undefined) => unknown;
+    argumentRefusal: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, tool: import("../../../../index.js").Tool<Record<string, unknown>, unknown>, args: unknown, call: {
+        readonly toolName: string;
+        readonly toolCallId: string;
+        readonly iteration: number;
+    }) => string | undefined;
+    parkedNow: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>) => ReadonlySet<string> | undefined;
+    historyForCheckIn: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, history: readonly import("../../../../index.js").LLMMessage[]) => import("../../../../index.js").LLMMessage[];
+    resolveWantsAtDispatch: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, toolName: string, wants: Readonly<Record<string, string>>, args: Readonly<Record<string, unknown>>, inputSchema: Readonly<Record<string, unknown>> | undefined) => Promise<{
+        readonly ok: true;
+        readonly args: Readonly<Record<string, unknown>>;
+        readonly wanted?: Readonly<Record<string, import("../../../../index.js").ArtifactMeta>> | undefined;
+    } | {
+        readonly ok: false;
+        readonly refusal: string;
+    }>;
+    credentialsIn: (scope: object, service: string | undefined) => import("../../../../identity/types.js").CredentialProvider;
+    onAuthorizationRequired: AuthorizationRequiredMode;
+    dispatchRoster: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>) => import("../../../../lib/spokenIds.js").SpokenIds;
+    noteOffWire: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, resolved: import("../toolResolver.js").ToolResolution, call: {
+        readonly toolName: string;
+        readonly toolCallId: string;
+        readonly iteration: number;
+    }) => void;
+    hasCredentials: boolean;
+    toolArtifacts: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, toolName: string, toolCallId: string) => Pick<import("../../../../index.js").ToolExecutionContext, "artifacts" | "hasArtifacts">;
+    toolProgress: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, call: {
+        readonly toolName: string;
+        readonly toolCallId: string;
+        readonly iteration: number;
+    }) => Pick<import("../../../../index.js").ToolExecutionContext, "progress">;
+    sessionContext: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, toolName: string, toolCallId: string) => Pick<import("../../../../index.js").ToolExecutionContext, "identity" | "runId" | "sessionId" | "resourceOwner" | "redact" | "onTeardown" | "teardownScopes">;
+    toolDispatchCtx: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, call: {
+        readonly toolName: string;
+        readonly toolCallId: string;
+        readonly iteration: number;
+    }, signal?: AbortSignal | undefined) => Pick<import("../../../../index.js").ToolExecutionContext, "tools">;
+    searchFunnel: import("../searchCoverage.js").SearchCoverageFunnel;
+    takeCodeRun: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, tool: import("../../../../index.js").Tool<Record<string, unknown>, unknown>, slot: import("../../../codeRunnerTool.js").CodeRunSlot, call: {
+        readonly toolName: string;
+        readonly toolCallId: string;
+        readonly takeListed: boolean;
+    }) => import("../../../codeRunnerTool.js").CodeRunFacts | undefined;
+    warnEffect: (toolName: string, sentence: string) => void;
+    declareCoverage: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, call: {
+        readonly toolName: string;
+        readonly toolCallId: string;
+        readonly iteration: number;
+    }, value: unknown, composed?: import("../../../../index.js").CoverageReading | undefined) => import("../../../../index.js").ToolResultStatus | undefined;
+    declareSemantics: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, call: {
+        readonly toolName: string;
+        readonly toolCallId: string;
+        readonly iteration: number;
+    }, value: unknown) => unknown;
+    refuseOverCeiling: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, call: {
+        readonly toolName: string;
+        readonly toolCallId: string;
+        readonly iteration: number;
+    }, tool: import("../../../../index.js").Tool<Record<string, unknown>, unknown> | undefined, value: unknown, declaredStatus?: import("../../../../index.js").ToolResultStatus | undefined) => string | undefined;
+    judgeColumns: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, call: {
+        readonly toolName: string;
+        readonly toolCallId: string;
+        readonly iteration: number;
+    }, value: unknown) => string | undefined;
+    endCall: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>) => Promise<void>;
+    declareRaisedAbsence: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, call: {
+        readonly toolName: string;
+        readonly toolCallId: string;
+        readonly iteration: number;
+    }, args: Readonly<Record<string, unknown>>, absence: import("../../../../index.js").ToolAbsence, history: readonly import("../../../../index.js").LLMMessage[]) => string | undefined;
+    noteSkillRefusal: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, iteration: number) => void;
+    frameworkSkipStepAnswered: (name: string, answered: import("../../../../index.js").Tool<Record<string, unknown>, unknown> | undefined) => boolean;
+    applySkipStep: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, call: {
+        readonly args: Readonly<Record<string, unknown>>;
+        readonly toolCallId: string;
+        readonly iteration: number;
+    }) => string;
+    applyPresent: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, call: {
+        readonly args: Readonly<Record<string, unknown>>;
+        readonly toolCallId: string;
+        readonly iteration: number;
+    }) => Promise<{
+        readonly ok: boolean;
+        readonly text: string;
+    }>;
+    afterMoment: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, call: {
+        readonly tool?: import("../../../../index.js").Tool<Record<string, unknown>, unknown> | undefined;
+        readonly toolName: string;
+        readonly toolCallId: string;
+        readonly iteration: number;
+        readonly args: Readonly<Record<string, unknown>>;
+        readonly result: unknown;
+        readonly error?: boolean | undefined;
+        readonly negativeResultId?: string | undefined;
+        readonly history: readonly import("../../../../index.js").LLMMessage[];
+        readonly identity?: {
+            tenant?: string | undefined;
+            principal?: string | undefined;
+            conversationId: string;
+        } | undefined;
+        readonly signal?: AbortSignal | undefined;
+    }) => Promise<unknown>;
+    placeResults: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, call: {
+        readonly toolName: string;
+        readonly toolCallId: string;
+        readonly iteration: number;
+    }, values: {
+        readonly result: unknown;
+        readonly modelResult: unknown;
+    }, eligible: boolean) => Promise<{
+        readonly result: unknown;
+        readonly modelResult: unknown;
+    }>;
+    noticeEmptyLookup: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, call: {
+        readonly toolName: string;
+        readonly toolCallId: string;
+        readonly iteration: number;
+    }, args: Readonly<Record<string, unknown>>, result: unknown, history: readonly import("../../../../index.js").LLMMessage[], answered: boolean) => void;
+    capResults: (toolName: string, values: {
+        readonly result: unknown;
+        readonly modelResult: unknown;
+    }) => {
+        readonly result: unknown;
+        readonly modelResult: unknown;
+    };
+    emitToolEnd: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, toolName: string, payload: import("../../../../events/payloads.js").ToolEndPayload, ran: boolean, declaredStatus?: string | undefined, negativeResultId?: string | undefined, refusalArgs?: Readonly<Record<string, unknown>> | undefined) => void;
+    readSkillStepIntroFor: (pickedId: string) => string;
+    applyStepReturn: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, call: {
+        readonly toolName: string;
+        readonly toolCallId: string;
+        readonly iteration: number;
+    }) => string;
+    applyToolEffects: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, call: {
+        readonly toolName: string;
+        readonly toolCallId: string;
+        readonly iteration: number;
+    }, envelope: import("../../../../index.js").ReadToolResultEnvelope, state: import("./contracts/callFacts.js").TransitionBatchState) => string;
+    repeatLedgers: import("../../repeatedCall.js").RepeatedCallLedgers;
+    noteOptionsFor: (tool: import("../../../../index.js").Tool<Record<string, unknown>, unknown> | undefined) => {
+        readonly sources: true;
+    } | undefined;
+    turnStampOf: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>) => import("../../findings/ledger.js").TurnStamp | undefined;
+    emitTransitionConflict: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, iteration: number, state: import("./contracts/callFacts.js").TransitionBatchState) => void;
+    heldAnswer: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, input: unknown, gate: import("../../../pause.js").ConsentGateKind) => import("../../../checkin.js").CheckInDecision;
+    peelCall: (tc: {
+        readonly name: string;
+        readonly args: Readonly<Record<string, unknown>>;
+    }) => import("../../findings/reserved.js").SplitFindings;
+    resumeAsk: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, frame: import("./contracts/resumeFrames.js").ResumeConsentFrame) => Promise<void>;
+    resumeCheckIn: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, frame: import("./contracts/resumeFrames.js").ResumeConsentFrame) => Promise<void>;
+    resumeCredential: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, frame: import("./contracts/resumeFrames.js").ResumeCallFrame) => Promise<void>;
+    resumePlain: (scope: import("footprintjs").TypedScope<import("../../types.js").AgentState>, frame: import("./contracts/resumeFrames.js").ResumeResultFrame) => Promise<void>;
+};
+/** Internal immutable callback and build-configuration port; no run state or dispatcher. */
+export type ToolCallOperations = Readonly<ReturnType<typeof composeToolCallOperations>>;
+//# sourceMappingURL=compose.d.ts.map

package/dist/types/core/agent/stages/toolCalls/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../../../../../src/core/agent/stages/toolCalls/compose.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAIvE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAiCjF,oGAAoG;AACpG,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0VnE;AAED,4FAA4F;AAC5F,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC,CAAC"}