0.8.2.28 APR/10/2026
  - feat(temporal): add temporal edge validity with schema V3 migration
    - Add valid_at/invalid_at fields to ThoughtRelation for explicit temporal
      bounds (e.g. "this fact was true from 2024 to 2025")
    - invalidated_thought_ids: HashSet<Uuid> built at chain open time from all
      Supersedes, Corrects, Invalidates relations for O(1) superseded detection
    - as_of: Option<DateTime<Utc>> on RankedSearchQuery enables point-in-time
      queries: excludes thoughts appended after the timestamp and thoughts
      superseded by thoughts appended at or before the timestamp
    - Schema V3 with full V2→V3 migration: LegacyThoughtRelationV2 (3-field),
      LegacyThoughtV1, migrate_v2_thoughts() with hash chain rebuild
    - Version-aware load_binary_thoughts() with peek_first_schema_version()
    - Bincode empty-Vec fast-path guard: always check schema_version after
      successful deserialization to detect silently-wrong old chains
    - REST API: RankedSearchRequest exposes as_of parameter
    - append_thought() auto-sets valid_at = Some(now) on new relations
    - ThoughtRelation::new(kind, target_id) convenience constructor
    - open_with_storage() persists migrated chains so future opens use native
    - migrate_legacy_chain_v0() generalized to detect actual from_version
    - REST API: rest_append_handler includes valid_at/invalid_at fields
  - feat(dedup): add automatic memory deduplication with Jaccard similarity
    - When dedup_threshold is set, each new thought's normalized lexical tokens
      are compared against recent thoughts using Jaccard similarity
    - If the best match exceeds threshold (0.0–1.0), a Supersedes relation is
      auto-added pointing to the most similar prior thought
    - dedup_scan_window (default 64) limits how many recent thoughts are scanned
    - Configurable via MENTISDB_DEDUP_THRESHOLD and MENTISDB_DEDUP_SCAN_WINDOW
    - MentisDb::with_dedup_threshold() and with_dedup_scan_window() builders
    - MentisDbServiceConfig: with_dedup_threshold(), with_dedup_scan_window()
    - invalidated_thought_ids updated correctly on auto-supersede
  - feat(scopes): add multi-level memory scopes via tag-based MemoryScope
    - MemoryScope enum: User (default), Session, Agent — stored as scope:user,
      scope:session, scope:agent tags to avoid schema migration
    - ThoughtInput::with_scope() adds the tag automatically
    - RankedSearchQuery::with_scope() filters by scope tag
    - REST API: AppendThoughtRequest.scope and RankedSearchRequest.scope
    - MemoryScope::as_tag(), from_tag(), Display impl for round-tripping
  - feat(cli): add add, search, agents subcommands via daemon REST
    - mentisdbd add <content> [--type] [--scope] [--tag] [--agent] [--chain] [--url]
    - mentisdbd search <query> [--limit] [--scope] [--chain] [--url]
    - mentisdbd agents [--chain] [--url]
    - Default REST URL: http://127.0.0.1:9472
    - Uses ureq for synchronous HTTP (no async runtime needed)
    - AddCommand, SearchCommand, AgentsCommand structs in cli::args
    - Updated help text with new subcommand documentation
  - fix(clippy): remove dead load_legacy_v0_thoughts/load_legacy_v0_binary_thoughts
    functions and convert match→if let in load_binary_thoughts fast path

0.8.1.27 APR/10/2026
  - feat(search): session cohesion boost and improved importance/vector/graph scoring
    - Session cohesion: thoughts within ±8 positions of a high-scoring lexical
      seed (score >= 3.0) receive a proximity boost up to 0.8, decaying linearly
      with distance — surfaces evidence turns adjacent to the matching turn but
      sharing no lexical terms; seeds with lexical≥5.0 excluded from boost;
      self excluded via nearest>0 guard
    - Importance scoring: replace flat 3.0× multiplier with differential boost
      proportional to lexical score (lexical × (importance-0.5) × 0.3)
    - Vector-lexical fusion: replace step-function boosts with smooth exponential
      decay; VECTOR_ONLY_BOOST=35, VECTOR_DECAY_RATE=3.0 — faster decay reduces
      vector interference with moderate-lexical results, improving ranking
      precision for queries with partial lexical overlap
    - BM25 DF cutoff lowered 50%→30% — filters non-discriminative entity names
      that appear in many turns without contributing relevance signal
    - ContinuesFrom relation kind boost raised 0.12 → 0.30; Corrects/Invalidates
      0.18 → 0.25; Supersedes 0.16 → 0.22; DerivedFrom 0.14 → 0.20
    - Graph proximity score raised 0.3/depth → 1.0/depth; seed support per extra
      seed 0.05 → 0.1 (max 5); MAX_GRAPH_SEEDS cap of 20 to bound BFS cost
    - Add session_cohesion field to RankedSearchScore for observability
    - LoCoMo 2-persona R@10: 55.8% (baseline) → 88.7%, single-hop 90.7%
    - LoCoMo 10-persona R@10: 74.2% (full benchmark, 1977 queries)
    - LongMemEval R@5: 65.0% → 67.6%, R@10: 70.6% → 73.2%
  - feat(locomo-benches): expand evidence with session-neighbor turns
    - _expand_evidence() broadens gold evidence to ±2 turns around each target
      within the same session group for fairer hit evaluation
    - Build session_map in load_locomo() for O(1) neighbor lookup
    - Show up to 5 evidence snippets in miss output (was 3)
  - fix(dashboard): guard against NaN/Infinity floats and null agents
    - with_confidence() and with_importance() now reject non-finite floats
      (NaN.clamp() returns NaN in Rust, which crashes serde_json serialization)
    - thought_json() sanitizes confidence/importance before json!() macro
    - renderAgentList() filters null agents to prevent JS TypeError
  - fix(server): propagate chain_key in RelationInput for cross-chain relations
    - RelationInput struct was missing the chain_key field; all cross-chain
      relation writes via REST and MCP silently defaulted to None, dropping
      the target chain reference and breaking cross-chain graph traversal
  - fix(server): add session_cohesion field to RankedSearchScoreResponse
    - Missing from initial session_cohesion commit which only added it to the
      dashboard response; REST /v1/ranked-search would fail to compile
  - fix(dashboard): add session_cohesion field to DashboardRankedScoreResponse
    - Mirrors the new session_cohesion field in RankedSearchScore so the
      dashboard serialization compiles and exposes the new score component
  - fix(ci): rustfmt formatting issue in session cohesion code
    - Use abs_diff() for correct single-line formatting that passes CI check

