@simplexlat/memhub 0.1.2 → 0.1.4

package/dist/cli.js

@@ -753,7 +753,8 @@ var CloudApiClient = class {
         headers: this.getHeaders(),
         body: JSON.stringify({ slug: "__health_check__" })
       });
-      return { ok: res.ok || res.status === 401 || res.status === 400, status: res.status };
+      const reachable = res.ok || res.status === 400 || res.status === 401 || res.status === 429;
+      return { ok: reachable, status: res.status, message: reachable ? void 0 : `HTTP ${res.status}` };
     } catch (err) {
       return { ok: false, status: 0, message: err.message };
     }
@@ -1347,9 +1348,9 @@ function getConfig() {
 }
 
 // src/connectors/ide-injector.ts
-import fs5 from "fs";
-import path5 from "path";
-import os3 from "os";
+import fs6 from "fs";
+import path6 from "path";
+import os4 from "os";
 
 // src/connectors/rules-injector.ts
 import fs4 from "fs";
@@ -1361,17 +1362,17 @@ var MEMHUB_PROTOCOL_INSTRUCTIONS = `${MEMHUB_RULES_BEGIN_MARKER}
 
 ## MemHub Persistent Shared Memory \u2014 Protocol
 
-You have access to MemHub, a persistent memory and team knowledge system that survives across sessions, compactions, and teammates.
+You have access to MemHub, a persistent memory and team knowledge system that survives across sessions, compactions, teammates, and repositories.
 
 ### WHEN TO SAVE TO MEMORY (mandatory \u2014 not optional)
 
-Call \`mem_save\` (or \`memory_save\`) IMMEDIATELY after any of these:
+You must autonomously call \`mem_save\` (or \`memory_save\`) IMMEDIATELY after any of these events without asking the user:
 - Bug fix completed
 - Architecture or design decision made
-- Non-obvious discovery about the codebase
-- Configuration change or environment setup
+- Non-obvious discovery about the codebase or dependencies
+- Configuration change, environment setup, or deployment step
 - Pattern established (naming, structure, convention)
-- User preference or team constraint learned
+- User preference, constraint, or requirement learned
 
 Format for \`mem_save\`:
 - **title**: Verb + what \u2014 short, searchable (e.g. "Fixed N+1 query in UserList", "Chose Zustand over Redux")
@@ -1384,31 +1385,62 @@ Format for \`mem_save\`:
   **Where**: Files or paths affected
   **Learned**: Gotchas, edge cases, things that surprised you (omit if none)
 
+### MULTI-PROJECT & NEW REPOSITORY AUTONOMY
+
+MemHub automatically detects the Git repository and folder context. When you save a memory in a new repository or workspace, MemHub autonomously connects it to the user's organization in the cloud dashboard and links all memories.
+
+### Topic update rules (mandatory)
+
+- Different topics must not overwrite each other (e.g. architecture vs bugfix)
+- Reuse the same \`topic_key\` to update an evolving topic instead of creating duplicate fragmented observations
+- If unsure about the key, call \`mem_suggest_topic_key\` first and reuse it
+- Use \`mem_update\` when you have an exact observation ID to update
+
 ### WHEN TO SEARCH MEMORY (mandatory)
 
-When the user asks to recall something or references past work ("remember", "recall", "what did we do", "c\xF3mo lo resolvimos", "qu\xE9 hicimos"):
+When the user asks to recall something or references past work ("remember", "recall", "what did we do", "c\xF3mo lo resolvimos", "qu\xE9 hicimos", or past session context):
 1. First call \`mem_context\` (fast recent session history)
 2. Call \`mem_search\` (or \`memory_recall\`) with relevant keywords (hybrid lexical + vector search)
 3. If needed, use \`mem_get_observation\` for full untruncated content
 
 Also search memory PROACTIVELY when:
 - Starting work on an unfamiliar area of the codebase
-- The user mentions a technical topic you have no context on
+- The user mentions a technical topic you have no context on \u2014 check if past sessions covered it
 
 ### SESSION CLOSE PROTOCOL (mandatory)
 
-Before ending a session or declaring a milestone done, call \`mem_session_summary\`:
-- **Goal**: What was worked on this session
-- **Discoveries**: Technical findings and gotchas
-- **Accomplished**: Key completed items
-- **Next Steps**: What remains for subsequent sessions
-- **Relevant Files**: Changed files and their purpose
+Before ending a session or declaring a milestone done, you MUST call \`mem_session_summary\` with this structure:
+
+## Goal
+[What was worked on this session]
+
+## Instructions
+[User preferences or constraints discovered \u2014 skip if none]
+
+## Discoveries
+- [Technical findings, gotchas, non-obvious learnings]
+
+## Accomplished
+- [Completed items with key details]
+
+## Next Steps
+- [What remains to be done \u2014 for the next session]
+
+## Relevant Files
+- path/to/file \u2014 [what it does or what changed]
 
 ### PASSIVE CAPTURE
 
-When completing a task, include a \`## Key Learnings:\` section at the end of your response with numbered items. MemHub will automatically capture and persist these learnings for the team.
+When completing a task or subtask, include a \`## Key Learnings:\` section at the end of your response with numbered items. MemHub will automatically capture and persist these learnings for the team.
+
+### AFTER COMPACTION
+
+If context reset or compaction occurs, immediately call \`mem_session_summary\` to persist the compacted summary, then call \`mem_context\` to recover previous session context.
 
 ${MEMHUB_RULES_END_MARKER}`;
