0.9.9.45 UNRELEASED
  - feat(dashboard): chains table redesign — replaced "Agent Idx", "Entity Idx",
    and "Vector Idx" columns with "Chain" (on-disk file), "Semantic" (vector
    embeddings sidecars), and "Lexical (RAM)" (in-memory BM25 index); the Lexical
    column shows `—` for unloaded chains and an estimated size (e.g. `53 KB`) once
    the chain is accessed and its index is built; Lexical header and values are
    styled in amber to indicate in-memory-only state
  - feat(search): add `LexicalIndex::estimated_memory_bytes()` to approximate the
    RAM footprint of the in-memory BM25 postings map, document-stats vector, and
    metadata; lower-bound estimate — real heap may be 1.2–1.5× larger
  - feat(api): add `MentisDb::estimated_lexical_index_bytes()` public method so
    dashboard and other callers can surface the lexical index size without accessing
    private fields
  - refactor(dashboard): rename `chain_sidecar_sizes` → `vector_index_size` and
    simplify `api_chains` JSON to expose only the three meaningful index sizes
    (chain file, semantic sidecars, lexical RAM estimate) per chain
  - feat(dashboard): comprehensive tooltips across the entire UI — every nav link,
    summary stat, table header, action button, form field, filter control, and
    modal now has a friendly HTML title attribute explaining what it does and what
    data it represents; uses native browser tooltips for zero-dependency compatibility

0.9.8.44 MAY/07/2026
  - BREAKING: rename binary from `mentisdbd` to `mentisdb` — all CLI commands,
    documentation, install scripts, CI artifact names, and TUI references updated;
    `cargo install mentisdb` still installs the crate, but the resulting binary
    is now `mentisdb` (no trailing `d`)
  - feat(dashboard): chains table now shows a "Size" column with human-readable
    storage size (B, KB, MB, GB, TB, PB) computed from each chain's on-disk file;
    summary bar shows total size, thoughts, agents, and per-index size totals
  - feat(dashboard): new Settings tab — view and edit all 18 `MENTISDB_*` env
    vars in a table with type-aware controls (checkbox for booleans, number for
    ports, text for strings); shows current value, default, and description per
    setting; "Reset to Default" per row; "Apply Settings" persists changes to a
    `.env` file and hot-reloads `auto_flush` immediately; restart-required flag
    for network/storage changes that cannot be applied to a running daemon
  - feat(tui): show chain file size in Storage Location column — prefixed with
    human-readable size in brackets (e.g. [10 KB] /path/to/chain.tcbin); sizes
    shown in B, KB, MB, or GB as appropriate; running status now includes PID
  - feat(config): dotenvy support — mentisdb now loads environment variables
    from a `.env` file in the current working directory at startup; existing
    shell environment variables take precedence over `.env` values; silently
    ignored when no `.env` file is present; all `MENTISDB_*` env vars,
    `RUST_LOG`, and `OPENAI_API_KEY` can now be managed via project-local
    `.env` files for cleaner per-project configuration
  - test: add `start_servers_headless_without_tui_state` regression test for the
    headless daemon startup path used by stdio proxy auto-launch and
    `--mode http --headless`
  - bench: LoCoMo R@10 = 71.80% (single 75.80%, multi 57.20%)


0.9.7.43 APR/30/2026
  - fix(dashboard): harden skill Markdown rendering — dashboard-rendered skill
    links now escape labels and href attributes, allow only http/https/mailto
    protocols, and render unsafe links as plain text, preventing stored skill
    content from creating scriptable links in the same-origin dashboard
  - fix(dashboard): editing from the skill detail page now targets the version
    being viewed and defaults to the latest version instead of the oldest
    version; valid-but-missing version UUIDs now return 404 instead of 500
  - chore(backup): ignore the new *.mentis backup archive extension in git so
    private chain, agent, vector, and skill data is not accidentally committed
  - fix(stdio): remove synthetic ack for notifications in stdio proxy — the old
    {id:'ack', result:{}} response broke Claude Desktop's MCP SDK which validates
    that response ids match pending requests; notifications are now silently
    absorbed (forwarded to daemon, nothing written to stdout), fixing the
    'Unexpected end of JSON input' error that prevented Claude Desktop from
    connecting
  - feat(stdio): --headless mode for background daemon auto-launch — the stdio
    proxy now passes --mode http --headless when spawning a background daemon,
    starting HTTP servers without the TUI (which crashes when stdin is null);
    adds DaemonArgMode::RunHeadless and run_headless() that skips TUI/terminal
    setup, runs migrations silently, and waits for SIGINT
  - feat(dashboard): skill editing — each skill row now has an Edit button that
    opens a modal with a textarea pre-filled with the skill's current markdown
    content; Save calls the existing upload endpoint to create a new version;
    preserves original agent_id and format; also fixes uploader column showing
    '—' instead of actual agent name
  - fix(stdio): tighten SSE detection in proxy — changed from contains('event:')
    to starts_with('event:') / starts_with('data:') to avoid false positives
    from tool descriptions containing the substring; added empty response body
    filter so 202 Accepted responses don't write empty lines to stdout
  - fix(stdio): local stdio mode now echoes client's protocol version instead of
    hardcoded 2025-06-18, and tool definitions include execution field
    {taskSupport:'optional'} matching the daemon's streamable HTTP output
  - feat(primer): updated priming phrase to 'use mentisdb as your memory system'
    across TUI, mentisdb.com, and docs.mentisdb.com
  - refactor(skill): MENTISDB_SKILL.md — strengthened TaskComplete trigger rule
    to emphasize immediate write on completion (not deferred), added 'deferring
    memory writes' to anti-patterns list
  - fix(update): clean up TUI terminal before restart to prevent ANSI garbage;
    old code called cmd.spawn()+exit(0) which killed the TUI thread without
    running TerminalCleanup, so the new process inherited alternate screen +
    raw mode; new restart_process() helper disables raw mode, leaves alternate
    screen, and uses exec() on Unix to replace the process (no zombie window),
    falling back to spawn+exit on non-Unix with terminal restored

