agentfootprint 10.2.0 → 10.3.1

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

@@ -0,0 +1,137 @@
+/**
+ * toolEffects — the typed tool-effects channel (9.19.0). ONE owner of the
+ * result-envelope grammar: the two effect kinds, the outcome-status
+ * vocabulary and the envelope recognizer. (The instruction-lease carriers a
+ * granted `require-instruction` effect becomes are `injection-engine/leases.ts`.)
+ *
+ * THE LAW this module implements: *push mandatory procedure; pull optional
+ * knowledge; never let arbitrary text promote itself into control authority.*
+ * Before this channel, a tool that wanted to steer the run had exactly one
+ * medium — its result STRING — and any convention riding it ("ROUTE:billing")
+ * was arbitrary text one prompt-injection away from control authority. The
+ * envelope replaces the convention with DATA the framework validates:
+ *
+ *   • `propose-transition` — the typed replacement for string routing
+ *     markers. The GRAPH decides: an accepted proposal moves the cursor like
+ *     a declared edge (a same-batch declared edge still wins — the
+ *     `reroute_superseded` precedent), a refusal is teaching and recorded.
+ *     Proposals come from TOOLS — deterministic code the author shipped — so
+ *     they are framework-tier evidence: admitted under every posture
+ *     (`assist`/`guard`/`rails`), but always reachability-checked against
+ *     the graph's own law. An unreachable target is refused, out loud.
+ *
+ *   • `require-instruction` — pushes a REGISTERED instruction (a skill body
+ *     or a declared snippet) into the next iteration(s) per a delivery
+ *     lease. `read_skill` stays the pull door; this is the push door, and it
+ *     can only push what was registered at build — an unknown id is refused,
+ *     never improvised.
+ *
+ * Beside the effects rides an optional `status` — the outcome-status
+ * normalization: `'denied'` must never route like `'success'`, so route
+ * edges can key on MEANING (`onToolStatus`) instead of parsing prose.
+ *
+ * RECOGNITION IS STRICT, and the strictness is the zero-cost guarantee.
+ * A value is an envelope iff it is a plain object whose keys are a subset of
+ * `{ content, effects, status }`, `content` is present, `effects` is an
+ * array, and EVERY element carries one of the two known `kind`s (an empty
+ * `effects: []` needs a valid `status` to say anything at all). Everything
+ * else — every shape any tool has ever returned — takes the exact path it
+ * always took, byte for byte. The two `kind` strings are therefore RESERVED
+ * vocabulary on the tool-result wire; a recognized envelope whose fields are
+ * malformed is refused teachingly (recorded), never half-applied.
+ */
+/**
+ * The outcome words, re-exported under the names they have always had.
+ *
+ * They are DECLARED in `semantics/toolOutcome.ts` (9.34.0) — a
+ * zero-import leaf — because a skill-graph route edge keys on them
+ * (`onToolStatus`) and `InjectionContext.toolResults[].status` is typed by
+ * them. Leaving the declaration here meant the graph's own context type
+ * reached into the agent loop for one string union, which points the
+ * dependency backwards: the loop depends on the graph, never the reverse.
+ *
+ * This module remains the owner of the ENVELOPE grammar below — the two
+ * effect kinds and the recognizer. Only the vocabulary moved down; the lease
+ * carriers live with their reader, `injection-engine/leases.ts`.
+ */
+export type { ToolResultStatus } from './toolOutcome.js';
+export { TOOL_RESULT_STATUSES } from './toolOutcome.js';
+import type { ToolResultStatus } from './toolOutcome.js';
+/** A tool proposes moving the skill-graph cursor. The graph decides. */
+export interface ProposeTransitionEffect {
+    readonly kind: 'propose-transition';
+    /** The skill node to move to. Reachability-checked against the graph's
+     *  own law (`reachableSkills(cursor)`); unreachable = teaching refusal. */
+    readonly targetSkillId: string;
+    /** Why — goes on the record (`tools.effect`), never optional: a routing
+     *  proposal with no reason is exactly the arbitrary authority this
+     *  channel exists to replace. */
+    readonly reason: string;
+}
+/** How long a pushed instruction stays delivered. */
+export type InstructionDeliveryLease = 'next-call' | 'until-skill-exit';
+/** A tool pushes a registered instruction into the coming iteration(s). */
+export interface RequireInstructionEffect {
+    readonly kind: 'require-instruction';
+    /** A REGISTERED injection id (a skill or an instruction). Unknown ids are
+     *  refused teachingly — the push door serves the declared catalog only. */
+    readonly instructionId: string;
+    /** `'next-call'` — exactly the next LLM call; `'until-skill-exit'` — every
+     *  call while the tenure that granted it holds (the skill the cursor was
+     *  on when the tool returned). */
+    readonly deliveryLease: InstructionDeliveryLease;
+}
+/** The typed effects a tool result may carry. Two kinds — deliberately. */
+export type ProposedEffect = ProposeTransitionEffect | RequireInstructionEffect;
+/**
+ * What a tool handler returns to opt into the channel:
+ * `{ content, effects, status? }`. `content` is what the model reads (any
+ * value — strings pass through, objects stringify exactly as a bare return
+ * would). Returning anything else keeps today's path, byte for byte.
+ *
+ * `effects` is REQUIRED — it is the envelope marker itself. The recognizer
+ * refuses to treat a value without an `effects` array as an envelope (that
+ * strictness IS the zero-cost guarantee: `{ content, status: 'success' }`
+ * is a shape a domain object could already have), so the type says exactly
+ * what the recognizer accepts. Status-only is spelled `effects: []` — the
+ * explicit marker when only `status` matters.
+ */
+export interface ToolResultEnvelope {
+    readonly content: unknown;
+    readonly effects: readonly ProposedEffect[];
+    readonly status?: ToolResultStatus;
+}
+/** A recognized envelope, read: content unwrapped, VALID effects listed,
+ *  malformed ones named (one teaching entry per bad effect). */
+export interface ReadToolResultEnvelope {
+    readonly content: unknown;
+    readonly effects: readonly ProposedEffect[];
+    readonly status?: ToolResultStatus;
+    /** Effects that carried a known `kind` with malformed fields — refused
+     *  loudly (recorded + a teaching sentence), never half-applied. */
+    readonly malformed: ReadonlyArray<{
+        readonly kind: ProposedEffect['kind'];
+        readonly refusalReason: string;
+    }>;
+}
+/**
+ * Recognize (or decline to recognize) a tool's return value as an effects
+ * envelope. `undefined` = not an envelope: the caller keeps today's path
+ * untouched. See the module header for the exact recognition rule and why
+ * it is strict.
+ */
+export declare function readToolResultEnvelope(result: unknown): ReadToolResultEnvelope | undefined;
+/**
+ * Name the ONE near-miss a tool author is likeliest to write: a status-only
+ * envelope with the `effects` marker left off — `{ content, status: 'denied' }`.
+ * That shape is NOT an envelope (recognition demands the `effects` array;
+ * see `ToolResultEnvelope`), and it stays data byte-for-byte — but a value
+ * whose only keys are envelope keys AND whose `status` speaks the closed
+ * outcome vocabulary is far more likely a dropped `effects: []` than a
+ * coincidence, and letting it route like an undeclared result with no word
+ * of why would be accepted-and-silently-wrong. Returns the teaching sentence
+ * for the caller's dev-mode warning; `undefined` for every other value.
+ * Diagnosis only — never changes what any value does.
+ */
+export declare function explainStatusOnlyNearMiss(result: unknown): string | undefined;
+//# sourceMappingURL=toolEffects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolEffects.d.ts","sourceRoot":"","sources":["../../../src/semantics/toolEffects.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAIH;;;;;;;;;;;;;GAaG;AACH,YAAY,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAKzD,wEAAwE;AACxE,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC;+EAC2E;IAC3E,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B;;qCAEiC;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,qDAAqD;AACrD,MAAM,MAAM,wBAAwB,GAAG,WAAW,GAAG,kBAAkB,CAAC;AAExE,2EAA2E;AAC3E,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAC;IACrC;+EAC2E;IAC3E,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B;;sCAEkC;IAClC,QAAQ,CAAC,aAAa,EAAE,wBAAwB,CAAC;CAClD;AAED,2EAA2E;AAC3E,MAAM,MAAM,cAAc,GAAG,uBAAuB,GAAG,wBAAwB,CAAC;AAEhF;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,CAAC;IAC5C,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC;CACpC;AAOD;gEACgE;AAChE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,CAAC;IAC5C,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC;IACnC;uEACmE;IACnE,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;QAChC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;QACtC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;KAChC,CAAC,CAAC;CACJ;AAMD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,GAAG,sBAAsB,GAAG,SAAS,CA2F1F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAc7E"}

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