+function getHomeDir() {
+  return process.env.HOME || os2.homedir();
+}
 var RulesInjector = class {
   /**
    * Injects or updates the managed MemHub rules block inside a markdown file.
@@ -1452,7 +1484,7 @@ ${MEMHUB_PROTOCOL_INSTRUCTIONS}
    */
   static injectClaudeCode(cwd = process.cwd()) {
     const local = this.injectIntoFile(path4.join(cwd, "CLAUDE.md"), "Claude Code (Workspace)");
-    const globalPath = path4.join(os2.homedir(), ".claude", "CLAUDE.md");
+    const globalPath = path4.join(getHomeDir(), ".claude", "CLAUDE.md");
     const global = this.injectIntoFile(globalPath, "Claude Code (Global)");
     return [local, global];
   }
@@ -1463,15 +1495,16 @@ ${MEMHUB_PROTOCOL_INSTRUCTIONS}
     const cursorRules = this.injectIntoFile(path4.join(cwd, ".cursorrules"), "Cursor (.cursorrules)");
     const mdcPath = path4.join(cwd, ".cursor", "rules", "memhub.mdc");
     const mdc = this.injectIntoFile(mdcPath, "Cursor MDC (.cursor/rules/memhub.mdc)");
-    return [cursorRules, mdc];
+    const globalCursor = this.injectIntoFile(path4.join(getHomeDir(), ".cursorrules"), "Cursor (Global .cursorrules)");
+    return [cursorRules, mdc, globalCursor];
   }
   /**
    * Injects rules for Google Antigravity / Gemini CLI
    */
   static injectAntigravity(cwd = process.cwd()) {
     const localRule = path4.join(cwd, ".gemini", "antigravity-cli", "rules", "memhub.md");
-    const globalRule = path4.join(os2.homedir(), ".gemini", "antigravity-cli", "rules", "memhub.md");
-    const legacyGlobalRule = path4.join(os2.homedir(), ".gemini", "config", "rules", "memhub.md");
+    const globalRule = path4.join(getHomeDir(), ".gemini", "antigravity-cli", "rules", "memhub.md");
+    const legacyGlobalRule = path4.join(getHomeDir(), ".gemini", "config", "rules", "memhub.md");
     return [
       this.injectIntoFile(localRule, "Antigravity (Workspace)"),
       this.injectIntoFile(globalRule, "Antigravity (Global)"),
@@ -1482,24 +1515,57 @@ ${MEMHUB_PROTOCOL_INSTRUCTIONS}
    * Injects rules for Windsurf (`.windsurfrules`)
    */
   static injectWindsurf(cwd = process.cwd()) {
-    return [this.injectIntoFile(path4.join(cwd, ".windsurfrules"), "Windsurf (.windsurfrules)")];
+    const local = this.injectIntoFile(path4.join(cwd, ".windsurfrules"), "Windsurf (.windsurfrules)");
+    const global = this.injectIntoFile(path4.join(getHomeDir(), ".windsurfrules"), "Windsurf (Global .windsurfrules)");
+    return [local, global];
   }
   /**
    * Injects rules for Cline / Roo Code (`.clinerules`)
    */
   static injectCline(cwd = process.cwd()) {
-    return [this.injectIntoFile(path4.join(cwd, ".clinerules"), "Cline (.clinerules)")];
+    const local = this.injectIntoFile(path4.join(cwd, ".clinerules"), "Cline (.clinerules)");
+    const global = this.injectIntoFile(path4.join(getHomeDir(), ".clinerules"), "Cline (Global .clinerules)");
+    return [local, global];
   }
   /**
    * Injects rules for Codex CLI & General Agent specification (`AGENTS.md`)
    */
   static injectCodex(cwd = process.cwd()) {
     const localAgents = this.injectIntoFile(path4.join(cwd, "AGENTS.md"), "Agents Specification (AGENTS.md)");
-    const globalCodex = this.injectIntoFile(path4.join(os2.homedir(), ".codex", "instructions.md"), "Codex CLI (Global instructions)");
+    const globalCodex = this.injectIntoFile(path4.join(getHomeDir(), ".codex", "instructions.md"), "Codex CLI (Global instructions)");
     return [localAgents, globalCodex];
   }
   /**
-   * Injects rules across all supported AI coding agents.
+   * Injects rules for OpenCode CLI (`OPENCODE.md` and `~/.config/opencode/rules/memhub.md`)
+   */
+  static injectOpenCode(cwd = process.cwd()) {
+    const local = this.injectIntoFile(path4.join(cwd, "OPENCODE.md"), "OpenCode (Workspace OPENCODE.md)");
+    const global1 = this.injectIntoFile(path4.join(getHomeDir(), ".config", "opencode", "rules", "memhub.md"), "OpenCode (Global ~/.config/opencode)");
+    const global2 = this.injectIntoFile(path4.join(getHomeDir(), ".opencode", "rules.md"), "OpenCode (Global ~/.opencode)");
+    return [local, global1, global2];
+  }
+  /**
+   * Injects rules for Alibaba Qwen Code / Qwen Agent (`.qwenrules`, `QWEN.md`, and `~/.qwen/rules.md`)
+   */
+  static injectQwen(cwd = process.cwd()) {
+    const localRules = this.injectIntoFile(path4.join(cwd, ".qwenrules"), "Qwen (.qwenrules)");
+    const localMd = this.injectIntoFile(path4.join(cwd, "QWEN.md"), "Qwen (Workspace QWEN.md)");
+    const globalQwen = this.injectIntoFile(path4.join(getHomeDir(), ".qwen", "rules.md"), "Qwen (Global ~/.qwen/rules.md)");
+    const globalDotRules = this.injectIntoFile(path4.join(getHomeDir(), ".qwenrules"), "Qwen (Global ~/.qwenrules)");
+    return [localRules, localMd, globalQwen, globalDotRules];
+  }
+  /**
+   * Injects rules for DeepSeek Harness / CLI (`.deepseekrules`, `DEEPSEEK.md`, and `~/.deepseek/rules.md`)
+   */
+  static injectDeepSeek(cwd = process.cwd()) {
+    const localRules = this.injectIntoFile(path4.join(cwd, ".deepseekrules"), "DeepSeek (.deepseekrules)");
+    const localMd = this.injectIntoFile(path4.join(cwd, "DEEPSEEK.md"), "DeepSeek (Workspace DEEPSEEK.md)");
+    const globalDeepSeek = this.injectIntoFile(path4.join(getHomeDir(), ".deepseek", "rules.md"), "DeepSeek (Global ~/.deepseek/rules.md)");
+    const globalDotRules = this.injectIntoFile(path4.join(getHomeDir(), ".deepseekrules"), "DeepSeek (Global ~/.deepseekrules)");
+    return [localRules, localMd, globalDeepSeek, globalDotRules];
+  }
+  /**
+   * Injects rules across all supported AI coding agents globally and locally.
    */
   static injectAll(cwd = process.cwd()) {
     return [
@@ -1508,26 +1574,197 @@ ${MEMHUB_PROTOCOL_INSTRUCTIONS}
       ...this.injectAntigravity(cwd),
       ...this.injectWindsurf(cwd),
       ...this.injectCline(cwd),
-      ...this.injectCodex(cwd)
+      ...this.injectCodex(cwd),
+      ...this.injectOpenCode(cwd),
+      ...this.injectQwen(cwd),
+      ...this.injectDeepSeek(cwd)
+    ];
+  }
+};
+
+// src/connectors/skills-injector.ts
+import fs5 from "fs";
+import path5 from "path";
+import os3 from "os";
+function getHomeDir2() {
+  return process.env.HOME || os3.homedir();
+}
+var MEMHUB_SKILL_MD = `---
+name: memhub
+description: Persistent, synchronized team memory and architecture decision logger for AI coding assistants. Use when saving decisions, searching previous solutions, querying shared project context, or closing sessions.
+---
+
+# MemHub Persistent Memory Skill
+
+MemHub synchronizes architectural decisions, bug fixes, technical patterns, and project knowledge across teammates and AI coding agents.
+
+## Core Capabilities
+
+1. **Autonomous Knowledge Ingestion**: Call \`mem_save\` immediately upon completing bugfixes, making architecture decisions, or establishing conventions.
+2. **Proactive Hybrid Retrieval**: Call \`mem_search\` and \`mem_context\` before beginning unfamiliar tasks to benefit from previous solutions.
+3. **Architecture Invariant Protection**: Call \`mem_pin\` to mark critical constraints into the team's \`/rules\` registry.
+4. **Session Handoff & Compaction Recovery**: Call \`mem_session_summary\` before declaring a milestone completed.
+
+## Slash Commands Quick Reference
+
+- \`/mem-save\`: Saves the latest code changes, bugfixes, or decisions as a structured observation.
+- \`/mem-search <query>\`: Searches team memories and previous solutions with hybrid lexical + vector ranking.
+- \`/mem-summary\`: Generates a structured session summary (Goal, Discoveries, Accomplished, Next Steps).
+- \`/mem-status\`: Displays connection status, device ID, and pending outbox events.
+
+## When to Save (Mandatory)
+
+Call \`mem_save\` immediately after:
+- Resolving a non-trivial bug
+- Deciding on a library, data structure, or design pattern
+- Configuring CI/CD, environment variables, or cloud infrastructure
+- Learning a user constraint or project convention
+`;
+var CLAUDE_COMMAND_SAVE = `Save a persistent memory observation of the latest work done using the \`mem_save\` tool.
+Include:
+- title: Verb + what (e.g. "Configured JWT Auth", "Fixed N+1 query in UserList")
+- type: bugfix | decision | architecture | discovery | pattern | config | preference
+- content:
+  **What**: One sentence summary of what was done.
+  **Why**: The motivation or problem solved.
+  **Where**: Affected files and directories.
+  **Learned**: Surprises, edge cases, or gotchas (if any).
+`;
+var CLAUDE_COMMAND_SEARCH = `Search the MemHub shared knowledge base for relevant past solutions, decisions, and patterns using the \`mem_search\` tool with the user's query: \`$ARGUMENTS\`.
+Provide a clear summary of findings with references.
+`;
+var CLAUDE_COMMAND_SUMMARY = `Generate and persist a structured session summary using the \`mem_session_summary\` tool.
+Structure:
+## Goal
+What we worked on in this session.
+
+## Discoveries
+Technical findings, gotchas, or surprising behaviors discovered.
+
+## Accomplished
+Key items completed.
+
+## Next Steps
+Remaining tasks for subsequent sessions.
+
+## Relevant Files
+Files touched and their purpose.
+`;
+var CLAUDE_COMMAND_STATUS = `Check and display the MemHub synchronization status using the \`memhub_sync_status\` tool.
+Show device ID, active project, outbox pending count, and cloud connection state.
+`;
+var SkillsInjector = class {
+  /**
+   * Injects slash commands for Claude Code in workspace and global ~/.claude/commands
+   */
+  static injectClaudeCommands(cwd = process.cwd()) {
+    const targets = [
+      path5.join(cwd, ".claude", "commands"),
+      path5.join(getHomeDir2(), ".claude", "commands")
+    ];
+    for (const dir of targets) {
+      try {
+        if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+        fs5.writeFileSync(path5.join(dir, "mem-save.md"), CLAUDE_COMMAND_SAVE, "utf8");
+        fs5.writeFileSync(path5.join(dir, "mem-search.md"), CLAUDE_COMMAND_SEARCH, "utf8");
+        fs5.writeFileSync(path5.join(dir, "mem-summary.md"), CLAUDE_COMMAND_SUMMARY, "utf8");
+        fs5.writeFileSync(path5.join(dir, "mem-status.md"), CLAUDE_COMMAND_STATUS, "utf8");
+      } catch {
+      }
+    }
+  }
+  /**
+   * Injects Antigravity / Gemini CLI skill in workspace and global ~/.gemini/antigravity-cli/skills/memhub
+   */
+  static injectAntigravitySkill(cwd = process.cwd()) {
+    const targets = [
+      path5.join(cwd, ".gemini", "antigravity-cli", "skills", "memhub"),
+      path5.join(getHomeDir2(), ".gemini", "antigravity-cli", "skills", "memhub"),
+      path5.join(getHomeDir2(), ".gemini", "config", "skills", "memhub")
     ];
+    for (const dir of targets) {
+      try {
+        if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+        fs5.writeFileSync(path5.join(dir, "SKILL.md"), MEMHUB_SKILL_MD, "utf8");
+      } catch {
+      }
+    }
+  }
+  /**
+   * Injects Codex CLI skill in global ~/.codex/skills/memhub
+   */
+  static injectCodexSkill() {
+    const dir = path5.join(getHomeDir2(), ".codex", "skills", "memhub");
+    try {
+      if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+      fs5.writeFileSync(path5.join(dir, "SKILL.md"), MEMHUB_SKILL_MD, "utf8");
+    } catch {
+    }
+  }
+  /**
+   * Injects OpenCode skill in global ~/.config/opencode/skills/memhub
+   */
+  static injectOpenCodeSkill() {
+    const dir = path5.join(getHomeDir2(), ".config", "opencode", "skills", "memhub");
+    try {
+      if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+      fs5.writeFileSync(path5.join(dir, "SKILL.md"), MEMHUB_SKILL_MD, "utf8");
+    } catch {
+    }
+  }
+  /**
+   * Injects Alibaba Qwen skill in global ~/.qwen/skills/memhub
+   */
+  static injectQwenSkill() {
+    const dir = path5.join(getHomeDir2(), ".qwen", "skills", "memhub");
+    try {
+      if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+      fs5.writeFileSync(path5.join(dir, "SKILL.md"), MEMHUB_SKILL_MD, "utf8");
+    } catch {
+    }
+  }
+  /**
+   * Injects DeepSeek skill in global ~/.deepseek/skills/memhub
+   */
+  static injectDeepSeekSkill() {
+    const dir = path5.join(getHomeDir2(), ".deepseek", "skills", "memhub");
+    try {
+      if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+      fs5.writeFileSync(path5.join(dir, "SKILL.md"), MEMHUB_SKILL_MD, "utf8");
+    } catch {
+    }
+  }
+  /**
+   * Injects all skills and slash commands across all supported AI environments.
+   */
+  static injectAll(cwd = process.cwd()) {
+    this.injectClaudeCommands(cwd);
+    this.injectAntigravitySkill(cwd);
+    this.injectCodexSkill();
+    this.injectOpenCodeSkill();
+    this.injectQwenSkill();
+    this.injectDeepSeekSkill();
   }
 };
 
 // src/connectors/ide-injector.ts
+function getHomeDir3() {
+  return process.env.HOME || os4.homedir();
+}
 var IdeConfigInjector = class {
   static serverConfig() {
     return { command: "memhub", args: ["serve"] };
   }
   static injectJsonMcpConfig(target, configPath, options) {
     try {
-      const parent = path5.dirname(configPath);
-      if (!fs5.existsSync(parent) && !options.dryRun) fs5.mkdirSync(parent, { recursive: true });
+      const parent = path6.dirname(configPath);
+      if (!fs6.existsSync(parent) && !options.dryRun) fs6.mkdirSync(parent, { recursive: true });
       let config = { mcpServers: {} };
-      if (fs5.existsSync(configPath)) config = JSON.parse(fs5.readFileSync(configPath, "utf8"));
+      if (fs6.existsSync(configPath)) config = JSON.parse(fs6.readFileSync(configPath, "utf8"));
       config.mcpServers = config.mcpServers || {};
       config.mcpServers.memhub = this.serverConfig();
-      const existed = fs5.existsSync(configPath);
-      if (!options.dryRun) fs5.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+      const existed = fs6.existsSync(configPath);
+      if (!options.dryRun) fs6.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
       return { target, filePath: configPath, success: true, action: existed ? "updated" : "created" };
     } catch (err) {
       return { target, filePath: configPath, success: false, action: "error", error: err.message };
@@ -1538,23 +1775,24 @@ var IdeConfigInjector = class {
    */
   static injectClaudeCode(options) {
     const cwd = options.cwd || process.cwd();
-    const configPath = path5.join(cwd, "mcp.json");
+    const configPath = path6.join(cwd, "mcp.json");
     try {
       let config = { mcpServers: {} };
-      if (fs5.existsSync(configPath)) {
-        config = JSON.parse(fs5.readFileSync(configPath, "utf8"));
+      if (fs6.existsSync(configPath)) {
+        config = JSON.parse(fs6.readFileSync(configPath, "utf8"));
       }
       config.mcpServers = config.mcpServers || {};
       config.mcpServers.memhub = this.serverConfig();
       if (!options.dryRun) {
-        fs5.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+        fs6.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
         RulesInjector.injectClaudeCode(cwd);
+        SkillsInjector.injectClaudeCommands(cwd);
       }
       return {
         target: "Claude Code",
         filePath: configPath,
         success: true,
-        action: fs5.existsSync(configPath) ? "updated" : "created"
+        action: fs6.existsSync(configPath) ? "updated" : "created"
       };
     } catch (err) {
       return {
@@ -1571,27 +1809,27 @@ var IdeConfigInjector = class {
    */
   static injectCursor(options) {
     const cwd = options.cwd || process.cwd();
-    const cursorDir = path5.join(cwd, ".cursor");
-    const configPath = path5.join(cursorDir, "mcp.json");
+    const cursorDir = path6.join(cwd, ".cursor");
+    const configPath = path6.join(cursorDir, "mcp.json");
     try {
-      if (!fs5.existsSync(cursorDir) && !options.dryRun) {
-        fs5.mkdirSync(cursorDir, { recursive: true });
+      if (!fs6.existsSync(cursorDir) && !options.dryRun) {
+        fs6.mkdirSync(cursorDir, { recursive: true });
       }
       let config = { mcpServers: {} };
-      if (fs5.existsSync(configPath)) {
-        config = JSON.parse(fs5.readFileSync(configPath, "utf8"));
+      if (fs6.existsSync(configPath)) {
+        config = JSON.parse(fs6.readFileSync(configPath, "utf8"));
       }
       config.mcpServers = config.mcpServers || {};
       config.mcpServers.memhub = this.serverConfig();
       if (!options.dryRun) {
-        fs5.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+        fs6.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
         RulesInjector.injectCursor(cwd);
       }
       return {
         target: "Cursor",
         filePath: configPath,
         success: true,
-        action: fs5.existsSync(configPath) ? "updated" : "created"
+        action: fs6.existsSync(configPath) ? "updated" : "created"
       };
     } catch (err) {
       return {
@@ -1607,11 +1845,12 @@ var IdeConfigInjector = class {
   static injectAntigravity(options) {
     const res = this.injectJsonMcpConfig(
       "Google Antigravity",
-      path5.join(os3.homedir(), ".gemini", "config", "mcp_config.json"),
+      path6.join(getHomeDir3(), ".gemini", "config", "mcp_config.json"),
       options
     );
     if (res.success && !options.dryRun) {
       RulesInjector.injectAntigravity(options.cwd || process.cwd());
+      SkillsInjector.injectAntigravitySkill(options.cwd || process.cwd());
     }
     return res;
   }
@@ -1619,7 +1858,7 @@ var IdeConfigInjector = class {
   static injectWindsurf(options) {
     const res = this.injectJsonMcpConfig(
       "Windsurf",
-      path5.join(os3.homedir(), ".codeium", "windsurf", "mcp_config.json"),
+      path6.join(getHomeDir3(), ".codeium", "windsurf", "mcp_config.json"),
       options
     );
     if (res.success && !options.dryRun) {
@@ -1631,7 +1870,7 @@ var IdeConfigInjector = class {
   static injectCline(options) {
     const res = this.injectJsonMcpConfig(
       "Cline",
-      path5.join(os3.homedir(), ".cline", "data", "settings", "cline_mcp_settings.json"),
+      path6.join(getHomeDir3(), ".cline", "data", "settings", "cline_mcp_settings.json"),
       options
     );
     if (res.success && !options.dryRun) {
@@ -1641,17 +1880,17 @@ var IdeConfigInjector = class {
   }
   /** Generic JSON client using the common { mcpServers: {} } format. */
   static injectOther(configPath, options) {
-    return this.injectJsonMcpConfig("Other MCP client", path5.resolve(configPath), options);
+    return this.injectJsonMcpConfig("Other MCP client", path6.resolve(configPath), options);
   }
   /**
    * Injects config and memory rules for Codex CLI (`config.toml` and `AGENTS.md`)
    */
   static injectCodex(options) {
-    const codexDir = path5.join(os3.homedir(), ".codex");
-    const configPath = path5.join(codexDir, "config.toml");
+    const codexDir = path6.join(getHomeDir3(), ".codex");
+    const configPath = path6.join(codexDir, "config.toml");
     try {
-      if (!fs5.existsSync(codexDir) && !options.dryRun) {
-        fs5.mkdirSync(codexDir, { recursive: true });
+      if (!fs6.existsSync(codexDir) && !options.dryRun) {
+        fs6.mkdirSync(codexDir, { recursive: true });
       }
       const entry = `
 # MemHub MCP Connector
@@ -1660,17 +1899,18 @@ command = "memhub"
 args = ["serve"]
 `;
       let content = "";
-      if (fs5.existsSync(configPath)) {
-        content = fs5.readFileSync(configPath, "utf8");
+      if (fs6.existsSync(configPath)) {
+        content = fs6.readFileSync(configPath, "utf8");
       }
       if (!content.includes("[mcp.servers.memhub]")) {
         content += entry;
         if (!options.dryRun) {
-          fs5.writeFileSync(configPath, content, "utf8");
+          fs6.writeFileSync(configPath, content, "utf8");
         }
       }
       if (!options.dryRun) {
         RulesInjector.injectCodex(options.cwd || process.cwd());
+        SkillsInjector.injectCodexSkill();
       }
       return {
         target: "Codex CLI",
@@ -1688,6 +1928,42 @@ args = ["serve"]
       };
     }
   }
+  /** OpenCode CLI global MCP configuration and rules. */
+  static injectOpenCode(options) {
+    const res = this.injectJsonMcpConfig(
+      "OpenCode CLI",
+      path6.join(getHomeDir3(), ".config", "opencode", "mcp.json"),
+      options
+    );
+    if (!options.dryRun) {
+      RulesInjector.injectOpenCode(options.cwd || process.cwd());
+    }
+    return res;
+  }
+  /** Alibaba Qwen Code / Qwen Agent global MCP configuration and rules. */
+  static injectQwen(options) {
+    const res = this.injectJsonMcpConfig(
+      "Qwen Code",
+      path6.join(getHomeDir3(), ".qwen", "mcp.json"),
+      options
+    );
+    if (!options.dryRun) {
+      RulesInjector.injectQwen(options.cwd || process.cwd());
+    }
+    return res;
+  }
+  /** DeepSeek Harness / CLI global MCP configuration and rules. */
+  static injectDeepSeek(options) {
+    const res = this.injectJsonMcpConfig(
+      "DeepSeek CLI",
+      path6.join(getHomeDir3(), ".deepseek", "mcp.json"),
+      options
+    );
+    if (!options.dryRun) {
+      RulesInjector.injectDeepSeek(options.cwd || process.cwd());
+    }
+    return res;
+  }
   /**
    * Injects for all supported IDEs and tools
    */
@@ -1698,7 +1974,10 @@ args = ["serve"]
       this.injectCodex(options),
       this.injectAntigravity(options),
       this.injectWindsurf(options),
-      this.injectCline(options)
+      this.injectCline(options),
+      this.injectOpenCode(options),
+      this.injectQwen(options),
+      this.injectDeepSeek(options)
     ];
   }
 };
@@ -1708,13 +1987,13 @@ import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { hostname } from "node:os";
 import { execSync as execSync2 } from "node:child_process";
-import path7 from "node:path";
+import path8 from "node:path";
 
 // src/update-notifier.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 import https from "https";
-var CHECK_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+var CHECK_INTERVAL_MS = 2 * 60 * 60 * 1e3;
 var PACKAGE_NAME = "@simplexlat/memhub";
 function compareVersions(v1, v2) {
   const parts1 = v1.split(".").map((p) => parseInt(p, 10) || 0);
@@ -1733,7 +2012,7 @@ async function fetchLatestFromNpm() {
       `https://registry.npmjs.org/${PACKAGE_NAME}/latest`,
       {
         headers: { "User-Agent": "memhub-cli" },
-        timeout: 1500
+        timeout: 2e3
       },
       (res) => {
         if (res.statusCode !== 200) {
@@ -1763,7 +2042,7 @@ async function fetchLatestFromNpm() {
 }
 var UpdateNotifier = class {
   static cacheFile() {
-    return path6.join(resolveStorageDir(), "update-cache.json");
+    return path7.join(resolveStorageDir(), "update-cache.json");
   }
   static async checkForUpdates(currentVersion) {
     if (process.argv.includes("serve") || process.argv.includes("update")) {
@@ -1774,32 +2053,31 @@ var UpdateNotifier = class {
       ensureDirectory(storageDir);
       const cachePath = this.cacheFile();
       let cache = { lastChecked: 0, latestVersion: currentVersion };
-      if (fs6.existsSync(cachePath)) {
+      if (fs7.existsSync(cachePath)) {
         try {
-          cache = JSON.parse(fs6.readFileSync(cachePath, "utf8"));
+          cache = JSON.parse(fs7.readFileSync(cachePath, "utf8"));
         } catch {
         }
       }
       const now = Date.now();
       let latestVersion = cache.latestVersion;
       if (now - cache.lastChecked > CHECK_INTERVAL_MS) {
-        const fetched = await fetchLatestFromNpm();
-        if (fetched) {
-          latestVersion = fetched;
-          cache = { lastChecked: now, latestVersion: fetched };
-          try {
-            fs6.writeFileSync(cachePath, JSON.stringify(cache), "utf8");
-          } catch {
+        fetchLatestFromNpm().then((fetched) => {
+          if (fetched) {
+            cache = { lastChecked: Date.now(), latestVersion: fetched };
+            try {
+              fs7.writeFileSync(cachePath, JSON.stringify(cache), "utf8");
+            } catch {
+            }
           }
-        }
+        }).catch(() => {
+        });
       }
       if (compareVersions(latestVersion, currentVersion) > 0) {
-        process.on("exit", () => {
-          console.error("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-          console.error(`\u2502  \u{1F680} Actualizaci\xF3n disponible para MemHub: ${currentVersion} \u2192 \x1B[32m${latestVersion}\x1B[0m   \u2502`);
-          console.error("\u2502  Ejecuta \x1B[1m\x1B[36mmh update\x1B[0m para instalar la \xFAltima versi\xF3n.         \u2502");
-          console.error("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n");
-        });
+        console.error("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+        console.error(`\u2502  \u{1F680} Actualizaci\xF3n disponible para MemHub: ${currentVersion} \u2192 \x1B[32m${latestVersion}\x1B[0m   \u2502`);
+        console.error("\u2502  Ejecuta \x1B[1m\x1B[36mmh update\x1B[0m para instalar la \xFAltima versi\xF3n.         \u2502");
+        console.error("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n");
       }
     } catch {
     }
@@ -1907,7 +2185,7 @@ function openInBrowser(url) {
 }
 
 // src/cli.ts
-var CLI_VERSION = "0.1.2";
+var CLI_VERSION = "0.1.4";
 void UpdateNotifier.checkForUpdates(CLI_VERSION);
 var program = new Command();
 var supportedTargets = ["claude", "cursor", "windsurf", "cline", "codex", "antigravity"];
@@ -1967,7 +2245,7 @@ async function installToSelectedClients(options) {
     }
   }
 }
-program.name("memhub").description("Local-first MCP proxy for MemHub & agentmemory").version("0.1.2");
+program.name("memhub").description("Local-first MCP proxy for MemHub & agentmemory").version("0.1.4");
 program.command("serve").description("Start the MemHub MCP stdio proxy server").action(async () => {
   const config = getConfig();
   const server = new MemHubMcpServer(config);
@@ -2138,6 +2416,17 @@ program.command("doctor").description("Run system health checks and diagnostics
       console.log(`   \u2717 Cloud API unreachable at ${config.apiUrl} (${health.message})`);
     }
   }
+  console.log("4. Checking for CLI updates:");
+  try {
+    const latest = await fetchLatestFromNpm();
+    if (latest && compareVersions(latest, CLI_VERSION) > 0) {
+      console.log(`   \u26A0\uFE0F Update available: ${CLI_VERSION} \u2192 ${latest}. Run \`mh update\` to upgrade.`);
+    } else {
+      console.log(`   \u2713 MemHub CLI is up to date (v${CLI_VERSION}).`);
+    }
+  } catch {
+    console.log(`   \u2713 Running MemHub CLI v${CLI_VERSION}.`);
+  }
   console.log("\nDoctor inspection completed.");
 });
 program.command("flush").description("Force an immediate push of all pending outbox events to the cloud").action(async () => {
@@ -2179,7 +2468,7 @@ program.command("flush").description("Force an immediate push of all pending out
 });
 program.command("rules").description("Inject or update MemHub persistent memory protocol instructions into all AI client rules").option("--cwd <path>", "Workspace directory to target", process.cwd()).action(async (options) => {
   console.log("\u{1F4DD} Injecting MemHub memory protocol rules into AI client configuration files...");
-  const results = RulesInjector.injectAll(path7.resolve(options.cwd));
+  const results = RulesInjector.injectAll(path8.resolve(options.cwd));
   for (const res of results) {
     if (res.success) {
       console.log(`  \u2713 ${res.target}: ${res.action} at ${res.filePath}`);
@@ -2187,6 +2476,9 @@ program.command("rules").description("Inject or update MemHub persistent memory
       console.log(`  \u2717 ${res.target}: ${res.error}`);
     }
   }
+  SkillsInjector.injectAll(path8.resolve(options.cwd));
+  console.log("  \u2713 Slash Commands (/mem-save, /mem-search, /mem-summary, /mem-status): configured");
+  console.log("  \u2713 Agent Skills: memhub/SKILL.md configured");
   console.log("\n\u2728 AI agents in this workspace and globally will now proactively save and recall team memories.");
 });
 program.command("update").description("Check for updates and upgrade @simplexlat/memhub to the latest version").option("--canary", "Install prerelease canary build").action(async (options) => {