agentfootprint 9.77.0 → 9.78.0

package/dist/types/integrity/column-types/types.d.ts

@@ -0,0 +1,122 @@
+/**
+ * The COLUMN-TYPE CONTRACT's vocabulary — what a tool may say about the
+ * columns of the rowset it returns, and the one rule that judges the saying.
+ *
+ * Pattern: closed vocabulary + definition-time assert (the `resultCeiling` /
+ *          `resultClass` law: a declaration this library cannot honour fails
+ *          at `defineTool`, never at the first row of the first run).
+ * Role:    leaf. `src/integrity/` imports nothing outside itself, so the
+ *          vocabulary lives HERE and `core/tools.ts` reaches in for it —
+ *          never the other way round.
+ *
+ * ── Why the words are these words ───────────────────────────────────────
+ * They are NOT invented. `number | string | boolean | date` is the vocabulary
+ * this ecosystem's rowset consumers already speak — a column-type union with
+ * exactly these members is what the visualization layer sniffs its way to
+ * today. Declaring in the consumer's own words is the `resultKind` law
+ * (9.70.0) restated one level down: the tool's result in the CONSUMER's
+ * vocabulary, not the framework's.
+ *
+ * The one member deliberately NOT carried over is `unknown`. A sniffer needs
+ * that word — it is what "I looked at the values and could not tell" sounds
+ * like. A DECLARATION has no use for it: an author who does not know what a
+ * column holds should not name the column, and `columns: { x: 'unknown' }`
+ * would be a promise about nothing that the checker would then have to
+ * pretend to verify.
+ *
+ * ── Two spellings, one meaning ──────────────────────────────────────────
+ * A column maps to a bare type (`lun: 'number'`) or to an object form
+ * (`note: { type: 'string', nullable: true }`). That is this library's house
+ * pattern for exactly this shape — `CostBudget` takes a bare number or
+ * `{ usd, onExceed }`, `artifacts` takes a bare store or `{ store, placement }`
+ * — and it is normalized ONCE, here, so every reader downstream sees one
+ * shape and no downstream file learns that there were two.
+ */
+/**
+ * What a declared column holds.
+ *
+ * | word | what a value must be |
+ * | --- | --- |
+ * | `number` | a JavaScript number that is FINITE — `NaN` and the infinities are a number that means "no number", and a chart handed one draws nothing |
+ * | `string` | a JavaScript string, including the empty one (emptiness is meaning, and meaning is above this check's ceiling) |
+ * | `boolean` | `true` or `false` — never `'true'`, never `0`, never `1` |
+ * | `date` | a valid `Date` instance, or a string `Date.parse` accepts (an epoch NUMBER is a `number`; say so and the axis picker stops guessing) |
+ */
+export type ColumnType = 'number' | 'string' | 'boolean' | 'date';
+/** The closed set, in one place, for the assert and for its own error message. */
+export declare const COLUMN_TYPES: readonly ColumnType[];
+/** The object spelling of one column's declaration. */
+export interface ColumnDeclaration {
+    /** What the column holds. */
+    readonly type: ColumnType;
+    /**
+     * `true` — a row of this column may legitimately carry NO VALUE (`null`,
+     * `undefined`, or the key simply not set on that row), and such a row is
+     * never a type violation.
+     *
+     * Default `false`, and the default is the strict one ON PURPOSE. The field
+     * failure this check is built from was a value that went missing and left
+     * an empty string behind; had the same code left a `null` behind, the
+     * defect would have been identical and a lenient default would have waved
+     * it through. One word turns it off, and every finding names that word — so
+     * a legitimate null column costs a one-word edit, while a silent default
+     * would cost the bug.
+     *
+     * `nullable` is a promise about VALUES. It is NOT a promise about the
+     * column's existence: a declared column that appears in no row at all is a
+     * `missing-column` finding whether or not it is nullable, because the
+     * declaration named a column and the result has no such column. The valve
+     * for "this column may or may not be there" is to not declare it —
+     * unlisted columns are allowed and unjudged.
+     */
+    readonly nullable?: boolean;
+}
+/**
+ * What a tool declares about the columns of its rowset — column name to type.
+ *
+ * OPEN, NEVER CLOSED. A declaration is a promise about what it NAMES, not a
+ * schema of everything the result may contain: a column nobody listed is
+ * allowed and is never judged. Two reasons, and both are the same reason.
+ *
+ *   • A closed schema punishes the wrong party. The day the backend adds a
+ *     column, every one of these tools starts filing findings about a change
+ *     that broke nothing — and a check that cries about correct behaviour is
+ *     a check people switch off, which is how the failure it exists to catch
+ *     gets back in.
+ *   • It is the rule the neighbouring boundary already keeps.
+ *     `toolArgsValidation` is permissive on keywords it does not know and
+ *     enforces `additionalProperties: false` only when an author explicitly
+ *     asks for it. Two validators at one seam disagreeing about whether
+ *     silence means "allowed" would be a worse defect than either could
+ *     catch.
+ */
+export type ToolResultColumns = Readonly<Record<string, ColumnType | ColumnDeclaration>>;
+/** One column's declaration after normalization — the ONLY shape any reader
+ *  downstream of `normalizeColumns` ever sees. */
+export interface NormalizedColumn {
+    readonly name: string;
+    readonly type: ColumnType;
+    readonly nullable: boolean;
+}
+/**
+ * Both spellings into one list, in declaration order.
+ *
+ * Order is kept because it is the author's order, and a finding that names
+ * columns in the order the author wrote them is a finding they can scan
+ * against their own source.
+ */
+export declare function normalizeColumns(columns: ToolResultColumns): readonly NormalizedColumn[];
+/**
+ * Refuse a `resultColumns` this library cannot honour, at definition time —
+ * naming the tool, the column and the fix.
+ *
+ * Exported beside {@link ColumnType} and called from `defineTool`, so a
+ * misspelled type fails on the line that wrote it rather than at the first
+ * rowset of the first armed run. Also called by the MCP ingest
+ * (`readToolExtras`) on a bag from a server this process does not control —
+ * which is why every read below goes through a fallback: a `null`, a number
+ * or an array must reach the teaching refusal, never blow up on the way to
+ * it.
+ */
+export declare function assertResultColumns(toolName: string, columns: unknown): void;
+//# sourceMappingURL=types.d.ts.map