@@ -0,0 +1,40 @@
+/**
+ * toolOutcome — the normalized tool-outcome vocabulary, as a PURE leaf
+ * (9.34.0).
+ *
+ * WHY IT LIVES HERE. A skill-graph route edge can key on what a tool
+ * DECLARED happened (`onToolStatus`), so this vocabulary is part of the
+ * graph's own reading of a turn — `InjectionContext.toolResults[].status`
+ * is typed by it. It used to be declared inside `core/agent/toolEffects.ts`
+ * (today `semantics/toolEffects.ts`),
+ * which meant the graph's context type reached into the agent loop's
+ * tool-effects module for one string union: the loop's vocabulary embedded
+ * in the graph's contract, pointing the dependency the wrong way.
+ *
+ * So the words moved DOWN here — a module with zero imports that both
+ * sides read. `semantics/toolEffects.ts` re-exports them under the same
+ * names, so every existing import path is unchanged; that module remains
+ * the owner of the ENVELOPE grammar (the two effect kinds, the recognizer).
+ *
+ * Zone: a zero-import leaf the skill-graph PURE CORE may reach (`PURE_LEAVES`).
+ * Pinned by `test/injection-engine/skill-graph-fence.test.ts`.
+ */
+/**
+ * Normalized outcome of one tool call, declared by the tool itself. Seven
+ * values, deliberately closed: routing keyed on meaning needs a vocabulary
+ * both sides spell identically. A string outside this set makes the value
+ * NOT an envelope (data path, unchanged).
+ *
+ * `'absent'` is the seventh (the `absent()` primitive, from field use), and
+ * it earns its own word rather than folding into `'success'` or `'failure'`
+ * for the reason the primitive exists: *nothing found* and *could not look*
+ * must not route down the same edge. Under `'failure'` an honest empty answer
+ * sends an operator to investigate a healthy collector; under `'success'` a
+ * route that wants to escalate on "we found nothing" has nothing to key on.
+ * A tool may declare it directly (`{ content, effects: [], status:
+ * 'absent' }`); returning `absent(…)` makes the framework declare it.
+ */
+export type ToolResultStatus = 'success' | 'failure' | 'denied' | 'invalid' | 'partial' | 'pending' | 'absent';
+/** The closed set, as data — validators and docs read one list. */
+export declare const TOOL_RESULT_STATUSES: readonly ToolResultStatus[];
+//# sourceMappingURL=toolOutcome.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolOutcome.d.ts","sourceRoot":"","sources":["../../../src/semantics/toolOutcome.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,gBAAgB,GACxB,SAAS,GACT,SAAS,GACT,QAAQ,GACR,SAAS,GACT,SAAS,GACT,SAAS,GACT,QAAQ,CAAC;AAEb,mEAAmE;AACnE,eAAO,MAAM,oBAAoB,EAAE,SAAS,gBAAgB,EAQ3D,CAAC"}

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

