agentfootprint 9.82.0 → 9.83.0

package/CHANGELOG.md

@@ -7,6 +7,97 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [9.83.0] - 2026-09-03
+
+### Fixed
+
+- **The evidence gate claimed a boundary it did not measure.** Both of its
+  user-facing sentences — the correction it sends the model
+  (`buildEvidenceCorrection`) and the warning it prints an operator
+  (`evidenceRefusalSentence`) — said the flagged values *"appear in NO tool
+  result **from this turn**"*. The index behind them has never been turn-scoped:
+  it walks every `role: 'tool'` turn in the history. The library was asserting a
+  scope it could not honour, in the two places that assertion is read.
+
+  Both now say what the check really reaches — *"appear in no tool result this
+  run read"* — which is both true and the stronger claim, and the operator
+  sentence adds the two facts a reader needs: that the corpus is the LIVE
+  WINDOW (a window strategy rewrites `scope.history` in place, so a dropped
+  result is not in it), and that `noticePriorTurnEvidence` is what answers the
+  recency question. The frame PREFIX is unchanged, so
+  `isLibraryAuthoredTurn` and every consumer matching on it are untouched.
+
+### Added
+
+- **`noticePriorTurnEvidence` — the answer is grounded, and nothing this turn
+  fetched grounds it.** Default off.
+
+  The measured failure: a consumer's agent answered a data question with **zero
+  tool calls**, and the gate approved it — `LLM calls 1 · Tool calls 0 ·
+  Iterations 1`, then *"All 7 values in the answer were found in what the tools
+  returned — the answer stands."* They were found: in an inventory result from
+  four turns earlier, fetched for a different question. The user had asked about
+  array performance; the answer recommended enabling a collector that had been
+  running for months. Two turns did it back to back. Every rail passed honestly
+  — the gate measures GROUNDEDNESS and had no notion of WHEN a value was
+  grounded.
+
+  Every indexed form now carries the turn that last served it — one number,
+  stamped during the walk the index was already doing (`EvidenceCorpus.values`
+  became a `Map<form, turn>`; a TURN starts at each `role: 'user'` message the
+  library did not author). When at least one value in the answer is grounded and
+  **not one of them** came from the turn being answered, one `advisory` finding
+  is filed at the claim seam:
+
+  ```ts
+  const agent = Agent.create({ provider, model, noticePriorTurnEvidence: true })
+    .tool(arrayInventory)
+    .namesAndNumbersFromEvidence() // ← the other half: it owns the extractor
+    .build();
+
+  await agent.run('what arrays are there?');       // fetches, answers, files nothing
+  await agent.followUp('how is array performance?'); // no tool call, answers from turn 1
+  // → prior-turn-evidence: 3 grounded value(s), all last served in turn 1,
+  //   and this turn called no tool at all.
+  ```
+
+  **The corpus is deliberately NOT narrowed to this turn.** That would have made
+  the old sentence true and been the wrong fix: *"and what about that disk?"*
+  leans on the previous turn's rows legitimately, and a check that cries wolf is
+  a check somebody switches off. ONE grounded value from this turn's own results
+  files nothing — not a threshold to tune, but the falsification of the claim
+  being tested. A follow-up that calls a tool usually gets that for free,
+  because a lookup keyed on an earlier identifier echoes it back.
+
+  A turn that served no tool results at all is the SAME finding with a stronger
+  witness, not a second kind: it is a cheaper proof of the identical fact.
+
+  **The ceiling** ships as `PRIOR_TURN_EVIDENCE_CEILING`, exported and quoted
+  verbatim into every message: referring back is indistinguishable, by evidence
+  alone, from going stale; the ordinals count only the turns still in the live
+  window, so the distance is a FLOOR (the boundary itself is exact — the
+  current request is un-droppable); and values that reached the model through
+  `.memory()` recall or RAG are exempt from grounding and invisible to it, so it
+  can under-report and never over-report.
+
+  **Two halves arm it**, and the second is structural rather than a policy
+  companion: the dial AND `.namesAndNumbersFromEvidence()`, whose extractor
+  decides which tokens in an answer are values at all. It REPORTS — whether an
+  answer is advised or refused stays the gate's own `posture` decision, and
+  nothing here blocks, revises or rewrites anything. Absent, a run is
+  byte-identical save the registered `prior-turn-evidence` row filed
+  `not-applicable`, which is the family's law rather than an exception to it.
+
+  Three terminal exits reach a caller without the gate ever producing a
+  grounding reading — an empty answer, a middleware denial, and an answer the
+  output schema rejected — and each files its disposition rather than leaving
+  the armed row untouched. An untouched armed row is what `assertAlive` reads
+  as wiring rot, so without this an empty answer under
+  `integrityPosture: 'dev'` would have failed a healthy run with
+  `CheckerDeadError`.
+
+  Docs: [Prior-turn evidence](https://agentfootprint.dev/docs/monitor/prior-turn-evidence).
+
 ## [9.82.0] - 2026-08-30
 
 ### Added

package/CLAUDE.md

@@ -53,6 +53,7 @@ not in this table, search `src/index.ts` for the nearest noun before writing cod
 | the model inventing an id or a reading that no tool ever returned — a deterministic fabrication detector on the final answer, with a posture for how hard it pushes back | `.namesAndNumbersFromEvidence()` + `posture` (`'assist'` record+flag, the default / `'guard'` one revision then ship flagged / `'rails'` refuse instead) + `shapes` + `exempt` + `minDigits` (default 4) + `nudge` (default off) | `src/core/agent/evidence/` | 9.35.0 |
 | counting a HUMAN-VERIFIED value as ground for the choice-seam check — the person clicked a row, the app verified the cells against the artifact, and the id the model takes from that selection is not fabricated; the source label travels onto the record | `externalGrounds` + `ExternalGround` + `external_ground_used` | `src/integrity/unsupported-argument/check.ts` | 9.72.0 |
 | a lookup tool that answers "nothing found" for EVERY id because a filter broke, and an agent reporting that absence as fact — the run itself produced the id, the lookup came back empty, and that PAIR is worth a look | `noticeEmptyLookups` + `readLookupResult` + `EMPTY_LOOKUP_CEILING` (dial default OFF and needs a tool declaring `argumentsFrom` too — two halves; kind `empty-lookup` at seam `write`, always `advisory: true`; empty = a zero-length ARRAY or an `absent()` envelope, every other shape files `not-applicable` and no finding; the ceiling is quoted verbatim into every message) | `src/integrity/empty-lookup/` | 9.77.0 |
+| an agent answering a NEW question out of an OLD turn's tool results — grounded, four turns stale, and the evidence gate approving it (`Tool calls 0` and "all 7 values were found in what the tools returned"). ALSO the bug half: the gate's two sentences claimed the flagged values "appear in no tool result FROM THIS TURN" while its index walked every `role:'tool'` turn — a boundary asserted and never measured; both now say "no tool result this run read" | `noticePriorTurnEvidence` + `PRIOR_TURN_EVIDENCE_CEILING` + `priorTurnEvidenceOf` + `AnswerGroundingReading` (dial default OFF and needs `.namesAndNumbersFromEvidence()` too — two halves, and the second is structural: the gate owns the extractor that decides which tokens are values; kind `prior-turn-evidence` at seam `claim`, always `advisory: true`; `EvidenceCorpus.values` became a `Map<form, turn>` stamped in the walk that was already happening, a TURN = each `role:'user'` message `isLibraryAuthoredTurn` did NOT write (counting the gate's own correction would file against every revised answer); fires when ≥1 value is grounded and NOT ONE came from the turn being answered — ONE current-turn value files nothing, which is what keeps an honest follow-up quiet and is the design's falsification test; the zero-tool-call turn is the SAME kind with a stronger witness, not a second kind; corpus is the LIVE WINDOW so ordinals are window-relative and the distance is a FLOOR, while the boundary stays exact (`'current-request'` is un-droppable); memory/RAG values are exempt from grounding and invisible — it can under-report, never over-report; the ceiling is quoted verbatim into every message) | `src/integrity/prior-turn-evidence/` | 9.83.0 |
 | a tool's ROWS quietly disagreeing with what the tool promised — a LUN 0 stored as `""` because it is falsy, a numeric column arriving as quoted strings, a declared column present in no row at all | `Tool.resultColumns` + `checkColumnTypes` + `COLUMN_TYPE_CEILING` + `readRowset` (dial `'off'` (default) / `'warn'` (file findings, model reads the rows unchanged) / `'enforce'` (refuse the rows, `resultCeiling`'s teaching-sentence idiom, delivered status `'invalid'`) — the `toolArgsValidation` trio, this seam's mirror; needs a tool declaring `resultColumns` too — two halves; types `number`/`string`/`boolean`/`date`, bare word or `{type, nullable}`, deliberately NO `'unknown'`; OPEN — unlisted columns allowed and unjudged; TWO kinds at seam `write` — `column-type-mismatch` (there, wrong type) vs `missing-column` (declared, in no row); rowset = an ARRAY OF PLAIN OBJECTS with ≥1 row, everything else incl. the ZERO-ROW result files `not-applicable` (empty is `empty-lookup`'s subject); travels MCP `_meta`; the ceiling is quoted verbatim into every message) | `src/integrity/column-types/` | 9.78.0 |
 | a model head-mathing a total from tool-result numbers while a compute tool sits unused on the wire — a LATE line each iteration naming the staged refs and the `wants` tool that spends them (recency working FOR the instruction), plus the revise correction naming the same route | `nudge: true` (default off) + `stagedRefsNudgeLine` + `findStagedRefs` + `grounding_nudged` | `src/core/agent/stagedRefs.ts` | 9.75.0 |
 | a tool answering "I looked and found nothing", routably | `absent` + `looked_for` + `checked`/`not_checked`/`cannot_cover` + `tryInstead` (delivered status `'absent'`, routable by `onToolStatus`) | `src/core/agent/coverage/absent.ts` | 9.43.0 |

