agentfootprint 10.2.0 → 10.3.1

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

@@ -1,418 +0,0 @@
-/**
- * coverage/period — the ONE period shape a result declares, the ONE rule set
- * every door asks, and the ONE verdict.
- *
- * Pattern: one rule set, every door (the `items.ts` law for `short` and
- *          `kind`): the three mints — `absent()`, `coverage()`,
- *          `describedResult()` — REFUSE a malformed period at the line the
- *          author wrote, and the recognizers READ a period an envelope minted
- *          elsewhere (a Python helper, an older or newer process) without
- *          repairing it. Both ask {@link periodProblem}, so a mint and a read
- *          cannot disagree about what a well-formed period is.
- * Role:    core/ layer leaf of the result doors (honesty layer 3). Imports only
- *          `refusal.ts`, the dev-mode flag and the time layer's one instant
- *          parser (`core/time/instant.ts` · `instantOf`, lenient profile) and its
- *          person-facing renderer (`core/time/present.ts`). The results layer
- *          (`../results/subflow.ts`) files one verdict per call from
- *          {@link periodVerdict}; the limits block prints one line per
- *          declaring call from {@link periodLine}.
- * Emits:   N/A.
- *
- * ## The shape — anchored on the READ
- *
- * ```ts
- * period: {
- *   queried: { from: '2026-09-26T09:00:00Z', to: '2026-09-26T10:00:00Z' }, // what the read asked for
- *   held: { from: '2026-08-27T02:00:00Z', to: '2026-09-26T02:00:00Z' },    // what the store holds — or 'unknown'
- *   readAt: '2026-09-26T10:00:03Z',                                         // when the read ran (optional)
- * }
- * // on the wire: "period": { "queried": {…}, "held": {…} | "unknown", "read_at"? }
- * ```
- *
- * Every value is an ISO 8601 instant WITH a zone (`Z` or `±HH:MM`) — the
- * library compares instants, and an instant without a zone is ambiguous, so it
- * is refused rather than guessed. `held: 'unknown'` is the store saying out
- * loud that it cannot vouch for what it holds. Nothing here ever parses a
- * duration: the library compares instants the tool declared and never reads
- * "2h" (the inputs layer's `ToolPeriod` says which ARGUMENT set the period;
- * this shape says what the READ covered).
- *
- * ## Why not the word `window`, and why not a coverage item
- *
- * `window` names the context window (`core/agent/window/`, `.window()`). A
- * coverage item's `kind` is a closed, record-only word: it cannot hold two
- * instants to compare.
- */
-import type { BoundPresentation } from '../../time/present.js';
-import { type PeriodDiffers, type SourceClock } from '../../time/checkRecord.js';
-/**
- * The period a result declares — what its READ covered — in the camelCase
- * spelling an author writes on `absent()`, `coverage()` and
- * `describedResult()`, and the record keeps (the `coverageDeclared` row, the
- * `tools.absent` / `tools.coverage_declared` events). The wire spells it
- * snake_case (`read_at`).
- *
- * @example
- * ```ts
- * absent({
- *   what: 'failed backup runs for host-103',
- *   checked: ['every job in the 02:00 export'],
- *   period: {
- *     queried: { from: '2026-09-26T09:00:00Z', to: '2026-09-26T10:00:00Z' },
- *     held: { from: '2026-08-27T02:00:00Z', to: '2026-09-26T02:00:00Z' },
- *   },
- * });
- * ```
- */
-export interface DeclaredPeriod {
-    /** The instants of the READ that produced this result — not of "this call".
-     *  ISO 8601 instants WITH a zone; `from` is not after `to`. */
-    readonly queried: {
-        readonly from: string;
-        readonly to: string;
-    };
-    /** What the store holds at the time of the read — the same shape — or
-     *  `'unknown'`, said out loud when the tool cannot vouch for it. */
-    readonly held: {
-        readonly from: string;
-        readonly to: string;
-    } | 'unknown';
-    /** When the read ran — a cached answer is served minutes after the read it
-     *  describes. An ISO 8601 instant with a zone. */
-    readonly readAt?: string;
-}
-/**
- * {@link DeclaredPeriod} as the wire spells it — `read_at` is the one key that
- * differs. What a model reads inside `af_absent`, `af_coverage` and
- * `af_semantics`, and what a foreign minter writes (`canonical-notes.json`
- * publishes every key, {@link PERIOD_WIRE}).
- *
- * @inline
- */
-export interface PeriodOnWire {
-    readonly queried: {
-        readonly from: string;
-        readonly to: string;
-    };
-    readonly held: {
-        readonly from: string;
-        readonly to: string;
-    } | 'unknown';
-    readonly read_at?: string;
-}
-/**
- * The period's wire spelling as DATA — every reserved key and the one literal
- * (`'unknown'`) — so a tool written in another language mints it byte for
- * byte. `canonical-notes.json` publishes it, generated from this constant
- * (`scripts/gen-canonical-notes.mjs`): the JSON cannot disagree with the code.
- *
- * @example
- * ```ts
- * PERIOD_WIRE.readAt; // 'read_at' — the one key whose wire spelling differs
- * ```
- */
-export declare const PERIOD_WIRE: Readonly<{
-    /** The key a period sits under on `af_absent`, `af_coverage` and `af_semantics`. */
-    readonly key: "period";
-    readonly queried: "queried";
-    readonly held: "held";
-    readonly from: "from";
-    readonly to: "to";
-    readonly readAt: "read_at";
-    /** The literal `held` carries when the store cannot vouch for what it holds. */
-    readonly heldUnknown: "unknown";
-}>;
-/**
- * How far a result's READ covered what it asked for — one pure rule over the
- * instants the tool declared (bounds are inclusive):
- *
- * - `covered` — the store holds every instant the read asked for;
- * - `partly-held` — it holds some of them;
- * - `not-held` — it holds none of them;
- * - `unknown` — the tool said it cannot vouch for what the store holds.
- *
- * @inline
- */
-export type PeriodVerdict = 'covered' | 'partly-held' | 'not-held' | 'unknown';
-/** Which door's words a problem is named in: the author's (camelCase) or the wire's. */
-export type KeySpelling = 'camel' | 'wire';
-/** One fault in a period, naming its field the way the reader spelled it. */
-export interface PeriodProblem {
-    /** Dot-pathed, from `period` down (`period.queried.from`, `period.readAt`). */
-    readonly field: string;
-    readonly message: string;
-}
-/**
- * THE rule set: the first fault in a period, or `undefined` when it is well
- * formed — asked by every mint (which refuses it) and every recognizer (which
- * drops it from the record and serves the envelope as the tool wrote it).
- *
- * In order: a plain object; no key it does not have (a spelling slip names the
- * key meant — `read_at` at a camelCase door names `readAt`); `queried` a
- * `{ from, to }` span of instants with `from` not after `to`; `held` the
- * literal `'unknown'` or a span by the same rule; `readAt` an instant.
- *
- * @example
- * ```ts
- * periodProblem({ queried: { from: 'yesterday', to: '2026-09-26T10:00:00Z' }, held: 'unknown' }, 'camel');
- * // → { field: 'period.queried.from', message: '`period.queried.from` must be an ISO 8601 instant with a zone — …' }
- * ```
- */
-export declare function periodProblem(value: unknown, spelling: KeySpelling): PeriodProblem | undefined;
-/**
- * Mint the wire form from an author's (camelCase) declaration — THROWS a
- * refusal (`refused: …`) on the first fault, at the line the author wrote (the
- * `absent()` law). `undefined` or `null` → `undefined`: not declared. A fresh
- * object, keys in wire order; nothing of the author's is held.
- */
-export declare function mintPeriod(declared: unknown): PeriodOnWire | undefined;
-/** What a recognizer read off an envelope's `period`. */
-export interface PeriodReading {
-    /** The record's (camelCase) form — present when the envelope declared a well-formed one. */
-    readonly period?: DeclaredPeriod;
-    /** Why a declared period was NOT read — present when it was malformed. */
-    readonly problem?: PeriodProblem;
-}
-/**
- * Read a wire period off a recognized envelope — never repaired. `{}` when
- * the envelope declares none (`undefined` or `null`, a JSON producer's
- * `None`); `{ period }` in the record's camelCase form when it is well formed;
- * `{ problem }` when it is not, so the caller can drop it from the record and
- * say so — the model still reads what the tool wrote.
- */
-export declare function readPeriod(wire: unknown): PeriodReading;
-/** A declared period as detached plain data — the record's copy. */
-export declare function copyPeriod(period: DeclaredPeriod): DeclaredPeriod;
-/**
- * Say, once per tool per process and in dev mode only, that a recognized
- * envelope's `period` — or an absence's `provenance` — could not be read and
- * was left off the record. The envelope itself is still recognized and served
- * as the tool wrote it — read, never repaired (the `items.ts` ·
- * `readItemExtras` precedent).
- */
-export declare function warnDroppedDeclaration(toolName: string | undefined, declaration: 'period' | 'provenance', problem: {
-    readonly message: string;
-}): void;
-/**
- * Forget every dropped-declaration warning issued so far.
- * @internal test seam — the ledger is process-wide and warn-once.
- */
-export declare function _resetPeriodWarnings(): void;
-/**
- * How far a declared period's READ covered what it asked for — ONE pure rule
- * over the instants the tool declared; bounds are inclusive:
- *
- * ```text
- * held === 'unknown'                                  → 'unknown'
- * held.from ≤ queried.from and queried.to ≤ held.to   → 'covered'
- * queried.to < held.from or queried.from > held.to    → 'not-held'
- * otherwise                                           → 'partly-held'
- * ```
- *
- * No clock is read and no duration is parsed: the tool declared both spans.
- * Throws a `TypeError` naming the fault when handed a period that is not well
- * formed — a caller error; every period the library files was checked first.
- *
- * @example
- * ```ts
- * periodVerdict({
- *   queried: { from: '2026-09-26T09:00:00Z', to: '2026-09-26T10:00:00Z' },
- *   held: { from: '2026-08-27T02:00:00Z', to: '2026-09-26T02:00:00Z' },
- * }); // 'not-held' — the data ends at 02:00; the hour asked about is after it
- * ```
- */
-export declare function periodVerdict(period: DeclaredPeriod): PeriodVerdict;
-/**
- * The verdict a CALL gets when its result declared more than one period (a
- * `coverage()` around an `absent()`, each with its own): the LEAST held of
- * them, so a reader is never told more than the weakest declaration covers —
- * `not-held`, then `partly-held`, then `unknown`, then `covered`.
- */
-export declare function leastHeld(verdicts: readonly PeriodVerdict[]): PeriodVerdict | undefined;
-/**
- * The verdicts the MODEL is served — every verdict but `covered`, which is
- * served as nothing at all.
- *
- * @inline
- */
-export type ServedPeriodVerdict = Exclude<PeriodVerdict, 'covered'>;
-/** The key the served verdict word sits under, inside the served `period`. */
-export declare const SERVED_VERDICT_KEY = "verdict";
-/**
- * The ONE note clause per served verdict (honesty step 7b, bench round 1).
- * Static library text: no instant, no tool value, nothing interpolated — the
- * `ABSENCE_NOTE` law. Each states the CONSEQUENCE of its word in the terms the
- * notes already teach ("ground this result does NOT cover"), because the bench
- * showed a model repeating `period.queried` as the ground a result covered
- * without ever comparing it with `period.held`.
- */
-export declare const PERIOD_VERDICT_CLAUSES: Readonly<Record<ServedPeriodVerdict, string>>;
-/** A wire period as served: the tool's own keys, then the verdict word. */
-export interface ServedPeriod {
-    /** The wire period, copied, with {@link SERVED_VERDICT_KEY} last. */
-    readonly period: Readonly<Record<string, unknown>>;
-    readonly verdict: ServedPeriodVerdict;
-    /** {@link PERIOD_VERDICT_CLAUSES}`[verdict]`. */
-    readonly clause: string;
-}
-/**
- * What the model is served for one declared wire period — `undefined` when
- * there is nothing to add: no period, a period the rule set refuses (served
- * as the tool wrote it — read, never repaired), or a `covered` one.
- *
- * The verdict is {@link periodVerdict} over the instants the tool declared —
- * the one rule the record's `period` row is filed by, so the word the model
- * reads and the row the fold reads cannot disagree. Computed at the SERVE
- * door, never minted: the tool's own output keeps the bytes it declared, so a
- * helper in another language mints nothing new.
- *
- * @example
- * ```ts
- * servedPeriod({
- *   queried: { from: '2026-09-26T09:00:00Z', to: '2026-09-26T10:00:00Z' },
- *   held: { from: '2026-08-27T02:00:00Z', to: '2026-09-26T02:00:00Z' },
- * })?.period; // { queried: {…}, held: {…}, verdict: 'not-held' }
- * ```
- */
-export declare function servedPeriod(wire: unknown): ServedPeriod | undefined;
-/**
- * The inverse, for a reader of what the model was SERVED: a wire period with
- * its served verdict word removed — when that word is exactly the one
- * {@link servedPeriod} computes from the rest. Anything else (no word, a word
- * that disagrees with the instants, a period the rule set refuses) comes back
- * as the same reference, so the rule set still names it: a verdict is derived
- * by the library, never declared by a tool.
- */
-export declare function unservedPeriod(wire: unknown): unknown;
-/**
- * A served note with its period clause removed (the inverse of appending
- * {@link PERIOD_VERDICT_CLAUSES}`[verdict]`), or the note as found.
- */
-export declare function noteWithoutClause(note: unknown, verdict: ServedPeriodVerdict): unknown;
-/** A served note: the note as found, then the period clause. */
-export declare function noteWithClause(note: unknown, clause: string): string;
-/**
- * The `Period:` line the limits block prints for one declaring call — the
- * period AS THE TOOL DECLARED IT, instants verbatim (no reformatting, no zone
- * conversion, no verdict word: the answer's standing owns the verdict's
- * sentence). Static words around the tool's own values. With a
- * `presentation` (the run's clock zone, only under `.time()`), the instants
- * are rendered in that zone instead — see {@link periodLineInZone}.
- *
- * @example
- * ```ts
- * periodLine('backup_runs', {
- *   queried: { from: '2026-09-26T09:00:00Z', to: '2026-09-26T10:00:00Z' },
- *   held: { from: '2026-08-27T02:00:00Z', to: '2026-09-26T02:00:00Z' },
- * });
- * // 'backup_runs queried 2026-09-26T09:00:00Z to 2026-09-26T10:00:00Z; the store holds
- * //  2026-08-27T02:00:00Z to 2026-09-26T02:00:00Z'
- * ```
- */
-export declare function periodLine(toolName: string, period: DeclaredPeriod, presentation?: BoundPresentation): string;
-/**
- * The results layer's verdict on ONE call's period — a row on the one honesty
- * ledger (`AgentState.findingsLedger`, `kind: 'period'`), filed by the results
- * subflow at the loop head (`../results/subflow.ts`), never by the model.
- *
- * - `verdict` — {@link periodVerdict} over the period the call's result
- *   declared (the least held, when it declared more than one), or
- *   `'undeclared'`: the tool declares a `ToolPeriod` and this result said
- *   nothing about what its read covered — declared silence, recorded as
- *   silence.
- * - `argument` — the argument the tool's `ToolPeriod` names: the join key to
- *   the inputs layer's `argument` row for the same call (`period: true`), which
- *   says WHO chose the period, while this row says WHAT the read covered.
- *
- * The row references the call's coverage row by `toolCallId` and never copies
- * the instants: the declaration stays in its own key (`coverageDeclared`).
- * Readers that switch over every row kind must skip one they do not know.
- */
-export interface PeriodRow {
-    readonly kind: 'period';
-    /** `AgentState.turnNumber` when the row was filed — the conversation turn. */
-    readonly turn: number;
-    readonly toolCallId: string;
-    readonly toolName: string;
-    /** The iteration of the batch the call ran in. */
-    readonly iteration: number;
-    readonly verdict: PeriodVerdict | 'undeclared';
-    /** The argument the tool's `ToolPeriod` names — present only when it declares one. */
-    readonly argument?: string;
-    /** `period-differs-from-asked { missing, extra }` — the read differs from the asked range (or, for a window the model chose, from the person's). */
-    readonly differs?: PeriodDiffers;
-    /** `period-shifted` — the call's look-back ran as sent, `byMs` after the turn's `now`. */
-    readonly shifted?: {
-        readonly byMs: number;
-    };
-    /** `period-beyond-retention` — refused as, or read as, wholly older than the tool's source keeps. */
-    readonly beyondRetention?: true;
-    /** `partly-beyond-retention` — the read crosses the edge of what the source keeps; `verdict` decides. */
-    readonly partlyBeyondRetention?: true;
-    /**
-     * The time the source holds, when it holds none or only part of what the
-     * call asked about (`verdict` `not-held` / `partly-held`) — the `queried` and
-     * `held` spans of the declared period that verdict came from, as the tool
-     * declared them. Filed only under `.time()`, where the served time line
-     * hands the model this conclusion in the person's zone (`timeLimits.ts` ·
-     * `heldLine`) and the evidence gate spells it (`core/time/forms.ts` ·
-     * `timeFormsOf`, its `held` source): the model never converts a source's
-     * UTC instants itself.
-     */
-    readonly held?: {
-        readonly queried: {
-            readonly from: string;
-            readonly to: string;
-        };
-        readonly held: {
-            readonly from: string;
-            readonly to: string;
-        };
-    };
-}
-/** A source's held span beside what the call asked about — {@link PeriodRow}'s `held`. */
-export type HeldSpan = NonNullable<PeriodRow['held']>;
-/** Every verdict a period row may carry, in the order the fold reports them. */
-export declare const PERIOD_ROW_VERDICTS: readonly PeriodRow['verdict'][];
-/**
- * The checkpoint door's test for a `period` row (`core/runCheckpoint.ts` ·
- * `ledgerRowIsWellFormed`) — the one owner of the row's shape, so the door
- * refuses exactly what this module never files.
- */
-export declare function periodRowIsWellFormed(row: Readonly<Record<string, unknown>>): boolean;
-/**
- * The one limits line for a call whose `period` row carries a time check
- * (time design § 10.2, step T8) — `undefined` when it carries none. Static
- * words around the two ranges, rendered in the presentation zone by the time
- * layer's one renderer, HANDED in bound (`core/time/present.ts` ·
- * `bindPresentation` → `range`, to the second, the zone named — coverage never
- * imports the renderer); the raw instants stay on the row.
- *
- * @example
- * ```ts
- * periodCheckLine(row, bindPresentation({ zone: 'America/Los_Angeles' })); // core/time/present.ts
- * // 'search_logs read more than was asked — asked: 2026-10-08 00:00:00–23:59:59 America/Los_Angeles
- * //  (UTC-07:00); read: 2026-10-08 00:00:00–2026-10-09 08:40:00 America/Los_Angeles (UTC-07:00)'
- * ```
- *
- * `audience` names who reads the line: the PERSON (the limits block, the
- * default — their window is "your window") or the MODEL (the served time line,
- * `agent/arguments/serve.ts` · `timeLimitsSentence` — the same window is "the
- * person's window"). That reference differs, and a SHIFTED read: the model is
- * handed the library's conclusion ({@link shiftedConclusion}) — which part of
- * the window the result does not cover, in the person's zone, and that the
- * answer says so — not the two ranges to compare (T8 bench: after a pause the
- * two-range line did not stop "1 error in the last 30 minutes", 11/20). The
- * person's line keeps its bytes.
- */
-export declare function periodCheckLine(row: PeriodRow, presentation: BoundPresentation, audience?: 'person' | 'model'): string | undefined;
-/**
- * The `Clocks` lines (time design § 9.6, § 10.2, step T8): one per wall-clock
- * source — a dataset whose declared axis names a zone — and, when two sources
- * declare different zones, the label that they differ. Every comparison is
- * made on instants; the lines only name the clocks.
- */
-export declare function clockLines(sources: readonly SourceClock[], differ: {
-    readonly zones: readonly string[];
-} | undefined): string[];
-//# sourceMappingURL=period.d.ts.map

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

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

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

