agentfootprint 13.0.0 → 14.0.0

package/dist/types/core/agent/stages/toolCalls/contracts/results.d.ts

@@ -0,0 +1,27 @@
+/** The results dependencies of the existing tool-call stage. */
+export interface ToolResultsPort {
+    /**
+     * The opt-in ceiling on ONE tool result, in characters (9.11.0).
+     *
+     * Undefined — the ordinary case — means results are never measured and never
+     * replaced, which is what every release before 9.11.0 did. Set, and EVERY
+     * result on EVERY dispatch path in this handler is measured against it; over
+     * the cap, the result the model reads and the result
+     * `agentfootprint.stream.tool_end` carries are both the marker. See
+     * `../../../toolResultCap.ts` for the shape and why it is opt-in.
+     */
+    readonly maxToolResultChars?: number;
+    /**
+     * Tell the model when it has already made this exact call and already got
+     * this exact answer (9.26.0). Threaded from `AgentOptions.repeatedCallNudge`,
+     * and only when the operator turned it OFF — `undefined` here means the
+     * default, which is on.
+     *
+     * Applied at the BATCH dispatch loop only, which is where a turn's repeats
+     * actually happen. The pause-resume paths deliver a call a PERSON answered
+     * or approved, and a note telling the model it has already done what a human
+     * just authorised would be the framework arguing with the human.
+     */
+    readonly repeatedCallNudge?: boolean;
+}
+//# sourceMappingURL=results.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"results.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/contracts/results.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,MAAM,WAAW,eAAe;IAC9B;;;;;;;;;OASG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CACtC"}

package/dist/types/core/agent/stages/toolCalls/contracts/resumeFrames.d.ts

@@ -0,0 +1,15 @@
+import type { CheckInDecision } from '../../../../checkin.js';
+/** Ephemeral values for one existing resume door; never checkpoint state. */
+export interface ResumeCallFrame {
+    readonly toolName: string;
+    readonly toolCallId: string;
+    readonly startMs: number;
+}
+export interface ResumeConsentFrame extends ResumeCallFrame {
+    readonly consentDecision: CheckInDecision;
+    readonly runSignal: AbortSignal | undefined;
+}
+export interface ResumeResultFrame extends ResumeCallFrame {
+    readonly input: unknown;
+}
+//# sourceMappingURL=resumeFrames.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resumeFrames.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/contracts/resumeFrames.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,6EAA6E;AAC7E,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAmB,SAAQ,eAAe;IACzD,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;IAC1C,QAAQ,CAAC,SAAS,EAAE,WAAW,GAAG,SAAS,CAAC;CAC7C;AAED,MAAM,WAAW,iBAAkB,SAAQ,eAAe;IACxD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB"}

package/dist/types/core/agent/stages/toolCalls/contracts/routing.d.ts

