v3.0.2

Summary

Website release. The site is rebuilt on the developer-vertical anatomy with a
fluid token system, a new cinematic showreel replaces the old terminal
recording, and the qa-launch release gate becomes executable code that runs in
CI.

No engine behaviour, public API, CLI surface or MCP tool name changes.

Full Changelog: v3.0.1...v3.0.2

The site

• Copy — the AIDA spine across the page, with PAS driving the problem
  block. Written for a developer deciding whether to install something.
• Layout — the developer anatomy: hero → demo → architecture → code grid
  → proof → quickstart → licence.
• Tokens — a token-first stylesheet with fluid clamp() spacing and type
  ramps, logical properties throughout, and no fixed values in components.
• Graphics — a twelve-icon line set on a 24px grid, plus three inline-SVG
  figures: a recall latency chart, the memory lifecycle state machine, and the
  system topology with a "your machine only" band around the engine and the
  store. Every figure is bound to claims.json, so no figure can drift from
  the code.

The showreel

An original twelve-second film, "The Memory Lattice": the agent forgets →
the note is checked against the code it cites → verified, versioned, local →
the wordmark and the one command. A constellation of nodes whose focus thread
draws from the note to the code and snaps green when the check passes.

Every visual is a pure function of t, with a seeded PRNG for the dust field,
so the render is reproducible. The pipeline is Playwright + ffmpeg — the
browser was already a devDependency, so there is no extra download, and the
old HyperFrames composition (which needed a 150MB browser to flatten a vector)
is gone.

The copy rule

The project now says "the majority of coding agents" rather than a number.
A number ages badly and invites a precision the registry cannot promise; the
precise count stays in claims.json, where it is a fact about the code
rather than a promise about the market. A test enforces it.

The gate

apps/website/scripts/qa-gate.ts runs the qa-launch gate checklist as
code — critical paths, the keyboard-only path, 200% zoom reflow, the
no-JavaScript first frame, animation performance, the header/footer chrome, a
placeholder/debug sweep, the payload budget and a second rendering engine. It
exits non-zero on any blocking failure, so CI runs it.

17/17, SHIP.

Defects the gate found (all fixed)

Severity	Finding
P0	With JavaScript disabled, all 43 .reveal elements stayed at opacity: 0 — the page below the hero rendered blank.
P1	The mobile menu sheet overflowed the viewport (x = -73).
P1	The header rendered as raw inline text. A missing CSS rule does not throw — it is invisible to axe and to an overflow check, so the site passed every automated gate while looking broken.
P1	A <p> inside a <dl>'s wrapper div — an axe-core definition-list violation.
P1	The copy button's fallback hint said "Press ⌘C" on every platform.
P2	Two animated elements combined filter: blur() with a transform animation, forcing a per-frame re-rasterisation of the blur.

Verification

• bun test — 1354 pass, 0 fail, 6172 assertions across 206 files
• bunx tsc --noEmit — clean
• bun run site:qa — 17/17, SHIP
• axe-core — 0 critical/serious on 4 pages; 26/26 contrast pairs at WCAG 2.2 AA
• Firefox 155 — renders without overflow

v3.0.1

Summary

Correctness release. Fixes five defects found by a cross-file invariant audit — a prompt-injection channel through CURRENT.md, a store that could fail its own schema validator, bi-temporal queries answered from a stale cache entry, a tiered context path that silently dropped as_of, and an access counter that never accumulated.

Also makes every published number machine-verified, and redesigns the website.

Full Changelog: v3.0.0...v3.0.1

Fixed

