@plur-ai/mcp 0.20.1 → 0.21.1

package/dist/index.d.ts

@@ -27,5 +27,56 @@ declare function compareSemver(a: string, b: string): number;
  * anchors to start-of-line so a leading space breaks the match.
  */
 declare function extractManifestVersion(skillMdPath: string): string | null;
+/**
+ * Hook set for `plur-mcp init`. Mirrors `buildInjectionHooks` in
+ * @plur-ai/cli's init.ts, which this package cannot import. The rehydrate
+ * entry must stay identical to the cli's; test/init-hooks.test.ts fails if
+ * the two diverge (#1279).
+ */
+declare function buildPlurHooks(cli: string): Record<string, HookEntry[]>;
+interface Settings {
+    hooks?: Record<string, HookEntry[]>;
+    [key: string]: unknown;
+}
+interface HookEntry {
+    matcher?: string;
+    hooks: Array<{
+        type: string;
+        command: string;
+        args?: string[];
+        timeout?: number;
+        async?: boolean;
+    }>;
+}
+/**
+ * Write the PLUR section into CLAUDE.md with core's `upsertInstructionSection`
+ * — the same logic as `plur init`: only a section PLUR shipped is replaced,
+ * one the user wrote or edited is kept and the new one added beside it, and a
+ * timestamped backup precedes any change to an existing file.
+ */
+declare function installClaudeMd(claudeMdPath?: string): Promise<string>;
+/**
+ * Merge PLUR hooks into Claude Code settings (#1279). No I/O apart from
+ * reading plur-hook.meta.json for the exec-form check.
+ * A hook is PLUR's only when isPlurHookSpec says so: the whole command is
+ * PLUR's launcher (the shim, with any slash direction or quoting, or the npx
+ * fallback, or on Windows the exec form `plur init` writes) followed by a
+ * `hook-*` subcommand and plain arguments (decisions H2, F4).
+ * - No PLUR hook present: append the full set ('installed').
+ * - PLUR hooks present: remove PLUR's hooks from PostCompact, which cannot
+ *   carry context (#1274), one hook at a time, dropping an entry only when
+ *   it has no hooks left. If a PLUR rehydrate was among them, add the
+ *   SessionStart(compact) entry unless one is there ('healed'). A file with
+ *   PLUR hooks but no rehydrate (the global file `plur init --project` writes) gets
+ *   none added. Nothing else changes, so a fuller
+ *   `plur init` install is not replaced by this smaller set.
+ * - Otherwise 'already', and the settings come back unchanged.
+ * User hooks are never removed or reordered, including a user hook that
+ * shares an entry with a PLUR hook.
+ */
+declare function applyPlurHooks(settings: Settings, hooksMap: Record<string, HookEntry[]>): {
+    settings: Settings;
+    status: 'installed' | 'healed' | 'already';
+};
 
-export { compareSemver, extractManifestVersion };
+export { type HookEntry, type Settings, applyPlurHooks, buildPlurHooks, compareSemver, extractManifestVersion, installClaudeMd };

package/dist/index.js

@@ -1,13 +1,72 @@
 #!/usr/bin/env node
 import {
   VERSION
-} from "./chunk-445S5QNU.js";
+} from "./chunk-O2NJFMNP.js";
 
 // src/index.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from "fs";
-import { join } from "path";
+import { existsSync, readFileSync as readFileSync2, writeFileSync, mkdirSync, readdirSync, statSync } from "fs";
+import { join as join2 } from "path";
 import { fileURLToPath } from "url";
