agentfootprint 9.74.0 → 9.76.0

package/dist/types/core/agent/evidence/gate.d.ts

@@ -51,6 +51,7 @@
  * (offline, cheap, fast). Set membership over normalized tokens is the entire
  * mechanism, it costs microseconds, and it is the same on every run.
  */
+import type { StagedRefsMatch } from '../stagedRefs.js';
 import type { EvidenceCorpus } from './evidenceIndex.js';
 import { EVIDENCE_CHECK_FRAME_PREFIX } from './frames.js';
 import type { EvidencePosture, EvidenceVerdict, NamesAndNumbersOptions, ResolvedEvidenceGate, UnsupportedValue } from './types.js';
@@ -90,8 +91,17 @@ export declare function describeValues(values: readonly UnsupportedValue[]): str
  * come first and untrusted text never gets the last line is the same rule the
  * compaction frame and the schema frame follow, and a rule with an exception
  * is not a rule.
+ *
+ * `stagedRefs` (optional) is the staged-refs join computed by the recheck
+ * stage: when this turn holds placed artifact tickets a served `wants` tool
+ * can spend, the frame names the refs and the spender by their declared names
+ * — "call the tool that provides it" without saying WHICH tool over WHICH ref
+ * leaves the model to head-math again. The clause sits INSIDE the authored
+ * frame (ref ids and tool names are declarations, not model output), so the
+ * quoted values still come last and `isLibraryAuthoredTurn`'s prefix match is
+ * untouched.
  */
