agentfootprint 10.3.0 → 10.3.1

package/dist/types/core/agent/coverage/timeLimitFacts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"timeLimitFacts.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/coverage/timeLimitFacts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,WAAW,EACjB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,8FAA8F;AAC9F,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEpD,+DAA+D;AAC/D,MAAM,WAAW,cAAc;IAC7B,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,4FAA4F;IAC5F,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IACzC,8FAA8F;IAC9F,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B,gGAAgG;IAChG,QAAQ,CAAC,WAAW,CAAC,EAAE,IAAI,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,SAAS,EAAE,QAAQ,GAAE,kBAA6B,GAAG,OAAO,CAOjG;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,EACtC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,QAAQ,GAAE,kBAA6B,GACtC,cAAc,GAAG,SAAS,CAsB5B"}

package/dist/types/core/agent/coverage/timeLimits.d.ts

@@ -1,68 +0,0 @@
-/**
- * coverage/timeLimits.ts — the time layer's limits lines for ONE turn (step T8),
- * composed from the record and nothing else.
- *
- * Two readers ask it, so the person and the model are told the same thing:
- *
- * - the limits block (`stages/prepareFinal.ts`), which prints the lines under
- *   `Period` and `Clocks` for the PERSON after the answer;
- * - the served time line (`agent/arguments/serve.ts` · `timeLimitsSentence`),
- *   which hands the MODEL the same lines as the library's conclusion, late, at
- *   the decision point, before it writes the answer.
- *
- * What it reads: the facts `timeLimitFacts.ts` · `timeLimitFactsOf` reads —
- * the turn's `period` rows whose result checks hold, the turn's
- * `source-clock` rows (`core/time/checkRecord.ts` · `clocksDiffer`) and the
- * clock row's zone — rendered here (`period.ts` · `periodCheckLine`,
- * `clockLines`). `undefined` when there is no clock (nothing to render in) or
- * nothing to say.
- *
- * Loaded through `import()` only, under `.time()` (`stages/prepareFinal.ts`;
- * `arguments/serve.ts`, itself loaded under the arm): it renders through
- * `core/time/present.ts`, which a plain agent never loads.
- */
-import { type PeriodRow } from './period.js';
-import { type BoundPresentation } from '../../time/present.js';
-import type { TimeLimitLines } from './answer.js';
-import { type TimeLimitFacts, type TimeLimitsAudience } from './timeLimitFacts.js';
-export type { TimeLimitLines };
-/** The clocks line under an unknown zone (G15): the ranges are in UTC because the person's zone is not known. */
-export declare const UNKNOWN_ZONE_LINE = "times are shown in UTC \u2014 the person's time zone is not known";
-/**
- * The model's line for a call whose source holds none or only part of the
- * time it asked about (`PeriodRow.held`): what the call asked about and what
- * its source holds, each AS DECLARED (inclusive ends, no end moved) and
- * rendered in the presentation zone by the time layer's one renderer — the
- * same spans the person's `Period:` line prints (`period.ts` · `periodLine`) — then
- * how much of the asked time that is. `undefined` when the row carries none.
- *
- * @example
- * ```ts
- * heldLine(row, bindPresentation({ zone: 'America/Los_Angeles' }));
- * // 'pscale_client_health asked about 2026-09-30 06:00:00–11:59:50 America/Los_Angeles (UTC-07:00);
- * //  its source holds 2026-10-01 09:22:44.300–10:02:44.300 America/Los_Angeles (UTC-07:00), which
- * //  covers none of that time'
- * ```
- */
-export declare function heldLine(row: PeriodRow, presentation: BoundPresentation): string | undefined;
-/**
- * The turn's time limits lines, from the ledger — {@link renderTimeLimits}
- * over `timeLimitFacts.ts` · `timeLimitFactsOf`. `turn` undefined reads every
- * row (a ledger that carries one turn). `audience` `'model'` (the served time
- * line) names the person's window as theirs and keeps, of the clocks, only the
- * label that two differ.
- *
- * @example
- * ```ts
- * timeLimitLinesOf(ledger, 1);
- * // { period: ['client_activity read less than was asked — asked: …; read: …'], clocks: [] }
- * ```
- */
-export declare function timeLimitLinesOf(ledger: readonly unknown[] | undefined, turn: number | undefined, audience?: TimeLimitsAudience): TimeLimitLines | undefined;
-/**
- * The limits lines for `audience`, rendered in the facts' zone by the time
- * layer's one renderer (`core/time/present.ts` · `bindPresentation`) —
- * `undefined` when there are no facts or nothing to say.
- */
-export declare function renderTimeLimits(facts: TimeLimitFacts | undefined, audience?: TimeLimitsAudience): TimeLimitLines | undefined;
-//# sourceMappingURL=timeLimits.d.ts.map