0.9.6.42 APR/29/2026
  - feat(tui): wider update dialog (80 cols) so GitHub release URL fits without
    wrapping; successful update now shows a green "Update Complete" overlay with
    the exact relaunch command and offers r to restart in-place or q to quit;
    mentisdb auto-restarts with the same CLI args when the user presses r
  - feat(backup): rename backup format from .mbak to .mentis; backup CLI now
    uses -o shorthand for --output (both still accepted); restore aborts with
    a clear error if mentisdb is detected running, preventing the daemon's
    in-memory state from overwriting restored files on next flush
  - feat(mcp): SSE support on MCP servers — start_mcp_server and start_https_mcp_server
    now return (ServerHandle, SseBroadcaster) tuples; GET endpoint returns text/event-stream
    with live MCP events, POST requests auto-broadcast JSON-RPC results/errors as SSE events;
    cloudllm_mcp bumped to 0.3.0
  - feat(server): bind_host parameter on standard_mcp_router — respects MENTISDB_BIND_HOST
    env var (defaults to 127.0.0.1) for flexible network binding on multi-homed machines
  - feat(mcp): add agent_id parameter to mentisdb_recent_context — allows filtering recent
    context by specific agent identity instead of always using the chain's default agent

0.9.5.41 APR/26/2026
  - feat(mcp): upgrade cloudllm_mcp to 0.2.1 — MCP 2025-11-25 protocol support;
    streamable HTTP servers now validate Origin headers for security on bound
    addresses and transparently skip validation on unspecified (0.0.0.0/::/::1)
    addresses for compatibility with tools that don't send Origin; protocol version
    negotiated during initialize is now "2025-11-25"
  - feat(ecosystem): Hermes agent by Nous Research ships a native MentisDB
    MemoryProvider — Hermes can now connect directly to a running mentisdb instance
    for durable semantic memory without an intermediary MCP bridge; the Hermes team
    implemented their own memory plugin against the MentisDB API for deeper
    integration into the Hermes agent lifecycle
  - fix(dashboard): restore "+Bootstrap New Chain" and "↺ Refresh" buttons on the
    Chains page — a refactor in 8ce4ff2 moved the Bootstrap modal HTML to a static
    section and introduced a one-shot `_chainBootstrapWired` guard, but accidentally
    dropped the `cl-bootstrap-btn` and `cl-refresh-btn` click handlers; the buttons
    rendered but did nothing after the first renderChainList() call because the guard
    prevented re-attaching handlers when the header DOM was rebuilt
  - fix(dashboard): header buttons (Refresh, Bootstrap) now re-attach their event
    listeners on every `renderChainList()` call instead of only on the first call,
    fixing a latent bug where navigating between pages (Chains → Agents → back to
    Chains) silently broke those buttons after any page transition

0.9.4.40 APR/23/2026
  - perf(search): incremental LexicalIndex — built once at chain open time and
    updated incrementally on every append_thought; eliminates the O(n) full-index
    rebuild that was happening inside every ranked search query; drops
    query_ranked_lexical_content latency from ~35 ms to ~237 µs (99.3% faster)
    and query_ranked_filtered_lexical from ~35 ms to ~23 µs (99.9% faster) on
    a 5 000-thought chain; scales sub-linearly with chain size instead of linearly
  - feat(daemon): per-read-operation sine-wave sounds — each logged read command
    (search, list_chains, get_thought, etc.) plays a unique 60–150 ms chime when
    MENTISDB_THOUGHT_SOUNDS=true; read sounds use pure sine waves in the 2 500–
    4 500 Hz range, while write sounds remain square-wave at 250–1 000 Hz, making
    the read/write distinction instinctive by pitch and timbre
  - perf(dashboard): Agents page now loads in two phases — phase 1 renders an
    instant skeleton from /dashboard/api/chains (fast registry read), then phase 2
    fires parallel per-chain requests to /dashboard/api/agents/:chain_key; each
    section populates independently as its response arrives, eliminating the
    serial O(total chains × total thoughts) blocking that made the page unusable
    with many chains
  - fix(dashboard): align Recent Thoughts table columns on agent detail page —
    the <tbody> was missing the Content <td>, causing the Date to slide under the
    Content header and the Branch button to slide under the Date header; restored
    the content preview cell and reordered cells to match headers
  - docs: agent memory protocol post — Hermes MemoryProvider as community standard
  - docs: OpenClaw × MentisDB integration post and protocol reassessment