@@ -0,0 +1,115 @@
+import type { StepPlanFor } from '../../../../../injection-engine/skillSteps.js';
+/** The routing dependencies of the existing tool-call stage. */
+export interface ToolRoutingPort {
+    /**
+     * Skill-graph read_skill GATE (`graph.reachableSkills`). When present, a
+     * `read_skill('id')` whose `id` is not reachable from the current cursor is
+     * REJECTED — the model gets a synthetic re-prompt naming the allowed ids and
+     * the cursor/activations stay unchanged, so it can't leave the graph mid-run.
+     * Undefined → no gate (plain read_skill agents append as before).
+     */
+    readonly allowedSkillIds?: (currentSkillId?: string) => readonly string[];
+    /**
+     * The OPEN skills — registered skills the graph never wires, admitted by the gate
+     * from ANY cursor (8.4.0; see `Agent.openSkillIds`). They ACTIVATE and never move
+     * the cursor: a skill the graph does not route is not a node, so it cannot be a
+     * hop. Only meaningful alongside `allowedSkillIds`.
+     */
+    readonly openSkillIds?: readonly string[];
+    /**
+     * The mount kernel's plan (9.59.0) — present only on agents built with
+     * `.maps()`. Read for exactly one thing: to tell a cursor move from a
+     * RE-ENGAGEMENT at the gate below. Everything else about engagement stays
+     * the kernel's business.
+     */
+    readonly engagementPlan?: import('../../../../../maps/engagement/types.js').EngagementPlan;
+    /**
+     * Is the mounted graph a decision `tree()`? Changes only the REFUSAL TEXT (8.5.0).
+     *
+     * A tree routes by predicate every iteration and has no cursor, so
+     * `reachableSkills()` is empty and every leaf pick is refused. Told with the
+     * generic message that reads "No skills are reachable from here", which is true
+     * but teaches nothing — the model would keep trying. The tree-shaped message says
+     * why the graph cannot be jumped at all, so the model stops asking and answers.
+     */
+    readonly skillGraphIsTree?: boolean;
+    /**
+     * The frozen step plans, keyed by skill id (9.18.0) — set only when ≥1
+     * registered skill declares `steps`. This stage owns the pointer's two
+     * RESULT-BOUNDARY moves, applied at EVERY site a result becomes final and
+     * is pushed (the batch loop AND all the pausable resume paths — a step
+     * whose tool paused, an `askHuman` step first among them, must advance on
+     * the resumed call exactly as it would have inline):
+     *
+     *   • ADVANCE — the finalized call is the current step's tool, ran, and
+     *     was not an error/denial/refusal → pointer + 1, `step_advanced`, and
+     *     the model-visible result gains the "now on step k+1" suffix
+     *     (composed BEFORE the history push — one past, no splicing).
+     *   • SKIP — a `skip_step` call: reason validated (empty → teaching
+     *     result, no event), `step_skipped` emitted, pointer moved or held
+     *     per the skill's declared `onSkip`, and the model-visible result is
+     *     OVERWRITTEN with the authoritative sentence (the read_skill-refusal
+     *     precedent — bookkeeping lives where the batch order lives).
+     *
+     * Postures never gate `skip_step`: skipping is judgment INSIDE a step,
+     * not routing. Undefined → no stepped skill anywhere; not one new line
+     * runs (zero-cost-when-unused).
+     */
+    readonly stepPlanFor?: StepPlanFor;
+    /**
+     * The mount's routing POSTURE beyond reachability (SG-C `strictness`).
+     * Undefined = `'assist'` = today's gate, byte-for-byte — not one new line
+     * runs. Judged AFTER reachability (an unreachable pick keeps its original
+     * teaching refusal), and only on HOPS — an OPEN skill (`.selfExplain()`,
+     * a `.skill()` beside the graph) is admitted from anywhere under every
+     * posture, so debugging never breaks:
+     *   • `'guard'` — a routing pick is admitted only while the turn's MENU is
+     *     outstanding AND names an offered id (the framework declared the
+     *     ambiguity; the model resolves exactly that). Off-menu / no-menu picks
+     *     get a teaching refusal + `skill.rejected { posture: 'guard' }`.
+     *   • `'rails'` — routing picks are refused outright: rules/scorer resolve
+     *     turn starts, declared routes handle transitions.
+     * Same graph, same trace: postures change refusal behavior only.
+     *
+     * Read only by the `read_skill` gate below, and that is the whole scope:
+     * `applyToolEffects` never consults it, because a `propose-transition`
+     * comes from a tool — the author's own code — and is admitted under every
+     * posture against reachability alone. See `SkillGraphOptions.strictness`
+     * (AgentBuilder.ts), which states the exemption for authors.
+     */
+    readonly skillStrictness?: 'guard' | 'rails';
+    /**
+     * Escalate-on-evidence (9.19.0). When declared, the two `skill.rejected`
+     * emit sites below increment a per-turn counter; at `afterRefusals` the
+     * rest of the turn flips onto the escalation brain (`scope.skillEscalated`
+     * — a committed fact callLLM's `brainFor` reads) and `skill.escalated`
+     * goes on the record ONCE. Undefined — the default — and not one new key
+     * is read or written (zero-cost-when-unused).
+     */
+    readonly escalation?: {
+        readonly afterRefusals: number;
+        /** The declared escalation brain, for the event's `to`. */
+        readonly to: {
+            readonly provider: string;
+            readonly model?: string;
+        };
+        /** Resolve the brain that WAS serving (the event's honest `from`) — the
+         *  same precedence chain callLLM applies, evaluated at the flip. */
+        readonly describeFrom: (cursor: string | undefined, resolvedModel: string | undefined) => {
+            readonly provider: string;
+            readonly model: string;
+        };
+    };
+    /**
+     * The registered injection ids a `require-instruction` tool effect may
+     * push, with the one fact its check-up needs (9.19.0): a skill whose
+     * declared body channel is `'tool-only'` cannot be pushed through the
+     * system slot — the slot suppresses it — so granting the lease would be
+     * accepted-and-silently-undelivered. Undefined → the agent registered no
+     * injections; every require-instruction is a teaching refusal.
+     */
+    readonly leaseTargets?: ReadonlyMap<string, {
+        readonly surfaceMode?: string;
+    }>;
+}
+//# sourceMappingURL=routing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/contracts/routing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+CAA+C,CAAC;AAEjF,gEAAgE;AAChE,MAAM,WAAW,eAAe;IAC9B;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC,cAAc,CAAC,EAAE,MAAM,KAAK,SAAS,MAAM,EAAE,CAAC;IAC1E;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,yCAAyC,EAAE,cAAc,CAAC;IAC3F;;;;;;;;OAQG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC;IACnC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;IAC7C;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE;QACpB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;QAC/B,2DAA2D;QAC3D,QAAQ,CAAC,EAAE,EAAE;YAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;QACpE;4EACoE;QACpE,QAAQ,CAAC,YAAY,EAAE,CACrB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,aAAa,EAAE,MAAM,GAAG,SAAS,KAC9B;YAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC;KAC5D,CAAC;IACF;;;;;;;OAOG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChF"}