package/dist/types/integrity/column-types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/integrity/column-types/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAC;AAElE,kFAAkF;AAClF,eAAO,MAAM,YAAY,EAAE,SAAS,UAAU,EAA4C,CAAC;AAE3F,uDAAuD;AACvD,MAAM,WAAW,iBAAiB;IAChC,6BAA6B;IAC7B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,iBAAiB,CAAC,CAAC,CAAC;AAEzF;kDACkD;AAClD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,GAAG,SAAS,gBAAgB,EAAE,CAUxF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAgD5E"}

package/dist/types/integrity/disposition/lifecycle.d.ts

@@ -14,7 +14,10 @@
  *          empty-lookup: that same declaration AND the operator's
  *          `noticeEmptyLookups` dial — two halves, because an advisory that
  *          armed itself off a declaration made for something else would not
- *          be opt-in at all).
+ *          be opt-in at all; column-types: `Tool.resultColumns` AND the
+ *          operator's `checkColumnTypes` dial off `'off'` — the same two
+ *          halves, arming BOTH `column-type-mismatch` and `missing-column`
+ *          off the one declaration).
  *          Registration is what makes silence auditable — an unregistered
  *          check is honest
  *          absence, a registered one that never notes is the wiring rot
@@ -60,6 +63,18 @@ export interface IntegrityChecksPresent {
      * silence.
      */
     readonly emptyLookup?: boolean;
+    /**
+     * The write seam's COLUMN-TYPE CONTRACT (9.78.0) — armed only when BOTH
+     * halves are true: the operator set `checkColumnTypes` to something other
+     * than `'off'` AND at least one tool declared `resultColumns`. The same
+     * two-halves law as `empty-lookup`, for the same reason: a declaration is
+     * a promise a consumer may already be reading for its own purposes, and
+     * arming a boundary check off it alone would make an absent dial change a
+     * run's bytes. ONE FLAG, TWO CHECKS — `column-type-mismatch` and
+     * `missing-column` are the same declaration read two ways, and nothing can
+     * arm one without arming the other.
+     */
+    readonly columnTypes?: boolean;
 }
 /**
  * Start one run's ledger: register the present checks and, in dev posture,

package/dist/types/integrity/disposition/lifecycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../src/integrity/disposition/lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAqB,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAUxE,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,KAAK,CAAC;AAEjD,gEAAgE;AAChE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,mDAAmD;IACnD,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;;;;OASG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,sBAAsB,EAC/B,OAAO,EAAE,gBAAgB,GACxB,iBAAiB,CAoJnB"}
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../src/integrity/disposition/lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAqB,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAWxE,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,KAAK,CAAC;AAEjD,gEAAgE;AAChE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,mDAAmD;IACnD,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;;;;OASG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,sBAAsB,EAC/B,OAAO,EAAE,gBAAgB,GACxB,iBAAiB,CAgLnB"}

package/dist/types/integrity/finding/types.d.ts

@@ -20,7 +20,7 @@
 import type { Assertion, SubjectRef } from '../assertion/types.js';
 import type { IntegritySeam } from '../disposition/types.js';
 /**
- * The six defect classes, by their plain names:
+ * The eight defect classes, by their plain names:
  *
  * | kind | means | mechanism |
  * |---|---|---|
@@ -30,6 +30,8 @@ import type { IntegritySeam } from '../disposition/types.js';
  * | `duplicate-execution`  | did settled work again                                 | once      |
  * | `unsupported-claim`    | stated something the record does not support           | grounding |
  * | `empty-lookup`         | the run produced this value, and the lookup for it found nothing | join |
+ * | `column-type-mismatch` | a column holds something other than the type its tool declared | type |
+ * | `missing-column`       | a column the tool declared is in none of its rows      | presence  |
  *
  * `empty-lookup` is the one class that is ADVISORY BY CONSTRUCTION (9.77.0) —
  * every finding it files carries `advisory: true`, because an empty result
@@ -38,8 +40,18 @@ import type { IntegritySeam } from '../disposition/types.js';
  * defect that was proven. It is deliberately NOT `dangling-reference`, whose
  * meaning is the opposite: there the ground has left reach, here the ground
  * is in reach and the lookup came back with nothing.
+ *
+ * `column-type-mismatch` and `missing-column` (9.78.0) are two classes rather
+ * than one ON PURPOSE, and the field failure they come from is the argument:
+ * a LUN of 0 stored as `''` and a LUN column that was never delivered send a
+ * person to two different files, and a checker that said only "something is
+ * off with logical_unit_number" would have helped with neither. Unlike
+ * `empty-lookup`, neither is advisory: a column declared `number` that holds
+ * a string is not a place to look, it is a broken promise — though what the
+ * check can see about it is bounded, and the bound ships as
+ * `COLUMN_TYPE_CEILING` in every message.
  */
