pkm-mcp-server 1.3.3 → 1.4.1

package/CHANGELOG.md

@@ -6,6 +6,20 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.4.1] - 2026-03-21
+
+### Fixed
+- SessionStart hook crash when installed via `init` — `resolve-project.js` imported `resolvePath` from `../helpers.js` which doesn't exist at `~/.claude/hooks/pkm/`. Inlined the path security check to remove the external dependency.
+
+## [1.4.0] - 2026-03-21
+
+### Added
+- `pkm-mcp-server init` now configures PKM hooks for Claude Code — copies hook scripts to `~/.claude/hooks/pkm/` and writes hook entries to `~/.claude/settings.json`
+- Individual opt-in for each hook: project context loading (SessionStart), passive capture (Stop), and explicit capture (PostToolUse)
+- Merge-aware settings.json writing — preserves unrelated hooks, replaces PKM entries on re-run
+- Hook script MCP config patching — works for both npx and cloned-repo installations
+- 32 new unit tests for hook setup functions (`patchMcpConfig`, `isPkmHookEntry`, `buildHookEntries`, `mergeHooksIntoSettings`, `copyHooks`)
+
 ## [1.3.3] - 2026-03-21
 
 ### Fixed

package/README.md

@@ -91,12 +91,34 @@ npm install -g pkm-mcp-server
 pkm-mcp-server init
 ```
 
-The setup wizard walks you through:
-1. Vault path (existing or new)
-2. Note templates (full set, minimal, or skip)
-3. PARA folder structure
-4. OpenAI API key for semantic search (optional)
-5. Automatic registration with Claude Code
+The setup wizard walks you through 5 steps. Nothing is written until you confirm each step, and you can press Ctrl+C at any time to cancel.
+
+**Step 1 — Vault path.** Point to an existing Obsidian vault or create a new one. The wizard resolves `~`, `$HOME`, and relative paths automatically. Safety checks prevent using system directories (`/`, `/home`, etc.) as a vault. For existing non-empty directories you can use it as-is, create a subfolder inside it, or wipe it (with triple confirmation). You'll be offered an optional backup before any changes — this creates a timestamped copy next to the vault (e.g. `PKM-backup-2026-03-21T14-30-00/`).
+
+**Step 2 — Note templates.** Copies template files into `<vault>/05-Templates/`. Three options:
+- **Full set** — all 13 templates (`adr`, `daily-note`, `devlog`, `fleeting-note`, `literature-note`, `meeting-notes`, `moc`, `note`, `permanent-note`, `project-index`, `research-note`, `task`, `troubleshooting-log`)
+- **Minimal** — just `note.md` (a single generic template)
+- **Skip** — for users with their own templates
+
+Existing templates are never overwritten.
+
+**Step 3 — PARA folder structure.** Creates 7 top-level folders with `_index.md` stubs:
+
+| Folder | Purpose |
+|--------|---------|
+| `00-Inbox/` | Quick captures and unsorted notes |
+| `01-Projects/` | Active project folders |
+| `02-Areas/` | Ongoing areas of responsibility |
+| `03-Resources/` | Reference material and reusable knowledge |
+| `04-Archive/` | Completed or inactive items |
+| `05-Templates/` | Note templates |
+| `06-System/` | System configuration and metadata |
+
+Each `_index.md` has `type: moc` frontmatter. Existing folders and index files are skipped.
+
+**Step 4 — OpenAI API key (optional).** Enables `vault_semantic_search` and `vault_suggest_links`. The key is stored only in your Claude Code configuration (`~/.claude.json`) and is used solely for generating text embeddings. You can add this later — see [Enable Semantic Search](#3-enable-semantic-search-optional).
+
+**Step 5 — Claude Code registration.** Registers the MCP server via `claude mcp add -s user`. If `obsidian-pkm` is already registered, you'll be asked whether to overwrite. The exact command is shown for confirmation before running. If the `claude` CLI is not found on PATH, the wizard prints the manual registration command instead.
 
 Restart Claude Code after setup. The server provides all tools except semantic search out of the box.
 
@@ -109,6 +131,8 @@ npm install
 node cli.js init
 ```
 
+You can also run the wizard without a global install: `npx pkm-mcp-server init`.
+
 ### 2. Manual Registration (alternative)
 
 If you prefer to skip the wizard, register directly with the Claude CLI:
