memorix 0.7.8 → 0.7.10

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.7.10] — 2026-02-24
+
+### Added
+- **Chinese README** (`README.zh-CN.md`) — Full bilingual documentation with language switcher at the top of both README files.
+- **Antigravity config guide** — Collapsible note in README Quick Start and updated `docs/SETUP.md` Antigravity section explaining the `MEMORIX_PROJECT_ROOT` requirement, why it's needed (cwd + MCP roots both unavailable), and how to configure it.
+- **Project detection priority documentation** — Clear detection chain (`--cwd` → `MEMORIX_PROJECT_ROOT` → `INIT_CWD` → `process.cwd()` → MCP roots → error) in README, SETUP.md, and troubleshooting section.
+
+## [0.7.9] — 2026-02-24
+
+### Fixed
+- **Dashboard auto-switch when project changes** — When the dashboard is already running (started from project A) and `memorix_dashboard` is called from project B, the dashboard server's current project is now updated via a `/api/set-current-project` POST request before opening the browser. Previously, the dashboard always showed the project it was initially started with; now it correctly switches to the calling project. Existing browser tabs will also show the correct project on the next page load/refresh.
+
+### Added
+- **MCP roots protocol support** — When the IDE's `cwd` is not a valid project (e.g., Antigravity sets cwd to `G:\Antigravity`), Memorix now automatically tries the MCP `roots/list` protocol to get the IDE's actual workspace path. This means standard MCP configs (`npx memorix@latest serve`) can work without `--cwd` in IDEs that support MCP roots. Falls back gracefully if the client doesn't support roots. Priority chain: `--cwd` > `MEMORIX_PROJECT_ROOT` > `INIT_CWD` > `process.cwd()` > **MCP roots** > error.
+
 ## [0.7.8] — 2026-02-24
 
 ### Fixed

package/README.md

@@ -2,6 +2,7 @@
   <img src="assets/logo.png" alt="Memorix Logo" width="120">
   <h1 align="center">Memorix</h1>
   <p align="center"><strong>Cross-Agent Memory Bridge — Your AI never forgets again</strong></p>
+  <p align="center"><a href="README.zh-CN.md">中文文档</a> | English</p>
   <p align="center">
     <a href="https://www.npmjs.com/package/memorix"><img src="https://img.shields.io/npm/v/memorix.svg?style=flat-square&color=cb3837" alt="npm version"></a>
     <a href="https://www.npmjs.com/package/memorix"><img src="https://img.shields.io/npm/dm/memorix.svg?style=flat-square&color=blue" alt="npm downloads"></a>