0.8.0.26 APR/08/2026
  - feat(search): Porter stemming in lexical tokenizer (normalizer v2)
    - Added rust-stemmers dependency with English Porter stemmer
    - normalize_lexical_tokens() now stems all tokens before indexing and
      querying so word variants share a common root (e.g. prefers/preferred/
      preferences → prefer)
    - LEXICAL_NORMALIZER_VERSION bumped to 2 to force index rebuilds
    - LongMemEval R@5 improved from 57.2% to 61.6% (stemming alone)
  - feat(search): tiered vector-lexical fusion in ranked-search scoring
    - Replace flat lexical+vector addition with tiered boost: vector gets
      60× when lexical==0, 20× ramp when lexical<1.0, additive otherwise
    - Surfaces semantically-relevant hits without overriding strong lexical
      matches (fixes preference-category regression from previous RRF approach)
    - LongMemEval R@5 improved from 61.6% to 65.0% (fusion + importance)
  - feat(search): boost importance weight from 0.2× to 3.0× in ranked scoring
    - User-originated thoughts (importance=0.8) now get +2.4 vs assistant
      thoughts (importance=0.2) at +0.6 — enough to tip close BM25 races
      where verbose assistant responses dominated preference/factual queries
  - feat(search): lower MIN_VECTOR_COSINE threshold from 0.12 to 0.06
    - Catches more short-evidence semantic matches that previously fell
      below the cosine cutoff
  - feat(thought): add Goal thought type for high-level objectives
    - Broader than Plan (which describes how) and Subgoal (a component)
    - Captures what the agent is trying to achieve so future sessions
      can orient quickly even if plan details have changed
    - Appended at end of ThoughtType enum (bincode-safe); dashboard
      string parser and startup-sound sequence updated
  - perf: -13.8% single-append latency (p=0.01) via three hot-path improvements:
    - Zero-copy record assembly: encode directly into length-prefixed Vec with one allocation
      using encode_into_std_write() — eliminates intermediate copy in append_thought
    - Bincode hashing: compute_thought_hash() now uses bincode instead of serde_json,
      eliminating a full JSON serialization per append (bincode ~3-5x faster for structs)
    - Configurable group commit window via MENTISDB_GROUP_COMMIT_MS env var (default 2ms);
      set to 0 for lowest latency, higher for bulk-load throughput
    - Double background write queue capacity (FLUSH_THRESHOLD*8 = 128 slots) to reduce
      backpressure stalls under concurrent multi-agent writes
    - Pre-allocate background writer buffer to FLUSH_THRESHOLD*512 bytes
  - security(skills): SkillReadOutput wrapper — SkillRegistry::read_skill() now returns
    SkillReadOutput { content, warnings, status } instead of a plain String, so callers
    can no longer silently ignore skill warnings or revocation status
  - security(skills): add MAX_SKILL_SIZE_BYTES=1MB limit to import_skill() to prevent
    unbounded skill uploads from exhausting server memory
  - security(skills): add XSS warning to render_markdown_skill() doc comment — output is
    raw Markdown, callers MUST sanitize before rendering in HTML contexts
  - security(skills): lower per-thought MAX_THOUGHT_PAYLOAD_BYTES from 64 MB to 10 MB
    as DoS protection against large blob uploads on shared chains
  - security(dashboard): add rate limiting to /dashboard/login — 5 failed attempts per IP
    within 5 minutes returns 429 Too Many Requests; counter resets on successful login
  - security(dashboard): use subtle::ConstantTimeEq for PIN comparison to prevent timing
    attacks; add subtle=2.6 dependency
  - refactor(skill): rewrite MENTISDB_SKILL.md from 68,270 to ~8,000 chars
    - Mandatory startup protocol as FIRST section (was buried at line 280 of 1579)
    - Explicit WRITE TRIGGERS table consolidating 4 scattered trigger definitions
    - All 29 thought types listed from codebase (was missing 13 types)
    - Back-referencing & thought graph section with full relation kinds table
    - Sub-agent orchestration rules (context ≤50%, flush before exit, handoffs)
    - Skill registry section (git-like versioning, upload/read/deprecate/revoke)
    - Added explicit READ-BEFORE-WRITE rule and per-turn write trigger checklist
    - Anti-patterns as concise list (was prose sections)
  - remove(JsonlStorageAdapter): binary is the only supported format for new chains
    - JsonlStorageAdapter re-opened the file on every append (O(n) file handles per chain)
    - StorageAdapterKind::Jsonl retained for registry backward-compat and migration reads
    - Legacy .jsonl chains still readable via mentisdbd migrate; write path removed
    - MentisDb::open_with_key_and_storage_kind returns Err if called with Jsonl
  - refactor(sidecar): ManagedSidecarEntry with auto_sync flag
    - Introduce ManagedSidecarEntry wrapping provider + auto_sync so FastEmbed
      can be registered for search without per-append ONNX cost during bulk
      ingestion
    - Add register_vector_sidecar_for_search() for search-only registration
    - FastEmbed auto-init now uses search-only registration instead of
      manage_vector_sidecar(), avoiding initial full rebuild on startup
  - fix(integrations): Claude Desktop mcp-remote bridge uses explicit node path
    as command to bypass shebang resolution picking an older Node.js version
    (mcp-remote requires Node >= 20; its undici dependency uses the File global
    added in Node 20, causing ReferenceError: File is not defined on Node 18)
  - fix(integrations): BridgeCommand struct carries both node_path and
    mcp_remote_path; detect_node_path() prefers the same directory as
    mcp-remote first (handles nvm-managed installs)
  - fix(cli): ensure_prerequisites() now validates Node >= 20 before
    installing or accepting mcp-remote; clear error messages guide users to
    upgrade via nvm/fnm
  - fix(integrations): remove hardcoded platform-specific mcp-remote paths
    from plan.rs; setup plan snippet and notes updated for node+mcp-remote
    pattern with Node >= 20 requirement
  - fix(integrations): fix qwen.rs to use set_path() instead of ensure_path(IfMissing)
    so $version=3 is always written (not silently skipped when present)
  - fix(bench): --force-reingest creates fresh timestamped chain
    - Prevented duplicate ingestion into the same chain (was causing 3×
      duplicate entries that corrupted vector sidecar results)
    - Switch rebuild_vectors to fastembed-minilm provider (was local-text-v1)
    - Increase graph max_visited from 50 to 200 for cross-session recall
    - Increase rebuild timeout from 300s to 600s for large chains
  - feat(bench): add full_bench.sh one-shot benchmark runner
    - Starts mentisdbd, waits for health, creates a fresh chain, and runs
      the full LongMemEval pipeline (ingest + vector rebuild + eval)
  - refactor(server): extract HasOptionalQueryFields trait — build_query, build_markdown_query,
    and build_traversal_query now share apply_optional_query_fields() helper (~40 lines)
    eliminating ~150 lines of duplicated optional-field application logic
  - refactor(platform): extract PlatformPaths struct in mod.rs to centralize home directory,
    config_root, and copilot_root computation for linux/macos/windows; reduces boilerplate
    by 8-18 lines per platform file
  - refactor: extract read_length_prefixed_thoughts<T> helper to DRY the two identical
    ~40-line bincode length-prefix read loops in load_legacy_v0_binary_thoughts and
    load_binary_thoughts; net ~70 lines removed; MAX_THOUGHT_PAYLOAD_BYTES hoisted
    to module-level constant
  - code(lib): fix unresolved doc links — to_memory_markdown → MentisDb::to_memory_markdown,
    append_thought → MentisDb::append_thought, Corrects/Invalidates →
    ThoughtRelationKind::Corrects/Invalidates; remove broken link to private WriterState
  - docs(README): rewrite Claude Desktop setup section with node+mcp-remote
    config pattern, Node >= 20 requirement, nvm/Homebrew examples, and
    shebang-issue explanation; recommend mentisdbd setup claude-desktop as
    primary setup path
  - docs(README): add MENTISDB_TLS_CERT, MENTISDB_TLS_KEY, MENTISDB_HTTPS_MCP_PORT,
    MENTISDB_HTTPS_REST_PORT environment variable documentation
  - docs(MENTISDB_SKILL.md): fix all wrong REST API examples — /v1/memories/append
    → POST /v1/thoughts, /v1/memories/search (GET) → POST /v1/search, and
    /v1/memories/recent (GET) → POST /v1/recent-context with JSON body
  - docs(MENTISDB_SKILL.md): add Step 0 chain/agent auto-selection guidance for agents
  - docs(WHITEPAPER): remove 'DRAFT:' prefix from title
  - bench: add append_latency_percentiles group (p50/p95/p99 per-append via iter_custom)
    and concurrent_append_query group (2/4/8 writer+reader threads on shared Mutex<MentisDb>)
  - test: add test_read_skill_nonexistent_version() asserting NotFound error for invalid
    version_id; update all read_skill() call sites to use .content for string operations
  - test: update Claude Desktop apply test for node+mcp-remote bridge
    pattern; add parse_node_major and snippet Node-requirement tests

0.7.7.25 APR/05/2026
 - fix(dashboard): Add Agent modal Memory Chain dropdown showed numeric indices instead of chain names
   - GET /dashboard/api/chains returns an array of objects; JS was calling Object.keys() on the array
     which yielded "0", "1", etc. instead of chain_key values
   - Fixed by checking Array.isArray and mapping c.chain_key before sorting

0.7.6.24 APR/04/2026
 - feat(dashboard): clickable relation thought-id links in Thought Detail popup
   - Relation target_id values in the Thought Detail modal are now styled
     blue underlined buttons instead of plain <code> spans
   - Clicking a relation target fetches the related thought via
     GET /dashboard/api/thoughts/{chainKey}/{thoughtId} and opens it in a
     new Thought Detail modal, enabling full navigation depth through
     related thoughts
   - Cross-chain relations resolve correctly using the relation's own
     chain_key when set, falling back to the current modal's chain context
   - All openModal() call sites updated to propagate chain key so relation
     navigation works from every view (explorer, agent detail, agent
     thoughts)
 - feat(dashboard): Upload Skill form on Skills page
   - Added POST /dashboard/api/skills endpoint (DashboardUploadSkillBody,
     api_upload_skill handler) accepting agent_id, content, optional
     skill_id, and format (markdown/json)
   - Skills page now has a "+ Upload Skill" button that opens a modal with
     Agent ID, Skill ID, Format, and Content textarea fields
   - On success the skill list reloads automatically after 1.8 s
 - feat(dashboard): Add Agent form on Agents page
   - Added POST /dashboard/api/agents endpoint (AgentCreateBody,
     api_create_agent handler) — creates or updates an agent registry
     entry; preserves existing status on update
   - Agents page now has a "+ Add Agent" button that opens a modal with a
     chain dropdown (populated live from existing chains), Agent ID,
     Display Name, Owner, and Description fields
   - Chain dropdown auto-populates from GET /dashboard/api/chains on open;
     on success the Agents page reloads scrolled to the correct chain
 - feat(skill): MENTISDB_SKILL.md — Large Chain Context Budget section
   - New section documenting index hierarchy table (6 levels from hybrid
     ranked search down to full traversal), chain-size tiers with
     recommended strategies (< 50 / 50-200 / 200-500 / > 500 thoughts),
     Checkpoint-First Bootstrap pattern for chains > 100 thoughts, per-query
     token budget caps, filter-before-load discipline rules, ranked_search
     as the default for topical queries on large chains, guidance on
     avoiding redundant context loads after search, and summarize-in-waves
     pattern for historical audits
   - Session Reload Summary section updated to reference Checkpoint-First
     Bootstrap on large chains instead of a raw recent_context dump
   - Operating Loop section updated to call mentisdb_head first and apply
     the size-appropriate retrieval strategy