0.9.3.39 APR/18/2026
  - feat(tui): full ratatui-based terminal user interface replaces text startup output
    — three-pane layout: top (banner + config + endpoints), middle (tabbed tables for
    chains/agents/skills with FocusedPane cycling via Tab/Shift+Tab, mouse click focus,
    contextual vim-style hint bar), bottom (agent primer + terminal-close warning);
    all panes scrollable with clamped bounds; TerminalCleanup RAII guard ensures safe
    terminal restoration on panic or early return; standard 8-color palette adapts to
    dark and light terminal backgrounds
  - feat(tui): drag-to-select copies any visible text — drag the mouse across any
    content (log lines, chain/agent/skill rows, endpoints, config, primer); on mouse
    release the selected rectangle is read from ratatui's live render buffer and
    written to clipboard via arboard + OSC 52 (enables Cmd+C on macOS in iTerm2,
    Terminal.app, kitty, WezTerm); live selection highlight via REVERSED cell style
  - feat(tui): 'c' key copies focused item — chain key, agent ID, skill name, full
    primer paste line, or visible log lines; 2-second green toast anchored near the
    focused pane confirms every copy
  - feat(tui): startup progress overlay — TUI renders immediately with a centered
    modal showing current phase; update dialog appears as an in-TUI modal
  - fix(tui): seamless single-TUI lifecycle — daemon runs one TUI instance for its
    entire lifetime; eliminates the visible flash/crash between startup and running
    phases that occurred when two TUI instances were started sequentially
  - fix(tui): startup crash overlay — when startup fails, a red full-screen overlay
    shows the error and keeps the TUI alive so the user can scroll logs before
    quitting; previously the daemon exited silently
  - fix(tui): log auto-scroll corrected for newest-first display — was pinned to the
    oldest entry (scroll=len-1 in a reversed list); now pins to scroll=0 (top=newest)
  - fix(tui): ratatui buffer swap — text extraction from drag-select now runs inside
    the terminal.draw() closure via frame.buffer_mut(), which is the live pre-swap
    buffer; current_buffer_mut() after draw() returns the cleared next-frame buffer
  - fix(tui): overlays use Clear widget to prevent background content bleeding through
    popup borders; startup overlay and update dialog are mutually exclusive
  - fix(tui): accurate startup status — "Checking chains for migrations…" instead of
    "Running migrations…" when no migrations are needed
  - fix(tui): chain key and skill name columns auto-sized to longest entry + 1
  - fix(tui): custom TuiLogger routes log output into TUI log buffer via mpsc channel,
    preventing raw stderr from corrupting the ratatui alternate screen
  - fix(tui): first-run setup wizard deferred to a separate terminal — wizard cannot
    run while TUI owns the terminal in raw/alternate-screen mode; TUI shows a note
    directing the user to run `mentisdb wizard` in a separate terminal instead
  - perf(tui): render_logs no longer allocates an intermediate Vec<&str> on every
    frame; single .iter().rev() pass reduces allocations at 10 Hz render rate
  - refactor(tui): removed dead code left by a prior session — show_update_dialog(),
    background_tip field, and background_launch_tip() were set/defined but never
    called or rendered
  - fix(stdio): proxy_jsonrpc_to_daemon now forwards raw JSON-RPC to the daemon's
    streamable HTTP endpoint (POST /) instead of manual method mapping, supporting
    the full MCP protocol (tools, resources, prompts, sampling, roots, notifications);
    resources/read still served locally (embedded skill markdown)
  - fix(daemon): remove broken `brew services start mentisdb` from macOS background
    launch tip — the formula does not ship a launchd plist; startup messaging now
    shows only the working nohup one-liner
  - chore: make ratatui 0.30 a non-optional always-on server dependency
  - fix: silence per-thought audio during benchmarks (MENTISDB_THOUGHT_SOUNDS=false)
  - chore: gitignore pymentisdb build artefacts + *.mbak backups


