@dinasor/mnemo-cli 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+
+All notable changes to Mnemo are documented here.
+
+Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). Mnemo uses [Semantic Versioning](https://semver.org/).
+
+## [Unreleased]
+
+## [0.0.1] - 2026-02-21
+
+### Added
+- First public Mnemo release with dual installers: `memory.ps1` (Windows PowerShell 5.1+/7+) and `memory_mac.sh` (macOS/Linux POSIX shell).
+- Installer CLI support for `--dry-run` / `-DryRun`, `--force` / `-Force`, project naming, and optional vector enablement.
+- Modular installer architecture with dedicated core and feature modules under `scripts/memory/installer/` (bootstrap, path resolution, I/O, bridges, scaffold, hooks, vector, MCP, `.gitignore`).
+- Canonical memory root at `.mnemo/` with compatibility bridges to `.cursor/` and `.agent/` so existing IDE integrations continue to work.
+- Bridge manager with cross-platform fallback behavior (symlink/junction/hardlink/mirror) and repair/migration logic for legacy layouts.
+- Canonical memory scaffold including always-read files (`hot-rules.md`, `active-context.md`, `memo.md`), lessons, journals, digests, ADR, and templates.
+- Atomic lesson workflow (`L-XXX-*`) and monthly journal workflow with rebuildable indexes/digests.
+- Helper script suite for daily operations (PowerShell + shell variants): rebuild index, lint memory, query memory, add lesson, add journal entry, clear active context.
+- Tag vocabulary enforcement and memory lint guardrails for frontmatter, structure, and token-safety checks.
+- Optional SQLite FTS support (`memory.sqlite`) when Python is available, including build/query helpers.
+- Optional vector mode with `mnemo_vector.py` MCP server and tools: `vector_search`, `vector_sync`, `vector_forget`, `vector_health`, `memory_status`.
+- Vector embedding provider support for both OpenAI and Gemini.
+- Autonomy runtime templates installed with vector mode (`autonomy/*` + `policies.yaml`) for ingestion, lifecycle, reranking, context safety, and policy handling.
+- Portable git hooks via `.githooks/` with automatic `core.hooksPath` setup.
+- Hook automation: `pre-commit` rebuild/lint and optional `post-commit` non-blocking vector sync.
+- Multi-agent bridge outputs: `CLAUDE.md`, `AGENTS.md`, and `.agent/rules/memory-system.md`.
+- Cross-platform CI coverage (Windows/macOS/Ubuntu), regression tests, modularization guardrails, and Python syntax checks for autonomy/retrieval modules.
+- Nightly benchmark workflow for retrieval quality/drift monitoring plus artifact upload.
+- GitHub release workflow for tag-based publishing with preflight/version/changelog validation and packaged installer assets.
+- Governance and contribution assets: `CONTRIBUTING.md`, `CODE_OF_CONDUCT.md`, `SECURITY.md`, `SUPPORT.md`, issue templates, PR template, `CODEOWNERS`, and Dependabot config.
+
+### Changed
+- Versioning is centralized in root `VERSION` and consumed by installers and generated output.
+- Installer/runtime path resolution prefers canonical `.mnemo` while preserving `.cursor` compatibility bridges.
+- Python resolution strategy is aligned across memory tooling (`py` / `python3` / `python` fallback behavior where applicable).
+- Managed `.gitignore` and hook behavior now reflect canonical `.mnemo` artifacts while keeping bridge compatibility.
+
+### Fixed
+- Duplicate managed `.gitignore` entries on repeated force installs.
+- Bridge idempotency/self-copy failures around `.cursor/mcp.json` compatibility targets.
+- Version string drift between installer metadata and generated output by using `VERSION` as single source of truth.
+- Python fallback handling in memory query flows that previously depended on a single interpreter name.
+
+[Unreleased]: https://github.com/DiNaSoR/Mnemo/compare/v0.0.1...HEAD
+[0.0.1]: https://github.com/DiNaSoR/Mnemo/releases/tag/v0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DragonArab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,263 @@
+<p align="center">
+  <img src="assets/header.png" alt="Mnemo - A Memory System for AI Coding Agents" width="100%">
+</p>
+
+# Mnemo 🧠
+
+[![CI](https://github.com/DiNaSoR/Mnemo/actions/workflows/ci.yml/badge.svg)](https://github.com/DiNaSoR/Mnemo/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/github/license/DiNaSoR/Mnemo)](LICENSE)
+
+> Token-safe repo memory for AI coding agents, with an autonomous runtime and optional semantic recall.
+>
+> ✅ Works with Cursor • Claude Code • Gemini Antigravity • OpenAI Codex • Windsurf • and more
+
+Mnemo scaffolds a structured memory layer under `.mnemo/` (canonical) and keeps permanent compatibility bridges for `.cursor/` and `.agent/`.
+
+## ✨ Why Mnemo
+
+- 🧭 **Predictable retrieval order** so agents read high-signal memory first
+- 🧱 **Atomic lessons + indexed journal** for durable project knowledge
+- 🛡️ **Quality guardrails** (lint, token budget checks, CI benchmarks)
+- ⚙️ **Autonomous mode** with vector sync and lifecycle tracking
+- 🔌 **MCP tools** for semantic recall in Cursor when vector mode is enabled
+
+## 🚀 Install Mnemo (once per project)
+
+Run from the **target project root**.
+
+### Any OS (npx, recommended)
+
+```sh
+# Installs into your current project folder
+npx @dinasor/mnemo-cli@latest
+
+# Optional flags (cross-platform)
+npx @dinasor/mnemo-cli@latest --dry-run
+npx @dinasor/mnemo-cli@latest --force
+npx @dinasor/mnemo-cli@latest --enable-vector --vector-provider gemini
+```
+
+### Windows (PowerShell)
+
+```powershell
+# Standard install
+powershell -ExecutionPolicy Bypass -File .\memory.ps1
+
+# With vector mode (OpenAI default)
+powershell -ExecutionPolicy Bypass -File .\memory.ps1 -EnableVector
+
+# With vector mode (Gemini embeddings)
+powershell -ExecutionPolicy Bypass -File .\memory.ps1 -EnableVector -VectorProvider gemini
+```
+
+### macOS / Linux (POSIX shell)
+
+```sh
+# Standard install
+sh ./memory_mac.sh
+
+# With vector mode (OpenAI default)
+sh ./memory_mac.sh --enable-vector
+
+# With vector mode (Gemini embeddings)
+sh ./memory_mac.sh --enable-vector --vector-provider gemini
+```
+
+### Post-install sanity check
+
+```powershell
+powershell -ExecutionPolicy Bypass -File .\scripts\memory\rebuild-memory-index.ps1
+powershell -ExecutionPolicy Bypass -File .\scripts\memory\lint-memory.ps1
+```
+
+If vector mode is enabled, restart your IDE once and run:
+
+```text
+vector_health
+vector_sync
+```
+
+---
+
+## 🧩 IDE setup guide (per project)
+
+Use the section that matches your IDE. Each project should run Mnemo install once.
+
+| IDE / Agent | What installer creates | What you do next |
+|---|---|---|
+| Cursor | `.mnemo/rules/cursor/00-memory-system.mdc` (+ `.mnemo/mcp/cursor.mcp.json`, bridged to `.cursor/mcp.json`) | Restart Cursor, run `vector_health`, then `vector_sync` |
+| Claude Code | `CLAUDE.md` bridge file | Open repo in Claude Code and follow read order from `CLAUDE.md` |
+| Gemini Antigravity | `.agent/rules/memory-system.md` | Ensure Antigravity loads project rules from `.agent/rules/` |
+| OpenAI Codex | `AGENTS.md` | Start Codex from repo root so `AGENTS.md` is in scope |
+| Windsurf / Other IDEs | `.mnemo/memory/` knowledge base (also visible at `.cursor/memory/`) | Point memory/context path to `.mnemo/memory/` |
+
+### 1) Cursor IDE 🟦
+
+1. Run installer in your project (`memory.ps1` or `memory_mac.sh`).
+2. For semantic tools, enable vector mode during install.
+3. Confirm `.mnemo/mcp/cursor.mcp.json` exists (and `.cursor/mcp.json` bridge is present).
+4. Restart Cursor.
+5. Run `vector_health` then `vector_sync`.
+
+You should see MCP tools:
+`vector_search`, `vector_sync`, `vector_forget`, `vector_health`, `memory_status`.
+
+### 2) Claude Code 🤝
+
+1. Run Mnemo install in your project root.
+2. Confirm `CLAUDE.md` exists (auto-generated by installer).
+3. Start Claude Code from the project root.
+4. Keep `.mnemo/memory/` committed so memory travels with the repo (Cursor still reads through bridge).
+
+### 3) Gemini Antigravity 🔷
+
+1. Run Mnemo install in your project root.
+2. Confirm `.agent/rules/memory-system.md` exists.
+3. Ensure your Antigravity setup loads `.agent/rules/`.
+4. (Optional) Enable vector mode for semantic memory workflows.
+
+### 4) OpenAI Codex 🧪
+
+1. Run Mnemo install in your project root.
+2. Confirm `AGENTS.md` exists.
+3. Launch Codex from the same root so `AGENTS.md` is used.
+4. Follow the retrieval order defined in `AGENTS.md`.
+
+### 5) Windsurf / Other IDEs 🌊
+
+1. Run Mnemo install in your project root.
+2. Point your IDE's memory/context config to `.mnemo/memory/` (or `.cursor/memory/` bridge).
+3. Reuse the same retrieval order:
+   `hot-rules.md` → `active-context.md` → `memo.md` → indexed lessons/digests.
+
+---
+
+## 🧠 What Mnemo gives you
+
+- **Always-read layer**: `.mnemo/memory/hot-rules.md`, `active-context.md`, `memo.md`
+- **Atomic lessons**: `.mnemo/memory/lessons/L-XXX-*.md` + generated lesson index
+- **Monthly journal + digests**: `.mnemo/memory/journal/YYYY-MM.md` + `.mnemo/memory/digests/*.digest.md`
+- **Rule enforcement**: `.mnemo/rules/cursor/00-memory-system.mdc` (bridged to `.cursor/rules/`)
+- **Helper scripts**: `scripts/memory/*` (rebuild, lint, query, add-lesson, add-journal-entry, clear-active)
+- **Optional SQLite FTS**: `.mnemo/memory/memory.sqlite` when Python is available
+- **Optional vector layer**: `scripts/memory/mnemo_vector.py` + MCP tools
+- **Optional autonomous runtime**: `scripts/memory/autonomy/*` (vector mode)
+
+## 🤖 Autonomous mode (no human in the loop)
+
+When installed with vector mode (`-EnableVector` / `--enable-vector`), Mnemo can run autonomously:
+
+| Component | Purpose |
+|---|---|
+| `autonomy/runner.py` | Orchestrates detect → ingest → lifecycle → journal delta |
+| `autonomy/ingest_pipeline.py` | Classifies/ingests changed memory content |
+| `autonomy/lifecycle_engine.py` | Fact ADD / UPDATE / DEPRECATE / NOOP with audit trail |
+| `autonomy/entity_resolver.py` | Stable entity IDs + alias mapping |
+| `autonomy/retrieval_router.py` | Intent routing to memory categories |
+| `autonomy/reranker.py` | Score fusion (semantic + authority + temporal + entity) |
+| `autonomy/context_safety.py` | Dedup, contradiction checks, token budget guard |
+| `autonomy/vault_policy.py` | Redaction/sensitivity policy enforcement |
+| `autonomy/policies.yaml` | Benchmark + safety thresholds |
+
+Runner triggers:
+- `post-commit` hook
+- `post-merge` / `post-checkout` hooks
+- `python runner.py --mode schedule`
+- `python runner.py --mode once`
+
+## 🗂️ Generated layout
+
+```text
+.mnemo/
+  memory/
+    hot-rules.md
+    active-context.md
+    memo.md
+    lessons/
+    journal/
+    digests/
+    adr/
+    templates/
+  rules/
+    cursor/
+      00-memory-system.mdc
+      01-vector-search.mdc   # vector mode only
+    agent/
+      memory-system.md
+  mcp/
+    cursor.mcp.json          # vector mode only
+
+.cursor/                     # permanent compatibility bridge
+  memory/
+  rules/
+  mcp.json                  # bridge to .mnemo/mcp/cursor.mcp.json
+
+.agent/                     # permanent compatibility bridge
+  rules/
+
+scripts/
+  memory/
+    rebuild-memory-index.ps1
+    lint-memory.ps1
+    query-memory.ps1
+    add-lesson.ps1
+    add-journal-entry.ps1
+    clear-active.ps1
+    mnemo_vector.py        # vector mode only
+    autonomy/              # vector mode only
+```
+
+## 🛠️ Helper scripts (quick reference)
+
+| Script | What it does |
+|---|---|
+| `rebuild-memory-index.ps1` | Rebuilds lesson/journal indexes and digests |
+| `lint-memory.ps1` | Validates frontmatter, tags, date headers, token budget |
+| `query-memory.ps1` | Searches memory via file search or SQLite FTS (`-UseSqlite`) |
+| `add-lesson.ps1` | Creates next `L-XXX` lesson with normalized tags |
+| `add-journal-entry.ps1` | Adds entry under current date in monthly journal |
+| `clear-active.ps1` | Resets `active-context.md` |
+| `mnemo_vector.py` | Vector sync/search MCP server (vector mode only) |
+
+## 🔐 Git hooks and API keys
+
+Mnemo auto-configures `core.hooksPath` to `.githooks` and installs:
+
+- `pre-commit`: rebuild + lint memory
+- `post-commit` (vector mode): non-blocking `vector_sync` with lock protection
+
+Important:
+- Cursor MCP tools read API keys from `.mnemo/mcp/cursor.mcp.json` env placeholders (`.cursor/mcp.json` stays bridged).
+- Git hooks read API keys from your shell environment.
+
+```sh
+# bash/zsh example
+export OPENAI_API_KEY="sk-..."
+# or
+export GEMINI_API_KEY="..."
+```
+
+## ✅ Recommended daily workflow
+
+1. Update `.mnemo/memory/active-context.md` at task start.
+2. Search first (`query-memory.ps1`) before opening many files.
+3. Use `vector_search` when keyword lookup misses.
+4. At finish: add journal entry, add lesson if needed, rebuild, clear active context.
+
+## 📋 Requirements
+
+- **PowerShell**: Windows PowerShell 5.1+ or PowerShell 7 (`pwsh`)
+- **Git**
+- **Optional**: Python 3 for SQLite FTS index
+- **Optional (vector mode)**:
+  - Python 3.10+
+  - API key: `OPENAI_API_KEY` or `GEMINI_API_KEY`
+  - Auto-installed deps: `openai`, `sqlite-vec`, `mcp[cli]>=1.2.0,<2.0` (+ `google-genai` for Gemini)
+
+## 🤝 Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Bug reports and feature requests use the issue templates in [.github/ISSUE_TEMPLATE/](.github/ISSUE_TEMPLATE/). Security issues go to [SECURITY.md](SECURITY.md).
+
+## 📄 License
+
+See [LICENSE](LICENSE).

package/VERSION

@@ -0,0 +1 @@
+0.0.1

package/bin/mnemo.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const packageRoot = path.resolve(__dirname, "..");
+const cwd = process.cwd();
+const rawArgs = process.argv.slice(2);
+const wantsHelp = rawArgs.includes("--help") || rawArgs.includes("-h");
+
+function printHelp() {
+  console.log(`Mnemo CLI
+
+Usage:
+  npx @dinasor/mnemo-cli@latest [options]
+
+Options:
+  --dry-run
+  --force
+  --enable-vector
+  --vector-provider <openai|gemini>
+  --project-name <name>
+  --repo-root <path>   (defaults to current directory)
+  --help
+`);
+}
+
+function fail(message) {
+  console.error(`[mnemo] ${message}`);
+  process.exit(1);
+}
+
+function mapWindowsArgs(args) {
+  const mapped = [];
+  let hasRepoRoot = false;
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+
+    if (arg === "--dry-run") {
+      mapped.push("-DryRun");
+      continue;
+    }
+    if (arg === "--force") {
+      mapped.push("-Force");
+      continue;
+    }
+    if (arg === "--enable-vector") {
+      mapped.push("-EnableVector");
+      continue;
+    }
+    if (arg === "--vector-provider") {
+      const value = args[i + 1];
+      if (!value) fail("Missing value for --vector-provider");
+      mapped.push("-VectorProvider", value);
+      i += 1;
+      continue;
+    }
+    if (arg === "--project-name") {
+      const value = args[i + 1];
+      if (!value) fail("Missing value for --project-name");
+      mapped.push("-ProjectName", value);
+      i += 1;
+      continue;
+    }
+    if (arg === "--repo-root") {
+      const value = args[i + 1];
+      if (!value) fail("Missing value for --repo-root");
+      mapped.push("-RepoRoot", value);
+      hasRepoRoot = true;
+      i += 1;
+      continue;
+    }
+
+    if (arg.toLowerCase() === "-reporoot") {
+      hasRepoRoot = true;
+    }
+    mapped.push(arg);
+  }
+
+  if (!hasRepoRoot && !wantsHelp) {
+    mapped.push("-RepoRoot", cwd);
+  }
+  return mapped;
+}
+
+function mapPosixArgs(args) {
+  const mapped = [];
+  let hasRepoRoot = false;
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    mapped.push(arg);
+
+    if (arg === "--repo-root") {
+      if (!args[i + 1]) fail("Missing value for --repo-root");
+      mapped.push(args[i + 1]);
+      hasRepoRoot = true;
+      i += 1;
+    }
+  }
+
+  if (!hasRepoRoot && !wantsHelp) {
+    mapped.push("--repo-root", cwd);
+  }
+  return mapped;
+}
+
+if (wantsHelp) {
+  printHelp();
+  process.exit(0);
+}
+
+if (process.platform === "win32") {
+  const installer = path.join(packageRoot, "memory.ps1");
+  if (!fs.existsSync(installer)) {
+    fail(`Installer not found at ${installer}`);
+  }
+
+  const args = [
+    "-ExecutionPolicy",
+    "Bypass",
+    "-File",
+    installer,
+    ...mapWindowsArgs(rawArgs)
+  ];
+  const result = spawnSync("powershell", args, { stdio: "inherit" });
+  process.exit(result.status ?? 1);
+}
+
+const installer = path.join(packageRoot, "memory_mac.sh");
+if (!fs.existsSync(installer)) {
+  fail(`Installer not found at ${installer}`);
+}
+const result = spawnSync("sh", [installer, ...mapPosixArgs(rawArgs)], {
+  stdio: "inherit"
+});
+process.exit(result.status ?? 1);

package/memory.ps1

@@ -0,0 +1,178 @@
+<#
+memory.ps1 - Mnemo Windows Installer (modular orchestrator)
+Windows-first, token-safe, scalable repo memory for AI coding agents.
+
+Version is read from VERSION file at repo root.
+
+Features:
+- Curated "always read" memory: hot-rules.md + active-context.md + memo.md
+- Atomic lessons (individual files) with strict YAML frontmatter
+- Monthly journal + auto-generated digest + journal index
+- Cursor rule (.mdc) to enforce behavior
+- Helper scripts: rebuild, query (SQLite+grep), lint, add-lesson, add-journal-entry
+- Tag validation against tag-vocabulary.md
+- BOM-tolerant parsing
+- Portable hooks via .githooks/ + .git/hooks/ (auto-configured)
+- Lint runs on pre-commit
+- Optional semantic vector layer (OpenAI / Gemini)
+- Autonomous memory runtime (no-human-in-the-loop) when EnableVector
+
+USAGE (from repo root):
+  powershell -ExecutionPolicy Bypass -File .\memory.ps1
+  powershell -ExecutionPolicy Bypass -File .\memory.ps1 -ProjectName "MyProject"
+  powershell -ExecutionPolicy Bypass -File .\memory.ps1 -Force
+  powershell -ExecutionPolicy Bypass -File .\memory.ps1 -DryRun
+  powershell -ExecutionPolicy Bypass -File .\memory.ps1 -EnableVector
+  powershell -ExecutionPolicy Bypass -File .\memory.ps1 -EnableVector -VectorProvider gemini
+#>
+
+[CmdletBinding()]
+param(
+  [string]$RepoRoot = (Get-Location).Path,
+  [string]$ProjectName = "",
+  [switch]$Force,
+  [switch]$DryRun,
+  [switch]$EnableVector,
+  [ValidateSet("openai","gemini")][string]$VectorProvider = "openai"
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+# Expose DryRun at script scope so modules can read it
+$script:DryRun = $DryRun.IsPresent
+
+# Read version from VERSION file (single source of truth)
+$InstallerRoot = Split-Path -Parent $MyInvocation.MyCommand.Path
+$_versionFile  = Join-Path $InstallerRoot "VERSION"
+$MnemoVersion  = if (Test-Path $_versionFile) { (Get-Content $_versionFile -Raw).Trim() } else { "0.0.0" }
+
+if ($DryRun) {
+  Write-Host "[DRY RUN] No files will be written. Showing what would happen." -ForegroundColor Cyan
+}
+
+# Bootstrap installer modules (dot-sources core + feature modules)
+. (Join-Path $InstallerRoot "scripts\memory\installer\bootstrap.ps1") -InstallerRoot $InstallerRoot
+
+# Resolve paths
+$RepoRoot = (Resolve-Path $RepoRoot).Path
+if ([string]::IsNullOrWhiteSpace($ProjectName)) {
+  $ProjectName = Split-Path -Leaf $RepoRoot
+}
+
+# Initialize path context
+$ctx = Initialize-MnemoPaths -RepoRoot $RepoRoot
+
+# Create directory structure
+foreach ($dir in $ctx.AllDirs) { New-MnemoDirectory -Path $dir }
+
+# Migrate legacy locations into canonical .mnemo store before scaffolding.
+if (-not $DryRun) {
+  $legacyPairs = @(
+    @{ Source = $ctx.CursorMemoryDir; Target = $ctx.MemoryDir; Label = ".cursor/memory -> .mnemo/memory" },
+    @{ Source = $ctx.CursorRulesDir;  Target = $ctx.RulesDir;  Label = ".cursor/rules -> .mnemo/rules/cursor" },
+    @{ Source = $ctx.AgentRulesDir;   Target = $ctx.MnemoRulesAgentDir; Label = ".agent/rules -> .mnemo/rules/agent" }
+  )
+  foreach ($pair in $legacyPairs) {
+    if (-not (Test-Path -LiteralPath $pair.Source)) { continue }
+    $sourceResolved = (Resolve-Path -LiteralPath $pair.Source -ErrorAction SilentlyContinue).Path
+    if ($sourceResolved -and (Test-MnemoPathEqual -A $sourceResolved -B $pair.Target)) { continue }
+    $copied = Copy-MnemoDirectoryContent -SourceDir $pair.Source -TargetDir $pair.Target
+    if ($copied -gt 0) {
+      Write-Host "Migrated $copied files ($($pair.Label))" -ForegroundColor Cyan
+    }
+  }
+}
+
+# Install memory content scaffold (hot-rules, memo, journal, rules, multi-agent bridges)
+Install-MemoryScaffold -Ctx $ctx -ProjectName $ProjectName -MnemoVersion $MnemoVersion -Force:$Force
+
+# Install helper scripts from templates (and autonomy modules if vector enabled)
+Install-MemoryScripts -Ctx $ctx -InstallerRoot $InstallerRoot -Force:$Force -EnableVector:$EnableVector -VectorProvider $VectorProvider
+
+# Vector engine setup (Python deps, installs mnemo_vector.py + autonomy modules)
+$vectorPython = $null
+if ($EnableVector) {
+  $vectorPython = Install-VectorEngine -Ctx $ctx -InstallerRoot $InstallerRoot -Force:$Force -VectorProvider $VectorProvider
+
+  if (-not $DryRun -and $null -ne $vectorPython) {
+    Install-McpConfig -Ctx $ctx -VectorPython $vectorPython -VectorProvider $VectorProvider -Force:$Force
+  }
+}
+
+# Git hooks (pre-commit lint/rebuild + optional post-commit vector sync)
+Install-GitHooks -Ctx $ctx -VectorPython $vectorPython -EnableVector:$EnableVector -Force:$Force
+
+# Bridge canonical .mnemo content into IDE integration locations.
+Ensure-MnemoCanonicalBridges -Ctx $ctx
+
+# Auto-configure portable hooks path (removes the manual 'git config' step)
+if (-not $DryRun -and (Test-Path $ctx.GitDir)) {
+  $currentHooksPath = & git -C $RepoRoot config core.hooksPath 2>$null
+  if ($currentHooksPath -ne ".githooks") {
+    & git -C $RepoRoot config core.hooksPath .githooks 2>$null
+    Write-Host "Configured: git config core.hooksPath .githooks" -ForegroundColor Green
+  }
+}
+
+# Token budget check
+Test-MnemoTokenBudget -Ctx $ctx
+
+# Auto-managed .gitignore block
+Update-MnemoGitignore -Ctx $ctx -EnableVector:$EnableVector
+
+# Setup complete
+Write-Host ""
+Write-Host "Setup complete. (Mnemo v$MnemoVersion)" -ForegroundColor Green
+Write-Host ""
+Write-Host "Memory system installed to: $($ctx.MemoryDir)" -ForegroundColor Cyan
+Write-Host "Cursor bridge path:        $($ctx.CursorMemoryDir)" -ForegroundColor DarkGray
+Write-Host ""
+Write-Host "Helper scripts:" -ForegroundColor Cyan
+Write-Host "  Add lesson:  scripts\memory\add-lesson.ps1 -Title ""..."" -Tags ""..."" -Rule ""...""" -ForegroundColor DarkGray
+Write-Host "  Add journal: scripts\memory\add-journal-entry.ps1 -Tags ""..."" -Title ""...""" -ForegroundColor DarkGray
+Write-Host "  Query:       scripts\memory\query-memory.ps1 -Query ""..."" [-UseSqlite]" -ForegroundColor DarkGray
+Write-Host "  Lint:        scripts\memory\lint-memory.ps1" -ForegroundColor DarkGray
+Write-Host "  Clear:       scripts\memory\clear-active.ps1" -ForegroundColor DarkGray
+Write-Host "  Rebuild:     scripts\memory\rebuild-memory-index.ps1" -ForegroundColor DarkGray
+Write-Host ""
+
+if ($EnableVector -and (-not $DryRun)) {
+  Write-Host "Vector tools enabled ($VectorProvider):" -ForegroundColor Cyan
+  Write-Host "  MCP tools: vector_search, vector_sync, vector_forget, vector_health, memory_status" -ForegroundColor DarkGray
+  Write-Host "  Rule: .cursor/rules/01-vector-search.mdc" -ForegroundColor DarkGray
+  Write-Host "  MCP:  .cursor/mcp.json -> MnemoVector server" -ForegroundColor DarkGray
+  Write-Host ""
+  Write-Host "Autonomous memory runtime:" -ForegroundColor Cyan
+  Write-Host "  Engine: scripts\memory\autonomy\runner.py" -ForegroundColor DarkGray
+  Write-Host "  Auto-triggers: post-commit, post-merge, post-checkout hooks" -ForegroundColor DarkGray
+  Write-Host ""
+  Write-Host "Important: export API key in your shell profile." -ForegroundColor Yellow
+  if ($VectorProvider -eq "gemini") {
+    Write-Host "  `$env:GEMINI_API_KEY = '<your-key>'" -ForegroundColor White
+  } else {
+    Write-Host "  `$env:OPENAI_API_KEY = '<your-key>'" -ForegroundColor White
+  }
+  Write-Host "  (MCP env in mcp.json is used by Cursor tools, not git hooks.)" -ForegroundColor DarkGray
+  Write-Host ""
+  Write-Host "Next steps:" -ForegroundColor Cyan
+  Write-Host "  1) Set API key environment variable" -ForegroundColor White
+  Write-Host "  2) Restart Cursor, then run: vector_health" -ForegroundColor White
+  Write-Host "  3) Run: vector_sync (first-time index build)" -ForegroundColor White
+  Write-Host "  4) Memory system is now autonomous (auto-syncs on every commit)" -ForegroundColor White
+} elseif ($EnableVector -and $DryRun) {
+  Write-Host "Vector tools previewed (dry run):" -ForegroundColor Cyan
+  Write-Host "  No dependencies installed and no MCP/hooks were modified." -ForegroundColor DarkGray
+  Write-Host ""
+} else {
+  Write-Host "Next steps:" -ForegroundColor Cyan
+  Write-Host "  1) Run: powershell -ExecutionPolicy Bypass -File scripts/memory/rebuild-memory-index.ps1" -ForegroundColor White
+  Write-Host "  2) Run: powershell -ExecutionPolicy Bypass -File scripts/memory/lint-memory.ps1" -ForegroundColor White
+  Write-Host "  3) Git hooks are pre-configured (auto-rebuilds on commit)" -ForegroundColor White
+  Write-Host "  4) For semantic search: re-run with -EnableVector [-VectorProvider gemini]" -ForegroundColor White
+}
+
+if ($DryRun) {
+  Write-Host ""
+  Write-Host "[DRY RUN] No changes were made." -ForegroundColor Cyan
+}