package/dist/types/core/agent/coverage/timeLimits.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"timeLimits.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/coverage/timeLimits.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAA+B,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,EAAoB,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACxB,MAAM,qBAAqB,CAAC;AAE7B,YAAY,EAAE,cAAc,EAAE,CAAC;AAK/B,iHAAiH;AACjH,eAAO,MAAM,iBAAiB,sEAAiE,CAAC;AAQhG;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,SAAS,EAAE,YAAY,EAAE,iBAAiB,GAAG,MAAM,GAAG,SAAS,CAW5F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,EACtC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,QAAQ,GAAE,kBAA6B,GACtC,cAAc,GAAG,SAAS,CAE5B;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,GAAG,SAAS,EACjC,QAAQ,GAAE,kBAA6B,GACtC,cAAc,GAAG,SAAS,CAyB5B"}

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

@@ -1,321 +0,0 @@
-/**
- * coverage/types — the shared vocabulary of the two coverage primitives.
- *
- * Pattern: one value type, two consumers — `absent()` says "I looked HERE and
- *          found nothing", `coverage()` says "my answer covers THIS and not
- *          THAT". Both are statements about the same thing: the ground a
- *          result stands on. Spelling them with one vocabulary is what lets
- *          the answer-level block merge an absence's boundary with a
- *          verdict's without translating between two grammars.
- * Role:    core/ layer, pure data. No behavior; TYPE-only imports (they erase
- *          at runtime): the one period shape (`period.ts`) and the one
- *          provenance shape `describedResult()` already declares
- *          (`lib/semantics/types.ts`), so an absence says its source and time
- *          in the same words a described result does.
- * Emits:   N/A.
- */
-import type { DescribedResultDeclaration, SemanticProvenance } from '../../../lib/semantics/types.js';
-import type { DeclaredPeriod, PeriodOnWire } from './period.js';
-/**
- * One piece of ground, and (optionally) why it is where it is.
- *
- * `what` is prose the TOOL AUTHOR wrote — a source, a window, a filter, a
- * fleet ("the fcns database on shq-fab-a", "the last 24h", "all four
- * arrays"). It is never composed from the model's arguments by this library,
- * because the library does not know which of them are real.
- */
-export interface CoverageItem {
-    /** The source, window, filter or population. Non-empty. */
-    readonly what: string;
-    /**
-     * Why it sits where it does. REQUIRED on `cannotCover` (a permanent blind
-     * spot is a claim about capability, and a claim with no reason cannot be
-     * acted on or disproved); optional on `checked` and `notChecked`, where
-     * "we did" and "we did not need to" are often the whole story.
-     */
-    readonly why?: string;
-    /**
-     * A short plain form of `what`, for a person reading a report — "every VM
-     * disk in the RVTools export of 2026-09-19" for a `what` that names the two
-     * tables it read. Optional; at most 80 characters, one line, and never
-     * longer than `what`.
-     *
-     * RECORD-ONLY: it rides the events (`tools.absent`,
-     * `tools.coverage_declared`), the tracked `coverageDeclared` rows and the
-     * answer account, and is REMOVED from what the model is served
-     * (`read.ts` · `servedToModel`). It is also withheld from the evidence
-     * corpus (`evidence.ts`), because it is the field an author is most tempted
-     * to personalise: NEVER interpolate the caller's arguments into it — a true
-     * short form restates `what`, so no value should live only here.
-     */
-    readonly short?: string;
-    /**
-     * What kind of ground a `notChecked` or `cannotCover` item is — a CLOSED
-     * set, read by the answer account's existence check:
-     *
-     *   • `'existence'` — whether the thing asked about exists at all, or is
-     *     the kind of thing the question assumes ("whether that name is a
-     *     storage array").
-     *   • `'scope'` — a population, family or source outside what this tool
-     *     reaches ("hosts that are not VMware").
-     *
-     * Refused on `checked`. RECORD-ONLY, like `short`. Absent = not declared:
-     * a reader never infers a kind from `what`. Library code never switches
-     * EXHAUSTIVELY over this union (every switch has a `default` arm), so a
-     * later member is an additive change for producers.
-     */
-    readonly kind?: 'existence' | 'scope';
-}
-/** What an author may write in a coverage list: bare prose, or prose + why. */
-export type CoverageInput = string | CoverageItem;
-/**
- * One thing the tool READ and found still RUNNING — a backup in progress, a
- * replication session still synchronizing — whose outcome is therefore not
- * known yet: neither a success nor a failure (`coverage()`'s `inProgress`).
- *
- * The TOOL decides which of its vendor's states are in flight — this library
- * never reads a state name, and the vendor's own verdict field, when there is
- * one, is the tool's to weigh. `what` is the author's prose, as for every
- * coverage item; `short` is the same RECORD-ONLY short form. `count` says how
- * many things this one entry stands for ("96 sessions still synchronizing" is
- * one entry with `count: 96`); omitted, the entry is one thing. It is served —
- * the model reads the number as the tool's own.
- *
- * No `kind`: that names ground a call did NOT reach, and an item in progress
- * is ground it reached.
- */
-export interface InProgressItem {
-    /** What is still running. Non-empty. */
-    readonly what: string;
-    /** Since when, or what the vendor reported — optional. */
-    readonly why?: string;
-    /** RECORD-ONLY short form, the {@link CoverageItem.short} rules. */
-    readonly short?: string;
-    /** How many things this entry stands for — a positive whole number; omitted = one. */
-    readonly count?: number;
-}
-/** What an author may write in `inProgress`: bare prose, or an {@link InProgressItem}. */
-export type InProgressInput = string | InProgressItem;
-/**
- * The three lists, normalized. This is the shape everything downstream reads —
- * the renderer, the event payload, the answer-level block.
- *
- * The three are NOT interchangeable, and the difference is the whole point:
- *
- *   • `checked` — ground this result actually stands on. A clean verdict here
- *     means VERIFIED.
- *   • `notChecked` — ground this run could have covered and did not (budget,
- *     a timeout, a scope the caller chose). A clean verdict says nothing
- *     about it. Re-asking with a wider scope can move it to `checked`.
- *   • `cannotCover` — ground no call to this tool will ever reach (no
- *     collector, no permission, no such telemetry). A clean verdict says
- *     nothing about it, and no retry ever will. This is the list that turns
- *     "everything looks fine" into "everything I can see looks fine".
- */
-export interface Coverage {
-    readonly checked: readonly CoverageItem[];
-    readonly notChecked: readonly CoverageItem[];
-    readonly cannotCover: readonly CoverageItem[];
-}
-/** What a tool author passes to {@link import('./ledger.js').coverage}. */
-export interface CoverageDeclaration {
-    readonly checked?: readonly CoverageInput[];
-    readonly notChecked?: readonly CoverageInput[];
-    readonly cannotCover?: readonly CoverageInput[];
-}
-/**
- * The other TOOL a suggestion points at, typed (9.113.0) — `tryInsteadTool`
- * on the declaration, `try_instead_tool` on the envelope.
- *
- * The `tryInstead` sentence puts a tool's name inside prose ("…or check
- * cluster_inventory for the collected names."), and a reader that wants to
- * know WHICH tool was suggested could only find out by parsing that sentence.
- * This library never parses a tool name out of prose, so the name rides here
- * as data — BESIDE the sentence, never in its place: `try_instead` stays a
- * string, so every reader of it reads what it always read.
- *
- * `tool` is NOT looked up. The tool may be served by a provider that resolves
- * per iteration, or be offered on a later turn; `absent()` requires a
- * non-empty name and records it as declared. Which names a provider accepts is
- * `core/tools.ts` · `assertValidToolName`'s question, and the library only
- * warns about it (dev mode), here as at `defineTool`.
- */
-export interface TryInsteadTool {
-    /** The tool's registered name, as a call would name it. */
-    readonly tool: string;
-    /** Why that tool, in the author's words ("it lists the collected names"). */
-    readonly why?: string;
-}
-/** What a tool author passes to {@link import('./absent.js').absent}. */
-export interface AbsenceDeclaration {
-    /**
-     * What was looked for, in the author's own words ("FLOGI entries on
-     * fc1/3"). Required: an absence that cannot say what it did not find is
-     * indistinguishable from a tool that returned nothing by accident.
-     */
-    readonly what: string;
-    /**
-     * The coverage of the search — REQUIRED and non-empty. An absence that
-     * names no coverage is a `null` with extra steps: the reader still cannot
-     * tell "I looked and there is nothing" from "I could not look", which is
-     * the entire failure this primitive exists to prevent.
-     */
-    readonly checked: readonly CoverageInput[];
-    /** Ground the search did not reach this time — an absence here proves
-     *  nothing about it. */
-    readonly notChecked?: readonly CoverageInput[];
-    /** Ground no search by this tool can reach. Each needs a `why`. */
-    readonly cannotCover?: readonly CoverageInput[];
-    /**
-     * Where to go INSTEAD, in one sentence ("widen the window with
-     * `window: '7d'`, or ask for a different interface"). Optional, and the
-     * highest-value optional field in the shape: the loop this primitive stops
-     * is a model with nowhere else to go.
-     *
-     * Prose for the model. Nothing in this library reads a tool name out of it:
-     * when the sentence points at another tool, name that tool in
-     * {@link AbsenceDeclaration.tryInsteadTool} as well.
-     */
-    readonly tryInstead?: string;
-    /**
-     * The other TOOL the suggestion points at, as data (9.113.0) —
-     * `{ tool, why? }`. Beside the sentence, not instead of it: the sentence is
-     * what the model is told, this is what a reader reads without parsing
-     * prose. Either may be given without the other; when both are given they
-     * must name the same tool, and the library cannot check that they do — it
-     * would have to read a tool name out of the sentence. ONE tool; a list is
-     * refused (see `absent.ts` · `readToolSuggestion` for why).
-     */
-    readonly tryInsteadTool?: TryInsteadTool;
-    /**
-     * Where the search looked and how old that source is — the SAME shape
-     * `describedResult()` declares (`measuredAt`, `source`, and optionally
-     * `ageSeconds`, `sourceExportDate`), respelled to the same snake_case wire
-     * (honesty step 7b). `measuredAt` and `source` are both required once it is
-     * present. So the found branch and the not-found branch of one `execute`
-     * carry their source and time in one shape: "searched the 02:00 export —
-     * nothing" as data, not prose in `checked`. `measuredAt` is the tool's own
-     * words, never parsed.
-     */
-    readonly provenance?: NonNullable<DescribedResultDeclaration['provenance']>;
-    /**
-     * What the search's READ covered in time — the instants it asked for, and
-     * what the store holds (or `'unknown'`, said out loud) — honesty step 7b.
-     * Every value is an ISO 8601 instant with a zone; a malformed period is
-     * refused here. The results layer files its verdict (covered · partly held ·
-     * not held · unknown), and `.limitsTravelWithTheAnswer()` prints it.
-     */
-    readonly period?: DeclaredPeriod;
-}
-/**
- * What a tool author passes to {@link import('./ledger.js').coverage}: the
- * three lists, and the period the verdict's read covered (honesty step 7b).
- * `coverage()` takes no `provenance` — a value that comes as rows from a
- * system of record has `describedResult()`.
- *
- * @inline
- */
-export type CoverageLedgerDeclaration = CoverageDeclaration & {
-    /**
-     * What the read behind this value covered in time — the instants it asked
-     * for, and what the store holds (or `'unknown'`). Refused when malformed.
-     */
-    readonly period?: DeclaredPeriod;
-    /**
-     * What the read found still RUNNING — its outcome not known yet (a backup in
-     * progress, a session still synchronizing). The tool decides what is in
-     * flight; the library never reads a vendor's state name. Needs `checked`
-     * beside it (an item in progress is ground the call read). An empty list
-     * says nothing and is omitted, like every coverage list. Served as
-     * `in_progress`, with one static clause after the note; recorded on the
-     * `coverageDeclared` row and `tools.coverage_declared`; printed under
-     * `.limitsTravelWithTheAnswer()`. It never changes the answer's standing.
-     */
-    readonly inProgress?: readonly InProgressInput[];
-};
-/**
- * The rendered absence — the exact object a tool hands back and the model
- * reads. Field names are snake_case and English on purpose: this value is
- * read by a language model far more often than by code, and `af_absent` is
- * the only field here that exists for the machine.
- *
- * The `af_absent` key is RESERVED vocabulary on the tool-result wire (the
- * `propose-transition` / `require-instruction` precedent): a plain object
- * carrying it is an absence, and nothing else in this library will treat any
- * other shape as one.
- */
-export interface ToolAbsence {
-    readonly af_absent: true;
-    /** The plain-English handle. Present so a model that skims one key still
-     *  reads the outcome rather than inferring it from a missing field. */
-    readonly outcome: 'nothing_found';
-    readonly looked_for: string;
-    readonly checked: readonly CoverageItem[];
-    readonly not_checked?: readonly CoverageItem[];
-    readonly cannot_cover?: readonly CoverageItem[];
-    /** Stated as data as well as prose — the note can be skimmed past, a
-     *  `true` in a field named for the question cannot. */
-    readonly retry_returns_the_same: true;
-    /** The author's sentence. A string, always — the typed tool rides its own
-     *  key, so a reader of this one never has to narrow it. */
-    readonly try_instead?: string;
-    /** The typed tool the suggestion points at (9.113.0), as declared — the
-     *  author's words, `{ tool, why? }`. The model reads it as written. */
-    readonly try_instead_tool?: TryInsteadTool;
-    /** Where the search looked and when that source was measured — the wire
-     *  `describedResult()` mints (`measured_at`, `source`, …), honesty step 7b. */
-    readonly provenance?: SemanticProvenance;
-    /** What the search's read covered in time — `queried`, `held` (or
-     *  `'unknown'`), `read_at` — honesty step 7b. */
-    readonly period?: PeriodOnWire;
-    /** The static sentence. Never interpolated — see `absent.ts`. */
-    readonly note: string;
-}
-/** The rendered coverage ledger, wrapped around the result it bounds. */
-export interface CoveredResult<T = unknown> {
-    readonly af_coverage: {
-        readonly checked?: readonly CoverageItem[];
-        readonly not_checked?: readonly CoverageItem[];
-        readonly cannot_cover?: readonly CoverageItem[];
-        /** What the read found still running — its outcome not known yet.
-         *  Serialized before `result`, like the lists. */
-        readonly in_progress?: readonly InProgressItem[];
-        /** What the read behind the value covered in time — honesty step 7b.
-         *  Serialized before `result`, like the lists. */
-        readonly period?: PeriodOnWire;
-        readonly note: string;
-    };
-    /** The tool's own answer, untouched. */
-    readonly result: T;
-}
-/**
- * One coverage statement as the RUN recorded it — what the event carries and
- * what accumulates in `AgentState.coverageDeclared`.
- *
- * `kind` is kept because the two read differently at the answer boundary: a
- * `'ledger'` bounds a verdict the answer is probably built on, an
- * `'absence'` bounds a search that found nothing.
- */
-export interface DeclaredCoverage extends Coverage {
-    readonly kind: 'absence' | 'ledger';
-    readonly toolName: string;
-    readonly toolCallId?: string;
-    readonly iteration: number;
-    /** Present for `'absence'` only — what the search was for. */
-    readonly lookedFor?: string;
-    /**
-     * The period the declaration said its read covered, in the record's
-     * camelCase form (honesty step 7b) — present only when the envelope declared
-     * a well-formed one. A described result with a period and no coverage lists
-     * files a `'ledger'` row whose three lists are empty.
-     */
-    readonly period?: DeclaredPeriod;
-    /**
-     * What the call found still running — its outcome not known yet — as the
-     * `coverage()` declared it (copied item by item; `short` and `count` when
-     * valid). Present only on a `'ledger'` row whose envelope declared a
-     * well-formed, non-empty `in_progress`.
-     */
-    readonly inProgress?: readonly InProgressItem[];
-}
-//# sourceMappingURL=types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/coverage/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EACV,0BAA0B,EAC1B,kBAAkB,EACnB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhE;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC;CACvC;AAED,+EAA+E;AAC/E,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,YAAY,CAAC;AAElD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,cAAc;IAC7B,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0DAA0D;IAC1D,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,oEAAoE;IACpE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,sFAAsF;IACtF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,0FAA0F;AAC1F,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,cAAc,CAAC;AAEtD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,QAAQ;IACvB,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;AAED,2EAA2E;AAC3E,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IAC5C,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IAC/C,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;CACjD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,cAAc;IAC7B,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,yEAAyE;AACzE,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,CAAC;IAC3C;4BACwB;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IAC/C,mEAAmE;IACnE,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IAChD;;;;;;;;;OASG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;;;;OAQG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC;IACzC;;;;;;;;;OASG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,WAAW,CAAC,0BAA0B,CAAC,YAAY,CAAC,CAAC,CAAC;IAC5E;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;CAClC;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,yBAAyB,GAAG,mBAAmB,GAAG;IAC5D;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;IACjC;;;;;;;;;OASG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC;CAClD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IACzB;2EACuE;IACvE,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;IAC1C,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAC/C,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAChD;2DACuD;IACvD,QAAQ,CAAC,sBAAsB,EAAE,IAAI,CAAC;IACtC;+DAC2D;IAC3D,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;2EACuE;IACvE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,cAAc,CAAC;IAC3C;mFAC+E;IAC/E,QAAQ,CAAC,UAAU,CAAC,EAAE,kBAAkB,CAAC;IACzC;qDACiD;IACjD,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,yEAAyE;AACzE,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,OAAO;IACxC,QAAQ,CAAC,WAAW,EAAE;QACpB,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;QAC3C,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;QAC/C,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;QAChD;0DACkD;QAClD,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;QACjD;0DACkD;QAClD,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;QAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;KACvB,CAAC;IACF,wCAAwC;IACxC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAiB,SAAQ,QAAQ;IAChD,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,QAAQ,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,8DAA8D;IAC9D,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;IACjC;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;CACjD"}

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

