gitmem-mcp 0.2.0 → 1.0.0

package/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.0] - 2026-02-10
+
+### Added
+- **Hooks plugin bundled**: `gitmem install-hooks` / `uninstall-hooks` CLI commands (OD-605, OD-606)
+- **CLI `check` command wired**: `gitmem check` now reachable from CLI (was defined but unreachable)
+- **Fresh-install E2E tests**: 16 integration tests covering CLI commands, hooks, and MCP server lifecycle (OD-607)
+- **README rewrite**: External-developer-facing docs with no internal jargon (OD-608)
+- **CONTRIBUTING.md**: Dev setup, testing tiers, and PR guidelines
+- **First public npm release** (OD-609)
+
+### Changed
+- Package name standardized to `gitmem-mcp` for npm
+- `gitmem configure` output uses `gitmem-mcp` (matching npm package name)
+- Removed internal project defaults from CLI commands
+
 ## [0.2.0] - 2026-02-08
 
 ### Added
@@ -42,6 +57,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Cache management (status, flush, health)
 - Agent identity detection
 
-[Unreleased]: https://github.com/nTEG-dev/gitmem/compare/v0.2.0...HEAD
+[Unreleased]: https://github.com/nTEG-dev/gitmem/compare/v1.0.0...HEAD
+[1.0.0]: https://github.com/nTEG-dev/gitmem/compare/v0.2.0...v1.0.0
 [0.2.0]: https://github.com/nTEG-dev/gitmem/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/nTEG-dev/gitmem/releases/tag/v0.1.0

package/README.md

@@ -2,85 +2,88 @@
 
 Institutional memory for AI coding agents. Never repeat the same mistake.
 