@@ -0,0 +1,323 @@
+/**
+ * semantics/types — the semantic tool-result vocabulary, as a PURE leaf
+ * (9.53.0, the `toolOutcome.ts` precedent).
+ *
+ * WHY IT LIVES HERE. Two sides read these words and neither may own the
+ * other: the agent loop's dispatch boundary (core/agent/stages/toolCalls.ts)
+ * recognizes the envelope at run time, and the `check:semantics` build gate
+ * (semantics/check.ts) judges the same shapes with no agent anywhere in
+ * sight. Declaring the vocabulary in a leaf both sides import keeps the
+ * dependency pointing the right way — the loop and the gate depend on the
+ * words, never on each other.
+ *
+ * The one exception to "zero imports" is TYPE-ONLY and deliberate: the
+ * envelope's `coverage` field ABSORBS the existing coverage vocabulary
+ * (`CoverageItem` / `CoverageInput`, semantics/coverage/types.ts — itself a
+ * pure-data leaf) instead of duplicating it. Two spellings of "ground this
+ * result does not cover" would eventually disagree; type-only imports erase
+ * at runtime, so this module stays a runtime leaf.
+ *
+ * ## What the envelope is
+ *
+ * A tool that answers "how many IOPS did fc1/3 do last hour?" today returns
+ * prose or an ad-hoc object, and every caveat that makes the number honest —
+ * the collection interval, whether the values are counters that must not be
+ * summed, when the world was actually measured, which clusters were not
+ * collected — is re-implemented by hand inside every tool and held in place
+ * by review. Culture scales to one disciplined author; it does not scale to
+ * a hundred tools. The semantic envelope makes those caveats TYPED DATA that
+ * travel with the values, so honesty is inherited, not re-authored — and so
+ * a build gate can refuse a triage tool that forgot its own limits.
+ *
+ * It is a SIBLING recognizer beside the effects envelope and the coverage
+ * primitives — its own reserved marker (`af_semantics`, the
+ * `af_absent`/`af_coverage` family), never new keys on the effects envelope.
+ * The three compose on one result: `{ content: describedResult({…}), effects:
+ * […], status }` is a tool that returns typed data AND proposes a transition.
+ */
+import type { CoverageDeclaration, CoverageItem } from './coverage/types.js';
+import type { DeclaredPeriod, PeriodOnWire } from './coverage/period.js';
+/**
+ * The reserved key that makes a semantic envelope recognizable. Reserved
+ * vocabulary on the tool-result wire (the `af_absent` / `af_coverage`
+ * precedent): a plain object carrying `af_semantics: true` that validates
+ * cleanly is an envelope; every other value any tool has ever returned keeps
+ * its bytes.
+ */
+export declare const SEMANTICS_MARKER = "af_semantics";
+/**
+ * One measured point. `t` is the tool's own clock words (an ISO string or an
+ * epoch number — the library never reinterprets it), `entity` is what was
+ * measured, `metric` names the measurement, `value` is the reading.
+ */
+export interface SemanticSeriesPoint {
+    readonly t: string | number;
+    readonly entity: string;
+    readonly metric: string;
+    readonly value: number | string | boolean | null;
+}
+/**
+ * One row of typed facts about one entity. The columns are the tool's own —
+ * this library requires only that every row says WHAT it is about.
+ */
+export interface SemanticFact {
+    readonly entity: string;
+    readonly [field: string]: unknown;
+}
+/** One typed relationship — "this VM rides that datastore", "this zone
+ *  contains that WWPN". `kind` names the relationship in the tool's words. */
+export interface SemanticEdge {
+    readonly from: string;
+    readonly to: string;
+    readonly kind: string;
+    readonly [field: string]: unknown;
+}
+/**
+ * The grain — what one value MEANS, stated when it is not what a reader
+ * would assume. This is the field that stops a model from adding
+ * `jobs_local` to `jobs_replicated_in` and announcing a fleet size nobody
+ * has.
+ */
+export interface SemanticGrain {
+    /** The collection interval the values live on ('30m', '1h', 'daily'). */
+    readonly interval?: string;
+    /** How the values were folded ('avg', 'max', 'sum', 'count', …). */
+    readonly aggregation?: string;
+    /**
+     * Whether the values are counters. MUST be stated (true or false) whenever
+     * `aggregation` is counter-looking (see
+     * {@link COUNTER_AGGREGATION_WORDS}): summing two counters double-counts,
+     * and a reader cannot tell a counter from a gauge by looking at a number.
+     */
+    readonly is_counter?: boolean;
+    /** What was folded away ('per-port rows collapsed to per-switch'). */
+    readonly collapsed?: string;
+}
+/**
+ * Where the values came from and how old they are. `measured_at` is when the
+ * WORLD was measured — not when the tool ran; a tool that reads a nightly
+ * export and answers in 4ms is serving yesterday.
+ */
+export interface SemanticProvenance {
+    /** When the world was measured (the tool's own clock words). Required
+     *  whenever the envelope carries `series` or `facts`. */
+    readonly measured_at: string;
+    /** How stale the data was when the tool answered, in seconds. */
+    readonly age_seconds?: number;
+    /** The system of record the values were read from. Required with
+     *  `measured_at`. */
+    readonly source: string;
+    /** For file-fed collectors: the export the values rode in on. */
+    readonly source_export_date?: string;
+}
+/**
+ * The ask-vs-answer decision, as data. A tool that matched three volumes for
+ * one WWN should not pick one silently — it should hand the question and the
+ * candidates back, typed, so the loop (or a UI) can ask.
+ */
+export interface SemanticClarify {
+    readonly question: string;
+    /** The candidates the question is choosing between. May be empty — an open
+     *  question is still a question. */
+    readonly candidates: readonly unknown[];
+}
+/**
+ * Rendering HINTS — the tool never renders. A UI that understands them draws
+ * a better table; one that does not loses nothing, because everything load-
+ * bearing is in the data fields. Dropped from the model's view entirely.
+ */
+export interface SemanticRender {
+    /** The default presentation ('table', 'chart', 'prose', …). A hint. */
+    readonly default: string;
+    /** Column order for a tabular view. */
+    readonly columns?: readonly string[];
+    /** Sort hint ('avg_iops desc'). */
+    readonly sort?: string;
+    /** A note about what filtering already happened ('replicas excluded'). */
+    readonly filter_note?: string;
+    /** Chart-shape hint ('line per entity'). */
+    readonly chart_hint?: string;
+}
+/**
+ * The envelope's coverage, normalized — the SAME three-list vocabulary the
+ * `coverage()` / `absent()` primitives speak (checked / not checked / cannot
+ * cover), in the snake_case spelling every rendered tool shape uses because
+ * a model reads it more often than code does. Declared through
+ * {@link DescribedResultDeclaration.coverage} with the exact `CoverageDeclaration`
+ * input the `coverage()` primitive takes; the dispatch loop declares it
+ * through the same channel (`tools.coverage_declared`, tracked state, the
+ * final-answer limits block) — absorbed, never duplicated.
+ */
+export interface SemanticCoverage {
+    readonly checked?: readonly CoverageItem[];
+    readonly not_checked?: readonly CoverageItem[];
+    readonly cannot_cover?: readonly CoverageItem[];
+}
+/**
+ * {@link SemanticGrain}, spelled as code: `isCounter` is `is_counter` on the
+ * wire.
+ *
+ * @inline
+ */
+interface DescribedGrain {
+    /** The collection interval the values live on ('30m', '1h', 'daily'). */
+    readonly interval?: string;
+    /** How the values were folded ('avg', 'max', 'sum', 'count', …). */
+    readonly aggregation?: string;
+    /**
+     * Whether the values are counters — cumulative readings a reader must never
+     * add together. MUST be stated (true or false) whenever `aggregation` is
+     * counter-looking (see {@link COUNTER_AGGREGATION_WORDS}).
+     */
+    readonly isCounter?: boolean;
+    /** What was folded away ('per-port rows collapsed to per-switch'). */
+    readonly collapsed?: string;
+}
+/**
+ * {@link SemanticProvenance}, spelled as code: `measuredAt`, `ageSeconds` and
+ * `sourceExportDate` are `measured_at`, `age_seconds` and
+ * `source_export_date` on the wire.
+ *
+ * @inline
+ */
+interface DescribedProvenance {
+    /**
+     * When the WORLD was measured, in the tool's own clock words — never
+     * parsed. Take it from the data: the export's time for a file, the moment
+     * of the read for a live query, the newest sample for a series, and the END
+     * of the window for a value computed over one.
+     */
+    readonly measuredAt: string;
+    /** How stale the data was when the tool answered, in seconds. */
+    readonly ageSeconds?: number;
+    /** The system of record the values were read from. */
+    readonly source: string;
+    /** For file-fed collectors: the export the values rode in on. */
+    readonly sourceExportDate?: string;
+}
+/**
+ * {@link SemanticRender}, spelled as code: `filterNote` and `chartHint` are
+ * `filter_note` and `chart_hint` on the wire.
+ *
+ * @inline
+ */
+interface DescribedRender {
+    /** The default presentation ('table', 'chart', 'prose', …). A hint. */
+    readonly default: string;
+    /** Column order for a tabular view. */
+    readonly columns?: readonly string[];
+    /** Sort hint ('avg_iops desc'). */
+    readonly sort?: string;
+    /** A note about what filtering already happened ('replicas excluded'). */
+    readonly filterNote?: string;
+    /** Chart-shape hint ('line per entity'). */
+    readonly chartHint?: string;
+}
+/**
+ * What a tool author passes to `describedResult()` — the
+ * result fields in ONE spelling, camelCase, respelled to
+ * the unchanged snake_case wire ({@link ToolSemantics}).
+ *
+ * `provenance` is REQUIRED whenever `series` or `facts` is present, and the
+ * compiler says so: a number with no source and no age is refused at run time
+ * anyway, inside the tool, where the model reads the refusal. A declaration
+ * with only `edges` or only a `clarify` question needs none.
+ *
+ * At least one of `series`, `facts`, `edges` or a non-null `clarify` must be
+ * present — an envelope with no data and no question declares nothing. There
+ * is no `notCovered`: the prose list the model reads is derived from
+ * `coverage`, so the two can never disagree.
+ */
+export type DescribedResultDeclaration = {
+    /** Measured points — `{ t, entity, metric, value }`. Needs `grain`. */
+    readonly series?: readonly SemanticSeriesPoint[];
+    /** Typed rows about entities — every row names its `entity`. */
+    readonly facts?: readonly SemanticFact[];
+    /** Typed relationships — `{ from, to, kind }`. */
+    readonly edges?: readonly SemanticEdge[];
+    /** What one value MEANS. Required with `series`. */
+    readonly grain?: DescribedGrain;
+    /** Where the values came from and how old they are. Required with
+     *  `series` or `facts`. */
+    readonly provenance?: DescribedProvenance;
+    /**
+     * What the READ behind the data covered in time (honesty step 7b) — the
+     * instants it asked for (`queried`), what the store holds (`held`, or
+     * `'unknown'` said out loud) and when the read ran (`readAt`). Every value
+     * is an ISO 8601 instant with a zone; the model reads it as declared, and
+     * the results layer files its verdict.
+     */
+    readonly period?: DeclaredPeriod;
+    /** The coverage()-vocabulary declaration this result absorbs. */
+    readonly coverage?: CoverageDeclaration;
+    /** A question the result hands back instead of picking silently. `null`
+     *  states "ambiguity was considered; there is none". It does not pause the
+     *  run — the model reads it and decides what to ask. */
+    readonly clarify?: SemanticClarify | null;
+    /** Hints for a UI. The model never reads them. */
+    readonly render?: DescribedRender;
+} & ({
+    readonly provenance: DescribedProvenance;
+} | {
+    readonly series?: undefined;
+    readonly facts?: undefined;
+});
+/**
+ * The rendered semantic envelope — the exact object a tool hands back.
+ * Field names are snake_case and English on purpose (the `ToolAbsence`
+ * precedent): this value is read by a language model far more often than by
+ * code, and `af_semantics` is the only field that exists for the machine.
+ */
+export interface ToolSemantics {
+    readonly af_semantics: true;
+    readonly series?: readonly SemanticSeriesPoint[];
+    readonly facts?: readonly SemanticFact[];
+    readonly edges?: readonly SemanticEdge[];
+    readonly grain?: SemanticGrain;
+    readonly provenance?: SemanticProvenance;
+    /** What the read behind the data covered in time — honesty step 7b; minted
+     *  only by `describedResult()`. The model reads it as declared. */
+    readonly period?: PeriodOnWire;
+    readonly coverage?: SemanticCoverage;
+    /** DERIVED from `coverage` (not checked + cannot cover), one prose line
+     *  per item — never author-set, so the list and the lists cannot drift. */
+    readonly not_covered?: readonly string[];
+    readonly clarify?: SemanticClarify | null;
+    readonly render?: SemanticRender;
+    /** The static sentence. Never interpolated — see `envelope.ts`. */
+    readonly note: string;
+}
+/**
+ * The declared class of a tool's RESULTS — what kind of answer this tool
+ * gives, stated by whoever wrote it (`defineTool({ resultClass })`; the
+ * `capabilities` law: declared, never inferred). The `check:semantics` gate
+ * keys its per-class rules on it:
+ *
+ *   • `'triage'` — a verdict about health or fault. Every sample result must
+ *     declare coverage: a triage that cannot say what it did NOT check turns
+ *     "everything looks fine" into a claim about ground it never stood on.
+ *   • `'inventory'` — a population listing. Every sample result must declare
+ *     coverage ("4 of 5 clusters"), and one with `facts` but no `render`
+ *     hint is warned at.
+ *
+ * Two classes, deliberately closed: each carries a rule the gate can PROVE.
+ * A class with no rule would be dead vocabulary.
+ */
+export type ToolResultClass = 'triage' | 'inventory';
+/** The closed set, as data — validators and docs read one list. */
+export declare const RESULT_CLASSES: readonly ToolResultClass[];
+/**
+ * Aggregation words that suggest the values are counters — the words that
+ * make `grain.is_counter` REQUIRED (stated true or false). Matched as whole
+ * tokens, singular or plural, case-insensitive.
+ */
+export declare const COUNTER_AGGREGATION_WORDS: readonly string[];
+/**
+ * The static sentence every semantic envelope carries in the model's view.
+ * Never interpolated (the `ABSENCE_NOTE` law): everything else the model
+ * reads is the tool's own data, and a note that quoted any of it back would
+ * hand the evidence corpus a second copy of values it already indexes.
+ */
+export declare const SEMANTICS_NOTE: string;
+export {};
+//# sourceMappingURL=types.d.ts.map

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

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

