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.
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) onClaimEvent,AppendClaimInputandClaimVersion, presence-gated underTRUTH_SCHEMA_VERSION = 1, with parsing reused from the existing validity discipline. - A succession channel beside the conflicts array: a separate, optional
TruthState.successionsfield, 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
eventsoperation onbrain_truth(plus a CLI subcommand) withsince/until/entity/limit, leaving today'sslotsresponse untouched entirely; rows carry validity fields verbatim and are reach-gated per row. - Grounded agent-stated claims as ledger events with the
agent_statedextractor tag and per-claim verdicts: grounded claims commit, ungrounded claims are reported back with reasons. - A single
correctverb (MCP action onbrain_lifecycle, CLI subcommand onbrain 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_statedevents 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-runpolling cursor on the truth ledger: tail-following stays consumer-side; ascending order pluslimitgives a resumable slice. - Provenance re-weighting of conflict priority: this wave the
agent_statedtag 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) andgrounding.ts(30-day contest balance) stay assertion-keyed, documented at their constants. - Turning the relational arm default-on: enablement stays
relationalArmEnabledplus 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
The assertion-versus-validity axis is contract item 1, stated once. A same-slot pair (same canonical
entityandaspect) 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-dayCONFLICT_WINDOW_DAYSdistance, 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:83returns the base fold unchanged;tests/core/brain/truth/conflicts.test.tspins "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.Succession surfaces as a separate channel, not a conflict kind.
TruthStategainsreadonly successions?: ReadonlyArray<ClaimSuccession>- optional and presence-gated, set only when non-empty, serialized with the conditional-spread pattern fromstore.ts:128-138so every windowless line, fold, state file and conflict result stays byte-identical.fold.tsis untouched; the succession pass lives in the policy layer (conflicts.tsplus a newsuccession.tssibling), matching the existing policy-over-fold shape.TruthConflictKindgains no member, soask_usersemantics, 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.Window defaults are explicit-input-first, frozen-at-ingest. CLI flags
--valid-from/--valid-untiland declared optional MCP ingest fields win outright. Absent input, ingest resolves the window from the source record's frontmattervalid_from/valid_untilwhen 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.One interval convention inside the truth layer: half-open. Ledger windows use
[validFrom, validUntil)withisValidAtsemantics fromlifecycle/temporal-replace.ts, reusingValidityBounds. Values parse with thesearch/validity.tsdiscipline (bare dates day-snapped, datetimes, never relative phrases) - no second grammar. The events operation'ssince/untilare a different vocabulary: they filter assertiontsonly, through the sharedtime-range.tsgrammar with its inclusive day-edge semantics. Both schema descriptions state their convention explicitly so the two temporal vocabularies stay unambiguous inside one response.Windowed recall is a dedicated
eventsoperation, not a slots filter.brain_truthgainsoperation: "events"withentity(optional, normalized, composing),since,until,limit; the CLI gainso2b brain truth eventswith the same arguments, matching the existing CLI-over-MCP op asymmetry (sweepprecedent). Today'sslotsresponse is untouched entirely, so every existing consumer stays byte-identical by construction -eventsin the slots/conflicts responses remains the count pinned bytests/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 }whereClaimEventRowis the stored event with validity fields verbatim. Ordering is stable ascending assertionts(thereadClaimEventsorder), which makes tail-follow pagination an advancingsince. Default limitDEFAULT_EVENT_LIST_LIMIT = 200, hard capCLAIM_EVENT_MAX_LIST_LIMIT = 1000,truncatedset when more rows matched. Bounds are resolved through the shared grammar and floored/ceiled to the second (eventsWindowBoundsin the newevents-window.ts), exact against second-precision stamps via string compare. Every row passes the same per-row visibility/reach gatebrain_claimsuses; rows dropped by the gate are counted inwithheldso 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 -eventsas a name is taken by the count, and the card's "filter the returned events" reading was false because no events were ever returned.Agent-stated claims land as ledger events with per-claim verdicts. A stated claim is
{ subject, relation, object }plus assertiontext,sourceand optionalagent. It commits as oneClaimEventwithentity= normalized subject,aspect= the relation token (validated against the single relation vocabulary boundary,isKnownRelation),value= object display form, andextractor: "agent_stated"(new optional field onClaimEvent/AppendClaimInput, tolerated bycoerceClaimunder schema v1). Grounding uses the one existing occurrence kernel: a pureanchorEntityFormsexport lifted fromatomic-facts.ts(quality-gated normalized match forms, minimum length 3); subject and object must be anchored intextor the claim is reported back, not committed. Naming deliberately avoids "grounding", which is taken by the source-diversity score intruth/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 touchingcontestingValues; the tag is additive annotation on conflict rows this wave.The correction end-state policy is contract item 2, one pure function.
src/core/brain/truth/correction-policy.tspins: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 atwindowEndwhen 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 (supersedefor validity_close,tombstonefor 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 showedsupersede()-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.The sweep is validate-all dry-run, then fail-recorded, no batch op.
brain_lifecycle correct(MCP action) ando2b brain lifecycle correct(CLI verb) gather the affected set within the caller's reach: the claim-graph closure (whatReplacedchain tip pluswhatContests), a full-vault match-only wikilink mention scan viaretargetWikilinkswithapply: 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 reusingretargetWikilinks' per-write failure carry: per-target retirement through the end-state policy, mention retargeting, per-record receipts viaappendDecisionChangeReceiptwith the bundle id carried inevidence_triggersascorrection_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 returnappended: false, an already-closed window stays closed. Brain/log and receipt lines are never rewritten (testimony). Rationale: fail-recorded matches theretargetWikilinksprecedent and avoids a first-of-kind batch op type in the same wave that introduces the underlying data.The coupling invariant is contract item 3, one predicate, every surface.
src/core/search/correction-coupling.tspinscouplingVerdict(input: { predecessorPath: string; successorPath: string | null; successorReadable: boolean }): CouplingVerdictwithCouplingVerdict = { 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 atpost-rank.ts:142-168where 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.Traversal budgets are named constants with config override; hub is degree, never prose.
relationalFanoutgainsTRAVERSAL_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) exceedsTRAVERSAL_HUB_DEGREE_THRESHOLD = 12is reached but not expanded. All four are overridable throughOPEN_SECOND_BRAIN_SEARCH_TRAVERSAL_*config following theparseBool(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.Entity bridges from chunk_entities, behind their own flag. A new store reader
entityBridgesForDocuments(new filesrc/core/search/store/entity-bridges.ts) joins thechunk_entitiestable so two documents mentioning one normalized entity get a bridge edge labeledentity. 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, soparseRelationalQueryvalidation is unaffected and attribution renders them asvia 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.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.
Ordered path provenance is per-node reach-gated and frontmatter-annotated.
RelationalReachgains an ordered path of{ documentId, relation }steps; only nodes readable at the caller's reach appear (per-node gating, thebrain_derive_factpremise-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 annotatedsuperseded_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.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.Schema-version discipline: optional fields stay under version 1.
validFrom,validUntilandextractorare optional, presence-gated fields tolerated bycoerceClaimand 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 carrysuccessionsonly when non-empty, and old binaries' strict state validators treat the derived cache as recomputable (readTruthStatereads null on structural mismatch and the caller refolds from events). No version bump, no migration.One operator concept
correct, no new MCP tool. The verb extendsbrain_lifecyclewith acorrectaction and the CLI lifecycle verb with acorrectsubcommand. 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 newbrain_correcttool would grow the matrix tool count for a concept that is lifecycle retirement plus provenance, whichbrain_lifecyclealready owns.
File changes
New files:
src/core/brain/truth/validity.ts- window parsing, intersection test,claimWindow,eventsWindowBoundshelpers (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 overresolveTimeRange(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 underplugins/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.