@orkestrel/agent 0.0.38 → 0.0.40

package/dist/src/core/index.d.cts

@@ -1744,8 +1744,8 @@ export declare interface AgentResult {
     readonly usage?: TokenUsage;
     /**
      * Reports cancellation or a turn limit reached with unresolved tool intent.
-     * A reply to a turn advertising no tools is a complete answer (`false`), even if it
-     * contains calls: those calls are dropped and observed through the `deny` event.
+     * A call in a reply to a turn advertising no tools is denied like any scoped-out call and the
+     * loop runs another turn, so a run whose last allowed turn still carried a call is partial (`true`).
      */
     readonly partial: boolean;
     /**
@@ -3126,7 +3126,8 @@ export declare function collectLedgerReplies(messages: readonly Message[], reque
  * or superseded. When the whole run is superseded, its first finding reaches that final filter.
  * Different text or an undefined result replaces the earlier run, so an empty lookup leaves the
  * earlier result out of every record. A thrown lookup leaves the earlier result live. A finding
- * with no canonical identity participates in no replacement.
+ * with no canonical identity participates in no replacement. A finding a write retired is
+ * superseded once {@link mergeSupersessions} merges the write's edges into the classification.
  *
  * @param input - The messages, findings, and classification to read
  * @returns The live message ids
@@ -3169,12 +3170,13 @@ export declare function collectProjectionIds(projection: LedgerProjection): Read
 /**
  * Collects stored messages eligible to open the recall offer.
  * @remarks
- * Notes and findings without a result do not open the offer. User statements, including quiet
- * statements available through recall's word route, can open it; this helper does not filter results.
+ * Notes, findings without a result, and findings {@link collectRetiredFindings} names do not open
+ * the offer. User statements, including quiet statements available through recall's word route,
+ * can open it; this helper does not filter results.
  * @param input - The messages, findings, and classification
  * @param requests - The marked request ids
  * @param notes - The annotation ids to exclude
- * @returns User statements, lookup findings with results, marked requests, and nonblank call-free replies
+ * @returns User statements, lookup findings with results that no write superseded and no later finding replaced, marked requests, and nonblank call-free replies
  * @example
  * ```ts
  * collectRecallMessages(input, new Set(), new Set()) // eligible stored messages
@@ -3202,6 +3204,27 @@ export declare function collectRecallMessages(input: LedgerProjectionInput, requ
  */
 export declare function collectRegistry(findings: readonly LedgerLookupFinding[]): LedgerRegistry;
 
+/**
+ * Collects the findings a write superseded or a later finding of the same lookup replaced.
+ *
+ * @remarks
+ * A write supersedes the findings {@link collectWriteSupersessions} maps. A later finding of the
+ * same canonical lookup identity, as {@link identifyLookup} writes it, replaces an earlier one when
+ * its text differs or it holds no result, and a later finding with the same text replaces nothing.
+ * A finding with no canonical identity is never replaced, and a finding the messages don't hold
+ * takes no part. A supersession the judge files is not read here.
+ *
+ * @param messages - The conversation's messages, which fix each finding's position
+ * @param findings - The lookup and write findings of those messages
+ * @returns The ids of the superseded and replaced findings
+ *
+ * @example
+ * ```ts
+ * collectRetiredFindings(messages, findings) // Set { 'tool-1' } when tool-2 wrote what tool-1 read
+ * ```
+ */
+export declare function collectRetiredFindings(messages: readonly Message[], findings: readonly LedgerLookupFinding[]): ReadonlySet<string>;
+
 /**
  * Collects each assistant message that carries calls together with the tool messages that answer
  * it, then each run of tool messages that no assistant message owns.
@@ -3225,6 +3248,29 @@ export declare function collectRegistry(findings: readonly LedgerLookupFinding[]
  */
 export declare function collectToolGroups(messages: readonly Message[]): ReadonlyArray<readonly Message[]>;
 
+/**
+ * Collects each finding a write made stale, mapped to the writes that supersede it.
+ *
+ * @remarks
+ * A write is a finding with `targets`. It supersedes another finding whose names meet its targets
+ * when that finding comes before it in conversation order, or sits in its own tool group and
+ * carries no targets, because one batch dispatches its calls at once. So the later of two writes in
+ * one group supersedes the earlier, and never the reverse. A finding's names are its result's `ids`
+ * and owner ids, or, for an empty finding, the ids its string arguments name, as `extractLiterals`
+ * reads them. Names and targets compare exactly. A write never supersedes itself, a finding with
+ * empty `targets` supersedes nothing, and a finding the messages don't hold takes no part.
+ *
+ * @param messages - The conversation's messages, which fix each finding's position and tool group
+ * @param findings - The lookup and write findings of those messages
+ * @returns Each superseded finding's id, in conversation order, mapped to the ids of the writes that supersede it, in conversation order
+ *
+ * @example
+ * ```ts
+ * collectWriteSupersessions(messages, findings) // Map { 'tool-1' => ['tool-2'] } when tool-2 wrote what tool-1 read
+ * ```
+ */
+export declare function collectWriteSupersessions(messages: readonly Message[], findings: readonly LedgerLookupFinding[]): ReadonlyMap<string, readonly string[]>;
+
 /**
  * Configures one {@link ConversationInterface.compact} call — the retained-tail size, the
  * `sections` cap, or both, overridden for one fold.
@@ -3254,6 +3300,22 @@ export declare interface CompactOptions {
     readonly signal?: AbortSignal;
 }
 
+/**
+ * Computes a checksum of text: two 32-bit FNV-1a lanes over its code points, as 16 hexadecimal digits.
+ *
+ * @remarks
+ * The checksum detects an edit, can collide, and makes no security claim. Over ASCII text, the first
+ * lane is the standard 32-bit FNV-1a hash.
+ *
+ * @param text - The text to checksum
+ * @returns The 16-digit lowercase hexadecimal checksum
+ * @example
+ * ```ts
+ * computeLedgerChecksum('a') // 'e40c292ce457465e'
+ * ```
+ */
+export declare function computeLedgerChecksum(text: string): string;
+
 /**
  * Computes the completion tokens attributable to a message's thinking.
  *
@@ -5682,6 +5744,23 @@ export declare function describeSnapshotRefusal(noun: string, id: unknown, fault
 /** Matches the logprob decoding failure `invalid or duplicate top logprob token`, which the ledger holds for the ledger's life. */
 export declare const DETERMINISTIC_JUDGE_ERROR: RegExp;
 
+/**
+ * Digests tool definitions as the JSON a provider request carries them, in order.
+ *
+ * @remarks
+ * A ledger stores this digest with its gauge, so a hydrate reuses the gauge only for the same
+ * definitions: an added, removed, reordered, or edited definition changes the digest. The digest is
+ * a {@link computeLedgerChecksum} checksum and makes no security claim.
+ *
+ * @param definitions - The tool definitions, as a tool manager's `definitions` method returns them
+ * @returns The 16-digit hexadecimal digest, or undefined when JSON cannot render the definitions
+ * @example
+ * ```ts
+ * digestLedgerTools([{ name: 'lookup_order', description: 'Read an order by its id.' }]) // '1eff754a69b7128c'
+ * ```
+ */
+export declare function digestLedgerTools(definitions: readonly ToolDefinition[]): string | undefined;
+
 /**
  * Digests held messages, lookup call context, stored copies, and sentence receipts using canonical text.
  * This non-cryptographic checksum detects host edits and makes no security claim.
@@ -6830,8 +6909,8 @@ export declare function isLedgerQuestion(value: unknown): value is LedgerQuestio
  * `conversation` must pass `isConversationSnapshot`, and `requests`, `notes`, and `failures` must be
  * dense arrays of strings. Each request and note id must name a `user` message of
  * `conversation.messages` and each failure id a `tool` message, so an id only a section original
- * holds is refused. A `gauge`, when present, must hold a finite `scale` greater than 0 and a finite
- * `overhead` of at least 0. The guard is exact: an unknown member and an own `undefined` `gauge` return
+ * holds is refused. A `gauge`, when present, must hold a finite `scale` greater than 0, a finite
+ * `overhead` of at least 0, and a string `digest`. The guard is exact: an unknown member and an own `undefined` `gauge` return
  * false, at the snapshot and in its `gauge`. Unreadable members and untrusted inputs return false. The
  * guard is structural: it admits a conversation holding a stored `system` role
  * or a repeated id, which `requireConversationSnapshot` and the `Conversation` constructor then
@@ -7641,6 +7720,7 @@ export declare class Ledger implements LedgerInterface {
      * @param provider - The provider that serves the conversation
      * @param options - The filing policy, capacity, and request bounds
      * @throws {LedgerError} Thrown when a threshold, share, capacity, limit, topic, lookup, or gauge is invalid
+     * @throws {LedgerError} Thrown when a write lacks the `consequential` annotation, writes come without `agent.authority`, or a write is named `recall` or shares a lookup's or another write's name (code `'WRITE'`)
      * @throws {LedgerError} Thrown when `predict` is not a nonnegative safe integer less than `capacity` (code `'CAPACITY'`)
      * @throws {LedgerError} Thrown when `questions` fails `isLedgerQuestion` (code `'QUESTION'`)
      * @throws {LedgerError} Thrown when `snapshot` is malformed or marks an id its conversation does not hold (code `'SNAPSHOT'`, its faults under `context.faults`)
@@ -7678,6 +7758,7 @@ export declare class Ledger implements LedgerInterface {
     snapshot(): LedgerSnapshot;
     /**
      * Appends a request and serves it, recovering an unfinished or rejected first pass with one answer pass.
+     * In either pass, a call the model makes in a turn that advertises no tools runs nothing and ends the pass after that generation, whatever the agent's `limit`, and when every call of that turn failed, the ledger stores the reply without its calls: a reply with text ends the pass complete, and one without text ends it partial with empty content.
      * A calibration call that reports no prompt usage, or a prompt usage of 0 or less, rejects with `LedgerError` code `'GAUGE'`; a provider error during calibration rejects with that error.
      * When the answer pass rejects, `respond` rejects with that error, and under the default `strict` a judge failure or another selection failure rejects it too. A rejection belongs to its own call: the ledger stays free, and the next call asks the judge again about whatever is still unanswered.
      * @param content - The request text
@@ -7764,9 +7845,18 @@ export declare const LEDGER_WORD: RegExp;
  * that `respond` call after the `fault` event, and the next call asks the judge again about whatever is
  * still unanswered. With `strict: false` the request goes on with that question undecided, or from the
  * conversation's `view()`. A provider failure in the first pass is the one
- * failure the answer pass recovers under either value.
- */
-export declare type LedgerAgentOptions = Pick<AgentOptions, 'limit' | 'timeout' | 'on' | 'scheduler' | 'instructions' | 'skills' | 'memos' | 'workspaces' | 'strict'>;
+ * failure the answer pass recovers under either value. `authority` gates every lookup and write:
+ * the ledger passes its agent one authority that denies a name the ledger doesn't advertise, allows
+ * `recall`, and hands every other call to this authority's `evaluate`, and every asked call to its
+ * `ask`. Without it, the ledger allows each lookup and holds no approver, so a `consequential`
+ * lookup is denied as unanswered at every call. In one request, the ledger denies the identical
+ * retry in a later turn of a lookup or write call the authority denied, declined, or left
+ * unanswered as a repeat, before its `evaluate` method and with no ask, and its `ask` refuses the
+ * identical twin in the same batch of a declined or unanswered ask without calling this authority's
+ * `ask`, so a person is asked about such a call once per request. The agent still reports that
+ * twin's `ask` event.
+ */
+export declare type LedgerAgentOptions = Pick<AgentOptions, 'limit' | 'timeout' | 'on' | 'scheduler' | 'instructions' | 'skills' | 'memos' | 'workspaces' | 'strict' | 'authority'>;
 
 /** Identifies an accepted direct message amendment whose sentence scope remains unresolved. */
 export declare interface LedgerAmendment {
@@ -7836,7 +7926,7 @@ export declare type LedgerEntityHandler = (text: string, partial: boolean) => Re
  * carrying the machine-readable `code`.
  *
  * @remarks
- * A threshold, share, capacity, limit, topic, lookup, question, or gauge outside its bounds is a
+ * A threshold, share, capacity, limit, topic, lookup, write, question, or gauge outside its bounds is a
  * programmer error and throws this with the matching {@link LedgerErrorCode}. A calibration call that reports
  * no prompt usage throws this with `'GAUGE'`. A snapshot option that `isLedgerSnapshot` refuses
  * throws this with `'SNAPSHOT'`, its `context` holding the `faults`. Narrow a caught value with {@link isLedgerError} and
@@ -7882,7 +7972,9 @@ export declare type LedgerErrorCode =
 /** Reports a snapshot that is malformed or that marks an id its conversation does not hold. */
 | 'SNAPSHOT'
 /** Reports filing wording that `isLedgerQuestion` refuses. */
-| 'QUESTION';
+| 'QUESTION'
+/** Reports a write without the `consequential` annotation, writes without `agent.authority`, or a write named `recall` or with a name a lookup or another write carries. */
+| 'WRITE';
 
 /** Captures held message identities and the accepted edges used to validate their copies. */
 export declare interface LedgerEvidence {
@@ -7918,6 +8010,18 @@ export declare interface LedgerGauge {
     readonly overhead: number;
 }
 
+/**
+ * Carries a stored gauge: its price and the digest of the tool definitions that price measured.
+ *
+ * @remarks
+ * `digest` is what the `digestLedgerTools` helper returns for the definitions the calibration request
+ * carried, or for the ledger's definitions at construction when the options supplied the gauge. A
+ * hydrate reuses the price only when the hydrated ledger's definitions have the same digest.
+ */
+export declare interface LedgerGaugeSnapshot extends LedgerGauge {
+    readonly digest: string;
+}
+
 /**
  * Carries a registry prepared for matching: its ids, each owner name's owners, and the compiled needles.
  *
@@ -7963,7 +8067,7 @@ export declare interface LedgerInterface {
     readonly agent: AgentInterface;
     /** Holds the one conversation the ledger files and serves. */
     readonly conversation: ConversationInterface;
-    /** Holds the measured price of a prompt, or undefined until the ledger calibrates when the options supplied none. */
+    /** Holds the measured price of a prompt, or undefined until the ledger calibrates when neither the options nor a snapshot priced on the same tool definitions supplied one. */
     readonly gauge: LedgerGauge | undefined;
     /**
      * Appends `content` as a user message and serves it through to its reply.
@@ -7971,7 +8075,11 @@ export declare interface LedgerInterface {
      * @remarks
      * The ledger calibrates first while `gauge` is undefined. When the first pass ends without final
      * text and the caller did not abort, the ledger adds the results and cue notes and makes one
-     * answer pass that advertises no tools. A rejected first pass counts as unfinished; when the
+     * answer pass that advertises no tools. In either pass, a call the model makes in a turn that
+     * advertises no tools runs nothing and ends the pass after that turn, so such a pass makes one
+     * model generation, whatever the agent's `limit`; when every call of that turn failed, the ledger
+     * stores the reply without its calls, as a call-free turn stores it. That pass ends with the
+     * reply's text and `partial: false`, or partial with empty content when the reply carries no text. A rejected first pass counts as unfinished; when the
      * answer pass rejects as well, `respond` rejects with that pass's error. A `respond` or `calibrate` call while either is in flight
      * rejects with an `AgentError` whose `code` is `'CONCURRENCY'`. A calibration call that reports no prompt usage, or a prompt usage of 0 or less, rejects with
      * `LedgerError` code `'GAUGE'`; a provider error during calibration rejects with that error.
@@ -8001,7 +8109,8 @@ export declare interface LedgerInterface {
      * @remarks
      * The ledger sends the head its agent's context builds and its conversation's view to the provider twice, with
      * and without the tool definitions. The call without tools prices the messages and the
-     * difference between the calls is the overhead cost.
+     * difference between the calls is the overhead cost. The ledger records the digest of the
+     * definitions the call with tools carried, and its snapshot stores that digest with the gauge.
      * An abort during calibration rejects with the abort reason. A call during `respond` or `calibrate` rejects
      * with `AgentError` code `'CONCURRENCY'`.
      *
@@ -8018,9 +8127,10 @@ export declare interface LedgerInterface {
      * The ledger first files every tool result whose message is appended, so a failure a direct
      * agent run left is marked; a result whose tool message is not yet appended is not captured. A
      * call while a `respond` or `calibrate` call is in flight throws, because an entered, unanswered
-     * request would hydrate as a dangling request; a direct agent run is not refused.
+     * request would hydrate as a dangling request; a direct agent run is not refused. The `gauge`
+     * member carries the digest of the tool definitions the gauge priced.
      *
-     * @returns The snapshot, each id list in conversation order and `gauge` present after the ledger holds one
+     * @returns The snapshot, each id list in conversation order and `gauge` present after the ledger holds one whose definitions JSON renders
      * @throws {AgentError} Thrown when a request or calibration is active (code `'CONCURRENCY'`)
      */
     snapshot(): LedgerSnapshot;
@@ -8057,8 +8167,18 @@ export declare interface LedgerListing {
  *
  * @remarks
  * The ledger registers the tool behind a repeat stop beside its own `recall` tool, so the tool must
- * not be named `recall`, and no two lookups can share a tool name.
+ * not be named `recall`, and no two lookups can share a tool name. A lookup is a read: a tool whose
+ * call changes a record is a {@link LedgerWrite}.
  * The repeat stop compares the tool name and canonical arguments without normalizing strings.
+ * A call the tool refuses for its arguments never counts as a run: when `execute` throws, or
+ * returns a promise that rejects with, an error `isToolError` admits whose code is `'ARGUMENTS'`,
+ * the request releases the call, so the identical call runs again. Every other failure counts.
+ * A call the authority denies, or whose ask is declined or left unanswered, never runs, and the
+ * request records it. Its identical retry in a later turn of the same request is denied with the
+ * {@link LedgerNote} `repeat` text before the authority evaluates or asks it, and ends the pass as a
+ * repeat does. Its identical twin in the same batch was evaluated with it: the twin of a denied call
+ * is denied as that retry is, and the twin of a declined or unanswered ask is refused without
+ * entering the host's approver, after the agent reports its `ask` event, and the pass goes on.
  * The projection uses {@link identifyLookup}, which trims and uppercases top-level string
  * arguments when deciding which finding replaces an earlier one.
  * A throwing `read` handler makes the lookup failed: it files as chatter and replaces no finding.
@@ -8079,7 +8199,9 @@ export declare interface LedgerLookup {
  * @remarks
  * `id` is the tool message's id, `name` and `arguments` come from the call it answers, and `text`
  * is the result text. `result` is what the lookup's handler read, undefined for a lookup that found
- * nothing; an empty finding still replaces an earlier finding of the same call.
+ * nothing; an empty finding still replaces an earlier finding of the same call. `targets` is present
+ * on the finding of a write whose handler read a result: the ids whose state the call changed or
+ * removed, which supersede the earlier findings that name them.
  */
 export declare interface LedgerLookupFinding {
     readonly id: string;
@@ -8087,6 +8209,7 @@ export declare interface LedgerLookupFinding {
     readonly arguments: Readonly<Record<string, unknown>>;
     readonly text: string;
     readonly result: LedgerLookupResult | undefined;
+    readonly targets?: readonly string[];
 }
 
 /**
@@ -8122,8 +8245,9 @@ export declare type LedgerLookupState = 'failed' | 'empty' | 'shown' | 'hidden';
  * @remarks
  * `cue` is the last user message of an answer pass. `results` heads the note that carries what the
  * first pass's lookups and recalls returned. `repeat` is the failure a repeated tool call returns,
- * and the ledger reads a failure with exactly this text as a repeat. `closure` is the failure a
- * `recall` call returns after the request's recalls are spent, repeated, or out of room.
+ * and the reason of the denial the ledger gives the identical retry of a call the authority denied;
+ * the ledger reads a failure with exactly this text, or that denial, as a repeat. `closure` is the
+ * failure a `recall` call returns after the request's recalls are spent, repeated, or out of room.
  */
 export declare interface LedgerNote {
     readonly cue: string;
@@ -8138,15 +8262,15 @@ export declare interface LedgerOccurrence extends LedgerLine, LedgerReceipt {
 
 /**
  * Configures a ledger: its judge and the wording and cutoffs it files with, the desk topics, the
- * context capacity, and the optional first-pass thinking, lookups, gauge, shares, snapshot, recall
- * limit, correction filter, and agent options.
+ * context capacity, and the optional first-pass thinking, lookups, writes, gauge, shares, snapshot,
+ * recall limit, correction filter, and agent options.
  *
  * @remarks
  * `judge` answers every filing question. `system` is the application's system text, a date
  * sentence included; it opens the system message, which also holds the instructions and the skills index the `agent` option supplies. The memos index and the workspace text go into the context message after it, and the records go into a copy of each request turn. `topics` lists the desk
  * topics. `questions` and `thresholds` are required with no default; pass the `LEDGER_QUESTIONS`
  * constant for the measured wording, and fit `thresholds` on the wording and the judge you pass. `capacity` is the model's context window in tokens and must be a positive safe
- * integer. Without `gauge`, the ledger calibrates before its first pass. `share` defaults leaf by leaf to `DEFAULT_LEDGER_SHARE`. The ledger writes the `LEDGER_NOTES` text.
+ * integer. Without `gauge`, or a `snapshot` gauge priced on the same tool definitions, the ledger calibrates before its first pass. `share` defaults leaf by leaf to `DEFAULT_LEDGER_SHARE`. The ledger writes the `LEDGER_NOTES` text.
  * `predict` is the generation cap in tokens, including thinking. Default: 0. It must be a
  * nonnegative safe integer less than `capacity`; construction throws `LedgerError` with code
  * `'CAPACITY'` otherwise. The plan budgets
@@ -8154,7 +8278,8 @@ export declare interface LedgerOccurrence extends LedgerLine, LedgerReceipt {
  * The plan retains its `remainder - predict < 2 * reserve` admission rule. Runtime recall fits whole
  * results to measured remaining capacity at the larger of the gauge rate and the request's measured
  * rate, allowing `LEDGER_SCALE_DRIFT` for new text. Lack of room omits results without closing recall.
- * `snapshot` hydrates the conversation and
+ * `writes` lists the {@link LedgerWrite} entries the model can call; a ledger with writes requires
+ * `agent.authority`. `snapshot` hydrates the conversation and
  * the marked ids a ledger's `snapshot()` returned; construction throws `LedgerError` with code
  * `'SNAPSHOT'` when `isLedgerSnapshot` refuses it, and `ConversationError` with code `'ROLE'` or
  * `'SNAPSHOT'` when its conversation holds a `system` message or repeats an id.
@@ -8177,11 +8302,12 @@ export declare interface LedgerOptions {
     readonly think?: boolean;
     readonly gauge?: LedgerGauge;
     readonly lookups?: readonly LedgerLookup[];
+    readonly writes?: readonly LedgerWrite[];
     readonly share?: Partial<LedgerShare>;
     readonly recall?: LedgerRecallOptions;
     readonly correction?: LedgerCorrectionOptions;
     readonly agent?: LedgerAgentOptions;
-    /** Hydrates from a snapshot: its conversation, its marked ids, and its gauge when these options supply none, because a `gauge` option wins over `snapshot.gauge`. */
+    /** Hydrates from a snapshot: its conversation, its marked ids, and its gauge when these options supply none and the gauge priced the same tool definitions, because a `gauge` option wins over `snapshot.gauge`. */
     readonly snapshot?: LedgerSnapshot;
 }
 
@@ -8411,9 +8537,22 @@ export declare class LedgerRequest implements LedgerRequestInterface {
      * @returns The attempts in asking order
      */
     get attempts(): readonly ClassifierAttempt[];
+    /**
+     * Returns the signal `abort` aborts for the current pass's run.
+     *
+     * @returns The current pass's abort signal, or undefined before a pass
+     */
+    get signal(): AbortSignal | undefined;
+    /**
+     * Reports whether `abort` ended the current pass.
+     *
+     * @returns True if the current pass was aborted; false otherwise, and before a pass
+     */
+    get aborted(): boolean;
     enter(conversation: ConversationInterface): Message;
     open(boundary: number): void;
     adopt(selection: Selection, boundary: number): void;
+    abort(): void;
     observe(call: GaugeCall, position: number): void;
     spend(usage: TokenUsage): void;
     think(messages: readonly Message[]): void;
@@ -8421,6 +8560,9 @@ export declare class LedgerRequest implements LedgerRequestInterface {
     faulted(error: unknown): boolean;
     file(attempts: readonly ClassifierAttempt[], plan?: Selection, draft?: LedgerDraft): void;
     admit(name: string, args: Readonly<Record<string, unknown>>): void;
+    release(name: string, args: Readonly<Record<string, unknown>>): void;
+    deny(name: string, args: Readonly<Record<string, unknown>>): void;
+    denied(name: string, args: Readonly<Record<string, unknown>>): boolean;
     recall(): void;
     close(): void;
     list(result: string, lines: ReadonlyMap<string, string>, groups: readonly string[]): void;
@@ -8437,7 +8579,8 @@ export declare class LedgerRequest implements LedgerRequestInterface {
  * @remarks
  * A ledger creates one request per `respond` call and drops it when the call settles, so no request
  * state reaches a later call or a run no call owns. Each agent run the call makes is a pass: `open`
- * starts one, and `selection`, `boundary`, and `usage` read the current pass, the last one opened.
+ * starts one, and `selection`, `boundary`, `usage`, `signal`, and `aborted` read the current pass,
+ * the last one opened.
  * `calls` lists the gauge calls of every pass in order. A call stays in flight, taking its usage and
  * thinking, until its pass observes the next call, and is final from then on.
  */
@@ -8471,6 +8614,18 @@ export declare interface LedgerRequestInterface {
     readonly calls: readonly GaugeCall[];
     /** Holds the filing attempts of every planning selection the request made, in asking order. */
     readonly attempts: readonly ClassifierAttempt[];
+    /** Holds the signal `abort` aborts for the current pass's run, or undefined before a pass. */
+    readonly signal: AbortSignal | undefined;
+    /** Reports whether `abort` ended the current pass, read from `signal`; false before a pass. */
+    readonly aborted: boolean;
+    /**
+     * Aborts the current pass's run through `signal`, with the reason `'stray'`, so the run ends after its turn.
+     *
+     * @remarks
+     * The ledger calls it when a turn that advertised no tools made a call. A later call, and a call
+     * before a pass opens, changes nothing.
+     */
+    abort(): void;
     /**
      * Appends the request's content to a conversation as a user message, once, and holds it as `message`.
      *
@@ -8532,6 +8687,37 @@ export declare interface LedgerRequestInterface {
      * @throws {Error} Thrown when the arguments have no canonical identity
      */
     admit(name: string, args: Readonly<Record<string, unknown>>): void;
+    /**
+     * Releases one tool call the request admitted, so a later `admit` of the same call passes.
+     *
+     * @remarks
+     * The call is compared as `admit` compares it. A call the request never admitted, or one whose
+     * arguments have no canonical identity, changes nothing.
+     *
+     * @param name - The tool name
+     * @param args - The call's arguments
+     */
+    release(name: string, args: Readonly<Record<string, unknown>>): void;
+    /**
+     * Records one tool call the authority denied, declined, or left unanswered, so `denied` reports it for the rest of the request.
+     *
+     * @remarks
+     * The call is compared as `admit` compares it, and a denial admits nothing. A call whose arguments
+     * have no canonical identity changes nothing. The ledger records each lookup or write call the
+     * agent's `deny` event reports with a decision.
+     *
+     * @param name - The tool name
+     * @param args - The call's arguments
+     */
+    deny(name: string, args: Readonly<Record<string, unknown>>): void;
+    /**
+     * Reports whether the request recorded this tool call as denied.
+     *
+     * @param name - The tool name
+     * @param args - The call's arguments
+     * @returns True if `deny` recorded the same call, compared as `admit` compares it; false otherwise
+     */
+    denied(name: string, args: Readonly<Record<string, unknown>>): boolean;
     /**
      * Counts one `recall` call, closing the request's recall tool when its recalls reach the limit.
      *
@@ -8602,7 +8788,10 @@ export declare interface LedgerShare {
  * `respond` appended, `notes` the user messages carrying `LEDGER_NOTES` text, and `failures` the
  * tool messages whose call or reading failed, each in conversation order. Each id names a message
  * of `conversation.messages`: a request or note a `user` message and a failure a `tool` message.
- * `gauge` carries the scale and overhead alone. The gauge's observations of earlier requests are
+ * `gauge` carries the scale, the overhead, and the required `digest` of the tool definitions they
+ * priced. A hydrated ledger whose definitions have another digest drops the gauge and calibrates
+ * before its first pass; a gauge with no `digest` refuses the snapshot, and `snapshot()` omits a gauge
+ * whose definitions JSON cannot render. The gauge's observations of earlier requests are
  * not carried, so a hydrated ledger sizes and closes `recall` from its fallback reserve until it
  * completes a request. A question a `strict: false` classifier held after a deterministic judge
  * failure is not carried, so a hydrated ledger asks it again. Hydrating a second ledger from one snapshot forks
@@ -8613,14 +8802,16 @@ export declare interface LedgerShare {
  * never the record coverage. A plain request omits `copy` because its content already lives in `conversation`.
  * The required window `digest` checks canonical held messages, lookup call context, copies, and receipts. A mismatch drains
  * the window and its evidence; a missing digest refuses the snapshot. An unencodable held message
- * makes `snapshot()` omit the window. The checksum detects edits, not authenticity.
+ * makes `snapshot()` omit the window. The checksum detects edits, not authenticity. A write's
+ * retirements carry no member: the hydrated ledger reads each write's targets again from the
+ * conversation and its failures, so a changed `writes` list brings retired reads back live.
  */
 export declare interface LedgerSnapshot {
     readonly conversation: ConversationSnapshot;
     readonly requests: readonly string[];
     readonly notes: readonly string[];
     readonly failures: readonly string[];
-    readonly gauge?: LedgerGauge;
+    readonly gauge?: LedgerGaugeSnapshot;
     readonly window?: LedgerWindowSnapshot;
 }
 
@@ -8783,6 +8974,7 @@ failures: readonly string[];
 gauge?: Readonly<{
 scale: number;
 overhead: number;
+digest: string;
 } & {}>;
 window?: Readonly<{
 digest: string;
@@ -8922,6 +9114,7 @@ failures: ArrayShape<StringShape>;
 gauge: OptionalShape<ObjectShape<    {
 scale: NumberShape;
 overhead: NumberShape;
+digest: StringShape;
 }, boolean | ContractShape>>;
 window: OptionalShape<ObjectShape<    {
 digest: StringShape;
@@ -9034,6 +9227,59 @@ export declare interface LedgerWordSet {
     readonly names: ReadonlySet<string>;
 }
 
+/**
+ * Carries one application write: the `consequential` tool the model calls and the handler that reads its results.
+ *
+ * @remarks
+ * The ledger registers the tool beside its lookups and `recall`, behind the same repeat stop, which
+ * releases a call the tool refuses for its arguments and refuses, without entering the host's
+ * approver, the identical retry or batch twin of a call the authority denied, declined, or left
+ * unanswered, as a lookup's does: a retry in a later turn, and the twin of a denied call, end the
+ * pass as a repeat, and the twin of a declined or unanswered ask is refused after the agent reports
+ * its `ask` event, and the pass goes on. The
+ * tool must carry `annotations.consequential: true`, must not be named `recall`, and can share no
+ * name with a lookup or another write, and a ledger with writes requires `agent.authority`;
+ * construction throws `LedgerError` with code `'WRITE'` otherwise. A write runs through the agent's
+ * scope, the host authority, the `consequential` floor, and the host's approver like any tool.
+ * The ledger files a successful result as a finding, as it files a lookup's, adding the ids its
+ * string arguments name to `ids` and never to `targets`. The finding supersedes every earlier
+ * finding whose `ids` or owner ids meet its `targets`, and every such finding without targets in
+ * its own tool group, as {@link collectWriteSupersessions} reads them. A handler that returns
+ * undefined reads a call that changed nothing, which retires nothing. A refused, denied, aborted,
+ * or thrown call, and a throwing handler, file nothing and retire nothing. The ledger reads the
+ * targets again from the conversation on every scan, so pass the same writes on every hydrate.
+ * When a write runs, the ledger also calls the handler on its result once, and the request admits
+ * again each lookup call whose finding the write retired, so a later read that checks the write
+ * passes the repeat stop; a second identical read with no write between is still a repeat.
+ */
+export declare interface LedgerWrite {
+    readonly tool: ToolInterface;
+    readonly read: LedgerWriteHandler;
+}
+
+/**
+ * Reads one successful write result into the ids and owners it names and the ids whose state it changed.
+ *
+ * @param args - The arguments the model called the write with
+ * @param text - The result text the tool returned
+ * @returns The ids, owners, and targets the result names, or undefined when the call changed nothing
+ *
+ * @example
+ * ```ts
+ * const read: LedgerWriteHandler = (args, text) => {
+ * 	if (text.startsWith('No change')) return undefined
+ * 	const id = String(args.id ?? '').trim().toUpperCase()
+ * 	return { ids: [id], owners: [{ id, names: [] }], targets: [id] }
+ * }
+ * ```
+ */
+export declare type LedgerWriteHandler = (args: Readonly<Record<string, unknown>>, text: string) => LedgerWriteResult | undefined;
+
+/** Carries what a write handler read from one write result: the ids and owners it names, and the ids whose state the call changed or removed. */
+export declare interface LedgerWriteResult extends LedgerLookupResult {
+    readonly targets: readonly string[];
+}
+
 /**
  * Links each id-shaped lookup argument to its owner.
  *
@@ -9757,6 +10003,26 @@ export declare interface MemoStoreInterface {
     delete(id: string): Promise<void>;
 }
 
+/**
+ * Merges supersession edges into a classification, adding each edge to both its supersessions and its amendments.
+ *
+ * @remarks
+ * Each earlier message's later ids stay distinct and in conversation order, so every supersession
+ * is still an amendment, as the classifier files one. An empty edge map returns the classification
+ * itself.
+ *
+ * @param classification - The judged classification
+ * @param edges - The later ids that supersede each earlier id, such as {@link collectWriteSupersessions} returns
+ * @param messages - The conversation's messages, which order the later ids
+ * @returns The classification with the edges merged
+ *
+ * @example
+ * ```ts
+ * mergeSupersessions(classification, new Map([['tool-1', ['tool-2']]]), messages).supersessions.get('tool-1') // ['tool-2']
+ * ```
+ */
+export declare function mergeSupersessions(classification: LedgerClassification, edges: ReadonlyMap<string, readonly string[]>, messages: readonly Message[]): LedgerClassification;
+
 /**
  * Represents one conversation turn fed to a {@link ProviderInterface} — a stored, identified
  * message.
@@ -11181,6 +11447,7 @@ export declare function renderSection<T>(open: string, members: readonly T[], re
  * @param name - The lookup tool name
  * @param args - The arguments the call carried; arguments JSON cannot carry leave the call as its bare tool name, per {@link renderLookupCall}
  * @param state - What became of the result: `failed`, `empty`, `shown` in the records, or `hidden` from them
+ * @param write - If `true`, the call is a write's, whose `empty` state reads `changed nothing`; if `false`, a lookup's, whose `empty` state reads `no record`. Default: `false`
  * @returns The stub text, which carries the call and its state
  *
  * @example
@@ -11189,7 +11456,7 @@ export declare function renderSection<T>(open: string, members: readonly T[], re
  * // 'lookup_order {"id":"BW-5512"}: result not shown; call recall with BW-5512'
  * ```
  */
-export declare function renderStub(name: string, args: Readonly<Record<string, unknown>>, state: LedgerLookupState): string;
+export declare function renderStub(name: string, args: Readonly<Record<string, unknown>>, state: LedgerLookupState, write?: boolean): string;
 
 /**
  * Renders a tool's output as the string content of its tool message, or returns `undefined` when JSON