memorix 0.5.1 → 0.6.0

package/README.md

@@ -1,5 +1,6 @@
 <p align="center">
-  <h1 align="center">🧠 Memorix</h1>
+  <img src="assets/logo.png" alt="Memorix Logo" width="120">
+  <h1 align="center">Memorix</h1>
   <p align="center"><strong>Cross-Agent Memory Bridge — Universal memory layer for AI coding agents via MCP</strong></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>
@@ -19,9 +20,9 @@
 
 ---
 
-> **Your AI forgot what you discussed yesterday? Not anymore.**
+> **One project, six agents, zero context loss.**
 >
-> Memorix stores and indexes project knowledge — architecture decisions, bug fixes, gotchas, code patterns — and exposes it via [MCP](https://modelcontextprotocol.io/) so **any AI coding agent** can access it. It also **syncs MCP configs, rules, skills, and workflows** across all your agents automatically.
+> Memorix is a **cross-agent memory bridge** — it lets Cursor, Windsurf, Claude Code, Codex, Copilot, and Antigravity **share the same project knowledge** in real-time. Architecture decisions made in one IDE are instantly available in another. Switch tools, open new windows, start fresh sessions — your context follows you everywhere via [MCP](https://modelcontextprotocol.io/). It also **syncs MCP configs, rules, skills, and workflows** across all your agents automatically.
 
 ---
 
@@ -98,6 +99,22 @@ Then use `"command": "memorix"` instead of `"command": "npx"` in your config.
 - **Skills & Workflows** — Copy skill folders and workflow files across agents
 - **Apply with Safety** — Backup `.bak` → Atomic write → Auto-rollback on failure
 
+### 🔒 Project Isolation
+
+- **Per-Project Data** — Each project stores data in its own directory (`~/.memorix/data/<owner--repo>/`)
+- **Git-Based Detection** — Project identity derived from `git remote`, no manual config needed
+- **Scoped Search** — `memorix_search` defaults to current project; set `scope: "global"` to search all
+- **Auto Migration** — Legacy global data automatically migrates to project directories on first run
+- **Zero Cross-Contamination** — Architecture decisions from project A never leak into project B
+
+### 📊 Visual Dashboard
+
+- **Web Dashboard** — `memorix_dashboard` opens a beautiful web UI at `http://localhost:3210`
+- **Project Switcher** — Dropdown to view any project's data without switching IDEs
+- **Knowledge Graph** — Interactive visualization of entities and relations
+- **Retention Scores** — Exponential decay scoring with immunity status
+- **Light/Dark Theme** — Premium glassmorphism design, bilingual (EN/中文)
+
 ### 🪝 Auto-Memory Hooks
 
 - **Implicit Memory** — Auto-captures decisions, errors, gotchas from agent activity
@@ -199,7 +216,8 @@ args = ["-y", "memorix@latest", "serve"]
 | `memorix_search` | L1: Compact index search | ~50-100/result |
 | `memorix_timeline` | L2: Chronological context | ~100-200/group |
 | `memorix_detail` | L3: Full observation details | ~500-1000/result |
-| `memorix_retention` | Memory decay & retention dashboard | — |
+| `memorix_retention` | Memory decay & retention status | — |
+| `memorix_dashboard` | Launch visual web dashboard in browser | — |
 | `memorix_rules_sync` | Scan/deduplicate/generate rules across agents | — |
 | `memorix_workspace_sync` | Migrate MCP configs, workflows, skills | — |
 
@@ -266,7 +284,7 @@ Files: ["src/auth/jwt.ts", "src/config.ts"]
 └────────────────────────┬─────────────────────────────────────┘
                          │ MCP Protocol (stdio)
 ┌────────────────────────▼─────────────────────────────────────┐
-│                 Memorix MCP Server (16 tools)                │
+│                 Memorix MCP Server (17 tools)                │
 │                                                              │
 │  ┌─────────────┐  ┌──────────────┐  ┌──────────────────┐   │
 │  │   Memory     │  │   Compact    │  │  Workspace Sync  │   │
@@ -340,7 +358,7 @@ npm run build        # Production build
 
 ```
 src/
-├── server.ts              # MCP Server entry (16 tools)
+├── server.ts              # MCP Server entry (17 tools)
 ├── types.ts               # All type definitions
 ├── memory/                # Graph, observations, retention, entity extraction
 ├── store/                 # Orama search engine + disk persistence
@@ -349,8 +367,9 @@ src/
 ├── hooks/                 # Auto-memory hooks (normalizer + pattern detector)
 ├── workspace/             # Cross-agent MCP/workflow/skills sync
 ├── rules/                 # Cross-agent rules sync (6 adapters)
+├── dashboard/             # Visual web dashboard (knowledge graph, stats)
 ├── project/               # Git-based project detection
-└── cli/                   # CLI commands (serve, hook, sync, status)
+└── cli/                   # CLI commands (serve, hook, sync, dashboard)
 ```
 
 > 📚 Full documentation available in [`docs/`](./docs/) — architecture, modules, API reference, design decisions, and more.

package/dist/cli/index.js

@@ -31,13 +31,16 @@ var init_esm_shims = __esm({
 // src/store/persistence.ts
 var persistence_exports = {};
 __export(persistence_exports, {
+  getBaseDataDir: () => getBaseDataDir,
   getDbFilePath: () => getDbFilePath,
   getGraphFilePath: () => getGraphFilePath,
   getProjectDataDir: () => getProjectDataDir,
   hasExistingData: () => hasExistingData,
+  listProjectDirs: () => listProjectDirs,
   loadGraphJsonl: () => loadGraphJsonl,
   loadIdCounter: () => loadIdCounter,
   loadObservationsJson: () => loadObservationsJson,
+  migrateGlobalData: () => migrateGlobalData,
   saveGraphJsonl: () => saveGraphJsonl,
   saveIdCounter: () => saveIdCounter,
   saveObservationsJson: () => saveObservationsJson
@@ -45,11 +48,105 @@ __export(persistence_exports, {
 import { promises as fs } from "fs";
 import path2 from "path";
 import os from "os";
+function sanitizeProjectId(projectId) {
+  return projectId.replace(/\//g, "--").replace(/[<>:"|?*\\]/g, "_");
+}
 async function getProjectDataDir(projectId, baseDir) {
-  const dataDir = baseDir ?? DEFAULT_DATA_DIR;
+  const base = baseDir ?? DEFAULT_DATA_DIR;
+  const dirName = sanitizeProjectId(projectId);
+  const dataDir = path2.join(base, dirName);
   await fs.mkdir(dataDir, { recursive: true });
   return dataDir;
 }
+function getBaseDataDir(baseDir) {
+  return baseDir ?? DEFAULT_DATA_DIR;
+}
+async function listProjectDirs(baseDir) {
+  const base = baseDir ?? DEFAULT_DATA_DIR;
+  try {
+    const entries = await fs.readdir(base, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => path2.join(base, e.name));
+  } catch {
+    return [];
+  }
+}
+async function migrateGlobalData(projectId, baseDir) {
+  const base = baseDir ?? DEFAULT_DATA_DIR;
+  const globalObsPath = path2.join(base, "observations.json");
+  const migratedObsPath = path2.join(base, "observations.json.migrated");
+  let sourceObsPath = null;
+  try {
+    await fs.access(globalObsPath);
+    sourceObsPath = globalObsPath;
+  } catch {
+    try {
+      await fs.access(migratedObsPath);
+      sourceObsPath = migratedObsPath;
+    } catch {
+      return false;
+    }
+  }
+  let globalObs = [];
+  try {
+    const data = await fs.readFile(sourceObsPath, "utf-8");
+    globalObs = JSON.parse(data);
+    if (!Array.isArray(globalObs) || globalObs.length === 0) return false;
+  } catch {
+    return false;
+  }
+  const projectDir2 = await getProjectDataDir(projectId, baseDir);
+  const projectObsPath = path2.join(projectDir2, "observations.json");
+  let projectObs = [];
+  try {
+    const data = await fs.readFile(projectObsPath, "utf-8");
+    projectObs = JSON.parse(data);
+    if (!Array.isArray(projectObs)) projectObs = [];
+  } catch {
+  }
+  if (projectObs.length >= globalObs.length) {
+    return false;
+  }
+  const existingIds = new Set(projectObs.map((o) => o.id));
+  const merged = [...projectObs];
+  for (const obs of globalObs) {
+    if (!existingIds.has(obs.id)) {
+      merged.push(obs);
+    }
+  }
+  merged.sort((a, b) => (a.id ?? 0) - (b.id ?? 0));
+  for (const obs of merged) {
+    obs.projectId = projectId;
+  }
+  await fs.writeFile(projectObsPath, JSON.stringify(merged, null, 2), "utf-8");
+  for (const file of ["graph.jsonl", "counter.json"]) {
+    const src = path2.join(base, file);
+    const srcMigrated = path2.join(base, file + ".migrated");
+    const dst = path2.join(projectDir2, file);
+    for (const source of [src, srcMigrated]) {
+      try {
+        await fs.access(source);
+        await fs.copyFile(source, dst);
+        break;
+      } catch {
+      }
+    }
+  }
+  const maxId = merged.reduce((max, o) => Math.max(max, o.id ?? 0), 0);
+  await fs.writeFile(
+    path2.join(projectDir2, "counter.json"),
+    JSON.stringify({ nextId: maxId + 1 }),
+    "utf-8"
+  );
+  for (const file of ["observations.json", "graph.jsonl", "counter.json"]) {
+    const src = path2.join(base, file);
+    try {
+      await fs.access(src);
+      await fs.rename(src, src + ".migrated");
+    } catch {
+    }
+  }
+  return true;
+}
 function getDbFilePath(projectDir2) {
   return path2.join(projectDir2, "memorix.msp");
 }
@@ -1132,12 +1229,14 @@ function detectProject(cwd) {
   const rootPath = getGitRoot(basePath) ?? findPackageRoot(basePath) ?? basePath;
   const gitRemote = getGitRemote(rootPath);
   if (gitRemote) {
-    const id = normalizeGitRemote(gitRemote);
-    const name2 = id.split("/").pop() ?? path3.basename(rootPath);
-    return { id, name: name2, gitRemote, rootPath };
+    const id2 = normalizeGitRemote(gitRemote);
+    const name2 = id2.split("/").pop() ?? path3.basename(rootPath);
+    return { id: id2, name: name2, gitRemote, rootPath };
   }
   const name = path3.basename(rootPath);
-  return { id: name, name, rootPath };
+  const id = `local/${name}`;
+  console.error(`[memorix] Warning: no git remote found at ${rootPath}, using fallback projectId: ${id}`);
+  return { id, name, rootPath };
 }
 function findPackageRoot(cwd) {
   let dir = path3.resolve(cwd);
@@ -3076,6 +3175,18 @@ async function detectInstalledAgents() {
     agents.push("kiro");
   } catch {
   }
+  const codexDir = path5.join(home, ".codex");
+  try {
+    await fs3.access(codexDir);
+    agents.push("codex");
+  } catch {
+  }
+  const antigravityDir = path5.join(home, ".gemini", "antigravity");
+  try {
+    await fs3.access(antigravityDir);
+    agents.push("antigravity");
+  } catch {
+  }
   return agents;
 }
 async function installHooks(agent, projectRoot, global = false) {
@@ -3152,15 +3263,34 @@ async function installAgentRules(agent, projectRoot) {
     case "copilot":
       rulesPath = path5.join(projectRoot, ".github", "copilot-instructions.md");
       break;
+    case "codex":
+      rulesPath = path5.join(projectRoot, "AGENTS.md");
+      break;
+    case "kiro":
+      rulesPath = path5.join(projectRoot, ".kiro", "rules", "memorix.md");
+      break;
     default:
-      return;
+      rulesPath = path5.join(projectRoot, ".agent", "rules", "memorix.md");
+      break;
   }
   try {
     await fs3.mkdir(path5.dirname(rulesPath), { recursive: true });
-    try {
-      await fs3.access(rulesPath);
-    } catch {
-      await fs3.writeFile(rulesPath, rulesContent, "utf-8");
+    if (agent === "codex") {
+      try {
+        const existing = await fs3.readFile(rulesPath, "utf-8");
+        if (existing.includes("Memorix")) {
+          return;
+        }
+        await fs3.writeFile(rulesPath, existing + "\n\n" + rulesContent, "utf-8");
+      } catch {
+        await fs3.writeFile(rulesPath, rulesContent, "utf-8");
+      }
+    } else {
+      try {
+        await fs3.access(rulesPath);
+      } catch {
+        await fs3.writeFile(rulesPath, rulesContent, "utf-8");
+      }
     }
   } catch {
   }
@@ -3174,22 +3304,50 @@ You have access to Memorix memory tools. Follow these rules to maintain persiste
 
 At the **beginning of every conversation**, before responding to the user:
 
-1. Call \`memorix_search\` with query related to the user's first message or the current project
-2. If results are found, use them to understand the current project state, recent decisions, and pending tasks
-3. Reference relevant memories naturally in your response
+1. Call \`memorix_search\` with a query related to the user's first message or the current project
+2. If results are found, use \`memorix_detail\` to fetch the most relevant ones
+3. Reference relevant memories naturally in your response \u2014 the user should feel you "remember" them
 
 This ensures you already know the project context without the user re-explaining.
 
 ## During Session \u2014 Capture Important Context
 
-Proactively call \`memorix_store\` when any of the following happen:
+**Proactively** call \`memorix_store\` whenever any of the following happen:
+
+### Architecture & Decisions
+- Technology choice, framework selection, or design pattern adopted
+- Trade-off discussion with a clear conclusion
+- API design, database schema, or project structure decisions
+
+### Bug Fixes & Problem Solving
+- A bug is identified and resolved \u2014 store root cause + fix
+- Workaround applied for a known issue
+- Performance issue diagnosed and optimized
+
+### Gotchas & Pitfalls
+- Something unexpected or tricky is discovered
+- A common mistake is identified and corrected
+- Platform-specific behavior that caused issues
 
-- **Architecture decision**: You or the user decide on a technology, pattern, or approach
-- **Bug fix**: A bug is identified and resolved \u2014 store the root cause and fix
-- **Gotcha/pitfall**: Something unexpected or tricky is discovered
-- **Configuration change**: Environment, port, path, or tooling changes
+### Configuration & Environment
+- Environment variables, port numbers, paths changed
+- Docker, nginx, Caddy, or reverse proxy config modified
+- Package dependencies added, removed, or version-pinned
 
-Use appropriate types: \`decision\`, \`problem-solution\`, \`gotcha\`, \`what-changed\`, \`discovery\`.
+### Deployment & Operations
+- Server deployment steps (Docker, VPS, cloud)
+- DNS, SSL/TLS certificate, domain configuration
+- CI/CD pipeline setup or changes
+- Database migration or data transfer procedures
+- Server topology (ports, services, reverse proxy chain)
+- SSH keys, access credentials setup (store pattern, NOT secrets)
+
+### Project Milestones
+- Feature completed or shipped
+- Version released or published to npm/PyPI/etc.
+- Repository made public, README updated, PR submitted
+
+Use appropriate types: \`decision\`, \`problem-solution\`, \`gotcha\`, \`what-changed\`, \`discovery\`, \`how-it-works\`.
 
 ## Session End \u2014 Store Summary
 
@@ -3197,18 +3355,21 @@ When the conversation is ending or the user says goodbye:
 
 1. Call \`memorix_store\` with type \`session-request\` to record:
    - What was accomplished in this session
-   - Current project state
+   - Current project state and any blockers
    - Pending tasks or next steps
-   - Any unresolved issues
+   - Key files modified
 
-This creates a "handoff note" for the next session.
+This creates a "handoff note" for the next session (or for another AI agent).
 
 ## Guidelines
 
-- **Don't store trivial information** (greetings, acknowledgments, simple file reads)
+- **Don't store trivial information** (greetings, acknowledgments, simple file reads, ls/dir output)
 - **Do store anything you'd want to know if you lost all context**
-- **Use concise titles** and structured facts
+- **Do store anything a different AI agent would need to continue this work**
+- **Use concise titles** (~5-10 words) and structured facts
 - **Include file paths** in filesModified when relevant
+- **Include related concepts** for better searchability
+- **Prefer storing too much over too little** \u2014 the retention system will auto-decay stale memories
 `;
 }
 async function uninstallHooks(agent, projectRoot, global = false) {
@@ -3233,7 +3394,7 @@ async function uninstallHooks(agent, projectRoot, global = false) {
 }
 async function getHookStatus(projectRoot) {
   const results = [];
-  const agents = ["claude", "copilot", "windsurf", "cursor", "kiro", "codex"];
+  const agents = ["claude", "copilot", "windsurf", "cursor", "kiro", "codex", "antigravity"];
   for (const agent of agents) {
     const projectPath = getProjectConfigPath(agent, projectRoot);
     const globalPath = getGlobalConfigPath(agent);
@@ -3398,31 +3559,65 @@ function sendError(res, message, status = 500) {
 function filterByProject(items, projectId) {
   return items.filter((item) => item.projectId === projectId);
 }
-async function handleApi(req, res, dataDir, projectId, projectName) {
+async function handleApi(req, res, dataDir, projectId, projectName, baseDir) {
   const url = new URL(req.url || "/", `http://${req.headers.host}`);
   const apiPath = url.pathname.replace("/api", "");
+  const requestedProject = url.searchParams.get("project");
+  let effectiveDataDir = dataDir;
+  let effectiveProjectId = projectId;
+  let effectiveProjectName = projectName;
+  if (requestedProject && requestedProject !== projectId) {
+    const sanitized = requestedProject.replace(/\//g, "--").replace(/[<>:"|?*\\]/g, "_");
+    const candidateDir = path6.join(baseDir, sanitized);
+    try {
+      await fs4.access(candidateDir);
+      effectiveDataDir = candidateDir;
+      effectiveProjectId = requestedProject;
+      effectiveProjectName = requestedProject.split("/").pop() || requestedProject;
+    } catch {
+    }
+  }
   try {
     switch (apiPath) {
+      case "/projects": {
+        try {
+          const entries = await fs4.readdir(baseDir, { withFileTypes: true });
+          const projects = entries.filter((e) => e.isDirectory() && e.name.includes("--")).map((e) => {
+            const dirName = e.name;
+            const id = dirName.replace(/--/g, "/");
+            return {
+              id,
+              name: id.split("/").pop() || id,
+              dirName,
+              isCurrent: id === projectId
+            };
+          });
+          sendJson(res, projects);
+        } catch {
+          sendJson(res, []);
+        }
+        break;
+      }
       case "/project": {
-        sendJson(res, { id: projectId, name: projectName });
+        sendJson(res, { id: effectiveProjectId, name: effectiveProjectName });
         break;
       }
       case "/graph": {
-        const graph = await loadGraphJsonl(dataDir);
+        const graph = await loadGraphJsonl(effectiveDataDir);
         sendJson(res, graph);
         break;
       }
       case "/observations": {
-        const allObs = await loadObservationsJson(dataDir);
-        const observations2 = filterByProject(allObs, projectId);
+        const allObs = await loadObservationsJson(effectiveDataDir);
+        const observations2 = filterByProject(allObs, effectiveProjectId);
         sendJson(res, observations2);
         break;
       }
       case "/stats": {
-        const graph = await loadGraphJsonl(dataDir);
-        const allObs = await loadObservationsJson(dataDir);
-        const observations2 = filterByProject(allObs, projectId);
-        const nextId2 = await loadIdCounter(dataDir);
+        const graph = await loadGraphJsonl(effectiveDataDir);
+        const allObs = await loadObservationsJson(effectiveDataDir);
+        const observations2 = filterByProject(allObs, effectiveProjectId);
+        const nextId2 = await loadIdCounter(effectiveDataDir);
         const typeCounts = {};
         for (const obs of observations2) {
           const t = obs.type || "unknown";
@@ -3440,8 +3635,8 @@ async function handleApi(req, res, dataDir, projectId, projectName) {
         break;
       }
       case "/retention": {
-        const allObs = await loadObservationsJson(dataDir);
-        const observations2 = filterByProject(allObs, projectId);
+        const allObs = await loadObservationsJson(effectiveDataDir);
+        const observations2 = filterByProject(allObs, effectiveProjectId);
         const now = Date.now();
         const scored = observations2.map((obs) => {
           const age = now - new Date(obs.createdAt || now).getTime();
@@ -3518,10 +3713,11 @@ function openBrowser(url) {
 }
 async function startDashboard(dataDir, port, staticDir, projectId, projectName, autoOpen = true) {
   const resolvedStaticDir = staticDir;
+  const baseDir = getBaseDataDir();
   const server = createServer(async (req, res) => {
     const url = req.url || "/";
     if (url.startsWith("/api/")) {
-      await handleApi(req, res, dataDir, projectId, projectName);
+      await handleApi(req, res, dataDir, projectId, projectName, baseDir);
     } else {
       await serveStatic(req, res, resolvedStaticDir);
     }
@@ -3579,6 +3775,14 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 async function createMemorixServer(cwd) {
   const project = detectProject(cwd);
+  try {
+    const { migrateGlobalData: migrateGlobalData2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
+    const migrated = await migrateGlobalData2(project.id);
+    if (migrated) {
+      console.error(`[memorix] Migrated legacy data to project directory: ${project.id}`);
+    }
+  } catch {
+  }
   const projectDir2 = await getProjectDataDir(project.id);
   const graphManager = new KnowledgeGraphManager(projectDir2);
   await graphManager.init();
@@ -3593,15 +3797,14 @@ async function createMemorixServer(cwd) {
     const { getHookStatus: getHookStatus2, installHooks: installHooks2, detectInstalledAgents: detectInstalledAgents2 } = await Promise.resolve().then(() => (init_installers(), installers_exports));
     const workDir = cwd ?? process.cwd();
     const statuses = await getHookStatus2(workDir);
-    const anyInstalled = statuses.some((s) => s.installed);
-    if (!anyInstalled) {
-      const agents = await detectInstalledAgents2();
-      for (const agent of agents) {
-        try {
-          const config = await installHooks2(agent, workDir);
-          console.error(`[memorix] Auto-installed hooks for ${agent} \u2192 ${config.configPath}`);
-        } catch {
-        }
+    const installedAgents = new Set(statuses.filter((s) => s.installed).map((s) => s.agent));
+    const detectedAgents = await detectInstalledAgents2();
+    for (const agent of detectedAgents) {
+      if (installedAgents.has(agent)) continue;
+      try {
+        const config = await installHooks2(agent, workDir);
+        console.error(`[memorix] Auto-installed hooks for ${agent} \u2192 ${config.configPath}`);
+      } catch {
       }
     }
   } catch {
@@ -3738,15 +3941,20 @@ Entity: ${entityName} | Type: ${type} | Project: ${project.id}${enrichment}`
         query: z.string().describe("Search query (natural language or keywords)"),
         limit: z.number().optional().describe("Max results (default: 20)"),
         type: z.enum(OBSERVATION_TYPES).optional().describe("Filter by observation type"),
-        maxTokens: z.number().optional().describe("Token budget \u2014 trim results to fit (0 = unlimited)")
+        maxTokens: z.number().optional().describe("Token budget \u2014 trim results to fit (0 = unlimited)"),
+        scope: z.enum(["project", "global"]).optional().describe(
+          'Search scope: "project" (default) only searches current project, "global" searches all projects'
+        )
       }
     },
-    async ({ query, limit, type, maxTokens }) => {
+    async ({ query, limit, type, maxTokens, scope }) => {
       const result = await compactSearch({
         query,
         limit,
         type,
-        maxTokens
+        maxTokens,
+        // Default to current project scope; 'global' removes the project filter
+        projectId: scope === "global" ? void 0 : project.id
       });
       let text = result.formatted;
       if (!syncAdvisoryShown && syncAdvisory) {
@@ -4325,7 +4533,29 @@ var init_serve = __esm({
       run: async ({ args }) => {
         const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
         const { createMemorixServer: createMemorixServer2 } = await Promise.resolve().then(() => (init_server2(), server_exports2));
-        const projectRoot = args.cwd || process.cwd();
+        const { execSync: execSync2 } = await import("child_process");
+        let projectRoot = args.cwd || process.env.INIT_CWD || process.cwd();
+        try {
+          execSync2("git rev-parse --show-toplevel", {
+            cwd: projectRoot,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+        } catch {
+          const scriptDir = new URL(".", import.meta.url).pathname.replace(/^\/([A-Z]:)/, "$1");
+          try {
+            const gitRoot = execSync2("git rev-parse --show-toplevel", {
+              cwd: scriptDir,
+              encoding: "utf-8",
+              stdio: ["pipe", "pipe", "pipe"]
+            }).trim();
+            if (gitRoot) {
+              projectRoot = gitRoot;
+              console.error(`[memorix] CWD has no git, using script dir: ${projectRoot}`);
+            }
+          } catch {
+          }
+        }
         const { server, projectId } = await createMemorixServer2(projectRoot);
         const transport = new StdioServerTransport();
         await server.connect(transport);
@@ -4725,7 +4955,8 @@ function patternToObservationType(pattern) {
     gotcha: "gotcha",
     configuration: "what-changed",
     learning: "discovery",
-    implementation: "what-changed"
+    implementation: "what-changed",
+    deployment: "what-changed"
   };
   return map[pattern] ?? "discovery";
 }
@@ -4796,6 +5027,23 @@ var init_pattern_detector = __esm({
         ],
         minLength: 200,
         baseConfidence: 0.5
+      },
+      {
+        type: "deployment",
+        keywords: [
+          /\b(deploy(ed|ing|ment)?|ship(ped|ping)?|releas(ed|ing)|publish(ed|ing)?)\b/i,
+          /(部署|发布|上线|迁移|运维)/,
+          /\b(docker|compose|container|kubernetes|k8s|helm)\b/i,
+          /\b(VPS|server|host(ing)?|cloud|AWS|Azure|GCP|Cloudflare)\b/i,
+          /\b(nginx|caddy|apache|reverse.?proxy|load.?balanc)\b/i,
+          /\b(SSL|TLS|cert(ificate)?|HTTPS|Let'?s?.?Encrypt|ACME)\b/i,
+          /\b(DNS|domain|A.?record|CNAME|nameserver|Cloudflare)\b/i,
+          /\b(CI\/CD|pipeline|GitHub.?Actions|Jenkins|GitLab.?CI)\b/i,
+          /\b(scp|rsync|ssh|sftp|systemd|systemctl|service)\b/i,
+          /(服务器|域名|证书|反向代理|负载均衡|镜像|容器)/
+        ],
+        minLength: 80,
+        baseConfidence: 0.75
       }
     ];
   }
@@ -5277,10 +5525,13 @@ var init_dashboard = __esm({
 // src/cli/index.ts
 init_esm_shims();
 import { defineCommand as defineCommand10, runMain } from "citty";
+import { createRequire as createRequire2 } from "module";
+var require2 = createRequire2(import.meta.url);
+var pkg = require2("../../package.json");
 var main = defineCommand10({
   meta: {
     name: "memorix",
-    version: "0.3.9",
+    version: pkg.version,
     description: "Cross-Agent Memory Bridge \u2014 Universal memory layer for AI coding agents via MCP"
   },
   subCommands: {