memorix 0.5.2 → 0.6.1

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);
@@ -1700,6 +1799,76 @@ var init_copilot = __esm({
   }
 });
 
+// src/rules/adapters/kiro.ts
+import matter7 from "gray-matter";
+var KiroAdapter;
+var init_kiro = __esm({
+  "src/rules/adapters/kiro.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    KiroAdapter = class {
+      source = "kiro";
+      filePatterns = [
+        ".kiro/steering/*.md",
+        "AGENTS.md"
+      ];
+      parse(filePath, content) {
+        if (filePath.includes(".kiro/steering/")) {
+          return this.parseSteeringRule(filePath, content);
+        }
+        if (filePath.endsWith("AGENTS.md")) {
+          return this.parseAgentsMd(filePath, content);
+        }
+        return [];
+      }
+      generate(rules) {
+        return rules.map((rule, i) => {
+          const fm = {};
+          if (rule.description) fm.description = rule.description;
+          const fileName = rule.id.replace(/^kiro:/, "").replace(/[^a-zA-Z0-9-_]/g, "-") || `rule-${i}`;
+          const body = Object.keys(fm).length > 0 ? matter7.stringify(rule.content, fm) : rule.content;
+          return {
+            filePath: `.kiro/steering/${fileName}.md`,
+            content: body
+          };
+        });
+      }
+      parseSteeringRule(filePath, content) {
+        const { data, content: body } = matter7(content);
+        const trimmed = body.trim();
+        if (!trimmed) return [];
+        const trigger = data.trigger;
+        const alwaysApply = !trigger || trigger === "always";
+        return [{
+          id: generateRuleId("kiro", filePath),
+          content: trimmed,
+          description: data.description,
+          source: "kiro",
+          scope: alwaysApply ? "global" : "path-specific",
+          paths: data.globs,
+          alwaysApply,
+          priority: alwaysApply ? 10 : 5,
+          hash: hashContent(trimmed)
+        }];
+      }
+      parseAgentsMd(filePath, content) {
+        const trimmed = content.trim();
+        if (!trimmed) return [];
+        return [{
+          id: generateRuleId("kiro", filePath),
+          content: trimmed,
+          source: "kiro",
+          scope: "project",
+          alwaysApply: true,
+          priority: 10,
+          hash: hashContent(trimmed)
+        }];
+      }
+    };
+  }
+});
+
 // src/rules/syncer.ts
 var syncer_exports = {};
 __export(syncer_exports, {
@@ -1718,6 +1887,7 @@ var init_syncer = __esm({
     init_windsurf();
     init_antigravity();
     init_copilot();
+    init_kiro();
     RulesSyncer = class {
       projectRoot;
       adapters;
@@ -1730,7 +1900,8 @@ var init_syncer = __esm({
           new CodexAdapter(),
           new WindsurfAdapter(),
           new AntigravityAdapter(),
-          new CopilotAdapter()
+          new CopilotAdapter(),
+          new KiroAdapter()
         ];
         for (const a of all) {
           this.adapters.set(a.source, a);
@@ -2339,8 +2510,60 @@ var init_antigravity2 = __esm({
   }
 });
 
+// src/workspace/mcp-adapters/kiro.ts
+import { homedir as homedir7 } from "os";
+import { join as join7 } from "path";
+var KiroMCPAdapter;
+var init_kiro2 = __esm({
+  "src/workspace/mcp-adapters/kiro.ts"() {
+    "use strict";
+    init_esm_shims();
+    KiroMCPAdapter = class {
+      source = "kiro";
+      parse(content) {
+        try {
+          const config = JSON.parse(content);
+          const servers = config.mcpServers ?? {};
+          return Object.entries(servers).map(([name, entry]) => ({
+            name,
+            command: entry.command ?? "",
+            args: entry.args ?? [],
+            ...entry.env && Object.keys(entry.env).length > 0 ? { env: entry.env } : {},
+            ...entry.url ? { url: entry.url } : {}
+          }));
+        } catch {
+          return [];
+        }
+      }
+      generate(servers) {
+        const mcpServers = {};
+        for (const s of servers) {
+          const entry = {};
+          if (s.url) {
+            entry.url = s.url;
+          } else {
+            entry.command = s.command;
+            entry.args = s.args;
+          }
+          if (s.env && Object.keys(s.env).length > 0) {
+            entry.env = s.env;
+          }
+          mcpServers[s.name] = entry;
+        }
+        return JSON.stringify({ mcpServers }, null, 2);
+      }
+      getConfigPath(projectRoot) {
+        if (projectRoot) {
+          return join7(projectRoot, ".kiro", "settings", "mcp.json");
+        }
+        return join7(homedir7(), ".kiro", "settings", "mcp.json");
+      }
+    };
+  }
+});
+
 // src/workspace/workflow-sync.ts
-import matter7 from "gray-matter";
+import matter8 from "gray-matter";
 var WorkflowSyncer;
 var init_workflow_sync = __esm({
   "src/workspace/workflow-sync.ts"() {
@@ -2355,7 +2578,7 @@ var init_workflow_sync = __esm({
         let description = "";
         let content = raw;
         try {
-          const parsed = matter7(raw);
+          const parsed = matter8(raw);
           description = parsed.data?.description ?? "";
           content = parsed.content.trim();
         } catch {
@@ -2377,7 +2600,7 @@ var init_workflow_sync = __esm({
         if (wf.description) {
           fm.description = wf.description;
         }
-        const content = matter7.stringify(wf.content, fm);
+        const content = matter8.stringify(wf.content, fm);
         return {
           filePath: `.agents/skills/${safeName}/SKILL.md`,
           content
@@ -2394,7 +2617,7 @@ var init_workflow_sync = __esm({
         }
         fm.globs = "";
         fm.alwaysApply = "false";
-        const content = matter7.stringify(wf.content, fm);
+        const content = matter8.stringify(wf.content, fm);
         return {
           filePath: `.cursor/rules/${safeName}.mdc`,
           content
@@ -2582,8 +2805,8 @@ var init_applier = __esm({
 
 // src/workspace/engine.ts
 import { readFileSync as readFileSync2, readdirSync, existsSync as existsSync4, cpSync, mkdirSync as mkdirSync2 } from "fs";
-import { join as join8 } from "path";
-import { homedir as homedir7 } from "os";
+import { join as join9 } from "path";
+import { homedir as homedir8 } from "os";
 var WorkspaceSyncEngine;
 var init_engine2 = __esm({
   "src/workspace/engine.ts"() {
@@ -2595,6 +2818,7 @@ var init_engine2 = __esm({
     init_claude_code2();
     init_copilot2();
     init_antigravity2();
+    init_kiro2();
     init_workflow_sync();
     init_syncer();
     init_sanitizer();
@@ -2608,7 +2832,8 @@ var init_engine2 = __esm({
           ["codex", new CodexMCPAdapter()],
           ["claude-code", new ClaudeCodeMCPAdapter()],
           ["copilot", new CopilotMCPAdapter()],
-          ["antigravity", new AntigravityMCPAdapter()]
+          ["antigravity", new AntigravityMCPAdapter()],
+          ["kiro", new KiroMCPAdapter()]
         ]);
         this.workflowSyncer = new WorkflowSyncer();
         this.rulesSyncer = new RulesSyncer(projectRoot);
@@ -2626,7 +2851,8 @@ var init_engine2 = __esm({
           codex: [],
           "claude-code": [],
           copilot: [],
-          antigravity: []
+          antigravity: [],
+          kiro: []
         };
         for (const [target, adapter] of this.adapters) {
           const configPath = adapter.getConfigPath(this.projectRoot);
@@ -2718,13 +2944,14 @@ var init_engine2 = __esm({
         windsurf: [".windsurf/skills"],
         "claude-code": [".claude/skills"],
         copilot: [".github/skills", ".copilot/skills"],
-        antigravity: [".agent/skills", ".gemini/skills", ".gemini/antigravity/skills"]
+        antigravity: [".agent/skills", ".gemini/skills", ".gemini/antigravity/skills"],
+        kiro: [".kiro/skills"]
       };
       /** Get the target skills directory for an agent (null if agent has no skills support) */
       getTargetSkillsDir(target) {
         const dirs = _WorkspaceSyncEngine.SKILLS_DIRS[target];
         if (!dirs || dirs.length === 0) return null;
-        return join8(this.projectRoot, dirs[0]);
+        return join9(this.projectRoot, dirs[0]);
       }
       /**
        * Scan all agent skills directories and collect unique skills.
@@ -2733,12 +2960,12 @@ var init_engine2 = __esm({
         const skills = [];
         const conflicts = [];
         const seen = /* @__PURE__ */ new Map();
-        const home = homedir7();
+        const home = homedir8();
         for (const [agent, dirs] of Object.entries(_WorkspaceSyncEngine.SKILLS_DIRS)) {
           for (const dir of dirs) {
             const paths = [
-              join8(this.projectRoot, dir),
-              join8(home, dir)
+              join9(this.projectRoot, dir),
+              join9(home, dir)
             ];
             for (const skillsRoot of paths) {
               if (!existsSync4(skillsRoot)) continue;
@@ -2746,7 +2973,7 @@ var init_engine2 = __esm({
                 const entries = readdirSync(skillsRoot, { withFileTypes: true });
                 for (const entry of entries) {
                   if (!entry.isDirectory()) continue;
-                  const skillMd = join8(skillsRoot, entry.name, "SKILL.md");
+                  const skillMd = join9(skillsRoot, entry.name, "SKILL.md");
                   if (!existsSync4(skillMd)) continue;
                   let description = "";
                   try {
@@ -2758,7 +2985,7 @@ var init_engine2 = __esm({
                   const newEntry = {
                     name: entry.name,
                     description,
-                    sourcePath: join8(skillsRoot, entry.name),
+                    sourcePath: join9(skillsRoot, entry.name),
                     sourceAgent: agent
                   };
                   const existing = seen.get(entry.name);
@@ -2795,7 +3022,7 @@ var init_engine2 = __esm({
         }
         for (const skill of skills) {
           if (skill.sourceAgent === target) continue;
-          const dest = join8(targetDir, skill.name);
+          const dest = join9(targetDir, skill.name);
           if (existsSync4(dest)) {
             skipped.push(`${skill.name} (already exists in ${target})`);
             continue;
@@ -2811,13 +3038,13 @@ var init_engine2 = __esm({
       }
       scanWorkflows() {
         const workflows = [];
-        const wfDir = join8(this.projectRoot, ".windsurf", "workflows");
+        const wfDir = join9(this.projectRoot, ".windsurf", "workflows");
         if (!existsSync4(wfDir)) return workflows;
         try {
           const files = readdirSync(wfDir).filter((f) => f.endsWith(".md"));
           for (const file of files) {
             try {
-              const content = readFileSync2(join8(wfDir, file), "utf-8");
+              const content = readFileSync2(join9(wfDir, file), "utf-8");
               workflows.push(this.workflowSyncer.parseWindsurfWorkflow(file, content));
             } catch {
             }
@@ -2905,7 +3132,8 @@ var init_engine2 = __esm({
           codex: "codex",
           windsurf: "windsurf",
           copilot: "copilot",
-          antigravity: "antigravity"
+          antigravity: "antigravity",
+          kiro: "kiro"
         };
         return map[target] ?? null;
       }
@@ -3076,6 +3304,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 +3392,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 +3433,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 +3484,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 +3523,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 +3688,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 +3764,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();
@@ -3475,8 +3799,42 @@ async function handleApi(req, res, dataDir, projectId, projectName) {
         });
         break;
       }
-      default:
+      default: {
+        const deleteMatch = apiPath.match(/^\/observations\/(\d+)$/);
+        if (deleteMatch && req.method === "DELETE") {
+          const obsId = parseInt(deleteMatch[1], 10);
+          const allObs = await loadObservationsJson(effectiveDataDir);
+          const idx = allObs.findIndex((o) => o.id === obsId);
+          if (idx === -1) {
+            sendError(res, "Observation not found", 404);
+          } else {
+            allObs.splice(idx, 1);
+            await saveObservationsJson(effectiveDataDir, allObs);
+            sendJson(res, { ok: true, deleted: obsId });
+          }
+          break;
+        }
+        if (apiPath === "/export") {
+          const graph = await loadGraphJsonl(effectiveDataDir);
+          const allObs = await loadObservationsJson(effectiveDataDir);
+          const observations2 = filterByProject(allObs, effectiveProjectId);
+          const nextId2 = await loadIdCounter(effectiveDataDir);
+          const exportData = {
+            project: { id: effectiveProjectId, name: effectiveProjectName },
+            exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            graph,
+            observations: observations2,
+            nextId: nextId2
+          };
+          res.writeHead(200, {
+            "Content-Type": "application/json",
+            "Content-Disposition": `attachment; filename="memorix-${effectiveProjectId.replace(/\//g, "-")}-export.json"`
+          });
+          res.end(JSON.stringify(exportData, null, 2));
+          break;
+        }
         sendError(res, "Not found", 404);
+      }
     }
   } catch (err) {
     const message = err instanceof Error ? err.message : "Unknown error";
@@ -3518,10 +3876,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 +3938,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 +3960,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 +4104,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 +4696,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 +5118,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 +5190,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
       }
     ];
   }