• Prompt-injection channel through CURRENT.md — the stored memory was sanitised, but the constraint copy written to CURRENT.md was not. Because CURRENT.md is replayed into every later prompt, one captured constraint could reach every future session in the workspace. Sanitisation now happens at the sink.
• Store could fail its own schema validator — stale_embedder was written onto entries but rejected as an unknown property, so every entry that failed embedding was permanently reported as corrupt.
• Bi-temporal queries served the wrong snapshot — the context cache key omitted as_of, so "what did we believe in Q1?" could be answered from a 30-second-old current-state entry.
• Tiered context dropped as_of and depth — get_context(tier=1, as_of=…) returned the current state while the untiered path returned the historical one.
• Access counter never accumulated — every read reset it to its baseline, silently disarming the access-frequency ranking axis, the LangMem frequency axis and the access-weighted retention half-life.
• Tier token budget was declared but never enforced — 327 tokens against a 200-token budget.
• MCP server advertised a stale version (1.6.0 while the package was at 3.0.0), three MCP tools were callable but not discoverable, memory_delete honoured undocumented flags that disabled its dry-run default, restoreSnapshotRing had no path containment, and the CLI --help text repeated an incorrect platform count.

Changed

• Every published number is now generated from the source. The site advertised "80+ coding agents" (52), "45+ credential shapes" (8 rule families) and "69 tools across 6 profiles" (115 across 7), while the README was already honest at 52 — every figure was hand-typed into prose in five files, and nothing compared any of them to the code. scripts/generate-claims.ts now derives them from src/, the website imports the manifest, and a test fails the build on any drift.
• Documentation split into human and agent layers — docs/agent-reference.md (the agent contract), docs/cli-reference.md (generated from src/), docs/roadmap.md, and a README restructured around a 60-second start and a documentation map.
• Website redesign — shared navigation, footer and logo components (the 404 page previously had no navigation at all), a working mobile menu, a complete SEO head, and an agent-readable llms.txt layer.
• New deterministic brand pipeline — a redesigned monogram, favicon, PWA icons, Open Graph card, Twitter card and README banner, rasterised with resvg from the fonts already vendored in the repository. The old pipeline needed a 150MB browser download to flatten a vector, and the Pages workflow was still calling it — which would have reverted every new asset on each deploy.

Verification

• bun test — 1336 pass, 0 fail, 6128 assertions across 205 files (was 1309)
• bunx tsc --noEmit — clean
• audit-a11y.ts — 0 critical/serious across 4 pages, 26/26 contrast pairs at WCAG 2.2 AA
• audit-visual.ts — 9/9 responsive viewports

Breaking changes

None. The public API, CLI surface and MCP tool names are unchanged.

v2.3.0 — Autonomous Memory Optimizer, Dashboard Trigger & Multi-Agent Concurrency

⚡ Muse Memory v2.3.0 — Autonomous Storage Optimizer, UI Dashboard Trigger & Multi-Agent Concurrency

Muse Memory v2.3.0 is a major feature release introducing the Autonomous Memory Storage Optimizer Engine, Zero-Daemon Automated Cadence, Embedded Web UI Dashboard Optimization Trigger, and Concurrent Multi-Agent Workstream Tracking across parallel agent swarms.

---

🚀 What's New in v2.3.0

1. Autonomous Memory Optimizer (src/optimize.ts)

• Multi-Factor Noise Pruning:
  • High-precision detection and pruning of test assertion noise (expect(...) traces, test runner outputs, mock data).
  • Junk fragment detection: prunes single-character debris ('1', '+'), micro-snippets, accidental system transcript dumps (MODEL PLANNER_RESPONSE, </SYSTEM_MESSAGE>, The above content does NOT show the entire file contents, and truncated outputs).
  • Candidate deduplication across normalized title and content keys, while strictly protecting human-confirmed and verified memories.
• SQLite Storage Defragmentation:
  • Automatically executes VACUUM; and PRAGMA optimize; in SQLite WAL mode to reclaim fragmented disk space.
  • Reclaimed 9.24 MB on local store during real-world benchmark runs.
• Operational Audit Ledger:
  • Emits structured AuditOperation = "optimize" events and stores metadata in .memory/optimization_meta.json.

2. Zero-Daemon Automated Cadence

• Automatically governs storage hygiene without persistent background daemons:
  • 7-Day Cadence: Runs optimization if now - last_optimized_at >= 7 days.
  • 48-Hour Inactivity Window: Runs optimization if workspace is idle for 48 hours and hasn't been optimized in 48 hours.
  • Automatically evaluated on turn start during context grounding (get_context, muse_context).

3. CLI Command: memory optimize

