agentfootprint 10.3.0 → 10.3.1

package/dist/types/core/agent/arguments/declare.d.ts

@@ -1,321 +0,0 @@
-/**
- * arguments/declare — what a tool author declares about its arguments, and the
- * ONE rule set that judges the declaration.
- *
- * Pattern: Map. A declaration is plain data on the `Tool` (`askOrAssume`,
- *          `period`), judged by one assert at three doors: definition
- *          (`core/tools.ts` · `defineTool`), dispatch (`rulesOf`, because a
- *          Tool built by hand or served by a ToolProvider never passes through
- *          `defineTool`) and MCP ingest (`lib/mcp/toolExtras.ts` ·
- *          `readToolExtras`). A malformed declaration is refused and never
- *          repaired.
- * Role:    core/ layer leaf of the inputs layer (honesty layer 2). Imports
- *          nothing from `findings/` — the folder's one-way law.
- * Emits:   N/A.
- *
- * ## The two forms of a rule
- *
- *   - `{ assume: value }` — a value the call leaves out is FILLED BY THE
- *     LIBRARY (never by the tool) and recorded as `default`; the answer's
- *     standing then says the value was assumed.
- *   - `{ ask: question, choices? }` — a value the call leaves out is asked of
- *     the person, ONCE per batch, before anything in the batch runs, through
- *     the typed ask (`core/inputRequest.ts`); the answer is filled and
- *     recorded as `answered` (`arguments/ask.ts`). A PRESENT value runs,
- *     recorded as the model's own — unless declared sources are armed
- *     (`.inputsLayer({ argumentSources: true })`, or `.findings({ argumentSources:
- *     true })` beside the ledger): then the model says where it
- *     came from, the library checks it (`checks.ts` · `checkSource`), and a
- *     value the check does not trace is asked about too. A choice may carry
- *     phrases the author vouches for (`{ value, said }`), matched only inside
- *     a quote the model declared.
- *
- * ## The period — `ToolPeriod`
- *
- * Which argument bounds the period the answer covers, and how its values are
- * SPELLED: `lookback` (`30m`, `24h`, `7d`, `2w`), `signed-lookback` (`-24h`),
- * `iso-range` (two ISO 8601 instants joined by `..`) or `wall-range` (two wall
- * times joined by `..`, with the zone in `zoneArgument`). Declared formats,
- * never phrases. A period on an argument with no rule is refused (adopted
- * Q13): a period argument is exactly what a rule is for.
- *
- * Since the time layer's step T5a the single-argument form is SUGAR over
- * `forms` (`core/time/convert.ts` · `sugarForms`): a tool declares every shape
- * its period takes — two arguments (`bounds`), one joined string, an object, a
- * `day`, a look-back with its `units` — and the facts about its source
- * (`direction`, `retention`, `maxRange`, `granularity`, `filtersToAsked`).
- * Under `.time()` the library fills a period the model left out from the
- * turn's one window, binds a sent one to the person's window, and hands the
- * tool `ctx.time` (`core/time/bind.ts`). Without `.time()` a period is judged
- * and read exactly as before.
- */
-import { type InputValue } from '../../inputRequest.js';
-import { PERIOD_SPELLINGS, type PeriodDirection, type PeriodFacts, type PeriodForm, type PeriodSpelling } from '../../time/periodForm.js';
-import { type DurationText } from '../../time/duration.js';
-/**
- * One allowed answer to an `ask` rule: a bare value, or a value with phrases
- * the author vouches for as meaning it (`{ value: '7d', said: ['last week'] }`).
- * The phrases are matched as whole tokens, only inside a quote the model
- * declared — never scanned for in the person's words.
- */
-export type AskChoice = InputValue | {
-    readonly value: InputValue;
-    readonly said?: readonly string[];
-};
-/**
- * One argument's rule — either ask the person, or assume a declared default.
- *
- * `assume`: a value the call leaves out is filled by the library and recorded
- * as `default`. `ask`: a value the call leaves out is asked of the person once
- * per batch, before anything in the batch runs, and recorded as `answered`.
- */
-export type ArgumentRule = {
-    readonly ask: string;
-    readonly choices?: readonly AskChoice[];
-} | {
-    readonly assume: InputValue;
-};
-/** Per argument name, its rule. Arguments with no rule run free. */
-export type AskOrAssume = Readonly<Record<string, ArgumentRule>>;
-export type { PeriodSpelling, PeriodForm, PeriodFacts } from '../../time/periodForm.js';
-export { PERIOD_SPELLINGS };
-/**
- * Which arguments set the period a tool's answer covers, how their values are
- * spelled, and the facts about the source. The one period shape's TOOL half;
- * the result half (`DeclaredPeriod`: what a read queried and what the store
- * holds) belongs to the result doors.
- *
- * Two ways to name the shape, never both: today's single argument
- * (`argument` + `spelling`, or `accepts` for several spellings, and
- * `zoneArgument` beside a `wall-range`), which is sugar over the general
- * `forms` — every shape the tool accepts, in preference order.
- *
- * @example
- * ```ts
- * period: { argument: 'window', spelling: 'lookback' }  // '2h', '24h', '7d'
- * period: {
- *   forms: [{ kind: 'bounds',
- *             from: { argument: 'start_time', as: 'epoch-ms' },
- *             to:   { argument: 'end_time',   as: 'epoch-ms', edge: 'exclusive' } }],
- *   direction: 'past', retention: '30d',
- * }
- * ```
- */
-export interface ToolPeriod {
-    readonly argument?: string;
-    readonly spelling?: PeriodSpelling;
-    /** Every single-argument spelling the argument takes, in preference order. */
-    readonly accepts?: readonly PeriodSpelling[];
-    /** The argument that carries the zone of a `wall-range`. */
-    readonly zoneArgument?: string;
-    readonly forms?: readonly PeriodForm[];
-    /** A `wall` / `date` / `day` form with no zone argument reads in the app's `.time({ zone })` — explicit, never implied. */
-    readonly wallZone?: 'app';
-    /** Which side of now the source can hold; absent: not checked. */
-    readonly direction?: PeriodDirection;
-    /** The oldest data the source keeps (`30d`). */
-    readonly retention?: DurationText;
-    /** The widest window the tool accepts at once (`24h`). */
-    readonly maxRange?: DurationText;
-    /** The source's smallest step (`1m`). */
-    readonly granularity?: DurationText;
-    /** The tool reads `ctx.time.asked` and drops rows outside it. */
-    readonly filtersToAsked?: boolean;
-}
-/** The JSON Schema types a ruled argument may have — flat primitives only (v1). */
-export declare const RULED_TYPES: readonly string[];
-/** An `ask` question's bound — the typed ask's own (`core/inputRequest.ts`). */
-export declare const ASK_QUESTION_CHARS = 4096;
-/** Choices per `ask` rule. */
-export declare const MAX_CHOICES = 100;
-/** One `said` phrase's length. */
-export declare const SAID_PHRASE_CHARS = 120;
-/** `said` phrases per choice. */
-export declare const MAX_SAID_PHRASES = 16;
-/** Arguments that may carry `ask` on one tool — the typed ask's field limit. */
-export declare const MAX_ASK_ARGUMENTS = 32;
-/**
- * The ONE owner of "this argument is missing from this call": no own key, or
- * a value that is `undefined`, `null`, or a string that is empty after
- * trimming. Deterministic; never a reading of what the value means.
- *
- * @example
- * ```ts
- * isMissing({ service: 'checkout' }, 'window');      // true — no key
- * isMissing({ window: '  ' }, 'window');             // true — blank string
- * isMissing({ window: '2h' }, 'window');             // false
- * ```
- */
-export declare function isMissing(args: Readonly<Record<string, unknown>>, argument: string): boolean;
-/**
- * Whether two argument values are the same value: same JavaScript type, and
- * the same token sequence under the evidence module's normaliser
- * (`evidence/normalize.ts` · `tokenize`, `canonicalForm` — one owner of "the
- * same value", so `41,200` ≡ `41200` here exactly as at the evidence gate). A
- * value with no token after normalisation equals nothing, not even itself: it
- * cannot be checked, and "cannot be checked" is never "equal".
- */
-export declare function sameArgumentValue(a: unknown, b: unknown): boolean;
-/**
- * Whether `value` is spelled the way `spelling` declares. `lookback` is a
- * positive integer and a unit (`m`, `h`, `d`, `w`); `signed-lookback` the
- * same with a leading minus; `iso-range` two ISO 8601 instants WITH a zone,
- * joined by `..`, each a day that exists (`2026-02-30` and hour `24` are
- * refused — `Date.parse` used to roll them forward). A format check, never a
- * conversion: nothing is ever turned into a duration, and no instant is
- * compared with "now".
- */
-export declare function parsesUnderSpelling(value: unknown, spelling: PeriodSpelling): boolean;
-/**
- * Convert a period value between the two spellings the library converts —
- * `lookback` ↔ `signed-lookback`, by adding or removing the leading minus.
- * Nothing is ever turned into a duration; an `iso-range` is never converted.
- * `undefined` when the value does not parse under `from`. The one owner: the
- * batch ask's shared period field (`ask.ts` · `periodsShareField`) and the
- * declared-sources check's earlier answer in another spelling (`checks.ts` ·
- * `checkSource`, `matched: 'spelling'`) both convert through it.
- */
-export declare function convertSpelling(value: InputValue, from: PeriodSpelling, to: PeriodSpelling): InputValue | undefined;
-declare class DeclarationRefused extends Error {
-}
-/** Forms per period — a tool spells its period in a handful of shapes, never dozens. */
-export declare const MAX_PERIOD_FORMS = 8;
-/**
- * Judge a tool's `askOrAssume` and `period`, at definition — and again at
- * dispatch (`rulesOf`) and at MCP ingest, by this same function. Throws an
- * `Error` naming the tool and the argument; returns nothing on a declaration
- * this version can apply. Both absent → a no-op.
- *
- * Refused: a rule on an argument the schema does not offer, whose type is not
- * exactly one of `string`, `number`, `integer`, `boolean`, or that is a `wants`
- * argument; a rule with both forms, neither, or an unknown key; a blank or
- * over-long question; empty, over-long or repeating choices; a choice or an
- * `assume` value the property's OWN schema rejects (never the root `required`);
- * a malformed `said` phrase; more than 32 `ask` arguments; a period on an
- * argument with no rule, an unknown spelling, or a declared value not spelled
- * that way.
- *
- * @example
- * ```ts
- * assertAskOrAssume('search_logs', { window: { assume: '2h' } }, undefined, schema);  // ok
- * assertAskOrAssume('search_logs', { window: { ask: 'Which period?', choices: ['1h', '24h'] } },
- *   undefined, schema);                                                           // ok
- * assertAskOrAssume('search_logs', { window: { assume: '9h' } }, undefined, schema);  // throws
- * ```
- */
-export declare function assertAskOrAssume(toolName: string, askOrAssume: unknown, period: unknown, inputSchema: Readonly<Record<string, unknown>> | undefined, wants?: Readonly<Record<string, string>>): void;
-/** One declared choice's phrases — words the author vouches for as meaning that value. */
-export interface ChoicePhrases {
-    readonly value: InputValue;
-    readonly said: readonly string[];
-}
-/** What an `ask` rule declares, as the layer reads it. */
-export interface RuledAsk {
-    /** The author's question — the ask field's `description`. */
-    readonly question: string;
-    /** The author's choices' values, in declared order — the field's `enum`. Absent: a free field. */
-    readonly choices?: readonly InputValue[];
-    /**
-     * The choices that declare `said` phrases, in declared order — matched as
-     * whole tokens only inside a quote the model declared (`checks.ts` ·
-     * `checkSource`, `matched: 'phrase'`), never scanned for in the person's
-     * words. Absent when no choice declares any.
-     */
-    readonly phrases?: readonly ChoicePhrases[];
-}
-/** One ruled argument of a tool, as the layer reads it. */
-export interface RuledArgument {
-    readonly argument: string;
-    readonly rule: 'ask' | 'assume';
-    /** The declared default — present on an `assume` rule. */
-    readonly assume?: InputValue;
-    /** The question and the choices — present on an `ask` rule. */
-    readonly ask?: RuledAsk;
-    /** The property's JSON Schema type — one of `RULED_TYPES`, judged at definition. */
-    readonly type: 'string' | 'number' | 'integer' | 'boolean';
-    /** Set on the argument `Tool.period` names. */
-    readonly period?: true;
-}
-/** A tool's rules, read and judged. */
-export interface ToolRules {
-    readonly ruled: readonly RuledArgument[];
-    readonly period?: ToolPeriod;
-}
-/**
- * Every form a tool's period takes, the sugar read (`core/time/convert.ts` ·
- * `sugarForms`) — empty when it declares none, or names an argument and no
- * spelling.
- */
-export declare function periodFormsOf(period: ToolPeriod | undefined): readonly PeriodForm[];
-/**
- * The form a call's window is in, read off what the call GIVES — the first form given whole
- * (every argument but the zone), else the first form given in part; `undefined` when every
- * form is left out. A period's forms are alternatives, so this is the one reading of "which
- * form did the call take", asked by the inputs layer (`resolve.ts` · `windowUntakenOf`) and
- * inner dispatch (`toolDispatch.ts` · `refuseUnaccountedRuledArguments`).
- */
-export declare function sentFormOf(forms: readonly PeriodForm[], args: Readonly<Record<string, unknown>>): number | undefined;
-/**
- * The arguments of every form but `forms[taken]` that it does not also name — an
- * alternative the call did not take. Empty for a single form: one form is one window.
- */
-export declare function untakenBesides(forms: readonly PeriodForm[], taken: number): ReadonlySet<string>;
-/**
- * The form a call that leaves EVERY form out owes, by the rules: a form this turn's kept
- * answers fill whole (`answered`), else the first form the rules ASSUME whole — its default IS
- * the window — else the first form, asked by its own asks. Never every form at once: that
- * would ask the person for two windows, which the tool refuses.
- */
-export declare function owedFormOf(forms: readonly PeriodForm[], rules: ToolRules, answered: (argument: string) => boolean): number;
-/**
- * Every argument a period names — the single argument, or each form's bound,
- * object and zone arguments. What a row's `period: true` marks.
- */
-export declare function periodArgumentsOf(period: ToolPeriod | undefined): ReadonlySet<string>;
-/**
- * The ONE argument a period is known by — the single `argument`, else the
- * first form's first bound. The results layer's join key (a `period` row names
- * it, and joins the call's `argument` row by it).
- */
-export declare function periodArgumentOf(period: ToolPeriod | undefined): string | undefined;
-/** The facts a period declares about its source, only those it declares. */
-export declare function periodFactsOf(period: ToolPeriod | undefined): PeriodFacts;
-/** Why a tool's rules could not be read — the assert's own sentence. */
-export interface RulesRefused {
-    readonly refused: string;
-}
-/** The shape `rulesOf` reads — any object carrying the three declarations. */
-export interface RuledToolLike {
-    readonly schema: {
-        readonly name: string;
-        readonly inputSchema?: Readonly<Record<string, unknown>>;
-    };
-    readonly askOrAssume?: unknown;
-    readonly period?: unknown;
-    readonly wants?: Readonly<Record<string, string>>;
-}
-/**
- * A tool's rules as the inputs layer applies them, or why they cannot be read,
- * or `undefined` for a tool that declares none. Runs the SAME assert
- * `defineTool` runs, because a Tool built by hand or delivered by a
- * ToolProvider never passed through `defineTool` — and a rule that fails here
- * refuses the call; it is never repaired. Cached per tool object.
- */
-export declare function rulesOf(tool: RuledToolLike | undefined): ToolRules | RulesRefused | undefined;
-/** True when `rulesOf` could not read the rules. */
-export declare function isRefused(value: ToolRules | RulesRefused | undefined): value is RulesRefused;
-/**
- * Whether a tool's argument rules can be read and rule at least one argument
- * — the one predicate for "this tool is RULED" wherever the declared sources'
- * `_findings.from` is planted (`core/slots/buildToolsSlot.ts`, `stages/seed.ts`):
- * only such a tool's calls are checked and filed.
- */
-export declare function carriesRules(tool: RuledToolLike | undefined): boolean;
-/**
- * Forget every definition-time warning issued so far.
- * @internal test seam — the ledger is process-wide and warn-once.
- */
-export declare function _resetDeclareWarnings(): void;
-/** @internal — `DeclarationRefused` is the assert's own error class, for tests. */
-export { DeclarationRefused };
-//# sourceMappingURL=declare.d.ts.map

package/dist/types/core/agent/arguments/declare.d.ts.map

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"absent.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/coverage/absent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAOH,OAAO,KAAK,EAAE,kBAAkB,EAAE,QAAQ,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAI5F,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,CAAC;AAEvC;;;;;GAKG;AAGH,eAAO,MAAM,YAAY,sYAC4W,CAAC;AAEtY;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,QAI8C,CAAC;AAmJlF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,kBAAkB,GAAG,WAAW,CA4D5D;AAED;sDACsD;AACtD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,QAAQ,CAMhE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAE5E;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc,GAAG,SAAS,CAExF"}

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

@@ -1,198 +0,0 @@
-/**
- * answer — how a ledger survives into the final answer.
- *
- * Pattern: composed by the FRAMEWORK, not requested from the model. Pure
- *          function of the run's declarations; the stage that calls it is a
- *          two-line wrapper (see `stages/prepareFinal.ts`).
- * Role:    core/ layer, pure.
- * Emits:   N/A.
- *
- * ## Why this is an append and not a check
- *
- * A ledger the model can drop is worthless, and every mechanism that ASKS the
- * model to carry it can be dropped: a note in the tool result is advice, a
- * system-prompt rule is advice, and a judge that reads the answer back and
- * asks "did it state its limits?" needs a second model to decide what
- * counts — which would put a language judgement in the one place this library
- * refuses to put one (see `evidence/README.md`: the guard may not need a
- * bigger model than the thing it guards).
- *
- * So the limits are APPENDED. The model does not write them, so the model
- * cannot drop them, and the mechanism is a string concatenation over data the
- * tools declared — deterministic, auditable, and cheap. It changes the bytes
- * of the answer, which is why it is opt-in
- * (`.limitsTravelWithTheAnswer()`): an agent that never asks for it is
- * byte-identical.
- *
- * ## Why a TYPED answer gets the same fold as data, never the block
- *
- * An answer with an output schema is JSON, and JSON followed by prose is not
- * JSON — appending the block made `runTyped()` throw on every answer that had
- * limits. So when an output schema is configured the answer string stays the
- * model's own, and the same fold travels BESIDE it: `coverageOfAnswer` below,
- * committed as `AgentState.answerCoverage`. The model still cannot drop it —
- * the framework composes it from what the tools declared — and a person reads
- * it wherever the app draws it, not wherever the prose happened to end.
- *
- * ## Why an absence contributes too
- *
- * `absent()` and `coverage()` make the same kind of statement about the same
- * run. A search that found nothing in the fcns database really did cover the
- * fcns database, and a search that could not reach the archive really is a
- * limit on the answer. Folding both into one block is the only way the reader
- * gets ONE boundary instead of a boundary per tool — and duplicates are
- * dropped, so five tools naming the same missing collector say it once.
- */
-import { type DeclaredPeriod } from './period.js';
-import type { BoundPresentation } from '../../time/present.js';
-import type { Coverage, DeclaredCoverage, InProgressItem } from './types.js';
-/**
- * One declaring call's period, as the answer's limits carry it (honesty step
- * 7b) — the tool, the call, and the period AS DECLARED: the data twin of one
- * `Period:` line.
- *
- * @inline
- */
-export interface AnswerPeriod extends DeclaredPeriod {
-    readonly toolName: string;
-    readonly toolCallId?: string;
-}
-/**
- * One declaring call's in-progress items, as the answer's limits carry them —
- * the tool, the call, and what its read found still running, as declared: the
- * data twin of that call's lines under "In progress (outcome not known yet)".
- *
- * @inline
- */
-export interface AnswerInProgress {
-    readonly toolName: string;
-    readonly toolCallId?: string;
-    readonly items: readonly InProgressItem[];
-}
-/**
- * A TYPED answer's limits, as data — the three coverage lists the prose block
- * would print, plus the values a tool's `assume` rule filled this turn (the
- * inputs layer, honesty layer 2), which the prose answer prints as its
- * "Assumed" block. The value of `AgentState.answerCoverage`,
- * `turn_end.answerCoverage` and `agent.answerCoverage()`.
- *
- * `assumed` is the SAME reading of the SAME rows the block prints
- * (`arguments/serve.ts` · `assumedLinesFor`): one entry per distinct (tool,
- * argument, value), in the order the rows were filed, a row a before-tool
- * rewrite superseded left out. `value` is the tool's own argument view —
- * `'REDACTED'`, with `hidden: true`, when that view hides the argument.
- * Present only when a value was assumed. `periods` (honesty step 7b) is the
- * data twin of the block's `Period:` lines, present only when a call declared one.
- */
-export interface AnswerCoverage extends Coverage {
-    /** The periods the calls declared (honesty step 7b) — one per declaring
-     *  call, as declared; present only when one did. */
-    readonly periods?: readonly AnswerPeriod[];
-    /** What the calls found still running — its outcome not known yet — one
-     *  entry per declaring call, as declared; present only when one did. Never a
-     *  reason on the answer's standing: a label that travels with the limits. */
-    readonly inProgress?: readonly AnswerInProgress[];
-    readonly assumed?: readonly {
-        readonly toolName: string;
-        readonly argument: string;
-        readonly value: string;
-        readonly hidden: boolean;
-    }[];
-}
-/** One assumed value as `AnswerCoverage` carries it. */
-type AssumedValue = NonNullable<AnswerCoverage['assumed']>[number];
-/** The block's opening line. Stable — tests and readers match on it. */
-export declare const COVERAGE_BLOCK_HEADING = "Coverage of this answer";
-/**
- * The inputs layer's "Assumed" block's opening line (`arguments/serve.ts` ·
- * `assumedBlock` composes the block). Owned here, beside the limits block's
- * heading: this module's `composeAnswerWithCoverage` is the one composer of
- * the section the framework appends after an answer, and a reader of the
- * answer's text (`lib/answer-account/account.ts` · `readAnswer`) finds every
- * block of it through this one module. Stable — tests and readers match on it.
- */
-export declare const ASSUMED_BLOCK_HEADING = "Assumed (a tool's rule, not your words):";
-/** The section heading the periods print under (honesty step 7b). Stable — readers match on it. */
-export declare const PERIOD_SECTION_LABEL = "Period";
-/** The section heading the wall-clock sources print under (the time layer, step T8). Stable. */
-export declare const CLOCKS_SECTION_LABEL = "Clocks";
-/**
- * The time layer's limits lines (step T8), already composed from the record
- * (`coverage/period.ts` · `periodCheckLine`, `clockLines`): `period` — one per
- * call whose read differs from what was asked, shifted, or was older than the
- * source keeps, printed under `Period` after the declared periods; `clocks` —
- * the wall-clock sources, under `Clocks`. Passed only under `.time()`.
- */
-export interface TimeLimitLines {
-    readonly period: readonly string[];
-    readonly clocks: readonly string[];
-    /**
-     * The MODEL's audience only (`coverage/timeLimits.ts` · `heldLine`): per call
-     * whose source holds none or only part of the asked time, what it asked
-     * about and what the source holds, in the person's zone. The person's block
-     * never reads it — its `Period:` line already prints both spans.
-     */
-    readonly held?: readonly string[];
-}
-/**
- * The run's declarations folded into the ANSWER's coverage — the three lists
- * `composeAnswerWithCoverage` renders, as data.
- *
- * `.limitsTravelWithTheAnswer()` on a typed answer (`.outputSchema()`): the
- * answer string has to stay the model's JSON for `runTyped()` to parse it, so
- * the limits travel beside it instead of inside it — this value, committed as
- * `AgentState.answerCoverage`, projected onto `turn_end.answerCoverage` and
- * returned by `agent.answerCoverage()`.
- *
- * Folded by the block's own fold (`foldSections`, the one place each list is
- * merged — declaration order, duplicates dropped), so every entry is one the
- * block would print and none is added. It keeps EVERY entry: the block's cap
- * (twelve per section, then "… and N more") is a reading aid for prose, not a
- * limit on the data.
- *
- * Fresh plain objects, copied field by field (`what`, `why`, and the
- * record-only `short` / `kind` when declared), never a reference into the rows
- * it was folded from — so the value can be committed, emitted and handed to a
- * caller as detached data. `undefined` when nothing was declared: the identity
- * case, the one every run whose tools declare nothing takes.
- */
-export declare function coverageOfAnswer(declared: readonly DeclaredCoverage[]): AnswerCoverage | undefined;
-/**
- * A typed answer's limits as ONE value: the folded coverage (or three empty
- * lists) and the values assumed this turn, `assumed` present only when one
- * was. `undefined` when there is neither — the identity case, so a run whose
- * tools declared nothing and assumed nothing commits exactly the keys it
- * always did.
- */
-export declare function answerCoverageOf(folded: AnswerCoverage | undefined, assumed: readonly AssumedValue[]): AnswerCoverage | undefined;
-/** A coverage value as detached plain data — the same three lists, every item copied. */
-export declare function copyCoverage(value: Coverage): Coverage;
-/** A typed answer's limits as detached plain data — the lists and any assumed values, copied. */
-export declare function copyAnswerCoverage(value: AnswerCoverage): AnswerCoverage;
-/**
- * Fold the run's declarations into one block and append it to the answer.
- *
- * Returns the answer UNCHANGED when nothing was declared — the identity case
- * matters, because it is the one every agent that never returns a coverage
- * shape takes.
- *
- * `standing` (the answer layer, honesty layer 4, under
- * `.answerLayer({ standingLine: true })`) is the answer's standing as one
- * already-composed line (`assessment/compose.ts` · `standingLineOf`); it opens
- * the section, and while it is on the caller passes no `assumed` block — the
- * line names the assumed values itself (one composer for one fact).
- *
- * `assumed` (the inputs layer, honesty layer 2) is a second, already-composed
- * block — the values a tool's `assume` rule filled this turn
- * (`arguments/serve.ts` · `assumedBlock`) — appended after the coverage block
- * under the same separator. With neither declarations nor an assumed block the
- * answer is unchanged, byte for byte.
- *
- * `presentation` (the time layer, only under `.time()`) is the run's clock
- * zone: each `Period:` line renders its instants there, the zone named
- * (`period.ts` · `periodLine`). Absent → the lines are the declared instants
- * verbatim, as they always were.
- */
-export declare function composeAnswerWithCoverage(answer: string, declared: readonly DeclaredCoverage[], assumed?: string, standing?: string, presentation?: BoundPresentation, time?: TimeLimitLines): string;
-export {};
-//# sourceMappingURL=answer.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"answer.d.ts","sourceRoot":"","sources":["../../../../../src/core/agent/coverage/answer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAIH,OAAO,EAA0B,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAgB,gBAAgB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAG3F;;;;;;GAMG;AACH,MAAM,WAAW,YAAa,SAAQ,cAAc;IAClD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;CAC3C;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,cAAe,SAAQ,QAAQ;IAC9C;wDACoD;IACpD,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAC3C;;iFAE6E;IAC7E,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAClD,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS;QAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;KAC1B,EAAE,CAAC;CACL;AAED,wDAAwD;AACxD,KAAK,YAAY,GAAG,WAAW,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;AAiBnE,wEAAwE;AACxE,eAAO,MAAM,sBAAsB,4BAA4B,CAAC;AAEhE;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,6CAA6C,CAAC;AAiChF,mGAAmG;AACnG,eAAO,MAAM,oBAAoB,WAAW,CAAC;AAE7C,gGAAgG;AAChG,eAAO,MAAM,oBAAoB,WAAW,CAAC;AAE7C;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AA2CD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,SAAS,gBAAgB,EAAE,GACpC,cAAc,GAAG,SAAS,CAwB5B;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,cAAc,GAAG,SAAS,EAClC,OAAO,EAAE,SAAS,YAAY,EAAE,GAC/B,cAAc,GAAG,SAAS,CAI5B;AAED,yFAAyF;AACzF,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,CAMtD;AAED,iGAAiG;AACjG,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,cAAc,GAAG,cAAc,CAaxE;AAsCD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,SAAS,gBAAgB,EAAE,EACrC,OAAO,SAAK,EACZ,QAAQ,SAAK,EACb,YAAY,CAAC,EAAE,iBAAiB,EAChC,IAAI,CAAC,EAAE,cAAc,GACpB,MAAM,CAeR"}