package/dist/types/core/agent/stages/toolCalls/decorators/limitsOperations.d.ts

@@ -0,0 +1,5 @@
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { ToolLimitsOperations } from '../contracts/operations/limits.js';
+/** Compose the existing limits callbacks once for this handler. */
+export declare function buildToolLimitsOperations(deps: Pick<ToolCallsHandlerDeps, 'maxToolResultChars'>): ToolLimitsOperations;
+//# sourceMappingURL=limitsOperations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"limitsOperations.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/decorators/limitsOperations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AASxE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAE9E,mEAAmE;AACnE,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,IAAI,CAAC,oBAAoB,EAAE,oBAAoB,CAAC,GACrD,oBAAoB,CAmFtB"}

package/dist/types/core/agent/stages/toolCalls/decorators/middlewareOperations.d.ts

@@ -0,0 +1,5 @@
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { ToolMiddlewareOperations } from '../contracts/operations/middleware.js';
+/** Compose the existing middleware callbacks once for this handler. */
+export declare function buildToolMiddlewareOperations(deps: Pick<ToolCallsHandlerDeps, 'negativeClaimsArmed' | 'toolMiddleware'>): ToolMiddlewareOperations;
+//# sourceMappingURL=middlewareOperations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"middlewareOperations.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/decorators/middlewareOperations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAWxE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AAEtF,uEAAuE;AACvE,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,IAAI,CAAC,oBAAoB,EAAE,qBAAqB,GAAG,gBAAgB,CAAC,GACzE,wBAAwB,CAyF1B"}

package/dist/types/core/agent/stages/toolCalls/decorators/reportingCredentials.d.ts

@@ -0,0 +1,30 @@
+import type { CredentialProvider } from '../../../../../identity/types.js';
+import type { ToolSecurityEmitter } from '../../../toolSecurityEvents.js';
+/**
+ * The constructor name of what was thrown, when what was thrown was an Error.
+ *
+ * Reported on `agentfootprint.credential.failed` so an alert can route on the
+ * CLASS of failure rather than parse a message. `undefined` for a thrown
+ * non-Error, because "Object" would be a fact about JavaScript rather than
+ * about the failure.
+ */
+export declare function errorClassOf(err: unknown): string | undefined;
+/**
+ * Wrap the credential provider handed to a tool as `ctx.credentials`, so a
+ * failure inside the tool's OWN `getCredential(...)` call is as visible as one
+ * on the declared-`needs` path.
+ *
+ * Why this exists (9.4.0). `needs` resolution has emitted
+ * `agentfootprint.credential.failed` since 6.11.0. The pull path — a tool that
+ * asks for its own credential mid-execute — emitted nothing: the throw was
+ * caught by the generic tool catch and became `tool_end` with `error: true`,
+ * one indistinguishable failure among all the other ways a tool can fail. An
+ * operator watching the credential domain saw a healthy silence while every
+ * call was failing to authenticate, which is the exact shape of the AWS
+ * identity-adapter bug this release fixes.
+ *
+ * It is a decorator, not a replacement: the same `id`, the same result, the
+ * same throw. It only makes a noise on the way past.
+ */
+export declare function reportingCredentials(provider: CredentialProvider, emitSecurity: ToolSecurityEmitter, toolName: string): CredentialProvider;
+//# sourceMappingURL=reportingCredentials.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reportingCredentials.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/decorators/reportingCredentials.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAC3E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAE1E;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAE7D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,kBAAkB,EAC5B,YAAY,EAAE,mBAAmB,EACjC,QAAQ,EAAE,MAAM,GACf,kBAAkB,CAiBpB"}

package/dist/types/core/agent/stages/toolCalls/evidence/coverageOperations.d.ts

@@ -0,0 +1,10 @@
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { ToolCoverageOperations } from '../contracts/operations/coverage.js';
+import type { ToolIntegrityOperations } from '../contracts/operations/integrity.js';
+interface ToolCoverageOperationsLinks {
+    readonly noticeEmptyLookup: ToolIntegrityOperations['noticeEmptyLookup'];
+}
+/** Compose the existing coverage callbacks once for this handler. */
+export declare function buildToolCoverageOperations(deps: Pick<ToolCallsHandlerDeps, 'resultsLayer' | 'negativeClaimsArmed'>, links: ToolCoverageOperationsLinks): ToolCoverageOperations;
+export {};
+//# sourceMappingURL=coverageOperations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"coverageOperations.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/evidence/coverageOperations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAoBxE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAClF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAEpF,UAAU,2BAA2B;IACnC,QAAQ,CAAC,iBAAiB,EAAE,uBAAuB,CAAC,mBAAmB,CAAC,CAAC;CAC1E;AAED,qEAAqE;AACrE,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,IAAI,CAAC,oBAAoB,EAAE,cAAc,GAAG,qBAAqB,CAAC,EACxE,KAAK,EAAE,2BAA2B,GACjC,sBAAsB,CAyOxB"}