• Command-line interface with formatted terminal scoreboard:

  memory optimize                  # Run optimization with SQLite VACUUM
  memory optimize --dry-run        # Preview candidate items to prune
  memory optimize --force          # Force immediate run ignoring cadence
  memory optimize --project core   # Target specific project scope

4. Dashboard "⚡ Optimize" Trigger (src/ui.ts)

• Web Observability Studio Header: Added #optimizeBtn with ⚡ Optimize button and hover tooltip.
• REST Endpoints: Added POST /api/optimize and GET /api/optimize/status.
• Live Client Feedback: Real-time spinner animations and flash toasts reporting items pruned and bytes reclaimed.

5. Concurrent Multi-Agent Workstream Tracking (src/governor.ts)

• Multi-Agent Coordination Protocol: Tracks parallel agents running simultaneously in separate IDE windows or chat sessions via AgentWorkstream.
• Live Markdown Table in CURRENT.md:

  ## 🤖 Active Concurrent Agent Workstreams
  | Agent / Session ID | Status | Active Task | Target Scope / Files | Last Active |
  | :--- | :--- | :--- | :--- | :--- |

• Prompt Context Awareness: formatPromptContext (src/retrieval.ts) and resolveMuseContext (src/orchestrator/context.ts) inject active concurrent workstreams so agents never clash or overwrite each other's files.
• Auto-prunes completed tasks after 48 hours.

6. CURRENT.md Guidelines & Bloat Sanitation

• Cleared .memory/CURRENT.md from 5,234 lines down to 26 clean, high-signal invariants.
• Established clear operational guidelines:
  • For Humans: Single-pane executive summary of active hard constraints and in-flight tasks. Zero verbose logs or transient filler.
  • For AI Agents: Mandatory grounding rules (never violate active constraints) and concurrent workstream awareness.
• Hardened syncConstraints and parseCurrentFile to reject multi-line transcript chunks and normalize duplicates.

---

🧪 Verification & Reliability

• Unit & Integration Tests: 502/502 passed across 85 test files (bun test).
• Static Typing: Zero TypeScript errors (tsc --noEmit).
• Production Bundle: Clean 1.50 MB bundle in dist/index.js (bun run build).
• Vibeguard Audit: 0 credential leaks (SecretScan.ts).

v2.2.1 — Impact Analysis, PR Context, Anchor Reconciler & Architecture Hardening

🚀 Muse Memory v2.2.1 — Impact Analysis, PR Context, Anchor Reconciler & Architecture Hardening

Muse Memory v2.2.1 brings pre-flight code and memory impact analysis, automated pull request context generation, interactive code anchor reconciliation, microsecond latency benchmarking, and critical security and concurrency hardening from a rigorous Linus Torvalds-style code review.

---

💥 Flagship Features (v2.2.0)

1. Unified Code & Memory Impact Analysis (memory code-impact)

• Synthesizes AST code callers, affected test suites, linked memories, living ADRs, negative anti-patterns, and active constraints into a unified pre-flight report.
• Computes a composite Risk Score (0–100) and categorical Risk Level (LOW, MEDIUM, HIGH, CRITICAL) with actionable mitigation recommendations before modifying code.
• Available via CLI (memory code-impact <file> [--symbol <name>]) and MCP tool (muse_code_impact).

2. PR & Change Context Generator (memory pr-context)

• Automatically analyzes git diffs against a base branch, linking touched code anchors, respected ADRs, active project constraints, and blast radius.
• Generates rich GitHub-ready Markdown pull request descriptions with verification checklists and merge promotion proposals.
• Available via CLI (memory pr-context [--base main] [--out <file>]) and MCP tool (muse_pr_context).

3. Interactive Code Anchor Reconciler (memory reconcile)

• Audits code anchors across memories, pruning dead anchors, refreshing structural hashes for drifted code, and marking abandoned memories stale.
• Supports --dry-run, --prune, --mark-stale, --update-hashes, and MCP tool (muse_reconcile_anchors).

4. Repeatable Speed, Quality & ROI Benchmark Suite (memory benchmark)

• Measures microsecond in-process cache reads (P50 < 4µs), SQLite FTS5 BM25 search, knapsack token packing, contradiction rates, and compression ratios in a clean ASCII scoreboard.
• Available via CLI (memory benchmark [--iterations N] [--budget N]).

5. Complete Shipped Agent Skills Roster

• Added 5 new turnkey skills to .agents/skills/:
  • muse-health: Unified 5-pillar architectural health gate.
  • muse-drift: Bidirectional doc-to-code drift auditor.
  • muse-why: Autonomous historical "Why" rationale explainer.
  • muse-sync: Cross-agent P2P gossip sync governor.
  • muse-mesh: Multi-repo and monorepo cross-project mesh.

---

🛡️ Linus Torvalds Code Review Hardening & Bug Fixes (v2.2.1)

• Command Injection Hardening: Replaced shell string invocation in generatePrContext (src/compaction/pr-context.ts) with direct argument array execution via execFileSync("git", ...) and validated git reference names against strict identifier patterns (/^[a-zA-Z0-9._\/-]+$/).
• SQLite Concurrency & Lock Contention: Configured PRAGMA busy_timeout = 5000; and PRAGMA foreign_keys = ON; in both Bun and Node SQLite database drivers (src/sqlite.ts), preventing immediate SQLITE_BUSY crashes in multi-agent and concurrent workflows.
• Store Listing O(N) Stat Storm: Optimized list(store) (src/store.ts) to query indexed SQLite records directly and discover external YAML files via single-pass readdirSync, eliminating thousands of redundant synchronous filesystem statSync calls.
• Accurate Benchmark Cold Startup: Corrected cold startup latency measurement in runMemoryBenchmark (src/benchmark/suite.ts) to benchmark actual unprimed store opening and initialization instead of in-memory array property access.
• Dual-Write Persistence Observability: Replaced silent error swallowing in save(store, entry) (src/store.ts) with structured warning logs when YAML filesystem persistence fails.
• Impact Analysis Precision: Tightened ADR matching in analyzeMemoryCodeImpact (src/intelligence/impact.ts) with normalized path checks, exact code anchor matching, and regex word boundaries, eliminating false-positive risk inflation on common filenames.
• Atomic Reconciler Transactions: Wrapped anchor reconciliation writes in reconcileCodeAnchors (src/health/reconcile.ts) inside an atomic SQLite transaction (BEGIN TRANSACTION ... COMMIT).

---

🧪 Verification & Evidence

• Test Suite: 497 tests passed cleanly across 84 files (bun test, 2,190 assertions).
• TypeScript: tsc --noEmit checked with 0 errors.
• Production Build: bun run build completed cleanly (dist/index.js 1.48 MB).
• Vibeguard SecretScan: Zero credentials or private keys leaked in codebase.

v2.1.0 — Cross-Agent Knowledge Sync, Web Observability Studio & Monorepo Mesh

Muse Memory v2.1.0 — Cross-Agent Knowledge Sync, Web Observability Studio & Monorepo Mesh

This release delivers three major architectural milestones expanding Muse Memory into a multi-agent, visual, and multi-workspace cognitive nervous system:

🤝 R14: Cross-Agent Knowledge Sync & P2P Gossip Protocol

• Cryptographic Sealed Packets: Portable SyncPacket format with whole-packet SHA-256 integrity verification.
• Vector Clock Causal Tracking: Causal versioning preventing cyclic feedback loops between asynchronous agents.
• Shared Filesystem Gossip Pool: Zero-daemon drop-directory synchronization for multi-agent pods.
• Semantic Contradiction & Secret Defense: Ingested peer memories are scanned by Vibeguard and checked for semantic contradictions (tagged with conflicted status and mutual conflict_ids).
• CLI & MCP: memory sync command suite and 4 MCP tools (muse_sync_broadcast, muse_sync_ingest, muse_sync_status, muse_sync_pool).

🌐 R15: Full Web Observability Studio

• Embedded Visual Studio: Zero-daemon local web dashboard accessible via memory studio (or memory ui).
• 5-Pillar Health Scorecard: Real-time project health gate evaluating Store Integrity, Native Anchors, Doc-Code Drift, Anti-Pattern Sentry, and Technical Debt (A-F grade, PASS/WARN/FAIL status, prioritized remediation checklist).
• Interactive ADR Registry & Drift Inspector: First-class ADR viewer and bidirectional code ↔ documentation alignment classification.
• Autonomous "Why" Reasoner: Explains historical code rationale through past bug workarounds, accepted trade-offs, and timeless rules.
• Fragility Clusters & Debt Hotspots: Heatmap of recurring bug clusters and code debt scanner.
• P2P Gossip Mesh Visualizer: Live peer ledger, vector clocks, and packet broadcast controls.

🕸️ R16: Multi-Repo & Monorepo Cross-Project Mesh

• Automatic Workspace Discovery: Auto-detects pnpm, npm, bun, and lerna monorepos, and sibling git repositories.
• Explicit Mesh Linking: Cross-project linkage via .memory/mesh_links.json.
• Cross-Project Memory Querying: Resolves memories across package stores with origin provenance badges ([mesh:@scope/package]).
• Shared Invariant Propagation: Broadcasts hard constraints and security rules across all packages in a single operation.
• Cross-Package Contract Audit: Validates dependency entrypoint exports (main, module, exports) and cross-repo code anchors (repo:<pkg>/<path>#<symbol>).
• CLI, MCP & UI: memory mesh suite, 4 MCP tools (muse_mesh_status, muse_mesh_query, muse_mesh_audit, muse_mesh_link), and Studio Monorepo Mesh tab.

🧪 Verification

• 498 automated tests passing across 81 files (100% pass rate).
• Zero TypeScript errors (tsc --noEmit).
• Pre-ship TruffleHog SecretScan verified clean.

v2.0.0 — Autonomous Cognitive Engine Major Overhaul

🧠 Muse Memory v2.0.0 — Autonomous Cognitive Engine Major Overhaul

Release Version: v2.0.0
Milestones: R1 through R13 complete
Test Status: 480/480 passing tests across 79 test suites
Tool Surface: 61 MCP Tools across 6 task-focused profiles

---

🌟 Highlights

Muse Memory v2.0.0 is a major architectural leap evolving Muse Memory from a passive episodic memory store into a complete, self-correcting, evidence-aware autonomous cognitive engine with zero external resident daemon dependencies.

1. 🏥 Unified 5-Pillar Project Health Gate (memory health / muse_health)

• Single-call comprehensive quality gate evaluating:
  1. Memory Store Integrity: Contradictions, expired entries, timeless rules.
  2. Native Code Anchor Validity: Live AST structural verification, drift detection.
  3. Documentation ↔ Code Alignment: Bi-directional drift, undocumented exports.
  4. Negative Lessons & Anti-Pattern Sentry: Saliency and defense against known traps.
  5. Technical Debt & Friction: TODO/FIXME markers, as any type bypasses, recurring bug clusters.
• Generates composite grades (A–F), gate status (PASS/WARN/FAIL), prioritized remediation checklist, and an ANSI terminal dashboard.

2. 🧠 Autonomous Engineering Cognition & "Why" Reasoner (muse_why)

• Traces code evolution backwards through past bug fixes, ADRs, accepted trade-offs, and timeless rules to explain why code was built the way it is before an agent refactors it.
• Bug & Friction Clustering (muse_bug_clusters): Categorizes failure patterns across 5 root causes (race_condition, type_drift, missing_guard, resource_leak, architecture_flaw) and computes subsystem fragility scores.
• Technical Debt Registry (muse_tech_debt): Scans code and memory for workarounds and dangerous type bypasses.

3. 🏛️ First-Class Architecture Decision Records & Drift Engine (memory_adr_*, memory_drift_audit)

• ADRs as living, queryable, scored memory entities (proposed, accepted, superseded, rejected) linked directly to affected symbols and tests.
• 6-state bi-directional drift classifier (DOCUMENTED, IMPLEMENTED, PARTIAL, CONFLICTING, STALE, MISSING).

4. ⚓ Native Structural Code Anchors (src/anchors/)

• Line-independent structural fingerprints normalized across whitespace and comment edits.
• Live verification detects whether symbols are valid, drifted, or orphaned without requiring external dependencies.

5. 🎯 Flagship Context Orchestrator & Task-Focused Profiles (muse_context)

• Fuses active constraints, code anchors, ranked memories, and negative lessons under token budget limits using knapsack packing.
• 6 role-tailored MCP profiles (core, coding, debugging, review, architecture, maintenance) that eliminate tool-surface bloat for coding agents.

6. 🪜 Scoped Promotion Ladder & Extended Archival Lifecycle (src/promotion/)

• Strict 3-tier promotion: local → project → global.
• 5× repeated success policy gate with automatic structural generalization.
• active → cold → dormant → archived lifecycle with zero-friction query rehydration.

7. ⚡ Core Speed & Multi-Factor Retrieval

• Sub-50 microsecond in-process L0 hot cache and L1 context cache with SQLite WAL tuning.
• 11-dimension retrieval scoring combining AST symbol matches, path proximity, FTS5 BM25, graph overlap, recency decay, and utility ROI.

---

📦 Installation & Upgrade

# Global Install
npm install -g musememory
# or with Bun:
bun add -g musememory

# One-line autonomous upgrade
memory upgrade

v1.11.0 — Cognitive Engine Evolution V2 & Architectural Hardening

🧠 What's New in Muse Memory v1.11.0

🏛️ Cognitive Engine Evolution & Core Capabilities

• 📜 Provenance & Source Ledger (.memory/sources.json / memory source): Records external documentation, research papers, RFCs, and authoritative URLs with retrieval timestamps, authors, and classification tags.
• 🔍 Evidence-Grounded Claim Ledger (.memory/claims.json / memory claim): Connects atomic memories to verifiable claims tagged with strict confidence ratings: [RAW] (locally verified), [FETCH] (authoritative URL), [SEARCH] (search-synthesized), and [INFER] (agent deduction).
• ⚡ Deterministic Tiered Retrieval Engine (--tier 0|1|2): Bounded 3-tier retrieval prevents context stuffing: Tier 0 (Manifest) index (~50 tokens), Tier 1 (Routing Set) (~300 tokens), and Tier 2 (Bounded Bodies) fitted greedily into the knapsack token budget.
• 🧊 Frozen Execution Snapshots (memory freeze): Captures immutable run state (.memory/runs/<run-id>/snapshot.json) combining task specs, workspace file inventory, git SHA, active constraints, and SHA-256 memory hashes for deterministic regression replay.
• 📝 Native Structured Prompt Registry (memory prompt): Reusable structured prompt templates with live memory context injection (includes built-in morning-standup, drift-audit, pre-publish-audit, sprint-compounding).
• ⏳ Multi-Scale Temporal Compounding (memory rollup): Aggregates atomic session memories into weekly (YYYY-Www.md), monthly (YYYY-MM.md), and quarterly (YYYY-QN.md) synthesis wiki pages, and compiles the .memory/HOT.md instant working memory cache.
• 🔄 Gauntlet Iteration Ledger & Plateau Detector (memory loop): Multi-agent improvement loop ledger (.memory/iterations.jsonl) that detects plateaus and regression signals to halt runaway token consumption.
• 🛡️ Strict Integrity & Health Gate (memory verify --strict): Zero-tolerance audit verifying zero secret credentials, referential link integrity, wikilink resolution, orphaned candidate retention, and claim-to-source completeness.

🔌 Interfaces & Ecosystem Expansion

• 40 Model Context Protocol (MCP) Tools: Native protocol tools exposing all provenance, claims, frozen runs, prompt runners, temporal rollups, gauntlet loops, and strict integrity verification.
• 41 CLI Commands: Complete terminal suite under memory / musememory / npx musememory.
• Zero Runtime Dependencies: Pure TypeScript, zero external database daemons or cloud servers.
• Test Suite: 368 unit and integration tests passing with 0 failures across 67 test files.

v1.10.0: Universal Multi-Agent Transcript Harvester & Auto-Learner

Universal Multi-Agent Transcript Harvester & Auto-Learner Engine

• Automated Workstation-Wide Chat Learning (memory learn / memory sync-chats):
  • Automatically probes host machine across 80+ agent platforms (Antigravity, Gemini CLI, Claude Code, OpenCode, Hermes, Goose, Codex, Cursor, etc.).
  • Extracts conversational fixes, architectural decisions, hard constraints, user preferences, and open loops from natural language turns without requiring rigid markdown tags.
  • Zero duplicate re-harvests guaranteed via content-hash persistent ledger (.memory/harvested-transcripts.json).
• Proactive Background Auto-Sync:
  • memory ui automatically synchronizes recent agent transcripts on launch.
  • get_context in MCP automatically triggers non-blocking incremental transcript harvests on session start.
  • memory doctor surfaces unharvested chat metrics with remediation guidance.
• Enhanced MCP Support:
  • memory_harvest tool supports { all: true } and { auto: true } for direct agent-driven workstation learning.

v1.9.0 - Autonomous Upgrade & Gamified Level-Up Matrix

🧠 Muse Memory v1.9.0 — Autonomous Upgrade & Gamified Level-Up Matrix

🚀 What's New in v1.9.0:

• Autonomous Upgrade & Self-Healing Engine (memory upgrade / memory update):
  • Automatically probes host environment to detect active package managers (bun, npm, pnpm, yarn).
  • Fetches the latest published release directly from npm registry and executes seamless global upgrades.
  • Automatically heals corrupted/missing files (.memory/, CURRENT.md, USER.md), auto-wires newly installed agent platforms, and re-indexes AST symbol graphs.
  • Added --check flag to inspect upstream updates without applying.
• Gamified ASCII Level-Up & Onboarding Matrix:
  • Integrated 5-level animated progress loaders ([████████████] 100%) with Level milestones across memory install, memory upgrade, and memory uninstall.
  • TTY-aware with graceful ANSI carriage return animations and clean CI logging fallbacks.
• Comprehensive Upgrading & Self-Healing Maintenance Guide: Detailed cross-toolchain upgrade instructions and verification procedures in README.md.

🧪 Verification:

• bun test: 319 passing tests across 57 test files (1294 assertions).
• tsc --noEmit: 0 static type errors.
• bun run build: Clean distribution bundle (dist/index.js).

v1.8.0 - Sprint SOW-200 Cognitive Enhancements

🧠 Muse Memory v1.8.0 — Sprint SOW-200 Cognitive Enhancements

🚀 What's New in v1.8.0:

• SOW-201: Live Runtime File & Symbol Verification Gate: Instant sub-millisecond CPU disk check verifying referenced code files in affected_paths with STRONG, WEAK, and STALE trust verdicts.
• SOW-202: Deterministic Relevance Cutoff Gate: Hard relevance score cutoff (Score >= 0.45) preventing weakly-related memories from bloating LLM prompt windows and saving 500–2,000 prompt tokens on unrelated queries.
• SOW-203: Git Code-Drift Scanner (memory drift / memory check CLI & memory_drift MCP tool): High-speed Git workspace scanner detecting modified or deleted code files and AST symbols, flagging drifted memories for re-verification or supersession.
• SOW-204: Gradient-Free Hebbian Co-Activation Plasticity: Associative synaptic link reinforcement incrementing edge weights (+0.05) when concepts are co-retrieved or confirmed together, enabling natural concept clustering with zero resident daemons.
• SOW-205: Semantic Memory Prompt Compression (memory compress CLI & memory_compress MCP tool): Lossless prompt compression stripping redundant Markdown whitespace and verbose headers, reducing prompt context token usage by 30–40%.
• 4-Phase Sprint & Roadmap Operating Lifecycle: Structured sprint pipeline (Requested ➔ Planned ➔ In Progress ➔ Done) with top-level Table of Contents and collapsible Roadmap board in README.md.

🧪 Verification:

• bun test: 315 passing tests across 56 test files (1282 assertions).
• tsc --noEmit: 0 static type errors.
• bun run build: Clean distribution bundle (dist/index.js).