package/dist/types/thinking/dispatch.d.ts

@@ -1,5 +1,5 @@
 /** One raw-thinking envelope for a provider choice, shared by both routing paths. */
-import type { LLMProvider, LLMResponse } from '../adapters/types.js';
+import type { LLMProvider, LLMResponse } from '../provider-contract/types.js';
 import type { ThinkingHandler } from './types.js';
 /** Plain data only; handler functions stay in the chart's build-time closure. */
 export declare function tagThinkingResponse(response: LLMResponse, answeredBy: string): LLMResponse;

package/dist/types/thinking/dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../../src/thinking/dispatch.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlD,iFAAiF;AACjF,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,GAAG,WAAW,CAO1F;AAED,6EAA6E;AAC7E,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,CAAC,CAAC,EAC/D,QAAQ,CAAC,EAAE,eAAe,GACzB,eAAe,CAoBjB;AAED,wFAAwF;AACxF,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,WAAW,EACrB,SAAS,GAAE,SAAS,WAAW,EAAO,EACtC,QAAQ,CAAC,EAAE,eAAe,GAAG,IAAI,GAChC,eAAe,GAAG,SAAS,CAgB7B"}
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../../src/thinking/dispatch.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlD,iFAAiF;AACjF,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,GAAG,WAAW,CAO1F;AAED,6EAA6E;AAC7E,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,CAAC,CAAC,EAC/D,QAAQ,CAAC,EAAE,eAAe,GACzB,eAAe,CAoBjB;AAED,wFAAwF;AACxF,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,WAAW,EACrB,SAAS,GAAE,SAAS,WAAW,EAAO,EACtC,QAAQ,CAAC,EAAE,eAAe,GAAG,IAAI,GAChC,eAAe,GAAG,SAAS,CAgB7B"}