package/dist/types/core/agent/stages/toolCalls/evidence/integrityOperations.d.ts

@@ -0,0 +1,5 @@
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { ToolIntegrityOperations } from '../contracts/operations/integrity.js';
+/** Compose the existing integrity callbacks once for this handler. */
+export declare function buildToolIntegrityOperations(deps: Pick<ToolCallsHandlerDeps, 'columnDeclarations' | 'columnCheckMode' | 'integrityLedger' | 'emptyLookupGrounding'>): ToolIntegrityOperations;
+//# sourceMappingURL=integrityOperations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"integrityOperations.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/evidence/integrityOperations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAUxE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAEpF,sEAAsE;AACtE,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,IAAI,CACR,oBAAoB,EACpB,oBAAoB,GAAG,iBAAiB,GAAG,iBAAiB,GAAG,sBAAsB,CACtF,GACA,uBAAuB,CAqJzB"}

package/dist/types/core/agent/stages/toolCalls/evidence/judgeLanded.d.ts

@@ -0,0 +1,30 @@
+import type { TypedScope } from 'footprintjs';
+import type { AgentState } from '../../../types.js';
+import type { Classifier } from '../../../../../classify/types.js';
+import type { TurnStamp } from '../../../findings/ledger.js';
+/**
+ * The judge's turn on ONE landed result (9.104.0) — called at the five
+ * places a result joins the batch (the execute loop and the four resume
+ * doors), right after the `toolResults` entry exists and before the next
+ * model call. Value-gated on `deps.findingsJudge`: unarmed, or armed with
+ * no judge, this is a no-op that awaits nothing. `judgeResult` never
+ * throws — a failed call is an error row and the run continues.
+ *
+ * `ran` is the caller's word that the TOOL produced this text: a permission
+ * denial, a halt, a fail-closed refusal, a declined check-in, a chain deny
+ * are sentences the library wrote about a call that never ran, and a
+ * denial text is not a tool result — asking a judge what it is worth for
+ * the proposition would file a standing for evidence nobody collected. The
+ * execute loop passes the nudge's own predicate (`executed && !denied &&
+ * !skillRejected`); the resume doors pass `dispatched.executed === true`;
+ * the `pauseHere` / `askHuman` door passes `true` because the person's
+ * answer IS that tool's result by the handler's contract.
+ */
+export declare function judgeLanded(scope: TypedScope<AgentState>, judge: Classifier | undefined, ran: boolean, entry: {
+    toolName: string;
+    result: string;
+    toolCallId: string;
+}, iteration: number, 
+/** The honesty layers' turn stamp — passed only while an honesty layer is armed. */
+stamp?: TurnStamp): Promise<void>;
+//# sourceMappingURL=judgeLanded.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"judgeLanded.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/evidence/judgeLanded.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,UAAU,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAE7D;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,EAC7B,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,EAC/D,SAAS,EAAE,MAAM;AACjB,oFAAoF;AACpF,KAAK,CAAC,EAAE,SAAS,GAChB,OAAO,CAAC,IAAI,CAAC,CAgBf"}

package/dist/types/core/agent/stages/toolCalls/evidence/madeInRun.d.ts

@@ -0,0 +1,7 @@
+/** The run a capability binding was made in — `undefined` when there is no binding. */
+export declare const madeInRun: (bindRun: {
+    readonly runContext?: {
+        readonly runId: string;
+    };
+} | undefined) => string | undefined;
+//# sourceMappingURL=madeInRun.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"madeInRun.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/evidence/madeInRun.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,eAAO,MAAM,SAAS,YACX;IAAE,QAAQ,CAAC,UAAU,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GAAG,SAAS,uBAC5C,CAAC"}

package/dist/types/core/agent/stages/toolCalls/evidence/producerCorpus.d.ts

@@ -0,0 +1,23 @@
+import type { LLMMessage } from '../../../../../provider-contract/types.js';
+import type { ProducedResult } from '../../../../../integrity/empty-lookup/check.js';
+/**
+ * The empty-lookup check's PRODUCER CORPUS (9.77.0) — every `role: 'tool'`
+ * RESULT in `history` from a tool the judged one names in `argumentsFrom`,
+ * as the run served it. The caller hands the history the judged call was
+ * served (the call itself is pushed after it), so a producer called earlier in
+ * the same batch is already in it — which is right: the model can only have
+ * taken a value from a result it had already been served.
+ *
+ * A message the batch settlement wrote (9.113.0) is no result: its ground
+ * never ran, so it produced nothing to take a value from. Read off the marker
+ * (`../../../findings/offer.ts` · `isResultMessage`), never the sentence.
+ *
+ * Each result is read as the TOOL's own bytes (`lib/toolBytes.ts` ·
+ * `toolBytesOf`): the note the inputs layer appends after a filled call's
+ * result carries the value the library filled, and a value only that note
+ * carries is not one the run's producer served.
+ *
+ * Exported for its unit test (`test/integrity/emptyLookup.test.ts`).
+ */
+export declare function producerCorpusOf(history: readonly LLMMessage[], argumentsFrom: readonly string[]): ProducedResult[];
+//# sourceMappingURL=producerCorpus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"producerCorpus.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/evidence/producerCorpus.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2CAA2C,CAAC;AAC5E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gDAAgD,CAAC;AAErF;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,UAAU,EAAE,EAC9B,aAAa,EAAE,SAAS,MAAM,EAAE,GAC/B,cAAc,EAAE,CASlB"}