@@ -1,42 +0,0 @@
-/**
- * Reduce one raw token to the form both sides compare on.
- *
- * Returns `''` for a token that is nothing but decoration — callers drop those.
- */
-export declare function normalizeToken(raw: string): string;
-/** How many digit characters a string carries. */
-export declare function countDigits(v: string): number;
-/**
- * Split free text into candidate tokens.
- *
- * Used on the answer (to find values to ground) and on any tool-result text
- * that is not JSON. Token boundaries are the whole point: a value that appears
- * only as a SUBSTRING of an unrelated field must not read as grounded, so
- * matching is always token-exact and never substring.
- */
-export declare function tokenize(text: string): string[];
-/**
- * The spellings of one normalized value that count as the SAME value when
- * looking it up.
- *
- * Only one rule so far, and it is a real one: an FCID is read off a switch as
- * `0xef0101` and quoted back sometimes as `ef0101`. Both sides expand, so the
- * prefix can be dropped by either the tool or the model without either being
- * accused of inventing it.
- *
- * Deliberately NOT here (9.110.0): a glued-unit number's bare form. Applied
- * on the INDEX side it would let a result's `latency 2024ms` ground an
- * answer's prose year `2024`, which weakens the gate; the glued spelling is
- * met on the LOOKUP side only, by the candidate that came from one
- * (`extract.ts · candidateForms`).
- */
-export declare function lookupForms(normalized: string): readonly string[];
-/**
- * The one spelling every equivalent value shares — the LAST of
- * `lookupForms`, so `0xef0101` and `ef0101` both canonicalise to `ef0101`.
- * A reader that must file one thing per VALUE (`findings/contingent.ts`,
- * one row per value per moment) keys on this rather than on the spelling
- * the model happened to use.
- */
-export declare function canonicalForm(normalized: string): string;
-//# sourceMappingURL=normalize.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/evidence/normalize.ts"],"names":[],"mappings":"AA0EA;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAiBlD;AAED,kDAAkD;AAClD,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAI7C;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAY/C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAKjE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAGxD"}