-## Features
+GitMem is an [MCP server](https://modelcontextprotocol.io/) that gives your AI coding agent persistent memory across sessions. It remembers mistakes (scars), successes (wins), and architectural decisions — so your agent learns from experience instead of starting from scratch every time.
 
-- **Predict**: Check institutional memory for relevant learnings before taking action (core GitMem MVP tool)
-- **Session Start**: Initialize session, detect agent identity, load last session context, retrieve relevant learnings, load recent decisions
-- **Session Close**: Persist session with compliance validation (standard/quick/autonomous close types)
-- **Learning Capture**: Create scars, wins, patterns, and anti-patterns in institutional memory
-- **Decision Logging**: Log architectural and operational decisions
-- **Scar Usage Tracking**: Track scar application for effectiveness measurement
-- **[Threads](docs/threads.md)**: Persistent work items that carry across sessions — create, list, resolve
-- **[Doc-Debt Tracking](docs/doc-debt-tracking.md)**: Detect when decisions outpace documentation updates
+## How It Works
 
-### Learning Types
+1. **Before each task**, the agent calls `recall` with a plan — GitMem surfaces relevant warnings from past sessions
+2. **When mistakes happen**, the agent captures them as "scars" — failures with context and counter-arguments
+3. **When things go well**, the agent captures wins and patterns to replicate
+4. **At session close**, the agent reflects on what worked, what broke, and what to do differently
 
-GitMem tracks **all learning types**:
-- **Scars** — Failures to avoid (critical institutional memory)
-- **Patterns** — Neutral observations and recurring patterns
-- **Wins** — Successes to replicate
-- **Anti-patterns** — Known bad approaches
+Over time, your agent builds institutional memory that prevents repeated mistakes and reinforces good patterns.
 
-All learning types use the same vector search infrastructure and are queried together for comprehensive institutional context.
+### Two Tiers
+
+| | Free Tier | Pro Tier |
+|---|-----------|----------|
+| **Storage** | Local `.gitmem/` directory | Supabase (PostgreSQL + pgvector) |
+| **Search** | Keyword matching | Semantic vector search |
+| **Setup** | Zero config | Supabase project + embedding API key |
+| **Best for** | Solo projects | Teams, cross-project memory |
 
 ## Quick Start
 
 ### Free Tier (zero config)
 
 ```bash
-npx gitmem init
-npx gitmem configure
+npx gitmem-mcp init
+npx gitmem-mcp configure
 ```
 
-Copy `CLAUDE.md.template` into your project, then start coding — memory is active.
+This creates a `.gitmem/` directory with starter scars and prints the MCP config to add to your editor.
+
+Add the config to your project's `.mcp.json` (Claude Code) or IDE settings (Cursor, Windsurf), then copy `CLAUDE.md.template` into your project root. Start coding — memory is active.
 
 ### Pro Tier (with Supabase)
 
 1. Create a free Supabase project at [database.new](https://database.new)
-2. `npx gitmem setup` — copy the SQL output into Supabase SQL Editor
+2. `npx gitmem-mcp setup` — copy the SQL output into Supabase SQL Editor
 3. Get an API key for embeddings (OpenAI, OpenRouter, or Ollama)
-4. `npx gitmem configure` — generates your `.mcp.json` config
-5. `npx gitmem init` — loads starter scars into Supabase
-6. Copy `CLAUDE.md.template` into your project
-7. Start coding — memory is active!
+4. Set `SUPABASE_URL` and `SUPABASE_SERVICE_ROLE_KEY` as environment variables
+5. `npx gitmem-mcp configure` — generates your MCP config with env vars
+6. `npx gitmem-mcp init` — loads starter scars into Supabase
+7. Copy `CLAUDE.md.template` into your project
+8. Start coding — memory is active!
 
 ## Installation
 
-### npm (recommended)
+### npx (no install required)
 
 ```bash
-npm install gitmem
+npx gitmem-mcp init
 ```
 
-### npx (no install)
+### Global install
 
 ```bash
-npx gitmem init
+npm install -g gitmem-mcp
+gitmem init
 ```
 
-### MCP Registration
+### MCP Configuration
 
-Add to your project's `.mcp.json` (Claude Code) or IDE settings (Cursor, Windsurf):
+Add to your project's `.mcp.json` (Claude Code) or IDE MCP settings (Cursor, Windsurf):
 
+**Free Tier:**
 ```json
 {
   "mcpServers": {
     "gitmem": {
       "command": "npx",
-      "args": ["-y", "gitmem"]
+      "args": ["-y", "gitmem-mcp"]
     }
   }
 }
 ```
 
-For Pro tier, add environment variables:
-
+**Pro Tier:**
 ```json
 {
   "mcpServers": {
     "gitmem": {
       "command": "npx",
-      "args": ["-y", "gitmem"],
+      "args": ["-y", "gitmem-mcp"],
       "env": {
         "SUPABASE_URL": "https://your-project.supabase.co",
         "SUPABASE_SERVICE_ROLE_KEY": "eyJ...",
@@ -91,131 +94,126 @@ For Pro tier, add environment variables:
 }
 ```
 
+Alternative embedding providers (set instead of `OPENAI_API_KEY`):
+- `OPENROUTER_API_KEY` — OpenRouter (multiple models)
+- `OLLAMA_URL` — Local Ollama instance (no API key needed)
+
 ### Verify
 
 ```bash
+# Claude Code
 claude mcp list
-# Should show: gitmem: ✓ Connected
+# Should show: gitmem: connected
 ```
 
 ## CLI Commands
 
 | Command | Description |
 |---------|-------------|
-| `gitmem init` | Initialize memory (loads starter scars) |
-| `gitmem setup` | Output SQL for Supabase schema setup |
-| `gitmem configure` | Generate `.mcp.json` config |
-| `gitmem server` | Start MCP server (default) |
+| `gitmem init` | Initialize memory — loads starter scars (auto-detects tier) |
+| `gitmem setup` | Output SQL for Supabase schema setup (Pro tier) |
+| `gitmem configure` | Generate MCP config for your editor |
+| `gitmem check` | Run diagnostic health check |
+| `gitmem check --full` | Full diagnostic with benchmarks |
+| `gitmem install-hooks` | Install Claude Code hooks plugin |
+| `gitmem uninstall-hooks` | Remove Claude Code hooks plugin |
+| `gitmem server` | Start MCP server (default when no command given) |
 | `gitmem help` | Show help |
 
 ## MCP Tools
 
-### `predict`
-
-Check institutional memory for relevant learnings before taking action.
-
-**Parameters:**
-- `plan` (required) - What you're about to do (e.g., "deploy to production")
-- `project?` - Project scope (default: "orchestra_dev")
-- `match_count?` - Number of learnings to return (default: 3)
-
-### `session_start`
-
-Initialize session and load institutional context.
-
-**Parameters:**
-- `agent_identity?` - Override agent identity (auto-detects if not provided)
-- `linear_issue?` - Current Linear issue identifier
-- `project?` - Project scope
-
-### `session_close`
+GitMem exposes tools via the Model Context Protocol. Your AI agent calls these automatically based on the instructions in `CLAUDE.md.template`.
 
-Persist session with compliance validation.
+### Core Tools
 
-**Parameters:**
-- `session_id` (required) - From session_start
-- `close_type` (required) - "standard" | "quick" | "autonomous"
-- `closing_reflection?` - Reflection answers (required for standard)
-- `human_corrections?` - Human additions (required for standard)
+| Tool | Purpose |
+|------|---------|
+| `recall` | Check memory for relevant warnings before taking action |
+| `session_start` | Initialize session, load context from last session |
+| `session_close` | Persist session with reflection |
+| `create_learning` | Capture scars (failures), wins (successes), or patterns |
+| `create_decision` | Log architectural/operational decisions |
+| `record_scar_usage` | Track which scars were applied |
+| `search` | Search institutional memory (exploration, no side effects) |
+| `log` | List recent learnings chronologically |
 
-### `create_learning`
+### Thread Tools
 
-Create scar, win, or pattern entry.
+Threads are persistent work items that carry across sessions.
 
-**Parameters:**
-- `learning_type` (required) - "scar" | "win" | "pattern"
-- `title`, `description` (required)
-- `severity?` - For scars: "critical" | "high" | "medium" | "low"
-- `counter_arguments?` - For scars: min 2 required
+| Tool | Purpose |
+|------|---------|
+| `list_threads` | List open threads |
+| `create_thread` | Create a new thread |
+| `resolve_thread` | Mark a thread as resolved |
 
-### `create_decision`
+### Pro Tier Tools
 
-Log decision to institutional memory.
+Available when Supabase is configured:
 
-**Parameters:**
-- `title`, `decision`, `rationale` (required)
-- `alternatives_considered?` - Rejected options
-- `docs_affected?` - Docs/files affected by this decision (relative paths from repo root). Used for [doc-debt tracking](docs/doc-debt-tracking.md).
-- `personas_involved?` - Team personas involved
-- `linear_issue?` - Associated issue
+| Tool | Purpose |
+|------|---------|
+| `analyze` | Session analytics and pattern detection |
+| `prepare_context` | Multi-agent context preparation |
+| `absorb_observations` | Multi-agent observation absorption |
+| Cache tools | `cache_status`, `cache_flush`, `cache_health` |
 
-### `record_scar_usage`
+## Learning Types
 
-Track scar application.
+GitMem tracks four types of institutional knowledge:
 
-**Parameters:**
-- `scar_id` (required) - Learning UUID
-- `reference_type` (required) - "explicit" | "implicit" | "acknowledged" | "refuted" | "none"
-- `reference_context` (required) - How scar was applied
+- **Scars** — Failures to avoid. Include severity and counter-arguments (why someone might think the mistake is OK). These are the core of GitMem.
+- **Wins** — Successes to replicate. Capture what worked and why.
+- **Patterns** — Neutral observations and recurring approaches.
+- **Anti-patterns** — Known bad approaches to flag.
 
-### `list_threads`
+All types are searched together when `recall` is called, giving the agent comprehensive context.
 
-List open threads (persistent work items across sessions). See [threads docs](docs/threads.md).
+## Hooks Plugin
 
-**Parameters:**
-- `status?` - Filter: "open" (default) or "resolved"
-- `include_resolved?` - Include recently resolved threads
+GitMem includes a Claude Code hooks plugin that automates memory protocols:
 
-### `create_thread`
+- **SessionStart** — Automatically calls `session_start` when a session begins
+- **PreToolUse** — Reminds the agent to call `recall` before consequential actions
+- **PostToolUse** — Tracks scar acknowledgment
+- **Stop** — Reminds the agent to close sessions properly
 
-Create a new open thread.
-
-**Parameters:**
-- `text` (required) - Thread description
-
-### `resolve_thread`
-
-Mark a thread as resolved.
+Install:
+```bash
+npx gitmem-mcp install-hooks
+```
 
-**Parameters:**
-- `thread_id?` - Exact thread ID (e.g., "t-a1b2c3d4")
-- `text_match?` - Case-insensitive substring match
-- `resolution_note?` - Brief resolution explanation
+Uninstall:
+```bash
+npx gitmem-mcp uninstall-hooks
+```
 
 ## Agent Detection
 
-Automatically detects agent identity based on:
-- `CLAUDE_CODE_ENTRYPOINT` environment variable
-- Docker container presence (`/.dockerenv`)
-- Hostname
+GitMem automatically detects the AI agent identity based on environment:
 
-| ENTRYPOINT | Docker | Identity |
-|------------|--------|----------|
-| cli | YES | CLI |
-| cli | NO | CODA-1 |
-| claude-desktop | NO | DAC |
-| (empty) | (has fs) | Brain_Local |
-| (empty) | (no fs) | Brain_Cloud |
+| Environment | Identity |
+|-------------|----------|
+| Claude Code in Docker | CLI |
+| Claude Desktop app | DAC |
+| Claude.ai with filesystem | Brain_Local |
+| Claude.ai without filesystem | Brain_Cloud |
+
+Override with `agent_identity` parameter in `session_start`.
 
 ## Development
 
 ```bash
+git clone https://github.com/nTEG-dev/gitmem.git
+cd gitmem
 npm install
-npm run build
-npm run dev  # Watch mode
-npm test
+npm run build    # Compile TypeScript + run unit tests
+npm run dev      # Watch mode
+npm test         # Run unit tests
 ```
 
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, testing tiers, and PR guidelines.
+
 ## License
 
-MIT
+MIT — see [LICENSE](LICENSE).

package/bin/gitmem.js

@@ -4,15 +4,29 @@
  * GitMem CLI
  *
  * Commands:
- *   gitmem setup     — Output SQL to paste into Supabase SQL Editor (pro/dev)
- *   gitmem init      — Load starter scars (local JSON or Supabase)
- *   gitmem configure — Generate .mcp.json entry for Claude Code
- *   gitmem server    — Start MCP server (default)
+ *   gitmem setup           — Output SQL to paste into Supabase SQL Editor (pro/dev)
+ *   gitmem init            — Load starter scars (local JSON or Supabase)
+ *   gitmem configure       — Generate .mcp.json entry for Claude Code
+ *   gitmem check           — Run diagnostic health check
+ *   gitmem install-hooks   — Install Claude Code hooks plugin
+ *   gitmem uninstall-hooks — Remove Claude Code hooks plugin
+ *   gitmem server          — Start MCP server (default)
  */
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import {
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  existsSync,
+  cpSync,
+  rmSync,
+  readdirSync,
+  chmodSync,
+  statSync,
+} from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
+import { homedir } from "os";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const command = process.argv[2];
@@ -22,11 +36,15 @@ function printUsage() {
 GitMem — Institutional Memory for AI Coding
 
 Usage:
-  npx gitmem setup      Output SQL for Supabase schema setup (pro/dev tier)
-  npx gitmem init       Load starter scars (auto-detects tier)
-  npx gitmem configure  Generate .mcp.json config for Claude Code
-  npx gitmem server     Start MCP server (default)
-  npx gitmem help       Show this help message
+  npx gitmem setup             Output SQL for Supabase schema setup (pro/dev tier)
+  npx gitmem init              Load starter scars (auto-detects tier)
+  npx gitmem configure         Generate .mcp.json config for Claude Code
+  npx gitmem check              Run diagnostic health check
+  npx gitmem check --full       Full diagnostic with benchmarks
+  npx gitmem install-hooks     Install Claude Code hooks plugin
+  npx gitmem uninstall-hooks   Remove Claude Code hooks plugin
+  npx gitmem server            Start MCP server (default)
+  npx gitmem help              Show this help message
 
 Free Tier (zero config):
   1. npx gitmem init
@@ -183,7 +201,7 @@ function cmdConfigure() {
       mcpServers: {
         gitmem: {
           command: "npx",
-          args: ["-y", "@nteg-dev/gitmem"],
+          args: ["-y", "gitmem-mcp"],
         },
       },
     };
@@ -202,7 +220,7 @@ function cmdConfigure() {
       mcpServers: {
         gitmem: {
           command: "npx",
-          args: ["-y", "@nteg-dev/gitmem"],
+          args: ["-y", "gitmem-mcp"],
           env: {
             SUPABASE_URL: "https://YOUR_PROJECT.supabase.co",
             SUPABASE_SERVICE_ROLE_KEY: "eyJ...",
@@ -238,7 +256,7 @@ function cmdConfigure() {
  */
 async function cmdSessionStart() {
   const args = process.argv.slice(3);
-  let project = "orchestra_dev";
+  let project = undefined;
   let agentIdentity = undefined;
 
   for (let i = 0; i < args.length; i++) {
@@ -347,6 +365,207 @@ async function cmdSessionRefresh() {
   }
 }
 
+/**
+ * Install the bundled hooks plugin to ~/.claude/plugins/gitmem-hooks/
+ *
+ * Copies the hooks/ directory from this package into the Claude Code
+ * plugins directory. Use --force to overwrite an existing installation.
+ */
+function cmdInstallHooks() {
+  const force = process.argv.includes("--force");
+  const hooksSource = join(__dirname, "..", "hooks");
+  const pluginsDir = join(homedir(), ".claude", "plugins");
+  const targetDir = join(pluginsDir, "gitmem-hooks");
+
+  console.log("GitMem Hooks Plugin — Install");
+  console.log("=============================");
+  console.log("");
+
+  // Check that bundled hooks exist
+  if (!existsSync(hooksSource) || !existsSync(join(hooksSource, ".claude-plugin", "plugin.json"))) {
+    console.error("Error: Bundled hooks directory not found.");
+    console.error("Expected at:", hooksSource);
+    console.error("Ensure the package is installed correctly.");
+    process.exit(1);
+  }
+
+  // Check if already installed
+  if (existsSync(targetDir) && !force) {
+    console.log("Hooks plugin is already installed at:");
+    console.log(`  ${targetDir}`);
+    console.log("");
+    console.log("To reinstall (overwrite), run:");
+    console.log("  npx gitmem install-hooks --force");
+    return;
+  }
+
+  // Create plugins directory if needed
+  if (!existsSync(pluginsDir)) {
+    mkdirSync(pluginsDir, { recursive: true });
+  }
+
+  // Copy hooks to target
+  console.log(`Source:  ${hooksSource}`);
+  console.log(`Target:  ${targetDir}`);
+  console.log("");
+
+  try {
+    cpSync(hooksSource, targetDir, { recursive: true });
+  } catch (err) {
+    console.error("Error copying hooks plugin:", err.message);
+    process.exit(1);
+  }
+
+  // Make shell scripts executable
+  const scriptsDir = join(targetDir, "scripts");
+  if (existsSync(scriptsDir)) {
+    for (const file of readdirSync(scriptsDir)) {
+      if (file.endsWith(".sh")) {
+        chmodSync(join(scriptsDir, file), 0o755);
+      }
+    }
+  }
+  const testsDir = join(targetDir, "tests");
+  if (existsSync(testsDir)) {
+    for (const file of readdirSync(testsDir)) {
+      if (file.endsWith(".sh")) {
+        chmodSync(join(testsDir, file), 0o755);
+      }
+    }
+  }
+
+  console.log("Installed successfully!");
+  console.log("");
+
+  // Verify gitmem MCP is configured (non-blocking warning)
+  let mcpFound = false;
+  const mcpPaths = [
+    join(process.cwd(), ".mcp.json"),
+    join(process.cwd(), ".claude", "mcp.json"),
+    join(homedir(), ".claude.json"),
+  ];
+  for (const p of mcpPaths) {
+    if (existsSync(p)) {
+      try {
+        const cfg = JSON.parse(readFileSync(p, "utf-8"));
+        const servers = cfg.mcpServers || {};
+        if (servers.gitmem || servers["gitmem-mcp"]) {
+          mcpFound = true;
+          break;
+        }
+      } catch {
+        // ignore parse errors
+      }
+    }
+  }
+
+  if (!mcpFound) {
+    console.log("WARNING: gitmem MCP server not detected in .mcp.json.");
+    console.log("  Hooks will be silent until gitmem MCP is configured.");
+    console.log("  Run: npx gitmem configure");
+    console.log("");
+  }
+
+  console.log("Next steps:");
+  console.log("  1. Restart Claude Code (exit and re-open)");
+  console.log("  2. The plugin hooks will activate on next session");
+  console.log("");
+  console.log("To update after a gitmem version bump:");
+  console.log("  npx gitmem install-hooks --force");
+}
+
+/**
+ * Uninstall the hooks plugin from ~/.claude/plugins/gitmem-hooks/
+ *
+ * Removes the plugin directory, cleans up enabledPlugins from settings,
+ * and removes temp state directories.
+ */
+function cmdUninstallHooks() {
+  const pluginDir = join(homedir(), ".claude", "plugins", "gitmem-hooks");
+
+  console.log("GitMem Hooks Plugin — Uninstall");
+  console.log("===============================");
+  console.log("");
+
+  // Remove plugin directory
+  if (existsSync(pluginDir)) {
+    rmSync(pluginDir, { recursive: true, force: true });
+    console.log("[uninstall] Removed plugin directory:", pluginDir);
+  } else {
+    console.log("[uninstall] Plugin directory not found (already removed)");
+  }
+
+  // Clean enabledPlugins from .claude/settings.json
+  // (Key scar: claude plugin uninstall doesn't always clean this up)
+  const settingsFiles = [
+    join(process.cwd(), ".claude", "settings.json"),
+    join(process.cwd(), ".claude", "settings.local.json"),
+  ];
+
+  for (const settingsPath of settingsFiles) {
+    if (existsSync(settingsPath)) {
+      try {
+        const cfg = JSON.parse(readFileSync(settingsPath, "utf-8"));
+        if (cfg.enabledPlugins) {
+          let cleaned = false;
+          for (const key of Object.keys(cfg.enabledPlugins)) {
+            if (key.startsWith("gitmem-hooks")) {
+              delete cfg.enabledPlugins[key];
+              cleaned = true;
+            }
+          }
+          if (cleaned) {
+            writeFileSync(settingsPath, JSON.stringify(cfg, null, 2) + "\n");
+            console.log(`[cleanup] Removed enabledPlugins entry from ${settingsPath}`);
+          }
+        }
+      } catch {
+        // ignore parse errors
+      }
+    }
+  }
+
+  // Clean temp state directories
+  let cleaned = 0;
+  try {
+    const tmpDir = "/tmp";
+    for (const entry of readdirSync(tmpDir)) {
+      if (entry.startsWith("gitmem-hooks-")) {
+        const fullPath = join(tmpDir, entry);
+        try {
+          if (statSync(fullPath).isDirectory()) {
+            rmSync(fullPath, { recursive: true, force: true });
+            cleaned++;
+          }
+        } catch {
+          // ignore permission errors on other users' temp dirs
+        }
+      }
+    }
+  } catch {
+    // /tmp read error — not critical
+  }
+
+  if (cleaned > 0) {
+    console.log(`[cleanup] Removed ${cleaned} temp state director(ies) from /tmp/`);
+  }
+
+  // Clean debug log
+  const debugLog = "/tmp/gitmem-hooks-plugin-debug.log";
+  if (existsSync(debugLog)) {
+    rmSync(debugLog, { force: true });
+    console.log("[cleanup] Removed debug log");
+  }
+
+  console.log("");
+  console.log("Uninstall complete.");
+  console.log("");
+  console.log("Notes:");
+  console.log("  - gitmem MCP server config (.mcp.json) was NOT modified");
+  console.log("  - Restart Claude Code for changes to take effect");
+  console.log("  - To reinstall: npx gitmem install-hooks");
+}
+
 switch (command) {
   case "setup":
     cmdSetup();
@@ -357,6 +576,15 @@ switch (command) {
   case "configure":
     cmdConfigure();
     break;
+  case "check":
+    import("../dist/commands/check.js").then((m) => m.main(process.argv.slice(3)));
+    break;
+  case "install-hooks":
+    cmdInstallHooks();
+    break;
+  case "uninstall-hooks":
+    cmdUninstallHooks();
+    break;
   case "session-start":
     cmdSessionStart();
     break;
@@ -373,7 +601,7 @@ switch (command) {
     printUsage();
     break;
   case undefined:
-    // Default: start MCP server (npx @nteg-dev/gitmem should start serving)
+    // Default: start MCP server (npx gitmem-mcp should start serving)
     import("../dist/index.js");
     break;
   default: