agentfootprint 10.3.0 → 10.3.1

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

@@ -1,56 +0,0 @@
-/**
- * moments — PUBLIC. The five places in the loop where a rule may speak.
- *
- * Pattern: Closed enumeration + a mechanical name mapping, with the mapping
- *          pinned by the compiler rather than by memory.
- * Role:    core/ layer. `LoopMoment` is the vocabulary `.act()` is keyed on
- *          and the vocabulary every ledger row now stamps itself with, so a
- *          person asking "where in the loop did this happen?" and a person
- *          asking "where in the loop can I intervene?" are reading the same
- *          five words.
- * Emits:   N/A (types + one pure function).
- *
- * ## Why the list is here and not inside `.act()`
- *
- * A bundle whose keys ARE the moments is only honest while the two sets
- * agree. Keep the list of moments in the options type and the sixth moment
- * ships with no key and nothing notices; keep it here, derive the key names
- * from it, and the day a moment is added the build fails inside `act.ts`
- * naming the key nobody wrote. That is the same trick `conformSource` plays
- * on the outside world, turned inward on ourselves.
- *
- * The mapping between the two spellings is mechanical — kebab in the record
- * (`'before-tool'`, which reads as a phase), camel in the bundle
- * (`beforeTool`, which reads as a property) — and `actKeyFor` is its runtime
- * twin, so the validator that decides which keys `.act()` accepts is
- * DERIVED from this list rather than typed out beside it.
- */
-/**
- * Every moment of one agent turn where a rule may act, in the order the loop
- * reaches them.
- *
- * ```
- * input → [ window → … LLM … → before-tool → tool → after-tool ]* → output
- * ```
- *
- * `watch` attends all five and more; `act` attends exactly these. The
- * difference is what a rule may DO there — an observer reports, a rule
- * changes what happens next.
- */
-export declare const LOOP_MOMENTS: readonly ["input", "before-tool", "after-tool", "window", "output"];
-/** One of the five moments. See {@link LOOP_MOMENTS}. */
-export type LoopMoment = (typeof LOOP_MOMENTS)[number];
-/**
- * The `.act()` key that governs a moment: the moment's name, camel-cased.
- *
- * `'before-tool'` → `beforeTool`. Purely mechanical, so there is no list of
- * pairs anywhere for the two spellings to drift apart in.
- */
-export type ActKey<M extends LoopMoment = LoopMoment> = M extends `${infer Head}-${infer Tail}` ? `${Head}${Capitalize<Tail>}` : M;
-/**
- * The runtime twin of {@link ActKey}. `.act()`'s accepted key set is built
- * from this over `LOOP_MOMENTS`, so an unknown key is refused by a rule that
- * cannot fall behind the list it is derived from.
- */
-export declare function actKeyFor(moment: LoopMoment): ActKey;
-//# sourceMappingURL=moments.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"moments.d.ts","sourceRoot":"","sources":["../../../../src/core/agent/moments.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,qEAAsE,CAAC;AAEhG,yDAAyD;AACzD,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU,IAAI,CAAC,SAAS,GAAG,MAAM,IAAI,IAAI,MAAM,IAAI,EAAE,GAC3F,GAAG,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,EAAE,GAC5B,CAAC,CAAC;AAEN;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAEpD"}

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

@@ -1,133 +0,0 @@
-/**
- * toolArgsValidation — validate LLM-produced tool args against the tool's
- * declared `inputSchema` BEFORE dispatch (backlog #9).
- *
- * Pattern: pure function module — no events, and no state beyond one compiled-
- *          regex cache (which doubles as the warn-once ledger for `pattern`s
- *          that do not compile); each dispatch boundary owns when to call it
- *          and what to do with the verdict.
- * Role:    The model writes tool args as free-form JSON; nothing guaranteed
- *          they match the schema the tool advertised. Dispatching garbage
- *          surfaced as deep tool stack traces (or worse, silent misbehavior).
- *          Validating at the boundary turns a malformed call into a
- *          MODEL-VISIBLE structured tool result, so the LLM corrects its
- *          args and retries on the next ReAct iteration.
- *
- * ── Honest-subset contract ────────────────────────────────────────────────
- * This is NOT a full JSON Schema implementation. It enforces the core that
- * tool schemas in the wild actually use, and IGNORES everything else
- * (permissive on unknown keywords — a schema using `oneOf`/`$ref` still
- * validates the supported core, never false-rejects on the rest):
- *
- *   ENFORCED: `type` (object/array/string/number/integer/boolean/null,
- *             union arrays), `required`, `properties` (recursive),
- *             `items` (single-schema, recursive), `enum` (primitives),
- *             `additionalProperties: false` when declared names are knowable,
- *             and the STRING SHAPE keywords `pattern` / `minLength` /
- *             `maxLength`. Object membership means OWN properties, not
- *             prototype lookup. An omitted `properties` map declares no names.
- *   IGNORED:  format, numeric min/max, oneOf/anyOf/allOf/not, $ref,
- *             const, dependencies, patternProperties, …
- * A malformed `properties` map or nonempty/malformed `patternProperties`
- * defers extra-key rejection: unknown name coverage cannot prove a key extra.
- * Independent required and declared-property checks still apply.
- *
- * ── Why string SHAPE joined the subset ────────────────────────────────────
- * A tool result ended with an offer ("I can also map these ids to volume
- * names"); the person answered "yes please"; the model bound that sentence as
- * the IDENTIFIER argument and dispatched. The tool's schema declared the
- * identifier's shape and this boundary did not read it, so a call that could
- * never succeed cost a round trip — and the consumer hand-rolled an
- * affirmative blocklist to do what the declaration already said. A declared
- * shape a boundary ignores is worse than no declaration: the author believes
- * it is enforced.
- *
- * `pattern` is JSON Schema's own semantics — UNANCHORED, ECMA-262, applied to
- * strings only. A regex the schema author got wrong must never take dispatch
- * with it: it is compiled once, and a compile failure degrades to no-pattern
- * plus one developer warning.
- *
- * ── Security: what an issue may echo ──────────────────────────────────────
- * `type` / `enum` / `required` / `additionalProperties` issues name the PATH,
- * the EXPECTED shape, and the TYPE of what arrived — never the supplied value.
- * Enum expectations echo SCHEMA values only (already LLM-visible in the tools
- * block).
- *
- * String-SHAPE issues are the one exception, and it is a narrow one: the
- * complaint IS the value's shape, so `expected string, got string` teaches
- * nothing and the correction cannot converge. They carry `value` — a capped
- * excerpt ({@link MAX_VALUE_CHARS}) of the offending string — plus `hint`, the
- * parameter's own `description`, which is where an author writes what the
- * identifier looks like. Neither adds exposure: the value is the model's own
- * tool-call argument, already verbatim in the history this message is appended
- * to. The OTel adapter renders `path`/`expected`/`got` only, so third-party
- * telemetry stays value-free either way.
- */
-/** When to enforce: 'enforce' rejects before dispatch (default), 'warn'
- *  emits the event but executes anyway, 'off' skips validation entirely. */
-export type ToolArgValidationMode = 'enforce' | 'warn' | 'off';
-/** Finite, value-free transport failure through the existing argument refusal owner. */
-export declare function streamedToolArgIssues(failure: NonNullable<import('../../adapters/types.js').LLMResponse['toolCalls'][number]['argumentsFailure']>): readonly ToolArgIssue[];
-/** One schema violation. `got` is a TYPE NAME (optionally with a measured
- *  length), never a value. */
-export interface ToolArgIssue {
-    /** Dot/bracket path from the args root, '' for the root itself. */
-    readonly path: string;
-    readonly expected: string;
-    readonly got: string;
-    /**
-     * A capped excerpt of the offending STRING. Present on string-shape issues
-     * (`pattern` / `minLength` / `maxLength`) and on nothing else — see the
-     * security note in this file's header for why those alone may echo.
-     */
-    readonly value?: string;
-    /**
-     * The parameter's own `description` from the schema, when it declares one.
-     * Carried on string-shape issues: the description is where an author writes
-     * what the identifier looks like, and that sentence is the correction.
-     */
-    readonly hint?: string;
-}
-export interface ToolArgValidationResult {
-    readonly ok: boolean;
-    readonly issues: readonly ToolArgIssue[];
-}
-/**
- * Validate tool-call args against the tool's `inputSchema`.
- *
- * Total function: a malformed/exotic SCHEMA never throws — anything outside
- * the honest subset is ignored, so the worst a bad schema can do is
- * under-validate (never block a legitimate call).
- */
-export declare function validateToolArgs(args: unknown, inputSchema: Readonly<Record<string, unknown>> | undefined): ToolArgValidationResult;
-/**
- * Validate ONE value against ONE property's own schema — the node rule
- * `validateToolArgs` applies below the root, and nothing above it.
- *
- * Exists for the inputs layer (`core/agent/arguments/declare.ts` ·
- * `assertAskOrAssume`): a declared `assume` value or `ask` choice is judged
- * against `inputSchema.properties[argument]` alone. Wrapping it as
- * `validateToolArgs({ [argument]: value }, inputSchema)` would enforce the
- * ROOT `required` too, and refuse a rule on `window` because the
- * declaration does not also carry `service`. Same honest subset, same total
- * function: an exotic property schema under-validates, never throws.
- *
- * @example
- * ```ts
- * validatePropertyValue('2h', { type: 'string', enum: ['1h', '2h'] }).ok; // true
- * validatePropertyValue('9h', { type: 'string', enum: ['1h', '2h'] }).ok; // false
- * ```
- */
-export declare function validatePropertyValue(value: unknown, propertySchema: Readonly<Record<string, unknown>> | undefined): ToolArgValidationResult;
-/**
- * Render the MODEL-VISIBLE tool result for a rejected call. Names paths and
- * expectations; reports received TYPES for structural issues and the capped
- * offending VALUE for string-shape ones, because a shape complaint that will
- * not say which string it is about cannot be acted on. `JSON.stringify` quotes
- * and escapes the excerpt, so a multi-line argument stays one line.
- *
- * The parameter's own `description` follows on its own line when the schema
- * declares one: that sentence is usually the whole correction.
- */
-export declare function formatToolArgIssues(toolName: string, issues: readonly ToolArgIssue[]): string;
-//# sourceMappingURL=toolArgsValidation.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"toolArgsValidation.d.ts","sourceRoot":"","sources":["../../../../src/core/agent/toolArgsValidation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AAEH;4EAC4E;AAC5E,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,MAAM,GAAG,KAAK,CAAC;AAE/D,wFAAwF;AACxF,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,WAAW,CAClB,OAAO,yBAAyB,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,kBAAkB,CAAC,CACvF,GACA,SAAS,YAAY,EAAE,CAQzB;AAED;8BAC8B;AAC9B,MAAM,WAAW,YAAY;IAC3B,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC;CAC1C;AAiRD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,OAAO,EACb,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,GACzD,uBAAuB,CAKzB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,EACd,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,GAC5D,uBAAuB,CAKzB;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,MAAM,CAgB7F"}

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

@@ -1,211 +0,0 @@
-/**
- * toolEffects — the typed tool-effects channel (9.19.0). ONE owner of the
- * result-envelope grammar: the two effect kinds, the outcome-status
- * vocabulary, the envelope recognizer, and the instruction-lease shapes.
- *
- * 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 `lib/injection-engine/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, the recognizer, the lease shapes — all of which are
- * genuinely loop-side. Only the vocabulary moved down.
- */
-export type { ToolResultStatus } from '../../lib/injection-engine/toolOutcome.js';
-export { TOOL_RESULT_STATUSES } from '../../lib/injection-engine/toolOutcome.js';
-import type { ToolResultStatus } from '../../lib/injection-engine/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;
-/**
- * The transition proposal the tool-calls stage ACCEPTED this iteration —
- * validated (graph mounted, target reachable), first-accepted-wins across
- * the batch. One-shot BY DATA, not by clearing writes: it is stamped with
- * the iteration that granted it, and the Evaluate stage honors it exactly
- * once — on the following iteration — so nothing ever has to write the key
- * back to undefined (zero-cost stays zero for agents that never see one).
- */
-export interface PendingToolTransition {
-    readonly targetSkillId: string;
-    /** The proposing tool — provenance for the record. */
-    readonly toolName: string;
-    readonly toolCallId?: string;
-    /** The effect's own declared reason. */
-    readonly reason: string;
-    /** The ReAct iteration whose batch granted it (valid for iteration + 1). */
-    readonly iteration: number;
-}
-/**
- * One granted `require-instruction` lease. Validity is COMPUTED, never
- * mutated: `'next-call'` serves exactly the Evaluate pass of
- * `iteration + 1`; `'until-skill-exit'` serves every pass while the tenant
- * that granted it (`skillId`) still holds the tenure.
- *
- * Death is PERMANENT, and the Evaluate tenure sweep is what makes it so:
- * `skillId === tenant` alone cannot tell "still holding the tenure" from
- * "re-entered the skill later" (a cyclic graph makes both real), so the
- * Evaluate stage prunes dead leases on EVERY pass — the same pass a tenure
- * ends, the leases it granted leave the record, and a cursor that comes back
- * finds nothing to resurrect. The tool-calls stage also prunes when it
- * appends a new grant (keeps mid-batch arrays tight), but the sweep is the
- * law's owner: it runs whether or not anything new was granted.
- */
-export interface InstructionLease {
-    readonly instructionId: string;
-    readonly deliveryLease: InstructionDeliveryLease;
-    /** The tenure that granted it (advanced cursor, else the activation tail);
-     *  absent when no tenant existed at grant. `'until-skill-exit'` compares
-     *  the CURRENT tenant against this — both-undefined still matches. */
-    readonly skillId?: string;
-    /** The granting tool — provenance for the record. */
-    readonly toolName: string;
-    readonly toolCallId?: string;
-    /** The ReAct iteration whose batch granted it. */
-    readonly iteration: number;
-}
-/** Who holds the tenure — the advanced cursor on graph agents, else the tail
- *  of `activatedInjectionIds` (the shipped `activeSkillId` notion the step
- *  pointer's re-key already uses). */
-export declare function tenantOf(cursor: string | undefined, activatedInjectionIds: readonly string[] | undefined): string | undefined;
-/**
- * The lease-served injection ids for ONE Evaluate pass — pure. `iteration`
- * is the pass being composed; `tenant` is who holds the tenure on it (the
- * ADVANCED cursor — a lease dies the same pass its tenure ends).
- *
- * `skillId === tenant` is a sound "tenure still holds" test ONLY because the
- * Evaluate tenure sweep (`pruneLeases`, every pass) removes a dead lease the
- * pass its tenure ends — so a cursor that re-enters the granting skill later
- * finds nothing to match, instead of resurrecting an ended grant.
- */
-export declare function activeLeaseIds(leases: readonly InstructionLease[] | undefined, iteration: number, tenant: string | undefined): readonly string[];
-/**
- * Drop leases that can never serve again. `iteration` is the CURRENT pass;
- * a `'next-call'` lease older than the previous iteration is spent, and an
- * `'until-skill-exit'` lease whose tenant is no longer current is dead.
- *
- * TWO call sites, one law. The Evaluate stage sweeps on EVERY pass (writing
- * the survivors under `nextInstructionLeases`, the cursor's alias round
- * trip) — that sweep is what makes death permanent: it records the death the
- * same pass the tenure ends, before any later pass could see the cursor
- * re-enter the granting skill and mistake re-entry for an unbroken tenure.
- * The tool-calls stage also prunes when it appends a new grant, so a
- * mid-batch array never carries spent leases into the commit.
- */
-export declare function pruneLeases(leases: readonly InstructionLease[] | undefined, iteration: number, currentTenant: string | undefined): readonly InstructionLease[];
-//# sourceMappingURL=toolEffects.d.ts.map

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

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

