Skip to content

Local-first 🧠 memory for Hermes Agent that lives in your Obsidian vault and remembers project context. Nightly 😴 dream passes turn repeat corrections into confirmed preferences with measurable confidence. Adapters ship for Claude Code, Codex, and OpenClaw, with an MCP server for anything else.

TypeScript
31.7 KB
Raw Blame

Truth-correctable, time-aware claims - validity windows, windowed recall, grounded agent-stated claims, a correct verb, and guaranteed serve-with-correction

Status: draft Author: feature-release orchestrator (via feature-release-playbook) Audience: implementation

Problem statement

The Open Second Brain truth ledger keys every comparison on assertion time: a 2024-dated claim ingested today still reads as a fresh contest against a 2026 claim, because ClaimEvent carries no validity window and the conflict scanner measures pure assertion-time distance. Recall cannot window claim events at all, agent-stated claims cannot ground into the ledger with per-claim verdicts, no correction verb exists anywhere, and no serving surface guarantees that a retired claim is served together with its correction. The multi-hop recall arm has no width bounds, no hub handling, no ordered path provenance, and nothing pins direct-hit precedence.

Scope

  • Optional per-claim validity fields (validFrom/validUntil) on ClaimEvent, AppendClaimInput and ClaimVersion, presence-gated under TRUTH_SCHEMA_VERSION = 1, with parsing reused from the existing validity discipline.
  • A succession channel beside the conflicts array: a separate, optional TruthState.successions field, never a new conflict kind; ask_user semantics, hygiene findings and priority ranking untouched.
  • Ingest window defaults: explicit input wins; otherwise ingest resolves the window from the source record's frontmatter validity when that source is readable at ingest, storing the frozen resolved value.
  • A dedicated events operation on brain_truth (plus a CLI subcommand) with since/until/entity/limit, leaving today's slots response untouched entirely; rows carry validity fields verbatim and are reach-gated per row.
  • Grounded agent-stated claims as ledger events with the agent_stated extractor tag and per-claim verdicts: grounded claims commit, ungrounded claims are reported back with reasons.
  • A single correct verb (MCP action on brain_lifecycle, CLI subcommand on brain lifecycle) sweeping discovery, per-target retirement, mention retargeting and receipt bundling, with per-target end-state policy and a fail-recorded, idempotent, bundle-correlated receipt sequence.
  • Deepened relational traversal with width caps (8 seeds, 4 per node, 16 total nodes), hub skipping by typed-edge degree, deadline bounding, entity-bridge edges over chunk_entities, and ordered per-node reach-gated path provenance.
  • Structural direct-hit precedence with a pinning test reconciled against the promote-never-sink rerank pin.
  • A shared serve-with-correction coupling predicate consumed by every serving surface (search pool and post-rank, recall by topic, context-pack, active.md, dream), fail-closed on unresolved or out-of-reach successors.
  • Documentation updates (README, docs/architecture.md agent-scope-matrix equality, plugin mirrors via bun run sync-plugin-mirrors).