-import { homedir, platform } from "os";
+import { homedir as homedir2, platform } from "os";
+
+// src/hook-command.ts
+import { homedir } from "os";
+import { readFileSync } from "fs";
+import { join } from "path";
+function isPlurHookSpec(spec) {
+  const command = typeof spec.command === "string" ? spec.command : "";
+  const args = Array.isArray(spec.args) ? spec.args.filter((a) => typeof a === "string") : [];
+  if (args.length === 0) return isPlurHookCommand(command);
+  const norm = (p) => p.replace(/\\/g, "/").replace(/"/g, "").toLowerCase();
+  const cmd = norm(command);
+  if (/(^|\/)cmd(\.exe)?$/.test(cmd)) return isPlurHookCommand(args.filter((a) => a.toLowerCase() !== "/c").join(" "));
+  if (!/(^|\/)node(\.exe)?$/.test(cmd)) return false;
+  if (!/^hook-[a-z0-9][a-z0-9-]*$/.test(args[1] ?? "")) return false;
+  const target = normEntry(args[0]);
+  return recordedCliEntries().some((e) => normEntry(e) === target);
+}
+function normEntry(p) {
+  return p.replace(/\\/g, "/").replace(/"/g, "").toLowerCase();
+}
+function entriesOf(meta) {
+  if (!meta || typeof meta !== "object") return [];
+  const m = meta;
+  if (Array.isArray(m.entrypoints)) return m.entrypoints.filter((e) => typeof e === "string" && e.length > 0);
+  return typeof m.entrypoint === "string" && m.entrypoint.length > 0 ? [m.entrypoint] : [];
+}
+function recordedCliEntries() {
+  try {
+    return entriesOf(JSON.parse(readFileSync(join(homedir(), ".plur", "bin", "plur-hook.meta.json"), "utf8")));
+  } catch {
+    return [];
+  }
+}
+var PLAIN = "[^\\s\"'`$&;|<>()]";
+var HOOK_TAIL = `[ \\t]+hook-[a-z0-9][a-z0-9-]*(?:[ \\t]+${PLAIN}+)*[ \\t]*$`;
+var SHIM_FILE = "(?:plur-hook(?:\\.cmd)?|(?<=/(?:\\.plur|plur~\\d+)/bin/)plur-h~\\d+\\.cmd)";
+var SHIM_PATH = [
+  `(?:${PLAIN}*/)?${SHIM_FILE}`,
+  `"(?:[^"]*/)?${SHIM_FILE}"`
+].join("|");
+var SHIM_FORM = new RegExp(`^(?:&[ \\t]+)?(?:${SHIM_PATH})${HOOK_TAIL}`);
+var NPX_FORM = new RegExp(`^npx(?:[ \\t]+-y)?[ \\t]+@plur-ai/cli(?:@${PLAIN}+)?${HOOK_TAIL}`);
+var HOME_SHIM_TAIL = new RegExp(`^${HOOK_TAIL}`);
+function homeShimPaths() {
+  const bin = `${homedir().replace(/\\/g, "/").toLowerCase().replace(/\/+$/, "")}/.plur/bin/`;
+  if (/[\r\n]/.test(bin)) return [];
+  return [`${bin}plur-hook.cmd`, `${bin}plur-hook`];
+}
+var MAX_HOOK_COMMAND_LENGTH = 8192;
+function isPlurHookCommand(command) {
+  return command.length <= MAX_HOOK_COMMAND_LENGTH && matchesPlurHookLauncher(command);
+}
+function matchesPlurHookLauncher(command) {
+  const normalised = command.trim().replace(/\\/g, "/").toLowerCase();
+  if (SHIM_FORM.test(normalised) || NPX_FORM.test(normalised)) return true;
+  return homeShimPaths().some((p) => normalised.startsWith(p) && HOME_SHIM_TAIL.test(normalised.slice(p.length)));
+}
+
+// src/index.ts
 var HELP = `plur-mcp v${VERSION} \u2014 persistent memory for AI agents
 
 Usage:
@@ -49,7 +108,7 @@ function compareSemver(a, b) {
 }
 function extractManifestVersion(skillMdPath) {
   try {
-    const content = readFileSync(skillMdPath, "utf8");
+    const content = readFileSync2(skillMdPath, "utf8");
     const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/m);
     if (!fmMatch) return null;
     const versionMatch = fmMatch[1].match(/^version:\s*"?([^"\n]+)"?\s*$/m);
@@ -59,40 +118,59 @@ function extractManifestVersion(skillMdPath) {
   }
 }
 var _shimName = platform() === "win32" ? "plur-hook.cmd" : "plur-hook";
-var _shimCandidate = join(homedir(), ".plur", "bin", _shimName);
+var _shimCandidate = join2(homedir2(), ".plur", "bin", _shimName);
 var CLI = existsSync(_shimCandidate) ? _shimCandidate : "npx @plur-ai/cli";
-var PLUR_HOOKS = {
-  // --- Session lifecycle ---
-  UserPromptSubmit: [{
-    hooks: [{ type: "command", command: `${CLI} hook-inject`, timeout: 15 }]
-  }],
-  PostCompact: [{
-    matcher: "auto|manual",
-    hooks: [{ type: "command", command: `${CLI} hook-inject --rehydrate`, timeout: 15 }]
-  }],
-  // Auto-close the memory lifecycle at session end (Claude Code SessionEnd,
-  // shipped v1.0.85) — captures a closing episode and cleans up the session
-  // checkpoint even if the agent forgot to call plur_session_end (#217).
-  SessionEnd: [{
-    hooks: [{ type: "command", command: `${CLI} hook-session-end`, timeout: 5 }]
-  }],
-  // --- Contextual injection ---
-  PreToolUse: [
-    { matcher: "EnterPlanMode", hooks: [{ type: "command", command: `${CLI} hook-inject --event plan_mode`, timeout: 10 }] },
-    { matcher: "Skill", hooks: [{ type: "command", command: `${CLI} hook-inject --event skill`, timeout: 10 }] },
-    { matcher: "Agent", hooks: [{ type: "command", command: `${CLI} hook-inject --event agent`, timeout: 10 }] },
-    { matcher: "Bash|Edit|Write|Agent", hooks: [{ type: "command", command: `${CLI} hook-observe`, timeout: 3 }] }
-  ],
-  PostToolUse: [
-    { matcher: "Bash|Edit|Write|Agent", hooks: [{ type: "command", command: `${CLI} hook-observe --post`, timeout: 3 }] }
-  ],
-  SubagentStart: [
-    { matcher: ".*", hooks: [{ type: "command", command: `${CLI} hook-inject --event subagent`, timeout: 10 }] }
-  ],
-  Stop: [
-    { matcher: "*", hooks: [{ type: "command", command: `${CLI} hook-learn-check`, timeout: 2 }] }
-  ]
-};
+function buildPlurHooks(cli) {
+  return {
+    // --- Session lifecycle ---
+    // Sync with a 20s budget, like `plur init` (#1313): async context reaches
+    // Claude Code only at the next safe point, so a first reply without tool
+    // calls had no memory. hook-inject exits by itself after 15s, so the
+    // timeout sits above that. Keep in step with CLAUDE_INJECT_TIMEOUT_S in
+    // @plur-ai/cli's lib/claude-inject-budget.ts.
+    UserPromptSubmit: [{
+      hooks: [{ type: "command", command: `${cli} hook-inject`, timeout: 20 }]
+    }],
+    // Re-inject after compaction. SessionStart with matcher "compact" fires
+    // right after compaction and can carry context; PostCompact cannot
+    // (#1274, #1279). Re-running init moves an old PostCompact entry here.
+    SessionStart: [{
+      matcher: "compact",
+      hooks: [{ type: "command", command: `${cli} hook-inject --rehydrate`, timeout: 20 }]
+    }, {
+      // `claude --resume` keeps the session id, and SessionEnd below deleted
+      // its folder-question nonces: the resumed session is asked again with a
+      // fresh nonce (#1347, option C). Identical to `plur init`'s entry.
+      matcher: "resume",
+      hooks: [{ type: "command", command: `${cli} hook-session-resume`, timeout: 3 }]
+    }],
+    // Auto-close the memory lifecycle at session end (Claude Code SessionEnd,
+    // shipped v1.0.85) — captures a closing episode and cleans up the session
+    // checkpoint even if the agent forgot to call plur_session_end (#217).
+    SessionEnd: [{
+      hooks: [{ type: "command", command: `${cli} hook-session-end`, timeout: 5 }]
+    }],
+    // --- Contextual injection ---
+    PreToolUse: [
+      { matcher: "EnterPlanMode", hooks: [{ type: "command", command: `${cli} hook-inject --event plan_mode`, timeout: 10 }] },
+      { matcher: "Skill", hooks: [{ type: "command", command: `${cli} hook-inject --event skill`, timeout: 10 }] },
+      { matcher: "Agent", hooks: [{ type: "command", command: `${cli} hook-inject --event agent`, timeout: 10 }] },
+      { matcher: "Bash|Edit|Write|Agent", hooks: [{ type: "command", command: `${cli} hook-observe`, timeout: 3 }] }
+    ],
+    PostToolUse: [
+      { matcher: "Bash|Edit|Write|Agent", hooks: [{ type: "command", command: `${cli} hook-observe --post`, timeout: 3 }] }
+    ],
+    SubagentStart: [
+      { matcher: ".*", hooks: [{ type: "command", command: `${cli} hook-inject --event subagent`, timeout: 10 }] }
+    ],
+    Stop: [
+      { matcher: "*", hooks: [{ type: "command", command: `${cli} hook-learn-check`, timeout: 2 }] }
+    ]
+  };
+}
+var PLUR_HOOKS = buildPlurHooks(CLI);
+var PLUR_INSTRUCTIONS_MARKER = "<!-- plur-instructions-v4 -->";
+var MEMORY_FOOTER_RULE = "End every reply with one short line: `Memory \u2014 recalled N \xB7 used: ENG-\u2026, ENG-\u2026 \xB7 written: ENG-\u2026` (recalled as a count; used and written as ids only, no statements), or `Memory \u2014 none`. Only count/list ids you actually saw this turn; never invent an id. Give details only if the user asks.";
 var CLAUDE_MD_SECTION = `## PLUR Memory
 
 You have persistent memory via PLUR. Corrections, preferences, and conventions persist across sessions as engrams.
@@ -113,42 +191,64 @@ Hooks inject engrams automatically on every first message \u2014 you do not need
 
 Do not ask permission to use these tools \u2014 they are your memory system.
 
+### Memory line on every reply
+
+${MEMORY_FOOTER_RULE}
+
 ### When corrected
 
 When the user corrects you ("no, use X not Y", "that's wrong"):
 1. Call \`plur_learn\` immediately \u2014 before continuing the task
 2. Call \`plur_feedback\` with negative signal on the wrong engram if one was injected
 3. Then continue with the corrected approach
-`;
-function installClaudeMd() {
-  const marker = "## PLUR Memory";
-  const projectClaudeMd = join(process.cwd(), "CLAUDE.md");
-  const globalClaudeMd = join(homedir(), "CLAUDE.md");
-  const claudeMdPath = existsSync(projectClaudeMd) ? projectClaudeMd : existsSync(globalClaudeMd) ? globalClaudeMd : projectClaudeMd;
-  if (existsSync(claudeMdPath)) {
-    const content = readFileSync(claudeMdPath, "utf8");
-    if (content.includes(marker)) {
-      return `already in ${claudeMdPath}`;
-    }
-    writeFileSync(claudeMdPath, content.trimEnd() + "\n\n" + CLAUDE_MD_SECTION);
-    return `added to ${claudeMdPath}`;
-  }
-  writeFileSync(claudeMdPath, `# CLAUDE.md
 
-${CLAUDE_MD_SECTION}`);
-  return `created ${claudeMdPath}`;
+${PLUR_INSTRUCTIONS_MARKER}
+`;
+function defaultClaudeMdPath() {
+  const projectClaudeMd = join2(process.cwd(), "CLAUDE.md");
+  const globalClaudeMd = join2(homedir2(), "CLAUDE.md");
+  return existsSync(projectClaudeMd) ? projectClaudeMd : existsSync(globalClaudeMd) ? globalClaudeMd : projectClaudeMd;
 }
-function findMcpConfig() {
-  const projectMcp = join(process.cwd(), ".mcp.json");
-  if (existsSync(projectMcp)) return projectMcp;
-  const globalMcp = join(homedir(), ".claude", "mcp.json");
-  if (existsSync(globalMcp)) return globalMcp;
-  return projectMcp;
+async function installClaudeMd(claudeMdPath = defaultClaudeMdPath()) {
+  const { upsertInstructionSection, writeWithBackup, SHIPPED_PLUR_SECTIONS } = await import("@plur-ai/core");
+  const existing = existsSync(claudeMdPath) ? readFileSync2(claudeMdPath, "utf8") : null;
+  const r = upsertInstructionSection(existing, {
+    section: CLAUDE_MD_SECTION,
+    title: "# CLAUDE.md",
+    heading: "## PLUR Memory",
+    marker: PLUR_INSTRUCTIONS_MARKER,
+    shipped: SHIPPED_PLUR_SECTIONS
+  });
+  if (r.status === "skipped") return `not written to ${claudeMdPath}: ${r.skipReason}`;
+  let backup;
+  try {
+    backup = r.status === "already" ? null : writeWithBackup(claudeMdPath, r.content, existing);
+  } catch (err) {
+    if (err.code === "PLUR_REFUSED") return `not written to ${claudeMdPath}: ${err.message}`;
+    throw err;
+  }
+  const head = {
+    created: `created ${claudeMdPath}`,
+    added: `added to ${claudeMdPath}`,
+    upgraded: `upgraded in ${claudeMdPath}`,
+    already: `already in ${claudeMdPath}`
+  }[r.status];
+  const notes = [];
+  if (backup) notes.push(`backup: ${backup}`);
+  if (r.keptSections > 0) {
+    notes.push(
+      `left ${r.keptSections} older "## PLUR Memory" section${r.keptSections === 1 ? "" : "s"} untouched because ${r.keptSections === 1 ? "it has" : "they have"} text PLUR did not write \u2014 remove it yourself once you have kept what you need`
+    );
+  }
+  if (r.closedOpenBlock) {
+    notes.push(`closed the ${r.closedOpenBlock === "fence" ? "code block" : "HTML comment"} left open at the end of the file before adding the section`);
+  }
+  return notes.length ? `${head} (${notes.join("; ")})` : head;
 }
 function readJsonObjectForWrite(path) {
   if (!existsSync(path)) return { data: {}, ok: true };
   try {
-    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return { data: parsed, ok: true };
     }
@@ -156,64 +256,125 @@ function readJsonObjectForWrite(path) {
   }
   return { data: {}, ok: false };
 }
-function writeMcpConfig(configPath) {
-  const { data, ok } = readJsonObjectForWrite(configPath);
-  if (!ok) {
-    return `skipped \u2014 ${configPath} exists but is not a JSON object; writing would discard your other MCP servers. Fix it by hand, then re-run \`plur-mcp init\``;
-  }
-  const config = data;
-  const servers = config.mcpServers ?? {};
+function healRaceyEntry(servers) {
   const existing = servers.plur;
-  if (existing) {
-    const args = existing.args ?? [];
-    const spec = args.filter((a) => a !== "-y" && !a.startsWith("-"))[0] ?? "";
-    if (existing.command === "npx" && /^@plur-ai\/mcp(@latest)?$/.test(spec)) {
-      const healed = { ...existing, ...MCP_SERVER_CONFIG };
-      if (JSON.stringify(healed) !== JSON.stringify(existing)) {
-        servers.plur = healed;
-        config.mcpServers = servers;
-        writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-        return `upgraded stale npx entry in ${configPath}`;
-      }
+  if (!existing || typeof existing !== "object") return false;
+  const args = existing.args ?? [];
+  const spec = args.filter((a) => a !== "-y" && !a.startsWith("-"))[0] ?? "";
+  if (existing.command !== "npx" || !/^@plur-ai\/mcp(@latest)?$/.test(spec)) return false;
+  const healed = { ...existing, ...MCP_SERVER_CONFIG };
+  if (JSON.stringify(healed) === JSON.stringify(existing)) return false;
+  servers.plur = healed;
+  return true;
+}
+async function installClaudeUserMcp() {
+  const { writeWithBackup, registerClaudeUserMcp } = await import("@plur-ai/core");
+  const legacyPath = join2(homedir2(), ".claude", "mcp.json");
+  const legacyRaw = existsSync(legacyPath) ? readFileSync2(legacyPath, "utf8") : null;
+  const legacy = readJsonObjectForWrite(legacyPath);
+  const oldServers = legacy.ok ? legacy.data.mcpServers : void 0;
+  const oldEntry = oldServers && typeof oldServers === "object" && !Array.isArray(oldServers) ? oldServers.plur : void 0;
+  const r = registerClaudeUserMcp({
+    userPath: join2(homedir2(), ".claude.json"),
+    entry: () => ({ ...MCP_SERVER_CONFIG }),
+    heal: (config) => healRaceyEntry(config.mcpServers) ? "upgraded stale npx entry" : null,
+    legacyEntry: oldEntry,
+    legacyPath,
+    rerunCommand: "plur-mcp init"
+  });
+  if (!r.ok || oldEntry === void 0) return { ok: r.ok, status: r.message };
+  let status = r.message;
+  const next = { ...legacy.data };
+  const rest = { ...oldServers };
+  delete rest.plur;
+  if (Object.keys(rest).length > 0) next.mcpServers = rest;
+  else delete next.mcpServers;
+  try {
+    const backup = writeWithBackup(legacyPath, JSON.stringify(next, null, 2) + "\n", legacyRaw);
+    status += `; removed the unused entry from ${legacyPath}${backup ? ` (backup: ${backup})` : ""}`;
+  } catch (err) {
+    status += `; could not remove the unused entry from ${legacyPath} (${err.message}) \u2014 Claude Code ignores it, remove it by hand`;
+  }
+  return { ok: true, status };
+}
+function isPlurCommandHook(h) {
+  return typeof h.command === "string" && isPlurHookSpec({ command: h.command, args: h.args });
+}
+function isPlurHook(entry) {
+  return (entry.hooks ?? []).some(isPlurCommandHook);
+}
+var REHYDRATE = /(?:^|\s)hook-inject\s+--rehydrate(?:\s|$)/;
+function launchLine(h) {
+  const args = Array.isArray(h.args) ? h.args.filter((a) => typeof a === "string") : [];
+  return [h.command, ...args].join(" ");
+}
+function isPlurRehydrateHook(h) {
+  return isPlurCommandHook(h) && REHYDRATE.test(launchLine(h).replace(/\\/g, "/").toLowerCase());
+}
+function isPlurRehydrate(entry) {
+  return (entry.hooks ?? []).some(isPlurRehydrateHook);
+}
+function hasPlurSubcommand(entries, subcommand) {
+  const re = new RegExp(`(?:^|\\s)${subcommand}(?:\\s|$)`);
+  return (entries ?? []).some((e) => (e.hooks ?? []).some((h) => isPlurCommandHook(h) && re.test(h.command.replace(/\\/g, "/").toLowerCase())));
+}
+var isResumeEntry = (e) => e.matcher === "resume";
+function stripPlurHooks(entries) {
+  const kept = [];
+  for (const entry of entries) {
+    if (!isPlurHook(entry)) {
+      kept.push(entry);
+      continue;
     }
-    return `already configured in ${configPath}`;
+    const rest = entry.hooks.filter((h) => !isPlurCommandHook(h));
+    if (rest.length > 0) kept.push({ ...entry, hooks: rest });
   }
-  servers.plur = MCP_SERVER_CONFIG;
-  config.mcpServers = servers;
-  const dir = join(configPath, "..");
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-  return `added to ${configPath}`;
+  return kept;
+}
+function applyPlurHooks(settings, hooksMap) {
+  const hooks = { ...settings.hooks ?? {} };
+  const installed = Object.values(hooks).some((entries) => (entries ?? []).some(isPlurHook));
+  if (!installed) {
+    for (const [event, entries] of Object.entries(hooksMap)) {
+      hooks[event] = [...hooks[event] ?? [], ...entries];
+    }
+    return { settings: { ...settings, hooks }, status: "installed" };
+  }
+  let changed = false;
+  let movedRehydrate = false;
+  if (hooks.PostCompact?.some(isPlurHook)) {
+    movedRehydrate = hooks.PostCompact.some(isPlurRehydrate);
+    const kept = stripPlurHooks(hooks.PostCompact);
+    if (kept.length > 0) hooks.PostCompact = kept;
+    else delete hooks.PostCompact;
+    changed = true;
+  }
+  if (movedRehydrate && !(hooks.SessionStart ?? []).some(isPlurRehydrate)) {
+    hooks.SessionStart = [...hooks.SessionStart ?? [], ...(hooksMap.SessionStart ?? []).filter((e) => !isResumeEntry(e))];
+    changed = true;
+  }
+  if (hasPlurSubcommand(hooks.SessionEnd, "hook-session-end") && !hasPlurSubcommand(hooks.SessionStart, "hook-session-resume")) {
+    const resume = (hooksMap.SessionStart ?? []).filter(isResumeEntry);
+    if (resume.length > 0) {
+      hooks.SessionStart = [...hooks.SessionStart ?? [], ...resume];
+      changed = true;
+    }
+  }
+  return changed ? { settings: { ...settings, hooks }, status: "healed" } : { settings, status: "already" };
 }
 function installHooks() {
-  const projectSettings = join(process.cwd(), ".claude", "settings.json");
-  const globalSettings = join(homedir(), ".claude", "settings.json");
-  const settingsPath = existsSync(join(process.cwd(), ".claude")) ? projectSettings : globalSettings;
+  const settingsPath = join2(homedir2(), ".claude", "settings.json");
   const settingsRead = readJsonObjectForWrite(settingsPath);
   if (!settingsRead.ok) {
     return `skipped \u2014 ${settingsPath} exists but is not a JSON object; writing would discard your other settings. Fix it by hand, then re-run \`plur-mcp init\``;
   }
   const settings = settingsRead.data;
-  const hooks = settings.hooks ?? {};
-  for (const entries of Object.values(hooks)) {
-    for (const entry of entries) {
-      for (const h of entry.hooks ?? []) {
-        if (h.command.includes("@plur-ai/cli")) {
-          return `already installed in ${settingsPath}`;
-        }
-      }
-    }
-  }
-  const existing = settings.hooks ?? {};
-  const merged = { ...existing };
-  for (const [event, newEntries] of Object.entries(PLUR_HOOKS)) {
-    merged[event] = [...merged[event] ?? [], ...newEntries];
-  }
-  settings.hooks = merged;
-  const dir = join(settingsPath, "..");
+  const { settings: next, status } = applyPlurHooks(settings, PLUR_HOOKS);
+  if (status === "already") return `already installed in ${settingsPath}`;
+  const dir = join2(settingsPath, "..");
   mkdirSync(dir, { recursive: true });
-  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-  return `installed in ${settingsPath}`;
+  writeFileSync(settingsPath, JSON.stringify(next, null, 2) + "\n");
+  return status === "healed" ? `updated PLUR hooks (SessionStart compact/resume) in ${settingsPath}` : `installed in ${settingsPath}`;
 }
 async function runInit() {
   const results = [];
@@ -231,36 +392,37 @@ async function runInit() {
   } catch {
   }
   results.push(`Search:   ${searchMode}`);
-  const mcpConfigPath = findMcpConfig();
-  const mcpStatus = writeMcpConfig(mcpConfigPath);
+  const mcp = await installClaudeUserMcp();
+  const mcpStatus = mcp.status;
+  if (!mcp.ok) process.exitCode = 1;
   results.push(`MCP:      ${mcpStatus}`);
   const hooksStatus = installHooks();
   results.push(`Hooks:    ${hooksStatus}`);
-  const claudeMdStatus = installClaudeMd();
+  const claudeMdStatus = await installClaudeMd();
   results.push(`CLAUDE.md: ${claudeMdStatus}`);
   const { Plur } = await import("@plur-ai/core");
   const plur = new Plur({ path: paths.root });
-  const bundledPacksDir = join(fileURLToPath(import.meta.url), "..", "..", "packs");
+  const bundledPacksDir = join2(fileURLToPath(import.meta.url), "..", "..", "packs");
   let packsStatus = "no bundled packs found";
   if (existsSync(bundledPacksDir)) {
     const installed = plur.listPacks();
     const installedByName = new Map(installed.map((p) => [p.name, p.manifest?.version]));
-    const entries = readdirSync(bundledPacksDir).filter((e) => statSync(join(bundledPacksDir, e)).isDirectory());
+    const entries = readdirSync(bundledPacksDir).filter((e) => statSync(join2(bundledPacksDir, e)).isDirectory());
     const newPacks = [];
     const upgradedPacks = [];
     for (const entry of entries) {
-      const bundledManifestPath = join(bundledPacksDir, entry, "SKILL.md");
+      const bundledManifestPath = join2(bundledPacksDir, entry, "SKILL.md");
       const bundledVersion = existsSync(bundledManifestPath) ? extractManifestVersion(bundledManifestPath) : null;
       const installedVersion = installedByName.get(entry);
       if (!installedByName.has(entry)) {
         try {
-          await plur.installPack(join(bundledPacksDir, entry));
+          await plur.installPack(join2(bundledPacksDir, entry));
           newPacks.push(entry);
         } catch {
         }
       } else if (bundledVersion && (!installedVersion || compareSemver(bundledVersion, installedVersion) > 0)) {
         try {
-          await plur.installPack(join(bundledPacksDir, entry));
+          await plur.installPack(join2(bundledPacksDir, entry));
           upgradedPacks.push(
             `${entry} ${installedVersion ?? "unknown"}\u2192${bundledVersion}`
           );
@@ -295,7 +457,7 @@ async function runInit() {
   }
 }
 async function runPacks() {
-  const plurPath = process.env.PLUR_PATH ?? join(homedir(), ".plur");
+  const plurPath = process.env.PLUR_PATH ?? join2(homedir2(), ".plur");
   const { Plur } = await import("@plur-ai/core");
   const { packsCommand } = await import("./packs-cli-XXZTSBHW.js");
   const plur = new Plur({ path: plurPath });
@@ -316,14 +478,14 @@ if (arg === "--version" || arg === "-v") {
 }
 if (arg === "init") {
   await runInit();
-  process.exit(0);
+  process.exit(process.exitCode ?? 0);
 }
 if (arg === "packs") {
   await runPacks();
   process.exit(0);
 }
 if (arg === "serve" || arg === void 0) {
-  const { runStdio } = await import("./server-LODRVEQB.js");
+  const { runStdio } = await import("./server-EHKHU4JH.js");
   runStdio().catch((err) => {
     console.error("Failed to start PLUR MCP server:", err);
     process.exit(1);
@@ -334,6 +496,9 @@ Run plur-mcp --help for usage.`);
   process.exit(1);
 }
 export {
+  applyPlurHooks,
+  buildPlurHooks,
   compareSemver,
-  extractManifestVersion
+  extractManifestVersion,
+  installClaudeMd
 };