package/dist/types/core/agent/middleware/runChain.d.ts

@@ -1,167 +0,0 @@
-/**
- * middleware/runChain — INTERNAL. The one place a chain is walked.
- *
- * Pattern: Chain of Responsibility driver.
- * Role:    core/ layer. Both stages (tool dispatch, message boundary) and
- *          the MCP server call in here, so the ordering law, the
- *          throw-is-a-denial law and the ledger row shape are written once
- *          and cannot drift between the three callers.
- * Emits:   N/A — it RETURNS rows; the caller commits and emits them, so a
- *          middleware still never touches scope.
- *
- * ## The rules this file implements
- *
- * **Order is declaration order.** The chain is walked front to back, and
- * each link is handed the previous link's output — so a scrubber placed
- * first is a scrubber every later rule sees the effect of.
- *
- * **The first non-allow answer wins.** A deny or an ask stops the walk;
- * the links behind it do not run. There is no "second opinion" pass,
- * because a refusal that a later middleware could overturn is not a
- * refusal.
- *
- * **A middleware that throws is a denial, never a pass.** The thrown
- * message becomes the reason. This is the same deny-by-default the
- * permission gate has always applied to a checker that throws: a
- * governance layer whose failure mode is "allow" is not a governance
- * layer.
- *
- * **A middleware that malfunctions is a denial too** (8.18.0). Two ways to
- * malfunction at the message boundary: answer `ask` where no pause exists to
- * carry it, or `allow` a value that is not text. Both used to fall through to
- * the allow branch — the ask filed an allow row for a rule that thought it had
- * paused, and the non-string became `content: undefined` on the wire. Same law,
- * same row: a link whose answer cannot be honoured has not permitted anything.
- *
- * **The result comes back through the onion.** `runToolAfterChain` walks the
- * SAME list in reverse, so the first-declared link gets the first word about
- * the call and the last word about the result. An outer rule is the one that
- * sees what every inner rule already did — which is the only order in which
- * "wrap" means anything.
- *
- * **A link that has no hook for a moment files no row.** It did not decide;
- * saying it allowed would be inventing a decision, and the ledger's whole
- * value is that a row means somebody looked.
- */
-import type { LLMMessage } from '../../../adapters/types.js';
-import type { MemoryIdentity } from '../../../memory/identity/types.js';
-import type { AskPayload, MessageMiddleware, MiddlewareDecision, ToolMiddleware } from './types.js';
-/** Tool args, as they travel the chain. */
-export type ToolArgs = Readonly<Record<string, unknown>>;
-/**
- * What to do when a middleware answers `ask` somewhere that cannot pause.
- *
- * `'pause'` — the caller will checkpoint (the normal dispatch path).
- * `'refuse'` — the ask is converted into a deny naming the middleware. Used
- * on the resume path (footprintjs's `PausableHandler.resume` returns void,
- * so a resumed dispatch cannot suspend a second time) and by `mcpServe`
- * (MCP is request/response — there is no pause to carry the ask).
- */
-export type AskPolicy = 'pause' | 'refuse';
-export type ToolChainResult = {
-    readonly kind: 'allow';
-    readonly args: ToolArgs;
-    readonly decisions: MiddlewareDecision[];
-} | {
-    readonly kind: 'deny';
-    readonly reason: string;
-    readonly middleware: string;
-    readonly args: ToolArgs;
-    readonly decisions: MiddlewareDecision[];
-    /**
-     * Set when the link did not deny but ASKED, and `askPolicy: 'refuse'`
-     * turned the ask into this denial — the call needed a person and there
-     * was no pause to carry the question. Absent on every link's own deny.
-     */
-    readonly refusedAsk?: true;
-} | {
-    readonly kind: 'ask';
-    readonly payload: AskPayload;
-    readonly middleware: string;
-    /** Index of the link that asked — resume continues from `index + 1`. */
-    readonly index: number;
-    /** Args as transformed up to the ask. These ride the checkpoint. */
-    readonly args: ToolArgs;
-    readonly decisions: MiddlewareDecision[];
-};
-export interface ToolChainInput {
-    readonly toolName: string;
-    /** `Tool.source` for the tool being dispatched, when it has one. */
-    readonly toolSource?: string;
-    readonly toolCallId: string;
-    readonly iteration: number;
-    readonly args: ToolArgs;
-    readonly history: readonly LLMMessage[];
-    readonly identity?: MemoryIdentity;
-    readonly signal?: AbortSignal;
-    /**
-     * Where to start walking. `0` for a fresh dispatch; `n` on resume, to
-     * continue the chain AFTER the link that asked without re-running the
-     * links whose decisions the checkpoint already carries.
-     */
-    readonly startIndex?: number;
-    readonly askPolicy?: AskPolicy;
-}
-/** Walk the tool chain. Never throws — a throwing link becomes a denial. */
-export declare function runToolChain(chain: readonly ToolMiddleware[], input: ToolChainInput): Promise<ToolChainResult>;
-export type ToolAfterChainResult = {
-    readonly kind: 'allow';
-    readonly result: unknown;
-    readonly decisions: MiddlewareDecision[];
-} | {
-    readonly kind: 'deny';
-    readonly reason: string;
-    readonly middleware: string;
-    /** The tool's REAL result. The side effect happened; the record says so. */
-    readonly result: unknown;
-    readonly decisions: MiddlewareDecision[];
-};
-export interface ToolAfterChainInput {
-    readonly toolName: string;
-    readonly toolSource?: string;
-    readonly toolCallId: string;
-    readonly iteration: number;
-    /** The args the tool ACTUALLY ran with — every before-transform applied. */
-    readonly args: ToolArgs;
-    readonly result: unknown;
-    /** `true` when the tool threw and `result` is the error's message. */
-    readonly error?: true;
-    readonly history: readonly LLMMessage[];
-    readonly identity?: MemoryIdentity;
-    readonly signal?: AbortSignal;
-}
-/**
- * Walk the chain BACKWARDS over a finished call. Never throws — a throwing
- * link becomes a denial, which at this moment means the model reads the
- * reason instead of the result.
- *
- * Only called for a call that actually executed. A call the chain denied, or
- * one still waiting on a person, has no result to decide about, and asking a
- * rule about a result that does not exist would be the same fabrication the
- * outcome union exists to prevent.
- */
-export declare function runToolAfterChain(chain: readonly ToolMiddleware[], input: ToolAfterChainInput): Promise<ToolAfterChainResult>;
-export type MessageChainResult = {
-    readonly kind: 'allow';
-    readonly content: string;
-    readonly decisions: MiddlewareDecision[];
-} | {
-    readonly kind: 'deny';
-    readonly reason: string;
-    readonly middleware: string;
-    /** Content as transformed by the links BEFORE the refusal. */
-    readonly content: string;
-    readonly decisions: MiddlewareDecision[];
-};
-export interface MessageChainInput {
-    readonly phase: 'input' | 'output';
-    readonly content: string;
-    readonly history: readonly LLMMessage[];
-    /** ReAct iteration for the ledger row. `0` at `'input'` (before iter 1). */
-    readonly iteration: number;
-    readonly identity?: MemoryIdentity;
-    readonly signal?: AbortSignal;
-}
-/** Walk the message chain. Never throws — a throwing link becomes a denial. */
-export declare function runMessageChain(chain: readonly MessageMiddleware[], input: MessageChainInput): Promise<MessageChainResult>;
-//# sourceMappingURL=runChain.d.ts.map

package/dist/types/core/agent/middleware/runChain.d.ts.map

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