Out of scope

  • Claim-edge composition over grounded object-entity linking: deferred to the next wave. The contract names the future edge source (claim/entity edges derived from sub-suite A's grounded agent_stated events joined through the entity registry) and its enablement gate (grounded claims accumulated in live data, object-entity linking landed). Traversal over edges with no live data cannot earn its budget.
  • Self-mined relation templates: the accept-gate design is its own card; no data exists until grounded claims accumulate.
  • A tombstone/supersede op type in the write batch: the sweep runs as a fail-recorded sequence this wave, not as one Kernel 2 batch.
  • A --since-last-run polling cursor on the truth ledger: tail-following stays consumer-side; ascending order plus limit gives a resumable slice.
  • Provenance re-weighting of conflict priority: this wave the agent_stated tag is annotation only; it never changes which pairs contest and never re-ranks conflict priority.
  • The assertion-time sibling consumers collision.ts (14-day convergence) and grounding.ts (30-day contest balance) stay assertion-keyed, documented at their constants.
  • Turning the relational arm default-on: enablement stays relationalArmEnabled plus rrf fusion; byte-identical off behavior is preserved by construction.

Chosen approach

Variant 3, Two Sub-Suites over a Pinned Contract, is accepted as recommended by the consultant with no orchestrator override. The wave splits into two sequenced sub-suites joined by a small, test-pinned contract. Sub-suite A (temporal truth) delivers the ledger validity fields with the succession channel, the windowed events surface, and grounded agent-stated claims as ledger events. Sub-suite B (correction and recall) delivers the correct verb, the deepened traversal with direct-hit precedence, and the coupling invariant, consuming A only through the contract. The contract pins exactly the three genuinely cross-card decisions - the axis precedence rule with the windowed event shape, the correction record-state policy, and the coupling-invariant statement - and nothing else. This keeps each sub-suite's blast radius bounded and reviewable as one unit while still delivering the wave's novel invariants that a five-narrow-cards reading would defer, and unlike a fully coupled kernel-first wave it does not concentrate ledger schema, write-path and five-surface serving risk in one release.

Design decisions

  1. The assertion-versus-validity axis is contract item 1, stated once. A same-slot pair (same canonical entity and aspect) classifies as succession, not contest, if and only if both claims carry present validity windows and the windows do not intersect. Everything else - either claim windowless, or windows intersecting - keeps today's assertion-time behavior verbatim: 30-day CONFLICT_WINDOW_DAYS distance, different-source requirement, kind: "value_conflict", resolution: "ask_user". An expired window never suppresses contestation on its own: a windowed claim whose window has passed still contests under the fall-through. Rationale: this preserves the pinned byte-identical windowless path (conflicts.ts:83 returns the base fold unchanged; tests/core/brain/truth/conflicts.test.ts pins "without conflicts the state matches the base fold exactly" and the bit-identical neutral default), answers the validator's pinned semantic decision explicitly, and keeps succession outside ask_user semantics so hygiene findings and priority ranking stay untouched.

  2. Succession surfaces as a separate channel, not a conflict kind. TruthState gains readonly successions?: ReadonlyArray<ClaimSuccession> - optional and presence-gated, set only when non-empty, serialized with the conditional-spread pattern from store.ts:128-138 so every windowless line, fold, state file and conflict result stays byte-identical. fold.ts is untouched; the succession pass lives in the policy layer (conflicts.ts plus a new succession.ts sibling), matching the existing policy-over-fold shape. TruthConflictKind gains no member, so ask_user semantics, the hygiene detector and conflict priority are structurally unreachable from succession code. Rationale: a new conflict kind would drag succession into dispute machinery built for ask_user; an optional channel adds read-side tolerance for an absent field instead.

  3. Window defaults are explicit-input-first, frozen-at-ingest. CLI flags --valid-from/--valid-until and declared optional MCP ingest fields win outright. Absent input, ingest resolves the window from the source record's frontmatter valid_from/valid_until when the source is readable at ingest (the first rung of the EventTimeResolver order; no mtime fallback - an mtime is an assertion-time proxy, not validity). The resolved value is stored frozen on the event; never a live reference. If the source is unreadable or windowless, the event is stored windowless and behaves byte-identically to today. Rationale: scan time never reads the vault, the ledger stays self-contained, and the freeze is contract text so A and B cannot reinterpret it.

  4. One interval convention inside the truth layer: half-open. Ledger windows use [validFrom, validUntil) with isValidAt semantics from lifecycle/temporal-replace.ts, reusing ValidityBounds. Values parse with the search/validity.ts discipline (bare dates day-snapped, datetimes, never relative phrases) - no second grammar. The events operation's since/until are a different vocabulary: they filter assertion ts only, through the shared time-range.ts grammar with its inclusive day-edge semantics. Both schema descriptions state their convention explicitly so the two temporal vocabularies stay unambiguous inside one response.

  5. Windowed recall is a dedicated events operation, not a slots filter. brain_truth gains operation: "events" with entity (optional, normalized, composing), since, until, limit; the CLI gains o2b brain truth events with the same arguments, matching the existing CLI-over-MCP op asymmetry (sweep precedent). Today's slots response is untouched entirely, so every existing consumer stays byte-identical by construction - events in the slots/conflicts responses remains the count pinned by tests/mcp/brain-truth.test.ts:96. The events response is { ok: true, operation: "events", entity: string | null, events: ClaimEventRow[], total: number, withheld: number, truncated: boolean } where ClaimEventRow is the stored event with validity fields verbatim. Ordering is stable ascending assertion ts (the readClaimEvents order), which makes tail-follow pagination an advancing since. Default limit DEFAULT_EVENT_LIST_LIMIT = 200, hard cap CLAIM_EVENT_MAX_LIST_LIMIT = 1000, truncated set when more rows matched. Bounds are resolved through the shared grammar and floored/ceiled to the second (eventsWindowBounds in the new events-window.ts), exact against second-precision stamps via string compare. Every row passes the same per-row visibility/reach gate brain_claims uses; rows dropped by the gate are counted in withheld so a remote caller sees deterministic output and a withheld page stays indistinguishable from an absent one. Rationale: this is the corrected mechanics from the premise verification - events as a name is taken by the count, and the card's "filter the returned events" reading was false because no events were ever returned.

  6. Agent-stated claims land as ledger events with per-claim verdicts. A stated claim is { subject, relation, object } plus assertion text, source and optional agent. It commits as one ClaimEvent with entity = normalized subject, aspect = the relation token (validated against the single relation vocabulary boundary, isKnownRelation), value = object display form, and extractor: "agent_stated" (new optional field on ClaimEvent/AppendClaimInput, tolerated by coerceClaim under schema v1). Grounding uses the one existing occurrence kernel: a pure anchorEntityForms export lifted from atomic-facts.ts (quality-gated normalized match forms, minimum length 3); subject and object must be anchored in text or the claim is reported back, not committed. Naming deliberately avoids "grounding", which is taken by the source-diversity score in truth/grounding.ts; the new module and verdicts speak of anchoring. Refuse-before-write still governs the payload boundary: an unknown relation, missing text or missing source refuses the whole call with nothing written; per-claim partial commit applies only to the anchoring verdict, which is safe because each event is an independent append in an append-only ledger and the response reports exactly what landed - the first partial-commit lane in this subsystem, justified by the verdict contract. Rationale: this is the store mapping that makes provenance visible to conflict detection without touching contestingValues; the tag is additive annotation on conflict rows this wave.

  7. The correction end-state policy is contract item 2, one pure function. src/core/brain/truth/correction-policy.ts pins: correctionEndState(input: { flatlyWrong: boolean; windowEnd?: string }, correctionTs: string): { endState: "validity_close" | "tombstone"; validUntil: string | null }. A flatly-wrong claim tombstones (hidden; the coupling invariant is vacuous for it, which is correct - nothing surfaces, correction included). Every other correction closes validity at windowEnd when time-scoped, else at the correction instant: the predecessor stays serveable inside its historical window, which is the only regime where serve-with-correction is non-trivial. The choice is recorded per target in the bundle receipt using the existing receipt reason codes (supersede for validity_close, tombstone for tombstone - name-aligned CLI verb, MCP action, receipt code). Succession logic consumes the policy's outcome through the ledger data (a validity-closed predecessor against its successor has non-overlapping present windows and classifies as succession under contract item 1); path-provenance annotation reads the same frontmatter outcome. Rationale: the recon showed supersede()-only sweeps make coupling vacuous for their own outputs because tombstoned means hidden; per-target choice keeps both regimes honest and answers the fork the card never surfaced.

  8. The sweep is validate-all dry-run, then fail-recorded, no batch op. brain_lifecycle correct (MCP action) and o2b brain lifecycle correct (CLI verb) gather the affected set within the caller's reach: the claim-graph closure (whatReplaced chain tip plus whatContests), a full-vault match-only wikilink mention scan via retargetWikilinks with apply: false (the counting pass asserts no vault identity), and same-entity/aspect truth-ledger claims. Dry-run returns the blast-radius report and writes nothing. Applied runs a fail-recorded sequence reusing retargetWikilinks' per-write failure carry: per-target retirement through the end-state policy, mention retargeting, per-record receipts via appendDecisionChangeReceipt with the bundle id carried in evidence_triggers as correction_bundle:<bundleId> (the receipt schema stays closed). For ledger claims, the correction appends a new event asserting the corrected value from the successor's source - same-source value change reads as self-correction in the fold (conflicts.ts:36-44), never a conflict. Replay converges: tombstone is a byte-identical no-op on replay, receipts return appended: false, an already-closed window stays closed. Brain/log and receipt lines are never rewritten (testimony). Rationale: fail-recorded matches the retargetWikilinks precedent and avoids a first-of-kind batch op type in the same wave that introduces the underlying data.

  9. The coupling invariant is contract item 3, one predicate, every surface. src/core/search/correction-coupling.ts pins couplingVerdict(input: { predecessorPath: string; successorPath: string | null; successorReadable: boolean }): CouplingVerdict with CouplingVerdict = { action: "serve_coupled"; correctionPath: string } | { action: "drop" }. A retired-but-serveable row (validity-closed predecessor inside its window, or superseded non-tip still serveable) is served only when its chain-tip correction is resolved and readable at the caller's reach; otherwise the row is dropped fail-closed, so a withheld page stays indistinguishable from an absent one. Content pulled in as a correction re-runs the full filter set - status, visibility scope, agent scope, reach - closing the recorded gap at post-rank.ts:142-168 where polarity-pulled successors bypass visibility and agent scope. The predicate replaces the search pipeline's best-effort polarity branch for retired rows and is consumed by recall by topic, context-pack, active.md and dream scan, replacing today's hide-or-annotate split with one rule. Tombstoned rows stay dropped by the status filter everywhere; the predicate governs the serveable-retired regime only. Rationale: the recon verified the partial coupling exists in search only, is best-effort, and is void for tombstoned predecessors - the genuinely missing property is the guarantee across surfaces, which needs exactly one predicate to be testable.

  10. Traversal budgets are named constants with config override; hub is degree, never prose. relationalFanout gains TRAVERSAL_MAX_SEEDS = 8, TRAVERSAL_MAX_EXPANSION_PER_NODE = 4, TRAVERSAL_MAX_TOTAL_NODES = 16, and hub detection: a node whose walked-edge degree (typed edges plus entity bridges) exceeds TRAVERSAL_HUB_DEGREE_THRESHOLD = 12 is reached but not expanded. All four are overridable through OPEN_SECOND_BRAIN_SEARCH_TRAVERSAL_* config following the parseBool(envOrConfig(...)) pattern. The walk stays deadline-bounded by accepting a deadline parameter; on a fired clock the frontier is abandoned deterministically and already-reached nodes are kept. Depth stays 2 by default. Rationale: the arm today has no width bound at all - every query wikilink is a seed and every typed edge of every frontier document is followed; upstream's 8/4/16 budgets are the copied precedent, and deadline bounding is required because recall phases run under a composite deadline.

  11. Entity bridges from chunk_entities, behind their own flag. A new store reader entityBridgesForDocuments (new file src/core/search/store/entity-bridges.ts) joins the chunk_entities table so two documents mentioning one normalized entity get a bridge edge labeled entity. Bridges are walked by the deepened arm when enabled (OPEN_SECOND_BRAIN_SEARCH_ENTITY_BRIDGES, default true, read only when the arm itself is enabled); they are machine-derived, not part of the query edge-type vocabulary, so parseRelationalQuery validation is unaffected and attribution renders them as via entity. Rationale: this is the chunk_entities half of the corrected scope - document typed relations plus entity co-occurrence now, while claim-edge composition over grounded linking waits for live data.

  12. Direct-hit precedence is structural admission plus a tightened rerank pin. Relational-only rows (absent from the organic candidate set) are admitted after the last organic row in the pre-rerank fused order, and the rerank pin for relational-origin rows is tightened: a relational-origin row may move within the relational block and may never sink below its pre-rerank position relative to other relational rows, and may never cross above an organic direct hit. The two pins coexist and are both test-pinned. Rationale: the recon showed nothing pins precedence today - neutral RRF weight 1 lets a relational-only rank-1 row outrank a keyword-rank-20 direct hit - and a sub-neutral lane weight would perturb all fusion globally, while admission is local to the arm's rows and reconciles cleanly with promote-never-sink.

  13. Ordered path provenance is per-node reach-gated and frontmatter-annotated. RelationalReach gains an ordered path of { documentId, relation } steps; only nodes readable at the caller's reach appear (per-node gating, the brain_derive_fact premise-gate precedent), and the attribution reason renders withheld hops as a count (relational: via <types> (<n> hops, <k> nodes withheld)). The machine-readable ordered path lands in the typed retrieval-trail vocabulary as a new stable code carrying readable document ids plus the withheld count - additive reason strings stay human provenance, the trail stays typed. When a readable path node is a non-tip superseded predecessor whose window has closed, the row is annotated superseded_by: <tip> through the record-state policy's frontmatter outcome - search reads frontmatter only, never the ledger, keeping the search-to-ledger coupling at zero.

  14. The arm's enablement story does not change. The deepened traversal rides the existing relationalArmEnabled (default false) plus rrf-fusion gates. Byte-identical off behavior holds by construction: with the arm off, fusion, ranking, attribution and the coupling predicate's search wiring see unchanged inputs. Rationale: flipping a default-on in the same wave as the coupling change would silently re-rank every stock deployment; enablement is an explicit operator choice documented by the docs lane.

  15. Schema-version discipline: optional fields stay under version 1. validFrom, validUntil and extractor are optional, presence-gated fields tolerated by coerceClaim and serialized by conditional spread. The read/write matrix: a new binary reads old lines (fields absent) and new lines (fields present, validated when present); an old binary reads new lines, ignores unknown keys, and behaves on the assertion-time axis exactly as today - state files carry successions only when non-empty, and old binaries' strict state validators treat the derived cache as recomputable (readTruthState reads null on structural mismatch and the caller refolds from events). No version bump, no migration.

  16. One operator concept correct, no new MCP tool. The verb extends brain_lifecycle with a correct action and the CLI lifecycle verb with a correct subcommand. The agent-scope-matrix equality keeps its tool count and gains the recipe rows for the new action; the test equality and docs/architecture.md classification move together (implementation lane updates the test, docs lane updates the document and regenerates mirrors). Rationale: a new brain_correct tool would grow the matrix tool count for a concept that is lifecycle retirement plus provenance, which brain_lifecycle already owns.

File changes

New files:

  • src/core/brain/truth/validity.ts - window parsing, intersection test, claimWindow, eventsWindowBounds helpers (lane 1).
  • src/core/brain/truth/succession.ts - succession classification over slot versions (lane 1).
  • src/core/brain/truth/stated-claims.ts - stated-claim validation and anchoring verdicts (lane 1).
  • src/core/brain/truth/correction-policy.ts - contract item 2, the end-state policy (lane 1).
  • src/core/brain/truth/events-window.ts - pure windowed event selection and second-precision bounds (lane 2).
  • src/mcp/brain/time-bounds.ts - shared SearchError-to-INVALID_PARAMS wrapper over resolveTimeRange (lane 2).
  • src/core/brain/lifecycle/correction.ts - correct-verb discovery, retirement and receipt bundling (lane 3).
  • src/core/search/correction-coupling.ts - contract item 3, the coupling predicate (lane 3).
  • src/core/search/store/entity-bridges.ts - chunk_entities bridge-edge reader (lane 4).
  • Tests: tests/core/brain/truth/validity.test.ts, tests/core/brain/truth/succession.test.ts, tests/core/brain/truth/stated-claims.test.ts, tests/core/brain/truth/correction-policy.test.ts (lane 1); tests/core/brain/truth/events-window.test.ts, tests/mcp/time-bounds.test.ts (lane 2); tests/core/brain/lifecycle/correction.test.ts, tests/core/search/correction-coupling.test.ts, tests/core/search/post-rank-coupling.test.ts, tests/core/brain/coupling-surfaces.test.ts, tests/mcp/brain-lifecycle-correct.test.ts (lane 3); tests/core/search/relational-path.test.ts (lane 4); tests/contract/serve-with-correction.test.ts (integrator).

Modified files:

  • src/core/brain/truth/types.ts, src/core/brain/truth/store.ts, src/core/brain/truth/conflicts.ts, src/core/brain/truth/ingest.ts, src/core/brain/atomic-facts.ts (export the anchoring kernel), tests/core/brain/truth/store.test.ts, tests/core/brain/truth/conflicts.test.ts, tests/core/architecture/visibility-surface-census.test.ts (lane 1).
  • src/mcp/brain/knowledge-tools.ts, src/mcp/brain/recall-tools.ts, src/cli/brain/verbs/truth.ts, tests/mcp/brain-truth.test.ts, tests/cli/brain-truth.test.ts (lane 2).
  • src/mcp/brain/lifecycle-tools.ts, src/cli/brain/verbs/lifecycle.ts, src/core/search/pipeline/post-rank.ts, src/core/brain/query.ts, src/core/brain/context-pack.ts, src/core/brain/active.ts, src/core/brain/dream-scan.ts, tests/mcp/agent-scope-matrix.test.ts (lane 3).
  • src/core/search/relational-fanout.ts, src/core/search/pipeline/relational-arm.ts, src/core/search/fusion.ts, src/core/search/ranker.ts, src/core/search/pipeline/attribution.ts, src/core/search/retrieval-trail.ts, src/core/search/index.ts, tests/core/search/relational-fanout.test.ts, tests/core/search/relational-arm.test.ts, tests/core/search/fusion.test.ts (lane 4).
  • README.md, docs/architecture.md, regenerated plugin mirrors under plugins/codex/ (docs lane).

Risks and open questions

  • Contract drift. The contract is new surface; a weak or stale contract would let the sub-suites drift exactly where they must not. Mitigation: all three items are pure modules with named test files committed by lane 1 and lane 3 first, and the integrator owns the cross-suite pinning test tests/contract/serve-with-correction.test.ts.
  • Partial-commit precedent. Per-claim commit for stated claims is the first partial-commit write lane in the subsystem. The verdict contract keeps it honest: the payload boundary still refuses whole calls, only anchoring verdicts are per-claim, and the response reports exactly what landed.
  • Entity-bridge noise. chunk_entities bridges can connect popular entities across unrelated documents. Mitigation: hub skipping by degree, width caps, and a dedicated flag to disable bridges independent of the arm.
  • Forward/backward compatibility. Old binaries reading new lines ignore unknown keys and stay on the assertion-time axis; a mixed-device vault therefore shows axis behavior per device until all devices upgrade. Acceptable for a derived, recomputable cache and append-only events; noted here so it is a documented property, not a surprise.
  • Sweep blast radius. A wrong target selection could retire many records. Mitigation: dry-run-first is the default UX, retarget is match-only and never rewrites code spans or Brain/log, receipts are per-record and idempotent, and the counting pass asserts no vault identity.
  • Open during implementation. The exact hub threshold value (12) and the entity-bridge default may need tuning against a real corpus; both are named constants with config override so tuning does not change code shape. The retrieval-trail code name for the ordered path is finalized in review against the existing stable-code vocabulary.

Premise verification

Verdicts below come from the premise-verification recon reports, which are authoritative over the card bodies. The recons confirmed two cards as stated and corrected three; each corrected card's scope in this design follows the corrected scope, not the card text.

t_edba0c15 - Per-claim temporal validity windows feeding conflict-vs-succession: CORRECTED

The gap is real but narrower and differently seated than the card implies: the conflict scanner genuinely has no validity axis and keys purely on assertion time (ingest-order dependence confirmed reproducible), but per-claim windows, a point-in-time query and a succession-aware claims view already exist on the sibling claim-graph layer, and the card's claims-table-view half is already at parity (brain_claims / o2b brain claims already render windows, provenance, supersession and tombstone status). Corrected scope adopted: (a) optional validFrom/validUntil on ClaimEvent/AppendClaimInput/ClaimVersion with presence-gated serialization under schema v1; (b) window defaults resolved from the source record's event time, frozen at ingest; (c) the conflict policy layer extended so two same-slot claims with non-overlapping present windows classify as succession while the windowless path stays byte-identical and succession stays outside ask_user semantics; (d) the precedence rule stated explicitly as contract item 1. The claims-table half is dropped as present parity; the one missing extractor column belongs to t_3e87656b's agent_stated tag.

t_cb7ff437 - Windowed entity-fact recall: since/until on brain_truth slots: CORRECTED

The gap is real (no since/until anywhere on the truth-ledger recall surface; the strict grammar is reusable), but the card's central reading was false: the slots response has never carried claim-event rows - events in that response is a count, pinned by test - so the feature necessarily extends the response shape or adds an operation, and the validator's either/or ("filter the events fed to the fold" versus "filter the returned events") is moot. Corrected scope adopted: a dedicated operation: "events" on brain_truth plus a CLI subcommand, leaving today's slots response untouched entirely so existing consumers stay byte-identical by construction; stable ascending order, named default limit, inclusive day-edge semantics inherited from the shared grammar, rows reach-gated per row, validity fields passed through verbatim, and the schema description stating that since/until filter assertion ts only. The fold stays whole: conflicts and current truth keep being computed over the full event set.

t_c37af4e9 - Multi-hop recall across claim/entity chains with bounded fan-out and path provenance: CORRECTED

The validator's resolution is confirmed - a bounded multi-hop lane exists and the card is a present_weaker extension of it - with two parity fixes the design respects: the relational arm is doubly opt-in (default-off and rrf-only, so unconditionally extending it ships to no one), and direct-hit precedence is NOT an existing guardrail (neutral RRF weight 1 lets a relational-only row outrank a direct hit; no test pins precedence). Corrected scope adopted: width caps (8 seeds, 4 per node, 16 total) and hub skipping by typed-edge degree as new work with named constants and config override; direct-hit precedence as a new structural mechanism (admission below the last organic row plus a tightened rerank pin) with a pinning test; ordered-path provenance with per-node reach gating; traversal over document typed relations plus chunk_entities entity bridges now; claim-edge composition over grounded object-entity linking deferred to the next wave behind the enablement sub-suite A ships, with the contract naming the future edge source and its gate; the arm's default-off enablement unchanged.

t_cabe84aa - Single correct-this-fact verb with served-only-with-correction coupling: CONFIRMED

Confirmed: the preservation half is at parity as claimed, no single correction verb exists anywhere in src/ or tests/, and no serving surface guarantees a retired claim is served coupled with its correction. Two refinements verified and folded in: a partial best-effort coupling already exists in the search pipeline only (relation polarity demotes a non-tombstoned predecessor and pulls in a resolved successor; unresolved leaves the predecessor served bare; topic recall, context-pack, active.md and dream have no analogue), and the trust.replacement pointer is opt-in, not unconditional. The design's novelty is the guaranteed cross-surface coupling (contract item 3) and the per-target end-state policy (contract item 2) the card never surfaced: supersede-only sweeps make coupling vacuous for their own outputs because tombstoned means hidden.

t_3e87656b - Agent-stated claims with mechanical grounding, provenance-based conflict detection, self-mined relation templates: CONFIRMED

Confirmed: all three gaps are real (no occurrence-grounded declared-claim path, no provenance-aware conflict detection, no relation-template learning). One inventory correction adopted: the closer existing path is the typed extraction intake (extract-intake.ts), not only derived-fact.ts, and the one existing occurrence-in-text kernel is anchorEntities in atomic-facts.ts - both are the extension points this design uses. Scope within this wave: agent-stated claims land as ledger events with the agent_stated extractor tag and per-claim anchoring verdicts; provenance is annotation only and never changes which pairs contest (the ask_user resolution stays pinned); the intake-relation bridge is contract-named and deferred with object-entity linking; relation-template learning is out of scope as its own future accept-gated card. The naming hazard is respected: "grounding" is taken by the source-diversity score in truth/grounding.ts, so the new verdicts speak of anchoring.