@@ -1,159 +0,0 @@
-/**
- * read — the ONE recognizer the tool-dispatch loop calls.
- *
- * Pattern: one reader, every dispatch door (the `applyResultCeiling`
- *          precedent). The batch loop and the credential/resume execute
- *          boundary both call this at the moment a handler's return lands, so
- *          a resumed call declares its coverage exactly as an inline one; the
- *          raise site (`../stages/toolCalls.ts` · `declareRaisedAbsence`)
- *          calls it on the `absence` a `requestInput` declared (9.114.0).
- * Role:    core/ layer, pure. Recognition and normalization only — the caller
- *          owns the events, the scope write and the delivered status.
- * Emits:   N/A.
- *
- * Zero-cost when unused: two `typeof` checks and a key lookup for every
- * result that is neither shape, and `undefined` back. Nothing is emitted,
- * nothing is written, and the value the model reads is the value the tool
- * returned — byte for byte.
- */
-import type { ToolResultStatus } from '../../../lib/injection-engine/toolOutcome.js';
-import { type DeclaredProvenance } from '../../../lib/semantics/described.js';
-import { type DeclaredPeriod } from './period.js';
-import type { Coverage, InProgressItem, TryInsteadTool } from './types.js';
-/** One coverage statement found in a result, before the caller stamps it with
- *  the call it came from. */
-export interface CoverageFacts {
-    readonly kind: 'absence' | 'ledger';
-    readonly coverage: Coverage;
-    /** Present for `'absence'` — what the search was for. */
-    readonly lookedFor?: string;
-    /**
-     * Present for `'absence'` when it declared a sentence (9.113.0) — trimmed,
-     * as `absent()` mints it, and never parsed for a tool name. Not a piece of
-     * coverage, so it sits beside `coverage` rather than inside it.
-     */
-    readonly tryInstead?: string;
-    /** Present for `'absence'` when it declared a typed tool (9.113.0) — a copy. */
-    readonly tryInsteadTool?: TryInsteadTool;
-    /**
-     * Present for `'absence'` when it declared where it looked and when that
-     * source was measured (honesty step 7b) — the record's camelCase form, read
-     * by the ONE provenance rule a described result is held to; a copy.
-     */
-    readonly provenance?: DeclaredProvenance;
-    /**
-     * The period the declaration's read covered (honesty step 7b) — the record's
-     * camelCase form, read by the ONE period rule (`period.ts`); a copy. Absent
-     * when none was declared, and when the envelope declared one the rule set
-     * refuses — read, never repaired: it is left off the record (dev-warned) and
-     * the model still reads what the tool wrote.
-     */
-    readonly period?: DeclaredPeriod;
-    /**
-     * Present for a `coverage()` ledger that declared a well-formed, non-empty
-     * `in_progress` — what its read found still running, its outcome not known
-     * yet (`inProgress.ts`). A malformed list is left off the record (dev-warned)
-     * and the model still reads what the tool wrote.
-     */
-    readonly inProgress?: readonly InProgressItem[];
-}
-/** What one recognized result declares. `undefined` from
- *  {@link readCoverageResult} means "neither shape": untouched path. */
-export interface CoverageReading {
-    /**
-     * The status the framework DELIVERS for this call. `'absent'` when an
-     * absence is in play — never `'failure'`, and that is the point: a status
-     * of `'failure'` would route an honest empty answer down the same edge as
-     * a broken collector, which is the exact confusion the primitive removes.
-     * Undefined for a bare ledger — a ledger says nothing about the outcome,
-     * only about its boundary.
-     */
-    readonly status?: ToolResultStatus;
-    /** In declaration order: the outer ledger first, then the absence it
-     *  wraps. Usually one entry; two only when an author bounded an absence. */
-    readonly declared: readonly CoverageFacts[];
-}
-/**
- * The value the MODEL is served for one finalized tool result: a recognized
- * envelope with `short` and `kind` removed from every coverage item. They are
- * RECORD-ONLY: the events, the tracked `coverageDeclared` rows and the answer
- * account carry them; the model's request never does, so a tool that
- * declares them costs no request byte.
- *
- * And one thing ADDED, derived from what the tool declared (honesty step 7b,
- * bench round 1): a declared `period` whose store did not hold all of the
- * time the read asked about is served with its verdict word and that word's
- * one note clause (see `withPeriodServed`). A `covered` period, a malformed
- * one and a result with none gain nothing.
- *
- * The shapes, and nesting: a bare absence; a ledger — its own lists AND
- * whatever it bounds, read by this same function (so `coverage(absent(…))`,
- * `coverage(coverage(…))` and a semantic envelope under a ledger are all
- * served stripped; the depth is whatever the author built); and a semantic
- * envelope's `coverage`.
- *
- * NOT stripped, because none is a recognized envelope OBJECT: a result
- * returned as JSON TEXT (an `mcpClient` result in its default text mode is
- * one), an `af_absent` whose `checked` is empty or missing (the recognizer
- * refuses it, so it is ordinary data — served and recorded as written), and
- * an absence buried inside a tool's own domain object or array. A key whose
- * value is `null` counts as omitted (a JSON producer's `None`), so it is
- * served as written and stamps nothing.
- *
- * Zero-cost when unused: the SAME reference back for every value that is not
- * a recognized envelope, and for every envelope whose items declare neither
- * key — so a caller that stamps `tool_end.modelResult` by reference
- * inequality stamps nothing new. A structural copy only when a key was
- * present.
- *
- * Asked at the ENTRY of `../stages/toolCalls.ts` · `afterMoment`, which every
- * dispatch path (the batch loop and the four resume doors) calls for a result
- * that ran — so every after-tool link is handed the served value, and none
- * can re-serve the fields — and by the result ceiling and the column judge at
- * both execute boundaries, which measure what the model will read.
- */
-export declare function servedToModel(value: unknown): unknown;
-/**
- * True when `modelResult` is exactly what {@link servedToModel} produced from
- * `result` — the two channels carry ONE value and differ only by the
- * record-only fields. `../stages/toolCalls.ts` · `placeResults` then gives
- * both channels the ticket, as it does when they are one reference, so a
- * declaring tool never keeps its whole payload on `tool_end.result`.
- */
-export declare function strippedOnly(result: unknown, modelResult: unknown): boolean;
-/**
- * Pure: the served form of `value`, and nothing remembered (the answer account
- * reads through this; the dispatch door asks {@link servedToModel}, which also
- * records the pair for `strippedOnly`).
- *
- * `seen` guards a ledger that bounds ITSELF (`v.result = v`, directly or
- * further down): a holder met twice is returned as found, so a pathological
- * cycle is served as written instead of overflowing the stack.
- */
-export declare function strip(value: unknown, seen?: WeakSet<object>): unknown;
-/**
- * The inverse of the serve, for a reader of what the model was served: every
- * declaring object's verdict word and period clause removed (the note swap is
- * kept — it is the absence's own static note), the rest as found. The same
- * reference back when nothing was served. Asked by the evidence projection
- * (`evidence.ts` · `absenceEvidenceProjection`): words the library derived
- * never ground an answer.
- *
- * It walks the shapes the serve writes — an object with a `period`, and a
- * ledger's `af_coverage` and `result`, to any depth — and nothing else.
- */
-export declare function withoutServedPeriod(value: unknown, seen?: WeakSet<object>): unknown;
-/**
- * Read one finalized tool result for coverage declarations — and, since
- * honesty step 7b, for the period each declaration's read covered and an
- * absence's source and time. `toolName` names the tool in the one dev
- * warning a malformed period or provenance gets (it is left off the record,
- * never repaired); the dispatch door passes it, a post-hoc reader need not.
- *
- * The two shapes compose: `coverage(absent({…}), {…})` is a search that found
- * nothing AND a boundary around the search, so both are declared and the
- * delivered status is still `'absent'` — the ledger bounds the answer, it
- * does not change what the answer was.
- */
-export declare function readCoverageResult(value: unknown, toolName?: string): CoverageReading | undefined;
-//# sourceMappingURL=read.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/coverage/read.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,EAAkB,KAAK,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAiB9F,OAAO,EAQL,KAAK,cAAc,EAEpB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAe,cAAc,EAAE,MAAM,YAAY,CAAC;AAExF;6BAC6B;AAC7B,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,QAAQ,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,yDAAyD;IACzD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,gFAAgF;IAChF,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC;IACzC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,kBAAkB,CAAC;IACzC;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;IACjC;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;CACjD;AAiCD;wEACwE;AACxE,MAAM,WAAW,eAAe;IAC9B;;;;;;;OAOG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC;IACnC;gFAC4E;IAC5E,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAC;CAC7C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CASrD;AAMD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,GAAG,OAAO,CAG3E;AAED;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,GAAE,OAAO,CAAC,MAAM,CAAiB,GAAG,OAAO,CA4BpF;AA4BD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,EACd,IAAI,GAAE,OAAO,CAAC,MAAM,CAAiB,GACpC,OAAO,CAWT;AAkBD;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CA2CjG"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"recognize.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/coverage/recognize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE7D;;;;GAIG;AACH,eAAO,MAAM,cAAc,cAAc,CAAC;AAE1C;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,GAAG,SAAS,CAMnE;AAED,yDAAyD;AACzD,eAAO,MAAM,eAAe,gBAAgB,CAAC;AAE7C;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,GAAG,SAAS,CAO5E"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"refusal.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/coverage/refusal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,cAAc,CAAC;AAE1C,2EAA2E;AAC3E,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAE9C;AAMD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAGvF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAW5F"}

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