0.7.5.23 MAR/31/2026
 - fix(auto-update): robust restart after cargo install
   - Removed the silent current_exe() fallback in install_latest_release():
     if installed_binary_path() is not found, PATH is now searched before
     giving up with a clear error — prevents exec() silently re-running the
     old binary when CARGO_INSTALL_ROOT or CARGO_HOME differ from defaults
   - shutdown_all_servers() errors during restart are now treated as warnings
     instead of aborting the entire restart flow; the exec/spawn proceeds
     regardless so a partially-shut-down server no longer leaves the user
     with no running daemon
   - exec() failure on Unix is now logged explicitly and falls back to
     spawn() + process::exit(0), ensuring the old process always terminates
     and the new one always starts even if exec() cannot replace the process
     image (e.g. due to Tokio FD state on macOS multi-threaded runtimes)
   - Update prompt now defaults to N on empty input [y/N]; prompt_yes_no
     extracted to prompt_yes_no_with_io for testability
   - Added four tests covering prompt defaults, y/n responses, and invalid
     input handling

0.7.4.22 MAR/30/2026
 - fix(daemon): conditional agent primer with HTTPS + friendly address
   - Primer box is now context-aware: no chains → full bootstrap primer
     (bootstrap chain, load mentisdb://skill/core, write Summary); chains
     exist → short resume notice directing the agent to
     mentisdb_recent_context since MCP initialize auto-delivers setup
     instructions on connect
   - Primer always shows the HTTPS MCP address when TLS is running, falls
     back to plain HTTP otherwise
   - my.mentisdb.com:<port> friendly alias now shown as an alternative
     address alongside the 127.0.0.1 local address
 - refactor(tests): move inline mentisdbd tests to tests/mentisdbd_tests.rs
   - Removed the #[cfg(test)] mod tests block from src/bin/mentisdbd.rs;
     all three agent-primer tests now live in the external test suite so
     the public API surface is exercised the same way third parties would
     use it and test parallelism is easier to manage

0.7.3.21 MAR/30/2026
 - fix(skills): dashboard and service now refresh the skill registry without restart
   - The shared in-process `SkillRegistry` now reloads itself when `mentisdb-skills.bin` changes on disk, so newly uploaded or updated skills appear immediately
   - Dashboard skill list/detail/diff/version views and skill lifecycle actions now read against the refreshed registry instead of requiring a full `mentisdbd` console restart
   - MCP/REST skill reads and writes also refresh before use, keeping agent uploads and the dashboard in sync even when skills are added from another surface
 - feat(wizard): interactive checkbox TUI for integration selection
   - Replaced the confusing text prompt ("default", "all", "none") with a
     live checkbox list rendered in raw terminal mode
   - Detected integrations show as [x] (will be configured) or [ ] (skipped)
     with a navigable > cursor; arrow keys or j/k move the cursor, Space
     toggles an item, 'a' selects all, 'n' deselects all, Enter confirms,
     Esc restores the auto-detected defaults
   - Falls back to the text-based boxed prompt when stdin is not a terminal
     (CI pipelines, piped input, --yes flag) so non-interactive use is
     unaffected
   - Added crossterm dependency for raw terminal key-event handling
 - fix(wizard): clippy implicit_saturating_sub lint in cursor navigation
   - Replaced guarded `cursor_idx -= 1` with `cursor_idx.saturating_sub(1)`
 - feat(daemon): agent primer notice printed at startup
   - `mentisdbd` now prints a copy-paste primer prompt after the endpoint
     addresses at startup so users can immediately hand their AI agent the
     exact one-liner needed to bootstrap memory for a project
   - The primer box shows the MCP address (and dashboard URL when TLS is
     enabled) and walks the agent through `mentisdb_bootstrap`, loading
     `mentisdb://skill/core`, and writing a first Summary checkpoint
   - Implemented as `build_agent_primer_lines(mcp_addr, dashboard_url)` with
     two unit tests covering the with- and without-dashboard cases
 - feat(docs): "Priming Your Agent" section on mentisdb.com
   - New `<Priming/>` Leptos component with a 3-step visual walkthrough:
     bootstrap the chain, load the skill rules, write a Summary checkpoint
   - Includes a copyable primer prompt block matching the startup box wording
     so users can grab it straight from the docs site
   - Section positioned after the InstallBox and before the Problem section;
     navbar gets a `#primer` anchor link between Rust Docs and Install CTA

0.7.2.20 MAR/29/2026
 - feat(search): managed vector sidecars and seamless hybrid ranked retrieval
   - Added a built-in local text embedding provider plus persisted per-chain managed vector-sidecar settings for `mentisdbd`
   - Managed sidecars now stay synchronized on append when enabled, and ranked search automatically blends lexical, graph, and vector signals through `hybrid` / `hybrid_graph` backends instead of requiring a separate semantic-search mode
   - Ranked result payloads now expose a `vector` score component across crate, REST, MCP, and dashboard surfaces, and strong semantic hits can surface even when lexical overlap is weak or absent
   - Vector sidecar writes now go through temp-file replacement, stale/corrupt sidecars degrade cleanly back to lexical+graph retrieval, and deleting a chain removes its sidecar/config artifacts
 - feat(dashboard): per-chain vector-sidecar management and hybrid-search visibility
   - Chain detail pages now show vector-sidecar status, freshness, indexed-thought counts, and the on-disk sidecar path for each managed provider
   - Added dashboard actions to enable/disable append-time sidecar sync, run `Sync now`, and `Rebuild from scratch` with explicit delete-and-recreate confirmation
   - The `Vector Sidecars` panel is now collapsible and collapsed by default so it does not get in the way of the search form
   - Explorer search copy and ranked result metadata now reflect the fact that dashboard search transparently uses lexical, graph, and managed vector retrieval when available
 - feat(setup): refresh first-run and integration-setup behavior
   - `mentisdbd` can now launch the interactive setup wizard directly from the first-run daemon notice
   - Claude Code setup now targets the global `~/.claude.json` / `%USERPROFILE%\\.claude.json` config (`mcpServers.mentisdb`), while the legacy `~/.claude/mcp/mentisdb.json` path remains detectable as a legacy companion file
   - GitHub Copilot CLI setup remains `~/.copilot/mcp-config.json` by default and respects `XDG_CONFIG_HOME/copilot/mcp-config.json` on XDG hosts
   - Expanded setup/apply/wizard regression coverage to lock the current path and detection behavior in place
 - docs: refresh README and release-facing docs for the current system reality
   - Updated README to document managed vector-sidecar APIs, default daemon behavior, transparent hybrid search, dashboard vector controls, and the current setup targets for Claude Code and Copilot
   - Added/updated regression coverage that keeps the release docs aligned with the implemented search/vector behavior

0.7.1.19 MAR/28/2026
 - feat(dashboard): wire chain explorer search to ranked retrieval and context bundles
   - Dashboard chain search now uses canonical ranked lexical+graph retrieval when search text is present, while preserving chronological filtering for plain agent/type-only browsing
   - Added grouped dashboard context-bundle inspection so operators can see seed-anchored supporting thoughts without flattening the entire graph into one list
   - Thought modal now surfaces ranked-search metadata such as score breakdowns, matched terms, graph distance, relation kinds, and bundle support preview
   - Added dashboard regression coverage for ranked search pagination, graph-support retrieval, grouped bundles, and legacy non-text filtering behavior
 - feat(search): add optional vector sidecars for semantic retrieval
   - Added `search::EmbeddingProvider`, `EmbeddingMetadata`, cosine-ranked `VectorIndex`, and deterministic vector validation helpers for provider-agnostic embedding pipelines
   - Added rebuildable per-chain vector sidecars with explicit integrity digests, model/version separation, and freshness states that distinguish fresh sidecars from stale or mismatched ones
   - Added explicit crate APIs to rebuild, load, inspect, and query vector sidecars without changing default `ThoughtQuery` or ranked-search behavior
   - Added regression coverage for vector ranking, sidecar corruption detection, model/version separation, stale-after-append behavior, and plain-chain fallback when the sidecar is damaged
 - feat(bootstrap): surface active skills in bootstrap response
   - `BootstrapResponse` now includes an `available_skills: Vec<SkillSummary>` field listing every active skill in the registry at spawn time
   - Uploaded skills are now discoverable at bootstrap time, but agents should only load trusted or relevant skills after verifying provenance
   - Core operating instructions are delivered through MCP `initialize.instructions` plus `resources/read(mentisdb://skill/core)`; uploaded skills are additive, not the bootstrap source of truth
 - fix(bootstrap): correct lock ordering to eliminate future deadlock risk
   - `bootstrap()` now captures `thought_count` and `head_hash`, drops the chain write-lock, then acquires the skills read-lock
   - Previously both locks could be held simultaneously; the fix ensures only one unrelated lock is held at a time
 - change(mcp): update tool descriptions to enforce eager spawn and checkpoint discipline
   - MCP `initialize.instructions` now points agents at `mentisdb://skill/core` so the official operating skill is discoverable without relying on out-of-band REST knowledge
   - `mentisdb_skill_md` remains as a compatibility fallback for clients that cannot read MCP resources
   - `mentisdb_bootstrap`: keeps checkpoint discipline guidance and available-skill discovery, but no longer carries the whole bootstrap burden by itself
   - `mentisdb_append`: emphasises saving a Summary/Checkpoint eagerly at every meaningful milestone and always before compaction, truncation, or agent handoff
   - `mentisdb_append_retrospective`: clarifies scope as hard failures, repeated snags, and non-obvious fixes only; adds requirement to call before context compaction or handoff so lessons survive agent clearance
   - `mentisdb_read_skill`: aligned to "trusted or relevant skills" language; references the `available_skills` bootstrap field and adds provenance warning for unknown skills
 - test(server): add bootstrap `available_skills` regression tests
   - New test: `bootstrap_response_includes_empty_available_skills_when_registry_is_empty` — asserts the field is present and empty when no skills are registered
   - New test: `bootstrap_response_includes_active_skills_after_skill_upload` — uploads a skill then bootstraps and asserts the skill appears in `available_skills` with the correct `skill_id` and `status`

0.6.4.17 MAR/24/2026
 - feat(storage): durable group commit for strict binary writes
   - `BinaryStorageAdapter` now routes `auto_flush=true` appends through the bounded background writer and acknowledges them only after the worker flushes to the OS
   - Concurrent strict-mode appends can share a short group-commit window, reducing contention while preserving zero-loss semantics for acknowledged writes
   - Added regression coverage to prove a strict append is already visible on disk before the original chain handle is dropped
 - fix(storage): buffered writes now behave like real buffering instead of silent data loss
   - `MENTISDB_AUTO_FLUSH=false` continues to persist thoughts through the background writer instead of skipping thought storage entirely
   - Buffered mode now batches per-chain agent-registry sidecar rewrites instead of rewriting the JSON sidecar on every append
   - The strict append hot path no longer pays the extra record-buffer allocation that had regressed single-append latency after the first background-writer refactor
 - feat(bench): persist and compare HTTP concurrency runs automatically
   - `benches/http_concurrency.rs` now saves per-mode baselines under `target/http_concurrency/` and prints delta tables on subsequent runs
   - New `MENTISDB_BENCH_AUTO_FLUSH` and `MENTISDB_BENCH_BASELINE` env vars make it easy to compare durable and buffered modes without manual table diffing
 - feat(dashboard): chain agent counts deep-link to per-chain agent registries
   - The Chains page `Agents` column now links directly to the matching chain section on `#/agents`
   - Agent registry section headers are linkable so the dashboard can auto-scroll to the right chain table

0.6.3.16 MAR/23/2026
 - fix(dashboard): deleted chains no longer linger or reappear
   - Dashboard reads now treat the on-disk chain registry as the source of truth for existence, so a deleted chain returns `404` instead of being silently reopened from a stale cached handle
   - Chain deletion now detaches persistence from any surviving in-memory handle before deregistering the chain, preventing the last drop from re-registering the chain after it was deleted
   - `deregister_chain()` now removes the per-chain agent-registry sidecar alongside the main chain storage file
   - The Chains and Agents dashboard views now skip chains that were externally deleted while still present in the live cache
   - Added regression tests for cached-handle deletion, external deregistration, stale reads after delete, and live-cached chain visibility
 - feat(dashboard): chain-level stats on the Agents page
   - Each `CHAIN: <chain_name>` section on `#/agents` now shows `Total Agents` and `Total Thoughts` above the table
   - `GET /dashboard/api/agents` now returns a per-chain summary envelope with `chain_key`, `total_agents`, `total_thoughts`, and the chain `agents` list
   - Cross-chain agent links, memory export, and copy-to-chain dialogs were updated to consume the richer response shape without breaking existing agent lookups
 - fix(ci): restore Linux workflow reliability for audio-enabled builds
   - GitHub Actions Linux jobs now install `pkg-config` and `libasound2-dev`, fixing `rodio` / ALSA build failures in `build`, `test`, and `clippy`
   - The release build workflow now explicitly grants `contents: write` so tagged builds can attach release artifacts

0.6.2.15 MAR/23/2026
 - fix(daemon): defer update prompt until startup output is complete
   - The update check still runs in the background, but it now waits to print until after the banner, configuration, and resolved endpoints are shown
   - The install question is rendered inside the ASCII dialog so the prompt is readable instead of colliding with startup logs

0.6.1.14 MAR/23/2026
 - change(daemon): enable update checks by default
   - `MENTISDB_UPDATE_CHECK` now defaults to `true`
   - Set `MENTISDB_UPDATE_CHECK=0` to disable the background GitHub release check
   - Updated daemon regression tests and docs to reflect the new default-on behavior

0.6.0.13 MAR/23/2026
 - feat(daemon): opt-in GitHub release update checks for `mentisdbd`
   - New `MENTISDB_UPDATE_CHECK=1` enables a background check against the latest GitHub release for `CloudLLM-ai/mentisdb`
   - Version comparison intentionally uses only the first three numeric components, ignoring the fourth monotone release counter
   - When a newer core version is found on an interactive terminal, `mentisdbd` shows an ASCII prompt window and accepts `Y`/`N`
   - Accepting the prompt runs `cargo install --git ... --tag ... --locked --force --bin mentisdbd mentisdb`, then gracefully shuts down and restarts the daemon
   - Non-interactive sessions never block on stdin; they print the manual cargo command instead
   - New `MENTISDB_UPDATE_REPO` env var allows overriding the GitHub repository used for update checks
 - fix(dashboard): Agent detail description rendering and freshness
   - Agent detail form fields (`Display Name`, `Description`, `Owner`) are now populated via DOM `.value` assignment after insertion, fixing the missing-description regression in the textarea
   - Dashboard chain reads now refresh cached chains from disk when auto-flush is enabled, so the Chains explorer and agent latest-thoughts panels show externally appended thoughts without requiring a daemon restart
 - fix(agent-registry): preserve agent metadata during append and copy flows
   - Cross-chain agent copy now upserts `description` into the target chain registry in addition to `display_name` and `owner`
   - Appending a thought without `agent_name` no longer downgrades a registered agent display name back to the raw `agent_id`
   - Case-only display-name corrections (for example `astro` -> `Astro`) no longer create alias churn
 - test: expand dashboard and daemon updater regression coverage
   - Added dashboard integration tests under `tests/dashboard_tests.rs` for agent detail hydration, copy-to-chain description preservation, and live thought refresh without daemon restart
   - Added updater tests under `tests/mentisdbd_tests.rs` for release-tag parsing, version comparison, opt-in env configuration, cargo install command construction, and startup-sound scheduler spacing

0.5.3.12 MAR/23/2026
 - feat(branding): real MentisDB infinity-M logo
   - Vectorized the official MentisDB logo (infinity/M mark) from JPEG source using potrace
   - Produced white-on-transparent SVG at public/logo.svg (1.5 KB, 3 paths)
   - mentisdb.com: replaced hand-drawn node-graph placeholder SVG in navbar and footer
   - docs.mentisdb.com: added logo.svg to public/; navbar img replaces plain wordmark
   - Dashboard: replaced 🧠 emoji in nav-brand with inline SVG data URI (embedded in binary, no external file)
 - docs: Claude for Desktop MCP connection guide (all OSes)
   - Documented that Claude for Desktop requires mcp-remote (npm install -g mcp-remote) as a bridge
   - Per-OS config examples (macOS, Windows, Linux) with correct command paths
   - NODE_TLS_REJECT_UNAUTHORIZED=0 env var required for self-signed cert; explained why and how to permanently trust the cert instead
   - Added Linux config file path (~/.config/Claude/claude_desktop_config.json)
   - Updated both README.md and docs.mentisdb.com user docs
 - fix: mcp-remote Claude Desktop config
   - node mcp-remote <url> is wrong (node tries to run a file named mcp-remote)
   - Correct invocation: use the full path to the mcp-remote binary as the command
   - MCP endpoint is at POST / (root), not /mcp

0.5.2.11 Mar/22/2026
 - feat: Reframe ThoughtType
   - New `ThoughtType::Reframe` variant for reframing thoughts that were accurate but unhelpfully framed
   - Distinct from Correction (factually wrong) and Invalidates (correct but stale)
   - Added to Corrections section in `to_memory_markdown` output
   - Sound signature: E5→D5→B4 gentle falling pattern in mentisdbd
   - Added to dashboard TYPE_GROUPS (Correction/red group)
 - feat: Supersedes ThoughtRelationKind
   - New `ThoughtRelationKind::Supersedes` variant for typed semantic "this replaces that" edges
   - Complements Reframe: use Reframe as ThoughtType, Supersedes as RelationKind pointing to the old thought
 - feat: cross-chain thought references
   - `ThoughtRelation` now has an optional `chain_key: Option<String>` field
   - Intra-chain refs remain backward-compatible (chain_key = None, skipped in JSON)
   - Binary (bincode) serialization always includes all 3 fields; JSON omits chain_key when None
   - Legacy v0 chains without chain_key are migrated transparently via LegacyThoughtRelation
   - New `ThoughtInput::with_cross_chain_relation()` builder method
 - feat: schema V2
   - `MENTISDB_SCHEMA_V2 = 2` constant added; `MENTISDB_CURRENT_VERSION` bumped to V2
   - Registry version is normalized to current version on load
 - feat: bulk import from MEMORY.md format
   - New `MentisDb::import_from_memory_markdown(markdown, default_agent_id)` library method
   - Parses all 29 ThoughtType variants, ThoughtRole, importance, confidence, tags from bullet lines
   - Source `[#N]` indices are discarded; thoughts are re-appended in order on the target chain
   - New REST endpoint: `POST /v1/import-markdown` (+ legacy alias `thoughtchain_import_memory_markdown`)
   - New MCP tool: `mentisdb_import_memory_markdown`
   - New dashboard endpoint: `POST /dashboard/api/chains/{chain_key}/import-markdown`
   - Tests: round-trip export→import, default agent fallback, malformed-line skipping
   - Benchmark: `bench_import_memory_markdown` (100-thought bulk import)
 - feat(dashboard): refs and relations in thought detail modal
   - Positional refs (intra-chain indices) displayed as #N, #M list
   - Typed relations displayed as `kind → target_id (chain: other-chain)` with chain_key omitted when intra-chain
 - feat(dashboard): Import MEMORY.md button on chain detail page
   - "📥 Import MEMORY.md" button opens a modal with textarea + default_agent_id input
   - Calls `POST /dashboard/api/chains/{chain_key}/import-markdown`, shows imported count on success
 - docs(skill): MENTISDB_SKILL.md updated for 0.5.2
   - Reframe ThoughtType entry with when-to-use guidance
   - Back-referencing section: how to use refs and relations on LessonLearned, Correction, and Reframe thoughts
   - Supersedes vs Corrects vs Invalidates decision guide
   - Cross-chain references section with examples
   - Example: Reframe superseding an overly broad constraint (bad/good patterns)
 - chore: bump crate version to 0.5.2

0.5.1.10 MAR/22/2026
 - feat(dashboard): copy agent memories to another chain
   - New "📋 Copy to Chain…" button on the Agent detail page (next to "Export Memory…")
   - Opens a modal showing only chains where the agent does NOT already have thoughts (preventing diverged history)
   - User must type the exact target chain name before the "Copy Memories" button is enabled
   - All semantic fields are preserved (type, role, content, tags, concepts, confidence, importance); positional refs and relations are intentionally dropped
   - Agent display name and owner are propagated via the first copied thought so the target chain's agent registry is populated correctly
   - New backend: `POST /dashboard/api/agents/{chain_key}/{agent_id}/copy-to/{target_chain_key}`
   - Returns 409 Conflict if the agent already has thoughts on the target chain
 - fix(dashboard): skill diff version picker defaults to oldest → newest
   - "From version" selector pre-selects v1 (oldest); "To version" pre-selects vN (newest)
   - Both selectors now use consistent chronological (oldest-first) ordering

0.5.0.9 MAR/21/2026
 - deprecate(config): rename MENTISDB_DEFAULT_KEY to MENTISDB_DEFAULT_CHAIN_KEY
   - New canonical env var is MENTISDB_DEFAULT_CHAIN_KEY
   - MENTISDB_DEFAULT_KEY remains fully functional as a deprecated alias (backwards compatible)
   - Updated .env.example, start_mentisdbd, README.md, and rustdocs
 - feat(dashboard): agent thoughts explorer
   - Per-agent detail page now includes cross-chain links: "All <DisplayName>'s thoughts on <chain-key>" for every chain the agent participated in
   - Clicking the link opens a filterable thought explorer pre-filtered to that agent's contributions
   - `renderAgentThoughts(agentId, chainKey)` function added to the SPA; supports pagination and per-page controls
 - feat(dashboard): skill revoke / deprecate with GitHub-style confirmation
   - "Revoke Skill…" button in skill detail header triggers an overlay panel
   - User must type the exact skill ID before "Revoke Forever" is enabled (mirrors GitHub repository deletion UX)
   - New admin-only `POST /dashboard/api/skills/{skill_id}/revoke` and `POST /dashboard/api/skills/{skill_id}/deprecate` routes in the dashboard server; these manage skill lifecycle entries in the `SkillRegistry` (backed by `SkillRegistry::revoke_skill` and `deprecate_skill`) and are separate from the MCP/REST API endpoints exposed to agents
 - feat(dashboard): version number in navigation header
   - Brand now reads "🧠 MentisDB v0.5.0" — fetched from new `GET /dashboard/api/version` endpoint on page load
   - New endpoint returns `{ "version": "…" }` compiled in via `env!("CARGO_PKG_VERSION")`
 - feat(dashboard): chain list refresh button
   - "↺ Refresh" button in the Chains page header re-fetches counts from the server without a full page reload
 - fix(dashboard): `api_chains` now includes mid-session chains
   - Result set is the union of disk-registry chain keys and chains live in the `Arc<DashMap>` cache
   - Chains created mid-session via MCP (e.g. `foo-chain`) appear immediately without daemon restart
 - fix(dashboard): agent thought counts were stale
   - `api_agents_all`, `api_agents_by_chain`, and `api_get_agent` now compute thought counts live via `chain.thoughts().iter().filter(|t| t.agent_id == agent_id).count()` instead of reading the stored `AgentRecord.thought_count` field which can drift
 - fix(dashboard): `renderAgentThoughts` used wrong element ID
   - Function was targeting `document.getElementById('main')` but the SPA container is `<main id="app">`; corrected to `getElementById('app')`
 - fix(dashboard): `setActive` JS error in agent thoughts view
   - `renderAgentThoughts` was calling the non-existent `setActive('agents')` — replaced with the correct `updateNav()` call
 - fix(dashboard): skill diff version picker shows sequential numbers
   - `From` / `To` selectors now display `N: short-hash (date)` so the relative order of versions is unambiguous
 - fix(dashboard): agent IDs in agents list are now clickable links
   - Each agent ID cell in the agents table renders as `<a href="#agents/{id}">` to navigate directly to the agent detail page
 - fix(startup): per-agent thought counts in startup report were stale
   - `print_agent_registry_summary` now counts live via the same filtered-iterator pattern used by dashboard handlers
 - fix: silence `DeviceSink` drop log from rodio 0.22
   - Calling `.log_on_drop(false)` on the `DeviceSink` suppresses the "Dropping DeviceSink, audio playing through this sink will stop" message on daemon exit
 - fix: resolve clippy errors in bench and tests
   - `benches/http_concurrency.rs`: filled all missing `MentisDbServerConfig` fields in the struct literal
   - `tests/mentisdb_tests.rs`: replaced four `vec![…]` array literals that hold only stack types with plain `[…]` arrays (`clippy::useless_vec`)
 - chore: bump crate version to 0.5.0
 - feat: HTTPS/TLS support for mentisdbd
   - Added HTTPS listeners for both MCP (port 9473) and REST (port 9474) alongside existing HTTP listeners
   - Auto-generates a self-signed TLS certificate on first startup via `rcgen`, saved to `~/.mentisdb/tls/cert.pem` and `~/.mentisdb/tls/key.pem`
   - Certificate includes SANs: `my.mentisdb.com`, `localhost`, `127.0.0.1`
   - `my.mentisdb.com` is a public DNS A-record → 127.0.0.1; use it as a friendly hostname for the local daemon once the cert is trusted
   - New env vars: `MENTISDB_HTTPS_MCP_PORT` (default 9473, 0=disabled), `MENTISDB_HTTPS_REST_PORT` (default 9474, 0=disabled), `MENTISDB_TLS_CERT`, `MENTISDB_TLS_KEY`
   - Added `start_https_mcp_server` and `start_https_rest_server` public API functions
   - `MentisDbServerConfig` extended with `https_mcp_addr`, `https_rest_addr`, `tls_cert_path`, `tls_key_path`
   - `MentisDbServerHandles` extended with `https_mcp: Option<ServerHandle>`, `https_rest: Option<ServerHandle>`
   - Daemon startup prints HTTPS endpoints, TLS cert path, per-OS cert trust commands, and `my.mentisdb.com` tip
 - feat: Startup jingle (PC-speaker style, `startup-sound` feature)
   - 4-note square-wave sequence on daemon start: C5 → E5 → D5 → B5 ("men-tis-D-B")
   - Implemented via `rodio` (CoreAudio / ALSA / WASAPI); feature-gated as `startup-sound` (on by default)
   - Jingle plays after the banner and configuration block are fully flushed to stdout, so visual output is always complete before sound
   - Silence with `MENTISDB_STARTUP_SOUND=0` / `false` / `no` / `off`
   - `MENTISDB_STARTUP_SOUND` added to the Configuration printout and `.env.example`
 - feat: Per-thought-type sound signatures (`MENTISDB_THOUGHT_SOUNDS`)
   - When enabled, a distinct ≤200ms square-wave sequence plays every time a thought is appended, keyed to its `ThoughtType`
   - 28 unique signatures; sequences are tuned to evoke the thought type (e.g. `Surprise` mirrors the Metal Gear Solid "!" alert: C5→E5→G5→C6)
   - Implemented via an `on_thought_appended: Option<Arc<dyn Fn(ThoughtType) + Send + Sync>>` callback on `MentisDbServiceConfig`; fired asynchronously via `spawn_blocking` so audio never blocks the append path
   - Defaults to `false` (opt-in) to avoid annoying users; toggle with `MENTISDB_THOUGHT_SOUNDS=true`
   - `MENTISDB_THOUGHT_SOUNDS` added to the Configuration printout and `.env.example`
 - ux: Reorder daemon startup output — useful info first, branding last
   - Endpoint catalog is now printed first (MCP / REST / HTTPS addresses)
   - Chain summary, Agent Registry summary, and Skill Registry summary follow
   - ASCII banner, version line, and Configuration block move to the bottom so operators see actionable info immediately
 - ux: ASCII-table startup summaries with ANSI colour
   - Chain Summary, Agent Registry, and Skill Registry are rendered as bordered ASCII tables using box-drawing characters
   - Column headers are printed in cyan; section separators and borders use dim styling
   - Agent Registry groups agents by chain key with a full-width pink section label row per chain
 - ux: Startup summaries show all configured env variables
   - Every supported `MENTISDB_*` env var is listed in the Configuration block, including those that were previously omitted
 - fix: Chain Summary now reads live thought and agent counts instead of stale registry values
   - Each chain is opened via `MentisDb::open_with_storage` at print time; stale registry values are only used as a fallback when a chain cannot be opened
 - fix: Off-by-one in `persist_chain_registration` — registry always stored N-1 thoughts
   - `persist_registries()` was called before `self.thoughts.push()` so `thought_count` written to `mentisdb-registry.json` was the pre-append count
   - Moved `persist_registries()` to after `self.thoughts.push()` so the persisted count always equals the post-append chain length
 - feat: `refresh_registered_chain_counts()` — startup registry repair
   - New public function that opens each registered chain, reads live `thought_count` and `agent_count`, and rewrites the registry JSON only when at least one entry has drifted
   - Called at daemon startup after chain migrations so any counts corrupted by the previous off-by-one bug (or by chains appended outside the daemon) are corrected on first boot
 - chore: Add `.env.example` documenting all supported environment variables with comments
 - feat: Web dashboard — admin UI embedded in the mentisdbd binary
   - Self-contained HTML/CSS/vanilla-JS single-page app served at `http://<host>:9475/dashboard`; no npm, no Node.js, zero new crate dependencies
   - HTML/CSS/JS live as real tracked files in `src/dashboard_static/` and are compiled into the binary via `include_str!` — diffs and IDE tooling work normally
   - Chain Manager: lists all chains with live thought/agent counts; click any chain to open the Thought Explorer
   - Thought Explorer: paginated table (25/50/100 per page) with 28-ThoughtType grouped multi-select filter (All/Clear per colour group); coloured type badges; click any row to open a full-detail modal (all fields, refs as links, content in scrollable pre block)
   - Agent Manager: agents grouped by chain; status badges; per-agent detail page with editable Display Name / Description / Owner fields, Revoke/Activate toggle, ed25519 public key add/revoke, and recent-thoughts preview
   - Skills Registry: lists all skills with status and version count; per-skill view with Rendered / Source / Diff tabs; inline markdown renderer; version selector; coloured unified-diff viewer comparing any two versions
   - PIN protection: set `MENTISDB_DASHBOARD_PIN` to gate all dashboard routes behind a login page; auth via `mentisdb_pin` cookie or `Authorization: Bearer <pin>` header; unset = open (suitable for localhost deployments)
   - New env vars: `MENTISDB_DASHBOARD_PORT` (default 9475; 0 = disabled), `MENTISDB_DASHBOARD_PIN` (default unset)
   - Dashboard URL printed in startup endpoint catalog; both env vars listed in Configuration block
   - `src/server.rs`: `MentisDbService.{chains,skills}` made `pub(crate)`; `MentisDbServerConfig` + `MentisDbServerHandles` extended with dashboard fields; `start_dashboard_server()` added; dashboard shares the same live `Arc<DashMap>` chains and `Arc<RwLock<SkillRegistry>>` as the REST service
 - fix: Chain Summary stale thought/agent counts resolved at startup
   - `refresh_registered_chain_counts` runs before servers start and writes live counts to the registry
   - `print_chain_summary` now reads directly from the refreshed registry (no redundant chain re-opens)
   - `api_chains` dashboard endpoint now uses `get_or_open_chain()` for all chains (eliminates stale fallback from registry)
 - fix: Thought detail modal missing ID, hash, and creation date
   - Frontend now reads `thought.id` (with fallback to `thought.thought_id`) and `thought.hash` (with fallback to `thought.thought_hash`)
   - Hash value is now copyable via a clipboard button (⎘ → ✓ on click)
 - feat: Chain browser sort order toggle + Genesis/Head navigation
   - New "⬇ Newest first / ⬆ Oldest first" toggle button (default: newest first)
   - "⏮ Genesis" and "Head ⏭" jump buttons for fast navigation
   - Backend: `ThoughtsQuery.order` param; `paginated_thoughts()` accepts `reverse: bool` flag
 - ux: Startup endpoint catalog shows friendly `my.mentisdb.com` URLs alongside `127.0.0.1` addresses
 - fix: Agent detail Owner field not displaying saved value
   - Frontend was reading `agent.agent_owner` but `AgentRecord` serializes the field as `agent.owner`
 - feat: Agent list table now shows Owner and Thoughts columns
 - chore: Bump dependencies — diffy 0.3→0.4, axum-server 0.7→0.8, rcgen 0.13→0.14, rodio 0.17→0.22
   - rodio 0.22 breaking changes: `OutputStream`/`Sink` removed; new API uses `DeviceSinkBuilder::open_default_sink()` + `Player::connect_new()`; `Source` trait: `current_frame_len`→`current_span_len`, `channels()`/`sample_rate()` return `NonZero<u16>`/`NonZero<u32>`
   - bincode reverted to 2.0.1 (3.0.0 dropped serde compatibility)
 - chore: MENTISDB_SKILL.md updated to v3 — 10 new undocumented agent patterns documented from borganism-brain chain analysis

0.4.3.8 MAR/16/2026
 - chore: Add Makefile
   - Added `Makefile` to the standalone repository root with targets: `build`, `build-mentisdbd`, `release`, `fmt`, `check`, `clippy`, `test`, `bench`, `doc`, `publish`, `publish-dry-run`, `install`, `clean`, and `help`
   - `bench` target pipes Criterion output through `tee` to `/tmp/mentisdb_bench_results.txt` so benchmark numbers are captured alongside the live terminal display
   - `install` target installs the `mentisdbd` daemon binary via `cargo install --path .`

0.4.2.7 MAR/16/2026
 - repo: Move MentisDB into its own standalone Git repository
   - Split the `mentisdb/` subtree out of the former `cloudllm` monorepo and preserved the MentisDB commit history in the new repository
   - Updated crate metadata to point at the standalone `CloudLLM-ai/mentisdb` repository
   - Replaced the old local `../mcp` path dependency with the published `cloudllm_mcp` crate so `mentisdbd` builds and runs from the standalone checkout
 - api: Make skill uploads warning-clean under strict Clippy
   - Replaced the long `SkillRegistry::upload_skill(...)` parameter list with a public `SkillUpload` request type
   - Updated server, tests, and benchmark call sites to use the new upload request builder methods
   - Fixed the remaining Clippy findings in `server.rs` and `skills.rs` so `cargo clippy -- -D warnings` passes on the standalone repository
 - chore: Track standalone repo build artifacts more cleanly
   - Added a root `.gitignore` for `target/` and editor backup files
   - Added `Cargo.lock` to the standalone repository so the daemon build resolves against a checked-in lockfile

0.4.1.6 MAR/16/2026
 - feat: Agent registry public key support
   - Added `AgentPublicKey { key_id, algorithm, public_key_bytes, revoked }` to the per-chain agent registry
   - Added `mentisdb_add_agent_key` MCP tool and `POST /v1/agents/{id}/keys` REST endpoint for key registration
   - Added `mentisdb_revoke_agent_key` MCP tool and `DELETE /v1/agents/{id}/keys/{key_id}` REST endpoint for key revocation
   - Public keys are serialized and persisted alongside the agent registry record
   - Ed25519 (`ed25519-dalek 2`) is the first supported algorithm; algorithm field is open for future extension
 - feat: Skill registry delta/diff versioning
   - First version of each skill is stored as full raw content; subsequent versions store only unified diff patches via `diffy`
   - Added `SkillVersionContent` enum (`Full { raw }` / `Delta { patch }`) replacing the embedded `SkillDocument` in `SkillVersion`
   - Added `version_number: u32` (zero-based monotone index) to `SkillVersion` and `SkillVersionSummary`
   - Version reconstruction applies the patch chain from v0 forward; all read and export paths go through `reconstruct_raw_content`
   - Content integrity hash is now SHA-256 of the full reconstructed raw content string
 - feat: Ed25519 cryptographic skill upload signing
   - Agents with registered public keys must provide `signing_key_id` and `skill_signature` (64-byte Ed25519) on every skill upload
   - Agents without registered public keys may upload without signatures for backward compatibility
   - Signature is verified against the agent's active public key in the agent registry before the upload is accepted
   - `signing_key_id` and `skill_signature` are stored on each `SkillVersion` for auditability
   - Added `verify_ed25519_signature` to the server layer using `ed25519-dalek 2`
 - feat: Skill registry V1→V2 startup migration
   - `migrate_skill_registry(chain_dir)` migrates the persisted `mentisdb-skills.bin` from registry V1 (full document per version) to V2 (delta content model)
   - Migration is idempotent; returns `None` if the registry is already at the current version or does not exist
   - `mentisdbd` runs skill registry migration at startup, after chain migration and before opening the skill registry
   - Panics on unrecoverable migration failure to prevent serving stale data
 - feat: Add `SkillRegistryMigrationReport` public type reporting migration outcome
 - perf: Replace outer `RwLock<HashMap>` with `DashMap` for concurrent chain lookup
   - Hot path for `get_chain` now acquires only a per-shard read lock instead of a global write lock
   - New chains are inserted using `entry().or_try_insert_with()` for shard-level atomicity; no global async lock held during chain open
   - Benchmark: `DashMap` delivers 750–930 read req/s at 10k concurrent tasks vs previous sequential bottleneck
 - perf: Add write buffering to `BinaryStorageAdapter`
   - Replaced per-append `File::open` with a lazily-initialized `Mutex<BufWriter<File>>`
   - `auto_flush = false` batches writes and flushes every `FLUSH_THRESHOLD = 16` appends or on `Drop`
   - `auto_flush = true` (default) flushes immediately after each append, preserving full crash durability
 - feat: Add `MENTISDB_AUTO_FLUSH` env var and `MentisDbServiceConfig::auto_flush` builder
   - Set `MENTISDB_AUTO_FLUSH=false` (or `0`) for high-throughput write workloads at reduced durability
   - Defaults to `true` for backward-compatible crash-safe behavior
   - Config field exposed via `with_auto_flush(bool)` builder method on `MentisDbServiceConfig`
 - bench: Add Criterion benchmark suite (22 benchmarks)
   - `benches/thought_chain.rs`: 10 benchmarks covering append throughput, query latency, and traversal patterns
   - `benches/skill_registry.rs`: 12 benchmarks covering skill upload, search, delta reconstruction, and lifecycle operations
   - Baselines committed; run with `cargo bench`
 - bench: Add harness-free HTTP concurrency benchmark
   - `benches/http_concurrency.rs`: starts `mentisdbd` in-process on a random port, measures write and read throughput at 100 / 1k / 10k concurrent Tokio tasks with p50/p95/p99 latency reporting
 - test: Expand skill registry coverage for delta versioning and signing
 - docs: Update MENTISDB_SKILL.md with Fleet Orchestration and multi-CLI sub-agent guide
   - Added 9-subsection Fleet Orchestration section: PM pattern, agent registration, parallel dispatch, context window protocol, anti-patterns, and self-improving fleet guidance
   - Added concrete spawning examples for GitHub Copilot CLI (`task` tool + `mode="background"`), Claude Code (parallel `Task()` calls), OpenAI Codex CLI (`--dangerously-auto-approve-everything` + shell backgrounding), and Qwen Code (`spawn_agent`)
   - Added universal 6-step PM pattern table applicable to any CLI
 - docs: Document `MENTISDB_AUTO_FLUSH` in README daemon configuration section
   - Added durability vs. throughput trade-off explanation and two example launch commands
 - docs: Update WHITEPAPER with delta versioning and cryptographic authorship sections

0.4.0.5 MAR/13/2026
 - feat: Complete the MentisDB skill registry release
   - Added the built-in `MENTISDB_SKILL.md` plus versioned uploaded skill documents for specialist agents
   - Finished the MCP and REST skill registry surfaces for list, manifest, upload, search, read, version listing, deprecate, and revoke flows
   - Tightened MCP tool metadata so live tool discovery advertises the full skill query parameter set
 - feat: Speed up durable memory queries with append-maintained indexes
   - Added indexes for agent id, thought type, and role to narrow candidate thoughts before full query filtering
   - Added timestamp-window position bounds so UTC `since` and `until` searches avoid scanning the full chain
 - feat: Add direct thought lookup and append-order traversal APIs
   - Added direct lookup by stable thought id, chain index, and content hash, plus explicit genesis vs head semantics
   - Added forward and backward chunk traversal from thought anchors or logical `genesis`/`head` boundaries, with reusable search filters
   - Added numeric traversal time windows using `start + delta` in `seconds` or `milliseconds` for MCP and REST callers
   - Exposed the new lookup and traversal surface through MCP and REST, separate from graph/context traversal
 - docs: Sync daemon and protocol documentation with the shipped server surface
   - Updated the daemon endpoint catalog, crate README, MCP spec, and REST spec to include the skill registry APIs and built-in skill endpoint
   - Clarified the current skill registry model: daemon-global storage with uploader validation against a chain agent registry
   - Documented head-vs-genesis semantics and the distinction between append-order traversal and graph/context traversal
 - feat: Default `MENTISDB_VERBOSE` to `true` when unset
   - Daemon now logs interaction events to the console out of the box without requiring explicit env configuration
   - `MENTISDB_VERBOSE=0` or `MENTISDB_VERBOSE=false` disables console interaction output
 - feat: Add file-backed interaction logging via `MENTISDB_LOG_FILE`
   - Set `MENTISDB_LOG_FILE=/path/to/mentisdb.log` to append all interaction events to a durable file
   - File logging is independent of `MENTISDB_VERBOSE`: operators can run a silent console with a durable file log, verbose console with no file, or both simultaneously
   - Log file path is displayed in daemon startup configuration output alongside other active env settings
   - Added `log_file` field to `MentisDbServiceConfig` with a `with_log_file` builder method
 - feat: Colorize daemon startup configuration output
   - Env variable names and their resolved values are now color-coded in the startup banner for easier visual scanning
 - test: Expand coverage for the new registry and query behavior
   - Added crate tests for skill import/export, persistence, lifecycle operations, and query timestamp windows
   - Added server tests for live skill registry MCP/REST flows and embedded skill retrieval
   - Moved skill parser tests into integration test files under `tests/` for consistency with crate standards

0.3.0.4 MAR/12/2026
Note: historical entries below use the original ThoughtChain / thoughtchaind
names because they describe earlier releases. The project is now being
rebranded to MentisDB / mentisdbd.
This release also records the project rename from ThoughtChain to MentisDB.

 - feat: Introduce ThoughtChain schema version `1`
   - Added explicit `schema_version` to durable thought records
   - Added optional `signing_key_id` and `thought_signature` fields for future signed-agent provenance
   - Added a stable signable thought payload path so signatures can target canonicalized thought data
 - feat: Move shared-agent metadata into registries
   - Added per-chain `AgentRegistry` sidecars for display names, owners, aliases, public keys, and agent activity metadata
   - New thoughts now store stable `agent_id` attribution while registry metadata resolves `agent_name` and `agent_owner` at read time
   - Query, memory export, JSON rendering, and `thoughtchain_list_agents` now resolve identity metadata from the registry instead of scanning or duplicating inline agent profile fields
 - feat: Add a global ThoughtChain registry and richer discovery metadata
   - Added a durable registry of chains with chain key, schema version, storage adapter, storage location, thought count, and agent count
   - `thoughtchain_list_chains` and `GET /v1/chains` now return richer chain summaries instead of only chain keys
   - Server chain discovery overlays live in-process counts on top of persisted registry metadata
 - feat: Add automatic migration from legacy schema version `0`
   - `thoughtchaind` now scans discovered chains at startup, migrates legacy JSONL and binary chains to version `1`, archives the old files, and reports progress in stdout
   - Migration logic lives in the library so it is reusable from tests and future tooling, not only from the daemon
   - Added migration coverage for both legacy JSONL and binary chains
 - feat: Add a versioned skill registry with adapter-based import and export
   - Added a binary `mentisdb-skills.bin` registry with explicit registry versioning, schema versioning, integrity hashes, uploader attribution, timestamps, immutable skill versions, and lifecycle status
   - Added structured skill adapters for Markdown -> Skill, JSON -> Skill, Skill -> Markdown, and Skill -> JSON
   - Added indexed registry search by skill id, name, tags, triggers, uploader identity, status, format, schema version, and upload time window
 - feat: Expose the skill registry through MCP and REST
   - Added MCP tools and REST endpoints for `list_skills`, `skill_manifest`, `upload_skill`, `search_skill`, `read_skill`, `skill_versions`, `deprecate_skill`, and `revoke_skill`
   - `read_skill` now returns explicit warnings that skill files may contain malicious or untrusted instructions
   - Added the embedded `mentisdb_skill_md` surface for the official built-in MentisDB skill file
 - feat: Make binary storage the default for new chains
   - `BinaryStorageAdapter` is now the default storage backend for new chains
   - Added `THOUGHTCHAIN_DEFAULT_STORAGE_ADAPTER` and retained `THOUGHTCHAIN_STORAGE_ADAPTER` as a compatibility alias
   - Added bootstrap-time storage adapter override support so callers can explicitly create JSONL or binary chains
   - Fixed adapter filename resolution so JSONL and binary chains always reopen using the correct file extension
 - feat: Make the daemon/server stack the default crate experience
   - `thoughtchain` now enables the `server` feature by default so `cargo install thoughtchain` and `cargo run --bin thoughtchaind` work without extra feature flags
   - Updated workspace manifests and launcher scripts to rely on the default server-enabled build
 - docs: Refresh installation, daemon, protocol, and design documentation
   - Updated README quick-start guidance to emphasize `cargo install thoughtchain`, `thoughtchaind`, and `nohup thoughtchaind &`
   - Updated MCP and REST protocol docs for schema `1`, registry-backed chain discovery, binary-default storage, bootstrap adapter overrides, signature fields, and the new skill registry
   - Updated the white paper to describe registries, schema versioning, migration, and the signing-oriented data model
 - test: Expand coverage for the new schema and migration model
   - Added coverage for stable signable payload generation
   - Added coverage for v0 to v1 migration
   - Added server coverage for registry-backed chain summaries, bootstrap adapter overrides, and the skill registry endpoints

0.2.1.3 MAR/11/2026
 - feat: Add env-controlled verbose interaction logging to `thoughtchaind`
   - Added `THOUGHTCHAIN_VERBOSE` with support for `1`, `0`, `true`, and `false`
   - When enabled, the daemon logs each ThoughtChain read and write interaction with chain key, touched agents, thought types, roles, tags, and concepts
   - Startup configuration output now shows the effective verbose setting
 - test: Add coverage for verbose env parsing in server configuration

0.2.0.2 MAR/11/2026
 - feat: Add retrospective memory support
   - Added `ThoughtType::LessonLearned`
   - Added `ThoughtRole::Retrospective`
   - Markdown memory export now surfaces non-default roles such as retrospectives
 - feat: Add guided retrospective append APIs
   - Added MCP tool `thoughtchain_append_retrospective`
   - Added REST endpoint `POST /v1/retrospectives`
   - Retrospective append defaults to `LessonLearned` and always stores thoughts with role `Retrospective`
 - feat: Add shared-daemon discovery APIs
   - Added MCP tool `thoughtchain_list_chains`
   - Added MCP tool `thoughtchain_list_agents`
   - Added REST endpoint `GET /v1/chains`
   - Added REST endpoint `POST /v1/agents`
 - docs: Update daemon and protocol documentation
   - Updated `thoughtchain/README.md` with retrospective guidance and MCP setup for Codex, Claude Code, Qwen Code, and GitHub Copilot CLI
   - Updated the white paper and protocol docs to explain retrospective memory, lessons learned, and shared-daemon discovery
 - test: Add coverage for retrospective type/role queries, discovery endpoints, and server append behavior

0.1.0.1 MAR/11/2026
 - feat: First public release of `thoughtchain`
   - Standalone Rust crate for semantic, hash-chained memory in long-running and multi-agent systems
   - Append-only, adapter-backed storage with explicit integrity verification
   - `StorageAdapter` abstraction for pluggable persistence backends
   - `JsonlStorageAdapter` as the current default backend
   - Stable crate metadata prepared for crates.io publishing
 - feat: Semantic thought model for durable agent memory
   - Rich `ThoughtType` taxonomy covering preferences, insights, facts, plans, corrections, checkpoints, summaries, surprises, and more
   - `ThoughtRole` separates semantic meaning from runtime roles such as memory, summary, compression, checkpoint, handoff, and audit
   - Stable thought ids, timestamps, importance, confidence, tags, concepts, refs, and typed relations
   - Shared-chain agent attribution via `agent_id`, `agent_name`, and optional `agent_owner`
 - feat: Query, replay, and export capabilities
   - Query by text, type, role, tags, concepts, agent ids, importance, confidence, and date range
   - Prompt-oriented catch-up rendering for session resumption
   - `MEMORY.md`-style Markdown export generated from chain walks and filters
   - Chain head inspection and integrity checks for durable memory operations
 - feat: Server support and standalone daemon
   - `thoughtchain::server` module behind the `server` feature
   - MCP server surface for remote agents
   - REST server surface for services, dashboards, CLIs, and generic HTTP clients
   - `thoughtchaind` binary to run ThoughtChain as a long-lived process
   - Env-configurable host, ports, default chain key, and storage directory
 - docs: Fully documented public API
   - Rustdoc coverage across public functions, enums, structs, and implementations
   - Added protocol documentation in the parent repository for both MCP and REST use
 - test: Dedicated crate test coverage
   - Separate tests under `thoughtchain/tests`
   - Coverage for persistence, integrity, querying, export behavior, and server routing