@@ -62,10 +63,33 @@ Add this to your agent's MCP config file, restart — done:
 ```
 
 > 📖 **Where is my config file?** → [Full setup guide for all 7 agents](docs/SETUP.md)
-> Windsurf • Cursor • Claude Code • Codex • VS Code Copilot • Antigravity • Kiro
+> Windsurf • Cursor • Claude Code • Codex • VS Code Copilot • Kiro • Antigravity
 
 That's it. No API keys. No cloud accounts. No dependencies. Just works.
 
+<details>
+<summary>⚠️ <strong>Antigravity users: extra config required</strong></summary>
+
+Antigravity sets its working directory to its own install path (e.g., `G:\Antigravity`) instead of your project directory, and does not support the MCP roots protocol. You **must** add `MEMORIX_PROJECT_ROOT`:
+
+```json
+{
+  "mcpServers": {
+    "memorix": {
+      "command": "npx",
+      "args": ["-y", "memorix@latest", "serve"],
+      "env": {
+        "MEMORIX_PROJECT_ROOT": "E:/your/project/path"
+      }
+    }
+  }
+}
+```
+
+You'll need to update `MEMORIX_PROJECT_ROOT` when switching projects. All other IDEs work without this.
+
+</details>
+
 ---
 
 ## 🎬 Real-World Scenarios
@@ -259,10 +283,13 @@ With vector search, queries like "authentication" also match memories about "log
 ## 🔒 Project Isolation
 
 - **Auto-detected** — Project identity from `git remote` URL, zero config needed
+- **MCP roots fallback** — If `cwd` is not a project (e.g., Antigravity), Memorix tries the [MCP roots protocol](https://modelcontextprotocol.io/docs/concepts/roots) to get your workspace path from the IDE
 - **Per-project storage** — `~/.memorix/data/<owner--repo>/` per project
 - **Scoped search** — Defaults to current project; `scope: "global"` to search all
 - **Zero cross-contamination** — Project A's decisions never leak into project B
 
+**Detection priority:** `--cwd` → `MEMORIX_PROJECT_ROOT` → `INIT_CWD` → `process.cwd()` → MCP roots → error
+
 ---
 
 ## ❓ Frequently Asked Questions

package/README.zh-CN.md

@@ -0,0 +1,360 @@
+<p align="center">
+  <img src="assets/logo.png" alt="Memorix Logo" width="120">
+  <h1 align="center">Memorix</h1>
+  <p align="center"><strong>跨 Agent 记忆桥梁 — 让你的 AI 再也不会忘记</strong></p>
+  <p align="center">中文文档 | <a href="README.md">English</a></p>
+  <p align="center">
+    <a href="https://www.npmjs.com/package/memorix"><img src="https://img.shields.io/npm/v/memorix.svg?style=flat-square&color=cb3837" alt="npm version"></a>
+    <a href="https://www.npmjs.com/package/memorix"><img src="https://img.shields.io/npm/dm/memorix.svg?style=flat-square&color=blue" alt="npm downloads"></a>
+    <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-green.svg?style=flat-square" alt="License"></a>
+    <a href="https://github.com/AVIDS2/memorix"><img src="https://img.shields.io/github/stars/AVIDS2/memorix?style=flat-square&color=yellow" alt="GitHub stars"></a>
+    <img src="https://img.shields.io/badge/tests-422%20passed-brightgreen?style=flat-square" alt="Tests">
+  </p>
+  <p align="center">
+    <img src="https://img.shields.io/badge/Works%20with-Cursor-orange?style=flat-square" alt="Cursor">
+    <img src="https://img.shields.io/badge/Works%20with-Windsurf-blue?style=flat-square" alt="Windsurf">
+    <img src="https://img.shields.io/badge/Works%20with-Claude%20Code-purple?style=flat-square" alt="Claude Code">
+    <img src="https://img.shields.io/badge/Works%20with-Codex-green?style=flat-square" alt="Codex">
+    <img src="https://img.shields.io/badge/Works%20with-Copilot-lightblue?style=flat-square" alt="Copilot">
+    <img src="https://img.shields.io/badge/Works%20with-Kiro-red?style=flat-square" alt="Kiro">
+    <img src="https://img.shields.io/badge/Works%20with-Antigravity-grey?style=flat-square" alt="Antigravity">
+  </p>
+  <p align="center">
+    <a href="#-别再反复解释你的项目了">痛点</a> •
+    <a href="#-30-秒快速开始">快速开始</a> •
+    <a href="#-真实使用场景">场景</a> •
+    <a href="#-memorix-能做什么">功能</a> •
+    <a href="#-与同类工具对比">对比</a> •
+    <a href="docs/SETUP.md">完整配置指南</a>
+  </p>
+</p>
+
+---
+
+## 😤 别再反复解释你的项目了
+
+你的 AI 助手每次新对话都会忘记一切。你要花 10 分钟重新解释架构。**又一次。** 如果从 Cursor 切到 Claude Code？所有上下文全部丢失。**又一次。**
+
+| 没有 Memorix | 有 Memorix |
+|-------------|-----------|
+| **第 2 次对话：** "我们的技术栈是什么？" | **第 2 次对话：** "我记得——Next.js + Prisma + tRPC。接下来做什么？" |
+| **切换 IDE：** 全部上下文丢失 | **切换 IDE：** 上下文立即跟随 |
+| **新同事的 AI：** 从零开始 | **新同事的 AI：** 已了解整个代码库 |
+| **50 次工具调用后：** 上下文爆炸，需要重开 | **重开后：** 无缝恢复到上次状态 |
+| **MCP 配置：** 在 7 个 IDE 之间手动复制粘贴 | **MCP 配置：** 一条命令全部同步 |
+
+**Memorix 解决所有这些问题。** 一个 MCP 服务器。七个 Agent。零上下文丢失。
+
+---
+
+## ⚡ 30 秒快速开始
+
+在你的 Agent 的 MCP 配置文件中添加以下内容，重启即可：
+
+```json
+{
+  "mcpServers": {
+    "memorix": {
+      "command": "npx",
+      "args": ["-y", "memorix@latest", "serve"]
+    }
+  }
+}
+```
+
+> 📖 **配置文件在哪里？** → [7 个 Agent 的完整配置指南](docs/SETUP.md)
+> Windsurf • Cursor • Claude Code • Codex • VS Code Copilot • Kiro • Antigravity
+
+就是这样。不需要 API Key，不需要云账号，不需要额外依赖。开箱即用。
+
+<details>
+<summary>⚠️ <strong>Antigravity 用户：需要额外配置</strong></summary>
+
+Antigravity 会将工作目录设为自身安装路径（如 `G:\Antigravity`），而不是你的项目目录，且不支持 MCP roots 协议。你**必须**添加 `MEMORIX_PROJECT_ROOT`：
+
+```json
+{
+  "mcpServers": {
+    "memorix": {
+      "command": "npx",
+      "args": ["-y", "memorix@latest", "serve"],
+      "env": {
+        "MEMORIX_PROJECT_ROOT": "E:/your/project/path"
+      }
+    }
+  }
+}
+```
+
+切换项目时需要更新 `MEMORIX_PROJECT_ROOT`。其他所有 IDE 都不需要这个配置。
+
+</details>
+
+---
+
+## 🎬 真实使用场景
+
+### 场景 1：跨会话记忆
+
+```
+周一早上 — 你和 Cursor 讨论认证架构：
+  你: "用 JWT + refresh token，15 分钟过期"
+  → Memorix 自动存储为 🟤 决策
+
+周二 — 新的 Cursor 会话：
+  你: "添加登录接口"
+  → AI 调用 memorix_search("auth") → 找到周一的决策
+  → "好的，我按之前的决策用 JWT + 15 分钟 refresh token 来实现"
+  → 零重复解释！
+```
+
+### 场景 2：跨 Agent 协作
+
+```
+你用 Windsurf 写后端，用 Claude Code 做代码审查：
+
+  Windsurf: 你修复了支付模块的一个竞态条件
+  → Memorix 存储为 🟡 问题-解决方案，包含修复细节
+
+  Claude Code: "审查支付模块"
+  → AI 调用 memorix_search("payment") → 找到竞态条件修复
+  → "我看到最近有个竞态条件修复，让我确认一下是否正确..."
+  → 知识在 Agent 之间无缝流转！
+```
+
+### 场景 3：踩坑预防
+
+```
+第 1 周: 你遇到一个 Windows 路径分隔符 bug
+  → Memorix 存储为 🔴 gotcha："用 path.join()，永远不要字符串拼接"
+
+第 3 周: AI 正要写 `baseDir + '/' + filename`
+  → 会话启动 hook 已将 gotcha 注入到上下文中
+  → AI 改写为 `path.join(baseDir, filename)`
+  → bug 在发生前就被阻止了！
+```
+
+### 场景 4：跨 IDE 工作区同步
+
+```
+你在 Cursor 里配置了 12 个 MCP 服务器。
+现在想试试 Kiro。
+
+  你: "把我的工作区同步到 Kiro"
+  → memorix_workspace_sync 扫描 Cursor 的 MCP 配置
+  → 生成 Kiro 兼容的 .kiro/settings/mcp.json
+  → 同时同步你的规则、技能和工作流
+  → Kiro 几秒内就绑定好了，不用花几个小时！
+```
+
+### 场景 5：自动生成项目技能
+
+```
+开发两周后，你有了 50+ 条观察记录：
+  - 8 个关于 Windows 路径问题的 gotcha
+  - 5 个关于认证模块的决策
+  - 3 个数据库迁移的问题-解决方案
+
+  你: "生成项目技能"
+  → memorix_skills 按实体聚类观察记录
+  → 自动生成 SKILL.md 文件：
+    - "auth-module-guide.md" — JWT 设置、刷新流程、常见陷阱
+    - "database-migrations.md" — Prisma 模式、回滚策略
+  → 同步技能到任何 Agent：Cursor、Claude Code、Kiro...
+  → 新同事的 AI 立即掌握你项目的最佳实践！
+```
+
+---
+
+## 🧠 Memorix 能做什么
+
+### 智能记忆（17 个 MCP 工具）
+
+| 你说的 | Memorix 做的 |
+|--------|-------------|
+| "记住这个架构决策" | `memorix_store` — 分类为 🟤 决策，提取实体，创建图关系 |
+| "我们之前关于认证决定了什么？" | `memorix_search` → `memorix_detail` — 3 层渐进式展示，节省约 10 倍 token |
+| "那个 bug 修复前后发生了什么？" | `memorix_timeline` — 按时间显示前后上下文 |
+| "显示知识图谱" | `memorix_dashboard` — 打开交互式 Web UI，含 D3.js 图谱 |
+| "哪些记忆快过期了？" | `memorix_retention` — 指数衰减评分，识别归档候选 |
+
+### 跨 Agent 工作区同步
+
+| 你说的 | Memorix 做的 |
+|--------|-------------|
+| "把 MCP 服务器同步到 Kiro" | `memorix_workspace_sync` — 迁移配置，合并（永不覆盖） |
+| "检查我的 Agent 规则" | `memorix_rules_sync` — 扫描 7 个 Agent，去重，检测冲突 |
+| "为 Cursor 生成规则" | `memorix_rules_sync` — 跨格式转换（`.mdc` ↔ `CLAUDE.md` ↔ `.kiro/steering/`） |
+| "生成项目技能" | `memorix_skills` — 从观察模式创建 SKILL.md |
+| "注入认证技能" | `memorix_skills` — 将技能内容直接返回到 Agent 上下文 |
+
+### 知识图谱（兼容 MCP 官方接口）
+
+| 工具 | 功能 |
+|------|-----|
+| `create_entities` | 构建项目知识图谱 |
+| `create_relations` | 用类型化边连接实体（causes、fixes、depends_on） |
+| `add_observations` | 将观察附加到实体 |
+| `search_nodes` / `open_nodes` | 查询图谱 |
+| `read_graph` | 导出完整图谱用于可视化 |
+
+> **即插即用**，兼容 [MCP 官方 Memory Server](https://github.com/modelcontextprotocol/servers/tree/main/src/memory) — 相同 API，更多功能。
+
+### 9 种观察类型
+
+每条记忆都有分类标签，用于智能检索：
+
+| 图标 | 类型 | 使用场景 |
+|------|------|---------|
+| 🎯 | `session-request` | 本次会话的原始任务/目标 |
+| 🔴 | `gotcha` | 关键陷阱 — "永远不要做 X，因为 Y" |
+| 🟡 | `problem-solution` | bug 修复，含根因和解决方案 |
+| 🔵 | `how-it-works` | 系统的技术解释 |
+| 🟢 | `what-changed` | 代码/配置变更记录 |
+| 🟣 | `discovery` | 新的洞见或发现 |
+| 🟠 | `why-it-exists` | 设计选择背后的原因 |
+| 🟤 | `decision` | 架构/设计决策 |
+| ⚖️ | `trade-off` | 取舍权衡，含利弊分析 |
+
+### 可视化 Dashboard
+
+运行 `memorix_dashboard` 在 `http://localhost:3210` 打开 Web UI：
+
+- **交互式知识图谱** — D3.js 力导向图，可视化实体和关系
+- **观察浏览器** — 按类型筛选，高亮搜索，展开/折叠详情
+- **记忆衰减面板** — 查看哪些记忆活跃、过期或待归档
+- **项目切换器** — 无需切换 IDE 即可查看任何项目的数据
+- **批量清理** — 自动检测并批量删除低质量观察
+- **明暗主题** — 玻璃拟态设计，中英双语界面
+
+### 自动记忆 Hook
+
+Memorix 可以**自动捕获**编码会话中的决策、错误和踩坑经验：
+
+```bash
+memorix hooks install    # 一条命令安装
+```
+
+- **隐式记忆** — 检测 "I decided to..."、"bug 是因为..."、"永远不要用 X" 等模式
+- **会话启动注入** — 自动将近期高价值记忆加载到 Agent 上下文
+- **多语言** — 支持英文 + 中文关键词匹配
+- **智能过滤** — 30 秒冷却，跳过无关命令（ls、cat、pwd）
+
+---
+
+## 📊 与同类工具对比
+
+| | [Mem0](https://github.com/mem0ai/mem0) | [mcp-memory-service](https://github.com/doobidoo/mcp-memory-service) | [claude-mem](https://github.com/anthropics/claude-code) | **Memorix** |
+|---|---|---|---|---|
+| **支持的 Agent** | SDK 集成 | 13+（MCP） | 仅 Claude Code | **7 个 IDE（MCP）** |
+| **跨 Agent 同步** | 否 | 否 | 否 | **是（配置、规则、技能、工作流）** |
+| **规则同步** | 否 | 否 | 否 | **是（7 种格式）** |
+| **技能引擎** | 否 | 否 | 否 | **是（从记忆自动生成）** |
+| **知识图谱** | 否 | 是 | 否 | **是（兼容 MCP 官方）** |
+| **混合搜索** | 否 | 是 | 否 | **是（BM25 + 向量）** |
+| **Token 高效** | 否 | 否 | 是（3 层） | **是（3 层渐进式展示）** |
+| **自动记忆 Hook** | 否 | 否 | 是 | **是（多语言）** |
+| **记忆衰减** | 否 | 是 | 否 | **是（指数衰减 + 豁免）** |
+| **可视化面板** | 云端 UI | 是 | 否 | **是（Web UI + D3.js 图谱）** |
+| **隐私** | 云端 | 本地 | 本地 | **100% 本地** |
+| **费用** | 按量付费 | $0 | $0 | **$0** |
+| **安装** | `pip install` | `pip install` | 内置于 Claude | **`npx memorix serve`** |
+
+**Memorix 是唯一同时桥接记忆和工作区跨 Agent 共享的工具。**
+
+---
+
+## 🔮 可选：向量搜索
+
+开箱即用，Memorix 使用 BM25 全文搜索（对代码已经足够好）。一条命令添加语义搜索：
+
+```bash
+# 方案 A：原生速度（推荐）
+npm install -g fastembed
+
+# 方案 B：通用兼容
+npm install -g @huggingface/transformers
+```
+
+有了向量搜索，"authentication" 这样的查询也能匹配到关于 "login flow" 的记忆。两种方案都 **100% 本地运行** — 零 API 调用，零费用。
+
+---
+
+## 🔒 项目隔离
+
+- **自动检测** — 通过 `git remote` URL 识别项目，零配置
+- **MCP roots 回退** — 如果 `cwd` 不是项目目录（如 Antigravity），Memorix 会尝试 [MCP roots 协议](https://modelcontextprotocol.io/docs/concepts/roots) 从 IDE 获取工作区路径
+- **按项目存储** — `~/.memorix/data/<owner--repo>/` 每个项目独立
+- **作用域搜索** — 默认搜索当前项目；`scope: "global"` 搜索所有项目
+- **零交叉污染** — 项目 A 的决策永远不会泄漏到项目 B
+
+**检测优先级：** `--cwd` → `MEMORIX_PROJECT_ROOT` → `INIT_CWD` → `process.cwd()` → MCP roots → 报错
+
+---
+
+## ❓ 常见问题
+
+**在 Cursor 和 Claude Code 之间切换时如何保持上下文？**
+在两个 IDE 都安装 Memorix。它们共享相同的本地记忆目录 — 在 Cursor 中做的架构决策在 Claude Code 中立即可搜索，无需云同步。
+
+**如何防止 AI 忘记之前的会话？**
+Memorix 将观察记录持久存储在磁盘上。下次会话，AI 调用 `memorix_search` 即可检索之前的决策、踩坑和知识。配合自动记忆 Hook，甚至可以自动捕获上下文。
+
+**如何在 IDE 之间同步 MCP 服务器配置？**
+运行 `memorix_workspace_sync`，设置 action 为 `"migrate"`，指定目标 IDE。它会扫描源配置并生成兼容的目标配置 — 合并，永不覆盖。
+
+**如何从 Cursor 迁移到 Windsurf / Kiro / Claude Code？**
+Memorix 工作区同步可以迁移 MCP 配置、Agent 规则（`.mdc` ↔ `CLAUDE.md` ↔ `.kiro/steering/`）、技能和工作流。一条命令，几秒完成。
+
+**有没有用于持久 AI 编码记忆的 MCP 服务器？**
+有 — Memorix 是一个跨 Agent 记忆 MCP 服务器，支持 7 个 IDE，提供知识图谱、3 层渐进式搜索、工作区同步和自动生成项目技能。
+
+**和 mcp-memory-service 有什么区别？**
+两个都是优秀的记忆服务器。Memorix 额外提供：跨 Agent 工作区同步（MCP 配置、规则、技能）、从记忆模式自动生成项目技能、3 层 token 高效搜索、会话启动记忆注入 Hook。
+
+**支持离线/本地运行吗？**
+完全支持。所有数据存储在 `~/.memorix/data/`。无云端，无 API Key，无外部服务。可选的向量搜索也通过 ONNX/WASM 本地运行。
+
+> 📖 AI 系统参考：查看 [`llms.txt`](llms.txt) 和 [`llms-full.txt`](llms-full.txt) 获取机器可读的项目文档。
+
+---
+
+## 🧑‍💻 开发
+
+```bash
+git clone https://github.com/AVIDS2/memorix.git
+cd memorix
+npm install
+
+npm run dev          # tsup 监听模式
+npm test             # vitest（422 个测试）
+npm run lint         # TypeScript 类型检查
+npm run build        # 生产构建
+```
+
+> 📚 **文档：** [架构设计](docs/ARCHITECTURE.md) • [API 参考](docs/API_REFERENCE.md) • [模块说明](docs/MODULES.md) • [设计决策](docs/DESIGN_DECISIONS.md) • [配置指南](docs/SETUP.md) • [已知问题与路线图](docs/KNOWN_ISSUES_AND_ROADMAP.md)
+
+---
+
+## 🙏 致谢
+
+Memorix 站在这些优秀项目的肩膀上：
+
+- [mcp-memory-service](https://github.com/doobidoo/mcp-memory-service) — 混合搜索、指数衰减、访问追踪
+- [MemCP](https://github.com/maydali28/memcp) — MAGMA 四图、实体提取、保留生命周期
+- [claude-mem](https://github.com/anthropics/claude-code) — 3 层渐进式展示
+- [Mem0](https://github.com/mem0ai/mem0) — 记忆层架构模式
+
+---
+
+## 📄 许可证
+
+Apache 2.0 — 详见 [LICENSE](LICENSE)
+
+---
+
+<p align="center">
+  <strong>Made with ❤️ by <a href="https://github.com/AVIDS2">AVIDS2</a></strong>
+  <br>
+  <sub>如果 Memorix 对你有帮助，欢迎在 GitHub 上给个 ⭐！</sub>
+</p>

package/dist/cli/index.js

@@ -4412,13 +4412,47 @@ function openBrowser(url) {
   exec(cmd, () => {
   });
 }
+function readBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
 async function startDashboard(dataDir, port, staticDir, projectId, projectName, autoOpen = true) {
   const resolvedStaticDir = staticDir;
   const baseDir = getBaseDataDir();
+  const state = { projectId, projectName, dataDir };
   const server = createServer(async (req, res) => {
     const url = req.url || "/";
+    if (url.startsWith("/api/set-current-project") && req.method === "POST") {
+      try {
+        const body = JSON.parse(await readBody(req));
+        if (body.projectId) {
+          const sanitized = body.projectId.replace(/\//g, "--").replace(/[<>:"|?*\\]/g, "_");
+          const candidateDir = path6.join(baseDir, sanitized);
+          try {
+            await fs4.access(candidateDir);
+          } catch {
+            sendError(res, `Project data directory not found: ${candidateDir}`, 404);
+            return;
+          }
+          state.projectId = body.projectId;
+          state.projectName = body.projectName || body.projectId.split("/").pop() || body.projectId;
+          state.dataDir = candidateDir;
+          console.error(`[dashboard] Switched current project to: ${state.projectId}`);
+          sendJson(res, { ok: true, projectId: state.projectId, projectName: state.projectName });
+        } else {
+          sendError(res, "Missing projectId in body", 400);
+        }
+      } catch {
+        sendError(res, "Invalid JSON body", 400);
+      }
+      return;
+    }
     if (url.startsWith("/api/")) {
-      await handleApi(req, res, dataDir, projectId, projectName, baseDir);
+      await handleApi(req, res, state.dataDir, state.projectId, state.projectName, baseDir);
     } else {
       await serveStatic(req, res, resolvedStaticDir);
     }
@@ -4474,7 +4508,7 @@ __export(server_exports2, {
 import { watch } from "fs";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
-async function createMemorixServer(cwd) {
+async function createMemorixServer(cwd, existingServer) {
   const project = detectProject(cwd);
   if (project.id === "__invalid__") {
     const resolvedCwd = cwd ?? process.cwd();
@@ -4586,7 +4620,7 @@ async function createMemorixServer(cwd) {
   } catch {
     console.error(`[memorix] Warning: could not watch observations file for hot-reload`);
   }
-  const server = new McpServer({
+  const server = existingServer ?? new McpServer({
     name: "memorix",
     version: "0.1.0"
   });
@@ -5248,13 +5282,27 @@ ${skill.content}` }]
           }, 1e3);
         });
         if (isAlive) {
+          const http = await import("http");
+          const postData = JSON.stringify({ projectId: project.id, projectName: project.name });
+          await new Promise((resolve2) => {
+            const req = http.request({
+              hostname: "127.0.0.1",
+              port: portNum,
+              path: "/api/set-current-project",
+              method: "POST",
+              headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(postData) }
+            }, () => resolve2());
+            req.on("error", () => resolve2());
+            req.write(postData);
+            req.end();
+          });
           const projectUrl = `${url}?project=${encodeURIComponent(project.id)}`;
           const { exec: exec2 } = await import("child_process");
           const cmd = process.platform === "win32" ? `start "" "${projectUrl}"` : process.platform === "darwin" ? `open "${projectUrl}"` : `xdg-open "${projectUrl}"`;
           exec2(cmd, () => {
           });
           return {
-            content: [{ type: "text", text: `Dashboard is already running at ${url}. Opened in browser for project: ${project.name} (${project.id}).` }]
+            content: [{ type: "text", text: `Dashboard is already running at ${url}. Switched to project: ${project.name} (${project.id}).` }]
           };
         }
         console.error("[memorix] Dashboard process no longer running, restarting...");
@@ -5389,14 +5437,52 @@ var init_serve = __esm({
       },
       run: async ({ args }) => {
         const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+        const { McpServer: McpServer2 } = await import("@modelcontextprotocol/sdk/server/mcp.js");
         const { createMemorixServer: createMemorixServer2 } = await Promise.resolve().then(() => (init_server2(), server_exports2));
-        const projectRoot = args.cwd || process.env.MEMORIX_PROJECT_ROOT || process.env.INIT_CWD || process.cwd();
+        const { detectProject: detectProject2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
+        let projectRoot = args.cwd || process.env.MEMORIX_PROJECT_ROOT || process.env.INIT_CWD || process.cwd();
         console.error(`[memorix] Starting with cwd: ${projectRoot}`);
-        const { server, projectId } = await createMemorixServer2(projectRoot);
-        const transport = new StdioServerTransport();
-        await server.connect(transport);
-        console.error(`[memorix] MCP Server running on stdio (project: ${projectId})`);
-        console.error(`[memorix] Project root: ${projectRoot}`);
+        const earlyDetect = detectProject2(projectRoot);
+        const needsRoots = earlyDetect.id === "__invalid__" || earlyDetect.id.startsWith("local/");
+        if (needsRoots) {
+          console.error(`[memorix] cwd is not a valid project, trying MCP roots protocol...`);
+          const mcpServer = new McpServer2({ name: "memorix", version: "0.1.0" });
+          const transport = new StdioServerTransport();
+          await mcpServer.connect(transport);
+          let rootResolved = false;
+          try {
+            const rootsResult = await Promise.race([
+              mcpServer.server.listRoots(),
+              new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), 5e3))
+            ]);
+            if (rootsResult && "roots" in rootsResult && Array.isArray(rootsResult.roots) && rootsResult.roots.length > 0) {
+              const rootUri = rootsResult.roots[0].uri;
+              if (rootUri.startsWith("file://")) {
+                const urlPath = decodeURIComponent(new URL(rootUri).pathname);
+                const normalizedPath = process.platform === "win32" && urlPath.match(/^\/[A-Za-z]:/) ? urlPath.slice(1) : urlPath;
+                console.error(`[memorix] MCP client root: ${normalizedPath}`);
+                projectRoot = normalizedPath;
+                rootResolved = true;
+              }
+            }
+          } catch {
+            console.error(`[memorix] MCP roots not available (client may not support it)`);
+          }
+          if (!rootResolved && earlyDetect.id === "__invalid__") {
+            console.error(`[memorix] ERROR: Could not detect a valid project.`);
+            console.error(`[memorix] Fix: set --cwd or MEMORIX_PROJECT_ROOT, or use an IDE that supports MCP roots.`);
+            process.exit(1);
+          }
+          const { projectId } = await createMemorixServer2(projectRoot, mcpServer);
+          console.error(`[memorix] MCP Server running on stdio (project: ${projectId})`);
+          console.error(`[memorix] Project root: ${projectRoot}`);
+        } else {
+          const { server, projectId } = await createMemorixServer2(projectRoot);
+          const transport = new StdioServerTransport();
+          await server.connect(transport);
+          console.error(`[memorix] MCP Server running on stdio (project: ${projectId})`);
+          console.error(`[memorix] Project root: ${projectRoot}`);
+        }
       }
     });
   }