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
14.5 KB
Raw Blame

Variants - truth-correctable, time-aware claims (audit trail)

Source: cli-output/consultant.md. The orchestrator accepted the consultant recommendation (Variant 3, Two Sub-Suites over a Pinned Contract) with no override. The three variants and the recommendation follow verbatim.

Consultant variants (verbatim)

Variant 1: Five Narrow Independent Cards

  • Approach: Each card lands as the smallest correct version of itself with no shared new module and no cross-card sequencing: the ledger gains optional validity fields read only by a new succession channel; the windowed recall surface gains one additive response field; the correction sweep orchestrates existing primitives under today's retire-in-place semantics; agent-stated claims ground into the intake relation layer without touching the ledger; multi-hop recall deepens the existing relational arm over document typed edges only. Every cross-card decision is taken locally in the most conservative direction, so nothing shared changes and the cards can be built fully in parallel.
    • Succession channel versus conflict kind: a separate successions channel beside the conflicts array in the policy layer, keyed only when both claims of a pair carry present non-overlapping windows; mixed or windowless pairs keep today's assertion-time behavior byte-identically; never a new conflict kind, so ask_user semantics, hygiene findings and priority ranking stay untouched. Precedence rule: validity governs only validity-versus-validity pairs; contestation stays assertion-keyed even for windowed pairs, an expired window never suppresses contestation on its own, and the assertion-time sibling consumers (collision, grounding score) stay assertion-keyed.
    • Window defaults: explicit input only (CLI flags and declared optional ingest fields); no automatic resolution from source records, keeping ledger ingest self-contained.
    • Correction record state and sweep atomicity: supersede/tombstone as today; the sweep is a deterministic fail-recorded sequence β€” dry-run discovery, per-record supersede, mention retargeting with apply:false then apply, per-record receipts correlated by a bundle id carried in evidence_triggers β€” with no record-state change and no write-batch extension.
    • Agent-stated claims: they land in the intake relation layer, extending the declared-payload boundary with anchorEntities occurrence grounding and report-back verdicts; no extractor tag on ledger events this wave, so provenance-based conflict detection reduces to additive annotation over the claim-graph fields that already exist.
    • Claim-chain recall: deferred. The arm deepens over document typed relations plus chunk_entities now; claim-edge composition is explicitly deferred until grounded object-entity linking exists.
    • Windowed-slots response shape: an additive claim_events field beside the count-preserving events; slots and the global count untouched (superset reading); rows in stable ascending ts order with a named default limit; the SearchError-to-INVALID_PARAMS boundary lifted out of recall-tools into a shared wrapper; the schema description states that since/until filters assertion ts only.
    • Multi-hop width caps: 8 seeds, 4 expansions per node, 16 total nodes as named constants with config override; a hub is a node whose walked-edge degree exceeds a threshold; traversal stays deadline-bounded; direct-hit precedence is not addressed this wave.
    • Serve-with-correction invariant: stays search-pipeline-only and best-effort; relation polarity is hardened so a resolvable, readable successor is always pulled in beside a demoted predecessor; recall by topic, context-pack, active.md and dream keep the hide-or-annotate split.
  • Trade-offs:
    • Pro: smallest blast radius per card; the byte-identical and ask_user invariants hold by construction because no shared code changes.
    • Pro: full parallelism, no ordering constraints; each card reviews as one unit and can ship or slip alone.
    • Con: the assertion-versus-validity axis is decided twice (windows card and windowing card) with real drift risk, and the precedence rule ends up implicit in two places instead of stated once.
    • Con: the wave's two genuinely novel ideas are not delivered β€” the coupling guarantee remains best-effort and search-only, and recall still cannot answer transitive claim questions.
    • Con: agent-stated claims never reach the ledger, so that card's headline (provenance-based conflict detection over ledger events) degrades to annotation, and the extractor column the claims view lacks stays missing.
  • Complexity: medium
  • Risk: low