package/dist/types/core/askComponent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"askComponent.d.ts","sourceRoot":"","sources":["../../../src/core/askComponent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACnD;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,WAAW,CAAC;CACjC;AAED,wDAAwD;AACxD,MAAM,MAAM,yBAAyB,GAAG,OAAO,GAAG,UAAU,GAAG,gBAAgB,CAAC;AAEhF;;;;;;;;;;;GAWG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,QAAQ,CAAC,IAAI,8BAAwC;IACrD,0BAA0B;IAC1B,QAAQ,CAAC,MAAM,EAAE,yBAAyB,CAAC;IAC3C;gDAC4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,QAAQ,CAAC,GAAG,CAAC,EAAE,WAAW,CAAC;gBAEf,MAAM,EAAE,yBAAyB,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,WAAW;CAO/F;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,IAAI,YAAY,CAwC9F;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,OAAO,GAAG,YAAY,GAAG,SAAS,CAe7E"}

package/dist/types/core/humanizeLLMError.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"humanizeLLMError.d.ts","sourceRoot":"","sources":["../../../src/core/humanizeLLMError.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAUH,0EAA0E;AAC1E,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAoDrD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,KAAK,CAIhD"}

package/dist/types/core/inputRequest.d.ts

@@ -1,199 +0,0 @@
-import type { ToolAbsence } from './agent/coverage/types.js';
-import { type TimeAskMessages, type TimeFormat } from './time/ask.js';
-import type { ZoneName } from './time/zone.js';
-/** Typed missing-input values. Collection is distinct from permission or consent. */
-export type InputValue = string | number | boolean;
-export interface InputField {
-    readonly id: string;
-    readonly type: 'string' | 'number' | 'boolean';
-    readonly required?: boolean;
-    readonly description?: string;
-    readonly enum?: readonly InputValue[];
-    /**
-     * A TIME field (time design § 6.1): the library checks the answer before the
-     * app sees it. `'instant'` — an ISO 8601 date-time with its offset
-     * (`2026-10-09T08:00-07:00`); `'time-range'` — an ISO 8601 interval
-     * `from/to` of two such instants, `from` before `to`; `'zone'` — an IANA
-     * zone name. The value stays a string on the wire, so refused unless
-     * `type: 'string'`. An answer that fails the check is not taken: the resume
-     * door asks again with `refused: { answer, reason }` (the reason a catalog
-     * sentence, `defaultTimeAskMessages`) and `repeat: { count }`, and nothing
-     * runs. A choice or a supplied value that fails it is refused at definition.
-     */
-    readonly format?: TimeFormat;
-    /**
-     * One label per `enum` choice, in its order — what a person reads beside
-     * the value (`'Fri, Oct 9, 2026, 8:00 – 8:40 AM PDT'`); the value is what the
-     * answer carries. Needs `enum`.
-     */
-    readonly labels?: readonly string[];
-    /**
-     * A time field's choices are the only answers. Without it a `format` field
-     * with `enum` keeps free entry open: any answer the format check takes is
-     * taken. Needs `format` and `enum`.
-     */
-    readonly strict?: boolean;
-}
-export interface InputRequestDeclaration {
-    readonly id: string;
-    readonly question: string;
-    readonly fields: readonly InputField[];
-    /** Values the collection tool already knows; never labelled as a person's answer. */
-    readonly supplied?: Readonly<Record<string, InputValue>>;
-    /** Opaque JSON authored by the collecting tool, never editable by the reply. */
-    readonly context?: Readonly<Record<string, unknown>>;
-    /**
-     * What the tool LOOKED AT before it asked (9.114.0): the envelope `absent()`
-     * returns, when a lookup found nothing and raises this request about the
-     * miss. Recognized at raise time by the one recognizer
-     * (`agent/coverage/absent.ts` · `readAbsence`) — anything it does not read
-     * is refused, and `null` is the field omitted — and filed by the dispatch
-     * door at the raise, before the
-     * checkpoint is returned: the same `tools.absent` event and
-     * `coverageDeclared` row a RETURNED absence files
-     * (`agent/stages/toolCalls.ts` · `declareRaisedAbsence`). Data for the
-     * record, not for the ask: it never rides the awaiting-input shape or the
-     * paused call's served result, and nothing on resume reads it, so the
-     * pending question says the miss only if `question` says it in words.
-     * Under `.limitsTravelWithTheAnswer()` the final answer's limits block
-     * carries it, as it does a returned miss.
-     */
-    readonly absence?: ToolAbsence;
-    /**
-     * The previous answer to this ask was REFUSED, and why: the app
-     * validated what the person gave, turned it down, and asks again. Carried
-     * on the awaiting-input shape the person receives — the checkpoint's
-     * `pauseData`, the pause outcome, the `pause.request` event — so a UI can
-     * say "Your answer '…' was not accepted: <reason>" instead of repeating
-     * the same question in silence. The reason is the APP'S words — with one
-     * exception the app arms itself: a time field's answer the library's check
-     * refused (`InputField.format`), whose reason is a catalog sentence the app
-     * can override (`defaultTimeAskMessages`, `.time({ messages })`). `answer`
-     * is optional and judged against `fields` like any answer; `null` is the
-     * field omitted.
-     */
-    readonly refused?: InputRefusal;
-}
-/** An app's refusal of the previous answer to the same ask — see `InputRequestDeclaration.refused`. */
-export interface InputRefusal {
-    /** The refused values, field id → value, as the person gave them. */
-    readonly answer?: Readonly<Record<string, InputValue>>;
-    /** Why it was refused, in the app's own words — or, for a time field the library checked, its catalog's (non-blank, at most 4096 characters). */
-    readonly reason: string;
-}
-/**
- * The runtime's mark on a RE-ASK: the same ask (same declaration
- * `id`) raised again in the same turn after the person answered it. Facts
- * only — never a reason. Stamped by the runtime, never declarable.
- */
-export interface InputRepeat {
-    /** How many times the person has already answered this ask in this turn. */
-    readonly count: number;
-    /**
-     * The person's previous answer (the fields they supplied) as the RECORD
-     * holds it — after the tool-result rules, redaction first among them, ran
-     * on it. Absent when the record no longer holds it in that shape (a rule
-     * replaced the result, placement moved it), never reconstructed.
-     */
-    readonly previousAnswer?: Readonly<Record<string, InputValue>>;
-}
-/** The stamped request as the person, the model and the durable pause read it — never the `absence`. */
-export interface AwaitingInput extends Omit<InputRequestDeclaration, 'absence'> {
-    readonly status: 'awaiting_input';
-    /** Runtime-stamped token, distinct from the author's reusable declaration id. */
-    readonly requestId: string;
-    readonly supplied: Readonly<Record<string, InputValue>>;
-    readonly origins: Readonly<Record<string, 'declaration' | 'response'>>;
-    readonly missing: readonly string[];
-    /** Present only on a re-ask — see `InputRepeat`. */
-    readonly repeat?: InputRepeat;
-    readonly origin: {
-        readonly originalRequest: string;
-        /**
-         * The call that raised the request. For the inputs layer's own batch ask
-         * (`context.agentfootprint.ask === 'arguments'`, honesty layer 2) no single
-         * call raised it — the library asked before anything in the batch ran — so
-         * this names the batch's FIRST asked call, and `context.agentfootprint.fields`
-         * lists every call each field is for.
-         */
-        readonly toolCallId: string;
-        readonly skillId?: string;
-        readonly offeredSkillIds?: readonly string[];
-    };
-}
-export interface InputResponse {
-    readonly requestId: string;
-    readonly values: Readonly<Record<string, InputValue>>;
-}
-export interface InputCancellation {
-    readonly requestId: string;
-    readonly cancel: true;
-}
-/** The dedicated collecting tool's result; it contains inputs, not observations. */
-export interface InputResponseResult {
-    readonly status: 'input_received';
-    readonly requestId: string;
-    readonly values: Readonly<Record<string, InputValue>>;
-    readonly origins: AwaitingInput['origins'];
-    readonly context?: InputRequestDeclaration['context'];
-    readonly origin: AwaitingInput['origin'];
-}
-/** A malformed or stale data reply; no value was consumed and the ask remains live. */
-export declare class InputRequestError extends TypeError {
-    readonly code: "ERR_INPUT_REQUEST_INVALID";
-    constructor(reason: string);
-}
-/**
- * A value a typed ask can carry in a field — as a supplied value, a choice or
- * an answer: a non-blank string of at most 4096 characters, a finite number,
- * or a boolean. The one rule, shared by this module's validation and by the
- * declarations that build a typed ask (`agent/arguments/declare.ts` judges an
- * `ask` rule's choices with it at definition).
- */
-export declare function isInputFieldValue(value: unknown): value is InputValue;
-/** One validation owner, shared by the declaration and durable-pause readers. */
-export declare function validateInputDeclaration(raw: unknown): InputRequestDeclaration;
-/** Where the same ask was last answered in this turn — what the runtime knows at a re-ask. */
-export interface AnsweredAsk {
-    /** The declaration `id` that was answered. */
-    readonly id: string;
-    /** The answered request's runtime token — how its landed result is found in the record. */
-    readonly requestId: string;
-    /** How many times this ask has been answered in this turn, this answer included. */
-    readonly count: number;
-}
-/**
- * The re-ask mark for a declaration, or `undefined` when this is not a re-ask.
- * The previous answer is READ FROM THE RECORD — the
- * `input_received` result that landed for `answered.requestId`, after the
- * tool-result rules ran on it — so it is redacted exactly as the answer is.
- * Only the fields the PERSON supplied (origin `'response'`) are kept; when
- * the record holds no such result, or its values no longer satisfy the
- * fields, the mark carries the count alone.
- */
-export declare function repeatOf(declaration: InputRequestDeclaration, answered: AnsweredAsk | undefined, history: readonly {
-    readonly role: string;
-    readonly content: unknown;
-}[]): InputRepeat | undefined;
-/** Runtime-only stamping: a model cannot choose its saved skill or original request. */
-export declare function stampInputRequest(declaration: InputRequestDeclaration, requestId: string, origin: AwaitingInput['origin'], repeat?: InputRepeat): AwaitingInput;
-/** Read only an explicitly declared, well-shaped input pause; never assistant prose. */
-export declare function readAwaitingInput(pauseData: unknown): AwaitingInput | undefined;
-/**
- * What the resume door knows when it checks a time field's answer: the
- * person's zone (the run clock's, under `.time()` — it arms the DST-gap check)
- * and the app's catalog overrides (`.time({ messages })`).
- */
-export interface TimeAnswerContext {
-    readonly zone?: ZoneName;
-    readonly messages?: Partial<TimeAskMessages>;
-}
-/**
- * Accept typed fields, or explicit cancellation, without coercing free text.
- * A time field's answer (`InputField.format`) is checked here too; one the
- * check refuses comes back as the same ask with `refused` and `repeat`, its
- * field `missing` again — the door that keeps a partial answer asks again
- * without running anything.
- */
-export declare function applyInputResponse(waiting: AwaitingInput, raw: unknown, time?: TimeAnswerContext): AwaitingInput | InputCancellation;
-//# sourceMappingURL=inputRequest.d.ts.map

package/dist/types/core/inputRequest.d.ts.map

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

package/dist/types/core/outputSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"outputSchema.d.ts","sourceRoot":"","sources":["../../../src/core/outputSchema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH;;;;;;;;;GASG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC;IACnC,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,CAAC,CAAC;IACzB;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,MAAM,oBAAoB,GAAG,UAAU,GAAG,aAAa,GAAG,QAAQ,CAAC;AAEzE;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IACzC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACzD;AAED;;;;;;;GAOG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,iBAAiB,CAAC;IACjD,SAAkB,KAAK,CAAC,EAAE,OAAO,CAAC;gBAGhC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,YAAY,GAAG,iBAAiB,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAQxF;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,kBAAkB,CAAC,OAAO,CAAC,GAAG,MAAM,CAOnF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,CAAC,CAmBlF"}