package/dist/types/core/agent/stages/toolCalls/evidence/scriptsOperations.d.ts

@@ -0,0 +1,12 @@
+import type { buildToolResolver } from '../../toolResolver.js';
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { ToolScriptsOperations } from '../contracts/operations/scripts.js';
+import type { ToolCatalogOperations } from '../contracts/operations/catalog.js';
+interface ToolScriptsOperationsLinks {
+    readonly peelCall: ToolCatalogOperations['peelCall'];
+    readonly resolveTool: ReturnType<typeof buildToolResolver>;
+}
+/** Compose the existing scripts callbacks once for this handler. */
+export declare function buildToolScriptsOperations(deps: Pick<ToolCallsHandlerDeps, 'scriptRecord'>, links: ToolScriptsOperationsLinks): ToolScriptsOperations;
+export {};
+//# sourceMappingURL=scriptsOperations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scriptsOperations.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/evidence/scriptsOperations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAYxE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAChF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAEhF,UAAU,0BAA0B;IAClC,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAC,UAAU,CAAC,CAAC;IACrD,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;CAC5D;AAED,oEAAoE;AACpE,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,CAAC,oBAAoB,EAAE,cAAc,CAAC,EAChD,KAAK,EAAE,0BAA0B,GAChC,qBAAqB,CAkMvB"}

package/dist/types/core/agent/stages/toolCalls/evidence/semanticsOperations.d.ts

@@ -0,0 +1,5 @@
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { ToolSemanticsOperations } from '../contracts/operations/semantics.js';
+/** Compose the existing semantics callbacks once for this handler. */
+export declare function buildToolSemanticsOperations(deps: Pick<ToolCallsHandlerDeps, 'collectClaimFacts'>): ToolSemanticsOperations;
+//# sourceMappingURL=semanticsOperations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"semanticsOperations.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/evidence/semanticsOperations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAYxE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAEpF,sEAAsE;AACtE,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,IAAI,CAAC,oBAAoB,EAAE,mBAAmB,CAAC,GACpD,uBAAuB,CA2FzB"}

package/dist/types/core/agent/stages/toolCalls/evidence/sourceClock.d.ts

@@ -0,0 +1,12 @@
+import type { TypedScope } from 'footprintjs';
+import type { AgentState } from '../../../types.js';
+/**
+ * File the `source-clock` row for one call's dataset whose declared time axis
+ * names `zone` (step T8) — once per call and zone this turn, through the one
+ * writer; no event (the row is the record).
+ */
+export declare function recordSourceClock(scope: TypedScope<AgentState>, call: {
+    readonly toolCallId: string;
+    readonly toolName: string;
+}, zone: string): void;
+//# sourceMappingURL=sourceClock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sourceClock.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/evidence/sourceClock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAKpD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,EAC7B,IAAI,EAAE;IAAE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAChE,IAAI,EAAE,MAAM,GACX,IAAI,CAUN"}

package/dist/types/core/agent/stages/toolCalls/evidence/towers.d.ts

@@ -0,0 +1,19 @@
+import type { TypedScope } from 'footprintjs';
+import type { AgentState } from '../../../types.js';
+import type { ResolvedEvidenceGate } from '../../../evidence/types.js';
+import { type EvidenceCorpus } from '../../../evidence/evidenceIndex.js';
+import type { StandingRow } from '../../../findings/types.js';
+/**
+ * What the dispatch moment of the contingent check needs for one batch
+ * (9.110.0), or `undefined` when nothing can be filed: one of the two doors
+ * is closed, the ledger is absent, or no result holds a set-aside standing.
+ * The corpus and the exempt set are built once per batch — every call of the
+ * batch was served the same history.
+ */
+export declare function towersFor(scope: TypedScope<AgentState>, findings: true | undefined, gate: ResolvedEvidenceGate | undefined): {
+    readonly gate: ResolvedEvidenceGate;
+    readonly corpus: EvidenceCorpus;
+    readonly exempt: ReadonlySet<string>;
+    readonly standingOf: ReadonlyMap<string, StandingRow>;
+} | undefined;
+//# sourceMappingURL=towers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"towers.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/evidence/towers.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,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EACL,KAAK,cAAc,EAGpB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAkB,MAAM,4BAA4B,CAAC;AAM9E;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,EAC7B,QAAQ,EAAE,IAAI,GAAG,SAAS,EAC1B,IAAI,EAAE,oBAAoB,GAAG,SAAS,GAEpC;IACE,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACrC,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CACvD,GACD,SAAS,CAyBZ"}