package/README.md

@@ -121,7 +121,7 @@ This is the step that makes "the test run and the production run are the same co
 
 `ollama()` talks Ollama's native API directly, so there's nothing to install on this side, streamed calls report real token counts (so `.compaction()` and cost budgets work), and when it can't work it says why in words that contain the fix — `ollama serve` when nothing is listening, `ollama pull <model>` when the model isn't there, never a raw connection error and never a hang.
 
-For llama.cpp's `llama-server`, vLLM, Together or Groq, use `openai({ baseURL: 'http://localhost:8080/v1', apiKey: 'not-needed', defaultModel: '…' })` — any server speaking the OpenAI Chat Completions API, same `Agent` code either way. Full recipes: [Ollama guide](https://footprintjs.github.io/agentfootprint/docs/build/ollama/) · [OpenAI-compatible endpoints](https://footprintjs.github.io/agentfootprint/docs/build/openai/#openai-compatible-endpoints-ollama-llamacpp-vllm-together-groq-lm-studio).
+For llama.cpp's `llama-server`, vLLM, Together or Groq, use `openai({ baseURL: 'http://localhost:8080/v1', apiKey: 'not-needed', defaultModel: '…' })` — any server speaking the OpenAI Chat Completions API, same `Agent` code either way. Full recipes: [Ollama guide](https://agentfootprint.dev/docs/build/ollama/) · [OpenAI-compatible endpoints](https://agentfootprint.dev/docs/build/openai/#openai-compatible-endpoints-ollama-llamacpp-vllm-together-groq-lm-studio).
 
 ### Then add context
 