-export type ContextErrorKind = 'invariant-violation' | 'unsupported-argument' | 'dangling-reference' | 'duplicate-execution' | 'unsupported-claim' | 'empty-lookup';
+export type ContextErrorKind = 'invariant-violation' | 'unsupported-argument' | 'dangling-reference' | 'duplicate-execution' | 'unsupported-claim' | 'empty-lookup' | 'column-type-mismatch' | 'missing-column';
 /** One detected context error — a labelled instance, automatically. */
 export interface ContextError {
     readonly kind: ContextErrorKind;

package/dist/types/integrity/finding/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/integrity/finding/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,gBAAgB,GACxB,qBAAqB,GACrB,sBAAsB,GACtB,oBAAoB,GACpB,qBAAqB,GACrB,mBAAmB,GACnB,cAAc,CAAC;AAEnB,uEAAuE;AACvE,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC;IACzC,qEAAqE;IACrE,QAAQ,CAAC,SAAS,EAAE,SAAS,SAAS,EAAE,CAAC;IACzC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC;IAC1B;;;;;;;;;OASG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC;IACzB,kGAAkG;IAClG,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAW5D;AAED,8DAA8D;AAC9D,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,SAAS,YAAY,EAAE,CAU5F"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/integrity/finding/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,MAAM,gBAAgB,GACxB,qBAAqB,GACrB,sBAAsB,GACtB,oBAAoB,GACpB,qBAAqB,GACrB,mBAAmB,GACnB,cAAc,GACd,sBAAsB,GACtB,gBAAgB,CAAC;AAErB,uEAAuE;AACvE,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC;IACzC,qEAAqE;IACrE,QAAQ,CAAC,SAAS,EAAE,SAAS,SAAS,EAAE,CAAC;IACzC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC;IAC1B;;;;;;;;;OASG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC;IACzB,kGAAkG;IAClG,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAW5D;AAED,8DAA8D;AAC9D,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,SAAS,YAAY,EAAE,CAU5F"}

package/dist/types/lib/mcp/toolExtras.d.ts

@@ -28,7 +28,7 @@
  *
  * ── What may travel, and the bar ────────────────────────────────────────
  * **A declaration a consumer-side check or rail reads; nothing that governs
- * execution.** The five fields below pass it. `needs` (credentials), `checkIn`
+ * execution.** Every field below passes it. `needs` (credentials), `checkIn`
  * (human consent) and the session hooks do NOT and never will: they govern how
  * a tool RUNS, and the tool runs on the server. Sending them would tell a
  * client to hold a gate that the only executor of the tool has already held,
@@ -49,7 +49,7 @@
  * That is the honest outcome: the rail it would have armed stays unarmed, and
  * the developer is told which rail and why.
  */