package/dist/types/core/agent/stages/toolCalls/execution/artifactsOperations.d.ts

@@ -0,0 +1,13 @@
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { ToolArtifactsOperations } from '../contracts/operations/artifacts.js';
+import type { ToolContextOperations } from '../contracts/operations/context.js';
+import type { ToolCatalogOperations } from '../contracts/operations/catalog.js';
+interface ToolArtifactsOperationsLinks {
+    readonly runScopeOf: ToolContextOperations['runScopeOf'];
+    readonly toolArtifacts: ToolContextOperations['toolArtifacts'];
+    readonly lookupTool: ToolCatalogOperations['lookupTool'];
+}
+/** Compose the existing artifacts callbacks once for this handler. */
+export declare function buildToolArtifactsOperations(deps: Pick<ToolCallsHandlerDeps, 'artifactStore' | 'placement'>, links: ToolArtifactsOperationsLinks): ToolArtifactsOperations;
+export {};
+//# sourceMappingURL=artifactsOperations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"artifactsOperations.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/execution/artifactsOperations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAiBxE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AACpF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAChF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAEhF,UAAU,4BAA4B;IACpC,QAAQ,CAAC,UAAU,EAAE,qBAAqB,CAAC,YAAY,CAAC,CAAC;IACzD,QAAQ,CAAC,aAAa,EAAE,qBAAqB,CAAC,eAAe,CAAC,CAAC;IAC/D,QAAQ,CAAC,UAAU,EAAE,qBAAqB,CAAC,YAAY,CAAC,CAAC;CAC1D;AAED,sEAAsE;AACtE,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,IAAI,CAAC,oBAAoB,EAAE,eAAe,GAAG,WAAW,CAAC,EAC/D,KAAK,EAAE,4BAA4B,GAClC,uBAAuB,CAgTzB"}

package/dist/types/core/agent/stages/toolCalls/execution/callStart.d.ts

@@ -0,0 +1,36 @@
+import { buildToolResolver } from '../../toolResolver.js';
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { TypedScope } from 'footprintjs';
+import type { AgentState } from '../../../types.js';
+import type { towersFor } from '../evidence/towers.js';
+import { findingsReferenceRefusal } from '../../../findings/admission.js';
+import type { LLMMessage } from '../../../../../provider-contract/types.js';
+import type { ToolArgs } from '../../../../../tools/runChain.js';
+import type { DispatchCall } from '../contracts/batchCall.js';
+import type { ToolCatalogOperations } from '../contracts/operations/catalog.js';
+import type { ToolScriptsOperations } from '../contracts/operations/scripts.js';
+import type { ToolObservationsOperations } from '../contracts/operations/observations.js';
+interface CallStartLinks {
+    readonly resolveTool: ReturnType<typeof buildToolResolver>;
+    readonly peelCall: ToolCatalogOperations['peelCall'];
+    readonly programOfCall: ToolScriptsOperations['programOfCall'];
+    readonly turnStampOf: ToolCatalogOperations['turnStampOf'];
+    readonly emitToolStart: ToolObservationsOperations['emitToolStart'];
+}
+/** Start one call with its original proposal, frozen views, records and clock. */
+export declare function buildCallStart(deps: Pick<ToolCallsHandlerDeps, 'findings'>, links: CallStartLinks): {
+    beginDispatchCall: (scope: TypedScope<AgentState>, tc: DispatchCall, iteration: number, towers: ReturnType<typeof towersFor>, callIndex: number, toolCalls: readonly DispatchCall[], findingsRefusals: readonly ReturnType<typeof findingsReferenceRefusal>[], frozenTurn: LLMMessage | undefined, callbackHistory: () => LLMMessage[], frozenArgsAt: (at: number) => ToolArgs | 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: ToolArgs) => ToolArgs | undefined;
+        historyForCallbacks: () => LLMMessage[];
+        startMs: number;
+        findingsRefusal: string | undefined;
+        invalidateViews: () => void;
+    };
+};
+export {};
+//# sourceMappingURL=callStart.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"callStart.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/execution/callStart.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,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,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2CAA2C,CAAC;AAC5E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAMjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,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,cAAc;IACtB,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC3D,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAC,UAAU,CAAC,CAAC;IACrD,QAAQ,CAAC,aAAa,EAAE,qBAAqB,CAAC,eAAe,CAAC,CAAC;IAC/D,QAAQ,CAAC,WAAW,EAAE,qBAAqB,CAAC,aAAa,CAAC,CAAC;IAC3D,QAAQ,CAAC,aAAa,EAAE,0BAA0B,CAAC,eAAe,CAAC,CAAC;CACrE;AAED,kFAAkF;AAClF,wBAAgB,cAAc,CAC5B,IAAI,EAAE,IAAI,CAAC,oBAAoB,EAAE,UAAU,CAAC,EAC5C,KAAK,EAAE,cAAc;+BAGZ,WAAW,UAAU,CAAC,MACzB,YAAY,aACL,MAAM,UACT,WAAW,gBAAgB,CAAC,aACzB,MAAM,aACN,SAAS,YAAY,EAAE,oBAChB,SAAS,WAAW,+BAA+B,CAAC,EAAE,cAC5D,UAAU,GAAG,SAAS,mBACjB,MAAM,UAAU,EAAE,gBACrB,CAAC,EAAE,EAAE,MAAM,KAAK,QAAQ,GAAG,SAAS;;;;;;yBAgE1B,QAAQ,KAAG,QAAQ,GAAG,SAAS;mCAYvB,UAAU,EAAE;;;+BAchB,IAAI;;EAkBnC"}