@@ -591,7 +591,7 @@ const reflexion = Loop.create()
 | 2 | 12 tools shown | **5 tools** (skill activated) |
 | 3 | 12 tools shown | 5 tools |
 
-> 📖 [Dynamic ReAct guide](https://footprintjs.github.io/agentfootprint/docs/build/dynamic-react/) · [Key concepts](https://footprintjs.github.io/agentfootprint/docs/getting-started/key-concepts/)
+> 📖 [Dynamic ReAct guide](https://agentfootprint.dev/docs/build/dynamic-react/) · [Key concepts](https://agentfootprint.dev/docs/getting-started/key-concepts/)
 
 ### Multi-agent — compose with the alphabet
 
@@ -635,7 +635,7 @@ The patterns the field knows reduce to the same alphabet:
 
 Same trick as the injection model: instead of N libraries for N patterns, we found the M building blocks all N patterns are made of.
 
-> 📖 Compare: [hand-rolled vs declarative](https://footprintjs.github.io/agentfootprint/docs/getting-started/why/) · [migration from LangChain / CrewAI / LangGraph](https://footprintjs.github.io/agentfootprint/docs/getting-started/vs/)
+> 📖 Compare: [hand-rolled vs declarative](https://agentfootprint.dev/docs/getting-started/why/) · [migration from LangChain / CrewAI / LangGraph](https://agentfootprint.dev/docs/getting-started/vs/)
 
 ### Check in with the receipts — human-in-the-loop consent for consequential actions
 
@@ -663,7 +663,7 @@ Run the flagship demo — an AI coworker that drafts a weekly status doc and che
 npm run example examples/features/34-checkin-coworker.ts -- --decline
 ```
 
-See the [Check-in guide](https://footprintjs.github.io/agentfootprint/docs/monitor/checkin/).
+See the [Check-in guide](https://agentfootprint.dev/docs/monitor/checkin/).
 
 ### Act — everything your agent does about its own loop, in one block
 
@@ -697,7 +697,7 @@ It is pure sugar over the five individual doors, pinned byte-equivalent per key
 npm run example examples/features/38-act.ts
 ```
 
-See [The moments of the loop](https://footprintjs.github.io/agentfootprint/docs/build/loop-moments/).
+See [The moments of the loop](https://agentfootprint.dev/docs/build/loop-moments/).
 
 ### Watch — who is looking while it does
 
@@ -774,7 +774,7 @@ answers at the cheap model's price inside the expensive conversation.
 [`08`](examples/observability/08-self-explain.ts) · the doors walk the
 [**same evidence the board visualizes ▶**](https://footprintjs.github.io/agentThinkingUI/demo/backtrack.html).
 
-> 📖 Powered by [footprintjs `causalChain()`](https://footprintjs.github.io/footPrint/blog/backward-causal-chain/) — backward thin-slicing on the commit log. [Causal memory deep dive](https://footprintjs.github.io/agentfootprint/docs/debug/causal-deep-dive/) · [Explainability & compliance](https://footprintjs.github.io/footPrint/blog/explainability-compliance/)
+> 📖 Powered by [footprintjs `causalChain()`](https://footprintjs.github.io/footPrint/blog/backward-causal-chain/) — backward thin-slicing on the commit log. [Causal memory deep dive](https://agentfootprint.dev/docs/debug/causal-deep-dive/) · [Explainability & compliance](https://footprintjs.github.io/footPrint/blog/explainability-compliance/)
 
 **One recording. Two lenses. Three consumers. Zero extra instrumentation.**
 
@@ -898,7 +898,7 @@ The flowchart, recorders, and tests don't change between dev and prod.
 | `anthropic` | Claude (Sonnet, Opus, Haiku) via `@anthropic-ai/sdk` |
 | `openai` | GPT-4o, GPT-4-turbo via `openai` SDK |
 | `bedrock` | Claude / Titan / Mistral via AWS Bedrock runtime |
-| `gemini` | Gemini via `@google/genai` — two doors, **Vertex** (project + ADC) or the Gemini API (one key). Not every door/model pair works: read the [door/model matrix](https://footprintjs.github.io/agentfootprint/docs/infrastructure/google-cloud/#the-doormodel-matrix) first |
+| `gemini` | Gemini via `@google/genai` — two doors, **Vertex** (project + ADC) or the Gemini API (one key). Not every door/model pair works: read the [door/model matrix](https://agentfootprint.dev/docs/infrastructure/google-cloud/#the-doormodel-matrix) first |
 | `ollama` | Local models, over Ollama's native API — no SDK, no key, real token counts, refusals that name `ollama serve` / `ollama pull` · `openai({ baseURL })` reaches llama.cpp, vLLM, and any other OpenAI-compatible endpoint |
 | `browserAnthropic` | Browser-side Claude calls (no proxy server) |
 | `browserOpenai` | Browser-side OpenAI calls (no proxy server) |
@@ -916,7 +916,7 @@ The flowchart, recorders, and tests don't change between dev and prod.
 - Skill artifact vocabularies — a skill or a step declares `produces` / `consumes` (artifact kinds), and `graph.checkup()` warns `artifact-kind-unsatisfied` when nothing on the agent claims to make what a consumer needs. Honest by construction: a warning, never an error, because it reads declarations only and artifacts outlive the turn that made them
 - Human-in-the-loop pause / resume — a tool calls `pauseHere(...)` (or `askHuman(...)`); `isPaused(result)` hands you a JSON-serializable checkpoint, and `agent.resume(checkpoint, input)` continues hours later on a different server
 - Resilience primitives — `withRetry`, `withFallback`, `withCircuitBreaker`, `.outputFallback`, `agent.resumeOnError`
-- Context Integrity — deterministic checks at the seams where a run contradicts ITSELF: a tool parked but still on the wire, a tool offered after the results grounding it were evicted, an answer field that disagrees with the fact it claims to report (`.claims()`, requires `.outputSchema()`). Nothing is blocked or rewritten — each defect is one typed finding, and every run files a disposition ledger so "no findings" and "no check ran" stay different states. `integrityPosture: 'dev'` adds the liveness proofs (a start-of-run canary; `CheckerDeadError` instead of a green report from a checker that never ran). Read it back with `find_context_errors` over a recording — [Context Integrity](https://footprintjs.github.io/agentfootprint/docs/monitor/context-integrity/)
+- Context Integrity — deterministic checks at the seams where a run contradicts ITSELF: a tool parked but still on the wire, a tool offered after the results grounding it were evicted, an answer field that disagrees with the fact it claims to report (`.claims()`, requires `.outputSchema()`). Nothing is blocked or rewritten — each defect is one typed finding, and every run files a disposition ledger so "no findings" and "no check ran" stay different states. `integrityPosture: 'dev'` adds the liveness proofs (a start-of-run canary; `CheckerDeadError` instead of a green report from a checker that never ran). Read it back with `find_context_errors` over a recording — [Context Integrity](https://agentfootprint.dev/docs/monitor/context-integrity/)
 - 60+ typed observability events — `agent` · `composition` · `context` · `stream` · `tools` · `skill` · `memory` · `cache` · `cost` · `permission` · `eval` · `embedding` · `pause` · `error` · `fallback` · `resilience` · `reliability` · `risk`
 
 **Debugging & compliance** (`agentfootprint/observe`)
@@ -934,7 +934,7 @@ The flowchart, recorders, and tests don't change between dev and prod.
 
 </details>
 
-> 📖 [Agent API reference](https://footprintjs.github.io/agentfootprint/docs/api/classes/Agent/) · [CHANGELOG](./CHANGELOG.md)
+> 📖 [Agent API reference](https://agentfootprint.dev/docs/api/classes/Agent/) · [CHANGELOG](./CHANGELOG.md)
 
 ---
 
@@ -942,12 +942,12 @@ The flowchart, recorders, and tests don't change between dev and prod.
 
 | If you are... | Go here |
 |---|---|
-| New to agents | [5-minute quick start](https://footprintjs.github.io/agentfootprint/docs/getting-started/quick-start/) |
-| Coming from LangChain / CrewAI / LangGraph | [Migration guide](https://footprintjs.github.io/agentfootprint/docs/getting-started/vs/) |
-| Architecting an enterprise rollout | [Production guide](https://footprintjs.github.io/agentfootprint/docs/monitor/deployment/) |
-| Doing due diligence | [Architecture overview](https://footprintjs.github.io/agentfootprint/docs/reference/dependency-graph/) |
-| Researcher / academic background | [Citations & prior art](https://footprintjs.github.io/agentfootprint/docs/reference/citations/) |
-| Curious about design | [Inspiration docs](https://footprintjs.github.io/agentfootprint/docs/reference/inspiration/) |
+| New to agents | [5-minute quick start](https://agentfootprint.dev/docs/getting-started/quick-start/) |
+| Coming from LangChain / CrewAI / LangGraph | [Migration guide](https://agentfootprint.dev/docs/getting-started/vs/) |
+| Architecting an enterprise rollout | [Production guide](https://agentfootprint.dev/docs/monitor/deployment/) |
+| Doing due diligence | [Architecture overview](https://agentfootprint.dev/docs/reference/dependency-graph/) |
+| Researcher / academic background | [Citations & prior art](https://agentfootprint.dev/docs/reference/citations/) |
+| Curious about design | [Inspiration docs](https://agentfootprint.dev/docs/reference/inspiration/) |
 
 Or jump into the [examples gallery](https://github.com/footprintjs/agentfootprint/tree/main/examples) — every example is also an end-to-end CI test.
 

package/ai-instructions/claude-code/SKILL.md

@@ -309,7 +309,7 @@ if (!report.ok) throw new Error(formatCheckup(report));
 The full architecture of the skill graph — the three surfaces, the authority rule, the
 nine cursor causes, the three-way `read_skill`, and a worked refusal taken from a real
 run — is published as **Skill graph architecture**:
-<https://footprintjs.github.io/agentfootprint/docs/build/skill-graph-architecture/>.
+<https://agentfootprint.dev/docs/build/skill-graph-architecture/>.
 Every capability claim there carries a status — `shipped` / `opt-in` /
 `application-provided` / `planned` — and every code block is type-checked against the
 shipped types at build. Read it rather than this file when the question is "how does

package/dist/core/Agent.js

@@ -315,6 +315,10 @@ class Agent extends RunnerBase_js_1.RunnerBase {
     /** See AgentOptions.noticeEmptyLookups (9.77.0). Default false — absent is
      *  byte-identical, save for the registered not-applicable ledger row. */
     noticeEmptyLookups = false;
+    /** See AgentOptions.noticePriorTurnEvidence (9.83.0). Default false —
+     *  absent is byte-identical, save for the registered not-applicable ledger
+     *  row. */
+    noticePriorTurnEvidence = false;
     /** Set at chart build: whether any tool in the FULL declared catalog
      *  declared `resultColumns` (9.78.0) — the other half of the column-type
      *  contract's arming. */
@@ -682,6 +686,22 @@ class Agent extends RunnerBase_js_1.RunnerBase {
             }
             this.noticeEmptyLookups = opts.noticeEmptyLookups;
         }
+        // The claim seam's recency dial (9.83.0) — refused at construction for
+        // the same reason as the write-seam one above: a truthy non-boolean here
+        // would silently arm a check the author only half asked for, and the
+        // arming is what decides whether a run is byte-identical to the one
+        // before it.
+        if (opts.noticePriorTurnEvidence !== undefined) {
+            if (typeof opts.noticePriorTurnEvidence !== 'boolean') {
+                throw new Error(`Agent: noticePriorTurnEvidence must be a boolean, got ` +
+                    `${JSON.stringify(opts.noticePriorTurnEvidence)}. It arms the claim-seam ` +
+                    `'prior-turn-evidence' advisory — a final answer whose every value was last served ` +
+                    `before this turn — and it needs \`.namesAndNumbersFromEvidence()\` armed beside ` +
+                    `it, because that gate owns the extractor that decides which tokens are values. ` +
+                    `Omit it (or pass false) and no such advisory is ever filed.`);
+            }
+            this.noticePriorTurnEvidence = opts.noticePriorTurnEvidence;
+        }
         // The column-type contract's dial (9.78.0) — refused at construction for
         // the same reason as the postures above, and with one more: `'enforce'`
         // REFUSES tool results, so a misspelling silently downgraded to off would
@@ -2389,6 +2409,12 @@ class Agent extends RunnerBase_js_1.RunnerBase {
             // AND a tool declaring `resultColumns`. Either alone leaves two
             // registered `not-applicable` rows.
             columnTypes: this.checkColumnTypes !== 'off' && this.integrityColumnsPresent,
+            // TWO HALVES (9.83.0), and here the second is structural rather than
+            // a policy choice: the evidence gate owns the extractor that decides
+            // which tokens in an answer are values, so a dial with no gate has
+            // nothing whose provenance it could read. Either alone leaves a
+            // registered `not-applicable` row.
+            priorTurnEvidence: this.noticePriorTurnEvidence && this.evidenceGate !== undefined,
         }, this.integrityPosture);
     }
     /**
@@ -3267,7 +3293,13 @@ class Agent extends RunnerBase_js_1.RunnerBase {
         // question a build-time mount can answer.
         const canCallTools = registryByName.size > 0 || this.externalToolProvider !== undefined;
         const hasWrapUp = canCallTools && this.wrapUpAtMaxIterations !== false;
-        const routeDecider = (0, route_js_1.buildRouteDeciderStage)(this.messageMiddleware, this.outputEnforcement, stepPlanFor, this.evidenceGate, hasWrapUp, this.claimContract, this.integrityLedgerHolder);
+        const routeDecider = (0, route_js_1.buildRouteDeciderStage)(this.messageMiddleware, this.outputEnforcement, stepPlanFor, this.evidenceGate, hasWrapUp, this.claimContract, this.integrityLedgerHolder, 
+        // THE CLAIM SEAM'S RECENCY READ (9.83.0). Value-conditional on both
+        // halves, so an agent that armed neither hands the decider builder
+        // exactly the arguments it always did — and `buildRouteDeciderStage`'s
+        // no-judge fast path still returns the very function reference every
+        // pre-9.83.0 chart was given.
+        this.noticePriorTurnEvidence && this.evidenceGate !== undefined ? true : undefined);
         // toolCallsHandler extracted to ./agent/stages/toolCalls.ts (v2.11.2).
         const toolCallsHandler = (0, toolCalls_js_1.buildToolCallsHandler)({
             registryByName,