-import { type Tool, type ToolOwner, type ToolResultCeiling } from '../../core/tools.js';
+import { type Tool, type ToolOwner, type ToolResultCeiling, type ToolResultColumns } from '../../core/tools.js';
 import type { ToolResultClass } from '../semantics/types.js';
 /**
  * The single `_meta` key every agentfootprint declaration travels under.
@@ -79,6 +79,21 @@ export interface McpToolExtras {
     /** The artifact kind a PLACED result is minted under — see
      *  {@link Tool.resultKind}. What makes a placed result spendable by `wants`. */
     readonly resultKind?: string;
+    /**
+     * What this tool's ROWS contain (9.78.0) — see {@link Tool.resultColumns}.
+     * Arms the write seam's `column-type-mismatch` and `missing-column` checks.
+     *
+     * It clears the bar this file states, and by the widest margin of the eight.
+     * It is a flat, inert fact about the RESULT that a consumer-side check
+     * reads; it governs nothing about how the tool runs, and the tool runs on
+     * the server. It is also the field case for carrying declarations at all: a
+     * remote catalogue of rowset tools is exactly where a numeric column
+     * arriving as text goes unnoticed, because the consumer holding the chart
+     * has no way to know what the producer meant. Leaving it behind would arm
+     * the check for local tools and leave every MCP tool a second-class citizen
+     * of it — the whole defect `toolExtras` was built to end.
+     */
+    readonly resultColumns?: ToolResultColumns;
     /** The identity edge integrity checks join on — see {@link Tool.owner}. */
     readonly owner?: ToolOwner;
     /** The declared class of this tool's results — see {@link Tool.resultClass}. */

package/dist/types/lib/mcp/toolExtras.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolExtras.d.ts","sourceRoot":"","sources":["../../../../src/lib/mcp/toolExtras.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,OAAO,EAQL,KAAK,IAAI,EACT,KAAK,SAAS,EACd,KAAK,iBAAiB,EACvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,aAAa;IAC5B;uEACmE;IACnE,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C;oFACgF;IAChF,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;IAC3B,gFAAgF;IAChF,QAAQ,CAAC,WAAW,CAAC,EAAE,eAAe,CAAC;IACvC;sCACkC;IAClC,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAC3C;;gBAEY;IACZ,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC;;+CAE2C;IAC3C,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,aAAa,GAAG,SAAS,CAWlE;AAED,6EAA6E;AAC7E,MAAM,WAAW,mBAAmB;IAClC,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,mBAAmB,GAAG,aAAa,CAuCxF;AA+ED;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C"}
+{"version":3,"file":"toolExtras.d.ts","sourceRoot":"","sources":["../../../../src/lib/mcp/toolExtras.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,OAAO,EASL,KAAK,IAAI,EACT,KAAK,SAAS,EACd,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,aAAa;IAC5B;uEACmE;IACnE,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C;oFACgF;IAChF,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAC3C,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;IAC3B,gFAAgF;IAChF,QAAQ,CAAC,WAAW,CAAC,EAAE,eAAe,CAAC;IACvC;sCACkC;IAClC,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAC3C;;gBAEY;IACZ,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC;;+CAE2C;IAC3C,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,aAAa,GAAG,SAAS,CAYlE;AAED,6EAA6E;AAC7E,MAAM,WAAW,mBAAmB;IAClC,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,mBAAmB,GAAG,aAAa,CA2CxF;AA+ED;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C"}

package/dist/types/lib/trace-toolpack/traceToolpack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"traceToolpack.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-toolpack/traceToolpack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AASH,OAAO,EAAc,KAAK,IAAI,EAA6B,MAAM,qBAAqB,CAAC;AAcvF,OAAO,EAIL,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAC;AAuQpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,sBAAsB,EACjC,OAAO,CAAC,EAAE,oBAAoB,GAC7B,IAAI,EAAE,CA0BR;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,kMAYnB,CAAC;AAspEX;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACjC,OAAO,CAAC,MAAM,CAAC,CASjB"}
+{"version":3,"file":"traceToolpack.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-toolpack/traceToolpack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AASH,OAAO,EAAc,KAAK,IAAI,EAA6B,MAAM,qBAAqB,CAAC;AAcvF,OAAO,EAIL,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAC;AAuQpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,sBAAsB,EACjC,OAAO,CAAC,EAAE,oBAAoB,GAC7B,IAAI,EAAE,CA0BR;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,kMAYnB,CAAC;AAwpEX;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACjC,OAAO,CAAC,MAAM,CAAC,CASjB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfootprint",
-  "version": "9.77.0",
+  "version": "9.78.0",
   "description": "The explainable agent framework — backtrack a wrong answer to the exact context that caused it (evidence, not guesses). Built on footprintjs.",
   "license": "MIT",
   "type": "commonjs",