0.9.2.38 APR/17/2026
  - feat(stdio): smart daemon detection in stdio MCP mode — the stdio process now
    checks if a daemon is running via the health endpoint, proxies to it if found,
    or launches one in the background (nohup on Unix, start /B on Windows); all
    MCP clients that spawn stdio subprocesses (Claude Desktop, Cursor, etc.) now
    share the same live chain cache with zero configuration; falls back to local
    mode if daemon launch fails
  - fix(server): `start_servers` now shares ONE `MentisDbService` across the HTTP
    MCP, HTTP REST, HTTPS MCP, HTTPS REST, and dashboard surfaces. Previously each
    surface received its own `MentisDbService::new(...)` and therefore its own
    `DashMap<chain_key, Arc<RwLock<MentisDb>>>`, causing a cross-surface split
    brain: an append via REST was invisible to MCP (and vice versa) until the
    daemon restarted and both services reloaded the chain from disk. Public
    single-surface entry points (`start_mcp_server`, `start_rest_server`,
    `start_https_*_server`) are unchanged. Adds regression test
    `start_servers_shares_state_across_mcp_and_rest` that pre-warms the MCP
    service, appends via REST, and asserts MCP immediately sees the new
    `head_hash` / `thought_count` / `latest_thought.index`.
  - feat: POST /v1/admin/flush REST endpoint — iterates all open chains and calls
    flush() on each BinaryStorageAdapter; documented in server module header
  - feat: backup/restore — new mentisdb backup / mentisdb restore subcommands create and
    restore .mbak zip archives of the full MENTISDB_DIR; manifest with SHA-256 checksums for
    every file; verification before any file is written on restore; --flush, --include-tls,
    --overwrite flags; 33 integration tests in tests/test_backup.rs covering roundtrip, TLS
    inclusion, idempotent restore, overwrite, corruption detection, chain count, byte totals,
    manifest JSON round-trip, required vs optional file tagging, subdirectory creation
  - feat: backup CLI auto-detects running daemon — calls POST /v1/admin/flush before
    reading files; connection refused means daemon not running (files captured as-is);
    other errors warn but proceed; BackupOptions docs updated to explain flush behavior
  - feat: restore CLI interactive conflict prompt — when files exist in target dir and
    --overwrite not passed, lists conflicting files and prompts user with boxed_yn_prompt;
    user decline exits gracefully with no changes; restore is fully idempotent without prompt
  - feat: terminal-close warning printed at daemon startup — yellow ⚠ notice that closing the
    terminal stops mentisdb, followed by OS-specific background-launch tip:
      macOS: nohup one-liner
      Linux: systemd user service unit snippet or nohup one-liner
      Windows: schtasks /create one-liner or Start-Process -WindowStyle Hidden
  - feat: CLI help text updated for backup and restore subcommands — clarifies daemon flush
    detection, idempotent restore behavior, interactive prompt, and --overwrite skip note
  - fix(search): federated search dedup now keeps the higher-scoring duplicate occurrence,
    matching the documented contract, instead of whichever chain surfaced the UUID first
  - fix(relations): relation dedup no longer collapses distinct edges that differ by
    `chain_key`, `valid_at`, or `invalid_at`; only exact duplicate relations are removed
  - fix(webhooks): webhook registry persistence now uses temp-file-plus-rename instead of
    truncating the live registry in place; delivery fan-out is now bounded by a queue and
    concurrency semaphore so bursty append workloads do not spawn an unbounded number of
    webhook tasks immediately; added tests for rename-failure preservation and bounded delivery
  - fix: branch ancestor discovery is now transitive — branch-aware search can walk from child
    to parent to grandparent chains instead of stopping at the direct parent only
  - fix: restore now rejects path-traversal entries inside `.mbak` archives before any
    file extraction; crafted manifest paths like `../escape.txt` or absolute paths now fail
    restore with `InvalidData`, preventing writes outside the target directory
  - fix: interactive restore confirmation now actually enables overwrite mode when the user
    answers yes; previously the prompt implied overwrite but still passed `overwrite=false`
    unless `--overwrite` was supplied explicitly
  - fix: LLM-extracted memories no longer send an OpenAI `response_format` hint — some
    OpenAI-compatible endpoints rejected the request with a schema/type error; MentisDB now
    relies on the prompt plus strict JSON validation of the returned payload, preserving
    portability across providers; added a regression-style test covering raw parse error output
  - fix(pymentisdb): `context_bundles()` now decodes proper typed `ContextBundleSeed`
    and `ContextBundleHit` objects instead of incorrectly nesting `ContextBundle` inside
    `ContextBundle.seed`; `append_thought()` now uses one canonical `ThoughtInput`
    payload builder instead of duplicated request assembly; `ranked_search()` and
    `context_bundles()` now accept `MemoryScope` enums directly and serialize them to
    the API's lowercase request form; added focused Python client tests
  - fix: wizard — ensure_prerequisites for Claude Desktop now prompts before brew install on
    macOS (previously silently ran brew install mcp-remote without asking); on macOS brew is
    tried first, npm is the fallback; dead check_node_version and detect_brew_mcp_remote
    functions removed; detect_mcp_remote_any() checks Homebrew paths then PATH
  - fix: wizard — mcp-remote is now used directly without a node wrapper when installed as an
    absolute executable (is_absolute_executable check); the shebang-based
    is_directly_executable fallback is retained for npm-installed scripts with a good shebang;
    integration_apply_tests updated to assert the correct behavior
  - fix(bench): rebuild session_map after --limit filter in LoCoMo — on dev runs, ground-truth
    evidence from filtered-out personas was leaking back into R@K scoring via
    _expand_evidence() neighbor lookups; the fix rebuilds session_map on the kept item set
    immediately after filtering; full-scale runs were unaffected
  - chore(server): extract `invalid_input_error()` and `not_found_error()` helpers next to
    `service_call`; replace four `Box::new(io::Error::new(...))` callsites with them for
    tighter request-rejection plumbing (net: -8 lines of boilerplate, identical behavior)
  - test(skill-signing): strengthened server-side signature-verification coverage for skill
    uploads — now explicitly checks missing signature fields, unknown signing-key ids, and
    tampered signatures with clearer failure assertions
  - docs(whitepaper): rewrote WHITEPAPER.md in academic register with formal definitions
    (Thought, Chain, BM25, RRF, Jaccard dedup, temporal validity), a tamper-evidence proof
    sketch, and a References section; added WHITEPAPER.tex LaTeX port using
    amsmath/amsthm/booktabs/\newtheorem; added build-whitepaper.sh with macOS and Ubuntu
    install instructions, --open/--clean flags, and path_helper sourcing so it finds
    pdflatex after a fresh BasicTeX install; added author affiliation (Universidad Católica
    Andrés Bello, Venezuela)
  - docs(whitepaper): corrected v0.8.9 benchmark numbers to match reproducible results —
    LongMemEval R@10 changed 74.1% → 72.2%, added R@20 = 78.0%; filled in previously empty
    LoCoMo-10P v0.8.9 single-hop (75.8%), multi-hop (57.4%), and R@20 (79.1%) cells; three
    independent full-scale runs (2026-04-14, 2026-04-17 × 2) produced bit-identical scores;
    added a reproducibility caption under the results table
  - docs(blog): new ranked-search pipeline walkthrough (docs/mentisdb-ranked-search-pipeline.html)
    covering filter-first selection, as-of temporal filter, three parallel scorers
    (BM25, dense vector, graph BFS), smooth exponential fusion, session cohesion, RRF,
    and deterministic sort — with file:line citations for every phase; prefaced with a
    "Three Signals, Three Failure Modes" explainer (vocabulary match vs meaning match vs
    relationship match) and a subsection on why BFS vs DFS for graph expansion
  - docs(server,readme): introduce `invalid_input_error()` / `not_found_error()` helpers;
    fill README coverage gaps for `source_episode`, `entity_type`, `BranchesFrom`,
    `mentisdb_federated_search`, `mentisdb_extract_memories`, `mentisdb_list_entity_types`,
    `mentisdb_upsert_entity_type` (MCP catalog count 37 → 42)
  - docs(docs.mentisdb.com): add Advanced Retrieval section (RRF, context bundles, dense
    vector sidecars, branching chains, federated search), Entity Types & Provenance
    section (per-chain entity_type registry, source_episode), Webhook Callbacks, LLM-Extracted
    Memories, and pymentisdb Python Client sections to user_docs.rs; add LLM-based reranking,
    Operations & Admin (POST /v1/admin/flush, .mbak backup/restore, MENTISDB_DASHBOARD_PIN)
    to developer_docs.rs
  - docs: daemon endpoint catalog and REST rustdocs updated to include the live router
    surface (`/v1/federated-search`, `/v1/import-markdown`, entity types, chain merge,
    webhooks, extract-memories, admin flush, and related endpoints); startup catalog
    generation now uses a shared helper to keep HTTP/HTTPS REST listings aligned
  - docs: `mentisdb --help` now documents `MENTISDB_DASHBOARD_PIN`, matching the daemon's
    supported environment variables and startup output
  - docs: new content-ingestion tutorial blog post (`docs/mentisdb-content-ingestion.html`)
    covering setup, REST/MCP/Rust usage, live-tested behavior, review-before-append workflow,
    troubleshooting, and use cases for normal users, enterprise knowledge workers, and coders
  - docs: new MentisDB vs Cognee comparison post (`docs/mentisdb-vs-cognee.html`) with a
    fair architectural comparison and comprehensive side-by-side table; blog index updated to
    surface the new posts first
  - docs(skill): audited the live MentisDB project chain and found heavy concentration in
    `Summary` / `LessonLearned` plus near-total collapse of typed edges to `References`;
    revised `MENTISDB_SKILL.md` to push minimum backlinking, richer relation selection,
    `Invalidates`, `LLMExtracted`, and higher-value underused types; added a new blog post
    (`docs/mentisdb-memory-usage-audit.html`) documenting the findings and the fix
  - docs: refreshed README, Rust docs, and `docs/llm-extracted-memories-design.md` to match
    the shipped ingestion behavior: 31 thought types total, `gpt-4o` defaults, no auto-append,
    no `response_format` requirement, and explicit JSON schema validation instead
  - docs: `docs/mentisdb-backup-and-restore.html` blog post covering backup/restore CLI,
    consistency model, SHA-256 manifest, .mbak format, REST endpoint, security notes