package/dist/types/core/agent/stages/toolCalls/execution/catalogOperations.d.ts

@@ -0,0 +1,18 @@
+import type { buildToolResolver } from '../../toolResolver.js';
+import type { Tool } from '../../../../../tools/tools.js';
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { ToolCatalogOperations } from '../contracts/operations/catalog.js';
+interface ToolCatalogOperationsLinks {
+    readonly resolveTool: ReturnType<typeof buildToolResolver>;
+    readonly peelArms: {
+        argumentSources: boolean;
+    } | undefined;
+    readonly frameworkSkipStep: Tool | undefined;
+    readonly registryByName: ToolCallsHandlerDeps['registryByName'];
+    readonly externalToolProvider: ToolCallsHandlerDeps['externalToolProvider'];
+    readonly providerToolCache: ToolCallsHandlerDeps['providerToolCache'];
+}
+/** Compose the existing catalog callbacks once for this handler. */
+export declare function buildToolCatalogOperations(deps: Pick<ToolCallsHandlerDeps, 'inputsLayer' | 'resultsLayer' | 'answerLayer' | 'findings' | 'argumentSources' | 'engagementPlan' | 'toolDeclaringSkills'>, links: ToolCatalogOperationsLinks): ToolCatalogOperations;
+export {};
+//# sourceMappingURL=catalogOperations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"catalogOperations.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/execution/catalogOperations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,+BAA+B,CAAC;AAC1D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAiBxE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAGhF,UAAU,0BAA0B;IAClC,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC3D,QAAQ,CAAC,QAAQ,EAAE;QAAE,eAAe,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAC;IAC5D,QAAQ,CAAC,iBAAiB,EAAE,IAAI,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,cAAc,EAAE,oBAAoB,CAAC,gBAAgB,CAAC,CAAC;IAChE,QAAQ,CAAC,oBAAoB,EAAE,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;IAC5E,QAAQ,CAAC,iBAAiB,EAAE,oBAAoB,CAAC,mBAAmB,CAAC,CAAC;CACvE;AAED,oEAAoE;AACpE,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,CACR,oBAAoB,EAClB,aAAa,GACb,cAAc,GACd,aAAa,GACb,UAAU,GACV,iBAAiB,GACjB,gBAAgB,GAChB,qBAAqB,CACxB,EACD,KAAK,EAAE,0BAA0B,GAChC,qBAAqB,CAyLvB"}

package/dist/types/core/agent/stages/toolCalls/execution/contextOperations.d.ts

@@ -0,0 +1,16 @@
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { ToolContextOperations } from '../contracts/operations/context.js';
+import type { ToolResourcesOperations } from '../contracts/operations/resources.js';
+import type { ToolCredentialsOperations } from '../contracts/operations/credentials.js';
+import type { ToolProgressOperations } from '../contracts/operations/progress.js';
+interface ToolContextOperationsLinks {
+    readonly runFactsOf: ToolResourcesOperations['runFactsOf'];
+    readonly registryByName: ToolCallsHandlerDeps['registryByName'];
+    readonly credentialsIn: ToolCredentialsOperations['credentialsIn'];
+    readonly hasCredentials: boolean;
+    readonly toolProgress: ToolProgressOperations['toolProgress'];
+}
+/** Compose the existing context callbacks once for this handler. */
+export declare function buildToolContextOperations(deps: Pick<ToolCallsHandlerDeps, 'emitForRun' | 'currentRun' | 'isRunRetired' | 'time' | 'artifactStore'>, links: ToolContextOperationsLinks): ToolContextOperations;
+export {};
+//# sourceMappingURL=contextOperations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contextOperations.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/execution/contextOperations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAsBxE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAChF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AACpF,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,wCAAwC,CAAC;AACxF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAIlF,UAAU,0BAA0B;IAClC,QAAQ,CAAC,UAAU,EAAE,uBAAuB,CAAC,YAAY,CAAC,CAAC;IAC3D,QAAQ,CAAC,cAAc,EAAE,oBAAoB,CAAC,gBAAgB,CAAC,CAAC;IAChE,QAAQ,CAAC,aAAa,EAAE,yBAAyB,CAAC,eAAe,CAAC,CAAC;IACnE,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,sBAAsB,CAAC,cAAc,CAAC,CAAC;CAC/D;AAED,oEAAoE;AACpE,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,CACR,oBAAoB,EACpB,YAAY,GAAG,YAAY,GAAG,cAAc,GAAG,MAAM,GAAG,eAAe,CACxE,EACD,KAAK,EAAE,0BAA0B,GAChC,qBAAqB,CAuMvB"}

