agentfootprint 10.3.0 → 10.4.0

package/dist/types/semantics/coverage/timeLimitFacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeLimitFacts.d.ts","sourceRoot":"","sources":["../../../../src/semantics/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/semantics/coverage/timeLimits.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 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 (`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
+ * `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 (`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/semantics/coverage/timeLimits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeLimits.d.ts","sourceRoot":"","sources":["../../../../src/semantics/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/semantics/coverage/types.d.ts

@@ -0,0 +1,321 @@
+/**
+ * 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
+ *          (`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 '../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
+ * `lib/toolName.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/semantics/coverage/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/semantics/coverage/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAClF,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/semantics/described.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"described.d.ts","sourceRoot":"","sources":["../../../src/semantics/described.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,EAOL,KAAK,aAAa,EAEnB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EACV,0BAA0B,EAE1B,kBAAkB,EAElB,aAAa,EACd,MAAM,YAAY,CAAC;AAkHpB,gGAAgG;AAChG,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,0BAA0B,CAAC,YAAY,CAAC,CAAC,CAAC;AAEvF;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,OAAO,GAAG,kBAAkB,CAQpE;AAED,6DAA6D;AAC7D,MAAM,WAAW,iBAAiB;IAChC,0FAA0F;IAC1F,QAAQ,CAAC,UAAU,CAAC,EAAE,kBAAkB,CAAC;IACzC,qEAAqE;IACrE,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC;CAClC;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,iBAAiB,CAa/D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,0BAA0B,GAAG,aAAa,CAE/E"}

package/dist/types/semantics/envelope.d.ts

@@ -0,0 +1,196 @@
+/**
+ * semantics/envelope — minting, recognizing and projecting the semantic
+ * tool-result envelope (9.53.0).
+ *
+ * Pattern: minted by a helper, RECOGNIZED by the framework (the `absent()` /
+ *          tool-effects precedent). A return shape the framework does not
+ *          understand is a convention, and a convention cannot ride the
+ *          record, feed a UI, or be refused by a build gate.
+ * Role:    lib/ layer, pure. The dispatch loop calls `readSemantics` at the
+ *          execute boundary; `describedResult()` is what a tool author writes;
+ *          `checkSemantics` (check.ts) judges the same shapes offline.
+ * Emits:   N/A (the caller emits `agentfootprint.tools.semantics_declared`).
+ *
+ * ## Two views of one envelope — the design decision, stated
+ *
+ * The MODEL reads a compact, rendering-free projection
+ * ({@link semanticsForModel}): the data (`series`/`facts`/`edges`), the
+ * caveats that must travel with it (`grain`, `provenance`), the composed
+ * `not_covered` prose, a non-null `clarify`, and the static note. Dropped
+ * from the model's view: the `af_semantics` marker (machine-only), `render`
+ * (a UI hint — the tool never renders, and a model parroting rendering
+ * directives is noise), the three-list `coverage` detail (it rides the
+ * coverage channel and the record; the model reads the composed
+ * `not_covered` lines instead), and a `clarify: null` (a stated non-question
+ * is a fact for the record, not something the model acts on).
+ *
+ * The RECORD gets everything: the full envelope — render, coverage,
+ * marker and all — lands on the `tools.semantics_declared` event BEFORE the
+ * result ceiling is measured, so grain and provenance survive to recordings
+ * and UIs even when the content itself is refused as oversized. The
+ * `coverage` field is additionally declared through the SAME channel the
+ * `coverage()` primitive uses (`tools.coverage_declared`, tracked state, the
+ * final-answer limits block) — absorbed, never duplicated.
+ *
+ * ## One rule set for authoring and recognition
+ *
+ * The mint refuses a declaration this vocabulary cannot honor at the
+ * CALL SITE (the `absent()` law) — so a minted envelope is honest by
+ * construction: series carry their grain, data carries its provenance,
+ * counter-looking aggregations state `is_counter`. `semanticIssues()` judges
+ * the RENDERED shape — the same rules over a value somebody may have built
+ * by hand — and is what recognition and the `check:semantics` gate both
+ * stand on. Recognition is STRICT (the zero-cost guarantee): a marker-
+ * bearing value with any issue is NOT recognized — it keeps its bytes on
+ * the data path (dev-warned, and named field-by-field by the gate), because
+ * this library does not half-apply a shape it cannot fully honor.
+ *
+ * ## One authoring door, one unchanged wire
+ *
+ * `describedResult()` declares camelCase names, then `mintSemantics` applies
+ * the same rule set used to recognize stored snake_case envelopes. Validation
+ * and record reading keep one owner; old wire records never need an adapter.
+ */
+import { type DeclaredPeriod } from './coverage/period.js';
+import type { Coverage } from './coverage/types.js';
+import { type DescribedResultDeclaration, type SemanticCoverage, type ToolSemantics } from './types.js';
+/** The codes an envelope can be faulted with — shared by recognition (any
+ *  issue ⇒ not recognized) and the `check:semantics` gate (issues become
+ *  findings under these same names). */
+export type SemanticIssueCode = 'malformed-semantics' | 'series-without-grain' | 'counter-aggregation-unstated' | 'data-without-provenance';
+/** One fault, naming the field so a refusal can teach and a gate can point. */
+export interface SemanticIssue {
+    readonly code: SemanticIssueCode;
+    /** The offending / missing field, dot-pathed ('grain.is_counter'). */
+    readonly field: string;
+    readonly message: string;
+}
+/** Whole-token match against {@link COUNTER_AGGREGATION_WORDS}, singular or
+ *  plural, case-insensitive — 'sum' and 'Counts' look like counters,
+ *  'summary' does not. */
+export declare function isCounterLookingAggregation(aggregation: string): boolean;
+/**
+ * The keys a {@link SemanticClarify} has — spelled the same in declarations
+ * and recorded envelopes — tied to the type in BOTH directions.
+ */
+export declare const CLARIFY_DECLARATION_KEYS: readonly string[];
+/**
+ * The six fields whose WIRE name is snake_case — the only names a declaration
+ * door may spell differently. Everything else (`interval`, `source`,
+ * `default`, the data rows, the eight top-level fields) is one word on both
+ * sides.
+ */
+export type SpelledField = 'is_counter' | 'measured_at' | 'age_seconds' | 'source_export_date' | 'filter_note' | 'chart_hint';
+/** How one door's author spells each {@link SpelledField}. */
+export type Spelling = Readonly<Record<SpelledField, string>>;
+/** The wire's own spelling — what `semanticIssues`, recognition, the gate
+ *  speak. */
+export declare const WIRE_SPELLING: Spelling;
+/** The objects inside a declaration whose keys a door checks by name. */
+export type DeclaredObject = 'grain' | 'provenance' | 'coverage' | 'clarify' | 'render';
+/** The objects inside a declaration a door copies into their wire spelling. */
+export type RespelledObject = 'grain' | 'provenance' | 'render';
+/**
+ * How the authoring door spells its declaration and translates it to the
+ * wire. The rule set is shared with record recognition; only field spelling
+ * differs between authoring refusals and stored-record findings.
+ */
+export interface DeclarationDoor {
+    /** The helper's name, for the one refusal that names the call itself. */
+    readonly name: string;
+    /** The top-level keys a declaration may carry. */
+    readonly declarationKeys: readonly string[];
+    /** The keys that would hand-write the DERIVED `not_covered` prose list. */
+    readonly derivedKeys: readonly string[];
+    /** Each object a declaration may carry, with the keys it has in this
+     *  door's spelling — refused BEFORE anything is copied. */
+    readonly objectKeys: ReadonlyArray<readonly [field: DeclaredObject, known: readonly string[]]>;
+    /** Copy one declared object into the wire's spelling, keeping key order.
+     *  What it does with a value that is not a plain object is the door's own
+     *  call: the rule set names whatever reaches the candidate. */
+    readonly toWire: (field: RespelledObject, value: unknown) => unknown;
+    /** How this door's author spells the six snake_case wire fields. */
+    readonly spelling: Spelling;
+}
+/** Compose the `not_covered` prose lines FROM coverage — the one derivation,
+ *  used by the mint and by the drift check, so the two can never disagree. */
+export declare function composeNotCovered(coverage: SemanticCoverage): readonly string[];
+/**
+ * THE provenance rule — one present `provenance` object, in the wire's
+ * spelling, judged; every fault, each naming its field the way `s` spells it.
+ * `issuesIn` asks it for a described result, and `coverage/absent.ts` asks it
+ * for an absence's `provenance` (honesty step 7b), so the two doors cannot
+ * disagree about what a well-formed source and time is: `measured_at` and
+ * `source` required, `age_seconds` a finite number ≥ 0, `source_export_date`
+ * a non-empty string, no other key.
+ */
+export declare function provenanceIssues(provenance: unknown, s: Spelling): SemanticIssue[];
+/**
+ * Judge one RENDERED envelope shape against the whole rule set. Empty = a
+ * well-formed envelope this library can honor. Non-empty = the faults, each
+ * naming its field.
+ *
+ * Called with values that carry the marker; on anything else it reports the
+ * missing marker rather than guessing.
+ */
+export declare function semanticIssues(value: unknown): readonly SemanticIssue[];
+/**
+ * The ONE mint behind `describedResult()`. Refuses (throws, at the call site — the `absent()` law) any
+ * declaration this vocabulary cannot honor, in the door's own words; returns
+ * the rendered envelope otherwise.
+ *
+ * In order: the declaration must be an object; a hand-written `not_covered`
+ * is refused as derived; every key the declaration and its objects carry must
+ * be one the door reads (a casing slip names the spelling meant); coverage is
+ * normalized; the candidate is built in the WIRE spelling; and the whole rule
+ * set judges it, naming each field as the door's author spelled it.
+ */
+export declare function mintSemantics(decl: DescribedResultDeclaration, door: DeclarationDoor): ToolSemantics;
+/**
+ * Recognize (or decline to recognize) a value as a semantic envelope —
+ * STRICT, and the strictness is the zero-cost guarantee. Only a plain object
+ * whose `af_semantics` is exactly `true` AND that passes the whole rule set
+ * qualifies; every other value any tool has ever returned takes the path it
+ * always took, byte for byte.
+ *
+ * `undefined` means "not an envelope this library can honor" — a marker-
+ * bearing value with faults stays DATA (never half-applied); the dispatch
+ * loop dev-warns it and `check:semantics` names every fault.
+ */
+export declare function readSemantics(value: unknown): ToolSemantics | undefined;
+/**
+ * Name what is wrong with a value that CARRIES the marker but was not
+ * recognized. `undefined` for values without the marker (they are data, not
+ * near-misses) and for well-formed envelopes. Diagnosis only — never changes
+ * what any value does.
+ */
+export declare function explainSemantics(value: unknown): readonly SemanticIssue[] | undefined;
+/**
+ * The MODEL's view of one recognized envelope — compact and rendering-free.
+ *
+ * Keeps: the data (`series`/`facts`/`edges`), the caveats that must travel
+ * with it (`grain`, `provenance`), the composed `not_covered` prose, a
+ * non-null `clarify`, and the static note. Drops: the marker, `render`
+ * (UI hint), the three-list `coverage` detail (rides the coverage channel
+ * and the record), and a `clarify: null`. Shallow-copied so the history
+ * entry is not the object the tool still holds.
+ *
+ * The period is served as the tool declared it — plus, when the store did not
+ * hold all of the time the read asked about, the verdict word inside it and
+ * that word's one clause after the note (`coverage/period.ts` ·
+ * `servedPeriod`; honesty step 7b, bench round 1). A `covered` period and an
+ * envelope with none are served byte for byte as before.
+ */
+export declare function semanticsForModel(sem: ToolSemantics): Record<string, unknown>;
+/**
+ * The period a RECOGNIZED envelope declared, in the record's camelCase form
+ * (honesty step 7b) — `undefined` when it declared none. Recognition already
+ * held the period to the rule set (a fault keeps the whole envelope data), so
+ * this is a read, never a judgement.
+ */
+export declare function periodOfSemantics(sem: ToolSemantics): DeclaredPeriod | undefined;
+/** The envelope's coverage in the normalized three-list shape the coverage
+ *  machinery reads — how `readCoverageResult` absorbs a semantic envelope's
+ *  boundary into the one coverage channel. */
+export declare function coverageOfSemantics(sem: ToolSemantics): Coverage;
+//# sourceMappingURL=envelope.d.ts.map

package/dist/types/semantics/envelope.d.ts.map

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

package/dist/types/semantics/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../src/semantics/format.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAoB,eAAe,EAAE,MAAM,YAAY,CAAC;AAQpE;sEACsE;AACtE,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAiBrE"}

package/dist/types/semantics/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/semantics/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EAChB,2BAA2B,EAC3B,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,KAAK,aAAa,EAClB,KAAK,iBAAiB,GACvB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,OAAO,EACL,cAAc,EACd,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,eAAe,GACrB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEpD,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,KAAK,cAAc,EAAE,MAAM,UAAU,CAAC;AAE7F,OAAO,EACL,yBAAyB,EACzB,cAAc,EACd,gBAAgB,EAChB,cAAc,EACd,KAAK,0BAA0B,EAC/B,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,KAAK,aAAa,GACnB,MAAM,YAAY,CAAC"}

package/dist/types/semantics/projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../../../src/semantics/projection.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,gCAAgC,GAAG,mCAAmC,CAAC;IACtF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AACD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7C,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;CAC7C;AAaD;;iFAEiF;AACjF,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,OAAO,GAAG,kBAAkB,CA+I/E;AAED,sFAAsF;AACtF,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,OAAO,GACb,SAAS,eAAe,EAAE,CAc5B"}