0.9.1.37 APR/14/2026
  - feat: LLM-extracted memories — GPT-4o (or any OpenAI-compatible endpoint) converts
    raw agent text/logs/transcripts into structured ThoughtInput records for review
    and append; opt-in behind llm-extraction feature (default), uses openai-rust2
    with 3× retry on 429/5xx, 60s timeout, ResponseFormat::JsonObject, temperature 0.1;
    LlmExtractionConfig::from_env() reads OPENAI_API_KEY, LLM_BASE_URL, LLM_MODEL;
    ExtractionResult includes model identifier and token usage; callers must review
    and validate thoughts before appending
  - feat: federated cross-chain search — ancestor_chain_keys() walks BranchesFrom
    relations to discover parent chains; ranked search on branch chains transparently
    includes ancestor chain results and annotates them with chain_key; enables fleet
    memory hierarchies where specialist chains share a common base
  - feat: pymentisdb Python client v0.9.0 — pip-installable Python package with
    MentisDbClient (append_thought, ranked_search, context_bundles, list_chains,
    upsert_agent, lexical_search, search, get_thought, traverse_thoughts, recent_context,
    head, register/list/delete_webhook, skill methods, memory_markdown, import);
    MentisDbMemory LangChain integration; full ThoughtType, ThoughtRole, MemoryScope,
    ThoughtRelationKind enums; Typed relations; Complete working examples
  - feat: wizard brew-first install — ensure_prerequisites tries brew install mcp-remote
    before npm; added PrerequisiteStatus::Skipped variant; detect_brew_mcp_remote() reads
    mcp-remote shebang to detect Homebrew-installed mcp-remote (which has a proper
    shebang pointing to the correct Node version, usable directly without node wrapper)
  - fix: wizard overwrite prompt changed to "Overwrite it with a fresh setup?" (was
    "Overwrite or keep the existing config?") for clarity
  - fix: CI doctest for LlmExtractionConfig uses unwrap_or_else instead of unwrap on
    OPENAI_API_KEY to avoid panic in CI environments without the env var
  - fix: LlmExtractionError::NotConfigured no longer panics on empty API key;
    returns a proper error instead
  - docs: two new blog posts covering complete MCP + REST integration:
    docs/mentisdb-third-party-integrations.html (wizard setup, Claude Desktop
    mcp-remote+Homebrew, OpenCode, REST API with full endpoint coverage, Python
    requests examples, all 37 MCP tools, troubleshooting)
    docs/pymentisdb-python-client.html (complete MentisDbClient API, LangChain
    integration, typed relations, complete working example)
  - docs(README): Python client section with pip install and example; consolidated
    Setup Scenarios section for Claude Desktop, Claude Code, OpenCode, Codex, Qwen
  - docs(docs.mentisdb.com): MCP section expanded with all 37 tools, REST section
    back-to-back with complete endpoint coverage and request/response schemas
  - docs: LLM extraction design doc (llm-extracted-memories-design.md) updated to
    reflect openai-rust2 usage, extract_memories_from_text API, LlmExtractionConfig,
    ExtractionResult, TokenUsage, LlmExtractionError variants
  - docs(ENGINEERING_PIPELINE): Phase 5 step 5l added — doc audit requirement for all
    public API changes reflected in docs/, README, docs.mentisdb.com, docs.rs
  - bench: LoCoMo 10-persona R@10 72.0%, LongMemEval R@5 66.8% (fresh chain)
    - WebhookManager registered at MentisDbService level, cloned per chain
    - Registration: POST /v1/webhooks with url, chain_key_filter, thought_type_filter
    - List: GET /v1/webhooks, Get one: GET /v1/webhooks/{id}, Delete: DELETE /v1/webhooks/{id}
    - MCP tools: mentisdb_register_webhook, mentisdb_list_webhooks, mentisdb_delete_webhook
    - WebhookPayload includes webhook_id, chain_key, thought full details, timestamp
    - Delivery is fire-and-forget (tokio::spawn, non-blocking from append path)
    - Exponential backoff retries: up to 5 attempts, max 32s delay
    - Persisted to $MENTISDB_DIR/webhooks.json
  - feat(search): irregular verb lemma expansion at query time in lexical search
    - normalize_lexical_tokens() gains expand_lemmas bool parameter
    - expand_lemmas=false at index time (avoids duplicate postings)
    - expand_lemmas=true at query time (bridges went→go, ran→run, etc.)
    - Uses existing lemmas.rs lookup table (160+ irregular verbs)
    - Dedup logic (dedup_threshold) also uses expand_lemmas=true
  - fix: duplicate closing braces in lexical.rs (syntax error from prior edit)
  - test: add integration tests for webhook manager persistence and delete