Variant 2: Shared Temporal Kernel, Fully Coupled Wave

  • Approach: Build one shared time-axis kernel first β€” a single module owning window parsing (the existing strict grammars lifted together), the half-open interval test, and one explicit precedence rule β€” then land all five cards as consumers in the same release, including claim-edge traversal over the grounded linking the same wave introduces and a guaranteed cross-surface coupling predicate. Every cross-card decision is made exactly once, in the kernel or in one named consumer.
    • Succession channel versus conflict kind: a separate successions channel; the precedence rule is a kernel property β€” classification keys on validity only when both claims of a pair carry present windows (non-overlapping present windows succeed; overlapping windows fall through to today's assertion-time contest rule); assertion time keeps governing contestation even for windowed pairs, an expired window never suppresses contestation on its own, and the sibling assertion-time consumers stay assertion-keyed and documented as such.
    • Window defaults: explicit input wins; absent input, ingest resolves the window from the source record's event time using the existing rung order and stores the resolved value frozen, so scan time never reads the vault.
    • Correction record state and sweep atomicity: validity-close is the default (the predecessor stays serveable inside its window, the only regime where serve-with-correction is non-trivial); tombstone only for flatly-wrong claims; chosen per target by whether the correction is time-scoped, and recorded in the receipt. A new write-batch op type lets discovery, retirement and mention retargeting commit as one validate-all-then-commit batch; the bundle id joins the receipts.
    • Agent-stated claims: they land in both stores with a defined bridge β€” ledger events (subject as entity, relation-derived aspect, object as value) carrying the agent_stated extractor tag, plus intake relations for synchronous entity linking; grounding is per claim (grounded commits, ungrounded reported back β€” the first partial-commit lane in the subsystem); provenance changes priority, ordering and resolution hints only, never which pairs contest.
    • Claim-chain recall: now. The arm walks the new claim/entity edges after the linking lands within the wave, under the same boundedness rules.
    • Windowed-slots response shape: an additive claim_events field carrying validity fields verbatim beside the count-preserving events; the schema text pins ts-only filtering so the two temporal vocabularies stay unambiguous inside one response.
    • Multi-hop width caps: one traversal-budget object (seeds, per-node, total, depth) shared with the existing traversal-lane precedent; hub by typed-edge degree; deadline-bounded; direct-hit precedence made structural (sub-neutral lane weight or admission below the last organic row) with a pinning test reconciled against the promote-never-sink rerank pin.
    • Serve-with-correction invariant: one shared predicate applied at every serving surface (search pool and post-rank, topic recall, context-pack, active.md, dream); a retired claim is served only beside its correction; an unresolved or out-of-reach successor drops the retired row (fail-closed, so a withheld page stays indistinguishable from an absent one); appended correction content re-runs the full visibility, agent-scope and reach filter set, closing the recorded pulled-in-successor gap.
  • Trade-offs:
    • Pro: every cross-card decision exists exactly once with one test seam; the wave delivers all five capabilities including the two novel invariants.
    • Pro: the precedence rule, the grammars and the coupling invariant each have one home, so byte-identical gating is enforced in one place per concern.
    • Con: largest blast radius β€” ledger schema, the write path, a new batch op type and five serving surfaces change in one release; a kernel bug touches every card at once.
    • Con: strict internal ordering (kernel first, then linking, then claim-edge traversal) removes parallelism and makes the release hard to split if review finds problems.
    • Con: first-of-kind mechanics concentrate here: the first partial-commit write lane, the first retirement op type in the write batch, and the first guaranteed serving predicate, all introduced together.
  • Complexity: large
  • Risk: medium

Variant 3: Two Sub-Suites over a Pinned Contract

  • Approach: Split the wave into two sequenced sub-suites joined by a small, test-pinned contract: sub-suite A (temporal truth) delivers the ledger validity fields, 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.
    • Succession channel versus conflict kind: a separate successions channel; the precedence rule is contract item 1 (both-claims-windowed pairs classify on validity; everything else keeps today's assertion behavior verbatim; an expired window never suppresses contestation), so A and B cannot drift on which time wins.
    • Window defaults: explicit input overrides; otherwise ingest resolves from the source record's event time when that source is readable at ingest, storing the frozen resolved window; the freeze (never a live reference) is contract text.
    • Correction record state and sweep atomicity: per target β€” a time-scoped correction closes validity (predecessor serveable in its window, coupling meaningful), a flatly-wrong claim tombstones; the choice is recorded in the bundle receipt and the policy is contract item 3, which succession logic and path-provenance annotation both read. The sweep runs validate-all dry-run first (blast-radius report), then a fail-recorded applied sequence reusing retargetWikilinks' per-write failure carry; no write-batch op type this wave; idempotent replay converges; the bundle id joins the receipts.
    • Agent-stated claims: they land as ledger events with the agent_stated extractor tag in A, with per-claim verdicts (grounded commits, ungrounded reported back); the intake-relation bridge is contract-specified and materialized in A only where object-entity linking is needed; provenance affects priority, ordering and hints only, never which pairs contest.
    • Claim-chain recall: document typed relations plus chunk_entities now in B, with full width caps and direct-hit precedence; claim-edge composition is deferred to the next wave behind the linking A delivers, with the contract naming the future edge source and its enablement gate β€” the one honest deferral, since those edges have no live data until A's grounded claims accumulate.
    • Windowed-slots response shape: a dedicated events operation on brain_truth (plus a CLI subcommand, matching the existing CLI-over-MCP op asymmetry), 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 like every row-returning surface.
    • Multi-hop width caps: 8 seeds, 4 per node, 16 total as named constants with config override; hub defined by typed-edge degree, never prose; deadline-bounded; direct-hit precedence structural with a pinning test; ordered-path provenance carries only nodes readable at the caller's reach (per-node gating like the derived-fact premise gate), with contested or superseded claims annotated through the contract's record-state policy.
    • Serve-with-correction invariant: one shared predicate module in B consumed by every serving surface; a retired row is served only beside its chain-tip correction when that successor is resolved and readable at the caller's reach, and is dropped otherwise; appended correction content re-runs the full filter set; the guarantee is pinned by a cross-suite test named in the contract.
  • Trade-offs:
    • Pro: the three genuinely cross-card decisions become first-class, test-pinned artifacts instead of implicit coupling; each sub-suite has a bounded blast radius and reviews as one unit.
    • Pro: delivers the novel invariants (guaranteed cross-surface coupling, provenance-bearing ledger claims, structural direct-hit precedence) while deferring exactly the one item with a data-maturity dependency.
    • Pro: the dedicated events operation keeps every existing consumer byte-identical by construction, the cheapest possible off state.
    • Con: the contract is new surface to maintain; a weak or stale contract would let the sub-suites drift exactly where they must not.
    • Con: claim-edge composition slips a wave, and the correction sweep reports partial application rather than committing as one batch.
  • Complexity: large
  • Risk: medium

Final rationale

Recommended: Variant 3

Rationale: The recons show exactly three hard couplings β€” the assertion-versus-validity axis shared by the windows and windowing cards, the correction record-state policy shared by the correct verb, the succession logic and path provenance, and the data dependency of claim-edge traversal on grounded linking β€” and Variant 3 makes exactly those three the pinned contract while leaving everything else independent, which is the DRY without the blast radius. It delivers the wave's novel invariants that Variant 1 defers (guaranteed serve-with-correction, provenance-bearing ledger claims, direct-hit precedence), and unlike Variant 2 it does not concentrate ledger schema, write-path and five-surface serving risk in one coupled release, nor introduce a first-of-kind partial-commit lane and batch op type in the same wave that introduces the underlying data. Deferring claim-edge composition behind the enablement A ships is the one honest sequencing choice, since traversal over edges with no live data cannot earn its budget.