-export declare function buildEvidenceCorrection(failedAnswer: string, values: readonly UnsupportedValue[]): readonly [{
+export declare function buildEvidenceCorrection(failedAnswer: string, values: readonly UnsupportedValue[], stagedRefs?: StagedRefsMatch): readonly [{
     role: 'assistant';
     content: string;
 }, {

package/dist/types/core/agent/evidence/gate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gate.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/evidence/gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAG1D,OAAO,KAAK,EACV,eAAe,EAEf,eAAe,EACf,sBAAsB,EACtB,oBAAoB,EACpB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAOpB,OAAO,EAAE,2BAA2B,EAAE,CAAC;AAEvC,wEAAwE;AACxE,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAUtC;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,GAAE,sBAA2B,GAAG,oBAAoB,CA8D3F;AAcD;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE;IACJ,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACtC,GACA,eAAe,CAajB;AAED,2EAA2E;AAC3E,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,gBAAgB,EAAE,GAAG,MAAM,CAK1E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,SAAS,gBAAgB,EAAE,GAClC,SAAS,CAAC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAatF;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,OAAO,GACf,MAAM,CAcR"}
+{"version":3,"file":"gate.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/evidence/gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAG1D,OAAO,KAAK,EACV,eAAe,EAEf,eAAe,EACf,sBAAsB,EACtB,oBAAoB,EACpB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAOpB,OAAO,EAAE,2BAA2B,EAAE,CAAC;AAEvC,wEAAwE;AACxE,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAUtC;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,GAAE,sBAA2B,GAAG,oBAAoB,CAuE3F;AAcD;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE;IACJ,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACtC,GACA,eAAe,CAajB;AAED,2EAA2E;AAC3E,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,gBAAgB,EAAE,GAAG,MAAM,CAK1E;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,UAAU,CAAC,EAAE,eAAe,GAC3B,SAAS,CAAC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAetF;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,OAAO,GACf,MAAM,CAcR"}

package/dist/types/core/agent/evidence/types.d.ts

@@ -73,6 +73,27 @@ export interface NamesAndNumbersOptions {
      * positives that follow.
      */
     readonly minDigits?: number;
+    /**
+     * The staged-refs nudge. Default `false` — off, byte-identical.
+     *
+     * When an iteration's context carries tool results staged by reference
+     * (`artifacts.placement` tickets) AND a tool the model can currently call
+     * declares `wants` over one of their kinds, the library appends ONE short
+     * line at the END of that request naming the refs and the spender tool:
+     * derived numbers come from the tool, not from mental arithmetic. Composed
+     * entirely from declarations (`Tool.resultKind` / `Tool.wants`) — no app
+     * prose — and placed late because the measured failure was recency: the
+     * app's own "use the compute tool" instruction sat at the top of the
+     * context while the numbers sat at the bottom, and the model summed them
+     * in its head. The line is request-only (never history) and recomposed per
+     * iteration, so it exists exactly while both conditions hold. Each firing
+     * lands as `agentfootprint.agent.grounding_nudged`.
+     *
+     * Advisory — the postures above stay the guarantee. An agent with no
+     * artifact placement or no `wants`-declaring tool arms nothing and keeps
+     * byte-identical requests.
+     */
+    readonly nudge?: boolean;
 }
 /** One value in the answer that no tool result carried. */
 export interface UnsupportedValue {
@@ -99,6 +120,8 @@ export interface ResolvedEvidenceGate {
     readonly exemptValues: ReadonlySet<string>;
     readonly exemptPatterns: readonly RegExp[];
     readonly minDigits: number;
+    /** The staged-refs nudge dial. `false` is today's bytes. */
+    readonly nudge: boolean;
 }
 /** The gate's verdict on one answer. */
 export interface EvidenceVerdict {

package/dist/types/core/agent/evidence/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/evidence/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,CAAC;AAE3D;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,aAAa;IAC5B;sDACkD;IAClD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,oDAAoD;AACpD,MAAM,WAAW,sBAAsB;IACrC,4DAA4D;IAC5D,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,CAAC;IACnC,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IAC3C;;;;;;;;OAQG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAC/C;;;;;;;;;OASG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,2DAA2D;AAC3D,MAAM,WAAW,gBAAgB;IAC/B,wEAAwE;IACxE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;+CAC2C;IAC3C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC;IAC1C,uEAAuE;IACvE,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC3C,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,wCAAwC;AACxC,MAAM,WAAW,eAAe;IAC9B,2EAA2E;IAC3E,QAAQ,CAAC,WAAW,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAClD,4DAA4D;IAC5D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;;;;;OAOG;IACH,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;CACrC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/evidence/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,CAAC;AAE3D;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,aAAa;IAC5B;sDACkD;IAClD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,oDAAoD;AACpD,MAAM,WAAW,sBAAsB;IACrC,4DAA4D;IAC5D,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,CAAC;IACnC,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IAC3C;;;;;;;;OAQG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAC/C;;;;;;;;;OASG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,2DAA2D;AAC3D,MAAM,WAAW,gBAAgB;IAC/B,wEAAwE;IACxE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;+CAC2C;IAC3C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC;IAC1C,uEAAuE;IACvE,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC3C,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,4DAA4D;IAC5D,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED,wCAAwC;AACxC,MAAM,WAAW,eAAe;IAC9B,2EAA2E;IAC3E,QAAQ,CAAC,WAAW,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAClD,4DAA4D;IAC5D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;;;;;OAOG;IACH,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;CACrC"}

package/dist/types/core/agent/stagedRefs.d.ts

@@ -0,0 +1,95 @@
+/**
+ * core/agent/stagedRefs — the join between data staged BY REFERENCE and the
+ * tool declared to spend it, composed into one sentence the model reads.
+ *
+ * ── The measured failure ────────────────────────────────────────────────────
+ * A traced production run: four tool results carried real numbers, a compute
+ * tool that could sum them was on the wire, and the app's prompt SAID to use
+ * it — yet the model summed the four numbers in its head and stated the total.
+ * The evidence gate recorded the truth ("appears in no tool result") and the
+ * answer shipped anyway, because the posture only observed. The prose
+ * instruction sat at the top of a long context; the numbers sat at the bottom.
+ * Recency won.
+ *
+ * ── The intervention: say it LATE, from DECLARATIONS ────────────────────────
+ * The library already holds both halves of the fix as data, no prose surface
+ * needed:
+ *
+ *   • a placed tool result (`artifacts.placement` / `Tool.resultKind`) is a
+ *     ticket in the conversation — `{ placed: true, ref, kind, … }` — naming
+ *     data staged by reference;
+ *   • a tool's `wants` (`{ arg: 'dataset/rows' }`) is the DECLARED promise
+ *     that it spends refs of exactly that kind — matched by the same
+ *     exact-string law the dispatch matcher uses, never by tool name.
+ *
+ * When both hold in one iteration, this module composes ONE short line naming
+ * the refs and the spender tool, placed at the END of the request — beside the
+ * data, where recency works for the instruction instead of against it. The
+ * line is ephemeral (request assembly only, never history) and recomposed
+ * each iteration, so it exists exactly while both conditions hold.
+ *
+ * The same join feeds the evidence correction: a revision that says "call the
+ * tool that provides it" without naming WHICH tool over WHICH ref leaves the
+ * model to head-math again.
+ *
+ * Pure functions, no scope, no events — the callers own delivery and record.
+ */
+import type { LLMMessage } from '../../adapters/types.js';
+import type { Tool } from '../tools.js';
+/** One staged parcel a spender tool could be handed. */
+export interface StagedRef {
+    /** The artifact ref, verbatim — what the model passes as the argument. */
+    readonly ref: string;
+    /** The minted kind — the exact string a `wants` declaration matched. */
+    readonly kind: string;
+}
+/** The join: which refs are in this iteration's context, and which served
+ *  tools declared `wants` over their kinds. Both lists are non-empty. */
+export interface StagedRefsMatch {
+    /** Distinct matched refs, oldest first, capped at {@link MAX_NUDGE_REFS}. */
+    readonly refs: readonly StagedRef[];
+    /** Matched refs beyond the cap — stated rather than silently dropped. */
+    readonly refsOmitted: number;
+    /** The spender tools' REGISTERED names, capped at {@link MAX_NUDGE_TOOLS}. */
+    readonly tools: readonly string[];
+}
+/** Most refs one nudge line names. Bounded so a fan-out that staged fifty
+ *  parcels cannot turn the one-line nudge into a page. */
+export declare const MAX_NUDGE_REFS = 6;
+/** Most spender tools one nudge line names. */
+export declare const MAX_NUDGE_TOOLS = 3;
+/**
+ * Harvest `Tool.wants` from the declared catalog — the `toolGrounding`
+ * harvest verbatim, and with the same caveat: ToolProvider-DELIVERED tools
+ * are invisible here (`list(ctx)` is opaque and per-iteration), so a provider
+ * tool declaring `wants` arms nothing. The runtime check stays correctly
+ * scoped on its own: the join below intersects this map with the tools the
+ * current call actually serves.
+ */
+export declare function toolWantsOf(registryByName: ReadonlyMap<string, Tool>): ReadonlyMap<string, readonly string[]>;
+/**
+ * The join itself: scan the conversation for placed tickets whose `kind` a
+ * currently-served `wants` tool declares, by the exact-string law the
+ * dispatch matcher uses. Returns `undefined` unless BOTH sides hold — no
+ * staged ref, or no served spender for any staged kind, means no match and
+ * the caller composes nothing.
+ *
+ * A `role: 'tool'` message carrying a placed result holds the ticket as JSON
+ * (`placedToolResult` is what wrote it); anything that does not parse to the
+ * ticket shape is an ordinary result and is skipped without a sound.
+ */
+export declare function findStagedRefs(messages: readonly LLMMessage[], toolWants: ReadonlyMap<string, readonly string[]>, servedToolNames: ReadonlySet<string>): StagedRefsMatch | undefined;
+/**
+ * The one late-positioned line (`nudge: true` on
+ * `.namesAndNumbersFromEvidence()`). Appended at request assembly as the LAST
+ * message of the iteration — never written to history — so the direction sits
+ * beside the data instead of a thousand tokens above it.
+ */
+export declare function stagedRefsNudgeLine(match: StagedRefsMatch): string;
+/**
+ * The refs sentence the evidence CORRECTION carries when the join holds at
+ * recheck time (see `buildEvidenceCorrection`) — the same facts, spoken
+ * inside the authored frame so the untrusted values still come last.
+ */
+export declare function stagedRefsTeachingClause(match: StagedRefsMatch): string;
+//# sourceMappingURL=stagedRefs.d.ts.map

package/dist/types/core/agent/stagedRefs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stagedRefs.d.ts","sourceRoot":"","sources":["../../../../src/core/agent/stagedRefs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE1D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,wDAAwD;AACxD,MAAM,WAAW,SAAS;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;yEACyE;AACzE,MAAM,WAAW,eAAe;IAC9B,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,SAAS,SAAS,EAAE,CAAC;IACpC,yEAAyE;IACzE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED;0DAC0D;AAC1D,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC,+CAA+C;AAC/C,eAAO,MAAM,eAAe,IAAI,CAAC;AAEjC;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,GACxC,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAQxC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,SAAS,UAAU,EAAE,EAC/B,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,EACjD,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,GACnC,eAAe,GAAG,SAAS,CAoC7B;AAaD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAOlE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAMvE"}

package/dist/types/core/agent/stages/callLLM.d.ts

@@ -68,6 +68,23 @@ export interface CallLLMStageDeps {
      * label. Absent → the corpus is exactly what it always was.
      */
     readonly externalGrounds?: () => readonly ExternalGround[];
+    /**
+     * The staged-refs nudge's harvest (`.namesAndNumbersFromEvidence({ nudge:
+     * true })`) — `Tool.wants` by tool name, present ONLY when the dial is on
+     * AND at least one registered tool declares `wants`; absent → this stage
+     * reads nothing new and every request keeps its exact bytes.
+     *
+     * When present, an iteration whose conversation holds placed artifact
+     * tickets a currently-served spender can consume gets ONE extra `role:
+     * 'user'` line appended at request assembly — never written to history —
+     * naming the refs and the spender: derived numbers come from the tool, not
+     * from mental arithmetic. Appended HERE for the wrap-up's reason (this is
+     * the one seam that decides what goes on the wire) and at the END for the
+     * measured reason: the failure this closes was recency — the app's own
+     * "use the compute tool" prose sat at the top of the context, the numbers
+     * at the bottom, and the model summed them in its head.
+     */
+    readonly toolWants?: ReadonlyMap<string, readonly string[]>;
     /**
      * The per-run disposition ledger, by REFERENCE (9.60.0) — plumbing shared
      * through the build closure like ProviderToolCache, never scope state.

package/dist/types/core/agent/stages/callLLM.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"callLLM.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/stages/callLLM.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAEV,WAAW,EAGX,aAAa,EACb,YAAY,EACb,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAe,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAI1E,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,kDAAkD,CAAC;AAK1D,OAAO,EAAgB,KAAK,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAqB,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAOnF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAyE9C,MAAM,WAAW,gBAAgB;IAC/B,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,qCAAqC;IACrC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,kCAAkC;IAClC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,kDAAkD;IAClD,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAC;IACrC,2CAA2C;IAC3C,QAAQ,CAAC,UAAU,CAAC,EAAE,kBAAkB,CAAC;IACzC;qDACiD;IACjD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,0EAA0E;IAC1E,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC;;sEAEkE;IAClE,QAAQ,CAAC,WAAW,EAAE,SAAS,aAAa,EAAE,CAAC;IAC/C;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;IAChE;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,SAAS,cAAc,EAAE,CAAC;IAC3D;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE;QACzB,OAAO,EAAE,OAAO,0CAA0C,EAAE,iBAAiB,GAAG,SAAS,CAAC;KAC3F,CAAC;IACF;;;;;uBAKmB;IACnB,QAAQ,CAAC,WAAW,CAAC,EAAE,iBAAiB,CAAC;IACzC;;;;;;oCAMgC;IAChC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IAC1D;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,aAAa,CAAC;IACpC;;yDAEqD;IACrD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,mBAAmB,EAAE,QAAQ,CAAC;IACzD;;;;;;OAMG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;CACvC;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,gBAAgB,GACrB,CAAC,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAugBlD"}
+{"version":3,"file":"callLLM.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/stages/callLLM.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAEV,WAAW,EAGX,aAAa,EACb,YAAY,EACb,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAe,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAI1E,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,kDAAkD,CAAC;AAM1D,OAAO,EAAgB,KAAK,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAqB,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAOnF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAyE9C,MAAM,WAAW,gBAAgB;IAC/B,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,qCAAqC;IACrC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,kCAAkC;IAClC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,kDAAkD;IAClD,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAC;IACrC,2CAA2C;IAC3C,QAAQ,CAAC,UAAU,CAAC,EAAE,kBAAkB,CAAC;IACzC;qDACiD;IACjD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,0EAA0E;IAC1E,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC;;sEAEkE;IAClE,QAAQ,CAAC,WAAW,EAAE,SAAS,aAAa,EAAE,CAAC;IAC/C;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;IAChE;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,SAAS,cAAc,EAAE,CAAC;IAC3D;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;IAC5D;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE;QACzB,OAAO,EAAE,OAAO,0CAA0C,EAAE,iBAAiB,GAAG,SAAS,CAAC;KAC3F,CAAC;IACF;;;;;uBAKmB;IACnB,QAAQ,CAAC,WAAW,CAAC,EAAE,iBAAiB,CAAC;IACzC;;;;;;oCAMgC;IAChC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IAC1D;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,aAAa,CAAC;IACpC;;yDAEqD;IACrD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,mBAAmB,EAAE,QAAQ,CAAC;IACzD;;;;;;OAMG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;CACvC;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,gBAAgB,GACrB,CAAC,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CA+hBlD"}

package/dist/types/core/agent/stages/evidenceRecheck.d.ts

@@ -24,9 +24,27 @@
 import type { TypedScope } from 'footprintjs';
 import type { ResolvedEvidenceGate } from '../evidence/types.js';
 import type { AgentState } from '../types.js';
+/**
+ * The staged-refs join's build-time half, threaded only when at least one
+ * registered tool declares `wants` (the `toolGrounding` law: absent means the
+ * stage reads no new scope key and the correction keeps its exact bytes).
+ */
+export interface EvidenceStagedRefsDeps {
+    /** Harvested `Tool.wants` — tool name → the kinds it spends. */
+    readonly toolWants: ReadonlyMap<string, readonly string[]>;
+    /** The static tool-schema names, late-bound (the `toolSchemas` getter
+     *  pattern) — the fallback before the tools slot has written
+     *  `dynamicToolSchemas`. */
+    readonly staticToolNames: () => readonly string[];
+}
 /**
  * Build the recheck stage. The decider already found the values and wrote the
  * carrier immediately before routing here — this stage does the work of asking.
+ *
+ * `stagedRefs` (optional): when this turn holds placed artifact tickets a
+ * currently-served `wants` tool can spend, the correction names the refs and
+ * the spender tool — the route to a grounded number, not just the demand for
+ * one. The revision-asked event carries the same facts, additively.
  */
-export declare function buildEvidenceRecheckStage(gate: ResolvedEvidenceGate): (scope: TypedScope<AgentState>) => void;
+export declare function buildEvidenceRecheckStage(gate: ResolvedEvidenceGate, stagedRefs?: EvidenceStagedRefsDeps): (scope: TypedScope<AgentState>) => void;
 //# sourceMappingURL=evidenceRecheck.d.ts.map

package/dist/types/core/agent/stages/evidenceRecheck.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"evidenceRecheck.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/stages/evidenceRecheck.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI9C,OAAO,KAAK,EAAE,oBAAoB,EAAoB,MAAM,sBAAsB,CAAC;AACnF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,oBAAoB,GACzB,CAAC,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,KAAK,IAAI,CAyDzC"}
+{"version":3,"file":"evidenceRecheck.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/stages/evidenceRecheck.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI9C,OAAO,KAAK,EAAE,oBAAoB,EAAoB,MAAM,sBAAsB,CAAC;AAEnF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,gEAAgE;IAChE,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;IAC3D;;gCAE4B;IAC5B,QAAQ,CAAC,eAAe,EAAE,MAAM,SAAS,MAAM,EAAE,CAAC;CACnD;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,oBAAoB,EAC1B,UAAU,CAAC,EAAE,sBAAsB,GAClC,CAAC,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,KAAK,IAAI,CAkFzC"}

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

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

package/dist/types/core/agent/toolDispatch.d.ts

@@ -0,0 +1,51 @@
+/**
+ * toolDispatch — the run's own tool dispatch, delivered as `ctx.tools`.
+ *
+ * Pattern: a deps-closure factory beside `toolArtifacts` / `toolProgress` in
+ *          the tool-calls handler; this module holds the PURE half (the
+ *          dispatch object over a lookup + an inner-context maker) so the
+ *          handler wires closures and nothing else.
+ * Role:    core/agent — composition over the registry (the runbookAsTool
+ *          substrate; any tool may consume it).
+ * Emits:   nothing itself. Inner executes flow through the tool's own
+ *          channels (`ctx.progress`, its result); they do NOT fire
+ *          `tool_start`/`tool_end` — an inner call is the OUTER call's work,
+ *          not a turn of the model's, and synthesizing model-facing events
+ *          for it would put calls in the record the model never made.
+ *
+ * What an inner call is NOT (phase 1, refused loudly, never silently):
+ *   - it cannot pause — a `checkIn` tool or a credential that needs
+ *     interactive consent refuses by name;
+ *   - it cannot redeem artifact refs — a `wants` tool refuses by name
+ *     (dispatch-time resolution belongs to the model-facing loop);
+ *   - it does not see ToolProvider-delivered tools — there is no build-time
+ *     list of those (the 9.72.0 caveat, carried forward honestly);
+ *   - it does not carry `ctx.tools` itself — composition depth stops at one,
+ *     the same bound the runbook grammar declares for sub-runbooks.
+ */
+import type { Tool, ToolDispatch, ToolExecutionContext } from '../tools.js';
+/** What the handler wires in — everything the dispatch cannot know itself. */
+export interface AgentToolDispatchDeps {
+    /** Name → Tool over the agent's dispatch map (static + skill-carried).
+     *  Provider-delivered tools are invisible by construction. */
+    readonly lookup: (name: string) => Tool | undefined;
+    /**
+     * Compose the execution context for ONE inner call: the outer call's own
+     * facts with `hasArtifacts: false`, a derived `toolCallId` (`seq` makes it
+     * unique within the outer call), and NO `tools` of its own.
+     */
+    readonly innerContext: (toolName: string, seq: number) => ToolExecutionContext;
+}
+/**
+ * Build the `ctx.tools` dispatch for one outer tool call.
+ *
+ * `call` resolves the inner tool's declared `needs` through the inner
+ * context's own credential provider (fail-closed — the provider throws its
+ * teaching refusal when none is attached), refuses the shapes an inner call
+ * cannot honor (see the module header), executes, and returns the result
+ * exactly as the tool returned it. Policy about what a result MEANS — an
+ * absence that should short-circuit, a coverage ledger that should fold —
+ * belongs to the consumer wrapping this dispatch, never here.
+ */
+export declare function agentToolDispatch(deps: AgentToolDispatchDeps): ToolDispatch;
+//# sourceMappingURL=toolDispatch.d.ts.map

package/dist/types/core/agent/toolDispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolDispatch.d.ts","sourceRoot":"","sources":["../../../../src/core/agent/toolDispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,KAAK,EACV,IAAI,EACJ,YAAY,EAEZ,oBAAoB,EACrB,MAAM,aAAa,CAAC;AAErB,8EAA8E;AAC9E,MAAM,WAAW,qBAAqB;IACpC;kEAC8D;IAC9D,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,SAAS,CAAC;IACpD;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,oBAAoB,CAAC;CAChF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,qBAAqB,GAAG,YAAY,CA4C3E"}

package/dist/types/core/flowchartAsTool.d.ts

@@ -1,6 +1,12 @@
 /**
  * flowchartAsTool — wrap a footprintjs `FlowChart` as an Agent `Tool`.
  *
+ * NOTE (9.76.0): for NEW procedures prefer `runbookAsTool` (core/runbook/) —
+ * the standard bridge whose every answer carries the honesty envelope
+ * (coverage, provenance, rule version, the recorded walk). This thin wrapper
+ * stays for compatibility; `resultMapper` users stay put and nothing here
+ * changes.
+ *
  * The Block A7 piece. footprintjs is the substrate; agentfootprint is
  * the agent layer above it. When a multi-step procedure is already
  * expressed as a footprintjs flowchart (intake validation, refund

package/dist/types/core/flowchartAsTool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flowchartAsTool.d.ts","sourceRoot":"","sources":["../../../src/core/flowchartAsTool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqHG;AAEH,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACd,KAAK,eAAe,EACrB,MAAM,aAAa,CAAC;AAYrB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,YAAY,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACnD;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS;QAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACnF;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,QAAQ,EAAE,qBAAqB,KAAK,MAAM,CAAC;AAEhF;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,gFAAgF;IAChF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yCAAyC;IACzC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACzD;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,qBAAqB,CAAC;IAC9C;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;IACrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,eAAe,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,sBAAsB,GAAG,IAAI,CAqJlE"}
+{"version":3,"file":"flowchartAsTool.d.ts","sourceRoot":"","sources":["../../../src/core/flowchartAsTool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2HG;AAEH,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACd,KAAK,eAAe,EACrB,MAAM,aAAa,CAAC;AAYrB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,YAAY,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACnD;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS;QAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACnF;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,QAAQ,EAAE,qBAAqB,KAAK,MAAM,CAAC;AAEhF;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,gFAAgF;IAChF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yCAAyC;IACzC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACzD;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,qBAAqB,CAAC;IAC9C;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;IACrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,eAAe,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,sBAAsB,GAAG,IAAI,CAsJlE"}

package/dist/types/core/runbook/coverage.d.ts

@@ -0,0 +1,70 @@
+/**
+ * runbook/coverage — the spine's ledger: inner folds + chart-declared
+ * entries + the bridge's own, and the sentence naming the rules.
+ *
+ * Pattern: pure fold over three sources, reusing the coverage primitives'
+ *          own recognizer and merge — no second grammar.
+ * Role:    core/runbook.
+ * Emits:   N/A.
+ *
+ * The three sources, in the order they land:
+ *   1. INNER LEDGERS — every recorded inner call's result is read by the
+ *      same `readCoverageResult` funnel the dispatch loop uses, and its
+ *      three lists fold upward. An inner tool's honesty is carried, never
+ *      re-authored.
+ *   2. THE CHART'S OWN — the procedure states run-specific coverage by
+ *      writing a `coverage` state key (`{ checked?, not_checked?,
+ *      cannot_cover? }`, items as `{what, why?}` bags or bare strings).
+ *      This is the app's vocabulary (which counters mean "not assessed" is
+ *      the chart's to know); the ENVELOPE is the bridge's.
+ *   3. THE BRIDGE'S OWN — one `checked` entry naming the procedure, its
+ *      recorded step count and the rule set it ran under; and, for a
+ *      verdict-shaped runbook, a `not_checked` entry counting DECLINED rows
+ *      (the three-outcome honesty: a row that reached no classification is
+ *      ground the answer does not cover).
+ */
+import type { CoverageItem } from '../agent/coverage/types.js';
+import type { InnerCallRecord } from './dispatch.js';
+import type { RunbookRules } from './types.js';
+/** The three lists, mid-fold. */
+export interface LedgerLists {
+    readonly checked: readonly CoverageItem[];
+    readonly notChecked: readonly CoverageItem[];
+    readonly cannotCover: readonly CoverageItem[];
+}
+/** Fold every recorded inner call's declared coverage upward. */
+export declare function foldInnerCoverage(records: readonly InnerCallRecord[]): LedgerLists;
+/** The chart-declared lists, read off the final state's `coverage` key.
+ *  Accepts both spellings of the two-word keys (state is often snake_case,
+ *  the declaration camelCase) — one reader, no drift. */
+export declare function chartCoverageOf(state: Readonly<Record<string, unknown>>): LedgerLists;
+/** What the composed ledger needs to know about this run. */
+export interface LedgerFacts {
+    readonly chartName: string;
+    readonly stepsExecuted: number;
+    readonly rules?: RunbookRules;
+    /** Rowset facts — present only for a verdict-shaped runbook. */
+    readonly rowsTotal?: number;
+    readonly declinedRows?: number;
+}
+/** The composed `af_coverage` value: three merged lists + the static law
+ *  note + this run's own sentence. */
+export interface ComposedLedger {
+    readonly checked?: readonly CoverageItem[];
+    readonly not_checked?: readonly CoverageItem[];
+    readonly cannot_cover?: readonly CoverageItem[];
+    readonly note: string;
+    readonly sentence: string;
+}
+/** Compose the whole ledger. Inner folds land first, chart-declared second,
+ *  the bridge's own last — provenance order, so a reader meets the sources
+ *  before the summary. */
+export declare function composeLedger(inner: LedgerLists, chart: LedgerLists, facts: LedgerFacts): ComposedLedger;
+/**
+ * The carried provenance stamp: the FIRST inner result that declared an
+ * `af_provenance` (on its unwrapped payload, or at its top level — both are
+ * read, in that order). A derived answer is still an answer, and a source's
+ * confession (`source: 'LOCAL SEED'`) must survive composition.
+ */
+export declare function carriedProvenanceOf(records: readonly InnerCallRecord[]): Record<string, unknown> | undefined;
+//# sourceMappingURL=coverage.d.ts.map

package/dist/types/core/runbook/coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../../../src/core/runbook/coverage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,iCAAiC;AACjC,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;IAC1C,QAAQ,CAAC,UAAU,EAAE,SAAS,YAAY,EAAE,CAAC;IAC7C,QAAQ,CAAC,WAAW,EAAE,SAAS,YAAY,EAAE,CAAC;CAC/C;AAID,iEAAiE;AACjE,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG,WAAW,CAkBlF;AAwBD;;yDAEyD;AACzD,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,WAAW,CASrF;AAED,6DAA6D;AAC7D,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC;IAC9B,gEAAgE;IAChE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;sCACsC;AACtC,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAC3C,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAC/C,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAOD;;0BAE0B;AAC1B,wBAAgB,aAAa,CAC3B,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,WAAW,GACjB,cAAc,CA8ChB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,eAAe,EAAE,GAClC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAerC"}

package/dist/types/core/runbook/dispatch.d.ts

@@ -0,0 +1,70 @@
+/**
+ * runbook/dispatch — the bridge's wrapper over `ctx.tools`.
+ *
+ * Pattern: decorator over {@link ToolDispatch}. The RAW dispatch (delivered
+ *          by the agent) returns every result untouched; POLICY about what a
+ *          result means belongs to the consumer — and this is the runbook's
+ *          policy: every inner outcome is RECORDED (for the coverage fold and
+ *          the provenance carry), and an inner ABSENCE short-circuits the
+ *          procedure unless the call site declared it survivable.
+ * Role:    core/runbook, pure.
+ * Emits:   N/A.
+ *
+ * WHY an absence short-circuits: "the inventory found nothing" IS the
+ * runbook's answer, and it must go back EXACTLY as it arrived so the
+ * framework still reads it as an absence — a verdict reached over a source
+ * that answered "nothing here" would be the confident-partial-answer failure
+ * this whole envelope exists to prevent. A stage that can genuinely carry on
+ * without the source says so at the call site (`{ allowAbsent: true }`) and
+ * owns stating the gap (usually as a coverage entry).
+ */
+import type { ToolAbsence } from '../agent/coverage/types.js';
+import type { ToolDispatch } from '../tools.js';
+/** One inner call, as the bridge recorded it. */
+export interface InnerCallRecord {
+    readonly tool: string;
+    readonly outcome: 'ok' | 'absent' | 'error';
+    /** The raw returned value (`'ok'` and `'absent'` outcomes). */
+    readonly result?: unknown;
+}
+/** The marker property that survives any error wrapping between a stage and
+ *  the bridge's catch. */
+declare const ABSENCE_SIGNAL: "af_runbook_absence";
+/**
+ * The control signal an un-survivable inner absence throws through the
+ * chart. The engine commits staged state and rethrows (commit-on-error is
+ * the law upstream), so the bridge catches this at `executor.run` and
+ * returns the absence verbatim.
+ */
+export declare class RunbookAbsenceSignal extends Error {
+    readonly absence: ToolAbsence;
+    readonly [ABSENCE_SIGNAL] = true;
+    constructor(absence: ToolAbsence, innerTool: string);
+}
+/** Recognize the signal on an error OR anywhere down its `cause` chain — an
+ *  engine layer that wraps the stage's throw must not defeat the pass-through. */
+export declare function absenceSignalOf(err: unknown): RunbookAbsenceSignal | undefined;
+/** What `recordingDispatch` hands back: the dispatch the procedure closes
+ *  over, and the record the envelope folds. */
+export interface RecordedDispatch {
+    readonly tools: ToolDispatch;
+    readonly records: readonly InnerCallRecord[];
+}
+/**
+ * Wrap the delivered dispatch (or its absence) for one runbook invocation.
+ *
+ * With NO dispatch delivered (`ctx.tools` absent — a hand-built context, a
+ * door with no dispatch map) the wrapper is the fail-closed teacher: `has`
+ * answers false and `call` refuses naming the fix, so a procedure that needs
+ * inner tools fails loudly at its first call instead of half-running.
+ */
+export declare function recordingDispatch(delivered: ToolDispatch | undefined, runbookName: string): RecordedDispatch;
+/**
+ * The definition-time probe dispatch — handed to the procedure factory ONCE
+ * at `runbookAsTool(...)` so the bridge can read the chart's declared
+ * contract. Stage bodies do not run at build; a factory that calls tools at
+ * build time hears exactly why that cannot work.
+ */
+export declare function probeDispatch(runbookName: string): ToolDispatch;
+export {};
+//# sourceMappingURL=dispatch.d.ts.map

package/dist/types/core/runbook/dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../../../src/core/runbook/dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAA2B,MAAM,aAAa,CAAC;AAEzE,iDAAiD;AACjD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,IAAI,GAAG,QAAQ,GAAG,OAAO,CAAC;IAC5C,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;0BAC0B;AAC1B,QAAA,MAAM,cAAc,sBAAgC,CAAC;AAErD;;;;;GAKG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAEjC,QAAQ,CAAC,OAAO,EAAE,WAAW;IADzC,QAAQ,CAAC,CAAC,cAAc,CAAC,QAAQ;gBACZ,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM;CAQ7D;AAED;kFACkF;AAClF,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,oBAAoB,GAAG,SAAS,CAS9E;AAED;+CAC+C;AAC/C,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;CAC9C;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,YAAY,GAAG,SAAS,EACnC,WAAW,EAAE,MAAM,GAClB,gBAAgB,CAiClB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,YAAY,CAW/D"}

package/dist/types/core/runbook/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * runbook — the standard bridge from a footprintjs procedure to an Agent
+ * tool with the mandatory honesty spine. See README.md in this folder.
+ */
+export { runbookAsTool } from './runbookAsTool.js';
+export { absenceSignalOf, probeDispatch, recordingDispatch, RunbookAbsenceSignal, type InnerCallRecord, type RecordedDispatch, } from './dispatch.js';
+export { DECLINED_VERDICT, DEFAULT_MAX_ROWS, renderVerdictTable, VERDICT_RENDER_NOTE, verdictRowsOf, } from './verdicts.js';
+export { DEFAULT_WALK_CAP, projectWalk, type ProjectedWalk, type WalkRow } from './walk.js';
+export type { RunbookAsToolOptions, RunbookEnvelope, RunbookProcedure, RunbookRules, RunbookVerdictsOptions, RunbookWalkOptions, VerdictRow, WalkDescriptor, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/core/runbook/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/runbook/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EACL,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,oBAAoB,EACpB,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACtB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,EACnB,aAAa,GACd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,KAAK,aAAa,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAC5F,YAAY,EACV,oBAAoB,EACpB,eAAe,EACf,gBAAgB,EAChB,YAAY,EACZ,sBAAsB,EACtB,kBAAkB,EAClB,UAAU,EACV,cAAc,GACf,MAAM,YAAY,CAAC"}

package/dist/types/core/runbook/runbookAsTool.d.ts

@@ -0,0 +1,89 @@
+/**
+ * runbookAsTool — turn a written operational procedure into a tool whose
+ * every answer is EVIDENCE: who decided what, against which threshold, on
+ * which rule version, with the recorded walk to check it against.
+ *
+ * The standard bridge from a footprintjs chart to the Agent's tool surface.
+ * Where `flowchartAsTool` returns bare `JSON.stringify(values)`,
+ * runbookAsTool supplies the missing middle — the honesty envelope every
+ * hand-rolled triage tool was building for itself:
+ *
+ *   THE MANDATORY SPINE (every runbook, whatever its shape):
+ *     - `af_coverage` — the three-list ledger, with every INNER tool's own
+ *       ledger folded upward through the run's dispatch, plus the sentence
+ *       naming the rule set and version;
+ *     - `result.af_provenance` — re-emitted FIRST (a carried `LOCAL SEED`
+ *       confession survives composition);
+ *     - `result.rule_version` — the declared rules' version, or the honest
+ *       `'undeclared'`;
+ *     - `result.walk` — the recorded walk's descriptor. The walk itself
+ *       ships as an artifact ticket (kind `recording/chart-walk`), never as
+ *       bytes; when it does not fit, the CONTROL FLOW survives and the
+ *       projection is declared.
+ *
+ *   THE OPTIONAL PROJECTION (selected by `resultKind: 'verdict/*'`):
+ *     verdict rows off the chart's `verdicts` state key, capped with
+ *     truthful counters, a pre-rendered table over the SAME rows, and
+ *     `verdict_meanings` GENERATED from the decider's declared branches +
+ *     the rule labels this run's decide() evidence carried.
+ *
+ *   THREE OUTCOMES, honestly: a clean envelope; an inner ABSENCE passed
+ *   through verbatim (the framework still reads it as an absence); and
+ *   DECLINED rows counted into the ledger as not-checked ground.
+ *
+ * The procedure is a FACTORY invoked per call with the run's own tool
+ * dispatch (`ctx.tools`) — fresh chart every run, stages close over the
+ * dispatch, and every inner tool's honesty ledger folds into this tool's
+ * answer.
+ *
+ * Reserved state keys the bridge reads off the final scope:
+ *   - `verdicts` — the rowset (verdict projection only);
+ *   - `coverage` — chart-declared coverage entries (`{checked?, not_checked?,
+ *     cannot_cover?}`);
+ *   - `report`  — the app's own result fields, spread into `result` verbatim
+ *     (spine keys win).
+ *
+ * Pause: NOT yet bridged. A paused inner chart throws with the checkpoint
+ * attached, exactly like `flowchartAsTool` — the approval-gate integration
+ * is the next phase of the runbook program.
+ *
+ * @example the smallest legal call — still yields the honest spine
+ *   const tool = runbookAsTool({
+ *     name: 'restart_check',
+ *     description: 'Run the restart-safety procedure.',
+ *     procedure: () =>
+ *       flowChart<{ safe: boolean }>('restart-safety', (scope) => {
+ *         scope.safe = true;
+ *       }, 'check').build(),
+ *   });
+ *
+ * @example a triage runbook with rules, verdicts, and an inner tool
+ *   const triage = runbookAsTool({
+ *     name: 'backup_triage',
+ *     description: 'Assess backup protection posture for every subject.',
+ *     resultKind: 'verdict/backup-posture',
+ *     rules: { name: 'health-signal', version: 'v1' },
+ *     verdicts: { decider: 'posture' },
+ *     composedOf: ['backup_inventory'],
+ *     procedure: (tools) =>
+ *       flowChart<TriageState>('backup-triage', async (scope) => {
+ *         const inner = (await tools.call('backup_inventory', {})) as InventoryResult;
+ *         scope.subjects = inner.result.rows;
+ *       }, 'inventory')
+ *         .addDeciderFunction('Posture', postureDecider, 'posture')
+ *           .addFunctionBranch('protected', 'Protected', landProtected)
+ *           .addFunctionBranch('unprotected', 'Unprotected', landUnprotected)
+ *           .end()
+ *         .build(),
+ *   });
+ */
+import { type Tool } from '../tools.js';
+import type { RunbookAsToolOptions } from './types.js';
+/**
+ * Wrap a footprintjs procedure as a `Tool` whose every answer carries the
+ * honesty spine. See the module header for the envelope; see
+ * {@link RunbookAsToolOptions} for the full options bag. The smallest legal
+ * call is `{ name, description, procedure }`.
+ */
+export declare function runbookAsTool(opts: RunbookAsToolOptions): Tool;
+//# sourceMappingURL=runbookAsTool.d.ts.map

package/dist/types/core/runbook/runbookAsTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runbookAsTool.d.ts","sourceRoot":"","sources":["../../../../src/core/runbook/runbookAsTool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AAaH,OAAO,EAAc,KAAK,IAAI,EAA6B,MAAM,aAAa,CAAC;AAQ/E,OAAO,KAAK,EAAE,oBAAoB,EAA+B,MAAM,YAAY,CAAC;AAuCpF;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAiR9D"}