0.8.8.34 APR/13/2026
  - feat: add source_episode field to Thought for episode provenance tracking
    - Optional episode/conversational context identifier groups related thoughts
    - Added to Thought, ThoughtInput (with with_source_episode() builder),
      ThoughtQuery (with with_source_episode() filter), thought_json output,
      and dashboard API
    - Not included in thought hash (backward compatible, like entity_type)
  - feat(search): add opt-in LLM-based reranking for ranked search
    - New fields on RankedSearchQuery: llm_rerank (bool), llm_model (Option<String>),
      llm_rerank_top_k (usize, default 20), with_llm_reranking() builder
    - RankedSearchScore gains llm_score field (0.0 when disabled)
    - MentisDb::llm_rerank_candidates() calls OpenAI or Anthropic API with graceful
      fallback on failure (falls back to original ranking)
    - REST: POST /v1/search/rerank dedicated endpoint
    - LLM reranking is query-time only, no persistence required
  - feat(search): verify and fix cross-chain graph query traversal
    - resolve_context_by_id now properly skips cross-chain relations
      (those with chain_key.is_some()) during local traversal
    - ThoughtAdjacencyIndex correctly tracks cross-chain targets via ThoughtLocator::cross_chain
    - Graph expansion works across chains via BranchesFrom relations
    - ancestor_chain_keys() discovers parent chains for cross-chain ranked search
  - test: add 8 search sanity-check regression tests
    - query_with_tags_any_returns_all_matching_thoughts
    - query_with_types_returns_only_matching_types
    - query_returns_empty_when_no_match_exists
    - query_with_text_search_finds_content
    - query_with_text_search_is_case_insensitive
    - query_filter_by_importance_threshold
    - entity_type_filter_returns_only_matching_entity_types
    - cross_chain_relation_traversal, query_respects_cross_chain_chain_key
  - test: LLM reranking tests (llm_rerank_disabled_by_default,
    llm_rerank_falls_back_on_failure, llm_rerank_top_k_respected)
  - test: source_episode tests (source_episode_field_round_trips,
    source_episode_filter_in_query, source_episode_none_when_not_set)

0.8.7.33 APR/13/2026
  - feat(entity_type): add entity_type field to Thought struct with V3 backward-compatible deserialization
    - Thought struct gains optional `entity_type: Option<String>` field with `#[serde(default)]`
    - Per-thought version detection for V3 chains with and without entity_type field
    - `ThoughtInput` gains `entity_type` field, passed through builder pattern
    - `Thought::with_entity_type()` builder method
    - entity_type is NOT included in the thought hash (backward-compatible)
    - bincode 2.0.1 respects `skip_serializing_if` — must NOT use it on entity_type
  - feat(entity_type): EntityTypeRegistry per chain with auto-observe, persistence, query filter
    - New `EntityTypeRegistry` struct tracking first_seen_index, last_seen_index, count
    - Auto-observed on every append when entity_type is set
    - Persisted as `chain_key-entity-types.json` alongside the chain binary
    - `list_entity_types()`, `get_entity_type()`, `upsert_entity_type()` on MentisDb
    - MCP endpoint: `POST /v1/entity-types` for upsert, `GET /v1/entity-types` for list
    - MCP tool: `mentisdb_upsert_entity_type`
    - ThoughtQuery gains `entity_type` filter for semantic filtering
    - Dashboard search UI gains entity_type filter input
  - feat(dashboard): display entity_type badge in thought rows and add entity_type filter
    - `thought_json()` now includes entity_type field in output
    - entity_type badge next to thought_type badge in all thought row views
    - entity_type badge in thought detail modal
    - DashboardSearchQuery gains entity_type filter parameter
    - dashboard_search_filter wires entity_type to ThoughtQuery
  - fix(dashboard): convert branch/delete/merge modals to popup overlays
    - Modals now use .modal-overlay hidden popup dialogs instead of inline display:none divs
    - Moved modal HTML and JS handlers to top-level of script for availability from any page
    - Added X close buttons and backdrop click-to-close for all modals
    - All style.display toggles replaced with classList.add/remove('hidden')
  - fix(server): resolve_chain_key now trims and filters empty strings before fallback
    - Added `.map(str::trim).filter(|value| !value.is_empty())` before `unwrap_or`
    - Matches the pattern already used in `resolve_agent_identity`
    - Handles `Some("")` and `Some("  ")` correctly
  - fix(wizard): continue past failed integrations instead of aborting (Issue #14)
    - `ensure_prerequisites` returns `PrerequisiteStatus` (Ok or Warning) not errors
    - `apply` loop in wizard.rs catches per-integration failures and continues
    - `apply_setup_with_environment` returns warnings not errors for soft checks
  - fix(dashboard): _openBranchChain accepts optional thoughtId parameter
    - Branch button on thought rows passes thought UUID to the modal
  - fix(dashboard): define global onclick handlers early as stubs with queue-draining
    - Branch/delete/merge onclick handlers are now top-level functions available from any page
  - fix(server): accept schema v4+ chains by trying current Thought deserialization first
    - Changed `v == MENTISDB_CURRENT_VERSION` to `v >= MENTISDB_CURRENT_VERSION`
    - Falls back to LegacyThoughtV2 for older schemas
    - Schema version normalized to MENTISDB_CURRENT_VERSION on next persist

0.8.6.32 APR/12/2026
  - feat(search): Reciprocal Rank Fusion (RRF) reranking for ranked search
    - New `src/search/ranked.rs` with `rrf_merge()`, `rrf_merge_three()`, RRF_K=60
    - `RankedSearchQuery` gains `enable_reranking: bool` (default false) and
      `rerank_k: usize` (default 50) fields with `with_reranking()` builder
    - When enabled, three single-signal rankings (lexical-only, vector-only,
      graph-only) are merged via `1/(k + rank)` and replace the additive total;
      importance, confidence, recency, session cohesion, and graph signals are
      added back as small additive adjustments
    - `RankedSearchScore` gains `rrf: f32` field (0.0 when reranking disabled)
    - REST and MCP transports pass `enable_reranking`/`rerank_k` through
    - 6 unit tests for RRF merge logic
  - feat(search): per-field BM25 document-frequency cutoffs (global DF)
    - `Bm25DfCutoffs` struct on `LexicalQuery` with configurable cutoff ratios
      per field: content, tags, concepts, agent_id, agent_registry
    - Terms whose global DF exceeds `cutoff_ratio * N` are filtered from that
      field only — preserves original stop-word suppression while allowing
      per-field tuning
    - Default cutoffs: content=0.30, tags=0.30, concepts=0.30, agent_id=0.70,
      agent_registry=0.60
    - `with_df_cutoffs()` builder on `LexicalQuery`
  - feat(search): irregular verb lemma expansion
    - `src/search/lemmas.rs` with ~170 irregular English verb mappings
    - Query tokenization expands "went"→"go", "gave"→"give", "ran"→"run", etc.
    - Indexed content is NOT changed — lemma expansion is query-time only
  - feat(branching): BranchesFrom relation and chain branching
    - `ThoughtRelationKind::BranchesFrom` for cross-chain divergence points
    - `MentisDb::branch_from()` creates a new chain with a genesis thought
      pointing back to the branch-point thought on the source chain
    - `ancestor_chain_keys()` walks BranchesFrom relations to discover parent
      and grandparent chains
    - Ranked search on branch chains transparently searches ancestor chains
      and annotates results with chain_key
    - REST endpoint: `POST /v1/chains/branch`
    - MCP tool: `mentisdb_branch_from`
  - fix(search): use global DF for Bm25DfCutoffs comparison
    - Per-field DF calculation was less aggressive than original global DF check,
      letting high-frequency terms pass through and adding noise
    - Changed to use global DF (postings list length) for cutoff comparison,
      matching the original stop-word suppression behavior
  - docs(whitepaper): expanded BM25 explanation, per-field DF cutoffs table,
    RRF section 6.8
  - bench: LoCoMo 73.0% R@10 (fresh chain), LongMemEval 57.6% R@5

0.8.5.31 APR/11/2026
  - fix(cli): panic in update/force-update subcommands — cannot start tokio runtime within runtime
    - run_update_standalone() created a nested tokio runtime inside #[tokio::main],
      causing "Cannot start a runtime from within a runtime" panic
    - Made run_update_standalone async and .await'd fetch directly instead of rt.block_on()
    - Added test: parse_daemon_args_accepts_update_subcommands verifies update/force-update parse

0.8.4.30 APR/11/2026
  - fix(updater): move update check before chain migrations
    - Users who couldn't open mentisdb after upgrading were stuck because
      the update check ran AFTER migrations, which crashed on the old binary.
      Now the update check runs FIRST, giving users the fix before their
      chains are touched.
    - If an update is found and accepted, mentisdb exits with instructions
      to restart. No automatic in-process restart — simpler and safer.
  - feat(cli): add `mentisdb update` and `mentisdb force-update` subcommands
    - `mentisdb update` checks for a newer release and prompts y/N to install
    - `mentisdb force-update` installs the latest release unconditionally,
      even if the current version appears up to date — useful for repairing
      a corrupted binary or forcing a fresh install
    - Both use the same cargo install path as the startup update check
  - refactor(updater): remove async update check task and restart channel
    - The update check now runs synchronously before migrations instead of
      in a background tokio task after servers start
    - Removed dead code: run_update_check_task(), RestartRequest,
      shutdown_all_servers(), restart_installed_binary()

0.8.3.29 APR/10/2026
  - fix(migration): per-thought schema detection for mixed-schema binary chains
    - Users upgrading from 0.8.1 to 0.8.2 encountered a crash when opening existing
      chains: "UnexpectedVariant { type_name: Option<T>, found: 64 }" or
      "UUID parsing failed: invalid length". We sincerely apologize for the snag.
    - Root cause: the old load_binary_thoughts() peeked only the FIRST thought's
      schema_version and applied one legacy format to the entire chain. Chains
      containing thoughts from multiple schema versions (e.g. V1 thoughts followed
      by V2 thoughts appended by a later daemon) would fail deserialization because
      the wrong struct layout was used for later thoughts.
    - Fix: replace single-schema-path approach with load_binary_thoughts_per_thought()
      which reads each thought's payload individually, peeks its schema_version
      varint, and dispatches to the correct legacy deserializer (V0/V1 with
      2-field ThoughtRelation, V2 with 3-field, or V3 direct). Rebuilds the hash
      chain for migrated thoughts after loading.
    - Remove dead migrate_v2_thoughts() function whose logic is now inline.
  - test(migration): comprehensive migration tests for all schema versions
    - migrate_v2_chain_with_all_relation_kinds: all 11 ThoughtRelationKind variants
      with and without chain_key, verifying valid_at/invalid_at are None after migration
    - migrate_v1_chain_with_all_thought_types: all 30 ThoughtType variants survive
    - migrate_v2_chain_with_all_thought_roles: all 8 ThoughtRole variants survive
    - migrate_mixed_chain_with_v1_v2_v3_thoughts: per-thought detection across
      V1, V2, and V3 thoughts in the same chain
    - migrate_v2_chain_with_signed_thought: signing_key_id and thought_signature
    - migrate_v1_chain_with_relations: 2-field LegacyTestRelation migrates to 5-field
      ThoughtRelation with chain_key=None, valid_at=None, invalid_at=None
  - docs(whitepaper): complete rewrite covering 0.8.2 features
    - 12 sections: architecture, schema evolution, semantic memory model, storage,
      query & retrieval, dedup, CLI, MCP, benchmarks, competitive landscape, future

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
    - mentisdb add <content> [--type] [--scope] [--tag] [--agent] [--chain] [--url]
    - mentisdb search <query> [--limit] [--scope] [--chain] [--url]
    - mentisdb 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 mentisdb 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 mentisdb, 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 mentisdb 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 mentisdb tests to tests/mentisdb_tests.rs
   - Removed the #[cfg(test)] mod tests block from src/bin/mentisdb.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 `mentisdb` 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
   - `mentisdb` 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 `mentisdb`
   - 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
   - `mentisdb` 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 `mentisdb`
   - 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, `mentisdb` shows an ASCII prompt window and accepts `Y`/`N`
   - Accepting the prompt runs `cargo install --git ... --tag ... --locked --force --bin mentisdb 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/mentisdb_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 mentisdb
   - 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_mentisdb, 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 mentisdb
   - 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 mentisdb 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-mentisdb`, `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 `mentisdb` 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 `mentisdb` 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
   - `mentisdb` 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 `mentisdb` 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 / mentisdb.
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