@@ -1,63 +0,0 @@
-/**
- * coverage/timeLimitFacts — WHAT the time layer's limits lines of one turn
- * say (step T8), read from the record and not yet rendered: the clock's zone,
- * the turn's `period` rows whose result checks hold, and the wall-clock
- * sources.
- *
- * Pattern: Walker over the committed ledger; pure, no rendering.
- * Role:    the record half of `timeLimits.ts`, split out BY FILE for the one
- *          synchronous door that needs it — the Tools mount's `inputMapper`
- *          (`agent/buildAgentChart.ts` · `timeLimitsArg`), which runs before
- *          any `import()` can: it hands these facts across, and the slot's
- *          served line renders them (`arguments/serve.ts` · `timeLimitsLine`,
- *          loaded under the arm). The renderer (`core/time/present.ts`) never
- *          reaches the graph `import { Agent }` loads (the optional-family
- *          law, `test/lib/trace-toolpack/browserGraph.test.ts`).
- * Emits:   N/A.
- *
- * `undefined` exactly when `timeLimits.ts` · `renderTimeLimits` would say
- * nothing for the same audience — so the mount arg stays value-conditional:
- * a turn whose reads match what was asked crosses no key.
- *
- * @example
- * ```ts
- * timeLimitFactsOf(ledger, 1, 'model');
- * // { zone: 'America/Los_Angeles', period: [{ kind: 'period', differs: { … }, … }], sources: [] }
- * ```
- */
-import type { PeriodRow } from './period.js';
-import { type ClocksDiffer, type SourceClock } from '../../time/checkRecord.js';
-import type { ZoneName } from '../../time/zone.js';
-/** Who reads the lines: the person (the limits block) or the model (the served time line). */
-export type TimeLimitsAudience = 'person' | 'model';
-/** The unrendered limits of one turn — see the file header. */
-export interface TimeLimitFacts {
-    /** The clock's zone — every range is rendered in it. */
-    readonly zone: ZoneName;
-    /** The turn's `period` rows that carry a check line, in the order filed. */
-    readonly period: readonly PeriodRow[];
-    /** The wall-clock sources, one per tool and zone (`checkRecord.ts` · `distinctSources`). */
-    readonly sources: readonly SourceClock[];
-    /** The label that two sources declare different zones (`checkRecord.ts` · `clocksDiffer`). */
-    readonly differ?: ClocksDiffer;
-    /** The clock's zone is unknown (G15): `zone` is only the UTC spelling, and the lines say so. */
-    readonly zoneUnknown?: true;
-}
-/**
- * Whether a `period` row carries a limits line for `audience`: a read that
- * differs, a shifted look-back, or a window beyond retention (`period.ts` ·
- * `periodCheckLine` returns one exactly then) — and, for the MODEL only, a
- * source that holds none or only part of the asked time (`held`, rendered by
- * `timeLimits.ts` · `heldLine`). The person's limits block already prints that
- * span on the call's `Period:` line (`period.ts` · `periodLine`), in their
- * zone, so it gets no second line.
- */
-export declare function carriesCheckLine(row: PeriodRow, audience?: TimeLimitsAudience): boolean;
-/**
- * The turn's limits facts from the ledger. `turn` undefined reads every row
- * (a ledger that carries one turn). `undefined` when there is no clock or,
- * for this `audience`, nothing to say: the person reads every wall-clock
- * source, the model only the label that two differ.
- */
-export declare function timeLimitFactsOf(ledger: readonly unknown[] | undefined, turn: number | undefined, audience?: TimeLimitsAudience): TimeLimitFacts | undefined;
-//# sourceMappingURL=timeLimitFacts.d.ts.map