Changelog

Added

• Replication-weighted recall factor (replication_max, CHITTA_REPLICATION_MAX), landed default-off: distinct-session replications per memory are cached on load; the live store has 0 memories with ≥2 independent replications and the golden delta was 0, so the card carries prior_effort: some (docs/EVALS.md).
• Snapshot load decodes sections in parallel from an mmap and overlaps triplet reconstruction with the rest of startup: snapshot phase 7.8–9.2 s → 3.6–4.3 s on the replica; startup sidecars are keyed to the snapshot so LSH/turbo hit with a WAL delta (live restart 27–33 s → 12.6 s); fused recall is deterministic across restarts (total-order sorts, hydration without touches).
• The per-Bash-call saddle check runs in bash/jq (81-fixture byte parity with saddle_detector.py): added PreToolUse overhead 97 → 24 ms median.
• Opt-in isolated evolve implementation streams (--candidates N, default 1): concurrent worktrees with private agent state, shared deadline and budget fallback, gate-passing selection by measured bet delta then patch size, all candidate outcomes in verdict/bet memories, and python3 -m evolve.report.
• Automatic-learning experiment harness: provenance-based cohort classification, prospective task/grader freezes, isolated paired replica trials (strict bwrap mode or home-audit with post-hoc voiding), exposure checks, deterministic grading and fixture-only dry runs (benchmarks/learning/protocol.md).
• Daemon startup caches derived search state across restarts (normalized embeddings, event-tape organs, quantized index): clean start 27 s → 13 s, optional sidecars, rollback-safe.
• Stigmergic artifact traces, after SwarmWorld¹⁴ (arXiv:2608.26081) measured ~95% of first reuse through observing an artifact rather than being told: pre-tool-hook adds [traces] on the first Read of a file per session (memories whose text names that file; CHITTA_FILE_TRACES=0 disables) and artifact-trace.sh (PostToolUse Write) registers newly written scripts as [artifact] <path> sha:<8> purpose:… signals so later sessions fork them.
• Two hypothesis cards for the evolve loop from the same reading: isolated best-of-2 implementation streams (SwarmWorld¹⁴: isolated search kept the best single artifact) and replication-weighted recall (Buehler's¹⁵ repeated runs reached model-dependent conclusions). The learning-experiment protocol gains two pre-registered secondary metrics: best-of-three per arm and artifact reuse rate.

Changed

• recall_analogy is explicit relation transfer only (a:b :: c:?): the predicate(s) linking a→b come from indexed triplet lookups and the answers are c's actual neighbours over those predicates, with supporting edges and a reason on abstention. Structural mode and VSA¹⁰ ranking are gone from the endpoint. Frozen-replica benchmark: hit@1 14/14, hit@3 14/14, 14/14 negative abstentions, 0 unsupported answers (docs/EVALS.md).
• Prompt, SessionStart and Stop hooks no longer start Python on the hot path: query cleaning, RPC-stats parsing, the heartbeat, session registration and the ledger render run in bash/jq against the daemon's CLI. Prompt hook median 822→635 ms, SessionStart 693→599 ms on a loaded node (docs/HOOKS.md).
• Linked git worktrees resolve to the main checkout's realm in the hooks, the session registry and the CLI, so Codex and evolve streams recall project memory.
• Recall ranks operational distiller fragments below curated kinds (kind_operational 0.8) so a correction outranks verbatim transcript notes of equal similarity.
• The daemon's binary-update probe uses posix_spawn instead of popen; the fork() ran OpenBLAS's atfork barrier and stalled the main loop under embedding load.
• Chained git add … && git commit commands are captured as milestones.

Fixed

• Nightly literature cards were rejected by the proposal loader (source URL instead of a kind, prose blast_radius, zero effort) and silently skipped by the selector; the watch now writes the loader's contract.

Removed

• Retired MDL¹¹ admission compression on 2026-09-15: native and Bash shadow taps, same-chunk pooling, corpus dictionaries/bootstrap, Python mirror, test targets, environment knobs and evolve coverage telemetry. Distilled learning storage, deduplication and recall ranking remain unchanged; no utility-posterior hard gate replaces it. Historical shadow logs remain untouched and inert. The paired 20-task automatic-learning experiment remains pending (see docs/EVOLVE.md).

Daemon / store

• Recall read path no longer writes: access touches accumulate and drain every 5 s; WAL fsync is timer-based (200 ms) with durable ops explicit; TurboQuant⁵ index rebuilds on the maintenance thread. Twelve concurrent recall_lanes: 1.7–3.6 s → 0.23–0.54 s.
• Embedding context pool (CHITTA_EMBED_CONTEXTS, default 4) and query-embedding LRU cache.
• Task ledger (threads, inbox, artifacts, session bindings, leases) moved from ~/.claude/task-ledger.db (NFS sqlite) into the daemon (ledger_op RPC) with an idempotent task_ledger.py migrate.
• Queue lives at <mind>/queue.jsonl; tag recall is a hard filter with realm applied after; correction lane realm-scoped; MDL small-evidence pooling (shadow).
• Daemon output kept in ~/.claude/mind/chittad.log (user journal unreadable on the cluster).

Hooks

• SessionStart lanes run concurrently (5.7–7.2 s → ~0.7–1.5 s) with a fallback line when every lane times out; SessionEnd fits its 5 s budget.
• Prompt hook: in-process realm detection; zero-distinctive-token turns skip topic lanes; UNKNOWN-band candidates need a distinctive turn token; keyword rows need two distinctive tokens or BM25²⁴ ≥ 60; pre-tool "BEFORE RUNNING" needs 0.6 similarity; hard guard against killing the --http MCP process.
• Hooks honour CHITTA_SOCKET_PATH; failed commands recorded via PostToolUseFailure; Codex exit-less shape recorded as unknown.

MCP

• Cold recall 10.8 s → 1.1 s (no Transformers import); streamable-HTTP sessions expire idle (30 min) and are capped (64); evolve runner reaps Codex.

Evolve

• Proposal cards carry verifiability, prior_effort, internal_evidence; selector weights them; every cycle requires a SELF_CHECK test and runs a bounded survey phase first; nightly/weekly timers; select.py renamed selector.py.

Eval

• Frozen replica copies loader markers, records its own pid, retries copies that race a save; real-agent noise calibration in benchmarks/noise.json; hook_total_ms metric.

Added — Causal Episode Compiler: Phases 15–17

• Phase 15 — FEP prior organ (v5.39.0) — FepPriorOrgan (new organ/fep_prior.rs): non-actuating generative model P(sym | context) over EventTape. Factored Dirichlet-multinomial emission: P(tool | state) · P(outcome | state, tool), entity marginalized. Online Bayesian count update with exponential forgetting (STATE_DECAY = 0.9995). Free energy per step replaces PPM³⁰ surprisal in the Phase 3 write gate. Two EWMA signals fed to TuriyaMonitor: ewma_drift (context_drift diagnosis) and ewma_shock (emission_shock diagnosis), extending the monitor to 7 typed diagnoses. Fully ephemeral; rebuilt from EventTape each consolidation_pass(). New tool: fep_status. FFI: cf_fep_status. Multi-model origin: GPT-5.5 + Opus 4.7 — FEP as tractable variational bound over the CEC symbol stream, not full FEP machinery.
• Phase 16 — MemoryKind lattice + CPU-native QueryRouter (v5.40.0) — MemoryKind (new organ/memory_kind.rs): four typed kinds — Thought, Observation, Decision, CodeFact — inferred at write time from tags/realm/content prefix. Static edge_legal(from, to) matrix enforced in add_assoc_edge(): (Observation, Thought) and (Decision, Thought) illegal (rationalization chain). QueryRouter (new organ/query_router.rs): typed RecallRequest IR dispatches to Exact | Fuzzy | Temporal | Causal | Hybrid | NeedsDisambiguation. LLM called only when grammar leaves a named UnboundSlot — every token spend corresponds to a specific auditable hole. Four falsifiability metrics written per consolidation_pass(): token-displacement ratio, deterministic replay rate, router error rate, contradiction yield. New tool: routed_recall. FFI: cf_routed_recall. Design from GPT-5.5 + Opus 4.7: edge-legality as highest-ROI structural guarantee; escalation via parse failure, not model confidence.
• Phase 17 — MemProvenance lattice + Reconciler + open-weight harvest (v5.41.0) — MemProvenance (new organ/provenance.rs): five provenance tags on every payload. Open-weight-generated writes enter candidate band; promoted only via witness_memory() on closed-loop signal (user correction, tool-result, router hit-rate delta). Candidate-laundering guard in add_assoc_edge(): src.candidate && !dst.candidate → edge rejected. Reconciler R0 (new organ/reconciler.rs): reconcile_all() scans assoc_edges for kind-legality violations and laundering; detect_contradictions() groups by (realm, 6-word prefix). R0/R1 split inviolable — R0 is model-free, deterministically replayable; R1 proposals only validated by R0 before commit. harvest_scope(): demand-driven extraction targets from Turīya anomalies + router misses. scripts/harvest_ow.py: offline open-weight extraction — vocab_geometry (embedding matrix PCA → HDC seed vectors), triplet_extract (model over corpus → S,P,O JSONL), feature_dict (sparse autoencoder). New tools: witness_memory, reconcile_pass, harvest_scope. FFI: cf_witness_memory, cf_reconcile_pass, cf_harvest_scope. Design from GPT-5.5 + Opus 4.7: failure mode first (globally inconsistent retrieval under cross-session contradiction); harvest scope demand-driven, not bulk ingest.
• All new tools wired end-to-end: FFI (cf_*), C++ wrappers in field_store.hpp, handler implementations in field_memory_recall.cpp, registered in register_memory_core_tools.cpp and TOOL_SPECS, exposed in chitta-mcp/server.py ADVANCED_TOOLS.

Added — Causal Episode Compiler: Phases 11–14

• Phase 11 — Turīya meta-cognition (v5.35.0) — TuriyaMonitor (new organ/turiya_monitor.rs): a pure read-only witness organ with zero write surface. Samples CDAWG⁶ state count, EventTape length, tracked/refuted Sequitur²⁵ rules, HypothesisMarket uncertainty, Q-value variance, and per-sample deltas after each consolidation_pass(). Stores a rolling 100-sample VecDeque<HealthSample>; persisted in FullSnapshot (V15→V16 migration). Five typed diagnoses in priority order: refutation_flood (refuted ≥ 50% of tracked), stale (no CDAWG growth despite >20 new events), q_collapse (variance < 0.005 with >50 states), high_uncertainty (mean probe_value > 0.65), healthy. Trend detection across last-5 samples. New tool: turiya_status. FFI: cf_turiya_status. Multi-model brainstorm origin (GPT-5.4 + Opus 4.7): both ranked pure witness as highest-ROI Phase 11.
• Phase 12 — Temporal compression (v5.36.0) — EventTape::compress_low_surprisal(cdawg, threshold=0.85): tombstones success events whose CDAWG PPM prediction confidence exceeds threshold. Failures (outcome class ≠ 0), session boundaries (session_id change), and the very last event are always preserved verbatim. O(n) single-pass boolean mask; tombstoned entries are removed and counter incremented. Called from consolidation_pass() after CDAWG rebuild. Mirror of Phase 3 (surprisal-gated writes): Phase 3 burns in high-surprisal events; Phase 12 compresses low-surprisal segments. New tool: tape_stats (total length, tombstoned count, compression ratio). FFI: cf_tape_stats.
• Phase 13 — Verbalization (v5.37.0) — SequiturRule::verbalize(tape): deterministic template engine (no LLM). Template: “Whenever {tool_a}({entity_short}) {outcome_verb}, {tool_b} tends to follow (observed ×N, avg outcome: label).” Same-entity shortcut: “…{tool_b} on the same entity tends to follow…” Verbalization promoted to the triplet knowledge graph as (rule_key, “verbalized_as”, text) during consolidation_pass(). Entity path shortening: strips prefix up to last /. Outcome labels: succeeds | fails | errors | partially succeeds. New tool: verbalize_rules --k N. FFI: cf_verbalize_rules.
• Phase 14 — Self-directed experimentation (v5.38.0) — store::queue_experiments(k): reads HypothesisMarket::top_probes(k) and for each probe with probe_value > 0.4 && refute_ratio < 0.3 calls cec_policy_store.propose(rule_id, InterventionKind::OpenTask). The adversarial gate is the same as Phase 9: no experiment is queued for a rule whose source is under active refutation. Auto-triggered from consolidation_pass() when Turīya diagnosis is HighUncertainty. Closes the full observe→synthesize→hold→experiment loop (epistemic state machine from GPT-5.4 brainstorm). New tool: queue_experiments --k N. FFI: cf_queue_experiments.
• All four new tools wired end-to-end: FFI (cf_*), C++ wrappers in field_store.hpp, handler implementations in field_memory_recall.cpp, registered in register_memory_core_tools.cpp and TOOL_SPECS, exposed in chitta-mcp/server.py ADVANCED_TOOLS. cec-status extended with Turīya section. Novel multi-model contributions: GPT-5.4 → epistemic state machine (Hold as first-class output); Opus 4.7 → think-cycle observability + checkpoint/replay metadata for consolidation_pass.

Added — CEC Real-Time Ingestion + Tooling

• Real-time event ingestion via PostToolUse hooks (v5.34.1) — every tool use now emits a CEC log_event automatically. post-bash-hook.sh: log_event(bash, cmd_basename, exit_code→outcome). post-edit-hook.sh: log_event(edit, file_path, 0) for all file extensions. Both fire-and-forget background subshells; do not block the 5 s hook budget.
• Conversational event ingestion (v5.34.2) — prompt-core.sh emits log_event(user_prompt, realm, 0) on every UserPromptSubmit; stop-core.sh emits log_event(assistant_response, realm, 0|2) on every Stop (outcome 2 when HAS_ERROR=true). Combined with remember/forget (wired since Phase 1), every category of agent activity is now captured in the EventTape automatically.
• consolidation_pass auto-fires at session boundaries (v5.34.2) — stop-core.sh and pre-compact-hook.sh both launch nohup chitta consolidation_pass detached from hook timeout. Sequitur rules and HypothesisMarket are always fresh before context is discarded. Log: $MIND/.cec_consolidation.log.
• cec-status aggregator (v5.34.3) — scripts/cec-status.sh (symlinked to ~/.claude/bin/cec-status). Runs four CEC queries in parallel and prints: failure pattern count, HypothesisMarket rule count + top uncertain probes (Wilson² CI), RefutationLedger live/refuted counts, InterventionStore active/shadow policy counts. --json flag available.
• CEC tools added to chitta --help (v5.34.4) — four new help categories: CEC events, CEC recall, CEC market, CEC exec. All 14 CEC tool names now visible in chitta --help.
• log_event_ex and log_decision fully wired into CLI (v5.34.5) — both tools were missing from four registration sites: ToolResult handler implementations, handler declarations, RPC registration, and the TOOL_SPECS/KNOWN_TOOLS dispatch array. All 14 CEC tools now respond to chitta <tool> --help.

Added — Causal Episode Compiler: Phases 9–10

• Phase 9 — Active memory executor (v5.33.0) — InterventionStore (new organ/intervention_store.rs) converts CEC from a pure read path into a control system. On every Sequitur rule refutation (contradict_ratio > 0.4), log_event() auto-files a task in the TaskRegistry and proposes a TurnInjection policy in shadow mode. Shadow eval gate: minimum 20 events + expected_lift > 0.15. Adversarial invariant: fire_active() checks refutation_ratio < 0.3 before firing any policy — policies whose source rule is being refuted are auto-suspended. Fixed field-name collision (organ::intervention vs. organ::intervention_store) by renaming the CEC field to cec_policy_store. New tools: executor_flush, list_policies. FFI: cf_executor_flush, cf_list_policies.
• Phase 10a — DecisionTape (v5.34.0) — organ/decision_tape.rs: explicit branch-point memory recording (chosen_sym, rejected: Vec<(sym, RejectionReason)>, confidence_delta) per turn. Six typed rejection reasons: LowerQValue, HigherFailRate, RefutedRule, CostEstimate, OutOfScope, UserOverride. Persisted in FullSnapshot (V14→V15 migration). Also fixes a latent bug where snap.event_tape was discarded on load and rebuilt from scratch; tape is now correctly restored from snapshot. recall_true_counterfactual queries the DecisionTape directly instead of inferring from CDAWG sibling edges. FFI: cf_log_decision, cf_recall_true_counterfactual.
• Phase 10b — Regret-shaped Q-values (v5.34.0) — log_event_ex(…, token_cost, latency_ms, retry_count) computes utility U = base − 0.001·cost − 0.00001·latency − 0.1·retries before calling update_q. Prevents “9-step success” from outranking “3-step success” in Q-value. Parameter reward renamed to utility throughout update_q. FFI: cf_log_event_ex.
• Phase 10c — Hypothesis Market (v5.34.0) — organ/hypothesis_market.rs: Wilson score CI (95%, z=1.96) + binary entropy per Sequitur rule. probe_value = H(p̂) × (1 − |p̂ − 0.5| × 2) — maximised at p̂=0.5 (maximum uncertainty), zero at certainty. Rebuilt from RefutationLedger after each consolidation_pass(); ephemeral (not in snapshot). Phase 9 executor reads HypothesisMarket::top_probes() before selecting which policy to fire — rules with high certainty get interventions, uncertain rules get disambiguation tasks. New tool: hypothesis_probes --k N. FFI: cf_hypothesis_probes.

Added — Causal Episode Compiler: Phases 6–8

• Phase 6 — Counterfactual recall (v5.30.0) — CdawgOrgan::counterfactual_alternatives(context, taken_sym, min_support, k) enumerates sibling edges at the CDAWG state reached by prefix P and compares fail_ratio(P→a) vs fail_ratio(P→b). Wilson lower bound (90% CI, z=1.645) ranks uncertain alternatives below well-supported ones. New tool: recall_counterfactual --tool T --entity E --outcome N. Gate: min_support = 5.
• Phase 7 — Causal refutation ledger (v5.31.0) — RefutationLedger (new organ/refutation_ledger.rs) tracks support (sym_a → expected sym_b) and contradict (sym_a → anything else) counts per Sequitur rule. Hysteresis thresholds: flip to Refuted when ratio > 0.4, reinstate when < 0.2. On refutation a (rule_N, “refuted_by”, “contradict_at_ts=…”) triplet is written. consolidation_pass() seeds the ledger from each Sequitur run; log_event() calls observe(prev, curr, ts) on every append. New tool: refutation_stats --k N.
• Phase 8 — Cross-session motif Q-values (v5.32.0) — CdawgState gains a q_value: f32 field. update_q(terminal_sym, reward, α, γ) propagates TD(0) credit up the suffix-link tree weighted by 1/|endpos| so generic high-frequency states do not absorb disproportionate signal. Called on every non-legacy outcome event (reward +1.0 success / −1.0 failure, α=0.05, γ=0.95). top_q_states(prefix, k) BFS from a prefix state, returns top-k by Q. store.rs::recall_motif_value maps states to RecallHit with score (q+1)/2 and next-action predictions from outgoing transitions. New tool: recall_motif_value --tool T --entity E --k N.
• SequiturRule gains contradict_count: u32 for persistence across consolidation passes.
• FFI: cf_recall_counterfactual, cf_refutation_stats, cf_recall_motif_value. All three wired through C++ handlers, registered in register_memory_core_tools.cpp, added to TOOL_SPECS, and exposed in MCP ADVANCED_TOOLS.

Added — Causal Episode Compiler: Phases 1–5

Embedding-free agentic memory substrate indexing state transitions (tool, entity, outcome) rather than content. Runs in parallel with HNSW⁴/BM25/HDC recall lanes, which are untouched.

• Phase 1 — Event Tape + CDAWG (v5.25.0) — EventTape: append-only log of (tool_id, entity_key, outcome_class, session_id, ts_ms) with deterministic entity canonicalization. CdawgOrgan: online CDAWG over packed u64 symbols; ephemeral, rebuilt from EventTape at load. EventTape serialized in FullSnapshot (V13→V14). Existing memories receive a synthetic legacy event for warm-start. Tools: log_event, recall_last_action, recall_failure_pattern, recall_causal.
• Phase 2 — TD(λ) + PMI antecedents + Roaring (v5.26.0) — CdawgState.endpos upgraded to RoaringBitmap. push_td_credit() backward eligibility traces (δ=+0.1/−0.2, γ=0.9). recall_causal_antecedent returns PMI-ranked predecessors.
• Phase 3 — Surprisal-gated writes + injection (v5.27.0) — PPM surprisal gate in put_memory: if surprisal > 2.0 nats, decay_rate halved. prompt-core.sh injects a “⚠ CEC:” warning when current CDAWG prefix has fail_ratio > 0.7 && fail_count ≥ 3.
• Phase 4 — HDC as heteroassociative binder (v5.28.0) — EpisodeHdcStore: each CEC event encoded as bind(R_tool,t) XOR bind(R_entity,e) XOR bind(R_outcome,o). recall_hdcbind(known_role, known_val, query_role) XOR-unbinds to infer the missing role by Hamming distance against codebook. Tool: recall_hdcbind.
• Phase 5 — Sequitur grammar + procedural KG promotion (v5.29.0) — run_sequitur() counts bigrams with frequency ≥ 5. consolidation_pass() promotes rules to triplet KG (compresses, avg_outcome, support, tape_range predicates). Dedup via query_subject(). Auto-triggers every 500 events. Tool: consolidation_pass.

Fixed — Pre-embed All Medium-Frequency Write Handlers

Completed the pre-embed pattern for remaining write tools: update, consolidation_merge, curiosity_note_gap, propose_change, profile_update, profile_observe, goal_set, reconsolidate. All 15 write handlers that call embed_text()/embed_ssl_aware() now compute embeddings outside rpc_mutex_.

Fixed — More Pre-embed Before Lock

Extended the pre-embed pattern to three more high-frequency write tools called by hooks and the distillation pipeline:

• suggestion_track — embeds content before rpc_mutex_.
• anticipation_observe — pre-computes "anticipation: context → action" embedding from params.
• create_episode — pre-computes "title: turns N-M" embedding from params.

Fixed — Daemon Lock Starvation

• Pre-embed write tools before exclusive lock — remember, observe, grow, learn* now compute embeddings (pure ML inference on yantra_, no field_store_ access) before acquiring rpc_mutex_ exclusively. Previously 30–60 s ML inference held the write lock, causing health_check and all reads to queue for 20+ minutes.
• Thread pool min workers 2 → 8 — pool now starts with 8 workers instead of 2, providing spare capacity when individual workers are occupied by slow operations.

Fixed — Memory & Startup Overhaul

Daemon RAM reduced from 22–26 GB → 2–4 GB. Snapshot size reduced from 4.2 GB → 420 MB. Root cause: runaway triplet accumulation — the distillation pipeline re-extracted the same subject-predicate-object facts on every run with no deduplication, producing ~14 million duplicate and invalidated entries over time.

• TripletStore deduplication — add() checks for an existing live (subject, predicate, object) entry before inserting; duplicates update weight in place. Eliminates the primary source of unbounded growth.
• Invalidated triplet purge — purge_invalidated() removes all valid_to_ms != 0 entries at load time and before snapshot save. Cleared 13.7 M dead entries (3.4 GB → 110 MB) on first startup after upgrade.
• Derived index skip — TripletStore’s three lookup indexes (by_subject, by_object, by_predicate) are cleared before serialization and rebuilt after deserialization. Previously serialized as redundant string copies (~3× snapshot bloat).
• AssocEdge deduplication — add_assoc_edge() upserts by (dst, edge_type) instead of appending.
• malloc_trim after store open — freed pages from load-time migration are returned to the OS immediately.
• Streaming snapshot load — deserialization now uses BufReader (1 MB read-ahead) instead of std::fs::read() which allocated the entire file as Vec<u8> before any deserialization.
• Daemon lock race — acquire_lock() now runs before early_server binds the socket; competing startups fail in milliseconds.
• Coactivation stats cap — coactivation_stats pruned to top-20 pairs per memory at load and save time.

Added

• Cross-harness disagreement detection (v5.21.59) — harness: Option<String> field added to MemoryPayload, inferred from source_tool on every write ("codex" if tool name starts with codex, "claude-code" otherwise). New cross_harness_conflicts tool scans all live non-staged memories, groups by semantic proximity, and returns pairs where harnesses differ — ranked by 1 − cosine_similarity (disagreement score). what_do_i_know_about now includes a cross_harness_conflicts array scoped to the recalled cluster. Snapshot bumped to V13 (0xF011_5741_7E00_000D) with LegacyMemoryPayloadV12 migration path covering V1–V12 snapshots on disk. FFI: cf_query_cross_harness_conflicts(h, realm, limit, min_score) → *char.
• Introspection tool — what_do_i_know_about (v5.21.58) — single MCP call that returns claims + provenance + staleness + contradictions for any topic. For each recalled hit: staged flag, invalidated_by, source_session, source_tool, age_days (from memory_claim_info); staleness verdict from symbol_stale_for_memory (checks invalidated_by, then artifact refs vs. live symbol index); contradiction peers from get_conflicts with resolution label. Params: topic, k (default 10), realm, confidence_min, include_stale, include_contradictions. Rust store methods: symbol_stale_for_memory(), memory_claim_info_json(). FFI: cf_symbol_stale_for_memory, cf_memory_claim_info.
• Snapshot V13 migration — payload harness field (v5.21.57–59) — ChunkHash import and LegacyMemoryPayloadV12 struct added to snapshot.rs. upgrade_payloads() helper upgrades all legacy payload maps (V1–V12) to V13 by inferring harness from source_tool. All seven legacy LegacyFullSnapshotV* structs updated to use LegacyMemoryPayloadV12; new LegacyFullSnapshotV12 added for V12-magic snapshots. peek_seqno() guard extended to accept FULL_SNAPSHOT_MAGIC_V12.
• Symbol-keyed event log (v5.21.56) — typed, WAL-backed event log keyed on symbol identity. SymbolEventLog organ stores Edited/Created/Deleted/TestFailed/TestPassed/Committed events with symbol_name, file_path, session_id, harness, and optional memory_id link. Indexed by symbol name and file path for O(1) lookup. upsert_symbol() C++ wrapper auto-logs an Edited event on every symbol write. invalidated_by field on MemoryState carries the commit hash or symbol-change ID that made the memory stale — set via mark_memory_invalidated. New MCP tools: symbol_event_log (query timeline), mark_memory_invalidated. FFI: cf_log_symbol_event, cf_query_symbol_events, cf_mark_memory_invalidated. WAL op: OP_SYMBOL_EVENT=67.
• Write-gate (staged admission) (v5.21.55) — all new memories start staged=true and are promoted to staged=false on first recall (access_count ≥ 1). Staged memories score 0.80× lower in the retrieval pipeline (StagedFactor) so they surface only when no promoted memory wins. Stale staged memories (age > 7 days, never recalled) are auto-pruned. Background promotion pass runs every 50 embed cycles (~25 min) via promote_staged_memories(). New MCP tool write_gate_stats reports staged_count and oldest_staged_age_days. FFI: cf_promote_staged_memories (→ packed u64 promoted | pruned), cf_write_gate_stats (→ JSON).
• Payload content sidecar (v5.21.50) — MemoryPayload.content moved from bincode into a flat .pld sidecar: [PLD_MAGIC:u64][count:u64]([id:u64][len:u32][bytes×len])×N. save_full_snapshot() writes .pld then clears content before bincode serialization; load_payload_sidecar() repopulates on load. v10 snapshots (content in bincode, no .pld) load transparently as a legacy path. New snapshot magic v1.0.11 (0xF011_5741_7E00_000B). At 1M memories × ~500 B average content: ~400 MB off the main bincode snapshot.
• Flat binary scan Vec (v5.21.47) — hamming_candidates() now iterates a contiguous Vec<(MemoryId, [u64;4])> instead of HashMap::iter(). Position index (binary_vec_pos) gives O(1) swap-remove on delete; in-place update on upsert. ~4× fewer cache misses at 1M memories. Guard requires binary_vec.len() == binary_codes.len() before using the fast path.
• Auto WAL compaction (v5.21.47) — maybe_compact_wal(threshold) checks segment count via wal_segment_count() and, if over threshold and 1 h has elapsed since last compact, calls compact_wal(). Called every 10 embed cycles (~5 min) from embed_loop with threshold=50. Cooldown tracked via last_compact_ms: Arc<AtomicI64> on ChittaField. FFI: cf_wal_segment_count, cf_maybe_compact_wal.
• Episode TTL pruning (v5.21.47) — prune_episodes(max_age_days, max_count) deletes episodes older than 90 days with strength < 0.3, then caps total episode count at 10 K (80% target on cap trigger). Called every 200 embed cycles (~1.7 h). Exposed as prune_episodes MCP tool. FFI: cf_prune_episodes.
• Mmap embedding skeleton (v5.21.47) — activate_mmap_embeddings() on SemanticIndex opens the .emb sidecar as a memory-mapped file (Arc<Mmap> to preserve Clone), builds a byte-offset index, and clears the heap HashMap. get_embedding() checks the offset index first. Guarded at >200 K in this release; completed in v5.21.48.
• Mmap embeddings — fully active (v5.21.48) — EmbLookup<'a> struct introduced: holds shared references to heap: &HashMap, offsets: &HashMap<MemoryId, u64>, and mmap: &Option<Arc<Mmap>>. Rust field-level split borrows allow HnswGraph::insert, search, search_layer, and select_neighbors to use mmap-backed neighbor lookups while mutating the graph. total_embedding_count() unifies heap + mmap counts; used by use_hnsw(), use_tier2(), the Hamming guard, normalize_all() consistency checks, len(), is_empty(), and all_ids(). activate_mmap_embeddings() now fires whenever the .emb sidecar exists — no size threshold. backfill_hnsw_delta, merge_delta_into_base, and rebuild_hnsw all iterate both embedding sources. Heap freed at any scale after first checkpoint.
• v10 snapshot format — embeddings stored in a .emb sidecar (magic header + count + flat {id, f32×256} records); binary sparse codes stored in a .bin sidecar ({id, u64×4}). Reduces main bincode snapshot size and structures both sidecars for future mmap-based loading at 1M-memory scale.
• Two-tier HNSW — delta_hnsw activates above 100 K memories (HNSW_TIER2_THRESHOLD). New inserts route to a small delta graph (O(log N_delta)) instead of the large base. Delta is merged into the base at checkpoint when it exceeds 10% of base size (HNSW_DELTA_MERGE_RATIO). Persisted as a .delta.hnsw sidecar alongside the base .hnsw. Search queries both tiers and fuses results via reciprocal rank fusion³.
• SSL NL gloss — gloss_ssl_content() in chitta/include/chitta/ssl_gloss.hpp translates SSL triplets (subject/predicate/object) into readable English sentences before embedding. Closes the representation gap between compact SSL format and BGE queries; SSL memories re-embedded via a one-time migration.
• Alias memories — when a new SSL memory is stored, a linked kind=alias NL counterpart is auto-created and connected via an alias-of triplet. Keeps NL and SSL representations synchronised without duplicating content.
• Embed worker fix — idle gate removed; the background embed worker now runs every 30 s during active sessions instead of waiting for an explicit activity signal. Pending queue clears even when the user is actively typing.
• pending_embed_ids MCP tool — new maintenance RPC to inspect or purge the stuck embed queue. Supports purge_orphans (drop entries whose memory no longer exists) and force_clear (forcibly clear a given set of IDs).

Fixed

• Compiler warnings (v5.21.54) — removed unreachable default_lsh_buckets() function (lsh_buckets is #[serde(skip)]); removed redundant top-level SessionRecallHit import in store.rs (re-imported locally inside the function); silenced #[allow(dead_code)] on InterventionStore::config field (reserved for future stale-threshold logic). Build is now warning-free.
• HNSW sidecar staleness check (v5.21.53) — load_hnsw() validated the sidecar node count against self.embeddings.len() (heap only); with mmap active and heap cleared that would always be 0, causing any loaded sidecar to be rejected as “larger than snapshot.” Now uses total_embedding_count() (heap + mmap offsets).
• Deleted set trimming (v5.21.52) — trim_deleted() on SemanticIndex retains only IDs still present as nodes in hnsw or delta_hnsw — the only structures that can surface a deleted ID in search results. Called at the end of every normalize_all() (once per WAL replay / restart); follows with shrink_to_fit() to return freed memory to the allocator. Prevents unbounded growth of the soft-delete set under high churn.
• binary_vec delete path (v5.21.51) — SemanticIndex::remove() now clears emb_offsets for the removed ID; previously mmap-sourced memories leaked into total_embedding_count() and all_ids() after deletion, inflating the binary guard threshold and including deleted IDs in HNSW rebuilds. purge_wrong_dim() now explicitly clears binary_vec and binary_vec_pos alongside binary_codes rather than relying on the normalize_all() length-mismatch rebuild.
• Mmap checkpoint data loss (v5.21.49) — save_embeddings_sidecar() previously wrote only the heap delta when mmap was active, overwriting the sidecar with a fraction of the dataset. Now copies raw f32 bytes directly from the mmap (zero-deserialise) and appends the heap delta; the next load and activate_mmap_embeddings() call recover the full combined dataset.
• Binary codes wipeout after mmap activation (v5.21.49) — normalize_all() rebuilt binary_codes by iterating self.embeddings (heap-only), producing an empty map when mmap was active and disabling the Hamming fast path. Now iterates all IDs via EmbLookup over both heap and mmap.
• provenance --cmd destination collision (v5.21.24).
• Pre-tool-hook exec bit restored after release tarball.

Fixed

• Queue JSONL corruption — hooks now enqueue via native chitta queue_write (single-syscall atomic append, JSON compaction); removes the ~40K/day [queue] FAILED: json parse error burst caused by multi-line jq output.
• Chain continuity warning spam — OpLog::replay() now resets chain_head = ZERO_HASH at instance-id prefix boundaries so independent per-instance segment chains no longer trigger header-level warnings (previously ~120K/day on startup).
• Dead-letter interleaving — sandbox::append_line_atomic() uses a single POSIX write() with O_APPEND | O_CLOEXEC and an EINTR/short-write loop.
• queue_write CLI arg parsing — flags interleaved after the subcommand no longer shift the tool/args slots.
• lib.sh fallback — when the chitta binary is absent, the bash fallback now compacts the JSON via python3 and fails loudly instead of silently injecting a malformed line.
• Safer deploy — CLAUDE.md documents atomic install (temp+rename) before systemctl restart, preserving daemon uptime across the binary swap.

Added

• Regression test replay_across_independent_instance_chains in chitta-field/src/log.rs covering the instance-boundary chain-reset invariant.

Added

• Agent Protocol Memory (Layer 8) — WAL-backed organ for tracking task ownership, delegation chains, evidence provenance, open probes, and completion criteria across multi-step agent loops.
• Task Contracts — register tasks with goal, constraints, acceptance criteria, priority, deadline, and parent/subtask links. Status FSM: Active → Blocked → Completed / Failed / Abandoned.
• Delegation Edges — record every agent handoff with from/to/handoff_note. Full delegation chain replays from WAL.
• Evidence Links — link memories to tasks as typed evidence (Observation, Artifact, Result, Analysis, UserFeedback) with relevance score and producer identity. Idempotent by (task_id, memory_id).
• Pending Probes — open questions blocking task completion. Probes carry expected answerer, priority, and resolve to Answered/Dismissed with recorded answer.
• Completion Criteria — upsert criteria against a task (idempotent by criterion text); mark met/unmet with evidence notes. Subconscious auto-completes tasks when all criteria are met.
• 10 new MCP tools — register_task, update_task, add_delegation, link_evidence, add_probe, resolve_probe, set_criterion, get_task, query_tasks, agent_protocol_stats.
• 7 new WAL op codes — OP_REGISTER_TASK=53 through OP_SET_CRITERION=59. Full crash-recovery replay.
• Subconscious integration — learning cycle auto-completes tasks with all criteria met; tasks_auto_completed stat tracked.

Added

• Intervention/Outcome/Attribution Ledger (Layer 7) — WAL-backed organ tracking agent actions before execution, observations during execution, and causal attribution after outcome.
• 10-class AttributionClass taxonomy — MemoryRecallError, SourceTrustError, ProcedureError, ToolExecutionError, EnvironmentShift, HiddenPrecondition, AmbiguousState, GoalSpecError, UserOverride, ExternalNondeterminism. Each class routes to a different learning subsystem.
• Attribution routing — MemoryRecallError → surprise credit; SourceTrustError → integration kernel source weight decrease; ProcedureError → skill memory demotion. Secondary class supported at 0.5× confidence.
• 8 new MCP tools — start_intervention, add_observation, close_intervention, record_attribution, query_interventions, get_intervention, intervention_stats, list_open_interventions.
• 4 new WAL op codes — OP_START_INTERVENTION=49 through OP_RECORD_ATTRIBUTION=52. Full WAL replay for crash recovery.
• Stale intervention auto-close — subconscious learning cycle closes interventions open longer than 30 minutes.

Added

• Autonomous Learning Pipeline — closes feedback loops from prediction errors to memory adaptation. Moves 1–6 push from “remembering” (~70%) to “learning” (~90%).
• Surprise Credit (Move 1) — hysteresis-gated strength adjustments. Rolling per-memory credit with gate threshold (|credit| ≥ 0.75, streak ≥ 2). Strength deltas clamped to ±0.08.
• Integration Kernel Feedback (Move 2) — repeated recall failures auto-decrease source trust via hard/soft thresholds.
• Debt Auto-Resolution (Move 3) — epistemic debts with sufficient evidence auto-resolved by subconscious learning cycle.
• Wisdom Promotion (Move 5) — clustered surprise patterns become wisdom candidates with lifecycle FSM: candidate → provisional → trusted → demoted.
• Learned Scorer (Move 6) — per-factor weight deltas from outcome calibration overlay the immutable scoring baseline.
• 9 new MCP tools — surprise_learning_stats, upsert_wisdom_candidate, update_wisdom_lifecycle, query_wisdom_candidates, wisdom_promotion_stats, attach_debt_evidence, update_scorer_model, learned_scorer_stats, effective_scorer_weights.
• 5 new WAL op codes — OP_UPDATE_SURPRISE_CREDIT=44 through OP_ATTACH_DEBT_EVIDENCE=48. All replay from WAL.
• Subconscious learning cycle — 30-minute deferred job for debt auto-resolution, scorer refresh, and wisdom candidate preparation.

Added

• Surprise Memory (Layer 4) — Prediction error tuples that reveal blind spots. Record what was expected vs what actually happened; query recurring surprise patterns; identify domains where predictions consistently fail. SurpriseDomainFactor in scoring pipeline boosts “actual” outcomes and suppresses wrong “expected” predictions. Friston (2010)²⁷.
• Epistemic Debt (Layer 5) — Uncertainty boundaries and competing hypotheses. Register fragile beliefs with competing explanations and discriminating tests; resolve or defer debts as evidence accumulates. EpistemicDebtFactor boosts memories in uncertain domains. Sperber et al.²⁸ (2010).
• Integration Kernel (Layer 6) — Recall source arbitration with learned weights. Track which recall sources (semantic, keyword, temporal, artifact, association) are useful per domain; weights update via Bayesian feedback. IntegrationWeightFactor applies learned source weight as multiplier. Shazeer et al.²⁹ (2017).
• 14 new MCP tools — record_surprise, query_surprises, get_blind_spots, surprise_stats, register_debt, resolve_debt, defer_debt, query_debts, get_fragile_decisions, debt_stats, record_feedback, get_source_weights, update_source_weight, integration_stats.
• 18-factor scoring pipeline — 3 new factors (SurpriseDomain, EpistemicDebt, IntegrationWeight) extend the pipeline from 15 to 18 composable factors. New config params in scoring.json.
• 5 new WAL op codes — OP_RECORD_SURPRISE=39, OP_REGISTER_DEBT=40, OP_UPDATE_DEBT=41, OP_UPDATE_SOURCE_WEIGHT=42, OP_RECORD_FEEDBACK=43. All replay from WAL — no snapshot version bump needed.

Added

• Executable Constraints (Layer 1) — Prolog-style logic engine. Assert/retract facts, unify variables, chain queries. Supports hypothetical branches for what-if reasoning.
• Trigger Tissue (Layer 2) — Event-condition-action rules that fire automatically when patterns match. Define triggers on memory events; the daemon evaluates conditions and fires actions.
• Predictive Memory (Layer 3) — Markov chain access predictor. Learns transition probabilities between memory accesses; pre-warms predicted-next-needed memories. PredictionBoost scoring factor.
• Three-layer paradigm — Constraints, triggers, and predictors follow the organ pattern: Rust store → WAL replay → FFI → C++ handlers → MCP tools.
• InterferenceDensity factor — Price of Meaning: penalty for local competitor crowding in the scoring pipeline.
• SpacingBoost factor — Geometry of Forgetting: well-spaced accesses boost recall.

Fixed

• Filter empty-content ghosts from all Rust recall paths (semantic, keyword, temporal, artifact).
• Missing trajectory_compact.hpp header broke CI.

Added

• ScoringPipeline — Neuroplastic trait-based scoring architecture. 12 composable scoring factors (Relevance, ACT-R¹, Strength, Confidence, Surprise, Arousal, MoodCongruence, FrustrationEscalation, Status, Epistemic, Kind, RealmReliability). Runtime-configurable via scoring.json with hot-reload.
• Externalized scoring constants — All 30+ hardcoded scoring constants moved to scoring.json. Every factor has independent weight, bias, and parameters.
• StrengthFactor — Added to pipeline (was missing from initial release).

Fixed

• V6→V7 snapshot migration for access_timestamps field.
• Safety guards: fallback snapshot loading (tries all snapshots if best fails), refuse-to-start-empty protection (prevents silent data loss when snapshots cannot deserialize).
• CI test fixes for scoring decomposition.

Added

• ACT-R base-level activation — Anderson & Schooler (1991) power-law decay over access history. Frequently and recently accessed memories get higher activation.
• Surprise-weighted scoring — FEP §2.3 surprise signal modulates retrieval score. High-surprise memories are boosted during recall.
• Arousal-modulated retrieval — Flashbulb memory effect: high-arousal memories receive retrieval boost proportional to arousal intensity.
• Mood-congruent recall — Bower²⁰ (1981): query affect is matched against memory affect for boosted retrieval when valence/arousal align.
• Frustration-escalation correction boost — Negative valence + high arousal boosts correction and preference memories, surfacing fixes when the user is frustrated.
• New FFI — cf_recall_semantic_ctx with query affect context for affect-aware retrieval.

Added

• Spectral geometry stats — Graph-theoretic analysis of the memory triplet network: eigenvalue spectrum, clustering coefficients, and connectivity metrics.
• Anomaly detection — Automatic detection of anomalous memory patterns using spectral methods.
• Realm hygiene — Automated cleanup of orphaned or miscategorized realm assignments.
• Drift tracking — Monitor semantic drift of memory clusters over time.

Added

• Skill versioning — Skills track version history, enabling rollback and diffing across iterations.
• Agent registry — Central registry of known agents with capabilities and routing metadata.
• Dashboard expansion — New panels for skill versions, agent status, and memory health.

Fixed

• Tag system — consistent creation, filtering, and surfacing across all layers.
• Chain replay tolerance + code-intel advisory hooks.
• kind_mul in score decomposition test.

Added

• SSL v0.3 — Soul Shorthand Language v0.3: affect encoding, semantic flags, cross-references, and two-tier compression for compact memory serialization.
• Token budget tracking — Session size, subagent caps, and cost telemetry tracked per hook invocation.

Fixed

• list_memories_brief ID truncation and rewrite migration script.

Added

• Edit/Write interception — fp (file-patch) hooks intercept Edit and Write tool calls for diff-first editing. Snakemake/Nextflow RTK support.
• Charge system — Hierarchical token budget for expensive casts. /checkpoint reclaims +20 charge.
• Cache expiry warning — Hook warns on idle >5 min when prompt cache is about to expire.
• Realm-aware novelty gate — P1–P2 novelty gating with kind scoring per realm.

Fixed

• Route [thought] memories to soul:meta realm; hybrid lane in prompt-hook.
• Keyword recall lane for exact token matching.
• Filter [thought] synthesis memories from prompt-hook output.

Added

• LocalBrain tool-calling — Real tool-calling for local LLM (gemma4:26b) via HTTP backend. Daemon-side dream publishing with JSON content assembly.
• Unified Codex plugin — chitta-mcp-install [claude-code|codex|all] for cross-platform plugin deployment.
• chitta-rtk — Native token-optimized command filter (RTK). Compiled Rust submodule replaces script-based approach. Handles gh pr/issue/run.
• Intercept native tools — Pre-tool-hook intercepts Read/Grep/Glob for token savings.
• Rich message metadata — sender_realm, sender_host, memory_id in inbox; full content display.
• Thinking distillation — Distill thinking-block snippets via gemma4:26b.
• Messaging system — msg_respond tool for reply routing; msg_inbox filtering and ack.

Fixed

• Per-turn soul recall dedup + remove unfiltered fallback recall.
• Tag param in recall was ignored — now hard-filters by triplet lookup.
• Skip soul recall for subagent Bash calls via agent_id detection.
• Skip session-start topology for subagent sessions.
• Strip system markup from prompt-hook before recall.
• Codex SessionStart hooks — JSON wrapper + dedup merge + 15s subconscious timeout.

Added

• Ingest/wiki/health-check/training-export pipelines — DuckDB naming cleanup and unified data pipeline tooling.
• Affect dimensions — Full stack integration of valence and arousal affect dimensions across storage, retrieval, and display.
• HTTP backend for ingester — Uses Ollama/vLLM directly (default: gemma4:26b). Removes all opencode dependencies.

Fixed

• Prevent release with unpushed submodules.
• Copy msg-notify to /tmp before exec to avoid NFS lock on plugin dir.

Added

• FEP attractor network — Self-orthogonalizing memory representations derived from the Free Energy Principle (Spisak¹⁹ & Friston, Neurocomputing 2026). Three-phase integration across chitta-field and the C++ daemon.
• Asymmetric prototype transitions — Forward direction gets full coupling strength; reverse is attenuated to 0.3×. Sequential data produces non-equilibrium dynamics.
• Asymmetric triplet weights — New reverse_weight field with #[serde(default)] backward compatibility.
• Surprise-modulated plasticity — Reconstruction error modulates decay rate. High-surprise memories resist forgetting; predictable ones fade faster.
• Attractor-based pattern completion — attractor_settle() iteratively blends query with prototype centroids and follows asymmetric transitions. New Route::Attractor in route learner.
• Hopfield³³ network — Asymmetric energy-based attractor network over memory co-activations with multi-hop directed settling.
• Self-orthogonalizing encoder — FEP-derived learning rule: prediction error + complexity penalty + Gram-Schmidt decorrelation between active atoms.
• Free-energy merge criterion — Deduplication uses accuracy-vs-complexity tradeoff instead of fixed cosine threshold.
• Adaptive vigilance — Prototype creation threshold adjusts based on aggregate reconstruction error.
• New FFI exports — cf_reconstruction_error, cf_memory_surprise, cf_search_attractor, cf_hopfield_co_retrieval, cf_hopfield_stats, cf_adapt_vigilance.

Fixed

• Negative start_turn in read_transcript — Python-style negative offsets now work correctly.
• CLI parser treats -5 after --start_turn as a value, not a flag.