package/dist/types/thinking/replay.d.ts

@@ -3,7 +3,7 @@
  * text, tool arguments, signatures or credentials. The concrete wire owns
  * capture and comparison; the run owns persistence and observation.
  */
-import type { LLMRequest } from '../adapters/types.js';
+import type { LLMRequest } from '../provider-contract/types.js';
 /** The order of already-stored content and its supported inert wire metadata. */
 export type ReplayPart = {
     readonly type: 'text';

package/dist/types/thinking/replay.d.ts.map

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

package/dist/types/thinking/replayHistory.d.ts

@@ -1,5 +1,5 @@
 /** Pure message matching for durable omissions; no second conversation store. */
-import type { LLMMessage } from '../adapters/types.js';
+import type { LLMMessage } from '../provider-contract/types.js';
 import type { ReplayPreparation } from './replay.js';
 /** Only an approved thinking edit, never a replacement conversation or tool result. */
 export interface ReplayRetirement {

package/dist/types/thinking/replayHistory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"replayHistory.d.ts","sourceRoot":"","sources":["../../../src/thinking/replayHistory.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIrD,uFAAuF;AACvF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,cAAc,EAAE,UAAU,CAAC,gBAAgB,CAAC,CAAC;IACtD,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC;CACxC;AAED,sEAAsE;AACtE,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,iBAAiB,GAAG,SAAS,gBAAgB,EAAE,CAiB7F;AAED,gFAAgF;AAChF,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CASpE;AAED,iFAAiF;AACjF,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,UAAU,EAAE,EAC9B,WAAW,EAAE,iBAAiB,GAC7B,SAAS,UAAU,EAAE,CAEvB;AAED,6EAA6E;AAC7E,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,SAAS,UAAU,EAAE,EAC9B,WAAW,EAAE,SAAS,gBAAgB,EAAE,GACvC,SAAS,UAAU,EAAE,CAkBvB"}
+{"version":3,"file":"replayHistory.d.ts","sourceRoot":"","sources":["../../../src/thinking/replayHistory.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIrD,uFAAuF;AACvF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,cAAc,EAAE,UAAU,CAAC,gBAAgB,CAAC,CAAC;IACtD,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC;CACxC;AAED,sEAAsE;AACtE,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,iBAAiB,GAAG,SAAS,gBAAgB,EAAE,CAiB7F;AAED,gFAAgF;AAChF,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CASpE;AAED,iFAAiF;AACjF,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,UAAU,EAAE,EAC9B,WAAW,EAAE,iBAAiB,GAC7B,SAAS,UAAU,EAAE,CAEvB;AAED,6EAA6E;AAC7E,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,SAAS,UAAU,EAAE,EAC9B,WAAW,EAAE,SAAS,gBAAgB,EAAE,GACvC,SAAS,UAAU,EAAE,CAkBvB"}

package/dist/types/thinking/thinkingHandlerFor.d.ts

@@ -9,7 +9,7 @@
  * Role:    the ONE place `Agent` and `LLMCall` resolve their handler when the
  *          builder did not set one.
  */
-import type { LLMProvider } from '../adapters/types.js';
+import type { LLMProvider } from '../provider-contract/types.js';
 import type { ThinkingHandler } from './types.js';
 /**
  * The thinking handler `provider` declares, or `undefined` when it declares

package/dist/types/thinking/thinkingHandlerFor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thinkingHandlerFor.d.ts","sourceRoot":"","sources":["../../../src/thinking/thinkingHandlerFor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,iBAAiB,CAAC,GACtD,eAAe,GAAG,SAAS,CAW7B"}
+{"version":3,"file":"thinkingHandlerFor.d.ts","sourceRoot":"","sources":["../../../src/thinking/thinkingHandlerFor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,iBAAiB,CAAC,GACtD,eAAe,GAAG,SAAS,CAW7B"}

package/dist/types/thinking/thinkingModeFor.d.ts

@@ -9,7 +9,7 @@
  * Role:    the ONE place the agent reads that declaration, so a malformed one
  *          is refused at build, by provider name, instead of meaning "no claim".
  */
-import type { LLMProvider } from '../adapters/types.js';
+import type { LLMProvider } from '../provider-contract/types.js';
 import type { ThinkingMode } from './types.js';
 /**
  * The mode `provider` declares for `model`, or `undefined` when it declares

package/dist/types/thinking/thinkingModeFor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thinkingModeFor.d.ts","sourceRoot":"","sources":["../../../src/thinking/thinkingModeFor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,cAAc,CAAC,EACpD,KAAK,EAAE,MAAM,GACZ,YAAY,GAAG,SAAS,CAiB1B"}
+{"version":3,"file":"thinkingModeFor.d.ts","sourceRoot":"","sources":["../../../src/thinking/thinkingModeFor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,cAAc,CAAC,EACpD,KAAK,EAAE,MAAM,GACZ,YAAY,GAAG,SAAS,CAiB1B"}