package/dist/types/core/agent/stages/toolCalls/execution/credentialAdmission.d.ts

@@ -0,0 +1,49 @@
+import type { buildCallStart } from './callStart.js';
+import type { buildDispatchContext } from '../batch/dispatchContext.js';
+import type { buildToolCredentialsOperations } from './credentialsOperations.js';
+import type { CallCredentialInput } from '../contracts/invocationInputs.js';
+import { type AuthorizationRequiredMode } from '../../../../../identity/consent.js';
+import type { CallArguments, CallResultCell } from '../contracts/callCells.js';
+import type { buildToolScriptsOperations } from '../evidence/scriptsOperations.js';
+import type { InputsDispatch } from '../contracts/inputsDispatch.js';
+import type { TypedScope } from 'footprintjs';
+import type { AgentState } from '../../../types.js';
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { DispatchCall } from '../contracts/batchCall.js';
+type CallStartFacts = ReturnType<ReturnType<typeof buildCallStart>['beginDispatchCall']>;
+type DispatchContext = ReturnType<ReturnType<typeof buildDispatchContext>['prepareDispatchContext']>;
+interface AdmitToolCredentialFrame {
+    readonly emitSecurity: CallStartFacts['emitSecurity'];
+    readonly need: NonNullable<NonNullable<CallStartFacts['tool']>['needs']>;
+    readonly credentialsIn: ReturnType<typeof buildToolCredentialsOperations>['credentialsIn'];
+    readonly runIdentity: DispatchContext['runIdentity'];
+    readonly authorization: CallCredentialInput;
+    readonly onAuthorizationRequired: AuthorizationRequiredMode;
+    readonly oneQuestionAsked: boolean;
+    readonly newHistory: DispatchContext['newHistory'];
+    readonly tc: DispatchCall;
+    readonly startMs: CallStartFacts['startMs'];
+    readonly callArguments: CallArguments;
+    readonly resolved: CallStartFacts['resolved'];
+    readonly fileScript: ReturnType<typeof buildToolScriptsOperations>['fileScript'];
+    readonly tool: CallStartFacts['tool'];
+    readonly iteration: number;
+    readonly proposedProgram: CallStartFacts['proposedProgram'];
+    readonly programOfCall: ReturnType<typeof buildToolScriptsOperations>['programOfCall'];
+    readonly outcome: CallResultCell;
+    readonly askedLayer: InputsDispatch | undefined;
+    readonly resolution: ReturnType<ReturnType<InputsDispatch['resolutionsFor']>['get']>;
+}
+/** Existing credentialAdmission body; original guard and native pause return stay with the handler. */
+export declare function admitToolCredential(scope: TypedScope<AgentState>, deps: Pick<ToolCallsHandlerDeps, 'clearConsentOutstanding' | 'reportConsentOutstanding'>, frame: AdmitToolCredentialFrame): Promise<{
+    toolCallId: string;
+    toolName: string;
+    question: string;
+    authorization: {
+        service: string;
+        authorizationUrl: string;
+        sessionId: string;
+    };
+} | undefined>;
+export {};
+//# sourceMappingURL=credentialAdmission.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"credentialAdmission.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/execution/credentialAdmission.ts"],"names":[],"mappings":"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"}

package/dist/types/core/agent/stages/toolCalls/execution/credentialsOperations.d.ts

@@ -0,0 +1,10 @@
+import type { CredentialProvider } from '../../../../../identity/types.js';
+import type { ToolCallsHandlerDeps } from '../contracts/handlerDeps.js';
+import type { ToolCredentialsOperations } from '../contracts/operations/credentials.js';
+interface ToolCredentialsOperationsLinks {
+    readonly baseCredentials: CredentialProvider;
+}
+/** Compose the existing credentials callbacks once for this handler. */
+export declare function buildToolCredentialsOperations(deps: Pick<ToolCallsHandlerDeps, 'currentRequest'>, links: ToolCredentialsOperationsLinks): ToolCredentialsOperations;
+export {};
+//# sourceMappingURL=credentialsOperations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"credentialsOperations.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/agent/stages/toolCalls/execution/credentialsOperations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAC3E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAExE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,wCAAwC,CAAC;AAExF,UAAU,8BAA8B;IACtC,QAAQ,CAAC,eAAe,EAAE,kBAAkB,CAAC;CAC9C;AAED,wEAAwE;AACxE,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,IAAI,CAAC,oBAAoB,EAAE,gBAAgB,CAAC,EAClD,KAAK,EAAE,8BAA8B,GACpC,yBAAyB,CAS3B"}