agentfootprint 9.101.1 → 9.103.0

package/CHANGELOG.md

@@ -5,6 +5,247 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [9.103.0] - 2026-09-17
+
+### Added — an answer-turn ask on the served ledger piece, as a dial
+
+- `findings({ answerAsk: 'quote-facts' })` appends a second model-facing ask
+  to the served ledger piece — `FINDINGS_ANSWER_ASK`, its last section after
+  a blank line — telling the model HOW to answer from it: answer from the
+  `facts` lines and copy each value as written; an `evidenceRefs` or
+  `nextSteps` result is unsettled, say so; a `{"collapsed":true,…}` ticket
+  carries no data (judged noise or ruled out, or its fact already listed),
+  do not draw on it; an undeclared result is
+  served in full and may be used; never invent a value. It says what the
+  model may do and promises nothing (judged by `unprovable` at the strictest
+  lifetime, registered in the model-facing inventory), and it is a constant,
+  so the piece's cache law holds with it. The default is `'none'` and the
+  dial is BENCH-GATED like `'ledger-only'`: it ships so
+  `bench/findings-shuffle.mjs`'s new fourth condition, `ledger+ask`, can
+  score it on a real model on `facts-in-answer` against `ledger-and-facts` —
+  the design page's fourth run measured one fact value in twelve restated
+  when the piece is served, and asked for this instruction variant next. On
+  the mock that row equals `ledger-and-facts` to the digit (the scripted
+  model ignores prose; the header says so). The dial rides the
+  `findingsServe` thread exactly — `Agent.ts` to seed and to call-llm,
+  value-conditionally — and lands on the record as the run constant
+  `AgentState.findingsAnswerAsk`, written ONLY under `'quote-facts'`, so an
+  armed agent on the default commits the key set it committed in 9.102.0,
+  every unarmed agent is byte-identical, and `servedAt` re-appends the ask
+  from the record by construction. A bad value is refused at build at either
+  door. Pinned: `findings/serve.test.ts` (the ask appended only under the
+  dial, exact bytes, absent by default, never alone), `findings-served.test.ts`
+  (both chart shapes end the served system text with the ask; without the
+  dial byte-identical), `findings-declarations.test.ts` (the option, the run
+  constant only when armed and on, the refusal), `receipt-conformance.test.ts`
+  (the rebuild byte-equal under the dial); all 18 byte-identity references
+  pass untouched.
+
+### Measured — the ask on two hosted models (`bench/findings-shuffle.mjs`, noise 4 at the end of the order, 1,000-token payloads, ten runs per condition)
+
+- Claude Sonnet 5: facts in the answer 0.883 with the ledger alone → 0.950 with the ask (1.000 without the ledger); noise cited 0.100 with either → 0.300 without the ledger; drift 0.70 → 0.40.
+- Claude Haiku 4.5: facts 0.983 → 1.000 with the ask; noise cited 0.000 (0.100 without the ledger); drift 0.30 → 0.20.
+- Collapsing facts too (`serve: 'ledger-only'`) was the worst row on both models and stays bench-gated. Full tables: docs/design/2026-09-findings-ledger-real-model.md.
+
+## [9.102.0] - 2026-09-17
+
+### Added — a declared fact stays in the window; noise leaves first
+
+- The window reads the findings ledger. On an agent with `.findings()` and a
+  window strategy, a turn whose tool result the model declared a `fact` is
+  HELD beyond `keepRecentTurns` — newest first, up to `keepLedgerFacts`
+  (default 4; `false` or `0` for no hold) — and the refusal is on the record
+  by name: `WindowRefusalReason` gains `'ledger-fact'`. It is a bounded hold
+  in the refusal engine, the content-aware sibling of the last-tool-result
+  pin (`ledgerFactPinsOf` beside `toolResultPinsOf`, admitted by the same
+  ceiling-spender in `planRemoval`), so `slidingWindow`, `tokenBudget`,
+  `summarizeOldest` and a consumer-written strategy all inherit it through
+  `planRemoval` — no new strategy file, none of the three shipped ones changed
+  a byte, the contiguous span, the drop ladder and the meter's single-seam
+  rebase untouched. 'Noise first' follows with no second mechanism: noise,
+  ruled-out, open and undeclared turns are unpinned and leave oldest-first as
+  they always did, and a judged noise turn that outlives a fact is already a
+  ticket on the wire. Why: the served piece restored a declared fact to the
+  answer turn, but under a window the fact's RESULT still left by recency —
+  the refusal engine saw a declared fact and a declared noise result as the
+  same bytes. By the model's claim only: a turn is the removal unit and its
+  standing is its most valuable result's (`fact > open > undeclared >
+  ruled-out > noise`); a result the model never named is undeclared and is not
+  held; the library reads no result's text to decide otherwise.
+- A fact hold never exists without its ceiling and its stand-down. The
+  ceiling is spent newest first and a held turn already inside
+  `keepRecentTurns` spends no slot (the free-pin law); the turns it turned away
+  are `yielded` on the record; nothing at or before the current request is
+  pinnable. The stand-down is the pin's: when the two previous visits removed
+  nothing and named only pins, the fact pins release for one visit and the
+  record says so. It reads BOTH pin names (`'last-tool-result'` and/or
+  `'ledger-fact'`), because a turn held by both pins is reported under the
+  recency pin's name — a fact stand-down reading only its own would never see
+  that turn blocking, and the two pins would alternate under each other's
+  name with the window never shrinking (derived, pinned by test, never
+  shipped). The recency pin's own stand-down reads only its own name, so its
+  9.57.0 rule is unchanged.
+- The record says what was held and whose standing left. `WindowRecord`
+  gains two optional keys, present only on an armed agent and filed by the
+  STAGE so a consumer-written strategy's record carries them too:
+  `ledgerFacts` (the `WindowObservations` shape — `pinned`, `yielded`,
+  `limit` = `keepLedgerFacts`, `standDown: true` on the visit it released)
+  and `droppedStandings` (`{ toolCallId, standing? }` for every tool result
+  that left; `standing` absent is undeclared, never a verdict the library
+  inferred). `WindowStrategyInput.standingOf?` hands a strategy a turn's
+  declared standing, bound by the stage from ONE read of the ledger and
+  absent on an unarmed agent — a strategy never reads scope for it; it is for
+  ordering or reporting among what the engine left removable, never for
+  inferring. What the model is TOLD about a drop is unchanged: the notice
+  names tools and counts, never a standing, never the model's own line.
+- `keepLedgerFacts` is live: `.findings({ keepLedgerFacts })` and
+  `Agent.create({ keepLedgerFacts })` (the `.findings()` door wins when both
+  are given), resolved once at build and validated there — a negative or
+  non-integer value is refused, never mid-run. Without `.findings()` the
+  option is accepted and does nothing (the keepLastToolResults-without-a-window
+  precedent). Exported from the root: `LedgerFactPin` (the candidate a hold is
+  built from: `toolCallIds`, `toolName`, `turnIndex`, `messageIndex`, `chars`),
+  beside the widened `WindowRefusalReason` and the `WindowRecord` additions.
+- Measured (`npm run bench:findings`, mock provider, 30 tool calls, a planted
+  fact every third, a sliding window keeping 6 turns): the results of 2 of 10
+  planted facts reached the answer turn verbatim by recency alone, 6 under the
+  default ceiling and 8 under a ceiling of 6, while the piece carried 9 of 10
+  on every armed row (the last batch is undeclared by the no-outputSchema law)
+  and the noise share of tool-result bytes on the wire stayed at the collapsed
+  level; every noise result left on every armed row, so the hold changed WHICH
+  facts left, not whether noise did. The design page has the print and its
+  reading; no real-model number exists yet.
+
+### Unchanged — an agent without `.findings()` plans, records and sends the bytes it did before
+
+- The hold, the ledger read, `standingOf`, `ledgerFacts` and `droppedStandings`
+  are all gated on the door: an unarmed window stage never reads
+  `findingsLedger` (pinned by a getter counting reads), hands its strategy the
+  exact input it always did, files the exact record it always did, and sends
+  the same request bytes — even when the model emits `_findings` on its own.
+  The 16 byte-identity references under `test/core/tools/reference/` pass
+  untouched; ONE new reference, `agent-findings-window`, was generated alone,
+  with what it holds read back from its bytes on the test file's header.
+- `keepLedgerFacts: false` plans exactly as the unarmed window (the bench
+  checks it: same facts verbatim, same tool messages, same receipt count, no
+  fact held), so the hold is an addition to the plan, never a rewrite of it.
+
+### Added — the ids the model may name are in the schema; the proposition before the call; a bench that can measure
+
+- The offer. On a hosted model the ask "by its tool_result id" produced
+  standings named by ORDINAL (`"0"`, `"1"`), recorded honestly as `unknownId`
+  and settling nothing (`docs/design/2026-09-findings-ledger-real-model.md`).
+  So from the second call on, the reserved `_findings` property on every
+  served schema binds the ids the model may name: `previous[].toolCallId`
+  carries `enum: <the tool results on the wire with no standing yet, newest
+  first, at most 32>` and says "one of the ids listed; a result not listed
+  cannot be named here"; a clipped list states the cap. The list is what the
+  model can still READ: a result with no standing, a `fact` (stood on in the
+  piece, served verbatim under the default mode) and an `open` result (served
+  verbatim, carrying what would settle it) stay listed, so a later call can
+  REVISE a standing — `open` → `fact` when a call settles it, `fact` →
+  `ruled-out` when a conflict resolves; the fold's last-wins law is reachable
+  through the enum. A result the model declared `noise` or `ruled-out` leaves
+  the list: it is a ticket on the wire under every serve mode and the piece
+  carries a count or one line, so there is nothing left to re-judge (a wrong
+  `ruled-out` is answered by a new call). The instruction asks the model to
+  name a result again only to change its standing. An evicted result is not
+  on the list, and the first call — with nothing to name — serves the base
+  property by reference, byte-identical to 9.101.0. ONE owner of the two sets
+  (`findings/offer.ts`: `offeredResultIds` for the enum, `undeclaredIds` for
+  the piece's `undeclared:` line — the honest absence, a subset of the offer),
+  computed at the Tools mount, where the served history and the ledger meet
+  (the slot is an isolated subflow), under the same arm that decorates; bound
+  at the ONE decoration site and committed with the tool list, so
+  `servedAt(k).tools.schemas` holds exactly what was offered and
+  `receipt.tools.schemaHashes` moves when the offer does. The law holds at
+  the schema AND at the row: the offer is what the model may COPY, never what
+  the library resolves — an id outside it still files as written, `unknownId:
+  true`, never mapped to a position or a tool name — and every id INSIDE it
+  resolves, because a standing is identified against the same served history
+  the offer was read from (`findings/offer.ts · knownResults`: the served
+  `role: 'tool'` messages plus the previous batch), so an id copied from the
+  offer files with its tool name whichever batch the result came from (the
+  first cut resolved against the last batch only, and an offered older id
+  filed as `unknownId` — caught in review, never released). The instruction
+  asks the JSON answer, which has no schema to bind, for the id exactly as
+  the schema listed it.
+- Named, not measured: from the second call on, an armed agent's tool schemas
+  vary per call (the enum), so a `'tools'` cache breakpoint cannot hit on such
+  a run and, on a prefix-cached wire, every breakpoint after it misses with
+  it — the system piece already moved the block on every declaring call
+  (step 3's recorded cost); the offer moves the tools prefix ahead of it. No
+  bench in the tree counts cache tokens; the lever not taken (the offer in
+  the request-only system piece, below the tools breakpoint — prose, which is
+  what failed on the real model) is on the design page.
+- The proposition. `FindingsDeclaration` gains `proposition?: string` (what
+  the call tests; the schema recommends it when `basis` is `'exploratory'`)
+  and `predicts?: string` (what the result should show if it holds), declared
+  on the call before its result exists; both land on the `BasisRow`, each cut
+  at 240 chars with the cut stated in the text. `FindingsDeclaredPayload`
+  gains `hasProposition?: true` — a flag, never the text. The served piece
+  quotes the judged call's own proposition on `open` and `ruled-out` lines
+  (`… — tested: <proposition>`), never on a fact line; `predicts` is
+  record-only.
+- The shuffle bench can measure (`bench/findings-shuffle.mjs`): `NOISE_AT`
+  (end / start / spread), `NOISE_SIZE` (about 250 / 1000 / 4000 tokens of
+  padding per noise record), noise values within 5% of a fact and never equal,
+  a `standing-accuracy` column (the share of the actor's standings on known
+  ids that agree with the planted truth — the harness knows the truth, so no
+  judge), and `--matrix` (24 cells for one model per invocation, the cost line
+  printed before the first call). Default mode prints the pre-packet numbers
+  to the digit and the mock smoke stays green. No hosted run was made in
+  this release; the real-model page holds the pre-offer tables and names the
+  number that must move.
+
+### Changed — `.findings()` refuses `reactMode: 'classic'`
+
+- The offer needs the tools slot recomposed every call, so `.findings()` is
+  REFUSED at build under `reactMode: 'classic'` — through both doors
+  (`.findings()` and `Agent.create({ findings })`), the `selfExplain` twin:
+  classic selects the Tools branch on turn 1 only, so an armed classic agent
+  would have served the offer-less base on every call and filed every
+  standing as `unknownId`, the number this packet exists to move silently
+  stuck at zero. 9.101.x accepted the combination and degraded it silently;
+  the message names the fix. `'dynamic'` (the default) and `'dynamic-grouped'`
+  are unchanged.
+
+### Fixed — the choice seam's enum fence read the decorated schema
+
+- Since 9.101.0, `withoutFindingsArgument` recognised the library's
+  decoration by REFERENCE only (`properties._findings ===
+  FINDINGS_ARGUMENT_SCHEMA`), and the reference never holds on the live path:
+  the served list `callLLM` reads is the committed `dynamicToolSchemas`, a
+  `structuredClone` of what the slot planted. So the choice seam's enum fence
+  (`declaredEnumValuesOf(withoutFindingsArgument(schema))`, the
+  `unsupported-argument` check) judged the model's argument values against a
+  schema that still carried `_findings`, and a value equal to one of the
+  findings vocabulary words — `direct`, `exploratory`, `low`, `medium`,
+  `high`, `fact`, `open`, `noise`, `ruled-out` — was excused as a declared
+  enum value the model was entitled to. The decoration is recognised by its
+  versioned marker now (the first sentence of the reserved property's
+  description), so the frozen base, an offer copy and a committed clone of
+  either are all peeled, and an author's own `_findings` is still read as
+  written. An armed agent may therefore file an `unsupported-argument`
+  finding it previously suppressed. Its unit test had passed because it
+  handed the function the live reference; `test/core/agent/findings/
+  reserved.test.ts` now pins the clone.
+
+### Unchanged — the unarmed agent, and the two armed references regenerated alone
+
+- An agent without `.findings()` maps no new key on the Tools mount, reads
+  neither `history` nor `findingsLedger` there, and serves and records the
+  bytes it did before: the 16 unarmed byte-identity references pass
+  untouched. `agent-findings` and `agent-findings-window` were regenerated
+  each alone (the rest copied aside and `cmp`-equal after) and their delta is
+  on the test file's header: the enum on every epoch after the first, a
+  `dynamicToolSchemas` write on each such epoch where an unchanged list used
+  to be an empty commit, the two new properties and the instruction's two new
+  lines, and the sizes that follow; regenerated once more, each alone, in the
+  second review for the revisable offer (a declared fact stays listed) and
+  the instruction's revised line. No message, ticket, ledger row, window
+  record or gap moved.
+
 ## [9.101.1] - 2026-09-16
 
 ### Fixed — the docs site's export-file ceiling

package/dist/core/Agent.js

@@ -142,6 +142,36 @@ const registry_js_1 = require("../thinking/registry.js");
 // Public types (AgentOptions, AgentInput, AgentOutput) extracted to
 // ./agent/types.ts and re-exported above (v2.11.1).
 // AgentState extracted to ./agent/types.ts (v2.11.1).
+/**
+ * The ledger-fact hold's default ceiling (9.102.0): how many fact turns the
+ * window holds beyond `keepRecentTurns` when `.findings()` and a window
+ * strategy are both configured and nobody named a number. Resolved in the
+ * constructor, ONCE, and threaded to `buildWindowStage` as a plain number —
+ * the stage applies no default of its own (absent = unarmed = no hold), so a
+ * reader has one place to look. `window/options.ts ·
+ * DEFAULT_KEEP_LAST_TOOL_RESULTS` is the pin's twin of this constant.
+ */
+const DEFAULT_KEEP_LEDGER_FACTS = 4;
+/**
+ * Validate the `keepLedgerFacts` dial — `window/options.ts ·
+ * requireKeepLastToolResults`'s twin: the same rule, the same moment.
+ * Refused at construction, never mid-run.
+ */
+function requireKeepLedgerFacts(value, label) {
+    if (value === false)
+        return;
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${label}: keepLedgerFacts must be a whole number >= 0, or false, got ` +
+            `${String(value)}. It is how many fact turns the window holds beyond ` +
+            `keepRecentTurns under .findings(); 0 and false both switch the hold off.`);
+    }
+}
+/** `false` → `0`; a number as named; nothing named → the default. */
+function resolveKeepLedgerFacts(named) {
+    if (named === false)
+        return 0;
+    return named ?? DEFAULT_KEEP_LEDGER_FACTS;
+}
 class Agent extends RunnerBase_js_1.RunnerBase {
     name;
     id;
@@ -249,8 +279,13 @@ class Agent extends RunnerBase_js_1.RunnerBase {
      *  conditioned on, so an unarmed agent hands each stage exactly the deps
      *  it always did. `serve` is threaded to seed (the run constant
      *  `findingsServe`) and to call-llm (`findingsServe` in its deps) on an
-     *  armed agent only. `keepLedgerFacts` is inert until standing-aware
-     *  eviction lands. */
+     *  armed agent only; `answerAsk` (9.103.0) rides the same two threads
+     *  as `findingsAnswerAsk`, and only when it is `'quote-facts'` — the
+     *  default `'none'` threads nothing. `keepLedgerFacts` is resolved once, here in the
+     *  constructor (this door over `AgentOptions.keepLedgerFacts`), into the
+     *  `keepLedgerFacts` field below and threaded to the window stage on an
+     *  armed agent with a window, where `stages/window.ts · buildWindowStage`
+     *  spends it as the `'ledger-fact'` pin ceiling. */
     findingsOptions;
     /** The opt-in tool-result ceiling in characters (9.11.0). Absent → results
      *  are never measured. See {@link AgentOptions.maxToolResultChars}. */
@@ -314,6 +349,13 @@ class Agent extends RunnerBase_js_1.RunnerBase {
     /** The last-tool-result pin (9.57.0) — set only when the operator named a
      *  value other than the default 2. See AgentOptions.keepLastToolResults. */
     keepLastToolResults;
+    /** The ledger-fact hold's ceiling (9.102.0), RESOLVED — set exactly when
+     *  `.findings()` is on: `findings({ keepLedgerFacts })` over
+     *  `AgentOptions.keepLedgerFacts`, `false` → `0`, nothing named →
+     *  `DEFAULT_KEEP_LEDGER_FACTS`. Undefined on every unarmed agent, so the
+     *  thread into the window stage reads as the decision it is. See
+     *  AgentOptions.keepLedgerFacts. */
+    keepLedgerFacts;
     /** See AgentOptions.integrityPosture (9.60.0). Default 'observe'. */
     integrityPosture = 'observe';
     /**
@@ -686,6 +728,35 @@ class Agent extends RunnerBase_js_1.RunnerBase {
             (0, options_js_1.requireKeepLastToolResults)(opts.keepLastToolResults, 'Agent');
             this.keepLastToolResults = opts.keepLastToolResults;
         }
+        // Its content-aware sibling (9.102.0). The top-level door is refused
+        // HERE, whether or not `.findings()` is on — a dial that is silently
+        // ignored is a configuration mistake, not a runtime condition (the
+        // `.findings()` door was refused by the builder). The value is resolved
+        // ONCE, under the arm only: the `.findings()` door wins when both are
+        // given, `false` is `0`, nothing named is the default. Without
+        // `.findings()` there is no ledger to hold facts from, so the option is
+        // accepted and does nothing — the keepLastToolResults-without-a-window
+        // precedent.
+        if (opts.keepLedgerFacts !== undefined)
+            requireKeepLedgerFacts(opts.keepLedgerFacts, 'Agent');
+        if (this.findingsOptions !== undefined) {
+            // The ledger needs the tools slot recomposed every call: from the second
+            // call on, the served `_findings` property binds the ids the model may
+            // name (`findings/offer.ts · offeredResultIds`, bound at the Tools
+            // mount) — and on a hosted model that binding is what makes a standing
+            // resolve at all (docs/design/2026-09-findings-ledger-real-model.md).
+            // `reactMode: 'classic'` selects the Tools branch on turn 1 only, so an
+            // armed classic agent would serve the offer-less base on every call and
+            // file every standing as `unknownId`. Refused loud, here at build, the
+            // `AgentBuilder.selfExplain` twin — never a silent degrade.
+            if (this.reactMode === 'classic') {
+                throw new Error("Agent: .findings() requires per-iteration slot recomposition — reactMode 'classic' " +
+                    'caches the tools slot on turn 1, so the ids the model may name (bound into every ' +
+                    'served tool schema from the second call on) would never reach it and every standing ' +
+                    "would file as unknownId. Use the default 'dynamic' mode (or 'dynamic-grouped').");
+            }
+            this.keepLedgerFacts = resolveKeepLedgerFacts(this.findingsOptions.keepLedgerFacts ?? opts.keepLedgerFacts);
+        }
         // Refused at construction, never mid-run — a misspelled posture that was
         // ignored would leave the liveness theorems switched off in an agent
         // that believes they are on (the concurrency-mode precedent).
@@ -3139,6 +3210,11 @@ class Agent extends RunnerBase_js_1.RunnerBase {
             ...(this.findingsOptions !== undefined && {
                 findings: true,
                 findingsServe: this.findingsOptions.serve ?? 'ledger-and-facts',
+                // The answer-turn ask (9.103.0): VALUE-conditional inside the arm —
+                // the default `'none'` threads nothing and writes no key.
+                ...(this.findingsOptions.answerAsk === 'quote-facts' && {
+                    findingsAnswerAsk: 'quote-facts',
+                }),
                 consumePendingResumeFindingsLedger: () => {
                     const l = this.pendingResumeFindingsLedger;
                     this.pendingResumeFindingsLedger = undefined;
@@ -3492,6 +3568,11 @@ class Agent extends RunnerBase_js_1.RunnerBase {
                 findings: true,
                 hasFindingsLedger: true,
                 findingsServe: this.findingsOptions.serve ?? 'ledger-and-facts',
+                // The answer-turn ask (9.103.0): the same value seed records, so the
+                // wire and the rebuild append it from one fact; absent on `'none'`.
+                ...(this.findingsOptions.answerAsk === 'quote-facts' && {
+                    findingsAnswerAsk: 'quote-facts',
+                }),
             }),
             ...(this.answerValidationConfig !== undefined && { suppressDraftTokens: true }),
             // The receipt's salt (9.88.0) — read per call, like seed's own accessor.
@@ -3588,6 +3669,16 @@ class Agent extends RunnerBase_js_1.RunnerBase {
                     ...(this.keepLastToolResults !== undefined && {
                         keepLastToolResults: this.keepLastToolResults,
                     }),
+                    // The findings ledger (9.102.0): the arm and the RESOLVED
+                    // ledger-fact ceiling, together or not at all. `keepLedgerFacts`
+                    // is set exactly when `.findings()` is on, so an unarmed agent
+                    // hands the stage exactly the deps object it always did; an
+                    // armed agent with no window strategy threads nothing, because
+                    // this whole stage does not exist for it.
+                    ...(this.keepLedgerFacts !== undefined && {
+                        hasFindingsLedger: true,
+                        keepLedgerFacts: this.keepLedgerFacts,
+                    }),
                     ...(pricingTable !== undefined && { pricingTable }),
                     ...(costBudget !== undefined && { costBudget }),
                 }),
@@ -3840,6 +3931,11 @@ class Agent extends RunnerBase_js_1.RunnerBase {
             // Escalation (9.19.0): the grouped chart threads `skillEscalated`
             // across the sf-llm-call boundary only when the policy exists.
             ...(this.skillBrains?.escalation !== undefined && { hasEscalation: true }),
+            // The findings ledger (9.102.0): both charts compute the OFFER on the
+            // Tools branch's mount only under the arm — the same value-conditional
+            // grammar as the slot's `findings` and callLLM's `hasFindingsLedger`,
+            // so the three can never disagree about whether the ledger is armed.
+            ...(this.findingsOptions !== undefined && { hasFindingsLedger: true }),
             // `.limitsTravelWithTheAnswer()` (this release) — value-conditional, the
             // `resolvedModel` precedent: absent from the deps object entirely for an
             // agent that did not ask, so both builders mount the final-branch stage