@@ -222,9 +246,9 @@ Vault/
 
 ### Templates
 
-Copy the files from `templates/` into your vault's `05-Templates/` folder. `vault_write` loads all `.md` files from that directory at startup and enforces frontmatter on every note created.
+`vault_write` loads all `.md` files from `05-Templates/` at startup and enforces frontmatter on every note created. The setup wizard (`pkm-mcp-server init`) installs these automatically — or you can copy the files from `templates/` manually.
 
-Included templates: `project-index`, `adr`, `devlog`, `permanent-note`, `research-note`, `troubleshooting-log`, `fleeting-note`, `literature-note`, `meeting-notes`, `moc`, `daily-note`, `task`. Add your own templates to `05-Templates/` and they become available to `vault_write` automatically.
+13 included templates: `adr`, `daily-note`, `devlog`, `fleeting-note`, `literature-note`, `meeting-notes`, `moc`, `note`, `permanent-note`, `project-index`, `research-note`, `task`, `troubleshooting-log`. Add your own templates to `05-Templates/` and they become available to `vault_write` automatically.
 
 ### CLAUDE.md for Your Projects
 

package/hooks/resolve-project.js

@@ -1,6 +1,12 @@
 import fs from "fs/promises";
 import path from "path";
-import { resolvePath } from "../helpers.js";
+
+function assertPathWithinVault(relativePath, vaultPath) {
+  const resolved = path.resolve(vaultPath, relativePath);
+  if (resolved !== vaultPath && !resolved.startsWith(vaultPath + path.sep)) {
+    throw new Error("Path escapes vault directory");
+  }
+}
 
 export async function resolveProject(cwd, vaultPath) {
   try {
@@ -35,7 +41,7 @@ export async function resolveProject(cwd, vaultPath) {
     if (match) {
       const annotatedPath = match[1].trim();
       try {
-        resolvePath(annotatedPath, vaultPath);
+        assertPathWithinVault(annotatedPath, vaultPath);
       } catch (e) {
         if (e.message === "Path escapes vault directory") {
           return { error: `CLAUDE.md annotation escapes vault directory: ${annotatedPath}` };

package/hooks/stop-sweep.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { appendFileSync, createWriteStream, mkdirSync } from "node:fs";
+import { access } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveProject } from "./resolve-project.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const VAULT_PATH = process.env.VAULT_PATH;
+const LOG_DIR = VAULT_PATH ? join(VAULT_PATH, ".obsidian", "hook-logs") : null;
+
+function logError(message) {
+  if (!LOG_DIR) {
+    console.error(`stop-sweep: ${message}`);
+    return;
+  }
+  try {
+    mkdirSync(LOG_DIR, { recursive: true });
+    appendFileSync(join(LOG_DIR, "sweep-errors.log"), `${new Date().toISOString()} ${message}\n`);
+  } catch {
+    console.error(`stop-sweep: ${message}`);
+  }
+}
+
+async function main() {
+  // Read hook input from stdin
+  let inputJson = "";
+  for await (const chunk of process.stdin) {
+    inputJson += chunk;
+  }
+
+  let input;
+  try {
+    input = JSON.parse(inputJson);
+  } catch {
+    logError("could not parse hook input JSON");
+    return;
+  }
+
+  const { transcript_path, session_id, cwd } = input;
+
+  // Skip if no transcript
+  if (!transcript_path) return;
+  try {
+    await access(transcript_path);
+  } catch {
+    return; // transcript file missing — normal for non-conversation triggers
+  }
+
+  if (!VAULT_PATH) {
+    console.error("stop-sweep: VAULT_PATH not set");
+    return;
+  }
+
+  if (!cwd) {
+    logError("hook input missing 'cwd' field");
+    return;
+  }
+
+  // Resolve project — no project, no captures
+  const { projectPath, error } = await resolveProject(cwd, VAULT_PATH);
+  if (error || !projectPath) return;
+
+  // Build MCP config
+  const indexPath = join(__dirname, "..", "index.js");
+  const mcpEnv = { VAULT_PATH };
+  if (process.env.OPENAI_API_KEY) {
+    mcpEnv.OPENAI_API_KEY = process.env.OPENAI_API_KEY;
+  }
+  const mcpConfig = JSON.stringify({
+    mcpServers: {
+      "obsidian-pkm": {
+        command: "node",
+        args: [indexPath],
+        env: mcpEnv,
+      },
+    },
+  });
+
+  const prompt = `You are a PKM librarian agent. Your job is to identify PKM-worthy content from the most recent conversation exchange and file it correctly in the vault.
+
+## Context
+
+- Project: ${projectPath}
+- Session: ${session_id}
+- Transcript: ${transcript_path}
+
+## Step 1: Read the transcript
+
+Read the file at ${transcript_path}. Find the LAST user message and LAST assistant response — this is the current exchange. All prior messages are historical context only. Do NOT capture anything from prior messages.
+
+## Step 2: Classify what's PKM-worthy
+
+Be conservative. Most exchanges produce NOTHING worth capturing. Skip:
+- Trivial Q&A, clarifications, implementation details obvious from code
+- Anything restating existing project context
+- Content already handled by a vault_capture call in the same exchange
+  (read the vault_capture arguments to see what type/title/content was captured;
+  skip that specific item, but still capture other PKM-worthy content)
+
+Before creating any note, use vault_search to check if a very similar note already exists — another sweep instance may have captured the same content from a prior exchange in a rapid conversation.
+
+If you find something worth capturing, classify it:
+
+| Content Type | Action |
+|---|---|
+| New task identified | Create task note: vault_write(template: "task", path: "${projectPath}/tasks/{kebab-title}.md") |
+| Task completed/status changed | Find existing task via vault_query, then vault_update_frontmatter to update status |
+| Significant decision agreed upon | Create ADR: vault_write(template: "adr", path: "${projectPath}/development/decisions/ADR-NNN-{kebab-title}.md") — use vault_list on the decisions directory to find the next ADR number |
+| Research finding / gotcha | Create research note: vault_write(template: "research-note", path: "${projectPath}/research/{kebab-title}.md") |
+| Bug root cause documented | Create troubleshooting log: vault_write(template: "troubleshooting-log", path: "${projectPath}/development/debug/{kebab-title}.md") |
+| Minor implementation detail | SKIP — it's in the code/commits |
+
+## Step 3: Create/update notes properly
+
+For every note you create:
+1. Use vault_write with the correct template
+2. Use vault_edit to replace ALL template placeholders with real content
+3. Use vault_suggest_links to find related notes (skip gracefully if unavailable)
+4. Add [[wikilinks]] to the related notes in the body
+5. Verify the note has no placeholder text remaining
+
+For task updates:
+1. Use vault_query to find the task by title/tags
+2. Use vault_update_frontmatter to update status/priority
+3. Optionally vault_append to add context about what changed
+
+## Step 4: Quality check
+
+If you created any notes, read each one back to confirm:
+- No template placeholders remain
+- Wikilinks are present to related notes (if vault_suggest_links was available)
+- Frontmatter is complete and valid
+
+If nothing is PKM-worthy, do nothing. Doing nothing is the correct default.`;
+
+  // All vault tools except vault_trash and vault_capture
+  const allowedTools = [
+    "vault_read", "vault_peek", "vault_write", "vault_append", "vault_edit",
+    "vault_update_frontmatter", "vault_search", "vault_semantic_search",
+    "vault_suggest_links", "vault_list", "vault_recent", "vault_links",
+    "vault_neighborhood", "vault_query", "vault_tags", "vault_activity", "vault_move",
+  ].map(t => `mcp__obsidian-pkm__${t}`).join(" ");
+
+  // Ensure log directory exists
+  mkdirSync(LOG_DIR, { recursive: true });
+  const logFile = join(LOG_DIR, `sweep-${new Date().toISOString().replace(/[:.]/g, "").slice(0, 15)}.log`);
+
+  const child = spawn("claude", [
+    "-p",
+    "--model", "sonnet",
+    "--mcp-config", mcpConfig,
+    "--max-turns", "15",
+    "--allowedTools", allowedTools,
+  ], {
+    detached: true,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  // Pipe prompt to stdin
+  child.stdin.write(prompt);
+  child.stdin.end();
+
+  // Log stdout and stderr to file
+  const logStream = createWriteStream(logFile, { flags: "a" });
+  child.stdout.pipe(logStream);
+  child.stderr.pipe(logStream);
+
+  // Detach — let the background process run independently
+  child.unref();
+}
+
+main().catch((err) => {
+  logError(`uncaught: ${err.message}`);
+  process.exit(0);
+});

package/init.js

@@ -198,6 +198,160 @@ export function detectInstallType(filePath) {
   return { command: "node", args: [cliPath] };
 }
 
+/**
+ * Replace the MCP_CONFIG= line in a shell script with a pre-baked JSON config.
+ * @param {string} scriptContent - Shell script content
+ * @param {{ command: string, args: string[] }} installType - Server command
+ * @returns {string} Patched script content
+ */
+export function patchMcpConfig(scriptContent, installType) {
+  const argsJson = JSON.stringify(installType.args);
+  const replacement = `MCP_CONFIG='{"mcpServers":{"obsidian-pkm":{"command":"${installType.command}","args":${argsJson},"env":{"VAULT_PATH":"'"$VAULT_PATH"'"}}}}'`;
+  const lines = scriptContent.split("\n");
+  const patched = lines.map(line => line.startsWith("MCP_CONFIG=") ? replacement : line);
+  return patched.join("\n");
+}
+
+const PKM_HOOK_BASENAMES = new Set(["session-start.js", "stop-sweep.sh", "capture-handler.sh"]);
+
+/**
+ * Detect if a hook entry is a PKM hook (by path substring or script basename).
+ * @param {object} entry - A hook event entry with `hooks` array
+ * @returns {boolean}
+ */
+export function isPkmHookEntry(entry) {
+  if (!entry.hooks || !Array.isArray(entry.hooks)) return false;
+  return entry.hooks.some(h => {
+    const cmd = h.command || "";
+    if (cmd.includes("hooks/pkm/")) return true;
+    for (const basename of PKM_HOOK_BASENAMES) {
+      if (cmd.includes(basename)) return true;
+    }
+    return false;
+  });
+}
+
+/**
+ * Build settings.json hook config entries for enabled hooks.
+ * @param {string} vaultPath - Absolute vault path
+ * @param {string} hooksDir - Absolute path to installed hooks directory
+ * @param {{ sessionStart: boolean, stopSweep: boolean, captureHandler: boolean }} enabledHooks
+ * @returns {Object} Hook entries keyed by event name (SessionStart, Stop, PostToolUse)
+ */
+export function buildHookEntries(vaultPath, hooksDir, enabledHooks) {
+  const entries = {};
+
+  if (enabledHooks.sessionStart) {
+    entries.SessionStart = [{
+      matcher: "startup|clear|compact",
+      hooks: [{
+        type: "command",
+        command: `VAULT_PATH="${vaultPath}" node ${path.join(hooksDir, "session-start.js")}`,
+        timeout: 15,
+        statusMessage: "Loading PKM project context...",
+      }],
+    }];
+  }
+
+  if (enabledHooks.stopSweep) {
+    entries.Stop = [{
+      hooks: [{
+        type: "command",
+        command: `VAULT_PATH="${vaultPath}" ${path.join(hooksDir, "stop-sweep.sh")}`,
+        async: true,
+        timeout: 10,
+      }],
+    }];
+  }
+
+  if (enabledHooks.captureHandler) {
+    entries.PostToolUse = [{
+      matcher: "mcp__obsidian-pkm__vault_capture",
+      hooks: [{
+        type: "command",
+        command: `VAULT_PATH="${vaultPath}" ${path.join(hooksDir, "capture-handler.sh")}`,
+        async: true,
+        timeout: 10,
+      }],
+    }];
+  }
+
+  return entries;
+}
+
+/**
+ * Merge PKM hook entries into ~/.claude/settings.json.
+ * @param {string} settingsPath - Path to settings.json
+ * @param {Object} hookEntries - Entries to add, keyed by event name
+ * @param {string[]} disabledEvents - Event names where PKM hooks should be removed
+ * @returns {Promise<{ error?: string }>}
+ */
+export async function mergeHooksIntoSettings(settingsPath, hookEntries, disabledEvents) {
+  let settings = {};
+
+  try {
+    const raw = await fs.readFile(settingsPath, "utf8");
+    try {
+      settings = JSON.parse(raw);
+    } catch {
+      return { error: `${settingsPath} contains invalid JSON. Fix it manually and re-run init.` };
+    }
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+    // File doesn't exist — start fresh
+  }
+
+  if (!settings.hooks) settings.hooks = {};
+
+  // Add/replace enabled hooks
+  for (const [eventName, entries] of Object.entries(hookEntries)) {
+    if (!settings.hooks[eventName]) settings.hooks[eventName] = [];
+    // Remove existing PKM entries
+    settings.hooks[eventName] = settings.hooks[eventName].filter(e => !isPkmHookEntry(e));
+    // Append new entries
+    settings.hooks[eventName].push(...entries);
+  }
+
+  // Remove disabled hooks
+  for (const eventName of disabledEvents) {
+    if (!settings.hooks[eventName]) continue;
+    settings.hooks[eventName] = settings.hooks[eventName].filter(e => !isPkmHookEntry(e));
+    if (settings.hooks[eventName].length === 0) {
+      delete settings.hooks[eventName];
+    }
+  }
+
+  await fs.mkdir(path.dirname(settingsPath), { recursive: true });
+  await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  return {};
+}
+
+const HOOK_FILES = ["session-start.js", "resolve-project.js", "load-context.js", "stop-sweep.sh", "capture-handler.sh"];
+const SHELL_HOOKS = new Set(["stop-sweep.sh", "capture-handler.sh"]);
+
+/**
+ * Copy hook scripts to destination, patching shell scripts with correct MCP config.
+ * @param {string} src - Source hooks directory
+ * @param {string} dest - Destination directory (e.g. ~/.claude/hooks/pkm/)
+ * @param {{ command: string, args: string[] }} installType - Server command for MCP config patching
+ */
+export async function copyHooks(src, dest, installType) {
+  await fs.mkdir(dest, { recursive: true });
+
+  for (const file of HOOK_FILES) {
+    const srcFile = path.join(src, file);
+    const destFile = path.join(dest, file);
+
+    if (SHELL_HOOKS.has(file)) {
+      let content = await fs.readFile(srcFile, "utf8");
+      content = patchMcpConfig(content, installType);
+      await fs.writeFile(destFile, content, { mode: 0o755 });
+    } else {
+      await fs.copyFile(srcFile, destFile);
+    }
+  }
+}
+
 const SYSTEM_DIRS = new Set(["/", "/home", "/usr", "/var", "/etc", "/tmp", "/opt", "/bin", "/sbin"]);
 
 function formatBytes(bytes) {
@@ -222,13 +376,14 @@ export async function runInit() {
 pkm-mcp-server setup wizard
 
 This will walk you through setting up your Obsidian vault for use with the
-PKM MCP server. You'll be asked about 5 things:
+PKM MCP server. You'll be asked about 6 things:
 
   1. Where your vault is (or where to create one)
   2. Whether to install note templates
   3. Whether to set up the recommended folder structure
   4. An optional OpenAI API key for semantic search
   5. Registering the server with Claude Code
+  6. Setting up PKM hooks for Claude Code
 
 Nothing is written until you confirm each step. Press Ctrl+C at any time to cancel.
 `);
@@ -316,6 +471,7 @@ Nothing is written until you confirm each step. Press Ctrl+C at any time to canc
     }
     // ── Step 6: Registration ──
     const hasClaude = await checkClaudeCli();
+    let hasMcpRegistration = false;
     if (!hasClaude) {
       const installType = detectInstallType();
       const manualCmd = `claude mcp add -s user -e VAULT_PATH=${vaultPath} -- obsidian-pkm ${installType.command} ${installType.args.join(" ")}`;
@@ -335,6 +491,7 @@ Nothing is written until you confirm each step. Press Ctrl+C at any time to canc
         if (!overwrite) {
           console.log("  Registration skipped.\n");
           skipRegistration = true;
+          hasMcpRegistration = true;
         } else {
           // Remove existing before re-adding
           try {
@@ -360,6 +517,7 @@ Nothing is written until you confirm each step. Press Ctrl+C at any time to canc
             await execFileAsync("claude", addArgs);
             console.log("  MCP server registered with Claude Code");
             steps.push("MCP server: registered");
+            hasMcpRegistration = true;
           } catch (regErr) {
             console.error(`\n  Registration failed: ${regErr.message}`);
             if (regErr.stderr) console.error(`  ${regErr.stderr.trim()}`);
@@ -377,7 +535,98 @@ Nothing is written until you confirm each step. Press Ctrl+C at any time to canc
       }
     }
 
-    // ── Step 7: Summary ──
+    const skipHooks = !hasClaude || !hasMcpRegistration;
+
+    // ── Step 7: PKM Hooks ──
+    const hooksDir = path.join(os.homedir(), ".claude", "hooks", "pkm");
+    const bundledHooksDir = path.join(path.dirname(fileURLToPath(import.meta.url)), "hooks");
+    let hooksSummary;
+
+    if (skipHooks) {
+      const reason = !hasClaude ? "Claude CLI not found" : "no MCP registration";
+      hooksSummary = `skipped (${reason})`;
+      steps.push(`Hooks: skipped (${reason})`);
+    } else {
+      // Check for existing hook files
+      let hookFilesExist = false;
+      try {
+        const existing = await fs.readdir(hooksDir);
+        hookFilesExist = existing.length > 0;
+      } catch { /* doesn't exist */ }
+
+      let doCopyHooks = true;
+      if (hookFilesExist) {
+        doCopyHooks = await confirmPrompt({
+          message: "PKM hook scripts are already installed. Overwrite with current version?",
+          default: false,
+        });
+      }
+
+      if (doCopyHooks) {
+        try {
+          const installType = detectInstallType();
+          await copyHooks(bundledHooksDir, hooksDir, installType);
+          console.log(`  Hook scripts installed to ${hooksDir}`);
+        } catch (copyErr) {
+          console.error(`\n  Hook file installation failed: ${copyErr.message}`);
+          const skipHookSetup = await confirmPrompt({ message: "Skip hooks and finish setup?", default: true });
+          if (skipHookSetup) {
+            hooksSummary = "skipped (file copy failed)";
+            steps.push("Hooks: skipped (file copy failed)");
+          } else {
+            throw copyErr;
+          }
+        }
+      }
+
+      // Only proceed to config if we haven't set hooksSummary (i.e., no error)
+      if (!hooksSummary) {
+        const enableSessionStart = await confirmPrompt({
+          message: "Enable project context loading? Automatically loads your project's index, recent devlog entries, and active tasks at the start of each Claude Code session.",
+          default: true,
+        });
+
+        const enableStopSweep = await confirmPrompt({
+          message: "Enable passive capture? After each Claude response, a background agent scans the conversation for decisions, task changes, and research findings, and stages them in your vault's inbox.",
+          default: true,
+        });
+
+        const enableCaptureHandler = await confirmPrompt({
+          message: "Enable explicit capture? When Claude calls vault_capture, a background agent creates a properly structured vault note (ADR, task, research note, or bug report) from the capture payload.",
+          default: true,
+        });
+
+        const enabledHooks = {
+          sessionStart: enableSessionStart,
+          stopSweep: enableStopSweep,
+          captureHandler: enableCaptureHandler,
+        };
+
+        const hookEntries = buildHookEntries(vaultPath, hooksDir, enabledHooks);
+        const disabledEvents = [];
+        if (!enableSessionStart) disabledEvents.push("SessionStart");
+        if (!enableStopSweep) disabledEvents.push("Stop");
+        if (!enableCaptureHandler) disabledEvents.push("PostToolUse");
+
+        const settingsPath = path.join(os.homedir(), ".claude", "settings.json");
+        const mergeResult = await mergeHooksIntoSettings(settingsPath, hookEntries, disabledEvents);
+
+        if (mergeResult.error) {
+          console.error(`\n  ${mergeResult.error}`);
+          hooksSummary = "skipped (settings.json error)";
+        } else {
+          const names = [];
+          if (enableSessionStart) names.push("context-loading");
+          if (enableStopSweep) names.push("passive-capture");
+          if (enableCaptureHandler) names.push("explicit-capture");
+          hooksSummary = names.length > 0 ? names.join(", ") : "none";
+          console.log(`  Hooks configured: ${hooksSummary}`);
+        }
+        steps.push(`Hooks: ${hooksSummary}`);
+      }
+    }
+
+    // ── Step 8: Summary ──
     // Build summary lines based on what was actually done
     const templateSummary = templateMode === "skip"
       ? "Skipped"
@@ -402,6 +651,7 @@ Setup complete!
   Folders:     ${folderSummary}
   Semantic:    ${semanticSummary}
   Claude Code: ${registrationSummary}
+  Hooks:       ${hooksSummary}
 
 To verify, restart Claude Code and try:
   "List the folders in my vault"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pkm-mcp-server",
-  "version": "1.3.3",
+  "version": "1.4.1",
   "description": "MCP server for Obsidian vault integration with Claude Code — 19 tools for notes, search, and graph traversal",
   "main": "cli.js",
   "exports": {