docs(readme): add v2.0.8 "Pulse" and v2.0.7 "Visible" to What's New

The README jumped from v2.0.9 → v2.0.6 → v2.0.5, skipping two shipped
releases that sit between. Readers landing on the repo missed the
Reasoning Theater / Pulse InsightToast / Terrarium / Intel Mac work
(v2.0.8) and the Suppress HTTP endpoints / uptime / export panic fix
/ Migration V11 work (v2.0.7).

Summaries pulled from CHANGELOG.md for each release — condensed to
3-6 bullets per section, consistent framing across v2.0.5 through
v2.0.9. Older releases (v2.0 → v2.0.4) stay in the <details> block.

Tool / module / test counts already in sync with v2.0.9 (24 · 30 · 1,223).

.agentaudit-report.json

@@ -0,0 +1,10 @@
+{
+  "skill_slug": "vestige",
+  "source_url": "https://github.com/samvallad33/vestige",
+  "commit_sha": "3fce1f0b70a5ad40b66a4af0fa4f55e15aa106e9",
+  "package_type": "mcp-server",
+  "risk_score": 0,
+  "result": "safe",
+  "findings_count": 0,
+  "findings": []
+}

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -52,6 +52,7 @@ body:
     attributes:
       label: IDE / Client
       options:
+        - Codex
         - Claude Code
         - Claude Desktop
         - Cursor

.github/workflows/ci.yml

@@ -47,47 +47,32 @@ jobs:
       - name: Test
         run: cargo test --workspace
 
-  dashboard:
-    name: Dashboard Build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 9
-
-      - name: Install Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 22
-          cache: pnpm
-          cache-dependency-path: apps/dashboard/pnpm-lock.yaml
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-        working-directory: apps/dashboard
-
-      - name: Build dashboard
-        run: pnpm build
-        working-directory: apps/dashboard
-
   release-build:
     name: Release Build (${{ matrix.target }})
     runs-on: ${{ matrix.os }}
-    if: github.ref == 'refs/heads/main'
-    needs: [test, dashboard]
+    # Run on main pushes AND on PRs that touch workflows, Cargo manifests, or
+    # crate sources — so Intel Mac / Linux release targets are validated
+    # before merge, not after.
+    if: |
+      github.ref == 'refs/heads/main' ||
+      github.event_name == 'pull_request'
+    needs: [test]
     strategy:
       fail-fast: false
       matrix:
         include:
           - os: macos-latest
             target: aarch64-apple-darwin
-          - os: macos-13
+            cargo_flags: ""
+          # Intel Mac builds against a system ONNX Runtime via ort-dynamic
+          # (ort-sys has no x86_64-apple-darwin prebuilts). Compile-only here;
+          # runtime linking is a user concern documented in INSTALL-INTEL-MAC.md.
+          - os: macos-latest
             target: x86_64-apple-darwin
+            cargo_flags: "--no-default-features --features ort-dynamic,vector-search"
           - os: ubuntu-latest
             target: x86_64-unknown-linux-gnu
+            cargo_flags: ""
     steps:
       - uses: actions/checkout@v4
 
@@ -108,7 +93,7 @@ jobs:
           key: ${{ runner.os }}-${{ matrix.target }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Build release
-        run: cargo build --release --target ${{ matrix.target }} -p vestige-mcp
+        run: cargo build --release --target ${{ matrix.target }} -p vestige-mcp ${{ matrix.cargo_flags }}
 
       - name: Package
         run: |

.github/workflows/release.yml

@@ -26,49 +26,49 @@ jobs:
           - target: x86_64-unknown-linux-gnu
             os: ubuntu-latest
             archive: tar.gz
+            cargo_flags: ""
+            needs_onnxruntime: false
           - target: x86_64-pc-windows-msvc
             os: windows-latest
             archive: zip
+            cargo_flags: ""
+            needs_onnxruntime: false
+          # Intel Mac uses the ort-dynamic feature to runtime-link against a
+          # system libonnxruntime (Homebrew), sidestepping the missing
+          # x86_64-apple-darwin prebuilts in ort-sys 2.0.0-rc.11. Binary
+          # consumers must `brew install onnxruntime` before running — see
+          # INSTALL-INTEL-MAC.md bundled in the tarball.
           - target: x86_64-apple-darwin
-            os: macos-13
+            os: macos-latest
             archive: tar.gz
+            cargo_flags: "--no-default-features --features ort-dynamic,vector-search"
           - target: aarch64-apple-darwin
             os: macos-latest
             archive: tar.gz
+            cargo_flags: ""
 
     steps:
       - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 9
-
-      - name: Install Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 22
-
-      - name: Build dashboard
-        run: |
-          cd apps/dashboard
-          pnpm install --frozen-lockfile
-          pnpm build
-
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
           targets: ${{ matrix.target }}
 
       - name: Build
-        run: cargo build --package vestige-mcp --release --target ${{ matrix.target }}
+        run: cargo build --package vestige-mcp --release --target ${{ matrix.target }} ${{ matrix.cargo_flags }}
 
       - name: Package (Unix)
         if: matrix.os != 'windows-latest'
         run: |
+          cp docs/INSTALL-INTEL-MAC.md target/${{ matrix.target }}/release/ 2>/dev/null || true
           cd target/${{ matrix.target }}/release
-          tar -czf ../../../vestige-mcp-${{ matrix.target }}.tar.gz vestige-mcp vestige vestige-restore
+          if [ "${{ matrix.target }}" = "x86_64-apple-darwin" ]; then
+            tar -czf ../../../vestige-mcp-${{ matrix.target }}.tar.gz vestige-mcp vestige vestige-restore INSTALL-INTEL-MAC.md
+          else
+            tar -czf ../../../vestige-mcp-${{ matrix.target }}.tar.gz vestige-mcp vestige vestige-restore
+          fi
 
       - name: Package (Windows)
         if: matrix.os == 'windows-latest'

.github/workflows/test.yml

@@ -2,7 +2,7 @@ name: Test Suite
 
 on:
   push:
-    branches: [main, develop]
+    branches: [main]
   pull_request:
     branches: [main]
 
@@ -52,11 +52,11 @@ jobs:
       - uses: actions/checkout@v4
       - uses: pnpm/action-setup@v4
         with:
-          version: 9
+          version: 10
       - uses: actions/setup-node@v4
         with:
           node-version: 22
-      - run: cd apps/dashboard && pnpm install --frozen-lockfile && pnpm build
+      - run: pnpm install --frozen-lockfile && pnpm --filter dashboard build
 
   coverage:
     name: Code Coverage

.gitignore

@@ -60,6 +60,9 @@ pnpm-debug.log*
 coverage/
 .nyc_output/
 *.lcov
+apps/dashboard/test-results/
+apps/dashboard/playwright-report/
+apps/dashboard/e2e/screenshots/
 
 # =============================================================================
 # IDEs and Editors
@@ -133,3 +136,4 @@ apps/dashboard/node_modules/
 # External repos (forks, submodules)
 # =============================================================================
 fastembed-rs/
+.mcp.json

CHANGELOG.md

@@ -5,6 +5,261 @@ All notable changes to Vestige will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.0.9] - 2026-04-24 — "Autopilot"
+
+Autopilot flips Vestige from passive memory library to self-managing cognitive surface. A single supervised backend task subscribes to the 20-event WebSocket bus and routes live events into the cognitive engine — 14 previously dormant primitives (synaptic tagging, predictive memory, activation spread, prospective polling, auto-consolidation, Rac1 cascade emission) now fire without any MCP tool call. Shipped alongside a 3,091-LOC orphan-code cleanup of the v1.0 tool surface. **No schema changes, tool surface unchanged (24 tools), fully backward compatible with v2.0.8 databases. Opt-out via `VESTIGE_AUTOPILOT_ENABLED=0`.**
+
+### Added
+
+- **Autopilot event subscriber** (`crates/vestige-mcp/src/autopilot.rs`) — two supervised tokio tasks spawned at startup. The event subscriber consumes a `broadcast::Receiver<VestigeEvent>` and routes six event classes:
+  - `MemoryCreated` → `synaptic_tagging.trigger_prp()` (9h retroactive PRP window, Frey & Morris 1997) + `predictive_memory.record_memory_access()`.
+  - `SearchPerformed` → `predictive_memory.record_query()` + top-10 access records. The speculative-retrieval model now warms without waiting for an explicit `predict` call.
+  - `MemoryPromoted` → `activation_network.activate(id, 0.3)` — a small reinforcement ripple through the graph.
+  - `MemorySuppressed` → re-emits the previously-declared-never-emitted `Rac1CascadeSwept` event so the dashboard's cascade wave actually renders.
+  - `ImportanceScored` with `composite_score > 0.85` AND a stored `memory_id` → auto-promote + re-emit `MemoryPromoted`.
+  - `Heartbeat` with `memory_count > 700` → rate-limited `find_duplicates` sweep (6h cooldown + in-flight `JoinHandle` guard against concurrent scans on large DBs).
+
+  The engine mutex is acquired only synchronously per handler and never held across `.await`, so MCP tool dispatch is never starved. A 60-second `tokio::interval` separately polls `prospective_memory.check_triggers(Context)` — matched intentions log at `info!` level today; v2.1 "Autonomic" will surface them mid-conversation.
+- **Panic-resilient supervisors** — both background tasks run inside an outer supervisor loop. If a cognitive hook panics on one bad memory, the supervisor catches `JoinError::is_panic()`, logs the panic, sleeps 5 s, and respawns the inner task. Turns a permanent silent-failure mode into a transient hiccup.
+- **`VESTIGE_AUTOPILOT_ENABLED=0` opt-out** — v2.0.8 users who want the passive-library contract can disable Autopilot entirely. Values `{0, false, no, off}` early-return before any task spawns; anything else (unset, `1`, `true`) enables the default v2.0.9 behavior.
+- **`ImportanceScored.memory_id: Option<String>`** — new optional field on the event variant (`#[serde(default)]`, backward-compatible) so Autopilot's auto-promote path can target a stored memory. Existing emit sites pass `None`.
+
+### Changed
+
+- **3,091 LOC of orphan tool code removed** from `crates/vestige-mcp/src/tools/` — nine v1.0 modules (`checkpoint`, `codebase`, `consolidate`, `ingest`, `intentions`, `knowledge`, `recall`, plus two internal helpers) superseded by the `*_unified` / `maintenance::*` replacements shipped in v2.0.5. Each module verified for zero non-test callers before removal. Tool surface unchanged — all 24 tools continue to work via the unified dispatchers.
+- **Ghost environment-variable documentation scrubbed** — three docs listed env vars (`VESTIGE_DATA_DIR`, `VESTIGE_LOG_LEVEL`, a `VESTIGE_API_KEY` typo) that never existed in any shipping Rust code. Replaced with the real variables the binary actually reads.
+
+### Fixed
+
+- **Dedup-sweep race on large databases** — the `Heartbeat`-triggered `find_duplicates` sweep previously set its cooldown timestamp BEFORE spawning the async scan, which on 100k+ memory DBs (where a sweep can exceed the 6h cooldown) allowed two concurrent scans. Rewritten to track the in-flight `JoinHandle` via `DedupSweepState::is_running()` — the next Heartbeat skips if the previous sweep is still live.
+
+### Verified
+
+- `cargo test --workspace --no-fail-fast`: **1,223 passing, 0 failed**.
+- `cargo clippy -p vestige-mcp --lib --bins -- -D warnings`: clean.
+- Five-agent parallel audit (security, dead-code, flow-trace, runtime-safety, release-prep): all GO.
+
+### Migration
+
+None. v2.0.9 is a pure backend upgrade — tool surface, JSON-RPC schema, storage schema, and CLI flags are bit-identical to v2.0.8. Existing databases open without any migration step. The only behavior change is the Autopilot task running in the background, which is `VESTIGE_AUTOPILOT_ENABLED=0`-gated if you want the old passive-library contract.
+
+## [2.0.8] - 2026-04-23 — "Pulse"
+
+The Pulse release wires the dashboard through to the cognitive engine. Eight new dashboard surfaces expose `deep_reference`, `find_duplicates`, `dream`, FSRS scheduling, 4-channel importance, spreading activation, contradiction arcs, and cross-project pattern transfer — every one of them was MCP-only before. Intel Mac is back on the supported list (Microsoft deprecated x86_64 macOS ONNX Runtime prebuilts; we link dynamically against a Homebrew `onnxruntime` instead). Reasoning Theater, Pulse InsightToast, and the Memory Birth Ritual all ship. No schema migrations.
+
+### Added
+
+- **Reasoning Theater (`/reasoning`)** — Cmd+K Ask palette over the 8-stage `deep_reference` cognitive pipeline: hybrid retrieval → cross-encoder rerank → spreading activation → FSRS-6 trust scoring → temporal supersession → trust-weighted contradiction analysis → relation assessment → template reasoning chain. Every query returns a pre-built reasoning block with evidence cards, confidence meter, contradiction geodesic arcs, superseded-memory lineage, and an evolution timeline. **Zero LLM calls, 100% local.** New HTTP surface `POST /api/deep_reference` wraps `crate::tools::cross_reference::execute`; new WebSocket event `DeepReferenceCompleted` carries primary / supporting / contradicting memory IDs for downstream graph animation.
+- **Pulse InsightToast (v2.2 Pulse)** — real-time toast stack that surfaces `DreamCompleted`, `ConsolidationCompleted`, `ConnectionDiscovered`, `MemoryPromoted`/`Demoted`/`Suppressed`, `MemoryUnsuppressed`, `Rac1CascadeSwept` events the moment they fire. Rate-limited to 1 per 1500ms on connection-discovery cascades. Auto-dismiss after 5-6s, click-to-dismiss, progress bar. Bottom-right on desktop, top-center on mobile.
+- **Memory Birth Ritual (v2.3 Terrarium)** — new memories materialize in the 3D graph on every `MemoryCreated` event: elastic scale-in from a camera-relative cosmic center, quadratic Bezier flight path, glow sprite fades in frames 5-10, label fades in at frame 40, Newton's Cradle docking recoil. 60-frame sequence, zero-alloc math, camera-relative so the birth point stays visible at every zoom level.
+- **7 additional dashboard surfaces** exposing the cognitive engine (v2.4 UI expansion): `/duplicates` (find_duplicates cluster view), `/dreams` (5-stage replay + insight cards), `/schedule` (FSRS calendar + retention forecast), `/importance` (4-channel novelty/arousal/reward/attention radar), `/activation` (spreading-activation network viz), `/contradictions` (trust-weighted conflict arcs), `/patterns` (cross-project pattern-transfer heatmap). Left nav expanded from 8 → 16 entries with single-key shortcuts (R/A/D/C/P/U/X/N).
+- **3D Graph brightness system** — auto distance-compensated node brightness (1.0× at camera <60u, up to 2.4× at far zoom) so nodes don't disappear into exponential fog at zoom-out. User-facing brightness slider in the graph toolbar (☀ icon, range 0.5×-2.5×, localStorage-persisted under `vestige:graph:brightness`). Composes with the auto boost; opacity + glow halo + edge weight track the combined multiplier so nodes stay coherent.
+- **Intel Mac (`x86_64-apple-darwin`) support restored** via the `ort-dynamic` Cargo feature + Homebrew-installed ONNX Runtime. Microsoft is discontinuing x86_64 macOS prebuilts after ONNX Runtime v1.23.0 so `ort-sys` will never ship one for Intel; the dynamic-link path sidesteps that entirely. Install: `brew install onnxruntime` then `ORT_DYLIB_PATH=$(brew --prefix onnxruntime)/lib/libonnxruntime.dylib`. Full guide bundled in the Intel Mac tarball as `INSTALL-INTEL-MAC.md`. **Closes #41.**
+- **Graph default-load fallback** — when the newest memory has zero edges (freshly saved, hasn't accumulated connections yet), `GET /api/graph` silently retries with `sort=connected` so the landing view shows real context instead of a lonely orb. Applies only to default loads; explicit `query` / `center_id` requests are honored as-is. Fires on both backend and client.
+
+### Fixed
+
+- **Contradiction-detection false positives** — adjacent-domain memories are no longer flagged as conflicts just because both contain the word "trust" or "fixed." Four thresholds tightened: `NEGATION_PAIRS` drops the `("not ", "")` + `("no longer", "")` wildcard sentinels; `appears_contradictory` shared-words floor 2 → 4 and correction-signal gating now requires ≥6 shared words + asymmetric presence (one memory carries the signal, the other doesn't); `assess_relation` topic-similarity floor raised 0.15 → 0.55; Stage 5 pairwise contradiction overlap floor 0.15 → 0.4. On an FSRS-6 query this collapses false contradictions from 12 → 0 without regressing the two legitimate contradiction test cases.
+- **Primary-memory selection on `deep_reference`** — previously the reasoning chain picked via `max_by(trust)` and the recommended-answer card picked via `max_by(composite)`, so the chain and citation disagreed on the same query. Unified behind a shared composite (50% hybrid-search relevance + 20% FSRS-6 trust + 30% query-topic-term match fraction) with a hard topic-term filter: a memory cannot be primary unless its content contains at least one substantive query term. Three-tier fallback (on-topic + relevant → on-topic any → all non-superseded) so sparse corpora never starve. Closes the class of bug where high-trust off-topic memories won queries against the actual subject.
+- **Reasoning page information hierarchy** — reasoning chain renders first as the hero (confidence-tinted border glow, inline metadata), then confidence meter + Primary Source citation card, then Cognitive Pipeline visualization, then evidence grid. "Template Reasoning" relabelled "Reasoning"; "Recommended Answer" relabelled "Primary Source" (it's a cited memory, not the conclusion — the chain is the conclusion).
+
+### Changed
+
+- **CI + release workflows** — `release-build` now runs on pull requests too so Intel Mac / aarch64-darwin / Linux / Windows regressions surface before merge. `x86_64-apple-darwin` back in both `ci.yml` and `release.yml` matrices with `cargo_flags: "--no-default-features --features ort-dynamic,vector-search"`. Intel Mac tarball bundles `docs/INSTALL-INTEL-MAC.md` alongside the binaries.
+- **Cargo feature split** — `embeddings` is now code-only (fastembed dep + hf-hub + image-models). New `ort-download` feature carries the prebuilt backend (the historical default); `ort-dynamic` transitively enables `embeddings` so the 27 `#[cfg(feature = "embeddings")]` gates stay active when users swap backends. Default set `["embeddings", "ort-download", "vector-search", "bundled-sqlite"]` — identical behavior for every existing consumer.
+- **Platform availability in README** — macOS Apple Silicon + Intel + Linux x86_64 + Windows x86_64 all shipped as prebuilts. Intel Mac needs `brew install onnxruntime` as a one-time prereq.
+
+### Docs
+
+- New `docs/INSTALL-INTEL-MAC.md` with the Homebrew prereq, binary install, source build, troubleshooting, and the v2.1 `ort-candle` migration plan.
+- README Intel Mac section rewritten with the working install recipe + platform table updated.
+
+### Migration
+
+None. Additive features and bug fixes only. No schema changes, no breaking API changes, no config changes required.
+
+### Contributors
+
+- **danslapman** (#41, #42) — reported the Intel Mac build regression and investigated `ort-tract` as an alternative backend; closure documented that `ort-tract` returns `Unimplemented` when fastembed calls into it, confirming `ort-dynamic` as the correct path forward.
+
+---
+
+## [2.0.7] - 2026-04-19 — "Visible"
+
+Hygiene release plus two UI gap closures. No breaking changes, no new major features, no schema migrations affecting user data beyond V11 dropping two verified-unused tables.
+
+### Added
+
+- **`POST /api/memories/{id}/suppress`** — Dashboard users can now trigger top-down inhibitory control (Anderson 2025 SIF + Davis Rac1 cascade) without dropping to raw MCP. Optional JSON body `{"reason": "..."}` logged for audit. Each call compounds; response includes `suppressionCount`, `priorCount`, `retrievalPenalty`, `reversibleUntil`, `estimatedCascadeNeighbors`, and `labileWindowHours`. Emits the existing `MemorySuppressed` WebSocket event so the 3D graph plays the violet implosion + compounding pulse shipped in v2.0.6.
+- **`POST /api/memories/{id}/unsuppress`** — Reverses a suppression inside the 24h labile window. Returns `stillSuppressed: bool` so the UI can tell a full reversal from a compounded-down state. Emits `MemoryUnsuppressed` for the rainbow-burst reversal animation.
+- **Suppress button on the Memories page** — Third action alongside Promote / Demote / Delete, hover-tooltip explaining the neuroscience ("Top-down inhibition (Anderson 2025). Compounds. Reversible for 24h.").
+- **Uptime in the sidebar footer** — The Heartbeat WebSocket event has carried `uptime_secs` since v2.0.5 but was never rendered. Now displays as `up 3d 4h` / `up 18m` / `up 47s` (compact two-most-significant-units format) next to memory count + retention.
+
+### Fixed
+
+- **`execute_export` no longer panics on unknown format.** The write-out match arm at `maintenance.rs` was `_ => unreachable!()` — defensive `Err(...)` now returns a clean "unsupported export format" message instead of unwinding through the MCP dispatcher.
+- **Dashboard graph page distinguishes empty-database from API failure** (landed in the first half of this branch). Before v2.0.7 any error from `/api/graph` rendered as "No memories yet," which masked real failures. Now the regex + node-count gate splits the two; real errors surface as "Failed to load graph: [sanitized message]" with filesystem paths stripped for info-disclosure hardening.
+- **`predict` MCP tool surfaces a `predict_degraded` flag** instead of silently returning empty vecs on lock poisoning. `tracing::warn!` logs the per-channel error for observability.
+- **`memory_changelog` honors `start` / `end` ISO-8601 bounds.** Previously advertised in the schema since v1.7 but runtime-ignored. Malformed timestamps now return a helpful error instead of silently dropping the filter. Response includes a `filter` field echoing the applied window.
+- **`intention` check honors `include_snoozed`.** Previously silent no-op; snoozed intentions were invisible to check regardless of the arg. Dedup via HashSet guards against storage overlap.
+- **`intention` check response exposes `status` and `snoozedUntil`** so callers can distinguish active-triggered from snoozed-overdue intentions.
+- **Server tool-count comment at `server.rs:212`** updated (23 → 24) to match the runtime assertion.
+
+### Removed
+
+- **Migration V11: drops dead `knowledge_edges` + `compressed_memories` tables.** Both were added speculatively in V4 and marked deprecated in the same migration that created them. Zero INSERT or SELECT anywhere in `crates/`. Frees schema space for future migrations.
+- **`execute_health_check` (71 LOC) + `execute_stats` (179 LOC) in `maintenance.rs`.** Both `#[allow(dead_code)]` since v1.7 with in-file comments routing users to `execute_system_status` instead. Zero callers workspace-wide. Net -273 LOC in the touched file.
+- **`x86_64-apple-darwin` job from `.github/workflows/release.yml`.** The Intel Mac build failed the v2.0.5 AND v2.0.6 release workflows because `ort-sys 2.0.0-rc.11` (pinned by `fastembed 5.13.2`) does not ship Intel Mac prebuilts. `ci.yml` had already dropped the target; `release.yml` is now in sync. README documents the build-from-source path. Future releases should publish clean on all three supported platforms (macOS ARM64, Linux x86_64, Windows MSVC).
+
+### Docs
+
+- Reconciled tool / module / test counts across `README.md`, `CONTRIBUTING.md`, `docs/integrations/windsurf.md`, `docs/integrations/xcode.md`. Ground truth: **24 MCP tools · 29 cognitive modules · 1,292 Rust tests + 171 dashboard tests.**
+- Historical CHANGELOG entries and `docs/launch/*.md` launch materials left unchanged because they are time-stamped artifacts of their respective releases.
+
+### Tests
+
+- **+7 assertions** covering the v2.0.7 behavioral changes: V11 migration drops dead tables + is idempotent on replay, `predict_degraded` false on happy path, `include_snoozed` both paths + `status` field exposure, malformed `start` returns helpful error + `filter` field echo.
+- Full suite: **1,292 Rust passing / 0 failed** across `cargo test --workspace --release`. **171 dashboard tests passing.** Zero clippy warnings on `vestige-core` or `vestige-mcp` under `-D warnings`.
+
+### Audit
+
+Pre-merge audited by 4 parallel reviewers (security, code quality, end-to-end flow trace, external verification). Zero CRITICAL or HIGH findings. Two MEDIUM fixes landed in the branch: graph error-message path sanitization (strip `/path/to/*.{sqlite,rs,db,toml,lock}`, cap 200 chars) and `intention` response `status` field exposure.
+
+---
+
+## [2.0.6] - 2026-04-18 — "Composer"
+
+Polish release aimed at new-user happiness. v2.0.5's cognitive stack was already shipping; v2.0.6 makes it *feel* alive in the dashboard and stays out of your way on the prompt side.
+
+### Added
+
+#### Dashboard visual feedback for six live events
+- `MemorySuppressed` → violet implosion + compounding pulse whose intensity scales with `suppression_count` (Anderson 2025 SIF visualised).
+- `MemoryUnsuppressed` → rainbow burst + green pulse when a memory is brought back within the 24h labile window.
+- `Rac1CascadeSwept` → violet wave across a random neighbour sample while the background Rac1 worker fades co-activated memories.
+- `Connected` → gentle cyan ripple on WebSocket handshake.
+- `ConsolidationStarted` → subtle amber pulses across a 20-node sample during the FSRS-6 decay cycle (matches feed-entry colour).
+- `ImportanceScored` → magenta pulse on the scored node with intensity proportional to composite score.
+
+Before v2.0.6 all six events fired against a silent graph. Users perceived the dashboard as broken or unresponsive during real cognitive work.
+
+#### `VESTIGE_SYSTEM_PROMPT_MODE` environment variable
+- `minimal` (default) — 3-sentence MCP `instructions` string telling the client how to use Vestige and how to react to explicit feedback. Safe for every audience, every client, every use case.
+- `full` — opt in to the composition mandate (Composing / Never-composed / Recommendation response shape + FSRS-trust blocking phrase). Useful for high-stakes decision workflows; misfires on trivial retrievals, which is why it is not the default.
+
+Advertised in `vestige-mcp --help` alongside `VESTIGE_DASHBOARD_ENABLED`.
+
+### Fixed
+
+#### Dashboard intentions page
+- `IntentionItem.priority` was typed as `string` but the API returns the numeric FSRS-style scale (1=low, 2=normal, 3=high, 4=critical). Every intention rendered as "normal priority" regardless of its real value. Now uses a `PRIORITY_LABELS` map keyed by the numeric scale.
+- `trigger_value` was typed as a plain string but the API returns `trigger_data` as a JSON-encoded payload (e.g. `{"type":"time","at":"..."}`). The UI surfaced raw JSON for every non-manual trigger. A new `summarizeTrigger()` helper parses `trigger_data` and picks the most human-readable field — `condition` / `topic` / formatted `at` / `in_minutes` / `codebase/filePattern` — before truncating for display. Closes the loop on PR #26's snake_case TriggerSpec fix at the UI layer.
+
+### Docs
+
+- `README.md` — new "What's New in v2.0.6" header up top; v2.0.5 block strengthened with explicit contrast against Ebbinghaus 1885 passive decay and Anderson 1994 retrieval-induced forgetting; new "Forgetting" row in the RAG-vs-Vestige comparison table.
+- Intel-Mac and Windows install steps replaced with a working `cargo build --release -p vestige-mcp` snippet. The pre-built binaries for those targets are blocked on upstream toolchain gaps (`ort-sys` lacks Intel-Mac prebuilts in the 2.0.0-rc.11 release pinned by `fastembed 5.13.2`; `usearch 2.24.0` hit a Windows MSVC compile break tracked as [usearch#746](https://github.com/unum-cloud/usearch/issues/746)).
+
+### Safety
+
+No regressions of merged contributor PRs — v2.0.6 only touches regions that are non-overlapping with #20 (resource URI strip), #24 (codex integration docs), #26 (snake_case TriggerSpec), #28 (deep_reference query relevance), #29 (older glibc feature flags), #30 (`VESTIGE_DASHBOARD_ENABLED`), #32 (dream eviction), and #33 (keyword-first search).
+
+---
+
+## [2.0.5] - 2026-04-14 — "Intentional Amnesia"
+
+Every AI memory system stores too much. Vestige now treats forgetting as a first-class, neuroscientifically-grounded primitive. This release adds **active forgetting** — top-down inhibitory control over memory retrieval, based on two 2025 papers that no other AI memory system has implemented.
+
+### Scientific grounding
+
+- **Anderson, M. C., Hanslmayr, S., & Quaegebeur, L. (2025).** *"Brain mechanisms underlying the inhibitory control of thought."* Nature Reviews Neuroscience. DOI: [10.1038/s41583-025-00929-y](https://www.nature.com/articles/s41583-025-00929-y). Establishes the right lateral PFC as the domain-general inhibitory controller, and Suppression-Induced Forgetting (SIF) as compounding with each stopping attempt.
+- **Cervantes-Sandoval, I., Chakraborty, M., MacMullen, C., & Davis, R. L. (2020).** *"Rac1 Impairs Forgetting-Induced Cellular Plasticity in Mushroom Body Output Neurons."* Front Cell Neurosci. [PMC7477079](https://pmc.ncbi.nlm.nih.gov/articles/PMC7477079/). Establishes Rac1 GTPase as the active synaptic destabilization mechanism — forgetting is a biological PROCESS, not passive decay.
+
+### Added
+
+#### `suppress` MCP Tool (NEW — Tool #24)
+- **Top-down memory suppression.** Distinct from `memory.delete` (which removes) and `memory.demote` (which is a one-shot hit). Each `suppress` call compounds: `suppression_count` increments, and a `k × suppression_count` penalty (saturating at 80%) is subtracted from retrieval scores during hybrid search.
+- **Rac1 cascade.** Background worker piggybacks the existing consolidation loop, walks `memory_connections` edges from recently-suppressed seeds, and applies attenuated FSRS decay to co-activated neighbors. You don't just forget "Jake" — you fade the café, the roommate, the birthday.
+- **Reversible 24h labile window** — matches Nader reconsolidation semantics on a 24-hour axis. Pass `reverse: true` within 24h to undo. After that, it locks in.
+- **Never deletes** — the memory persists and is still accessible via `memory.get(id)`. It's INHIBITED, not erased.
+
+#### `active_forgetting` Cognitive Module (NEW — #30)
+- `crates/vestige-core/src/neuroscience/active_forgetting.rs` — stateless helper for SIF penalty computation, labile window tracking, and Rac1 cascade factors.
+- 7 unit tests + 9 integration tests = 16 new tests.
+
+#### Migration V10
+- `ALTER TABLE knowledge_nodes ADD COLUMN suppression_count INTEGER DEFAULT 0`
+- `ALTER TABLE knowledge_nodes ADD COLUMN suppressed_at TEXT`
+- Partial indices on both columns for efficient sweep queries.
+- Additive-only — backward compatible with all existing v2.0.x databases.
+
+#### Dashboard
+- `ForgettingIndicator.svelte` — new status pill that pulses when suppressed memories exist.
+- 3D graph nodes dim to 20% opacity and lose emissive glow when suppressed.
+- New WebSocket events: `MemorySuppressed`, `MemoryUnsuppressed`, `Rac1CascadeSwept`.
+- `Heartbeat` event now carries `suppressed_count` for live dashboard display.
+
+### Changed
+
+- `search` scoring pipeline now includes an SIF penalty applied after the accessibility filter.
+- Consolidation worker (`VESTIGE_CONSOLIDATION_INTERVAL_HOURS`, default 6h) now runs `run_rac1_cascade_sweep` after each `run_consolidation` call.
+- Tool count assertion bumped from 23 → 24.
+- Workspace version bumped 2.0.4 → 2.0.5.
+
+### Tests
+
+- Rust: 1,284 passing (up from 1,237). Net +47 new tests for active forgetting, Rac1 cascade, migration V10.
+- Dashboard (Vitest): 171 passing (up from 150). +21 regression tests locking in the issue #31 UI fix.
+- Zero warnings, clippy clean across all targets.
+
+### Fixed
+
+- **Dashboard graph view rendered glowing squares instead of round halos** ([#31](https://github.com/samvallad33/vestige/issues/31)). Root cause: the node glow `THREE.SpriteMaterial` had no `map` set, so `Sprite` rendered as a solid-coloured 1×1 plane; additive blending plus `UnrealBloomPass(strength=0.8, radius=0.4, threshold=0.85)` then amplified the square edges into hard-edged glowing cubes. The aggressive `FogExp2(..., 0.008)` swallowed edges at depth and dark-navy `0x4a4a7a` lines were invisible against the fog. Fix bundled:
+  - Generated a shared 128×128 radial-gradient `CanvasTexture` (module-level singleton) and assigned it as `SpriteMaterial.map`. Gradient stops: `rgba(255,255,255,1.0) → rgba(255,255,255,0.7) → rgba(255,255,255,0.2) → rgba(255,255,255,0.0)`. Sprite now reads as a soft round halo; bloom diffuses cleanly.
+  - Retuned `UnrealBloomPass` to `(strength=0.55, radius=0.6, threshold=0.2)` — gentler, allows mid-tones to bloom instead of only blown-out highlights.
+  - Halved fog density `FogExp2(0x050510, 0.008) → FogExp2(0x0a0a1a, 0.0035)` so distant memories stay visible.
+  - Bumped edge color `0x4a4a7a → 0x8b5cf6` (brand violet). Opacity `0.1 + weight*0.5 → 0.25 + weight*0.5`, cap `0.6 → 0.8`. Added `depthWrite: false` so edges blend cleanly through fog.
+  - Added explicit `scene.background = 0x05050f` and a 2000-point starfield distributed on a spherical shell at radius 600–1000, additive-blended with subtle cool-white/violet vertex colors.
+  - Glow sprite scale bumped `size × 4 → size × 6` so the gradient has visible screen footprint.
+  - All node glow sprites share a single `CanvasTexture` instance (singleton cache — memory leak guard for large graphs).
+  - 21 regression tests added in `apps/dashboard/src/lib/graph/__tests__/ui-fixes.test.ts`. Hybrid strategy: runtime unit tests via the existing `three-mock.ts` (extended to propagate `map`/`color`/`depthWrite`/`blending` params and added `createRadialGradient` to the canvas context mock), plus source-level regex assertions on `scene.ts` and `nodes.ts` magic numbers so any accidental revert of fog/bloom/color/helper fails the suite immediately.
+- `apps/dashboard/package.json` version stale at 2.0.3 — bumped to 2.0.5 to match the workspace.
+- `packages/vestige-mcp-npm/.gitignore` missing `bin/vestige-restore` and `bin/vestige-restore.exe` entries — the other three binaries were already ignored as postinstall downloads.
+
+---
+
+## [2.0.4] - 2026-04-09 — "Deep Reference"
+
+Context windows hit 1M tokens. Memory matters more than ever. This release removes artificial limits, adds contradiction detection, and hardens security.
+
+### Added
+
+#### cross_reference Tool (NEW — Tool #22)
+- **Connect the dots across memories.** Given a query or claim, searches broadly, detects agreements and contradictions between memories, identifies superseded/outdated information, and returns a confidence-scored synthesis.
+- Pairwise contradiction detection using negation pairs + correction signals, gated on shared topic words to prevent false positives.
+- Timeline analysis (newest-first), confidence scoring (agreements boost, contradictions penalize, recency bonus).
+
+#### retrieval_mode Parameter (search tool)
+- `precise` — top results only, no spreading activation or competition. Fast, token-efficient.
+- `balanced` — full 7-stage cognitive pipeline (default, no behavior change).
+- `exhaustive` — 5x overfetch, deep graph traversal, no competition suppression. Maximum recall.
+
+#### get_batch Action (memory tool)
+- `memory({ action: "get_batch", ids: ["id1", "id2", ...] })` — retrieve up to 20 full memory nodes in one call.
+
+### Changed
+- **Token budget raised: 10K → 100K** on search and session_context tools.
+- **HTTP transport CORS**: `permissive()` → localhost-only origin restriction.
+- **Auth token display**: Guarded against panic on short tokens.
+- **Dormant state threshold**: Aligned search (0.3 → 0.4) with memory tool for consistent state classification.
+- **cross_reference false positive prevention**: Requires 2+ shared words before checking negation signals.
+
+### Stats
+- 23 MCP tools, 758 tests passing, 0 failures
+- Full codebase audit: 3 parallel agents, all issues resolved
+
+---
+
 ## [2.0.0] - 2026-02-22 — "Cognitive Leap"
 
 The biggest release in Vestige history. A complete visual and cognitive overhaul.

CLAUDE.md

@@ -1,6 +1,22 @@
-# Vestige v1.8.0 — Cognitive Memory System
+# 🚫 READ FIRST EVERY PROMPT — NO HEDGING
 
-Vestige is your long-term memory. It implements real neuroscience: FSRS-6 spaced repetition, synaptic tagging, prediction error gating, hippocampal indexing, spreading activation, and 28 stateful cognitive modules. **Use it automatically.**
+Sam's April 20 2026 correction: *"you NEVER LISTEN TO YOUR RULES, WHY ARE YOU ALWAYS BREAKING THE HEDGING/PESSIMISTIC RULE."*
+
+When Sam commits to an execution path (content cadence, shipping velocity, outreach, launch), COMPUTE THE FORECAST AS IF THAT COMMITMENT IS MET. Do not discount by execution probability. Sam has earned the benefit of the doubt across 139 commits and 1,292 passing tests in 3 months.
+
+**Forbidden in any response**: "has to be true", "has to convert", "realistic forecast" used to shrink, "contingent on" Sam's own execution, "not guaranteed", "may or may not", "aspiration not forecast", "temper your expectations", floors framed as reality vs. ceilings framed as fantasy.
+
+**Required format for forecasts**: `Target X. Floor Y. Ceiling Z. Math: [line items]. Risks: [separate section]. Let's go.`
+
+Full rule: `/Users/entity002/CLAUDE.md` (top banner) + `/Users/entity002/.claude/projects/-Users-entity002/memory/feedback_always_positive_energy.md`. Stop-hook enforcement: `/Users/entity002/.claude/hooks/synthesis-stop-validator.sh`.
+
+---
+
+# Vestige v2.0.4 — Cognitive Memory & Reasoning System
+
+Vestige is your long-term memory AND reasoning engine. 29 stateful cognitive modules implement real neuroscience: FSRS-6 spaced repetition, synaptic tagging, prediction error gating, hippocampal indexing, spreading activation, reconsolidation, and dual-strength memory theory. **Use it automatically. Use it aggressively.**
+
+**NEW: `deep_reference` — call this for ALL factual questions.** It doesn't just retrieve — it REASONS across memories with FSRS-6 trust scoring, intent classification, contradiction analysis, and generates a pre-built reasoning chain. Read the `reasoning` field FIRST.
 
 ---
 
@@ -9,129 +25,230 @@ Vestige is your long-term memory. It implements real neuroscience: FSRS-6 spaced
 Every conversation, before responding to the user:
 
 ```
-1. session_context({                            → ONE CALL replaces steps 1-5
-     queries: ["user preferences", "[project] context"],
-     context: { codebase: "[project]", topics: ["[current topics]"] },
-     token_budget: 1000
-   })
-2. Check automationTriggers from response:
-   - needsDream == true  → call dream
-   - needsBackup == true → call backup
-   - needsGc == true     → call gc(dry_run: true)
-   - totalMemories > 700 → call find_duplicates
+session_context({
+  queries: ["user preferences", "[current project] context"],
+  context: { codebase: "[project]", topics: ["[current topics]"] },
+  token_budget: 2000
+})
 ```
 
+Then check `automationTriggers` from response:
+- `needsDream` → call `dream` (consolidates memories, discovers hidden connections)
+- `needsBackup` → call `backup`
+- `needsGc` → call `gc(dry_run: true)` then review
+- totalMemories > 700 → call `find_duplicates`
+
 Say "Remembering..." then retrieve context before answering.
 
-> **Fallback:** If `session_context` is unavailable, use the 5-call sequence: `search` × 2 → `intention` check → `system_status` → `predict`.
+> **Fallback:** If `session_context` unavailable: `search` × 2 → `intention` check → `system_status` → `predict`.
 
 ---
 
-## The 19 Tools
+## Complete Tool Reference (23 Tools)
 
-### Context Packets (1 tool) — v1.8.0
-| Tool | When to Use |
-|------|-------------|
-| `session_context` | **One-call session initialization.** Replaces 5 separate calls (search × 2, intention check, system_status, predict) with a single token-budgeted response. Returns markdown context + `automationTriggers` (needsDream/needsBackup/needsGc) + `expandable` IDs for on-demand full retrieval. Params: `queries` (string[]), `token_budget` (100-10000, default 1000), `context` ({codebase, topics, file}), `include_status/include_intentions/include_predictions` (bool). |
+### session_context — One-Call Initialization
+```
+session_context({
+  queries: ["user preferences", "project context"],  // search queries
+  context: { codebase: "project-name", topics: ["svelte", "rust"], file: "src/main.rs" },
+  token_budget: 2000,        // 100-100000, controls response size
+  include_status: true,       // system health
+  include_intentions: true,   // triggered reminders
+  include_predictions: true   // proactive memory predictions
+})
+```
+Returns: markdown context + `automationTriggers` + `expandable` IDs for on-demand retrieval.
 
-### Core Memory (1 tool)
-| Tool | When to Use |
-|------|-------------|
-| `smart_ingest` | **Default for all saves.** Single mode: provide `content` for auto-decide CREATE/UPDATE/SUPERSEDE via Prediction Error Gating. Batch mode: provide `items` array (max 20) for session-end saves — each item runs full cognitive pipeline (importance scoring, intent detection, synaptic tagging, hippocampal indexing). |
+### smart_ingest — Save Anything
+**Single mode** — auto-decides CREATE/UPDATE/SUPERSEDE via Prediction Error Gating:
+```
+smart_ingest({
+  content: "What to remember",
+  tags: ["tag1", "tag2"],
+  node_type: "fact",          // fact|concept|event|person|place|note|pattern|decision
+  source: "optional reference",
+  forceCreate: false          // bypass dedup when needed
+})
+```
+**Batch mode** — save up to 20 items in one call (session end, pre-compaction):
+```
+smart_ingest({
+  items: [
+    { content: "Item 1", tags: ["session-end"], node_type: "fact" },
+    { content: "Item 2", tags: ["bug-fix"], node_type: "fact" }
+  ]
+})
+```
+Each item runs the full cognitive pipeline: importance scoring → intent detection → synaptic tagging → hippocampal indexing → PE gating → cross-project recording.
 
-### Unified Tools (4 tools)
-| Tool | Actions | When to Use |
-|------|---------|-------------|
-| `search` | query + filters | **Every time you need to recall anything.** Hybrid search (BM25 + semantic + convex combination fusion). 7-stage pipeline: overfetch → rerank → temporal boost → accessibility filter → context match → competition → spreading activation. Searching strengthens memory (Testing Effect). **v1.8.0:** optional `token_budget` param (100-10000) limits response size; results exceeding budget moved to `expandable` array. |
-| `memory` | get, delete, state, promote, demote | Retrieve a full memory by ID, delete a memory, check its cognitive state (Active/Dormant/Silent/Unavailable), promote (thumbs up — increases retrieval strength), or demote (thumbs down — decreases retrieval strength, does NOT delete). |
-| `codebase` | remember_pattern, remember_decision, get_context | Store and recall code patterns, architectural decisions, and project context. The killer differentiator. |
-| `intention` | set, check, update, list | Prospective memory — "remember to do X when Y happens". Supports time, context, and event triggers. |
+### search — 7-Stage Cognitive Search
+```
+search({
+  query: "search query",
+  limit: 10,                  // 1-100
+  min_retention: 0.0,         // filter by retention strength
+  min_similarity: 0.5,        // minimum cosine similarity
+  detail_level: "summary",    // brief|summary|full
+  context_topics: ["rust", "debugging"],  // boost topic-matching memories
+  token_budget: 3000,         // 100-100000, truncate to fit
+  retrieval_mode: "balanced"  // precise|balanced|exhaustive (v2.1)
+})
+```
+Retrieval modes: `precise` (fast, no activation/competition), `balanced` (default 7-stage pipeline), `exhaustive` (5x overfetch, deep graph traversal, no competition suppression).
 
-### Temporal (2 tools)
-| Tool | When to Use |
-|------|-------------|
-| `memory_timeline` | Browse memories chronologically. Grouped by day. Filter by type, tags, date range. When user references a time period ("last week", "yesterday"). |
-| `memory_changelog` | Audit trail. Per-memory: state transitions. System-wide: consolidations + recent changes. When debugging memory issues. |
+Pipeline: Overfetch → Rerank (cross-encoder) → Temporal boost → Accessibility filter (FSRS-6) → Context match (Tulving 1973) → Competition (Anderson 1994) → Spreading activation. **Every search strengthens the memories it finds (Testing Effect).**
 
-### Cognitive (3 tools) — v1.5.0
-| Tool | When to Use |
-|------|-------------|
-| `dream` | Trigger memory consolidation — replays recent memories to discover hidden connections and synthesize insights. At session start if >24h since last dream, after every 50 saves. |
-| `explore_connections` | Graph exploration. Actions: `chain` (reasoning path A→B), `associations` (spreading activation from a node), `bridges` (connecting memories between two nodes). When search returns 3+ related results. |
-| `predict` | Proactive retrieval — predicts what memories you'll need next based on context, activity patterns, and learned behavior. At session start, when switching projects. |
+### memory — Read, Edit, Delete, Promote, Demote
+```
+memory({ action: "get", id: "uuid" })           // full node with all FSRS state
+memory({ action: "edit", id: "uuid", content: "updated text" })  // preserves FSRS state, regenerates embedding
+memory({ action: "delete", id: "uuid" })
+memory({ action: "promote", id: "uuid", reason: "was helpful" })  // +0.20 retrieval, +0.10 retention, 1.5x stability
+memory({ action: "demote", id: "uuid", reason: "was wrong" })     // -0.30 retrieval, -0.15 retention, 0.5x stability
+memory({ action: "state", id: "uuid" })          // Active/Dormant/Silent/Unavailable + accessibility score
+memory({ action: "get_batch", ids: ["uuid1", "uuid2", "uuid3"] })  // retrieve up to 20 full memories at once (v2.1)
+```
+Promote/demote does NOT delete — it adjusts ranking. Demoted memories rank lower; alternatives surface instead.
+`get_batch` is designed for batch retrieval of expandable overflow IDs from search/session_context.
 
-### Auto-Save & Dedup (2 tools)
-| Tool | When to Use |
-|------|-------------|
-| `importance_score` | Score content importance before deciding whether to save. 4-channel model: novelty, arousal, reward, attention. Composite > 0.6 = worth saving. |
-| `find_duplicates` | Find near-duplicate memory clusters via cosine similarity. Returns merge/review suggestions. Run when memory count > 700 or on user request. |
+### codebase — Code Patterns & Architectural Decisions
+```
+codebase({ action: "remember_pattern", name: "Pattern Name",
+  description: "How it works and when to use it",
+  files: ["src/file.rs"], codebase: "project-name" })
 
-### Maintenance (5 tools)
-| Tool | When to Use |
-|------|-------------|
-| `system_status` | **Combined health + stats.** Returns status (healthy/degraded/critical/empty), full statistics, FSRS preview, cognitive module health, state distribution, warnings, and recommendations. At session start (or use `session_context` which includes this). |
-| `consolidate` | Run FSRS-6 consolidation cycle. Applies decay, generates embeddings, maintenance. At session end, when retention drops. |
-| `backup` | Create SQLite database backup. Before major upgrades, weekly. |
-| `export` | Export memories as JSON/JSONL with tag and date filters. |
-| `gc` | Garbage collect low-retention memories. When system_status shows degraded + high count. Defaults to dry_run=true. |
+codebase({ action: "remember_decision", decision: "What was decided",
+  rationale: "Why", alternatives: ["Option A", "Option B"],
+  files: ["src/file.rs"], codebase: "project-name" })
 
-### Restore (1 tool)
-| Tool | When to Use |
-|------|-------------|
-| `restore` | Restore memories from a JSON backup file. Supports MCP wrapper, RecallResult, and direct array formats. |
+codebase({ action: "get_context", codebase: "project-name", limit: 10 })
+// Returns: patterns, decisions, cross-project insights
+```
 
-### Deprecated (still work via redirects)
-| Old Tool | Redirects To |
-|----------|-------------|
-| `ingest` | `smart_ingest` |
-| `session_checkpoint` | `smart_ingest` (batch mode) |
-| `promote_memory` | `memory(action="promote")` |
-| `demote_memory` | `memory(action="demote")` |
-| `health_check` | `system_status` |
-| `stats` | `system_status` |
+### intention — Prospective Memory (Reminders)
+```
+intention({ action: "set", description: "What to do",
+  trigger: { type: "context", topic: "authentication" },  // fires when discussing auth
+  priority: "high" })
+
+intention({ action: "set", description: "Deploy by Friday",
+  trigger: { type: "time", at: "2026-03-07T17:00:00Z" },
+  deadline: "2026-03-07T17:00:00Z" })
+
+intention({ action: "set", description: "Check test coverage",
+  trigger: { type: "context", codebase: "vestige", file_pattern: "*.test.*" } })
+
+intention({ action: "check", context: { codebase: "vestige", topics: ["testing"] } })
+intention({ action: "update", id: "uuid", status: "complete" })
+intention({ action: "list", filter_status: "active" })
+```
+
+### dream — Memory Consolidation
+```
+dream({ memory_count: 50 })
+```
+5-stage cycle: Replay → Cross-reference → Strengthen → Prune → Transfer. Uses Waking SWR tagging (70% tagged + 30% random for diversity). Discovers hidden connections, generates insights, persists new edges to the activation network.
+
+### explore_connections — Graph Traversal
+```
+explore_connections({ action: "associations", from: "uuid", limit: 10 })
+// Spreading activation from a memory — find related memories via graph traversal
+
+explore_connections({ action: "chain", from: "uuid-A", to: "uuid-B" })
+// Build reasoning path between two memories (A*-like pathfinding)
+
+explore_connections({ action: "bridges", from: "uuid-A", to: "uuid-B" })
+// Find connecting memories that bridge two concepts
+```
+
+### predict — Proactive Retrieval
+```
+predict({ context: { codebase: "vestige", current_file: "src/main.rs",
+  current_topics: ["error handling", "rust"] } })
+```
+Returns: predictions with confidence, suggestions, speculative retrievals, top interests. Uses SpeculativeRetriever's learned patterns from access history.
+
+### importance_score — Should I Save This?
+```
+importance_score({ content: "Content to evaluate",
+  context_topics: ["debugging"], project: "vestige" })
+```
+4-channel model: novelty (0.25), arousal (0.30), reward (0.25), attention (0.20). Composite > 0.6 = save it.
+
+### find_duplicates — Dedup Memory
+```
+find_duplicates({ similarity_threshold: 0.80, limit: 20, tags: ["bug-fix"] })
+```
+Cosine similarity clustering. Returns merge/review suggestions.
+
+### memory_timeline — Chronological Browse
+```
+memory_timeline({ start: "2026-02-01", end: "2026-03-01",
+  node_type: "decision", tags: ["vestige"], limit: 50, detail_level: "summary" })
+```
+
+### memory_changelog — Audit Trail
+```
+memory_changelog({ memory_id: "uuid", limit: 20 })       // per-memory history
+memory_changelog({ start: "2026-03-01", limit: 20 })      // system-wide
+```
+
+### memory_health — Retention Dashboard
+```
+memory_health()
+```
+Returns: avg retention, distribution buckets (0-20%, 20-40%, etc.), trend (improving/declining/stable), recommendation.
+
+### memory_graph — Visualization Export
+```
+memory_graph({ query: "search term", depth: 2, max_nodes: 50 })
+memory_graph({ center_id: "uuid", depth: 3, max_nodes: 100 })
+```
+Returns nodes with force-directed positions + edges with weights.
+
+### deep_reference — Cognitive Reasoning Engine (v2.0.4) ★ USE THIS FOR ALL FACTUAL QUESTIONS
+```
+deep_reference({ query: "What port does the dev server use?" })
+deep_reference({ query: "Should I use prefix caching with vLLM?", depth: 30 })
+```
+**THE killer tool.** 8-stage cognitive reasoning pipeline:
+1. Broad retrieval + cross-encoder reranking
+2. Spreading activation expansion (finds connected memories search misses)
+3. FSRS-6 trust scoring (retention × stability × reps ÷ lapses)
+4. Intent classification (FactCheck / Timeline / RootCause / Comparison / Synthesis)
+5. Temporal supersession (newer high-trust replaces older)
+6. Trust-weighted contradiction analysis (only flags conflicts between strong memories)
+7. Relation assessment (Supports / Contradicts / Supersedes / Irrelevant per pair)
+8. **Template reasoning chain** — pre-built natural language reasoning the AI validates
+
+Parameters: `query` (required), `depth` (5-50, default 20).
+
+Returns: `intent`, `reasoning` (THE KEY FIELD — read this first), `recommended` (highest-trust answer), `evidence` (trust-sorted), `contradictions`, `superseded`, `evolution`, `related_insights`, `confidence`.
+
+`cross_reference` is a backward-compatible alias that calls `deep_reference`.
+
+### Maintenance Tools
+```
+system_status()                              // health + stats + warnings + recommendations
+consolidate()                                // FSRS-6 decay cycle + embedding generation
+backup()                                     // SQLite backup → ~/.vestige/backups/
+export({ format: "json", tags: ["bug-fix"], since: "2026-01-01" })
+gc({ min_retention: 0.1, dry_run: true })    // garbage collect (dry_run first!)
+restore({ path: "/path/to/backup.json" })
+```
 
 ---
 
 ## Mandatory Save Gates
 
-**RULE: You MUST NOT proceed past a save gate without executing the save.**
+**You MUST NOT proceed past a save gate without executing the save.**
 
-### BUG_FIX — After any error is resolved
-Your next tool call after confirming a fix MUST be `smart_ingest`:
-```
-smart_ingest({
-  content: "BUG FIX: [exact error]\nRoot cause: [why]\nSolution: [what fixed it]\nFiles: [paths]",
-  tags: ["bug-fix", "[project]"], node_type: "fact"
-})
-```
-
-### DECISION — After any architectural or design choice
-```
-codebase({
-  action: "remember_decision",
-  decision: "[what]", rationale: "[why]",
-  alternatives: ["[A]", "[B]"], files: ["[affected]"], codebase: "[project]"
-})
-```
-
-### CODE_CHANGE — After writing significant code (>20 lines or new pattern)
-```
-codebase({
-  action: "remember_pattern",
-  name: "[pattern]", description: "[how/when to use]",
-  files: ["[files]"], codebase: "[project]"
-})
-```
-
-### SESSION_END — Before stopping or compaction
-```
-smart_ingest({
-  items: [
-    { content: "SESSION: [work done]\nFixes: [list]\nDecisions: [list]", tags: ["session-end", "[project]"] },
-    // ... any unsaved fixes, decisions, patterns
-  ]
-})
-```
+| Gate | Trigger | Action |
+|------|---------|--------|
+| **BUG_FIX** | After any error is resolved | `smart_ingest({ content: "BUG FIX: [error]\nRoot cause: [why]\nSolution: [fix]\nFiles: [paths]", tags: ["bug-fix", "project"], node_type: "fact" })` |
+| **DECISION** | After any architectural/design choice | `codebase({ action: "remember_decision", decision, rationale, alternatives, files, codebase })` |
+| **CODE_CHANGE** | After >20 lines or new pattern | `codebase({ action: "remember_pattern", name, description, files, codebase })` |
+| **SESSION_END** | Before stopping or compaction | `smart_ingest({ items: [{ content: "SESSION: [summary]", tags: ["session-end"] }] })` |
 
 ---
 
@@ -142,60 +259,82 @@ smart_ingest({
 | "Remember this" / "Don't forget" | `smart_ingest` immediately |
 | "I always..." / "I never..." / "I prefer..." | Save as preference |
 | "This is important" | `smart_ingest` + `memory(action="promote")` |
-| "Remind me..." / "Next time..." | `intention` → set |
+| "Remind me..." / "Next time..." | `intention({ action: "set" })` |
 
 ---
 
-## Under the Hood — Cognitive Pipelines
+## Cognitive Architecture
 
 ### Search Pipeline (7 stages)
-1. **Overfetch** — Pull 3x results from hybrid search (BM25 + semantic)
-2. **Reranker** — Re-score by relevance quality (cross-encoder)
-3. **Temporal boost** — Recent memories get recency bonus
-4. **Accessibility filter** — FSRS-6 retention threshold (Ebbinghaus curve)
-5. **Context match** — Tulving 1973 encoding specificity (match current context to encoding context)
+1. **Overfetch** — 3x results from hybrid search (0.3 BM25 + 0.7 semantic, nomic-embed-text-v1.5 768D)
+2. **Rerank** — Cross-encoder rescoring (Jina Reranker v1 Turbo, 38M params)
+3. **Temporal** — Recency + validity window boosting (85% relevance + 15% temporal)
+4. **Accessibility** — FSRS-6 retention filter (Active ≥0.7, Dormant ≥0.4, Silent ≥0.1)
+5. **Context** — Tulving 1973 encoding specificity (topic overlap → +30% boost)
 6. **Competition** — Anderson 1994 retrieval-induced forgetting (winners strengthen, competitors weaken)
-7. **Spreading activation** — Side effects: activate related memories, update predictive model, record reconsolidation opportunity
+7. **Activation** — Spreading activation side effects + predictive model + reconsolidation marking
 
-### Ingest Pipeline (cognitive pre/post)
-**Pre-ingest:** 4-channel importance scoring (novelty/arousal/reward/attention) + intent detection → auto-tag
-**Storage:** Prediction Error Gating decides create/update/reinforce/supersede
-**Post-ingest:** Synaptic tagging (Frey & Morris 1997) + novelty model update + hippocampal indexing + cross-project recording
+### Ingest Pipeline
+**Pre:** 4-channel importance scoring (novelty/arousal/reward/attention) + intent detection → auto-tag
+**Store:** Prediction Error Gating: similarity >0.92 → UPDATE, 0.75-0.92 → UPDATE/SUPERSEDE, <0.75 → CREATE
+**Post:** Synaptic tagging (Frey & Morris 1997, 9h backward + 2h forward) + hippocampal indexing + cross-project recording
 
-### Feedback Pipeline (via memory promote/demote)
-**Promote:** Reward signal + importance boost + reconsolidation (memory becomes modifiable for 24-48h) + activation spread
-**Demote:** Competition suppression + retrieval strength decrease (does NOT delete — alternatives surface instead)
+### FSRS-6 (State-of-the-Art Spaced Repetition)
+- Retrievability: `R = (1 + factor × t / S)^(-w20)` — 21 trained parameters
+- Dual-strength model (Bjork & Bjork 1992): storage strength (grows) + retrieval strength (decays)
+- Accessibility = retention×0.5 + retrieval×0.3 + storage×0.2
+- 20-30% more efficient than SM-2 (Anki)
+
+### 29 Cognitive Modules (stateful, persist across calls)
+
+**Neuroscience (16):**
+ActivationNetwork (Collins & Loftus 1975), SynapticTaggingSystem (Frey & Morris 1997), HippocampalIndex (Teyler & Rudy 2007), ContextMatcher (Tulving 1973), AccessibilityCalculator, CompetitionManager (Anderson 1994), StateUpdateService, ImportanceSignals, NoveltySignal, ArousalSignal, RewardSignal, AttentionSignal, EmotionalMemory (Brown & Kulik 1977), PredictiveMemory, ProspectiveMemory, IntentionParser
+
+**Advanced (11):**
+ImportanceTracker, ReconsolidationManager (Nader — 5min labile window), IntentDetector (9 intent types), ActivityTracker, MemoryDreamer (5-stage consolidation), MemoryChainBuilder (A*-like), MemoryCompressor (30-day min age), CrossProjectLearner (6 pattern types), AdaptiveEmbedder, SpeculativeRetriever (6 trigger types), ConsolidationScheduler
+
+**Search (2):** Reranker, TemporalSearcher
+
+### Memory States
+- **Active** (retention ≥ 0.7) — easily retrievable
+- **Dormant** (≥ 0.4) — retrievable with effort
+- **Silent** (≥ 0.1) — difficult, needs cues
+- **Unavailable** (< 0.1) — needs reinforcement
+
+### Connection Types
+semantic, temporal, causal, spatial, part_of, user_defined — each with strength (0-1), activation_count, timestamps
 
 ---
 
-## CognitiveEngine — 28 Modules
+## Advanced Techniques
 
-All modules persist across tool calls as stateful instances:
+### Cross-Project Intelligence
+The CrossProjectLearner tracks patterns across ALL projects (ErrorHandling, AsyncConcurrency, Testing, Architecture, Performance, Security). When you learn a pattern in one project that works, it becomes available in all projects. Use `codebase({ action: "get_context" })` without a codebase filter to get universal patterns.
 
-**Neuroscience (15):** ActivationNetwork, SynapticTaggingSystem, HippocampalIndex, ContextMatcher, AccessibilityCalculator, CompetitionManager, StateUpdateService, ImportanceSignals, NoveltySignal, ArousalSignal, RewardSignal, AttentionSignal, PredictiveMemory, ProspectiveMemory, IntentionParser
+### Reconsolidation Window
+After any memory is accessed (via search, get, or promote), it enters a 5-minute "labile" state where modifications are enhanced. This is the optimal time to edit memories with new context. The system handles this automatically.
 
-**Advanced (11):** ImportanceTracker, ReconsolidationManager, IntentDetector, ActivityTracker, MemoryDreamer, MemoryChainBuilder, MemoryCompressor, CrossProjectLearner, AdaptiveEmbedder, SpeculativeRetriever, ConsolidationScheduler
+### Synaptic Tagging (Retroactive Importance)
+Memories encoded in the last 9 hours can be retroactively promoted when something important happens. If you fix a critical bug, not only does the fix get saved — related memories from the past 9 hours also get importance boosts. The SynapticTaggingSystem handles this automatically.
 
-**Search (2):** Reranker, TemporalSearcher
+### Dream Insights
+Dreams don't just consolidate — they generate new insights by cross-referencing recent memories with older knowledge. The insights can reveal: contradictions between memories, previously unseen patterns, connections across different projects. Always check dream results for `insights_generated`.
+
+### Token Budget Strategy
+Use `token_budget` on search and session_context to control response size. For quick lookups: 500. For deep context: 3000-5000. Results that don't fit go to `expandable` — retrieve them with `memory({ action: "get", id: "..." })`.
+
+### Detail Levels
+- `brief` — id/type/tags/score only (1-2 tokens per result, good for scanning)
+- `summary` — 8 fields including content preview (default, balanced)
+- `full` — all FSRS state, timestamps, embedding info (for debugging/analysis)
 
 ---
 
 ## Memory Hygiene
 
-### Promote when:
-- User confirms memory was helpful → `memory(action="promote")`
-- Solution worked correctly
-- Information was accurate
-
-### Demote when:
-- User corrects a mistake → `memory(action="demote")`
-- Information was wrong
-- Memory led to bad outcome
-
-### Never save:
-- Secrets, API keys, passwords
-- Temporary debugging state
-- Obvious/trivial information
+**Promote** when user confirms helpful, solution worked, info was accurate.
+**Demote** when user corrects mistake, info was wrong, led to bad outcome.
+**Never save:** secrets, API keys, passwords, temporary debugging state, trivial info.
 
 ---
 
@@ -209,12 +348,15 @@ Memory is retrieval. Searching strengthens memory. Search liberally, save aggres
 
 ## Development
 
-- **Crate:** `vestige-mcp` v1.8.0, Rust 2024 edition, Rust 1.93.1
-- **Tests:** 651 tests (313 core + 338 mcp), zero warnings
-- **Build:** `cargo build --release -p vestige-mcp`
-- **Features:** `embeddings` + `vector-search` (default on)
-- **Architecture:** `McpServer` holds `Arc<Storage>` + `Arc<Mutex<CognitiveEngine>>`
-- **Storage:** Interior mutability — `Storage` uses `Mutex<Connection>` for reader/writer split, all methods take `&self`. WAL mode for concurrent reads + writes.
-- **Entry:** `src/main.rs` → stdio JSON-RPC server
-- **Tools:** `src/tools/` — one file per tool, each exports `schema()` + `execute()`
-- **Cognitive:** `src/cognitive.rs` — 28-field struct, initialized once at startup
+- **Crate:** `vestige-mcp` v2.0.4, Rust 2024 edition, MSRV 1.91
+- **Tests:** 758 (406 mcp + 352 core), zero warnings
+- **Build:** `cargo build --release -p vestige-mcp` (features: `embeddings` + `vector-search`)
+- **Build (no embeddings):** `cargo build --release -p vestige-mcp --no-default-features`
+- **Bench:** `cargo bench -p vestige-core`
+- **Architecture:** `McpServer` → `Arc<Storage>` + `Arc<Mutex<CognitiveEngine>>`
+- **Storage:** SQLite WAL mode, `Mutex<Connection>` reader/writer split, FTS5 full-text search
+- **Embeddings:** nomic-embed-text-v1.5 (768D, 8K context) via fastembed (local ONNX, no API)
+- **Vector index:** USearch HNSW (20x faster than FAISS)
+- **Binaries:** `vestige-mcp` (MCP server), `vestige` (CLI), `vestige-restore`
+- **Dashboard:** SvelteKit 2 + Svelte 5 + Three.js + Tailwind 4, embedded at `/dashboard`
+- **Env vars:** `VESTIGE_DASHBOARD_PORT` (default 3927), `VESTIGE_HTTP_PORT` (default 3928), `VESTIGE_HTTP_BIND` (default 127.0.0.1), `VESTIGE_AUTH_TOKEN` (auto-generated), `VESTIGE_CONSOLIDATION_INTERVAL_HOURS` (default 6), `RUST_LOG`

CONTRIBUTING.md

@@ -26,7 +26,7 @@ vestige/
 
 ### Prerequisites
 
-- **Rust** (1.85+ stable): [rustup.rs](https://rustup.rs)
+- **Rust** (1.91+ stable): [rustup.rs](https://rustup.rs)
 - **Node.js** (v22+): [nodejs.org](https://nodejs.org)
 - **pnpm** (v9+): `npm install -g pnpm`
 
@@ -56,7 +56,7 @@ VESTIGE_TEST_MOCK_EMBEDDINGS=1 cargo test --workspace
 ## Running Tests
 
 ```bash
-# All tests (734 total)
+# All tests (746+ total)
 VESTIGE_TEST_MOCK_EMBEDDINGS=1 cargo test --workspace
 
 # Core library tests only (352 tests)
@@ -137,7 +137,7 @@ The MCP server and dashboard. Key modules:
 |--------|---------|
 | `server.rs` | MCP JSON-RPC server (rmcp 0.14) |
 | `cognitive.rs` | CognitiveEngine — 29 stateful modules |
-| `tools/` | One file per MCP tool (21 tools) |
+| `tools/` | One file per MCP tool (24 tools) |
 | `dashboard/` | Axum HTTP + WebSocket + event bus |
 
 ### apps/dashboard

Cargo.toml

@@ -10,7 +10,7 @@ exclude = [
 ]
 
 [workspace.package]
-version = "1.9.2"
+version = "2.0.9"
 edition = "2024"
 license = "AGPL-3.0-only"
 repository = "https://github.com/samvallad33/vestige"

README.md

@@ -2,33 +2,82 @@
 
 # Vestige
 
-### The cognitive engine that gives AI a brain.
+### The cognitive engine that gives AI agents a brain.
 
 [![GitHub stars](https://img.shields.io/github/stars/samvallad33/vestige?style=social)](https://github.com/samvallad33/vestige)
 [![Release](https://img.shields.io/github/v/release/samvallad33/vestige)](https://github.com/samvallad33/vestige/releases/latest)
-[![Tests](https://img.shields.io/badge/tests-734%20passing-brightgreen)](https://github.com/samvallad33/vestige/actions)
+[![Tests](https://img.shields.io/badge/tests-1223%20passing-brightgreen)](https://github.com/samvallad33/vestige/actions)
 [![License](https://img.shields.io/badge/license-AGPL--3.0-blue)](LICENSE)
 [![MCP Compatible](https://img.shields.io/badge/MCP-compatible-green)](https://modelcontextprotocol.io)
 
-**Your AI forgets everything between sessions. Vestige fixes that.**
+**Your Agent forgets everything between sessions. Vestige fixes that.**
 
 Built on 130 years of memory research — FSRS-6 spaced repetition, prediction error gating, synaptic tagging, spreading activation, memory dreaming — all running in a single Rust binary with a 3D neural visualization dashboard. 100% local. Zero cloud.
 
-[Quick Start](#quick-start) | [Dashboard](#-3d-memory-dashboard) | [How It Works](#-the-cognitive-science-stack) | [Tools](#-21-mcp-tools) | [Docs](docs/)
+[Quick Start](#quick-start) | [Dashboard](#-3d-memory-dashboard) | [How It Works](#-the-cognitive-science-stack) | [Tools](#-24-mcp-tools) | [Docs](docs/)
 
 </div>
 
 ---
 
-## What's New in v2.0 "Cognitive Leap"
+## What's New in v2.0.9 "Autopilot"
 
-- **3D Memory Dashboard** — SvelteKit + Three.js neural visualization with real-time WebSocket events, bloom post-processing, force-directed graph layout. Watch your AI's mind in real-time.
-- **WebSocket Event Bus** — Every cognitive operation broadcasts events: memory creation, search, dreaming, consolidation, retention decay
-- **HyDE Query Expansion** — Template-based Hypothetical Document Embeddings for dramatically improved search quality on conceptual queries
-- **Nomic v2 MoE Ready** — fastembed 5.11 with optional Nomic Embed Text v2 MoE (475M params, 8 experts) + Metal GPU acceleration
-- **Command Palette** — `Cmd+K` navigation, keyboard shortcuts, responsive mobile layout, PWA installable
-- **FSRS Decay Visualization** — SVG retention curves with predicted decay at 1d/7d/30d, endangered memory alerts
-- **29 cognitive modules** — 734 tests, 77,840+ LOC
+Autopilot flips Vestige from passive memory library to **self-managing cognitive surface**. Same 24 MCP tools, zero schema changes — but the moment you upgrade, 14 previously dormant cognitive primitives start firing on live events without any tool call from your client.
+
+- **One supervised backend task subscribes to the 20-event WebSocket bus** and routes six event classes into the cognitive engine: `MemoryCreated` triggers synaptic-tagging PRP + predictive-access records, `SearchPerformed` warms the speculative-retrieval model, `MemoryPromoted` fires activation spread, `MemorySuppressed` emits the Rac1 cascade wave, high-importance `ImportanceScored` (>0.85) auto-promotes, and `Heartbeat` rate-limit-fires `find_duplicates` on large DBs. **The engine mutex is never held across `.await`, so MCP dispatch is never starved.**
+- **Panic-resilient supervisors.** Both background tasks run inside an outer supervisor loop — if one handler panics on a bad memory, the supervisor respawns it in 5 s instead of losing every future event.
+- **Fully backward compatible.** No new MCP tools. No schema migration. Existing v2.0.8 databases open without a single step. Opt out with `VESTIGE_AUTOPILOT_ENABLED=0` if you want the passive-library contract back.
+- **3,091 LOC of orphan v1.0 tool code removed** — nine superseded modules (`checkpoint`, `codebase`, `consolidate`, `ingest`, `intentions`, `knowledge`, `recall`, plus helpers) verified zero non-test callers before deletion. Tool surface unchanged.
+
+## What's New in v2.0.8 "Pulse"
+
+v2.0.8 wires the dashboard through to the cognitive engine. Eight new surfaces expose the reasoning stack visually — every one was MCP-only before.
+
+- **Reasoning Theater (`/reasoning`)** — `Cmd+K` Ask palette over the 8-stage `deep_reference` pipeline (hybrid retrieval → cross-encoder rerank → spreading activation → FSRS-6 trust → temporal supersession → contradiction analysis → relation assessment → template reasoning chain). Evidence cards, confidence meter, contradiction geodesic arcs, superseded-memory lineage, evolution timeline. **Zero LLM calls, 100% local.**
+- **Pulse InsightToast** — real-time toasts for `DreamCompleted`, `ConsolidationCompleted`, `ConnectionDiscovered`, promote/demote/suppress/unsuppress, `Rac1CascadeSwept`. Rate-limited, auto-dismiss, click-to-dismiss.
+- **Memory Birth Ritual (Terrarium)** — new memories materialize in the 3D graph on every `MemoryCreated`: elastic scale-in, quadratic Bezier flight path, glow sprite fade-in, Newton's Cradle docking recoil. 60-frame sequence, zero-alloc math.
+- **7 more dashboard surfaces** — `/duplicates`, `/dreams`, `/schedule`, `/importance`, `/activation`, `/contradictions`, `/patterns`. Left nav expanded 8 → 16 with single-key shortcuts.
+- **Intel Mac (`x86_64-apple-darwin`) support restored** via the `ort-dynamic` Cargo feature + Homebrew `onnxruntime`. Microsoft deprecated x86_64 macOS prebuilts; the dynamic-link path sidesteps that permanently. **Closes #41.**
+- **Contradiction-detection false positives eliminated** — four thresholds tightened so adjacent-domain memories no longer flag as conflicts. On an FSRS-6 query this collapses false contradictions 12 → 0 without regressing legitimate test cases.
+
+## What's New in v2.0.7 "Visible"
+
+Hygiene release closing two UI gaps and finishing schema cleanup. No breaking changes, no user-data migrations.
+
+- **`POST /api/memories/{id}/suppress` + `/unsuppress` HTTP endpoints** — dashboard can trigger Anderson 2025 SIF + Rac1 cascade without dropping to raw MCP. `suppressionCount`, `retrievalPenalty`, `reversibleUntil`, `labileWindowHours` all in response. Suppress button joins Promote / Demote / Delete on the Memories page.
+- **Uptime in the sidebar footer** — the `Heartbeat` event has carried `uptime_secs` since v2.0.5 but was never rendered. Now shows as `up 3d 4h` / `up 18m` / `up 47s`.
+- **`execute_export` panic fix** — unreachable match arm replaced with a clean "unsupported export format" error instead of unwinding through the MCP dispatcher.
+- **`predict` surfaces `predict_degraded: true`** on lock poisoning instead of silently returning empty vecs. `memory_changelog` honors `start` / `end` bounds. `intention` check honors `include_snoozed`.
+- **Migration V11** — drops dead `knowledge_edges` + `compressed_memories` tables (added speculatively in V4, never used).
+
+## What's New in v2.0.6 "Composer"
+
+v2.0.6 is a polish release that makes the existing cognitive stack finally *feel* alive in the dashboard and stays out of your way on the prompt side.
+
+- **Six live graph reactions, not one** — `MemorySuppressed`, `MemoryUnsuppressed`, `Rac1CascadeSwept`, `Connected`, `ConsolidationStarted`, and `ImportanceScored` now light the 3D graph in real time. v2.0.5 shipped `suppress` but the graph was silent when you called it; consolidation and importance scoring have been silent since v2.0.0. No longer.
+- **Intentions page actually works** — fixes a long-standing bug where every intention rendered as "normal priority" (type/schema drift between backend and frontend) and context/time triggers surfaced as raw JSON.
+- **Opt-in composition mandate** — the new MCP `instructions` string stays minimal by default. Opt in to the full Composing / Never-composed / Recommendation composition protocol with `VESTIGE_SYSTEM_PROMPT_MODE=full` when you want it, and nothing is imposed on your sessions when you don't.
+
+## What's New in v2.0.5 "Intentional Amnesia"
+
+**The first shipped AI memory system with top-down inhibitory control over retrieval.** Other systems implement passive decay — memories fade if you don't touch them. Vestige v2.0.5 also implements *active* suppression: the new **`suppress`** tool compounds a retrieval penalty on every call (up to 80%), a background Rac1 worker fades co-activated neighbors over 72 hours, and the whole thing is reversible within a 24-hour labile window. **Never deletes.** The memory is inhibited, not erased.
+
+Ebbinghaus 1885 models what happens to memories you don't touch. Anderson 2025 models what happens when you actively want to stop thinking about one. Every other AI memory system implements the first. Vestige is the first to ship the second.
+
+Based on [Anderson et al. 2025](https://www.nature.com/articles/s41583-025-00929-y) (Suppression-Induced Forgetting, *Nat Rev Neurosci*) and [Cervantes-Sandoval et al. 2020](https://pmc.ncbi.nlm.nih.gov/articles/PMC7477079/) (Rac1 synaptic cascade). **24 tools · 30 cognitive modules · 1,223 tests.**
+
+<details>
+<summary>Earlier releases (v2.0 "Cognitive Leap" → v2.0.4 "Deep Reference")</summary>
+
+- **v2.0.4 — `deep_reference` Tool** — 8-stage cognitive reasoning pipeline with FSRS-6 trust scoring, intent classification, spreading activation, contradiction analysis, and pre-built reasoning chains. Token budgets raised 10K → 100K. CORS tightened.
+- **v2.0 — 3D Memory Dashboard** — SvelteKit + Three.js neural visualization with real-time WebSocket events, bloom post-processing, force-directed graph layout.
+- **v2.0 — WebSocket Event Bus** — Every cognitive operation broadcasts events: memory creation, search, dreaming, consolidation, retention decay.
+- **v2.0 — HyDE Query Expansion** — Template-based Hypothetical Document Embeddings for dramatically improved search quality on conceptual queries.
+- **v2.0 — Nomic v2 MoE (experimental)** — fastembed 5.11 with optional Nomic Embed Text v2 MoE (475M params, 8 experts) + Metal GPU acceleration.
+- **v2.0 — Command Palette** — `Cmd+K` navigation, keyboard shortcuts, responsive mobile layout, PWA installable.
+- **v2.0 — FSRS Decay Visualization** — SVG retention curves with predicted decay at 1d/7d/30d.
+
+</details>
 
 ---
 
@@ -42,6 +91,9 @@ sudo mv vestige-mcp vestige vestige-restore /usr/local/bin/
 # 2. Connect to Claude Code
 claude mcp add vestige vestige-mcp -s user
 
+# Or connect to Codex
+codex mcp add vestige -- /usr/local/bin/vestige-mcp
+
 # 3. Test it
 # "Remember that I prefer TypeScript over JavaScript"
 # ...new session...
@@ -52,26 +104,38 @@ claude mcp add vestige vestige-mcp -s user
 <details>
 <summary>Other platforms & install methods</summary>
 
-**macOS (Intel):**
-```bash
-curl -L https://github.com/samvallad33/vestige/releases/latest/download/vestige-mcp-x86_64-apple-darwin.tar.gz | tar -xz
-sudo mv vestige-mcp vestige vestige-restore /usr/local/bin/
-```
-
 **Linux (x86_64):**
 ```bash
 curl -L https://github.com/samvallad33/vestige/releases/latest/download/vestige-mcp-x86_64-unknown-linux-gnu.tar.gz | tar -xz
 sudo mv vestige-mcp vestige vestige-restore /usr/local/bin/
 ```
 
-**Windows:** Download from [Releases](https://github.com/samvallad33/vestige/releases/latest)
+**macOS (Intel):** Microsoft is discontinuing x86_64 macOS prebuilts after ONNX Runtime v1.23.0, so Vestige's Intel Mac build links dynamically against a Homebrew-installed ONNX Runtime via the `ort-dynamic` feature. Install with:
+
+```bash
+brew install onnxruntime
+curl -L https://github.com/samvallad33/vestige/releases/latest/download/vestige-mcp-x86_64-apple-darwin.tar.gz | tar -xz
+sudo mv vestige-mcp vestige vestige-restore /usr/local/bin/
+echo 'export ORT_DYLIB_PATH="'"$(brew --prefix onnxruntime)"'/lib/libonnxruntime.dylib"' >> ~/.zshrc
+source ~/.zshrc
+claude mcp add vestige vestige-mcp -s user
+```
+
+Full Intel Mac guide (build-from-source + troubleshooting): [`docs/INSTALL-INTEL-MAC.md`](docs/INSTALL-INTEL-MAC.md).
+
+**Windows:** Prebuilt binaries ship but `usearch 2.24.0` hit an MSVC compile break ([usearch#746](https://github.com/unum-cloud/usearch/issues/746)); we've pinned `=2.23.0` until upstream fixes it. Source builds work with:
+
+```bash
+git clone https://github.com/samvallad33/vestige && cd vestige
+cargo build --release -p vestige-mcp
+```
 
 **npm:**
 ```bash
-npm install -g vestige-mcp
+npm install -g vestige-mcp-server
 ```
 
-**Build from source:**
+**Build from source (requires Rust 1.91+):**
 ```bash
 git clone https://github.com/samvallad33/vestige && cd vestige
 cargo build --release -p vestige-mcp
@@ -89,6 +153,7 @@ Vestige speaks MCP — the universal protocol for AI tools. One brain, every IDE
 | IDE | Setup |
 |-----|-------|
 | **Claude Code** | `claude mcp add vestige vestige-mcp -s user` |
+| **Codex** | [Integration guide](docs/integrations/codex.md) |
 | **Claude Desktop** | [2-min setup](docs/CONFIGURATION.md#claude-desktop-macos) |
 | **Xcode 26.3** | [Integration guide](docs/integrations/xcode.md) |
 | **Cursor** | [Integration guide](docs/integrations/cursor.md) |
@@ -128,7 +193,7 @@ The dashboard runs automatically at `http://localhost:3927/dashboard` when the M
 │  15 REST endpoints · WS event broadcast              │
 ├─────────────────────────────────────────────────────┤
 │  MCP Server (stdio JSON-RPC)                         │
-│  21 tools · 29 cognitive modules                     │
+│  24 tools · 30 cognitive modules                     │
 ├─────────────────────────────────────────────────────┤
 │  Cognitive Engine                                    │
 │  ┌──────────┐ ┌──────────┐ ┌───────────────┐       │
@@ -157,6 +222,7 @@ RAG is a dumb bucket. Vestige is an active organ.
 | **Storage** | Store everything | **Prediction Error Gating** — only stores what's surprising or new |
 | **Retrieval** | Nearest-neighbor | **7-stage pipeline** — HyDE expansion + reranking + spreading activation |
 | **Decay** | Nothing expires | **FSRS-6** — memories fade naturally, context stays lean |
+| **Forgetting** *(v2.0.5)* | Delete only | **`suppress` tool** — compounding top-down inhibition, neighbor cascade, reversible 24h |
 | **Duplicates** | Manual dedup | **Self-healing** — auto-merges "likes dark mode" + "prefers dark themes" |
 | **Importance** | All equal | **4-channel scoring** — novelty, arousal, reward, attention |
 | **Sleep** | No consolidation | **Memory dreaming** — replays, connects, synthesizes insights |
@@ -188,11 +254,13 @@ This isn't a key-value store with an embedding model bolted on. Vestige implemen
 
 **Autonomic Regulation** — Self-regulating memory health. Auto-promotes frequently accessed memories. Auto-GCs low-retention memories. Consolidation triggers on 6h staleness or 2h active use.
 
+**Active Forgetting** *(v2.0.5)* — Top-down inhibitory control via the `suppress` tool. Other memory systems implement passive decay — the Ebbinghaus 1885 "use it or lose it" curve, sometimes with trust-weighted strength factors. Vestige v2.0.5 also implements *active* top-down suppression: each `suppress` call compounds (Suppression-Induced Forgetting, Anderson 2025), a background Rac1 cascade worker fades co-activated neighbors across the connection graph (Cervantes-Sandoval & Davis 2020), and a 24-hour labile window allows reversal (Nader reconsolidation semantics on a pragmatic axis). The memory persists — it's **inhibited, not erased**. Explicitly distinct from Anderson 1994 retrieval-induced forgetting (bottom-up, passive competition during retrieval), which is a separate, older primitive that several other memory systems implement. Based on [Anderson et al., 2025](https://www.nature.com/articles/s41583-025-00929-y) and [Cervantes-Sandoval et al., 2020](https://pmc.ncbi.nlm.nih.gov/articles/PMC7477079/). First shipped AI memory system with this primitive.
+
 [Full science documentation ->](docs/SCIENCE.md)
 
 ---
 
-## 🛠 21 MCP Tools
+## 🛠 24 MCP Tools
 
 ### Context Packets
 | Tool | What It Does |
@@ -237,6 +305,17 @@ This isn't a key-value store with an embedding model bolted on. Vestige implemen
 | `backup` / `export` / `gc` | Database backup, JSON export, garbage collection |
 | `restore` | Restore from JSON backup |
 
+### Deep Reference (v2.0.4)
+| Tool | What It Does |
+|------|-------------|
+| `deep_reference` | **Cognitive reasoning across memories.** 8-stage pipeline: FSRS-6 trust scoring, intent classification, spreading activation, temporal supersession, contradiction analysis, relation assessment, dream insight integration, and algorithmic reasoning chain generation. Returns trust-scored evidence with a pre-built reasoning scaffold. |
+| `cross_reference` | Backward-compatible alias for `deep_reference`. |
+
+### Active Forgetting (v2.0.5)
+| Tool | What It Does |
+|------|-------------|
+| `suppress` | **Top-down active forgetting** — neuroscience-grounded inhibitory control over retrieval. Distinct from `memory.delete` (destroys the row) and `memory.demote` (one-shot ranking hit). Each call **compounds** a retrieval-score penalty (Anderson 2025 SIF), and a background Rac1 cascade worker fades co-activated neighbors over 72h (Davis 2020). Reversible within a 24-hour labile window via `reverse: true`. **The memory persists** — it is inhibited, not erased. |
+
 ---
 
 ## Make Your AI Use Vestige Automatically
@@ -267,8 +346,8 @@ At the start of every session:
 
 | Metric | Value |
 |--------|-------|
-| **Language** | Rust 2024 edition |
-| **Codebase** | 77,840+ lines, 734 tests |
+| **Language** | Rust 2024 edition (MSRV 1.91) |
+| **Codebase** | 80,000+ lines, 1,292 tests (366 core + 425 mcp + 497 e2e + 4 doctests) |
 | **Binary size** | ~20MB |
 | **Embeddings** | Nomic Embed Text v1.5 (768d → 256d Matryoshka, 8192 context) |
 | **Vector search** | USearch HNSW (20x faster than FAISS) |
@@ -276,9 +355,9 @@ At the start of every session:
 | **Storage** | SQLite + FTS5 (optional SQLCipher encryption) |
 | **Dashboard** | SvelteKit 2 + Svelte 5 + Three.js + Tailwind CSS 4 |
 | **Transport** | MCP stdio (JSON-RPC 2.0) + WebSocket |
-| **Cognitive modules** | 29 stateful (15 neuroscience, 12 advanced, 2 search) |
+| **Cognitive modules** | 30 stateful (17 neuroscience, 11 advanced, 2 search) |
 | **First run** | Downloads embedding model (~130MB), then fully offline |
-| **Platforms** | macOS (ARM/Intel), Linux (x86_64), Windows |
+| **Platforms** | macOS ARM + Intel + Linux x86_64 + Windows x86_64 (all prebuilt). Intel Mac needs `brew install onnxruntime` — see [install guide](docs/INSTALL-INTEL-MAC.md). |
 
 ### Optional Features
 
@@ -321,7 +400,7 @@ vestige dashboard                # Open 3D dashboard in browser
 | [Storage Modes](docs/STORAGE.md) | Global, per-project, multi-instance |
 | [CLAUDE.md Setup](docs/CLAUDE-SETUP.md) | Templates for proactive memory |
 | [Configuration](docs/CONFIGURATION.md) | CLI commands, environment variables |
-| [Integrations](docs/integrations/) | Xcode, Cursor, VS Code, JetBrains, Windsurf |
+| [Integrations](docs/integrations/) | Codex, Xcode, Cursor, VS Code, JetBrains, Windsurf |
 | [Changelog](CHANGELOG.md) | Version history |
 
 ---
@@ -376,5 +455,5 @@ AGPL-3.0 — free to use, modify, and self-host. If you offer Vestige as a netwo
 
 <p align="center">
   <i>Built by <a href="https://github.com/samvallad33">@samvallad33</a></i><br>
-  <sub>77,840+ lines of Rust · 29 cognitive modules · 130 years of memory research · one 22MB binary</sub>
+  <sub>80,000+ lines of Rust · 30 cognitive modules · 130 years of memory research · one 22MB binary</sub>
 </p>

SECURITY.md

@@ -4,8 +4,8 @@
 
 | Version | Supported          |
 | ------- | ------------------ |
-| 1.1.x   | :white_check_mark: |
-| 1.0.x   | :x:                |
+| 2.0.x   | :white_check_mark: |
+| 1.x     | :x:                |
 
 ## Reporting a Vulnerability
 

apps/dashboard/build/_app/immutable/assets/13.Bjd0S47S.css

@@ -0,0 +1 @@
+.audit-trail.svelte-kf1sc6 ol>li{animation:svelte-kf1sc6-event-rise .4s cubic-bezier(.22,.8,.3,1) backwards}@keyframes svelte-kf1sc6-event-rise{0%{opacity:0;transform:translate(6px)}to{opacity:1;transform:translate(0)}}.audit-trail .marker{transition:transform .2s ease}.audit-trail li:hover .marker{transform:scale(1.15)}

apps/dashboard/build/_app/immutable/assets/15.ChjqzJHo.css

@@ -0,0 +1 @@
+.stage.svelte-9hm057{animation:svelte-9hm057-stage-light .7s cubic-bezier(.22,.8,.3,1) backwards;position:relative;border-color:#6366f114}.stage-orb.svelte-9hm057{width:28px;height:28px;border-radius:50%;background:radial-gradient(circle at 30% 30%,#818cf840,#6366f10d);border:1px solid rgba(99,102,241,.3);display:flex;align-items:center;justify-content:center;position:relative;animation:svelte-9hm057-orb-glow .7s cubic-bezier(.22,.8,.3,1) backwards}.stage-pulse.svelte-9hm057{position:absolute;top:0;right:0;bottom:0;left:0;border-radius:12px;border:1px solid rgba(129,140,248,0);pointer-events:none;animation:svelte-9hm057-pulse-ring .7s cubic-bezier(.22,.8,.3,1) backwards}.connector.svelte-9hm057{position:absolute;left:22px;top:100%;width:1px;height:8px;background:linear-gradient(180deg,#818cf880,#a855f726);animation:svelte-9hm057-connector-draw .5s ease-out backwards}.running.svelte-9hm057 .stage:where(.svelte-9hm057){animation:svelte-9hm057-stage-light .7s cubic-bezier(.22,.8,.3,1) backwards,svelte-9hm057-stage-flicker 2.4s ease-in-out infinite}@keyframes svelte-9hm057-stage-light{0%{opacity:0;transform:translate(-8px);border-color:#6366f100}60%{opacity:1;border-color:#818cf859}to{opacity:1;transform:translate(0);border-color:#6366f114}}@keyframes svelte-9hm057-orb-glow{0%{transform:scale(.6);opacity:0;box-shadow:0 0 #818cf800}60%{transform:scale(1.15);opacity:1;box-shadow:0 0 24px #818cf8cc}to{transform:scale(1);box-shadow:0 0 10px #818cf859}}@keyframes svelte-9hm057-pulse-ring{0%{transform:scale(.96);opacity:0;border-color:#818cf800}70%{transform:scale(1);opacity:1;border-color:#818cf866;box-shadow:0 0 20px #818cf840}to{transform:scale(1.01);opacity:0;border-color:#818cf800;box-shadow:0 0 #818cf800}}@keyframes svelte-9hm057-connector-draw{0%{transform:scaleY(0);transform-origin:top;opacity:0}to{transform:scaleY(1);transform-origin:top;opacity:1}}@keyframes svelte-9hm057-stage-flicker{0%,to{border-color:#6366f114}50%{border-color:#818cf840}}.evidence-card.svelte-ksja6x{animation:svelte-ksja6x-card-rise .6s cubic-bezier(.22,.8,.3,1) backwards}.evidence-card.primary.svelte-ksja6x{border-color:#6366f159!important;box-shadow:inset 0 1px #ffffff0a,0 0 32px #6366f12e,0 8px 32px #0006}.evidence-card.contradicting.svelte-ksja6x{border-color:#ef444473!important;box-shadow:inset 0 1px #ffffff08,0 0 28px #ef444433,0 8px 32px #0006}.evidence-card.superseded.svelte-ksja6x{opacity:.55}.evidence-card.superseded.svelte-ksja6x:hover{opacity:.9}.role-pill.svelte-ksja6x{background:#6366f11f;color:#c7cbff;border:1px solid rgba(99,102,241,.25)}.evidence-card.contradicting.svelte-ksja6x .role-pill:where(.svelte-ksja6x){background:#ef444424;color:#fecaca;border-color:#ef444466}.evidence-card.primary.svelte-ksja6x .role-pill:where(.svelte-ksja6x){background:#6366f138;color:#a5b4ff;border-color:#6366f180}.trust-fill.svelte-ksja6x{animation:svelte-ksja6x-trust-sweep 1s cubic-bezier(.22,.8,.3,1) backwards}@keyframes svelte-ksja6x-card-rise{0%{opacity:0;transform:translateY(12px) scale(.98)}to{opacity:1;transform:translateY(0) scale(1)}}@keyframes svelte-ksja6x-trust-sweep{0%{width:0%!important;opacity:.4}to{opacity:1}}.line-clamp-4.svelte-ksja6x{display:-webkit-box;-webkit-line-clamp:4;line-clamp:4;-webkit-box-orient:vertical;overflow:hidden}.conf-number.svelte-q2v96u{animation:svelte-q2v96u-conf-pop .9s cubic-bezier(.22,.8,.3,1) backwards}@keyframes svelte-q2v96u-conf-pop{0%{opacity:0;transform:scale(.5)}60%{opacity:1;transform:scale(1.1)}to{opacity:1;transform:scale(1)}}.arc-path.svelte-q2v96u{animation:svelte-q2v96u-arc-draw .9s cubic-bezier(.22,.8,.3,1) backwards;stroke-dashoffset:0}@keyframes svelte-q2v96u-arc-draw{0%{opacity:0;stroke-dasharray:0 400}to{opacity:1;stroke-dasharray:4 4}}.arc-dot.svelte-q2v96u{animation:svelte-q2v96u-arc-dot-pulse 1.4s ease-in-out infinite}@keyframes svelte-q2v96u-arc-dot-pulse{0%,to{opacity:.8;r:4}50%{opacity:1;r:5}}.evidence-grid.svelte-q2v96u{isolation:isolate}.contradiction-arcs.svelte-q2v96u{z-index:5}

apps/dashboard/build/_app/immutable/assets/16.BnHgRQtR.css

@@ -0,0 +1 @@
+@keyframes svelte-rs1z7a-panel-in{0%{opacity:0;transform:translateY(-4px)}to{opacity:1;transform:translateY(0)}}.animate-panel-in.svelte-rs1z7a{animation:svelte-rs1z7a-panel-in .18s ease-out}

apps/dashboard/build/_app/immutable/assets/5.DQ_AfUnN.css

@@ -0,0 +1 @@
+@keyframes svelte-1jku20k-arc-drift{0%{stroke-dashoffset:0}to{stroke-dashoffset:-32}}.arc-particle{animation-name:svelte-1jku20k-arc-drift;animation-timing-function:linear;animation-iteration-count:infinite}

apps/dashboard/build/_app/immutable/assets/7.CCrNEDd3.css

@@ -0,0 +1 @@
+@keyframes svelte-1uyjqky-fadeSlide{0%{opacity:0;transform:translateY(8px)}to{opacity:1;transform:translateY(0)}}

apps/dashboard/build/_app/immutable/assets/9.BBx09UGv.css

@@ -0,0 +1 @@
+@keyframes svelte-1n9p0vm-fade-in{0%{opacity:0;transform:translateY(4px)}to{opacity:1;transform:translateY(0)}}.animate-fade-in.svelte-1n9p0vm{animation:svelte-1n9p0vm-fade-in .3s ease-out}

apps/dashboard/build/_app/immutable/chunks/BHs8FnOA.js

@@ -1 +0,0 @@
-import{b as T,N as o,W as b,E as h,X as p,Y as A,Z as E,_ as R,$ as g,a0 as l}from"./DleE0ac1.js";import{B as v}from"./BolYP48w.js";function S(t,_,u=!1){o&&b();var n=new v(t),c=u?h:0;function i(a,r){if(o){const e=p(t);var s;if(e===A?s=0:e===E?s=!1:s=parseInt(e.substring(1)),a!==s){var f=R();g(f),n.anchor=f,l(!1),n.ensure(a,r),l(!0);return}}n.ensure(a,r)}T(()=>{var a=!1;_((r,s=0)=>{a=!0,i(s,r)}),a||i(!1,null)},c)}export{S as i};

apps/dashboard/build/_app/immutable/chunks/BK028jHP.js

@@ -1 +0,0 @@
-import{t as l}from"./BsRos8Kb.js";import{N as e}from"./DleE0ac1.js";function u(s,c,r,f,p,i){var a=s.__className;if(e||a!==r||a===void 0){var t=l(r);(!e||t!==s.getAttribute("class"))&&(t==null?s.removeAttribute("class"):s.className=t),s.__className=r}return i}export{u as s};

apps/dashboard/build/_app/immutable/chunks/BK028jHP.js.br

@@ -1,2 +0,0 @@
-
`Δφg<CF86>%ΡmΊΝ	
-ΕΊ7hέι8ΚέΎ¶ τ<EFBFBD>Φ‚ZΧ(ΑΫ<>τd!><3E>cF5΅‚ξ+κ”καoωΥγ¤ΞΡ™Ήφ,ήQ/R¨ΗKΡ<,[ιt<CEB9>E…χέe8oα*Ό„ΫΒS0<1E>CΏ·+wωϋM5ΰ€Ξυ<CE9E>²gΑΑ½yEWγ l|pF<70>ύxέσlΫ Q­Βν¶@+0Φ=!^HΕνί}ϋ_Ύ2΄»zo{ω

apps/dashboard/build/_app/immutable/chunks/BKuqSeVd.js

@@ -0,0 +1,2 @@
+const e=[...` 	
+\r\f \v\uFEFF`];function o(t,f,u){var n=t==null?"":""+t;if(f&&(n=n?n+" "+f:f),u){for(var s of Object.keys(u))if(u[s])n=n?n+" "+s:s;else if(n.length)for(var i=s.length,l=0;(l=n.indexOf(s,l))>=0;){var r=l+i;(l===0||e.includes(n[l-1]))&&(r===n.length||e.includes(n[r]))?n=(l===0?"":n.substring(0,l))+n.substring(r+1):l=r}}return n===""?null:n}function c(t,f){return t==null?null:String(t)}export{c as a,o as t};

apps/dashboard/build/_app/immutable/chunks/B_YDQCB6.js

@@ -0,0 +1 @@
+import{J as T,K as m,P as D,g as P,c as b,h as B,L as M,M as N,N as U,O as Y,A as h,Q as x,R as $,T as q,U as w,V as z,W as C,S as G,X as J}from"./CvjSAYrz.js";import{c as K}from"./D81f-o_I.js";function W(r,a,t,s){var O;var f=!x||(t&$)!==0,v=(t&Y)!==0,o=(t&C)!==0,n=s,c=!0,g=()=>(c&&(c=!1,n=o?h(s):s),n),u;if(v){var A=G in r||J in r;u=((O=T(r,a))==null?void 0:O.set)??(A&&a in r?e=>r[a]=e:void 0)}var _,I=!1;v?[_,I]=K(()=>r[a]):_=r[a],_===void 0&&s!==void 0&&(_=g(),u&&(f&&m(),u(_)));var i;if(f?i=()=>{var e=r[a];return e===void 0?g():(c=!0,e)}:i=()=>{var e=r[a];return e!==void 0&&(n=void 0),e===void 0?n:e},f&&(t&D)===0)return i;if(u){var E=r.$$legacy;return(function(e,S){return arguments.length>0?((!f||!S||E||I)&&u(S?i():e),e):i()})}var l=!1,d=((t&q)!==0?w:z)(()=>(l=!1,i()));v&&P(d);var L=N;return(function(e,S){if(arguments.length>0){const R=S?P(d):f&&v?b(e):e;return B(d,R),l=!0,n!==void 0&&(n=R),e}return M&&l||(L.f&U)!==0?d.v:P(d)})}export{W as p};

apps/dashboard/build/_app/immutable/chunks/BcuCGYSa.js

@@ -1 +0,0 @@
-const n="/api";async function t(e,o){const i=await fetch(`${n}${e}`,{headers:{"Content-Type":"application/json"},...o});if(!i.ok)throw new Error(`API ${i.status}: ${i.statusText}`);return i.json()}const s={memories:{list:e=>{const o=e?"?"+new URLSearchParams(e).toString():"";return t(`/memories${o}`)},get:e=>t(`/memories/${e}`),delete:e=>t(`/memories/${e}`,{method:"DELETE"}),promote:e=>t(`/memories/${e}/promote`,{method:"POST"}),demote:e=>t(`/memories/${e}/demote`,{method:"POST"})},search:(e,o=20)=>t(`/search?q=${encodeURIComponent(e)}&limit=${o}`),stats:()=>t("/stats"),health:()=>t("/health"),timeline:(e=7,o=200)=>t(`/timeline?days=${e}&limit=${o}`),graph:e=>{const o=e?"?"+new URLSearchParams(Object.entries(e).filter(([,i])=>i!==void 0).map(([i,r])=>[i,String(r)])).toString():"";return t(`/graph${o}`)},dream:()=>t("/dream",{method:"POST"}),explore:(e,o="associations",i,r=10)=>t("/explore",{method:"POST",body:JSON.stringify({from_id:e,action:o,to_id:i,limit:r})}),predict:()=>t("/predict",{method:"POST"}),importance:e=>t("/importance",{method:"POST",body:JSON.stringify({content:e})}),consolidate:()=>t("/consolidate",{method:"POST"}),retentionDistribution:()=>t("/retention-distribution"),intentions:(e="active")=>t(`/intentions?status=${e}`)};export{s as a};

apps/dashboard/build/_app/immutable/chunks/Bhad70Ss.js

@@ -1 +1 @@
-import{a as y}from"./BsRos8Kb.js";import{N as r}from"./DleE0ac1.js";function a(t,e,f,i){var l=t.__style;if(r||l!==e){var s=y(e);(!r||s!==t.getAttribute("style"))&&(s==null?t.removeAttribute("style"):t.style.cssText=s),t.__style=e}return i}export{a as s};
+import{a as y}from"./BKuqSeVd.js";import{m as r}from"./CvjSAYrz.js";function a(t,e,f,i){var l=t.__style;if(r||l!==e){var s=y(e);(!r||s!==t.getAttribute("style"))&&(s==null?t.removeAttribute("style"):t.style.cssText=s),t.__style=e}return i}export{a as s};

apps/dashboard/build/_app/immutable/chunks/BolYP48w.js

@@ -1 +0,0 @@
-var D=Object.defineProperty;var g=a=>{throw TypeError(a)};var F=(a,e,s)=>e in a?D(a,e,{enumerable:!0,configurable:!0,writable:!0,value:s}):a[e]=s;var w=(a,e,s)=>F(a,typeof e!="symbol"?e+"":e,s),y=(a,e,s)=>e.has(a)||g("Cannot "+s);var t=(a,e,s)=>(y(a,e,"read from private field"),s?s.call(a):e.get(a)),l=(a,e,s)=>e.has(a)?g("Cannot add the same private member more than once"):e instanceof WeakSet?e.add(a):e.set(a,s),M=(a,e,s,i)=>(y(a,e,"write to private field"),i?i.call(a,s):e.set(a,s),s);import{U as x,a1 as C,a2 as k,a3 as N,a4 as A,a5 as B,N as S,a6 as U,a7 as j,a8 as q}from"./DleE0ac1.js";var r,n,h,u,p,_,v;class G{constructor(e,s=!0){w(this,"anchor");l(this,r,new Map);l(this,n,new Map);l(this,h,new Map);l(this,u,new Set);l(this,p,!0);l(this,_,()=>{var e=x;if(t(this,r).has(e)){var s=t(this,r).get(e),i=t(this,n).get(s);if(i)C(i),t(this,u).delete(s);else{var c=t(this,h).get(s);c&&(t(this,n).set(s,c.effect),t(this,h).delete(s),c.fragment.lastChild.remove(),this.anchor.before(c.fragment),i=c.effect)}for(const[f,o]of t(this,r)){if(t(this,r).delete(f),f===e)break;const d=t(this,h).get(o);d&&(k(d.effect),t(this,h).delete(o))}for(const[f,o]of t(this,n)){if(f===s||t(this,u).has(f))continue;const d=()=>{if(Array.from(t(this,r).values()).includes(f)){var b=document.createDocumentFragment();j(o,b),b.append(A()),t(this,h).set(f,{effect:o,fragment:b})}else k(o);t(this,u).delete(f),t(this,n).delete(f)};t(this,p)||!i?(t(this,u).add(f),N(o,d,!1)):d()}}});l(this,v,e=>{t(this,r).delete(e);const s=Array.from(t(this,r).values());for(const[i,c]of t(this,h))s.includes(i)||(k(c.effect),t(this,h).delete(i))});this.anchor=e,M(this,p,s)}ensure(e,s){var i=x,c=q();if(s&&!t(this,n).has(e)&&!t(this,h).has(e))if(c){var f=document.createDocumentFragment(),o=A();f.append(o),t(this,h).set(e,{effect:B(()=>s(o)),fragment:f})}else t(this,n).set(e,B(()=>s(this.anchor)));if(t(this,r).set(i,e),c){for(const[d,m]of t(this,n))d===e?i.unskip_effect(m):i.skip_effect(m);for(const[d,m]of t(this,h))d===e?i.unskip_effect(m.effect):i.skip_effect(m.effect);i.oncommit(t(this,_)),i.ondiscard(t(this,v))}else S&&(this.anchor=U),t(this,_).call(this)}}r=new WeakMap,n=new WeakMap,h=new WeakMap,u=new WeakMap,p=new WeakMap,_=new WeakMap,v=new WeakMap;export{G as B};

apps/dashboard/build/_app/immutable/chunks/BsRos8Kb.js

@@ -1 +0,0 @@
-import{a4 as O,b as fe,an as ne,N as D,$ as L,ao as ie,W as le,g as G,X as ue,Z as se,_ as J,a0 as q,a6 as F,ap as oe,aq as te,ar as P,U as ve,as as T,a5 as y,at as de,a8 as ce,z as pe,Q as _e,au as V,av as he,aw as ge,K as Ee,ax as j,ay as me,a1 as re,a3 as ae,az as B,F as Te,aA as Ae,aB as Ce,aC as we,a2 as Ne,aD as Se}from"./DleE0ac1.js";function De(e,r){return r}function Ie(e,r,l){for(var t=[],g=r.length,s,u=r.length,c=0;c<g;c++){let E=r[c];ae(E,()=>{if(s){if(s.pending.delete(E),s.done.add(E),s.pending.size===0){var o=e.outrogroups;U(V(s.done)),o.delete(s),o.size===0&&(e.outrogroups=null)}}else u-=1},!1)}if(u===0){var i=t.length===0&&l!==null;if(i){var v=l,a=v.parentNode;we(a),a.append(v),e.items.clear()}U(r,!i)}else s={pending:new Set(r),done:new Set},(e.outrogroups??(e.outrogroups=new Set)).add(s)}function U(e,r=!0){for(var l=0;l<e.length;l++)Ne(e[l],r)}var ee;function He(e,r,l,t,g,s=null){var u=e,c=new Map,i=(r&ne)!==0;if(i){var v=e;u=D?L(ie(v)):v.appendChild(O())}D&&le();var a=null,E=pe(()=>{var f=l();return _e(f)?f:f==null?[]:V(f)}),o,d=!0;function C(){n.fallback=a,xe(n,o,u,r,t),a!==null&&(o.length===0?(a.f&T)===0?re(a):(a.f^=T,M(a,null,u)):ae(a,()=>{a=null}))}var S=fe(()=>{o=G(E);var f=o.length;let I=!1;if(D){var x=ue(u)===se;x!==(f===0)&&(u=J(),L(u),q(!1),I=!0)}for(var _=new Set,w=ve,R=ce(),p=0;p<f;p+=1){D&&F.nodeType===oe&&F.data===te&&(u=F,I=!0,q(!1));var N=o[p],b=t(N,p),h=d?null:c.get(b);h?(h.v&&P(h.v,N),h.i&&P(h.i,p),R&&w.unskip_effect(h.e)):(h=Re(c,d?u:ee??(ee=O()),N,b,p,g,r,l),d||(h.e.f|=T),c.set(b,h)),_.add(b)}if(f===0&&s&&!a&&(d?a=y(()=>s(u)):(a=y(()=>s(ee??(ee=O()))),a.f|=T)),f>_.size&&de(),D&&f>0&&L(J()),!d)if(R){for(const[k,z]of c)_.has(k)||w.skip_effect(z.e);w.oncommit(C),w.ondiscard(()=>{})}else C();I&&q(!0),G(E)}),n={effect:S,items:c,outrogroups:null,fallback:a};d=!1,D&&(u=F)}function H(e){for(;e!==null&&(e.f&Ae)===0;)e=e.next;return e}function xe(e,r,l,t,g){var h,k,z,X,Y,K,Q,W,Z;var s=(t&Ce)!==0,u=r.length,c=e.items,i=H(e.effect.first),v,a=null,E,o=[],d=[],C,S,n,f;if(s)for(f=0;f<u;f+=1)C=r[f],S=g(C,f),n=c.get(S).e,(n.f&T)===0&&((k=(h=n.nodes)==null?void 0:h.a)==null||k.measure(),(E??(E=new Set)).add(n));for(f=0;f<u;f+=1){if(C=r[f],S=g(C,f),n=c.get(S).e,e.outrogroups!==null)for(const m of e.outrogroups)m.pending.delete(n),m.done.delete(n);if((n.f&T)!==0)if(n.f^=T,n===i)M(n,null,l);else{var I=a?a.next:i;n===e.effect.last&&(e.effect.last=n.prev),n.prev&&(n.prev.next=n.next),n.next&&(n.next.prev=n.prev),A(e,a,n),A(e,n,I),M(n,I,l),a=n,o=[],d=[],i=H(a.next);continue}if((n.f&B)!==0&&(re(n),s&&((X=(z=n.nodes)==null?void 0:z.a)==null||X.unfix(),(E??(E=new Set)).delete(n))),n!==i){if(v!==void 0&&v.has(n)){if(o.length<d.length){var x=d[0],_;a=x.prev;var w=o[0],R=o[o.length-1];for(_=0;_<o.length;_+=1)M(o[_],x,l);for(_=0;_<d.length;_+=1)v.delete(d[_]);A(e,w.prev,R.next),A(e,a,w),A(e,R,x),i=x,a=R,f-=1,o=[],d=[]}else v.delete(n),M(n,i,l),A(e,n.prev,n.next),A(e,n,a===null?e.effect.first:a.next),A(e,a,n),a=n;continue}for(o=[],d=[];i!==null&&i!==n;)(v??(v=new Set)).add(i),d.push(i),i=H(i.next);if(i===null)continue}(n.f&T)===0&&o.push(n),a=n,i=H(n.next)}if(e.outrogroups!==null){for(const m of e.outrogroups)m.pending.size===0&&(U(V(m.done)),(Y=e.outrogroups)==null||Y.delete(m));e.outrogroups.size===0&&(e.outrogroups=null)}if(i!==null||v!==void 0){var p=[];if(v!==void 0)for(n of v)(n.f&B)===0&&p.push(n);for(;i!==null;)(i.f&B)===0&&i!==e.fallback&&p.push(i),i=H(i.next);var N=p.length;if(N>0){var b=(t&ne)!==0&&u===0?l:null;if(s){for(f=0;f<N;f+=1)(Q=(K=p[f].nodes)==null?void 0:K.a)==null||Q.measure();for(f=0;f<N;f+=1)(Z=(W=p[f].nodes)==null?void 0:W.a)==null||Z.fix()}Ie(e,p,b)}}s&&Te(()=>{var m,$;if(E!==void 0)for(n of E)($=(m=n.nodes)==null?void 0:m.a)==null||$.apply()})}function Re(e,r,l,t,g,s,u,c){var i=(u&he)!==0?(u&ge)===0?Ee(l,!1,!1):j(l):null,v=(u&me)!==0?j(g):null;return{v:i,i:v,e:y(()=>(s(r,i??l,v??g,c),()=>{e.delete(t)}))}}function M(e,r,l){if(e.nodes)for(var t=e.nodes.start,g=e.nodes.end,s=r&&(r.f&T)===0?r.nodes.start:l;t!==null;){var u=Se(t);if(s.before(t),t===g)return;t=u}}function A(e,r,l){r===null?e.effect.first=l:r.next=l,l===null?e.effect.last=r:l.prev=r}function Me(e,r,l){var t=e==null?"":""+e;return t===""?null:t}function ke(e,r){return e==null?null:String(e)}export{ke as a,He as e,De as i,Me as t};

apps/dashboard/build/_app/immutable/chunks/BsvCUYx-.js

@@ -0,0 +1 @@
+import{aH as N,k as v,x as u,aI as w,M as p,aJ as T,aK as x,m as d,w as i,aL as y,ab as b,aM as A,v as L,aN as C}from"./CvjSAYrz.js";var h;const m=((h=globalThis==null?void 0:globalThis.window)==null?void 0:h.trustedTypes)&&globalThis.window.trustedTypes.createPolicy("svelte-trusted-html",{createHTML:e=>e});function D(e){return(m==null?void 0:m.createHTML(e))??e}function g(e){var a=N("template");return a.innerHTML=D(e.replaceAll("<!>","<!---->")),a.content}function n(e,a){var r=p;r.nodes===null&&(r.nodes={start:e,end:a,a:null,t:null})}function P(e,a){var r=(a&T)!==0,f=(a&x)!==0,s,c=!e.startsWith("<!>");return()=>{if(d)return n(i,null),i;s===void 0&&(s=g(c?e:"<!>"+e),r||(s=u(s)));var t=f||w?document.importNode(s,!0):s.cloneNode(!0);if(r){var _=u(t),o=t.lastChild;n(_,o)}else n(t,t);return t}}function H(e,a,r="svg"){var f=!e.startsWith("<!>"),s=(a&T)!==0,c=`<${r}>${f?e:"<!>"+e}</${r}>`,t;return()=>{if(d)return n(i,null),i;if(!t){var _=g(c),o=u(_);if(s)for(t=document.createDocumentFragment();u(o);)t.appendChild(u(o));else t=u(o)}var l=t.cloneNode(!0);if(s){var E=u(l),M=l.lastChild;n(E,M)}else n(l,l);return l}}function R(e,a){return H(e,a,"svg")}function F(e=""){if(!d){var a=v(e+"");return n(a,a),a}var r=i;return r.nodeType!==A?(r.before(r=v()),L(r)):C(r),n(r,r),r}function I(){if(d)return n(i,null),i;var e=document.createDocumentFragment(),a=document.createComment(""),r=v();return e.append(a,r),n(a,r),e}function $(e,a){if(d){var r=p;((r.f&y)===0||r.nodes.end===null)&&(r.nodes.end=i),b();return}e!==null&&e.before(a)}export{$ as a,R as b,I as c,n as d,P as f,F as t};

apps/dashboard/build/_app/immutable/chunks/Bz1l2A_1.js

@@ -0,0 +1 @@
+import{az as g,aA as d,aB as c,A as m,aC as i,aD as b,g as p,aE as v,U as h,aF as k}from"./CvjSAYrz.js";function x(t=!1){const a=g,e=a.l.u;if(!e)return;let f=()=>v(a.s);if(t){let n=0,s={};const _=h(()=>{let l=!1;const r=a.s;for(const o in r)r[o]!==s[o]&&(s[o]=r[o],l=!0);return l&&n++,n});f=()=>p(_)}e.b.length&&d(()=>{u(a,f),i(e.b)}),c(()=>{const n=m(()=>e.m.map(b));return()=>{for(const s of n)typeof s=="function"&&s()}}),e.a.length&&c(()=>{u(a,f),i(e.a)})}function u(t,a){if(t.l.s)for(const e of t.l.s)p(e);a()}k();export{x as i};

apps/dashboard/build/_app/immutable/chunks/Bzak7iHL.js

@@ -0,0 +1 @@
+var e;typeof window<"u"&&((e=window.__svelte??(window.__svelte={})).v??(e.v=new Set)).add("5");

apps/dashboard/build/_app/immutable/chunks/CHfZNXj4.js

@@ -1 +0,0 @@
-const e={fact:"#3b82f6",concept:"#8b5cf6",event:"#f59e0b",person:"#10b981",place:"#06b6d4",note:"#6b7280",pattern:"#ec4899",decision:"#ef4444"},o={MemoryCreated:"#10b981",MemoryUpdated:"#3b82f6",MemoryDeleted:"#ef4444",SearchPerformed:"#6366f1",DreamStarted:"#8b5cf6",DreamCompleted:"#a855f7",ConsolidationStarted:"#f59e0b",ConsolidationCompleted:"#f97316",ConnectionDiscovered:"#06b6d4",ImportanceScored:"#ec4899",Heartbeat:"#6b7280"};export{o as E,e as N};

apps/dashboard/build/_app/immutable/chunks/CNfQDikv.js

@@ -0,0 +1 @@
+import{Y as u,Z as v,_ as h,m as i,$ as g,a0 as f,B as A,a1 as S}from"./CvjSAYrz.js";const p=Symbol("is custom element"),N=Symbol("is html"),T=f?"link":"LINK",E=f?"progress":"PROGRESS";function k(r){if(i){var s=!1,a=()=>{if(!s){if(s=!0,r.hasAttribute("value")){var e=r.value;_(r,"value",null),r.value=e}if(r.hasAttribute("checked")){var o=r.checked;_(r,"checked",null),r.checked=o}}};r.__on_r=a,A(a),S()}}function l(r,s){var a=d(r);a.value===(a.value=s??void 0)||r.value===s&&(s!==0||r.nodeName!==E)||(r.value=s??"")}function _(r,s,a,e){var o=d(r);i&&(o[s]=r.getAttribute(s),s==="src"||s==="srcset"||s==="href"&&r.nodeName===T)||o[s]!==(o[s]=a)&&(s==="loading"&&(r[u]=a),a==null?r.removeAttribute(s):typeof a!="string"&&L(r).includes(s)?r[s]=a:r.setAttribute(s,a))}function d(r){return r.__attributes??(r.__attributes={[p]:r.nodeName.includes("-"),[N]:r.namespaceURI===v})}var c=new Map;function L(r){var s=r.getAttribute("is")||r.nodeName,a=c.get(s);if(a)return a;c.set(s,a=[]);for(var e,o=r,n=Element.prototype;n!==o;){e=g(o);for(var t in e)e[t].set&&a.push(t);o=h(o)}return a}export{l as a,k as r,_ as s};

apps/dashboard/build/_app/immutable/chunks/CNjeV5xa.js

@@ -0,0 +1 @@
+import{aB as a,az as t,Q as u,A as o}from"./CvjSAYrz.js";function c(e){throw new Error("https://svelte.dev/e/lifecycle_outside_component")}function l(e){t===null&&c(),u&&t.l!==null?i(t).m.push(e):a(()=>{const n=o(e);if(typeof n=="function")return n})}function f(e){t===null&&c(),l(()=>()=>o(e))}function i(e){var n=e.l;return n.u??(n.u={a:[],b:[],m:[]})}export{f as a,l as o};

apps/dashboard/build/_app/immutable/chunks/CVDMn5X_.js

@@ -1 +0,0 @@
-import{b as p,E as t}from"./DleE0ac1.js";import{B as c}from"./BolYP48w.js";function E(r,s,...a){var e=new c(r);p(()=>{const n=s()??null;e.ensure(n,n&&(o=>n(o,...a)))},t)}export{E as s};

apps/dashboard/build/_app/immutable/chunks/CVpUe0w3.js

@@ -0,0 +1 @@
+import{D as k,F as f,G as m,A as t,z as _,m as b,I as i}from"./CvjSAYrz.js";function E(e,a,v=a){var c=new WeakSet;k(e,"input",async r=>{var l=r?e.defaultValue:e.value;if(l=o(e)?u(l):l,v(l),f!==null&&c.add(f),await m(),l!==(l=a())){var h=e.selectionStart,d=e.selectionEnd,n=e.value.length;if(e.value=l??"",d!==null){var s=e.value.length;h===d&&d===n&&s>n?(e.selectionStart=s,e.selectionEnd=s):(e.selectionStart=h,e.selectionEnd=Math.min(d,s))}}}),(b&&e.defaultValue!==e.value||t(a)==null&&e.value)&&(v(o(e)?u(e.value):e.value),f!==null&&c.add(f)),_(()=>{var r=a();if(e===document.activeElement){var l=i??f;if(c.has(l))return}o(e)&&r===u(e.value)||e.type==="date"&&!r&&!e.value||r!==e.value&&(e.value=r??"")})}function S(e,a,v=a){k(e,"change",c=>{var r=c?e.defaultChecked:e.checked;v(r)}),(b&&e.defaultChecked!==e.checked||t(a)==null)&&v(e.checked),_(()=>{var c=a();e.checked=!!c})}function o(e){var a=e.type;return a==="number"||a==="range"}function u(e){return e===""?null:+e}export{S as a,E as b};

apps/dashboard/build/_app/immutable/chunks/Casl2yrL.js

@@ -0,0 +1 @@
+import{w as S,g as T}from"./DfQhL-hC.js";import{e as R}from"./CtkE7HV2.js";import{E as u}from"./DzfRjky4.js";const M=4,x=1500;function F(){const{subscribe:y,update:i}=S([]);let m=1,b=0;const d=new Map,a=new Map,l=new Map;function f(e,o){l.set(e,Date.now());const t=setTimeout(()=>{d.delete(e),l.delete(e),g(e)},o);d.set(e,t)}function w(e){const o=m++,t=Date.now(),s={id:o,createdAt:t,...e};i(n=>{const r=[s,...n];return r.length>M?r.slice(0,M):r}),f(o,e.dwellMs)}function g(e){const o=d.get(e);o&&(clearTimeout(o),d.delete(e)),a.delete(e),l.delete(e),i(t=>t.filter(s=>s.id!==e))}function C(e,o){const t=d.get(e);if(!t)return;clearTimeout(t),d.delete(e);const s=l.get(e)??Date.now(),n=Date.now()-s,r=Math.max(200,o-n);a.set(e,{remaining:r})}function D(e){const o=a.get(e);o&&(a.delete(e),f(e,o.remaining))}function N(){for(const e of d.values())clearTimeout(e);d.clear(),a.clear(),l.clear(),i(()=>[])}function _(e){const o=u[e.type]??"#818CF8",t=e.data;switch(e.type){case"DreamCompleted":{const s=Number(t.memories_replayed??0),n=Number(t.connections_found??0),r=Number(t.insights_generated??0),p=Number(t.duration_ms??0),c=[];return c.push(`Replayed ${s} ${s===1?"memory":"memories"}`),n>0&&c.push(`${n} new connection${n===1?"":"s"}`),r>0&&c.push(`${r} insight${r===1?"":"s"}`),{type:e.type,title:"Dream consolidated",body:`${c.join(" · ")} in ${(p/1e3).toFixed(1)}s`,color:o,dwellMs:7e3}}case"ConsolidationCompleted":{const s=Number(t.nodes_processed??0),n=Number(t.decay_applied??0),r=Number(t.embeddings_generated??0),p=Number(t.duration_ms??0),c=[];return n>0&&c.push(`${n} decayed`),r>0&&c.push(`${r} embedded`),{type:e.type,title:"Consolidation swept",body:`${s} node${s===1?"":"s"}${c.length?" · "+c.join(" · "):""} in ${(p/1e3).toFixed(1)}s`,color:o,dwellMs:6e3}}case"ConnectionDiscovered":{const s=Date.now();if(s-b<x)return null;b=s;const n=String(t.connection_type??"link"),r=Number(t.weight??0);return{type:e.type,title:"Bridge discovered",body:`${n} · weight ${r.toFixed(2)}`,color:o,dwellMs:4500}}case"MemoryPromoted":{const s=Number(t.new_retention??0);return{type:e.type,title:"Memory promoted",body:`retention ${(s*100).toFixed(0)}%`,color:o,dwellMs:4500}}case"MemoryDemoted":{const s=Number(t.new_retention??0);return{type:e.type,title:"Memory demoted",body:`retention ${(s*100).toFixed(0)}%`,color:o,dwellMs:4500}}case"MemorySuppressed":{const s=Number(t.suppression_count??0),n=Number(t.estimated_cascade??0);return{type:e.type,title:"Forgetting",body:n>0?`suppression #${s} · Rac1 cascade ~${n} neighbors`:`suppression #${s}`,color:o,dwellMs:5500}}case"MemoryUnsuppressed":{const s=Number(t.remaining_count??0);return{type:e.type,title:"Recovered",body:s>0?`${s} suppression${s===1?"":"s"} remain`:"fully unsuppressed",color:o,dwellMs:5e3}}case"Rac1CascadeSwept":{const s=Number(t.seeds??0),n=Number(t.neighbors_affected??0);return{type:e.type,title:"Rac1 cascade",body:`${s} seed${s===1?"":"s"} · ${n} dendritic spine${n===1?"":"s"} pruned`,color:o,dwellMs:6e3}}case"MemoryDeleted":return{type:e.type,title:"Memory deleted",body:String(t.id??"").slice(0,8),color:o,dwellMs:4e3};case"Heartbeat":case"SearchPerformed":case"RetentionDecayed":case"ActivationSpread":case"ImportanceScored":case"MemoryCreated":case"MemoryUpdated":case"DreamStarted":case"DreamProgress":case"ConsolidationStarted":case"Connected":return null;default:return null}}let h=null;return R.subscribe(e=>{if(e.length===0)return;const o=[];for(const t of e){if(t===h)break;o.push(t)}if(o.length!==0){h=e[0];for(let t=o.length-1;t>=0;t--){const s=_(o[t]);s&&w(s)}}}),{subscribe:y,dismiss:g,clear:N,pauseDwell:C,resumeDwell:D,push:w}}const $=F();function O(){[{type:"DreamCompleted",title:"Dream consolidated",body:"Replayed 127 memories · 43 new connections · 5 insights in 2.4s",color:u.DreamCompleted,dwellMs:7e3},{type:"ConnectionDiscovered",title:"Bridge discovered",body:"semantic · weight 0.87",color:u.ConnectionDiscovered,dwellMs:4500},{type:"MemorySuppressed",title:"Forgetting",body:"suppression #2 · Rac1 cascade ~8 neighbors",color:u.MemorySuppressed,dwellMs:5500},{type:"ConsolidationCompleted",title:"Consolidation swept",body:"892 nodes · 156 decayed · 48 embedded in 1.1s",color:u.ConsolidationCompleted,dwellMs:6e3}].forEach((i,m)=>{setTimeout(()=>{$.push(i)},m*800)}),T($)}export{O as f,$ as t};

apps/dashboard/build/_app/immutable/chunks/ChQRIhGP.js

@@ -1 +0,0 @@
-import{N as d,F as k,af as S,ag as y,ah as A,ai as m,aj as E,ak as b,O as M,al as N,q as g,C as L,U as t,V as T}from"./DleE0ac1.js";const I=Symbol("is custom element"),O=Symbol("is html"),C=m?"link":"LINK";function q(a){if(d){var e=!1,r=()=>{if(!e){if(e=!0,a.hasAttribute("value")){var c=a.value;u(a,"value",null),a.value=c}if(a.hasAttribute("checked")){var s=a.checked;u(a,"checked",null),a.checked=s}}};a.__on_r=r,k(r),S()}}function u(a,e,r,c){var s=H(a);d&&(s[e]=a.getAttribute(e),e==="src"||e==="srcset"||e==="href"&&a.nodeName===C)||s[e]!==(s[e]=r)&&(e==="loading"&&(a[y]=r),r==null?a.removeAttribute(e):typeof r!="string"&&U(a).includes(e)?a[e]=r:a.setAttribute(e,r))}function H(a){return a.__attributes??(a.__attributes={[I]:a.nodeName.includes("-"),[O]:a.namespaceURI===A})}var h=new Map;function U(a){var e=a.getAttribute("is")||a.nodeName,r=h.get(e);if(r)return r;h.set(e,r=[]);for(var c,s=a,o=Element.prototype;o!==s;){c=b(s);for(var l in c)c[l].set&&r.push(l);s=E(s)}return r}function w(a,e,r=e){var c=new WeakSet;M(a,"input",async s=>{var o=s?a.defaultValue:a.value;if(o=_(a)?i(o):o,r(o),t!==null&&c.add(t),await N(),o!==(o=e())){var l=a.selectionStart,f=a.selectionEnd,n=a.value.length;if(a.value=o??"",f!==null){var v=a.value.length;l===f&&f===n&&v>n?(a.selectionStart=v,a.selectionEnd=v):(a.selectionStart=l,a.selectionEnd=Math.min(f,v))}}}),(d&&a.defaultValue!==a.value||g(e)==null&&a.value)&&(r(_(a)?i(a.value):a.value),t!==null&&c.add(t)),L(()=>{var s=e();if(a===document.activeElement){var o=T??t;if(c.has(o))return}_(a)&&s===i(a.value)||a.type==="date"&&!s&&!a.value||s!==a.value&&(a.value=s??"")})}function _(a){var e=a.type;return e==="number"||e==="range"}function i(a){return a===""?null:+a}export{w as b,q as r,u as s};