memorix 0.5.2 → 0.6.1

package/dist/index.js

@@ -29,17 +29,138 @@ 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
+});
 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");
+}
 function getGraphFilePath(projectDir2) {
   return path2.join(projectDir2, "graph.jsonl");
 }
+async function hasExistingData(projectDir2) {
+  try {
+    await fs.access(getDbFilePath(projectDir2));
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function saveGraphJsonl(projectDir2, entities, relations) {
   const lines = [
     ...entities.map(
@@ -645,6 +766,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) {
@@ -721,15 +854,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 {
   }
@@ -743,22 +895,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
 
@@ -766,18 +946,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) {
@@ -802,7 +985,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);
@@ -967,31 +1150,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";
@@ -1009,8 +1226,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();
@@ -1044,8 +1261,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";
@@ -1087,10 +1338,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);
     }
@@ -1719,12 +1971,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);
@@ -2244,6 +2498,69 @@ var CopilotAdapter = class {
   }
 };
 
+// src/rules/adapters/kiro.ts
+init_esm_shims();
+import matter7 from "gray-matter";
+var 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 RulesSyncer = class {
   projectRoot;
@@ -2257,7 +2574,8 @@ var RulesSyncer = class {
       new CodexAdapter(),
       new WindsurfAdapter(),
       new AntigravityAdapter(),
-      new CopilotAdapter()
+      new CopilotAdapter(),
+      new KiroAdapter()
     ];
     for (const a of all) {
       this.adapters.set(a.source, a);
@@ -2399,8 +2717,8 @@ var RulesSyncer = class {
 // src/workspace/engine.ts
 init_esm_shims();
 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";
 
 // src/workspace/mcp-adapters/windsurf.ts
 init_esm_shims();
@@ -2834,9 +3152,55 @@ var AntigravityMCPAdapter = class {
   }
 };
 
+// src/workspace/mcp-adapters/kiro.ts
+init_esm_shims();
+import { homedir as homedir7 } from "os";
+import { join as join7 } from "path";
+var 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
 init_esm_shims();
-import matter7 from "gray-matter";
+import matter8 from "gray-matter";
 var WorkflowSyncer = class {
   /**
    * Parse a Windsurf workflow markdown file into a WorkflowEntry.
@@ -2846,7 +3210,7 @@ var WorkflowSyncer = class {
     let description = "";
     let content = raw;
     try {
-      const parsed = matter7(raw);
+      const parsed = matter8(raw);
       description = parsed.data?.description ?? "";
       content = parsed.content.trim();
     } catch {
@@ -2868,7 +3232,7 @@ var WorkflowSyncer = class {
     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
@@ -2885,7 +3249,7 @@ var WorkflowSyncer = class {
     }
     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
@@ -3067,7 +3431,8 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
       ["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);
@@ -3085,7 +3450,8 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
       codex: [],
       "claude-code": [],
       copilot: [],
-      antigravity: []
+      antigravity: [],
+      kiro: []
     };
     for (const [target, adapter] of this.adapters) {
       const configPath = adapter.getConfigPath(this.projectRoot);
@@ -3177,13 +3543,14 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
     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.
@@ -3192,12 +3559,12 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
     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;
@@ -3205,7 +3572,7 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
             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 {
@@ -3217,7 +3584,7 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
               const newEntry = {
                 name: entry.name,
                 description,
-                sourcePath: join8(skillsRoot, entry.name),
+                sourcePath: join9(skillsRoot, entry.name),
                 sourceAgent: agent
               };
               const existing = seen.get(entry.name);
@@ -3254,7 +3621,7 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
     }
     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;
@@ -3270,13 +3637,13 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
   }
   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 {
         }
@@ -3364,7 +3731,8 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
       codex: "codex",
       windsurf: "windsurf",
       copilot: "copilot",
-      antigravity: "antigravity"
+      antigravity: "antigravity",
+      kiro: "kiro"
     };
     return map[target] ?? null;
   }
@@ -3384,6 +3752,14 @@ var OBSERVATION_TYPES = [
 ];
 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();
@@ -3398,15 +3774,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 {
@@ -3543,15 +3918,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) {