vibeusage 0.2.23 → 0.3.0

package/src/commands/status.js

@@ -3,20 +3,10 @@ const path = require("node:path");
 const fs = require("node:fs/promises");
 
 const { readJson } = require("../lib/fs");
-const { readCodexNotify, readEveryCodeNotify } = require("../lib/codex-config");
-const { isClaudeHookConfigured, buildClaudeHookCommand } = require("../lib/claude-config");
-const {
-  resolveGeminiConfigDir,
-  resolveGeminiSettingsPath,
-  isGeminiHookConfigured,
-  buildGeminiHookCommand,
-} = require("../lib/gemini-config");
-const { resolveOpencodeConfigDir, isOpencodePluginInstalled } = require("../lib/opencode-config");
 const { collectLocalSubscriptions } = require("../lib/subscriptions");
 const { normalizeState: normalizeUploadState } = require("../lib/upload-throttle");
 const { collectTrackerDiagnostics } = require("../lib/diagnostics");
-const { probeOpenclawHookState } = require("../lib/openclaw-hook");
-const { probeOpenclawSessionPluginState } = require("../lib/openclaw-session-plugin");
+const { createIntegrationContext, listIntegrations, probeIntegrations } = require("../lib/integrations");
 const { resolveTrackerPaths } = require("../lib/tracker-paths");
 
 async function cmdStatus(argv = []) {
@@ -28,7 +18,7 @@ async function cmdStatus(argv = []) {
   }
 
   const home = os.homedir();
-  const { trackerDir, binDir } = await resolveTrackerPaths({ home });
+  const { trackerDir } = await resolveTrackerPaths({ home });
   const configPath = path.join(trackerDir, "config.json");
   const queuePath = path.join(trackerDir, "queue.jsonl");
   const queueStatePath = path.join(trackerDir, "queue.state.json");
@@ -38,17 +28,6 @@ async function cmdStatus(argv = []) {
   const throttlePath = path.join(trackerDir, "sync.throttle");
   const uploadThrottlePath = path.join(trackerDir, "upload.throttle.json");
   const autoRetryPath = path.join(trackerDir, "auto.retry.json");
-  const codexHome = process.env.CODEX_HOME || path.join(home, ".codex");
-  const codexConfigPath = path.join(codexHome, "config.toml");
-  const codeHome = process.env.CODE_HOME || path.join(home, ".code");
-  const codeConfigPath = path.join(codeHome, "config.toml");
-  const claudeSettingsPath = path.join(home, ".claude", "settings.json");
-  const geminiConfigDir = resolveGeminiConfigDir({ home, env: process.env });
-  const geminiSettingsPath = resolveGeminiSettingsPath({ configDir: geminiConfigDir });
-  const opencodeConfigDir = resolveOpencodeConfigDir({ home, env: process.env });
-  const notifyPath = path.join(binDir, "notify.cjs");
-  const claudeHookCommand = buildClaudeHookCommand(notifyPath);
-  const geminiHookCommand = buildGeminiHookCommand(notifyPath);
 
   const config = await readJson(configPath);
   const cursors = await readJson(cursorsPath);
@@ -63,27 +42,10 @@ async function cmdStatus(argv = []) {
   const lastOpenclawSync = (await safeReadText(openclawSignalPath))?.trim() || null;
   const lastNotifySpawn = parseEpochMsToIso((await safeReadText(throttlePath))?.trim() || null);
 
-  const codexNotify = await readCodexNotify(codexConfigPath);
-  const notifyConfigured = Array.isArray(codexNotify) && codexNotify.length > 0;
-  const everyCodeNotify = await readEveryCodeNotify(codeConfigPath);
-  const everyCodeConfigured = Array.isArray(everyCodeNotify) && everyCodeNotify.length > 0;
-  const claudeHookConfigured = await isClaudeHookConfigured({
-    settingsPath: claudeSettingsPath,
-    hookCommand: claudeHookCommand,
-  });
-  const geminiHookConfigured = await isGeminiHookConfigured({
-    settingsPath: geminiSettingsPath,
-    hookCommand: geminiHookCommand,
-  });
-  const opencodePluginConfigured = await isOpencodePluginInstalled({
-    configDir: opencodeConfigDir,
-  });
-  const openclawSessionPluginState = await probeOpenclawSessionPluginState({
-    home,
-    trackerDir,
-    env: process.env,
-  });
-  const openclawHookState = await probeOpenclawHookState({ home, trackerDir, env: process.env });
+  const integrationContext = await createIntegrationContext({ home, env: process.env });
+  const probes = await probeIntegrations(integrationContext);
+  const descriptors = new Map(listIntegrations().map((integration) => [integration.name, integration]));
+  const probeByName = new Map(probes.map((probe) => [probe.name, probe]));
 
   const lastUpload = uploadThrottle.lastSuccessMs
     ? parseEpochMsToIso(uploadThrottle.lastSuccessMs)
@@ -110,6 +72,13 @@ async function cmdStatus(argv = []) {
   });
   const subscriptionLines =
     subscriptions.length > 0 ? subscriptions.map(formatSubscriptionLine) : [];
+  const codexProbe = probeByName.get("codex");
+  const everyCodeProbe = probeByName.get("every-code");
+  const claudeProbe = probeByName.get("claude");
+  const geminiProbe = probeByName.get("gemini");
+  const opencodeProbe = probeByName.get("opencode");
+  const openclawSessionProbe = probeByName.get("openclaw-session");
+  const openclawLegacyProbe = probeByName.get("openclaw-legacy");
 
   process.stdout.write(
     [
@@ -126,13 +95,19 @@ async function cmdStatus(argv = []) {
       `- Backoff until: ${backoffUntil || "never"}`,
       lastUploadError ? `- Last upload error: ${lastUploadError}` : null,
       autoRetryLine,
-      `- Codex notify: ${notifyConfigured ? JSON.stringify(codexNotify) : "unset"}`,
-      `- Every Code notify: ${everyCodeConfigured ? JSON.stringify(everyCodeNotify) : "unset"}`,
-      `- Claude hooks: ${claudeHookConfigured ? "set" : "unset"}`,
-      `- Gemini hooks: ${geminiHookConfigured ? "set" : "unset"}`,
-      `- Opencode plugin: ${opencodePluginConfigured ? "set" : "unset"}`,
-      `- OpenClaw session plugin: ${openclawSessionPluginState?.configured ? "set" : "unset"}`,
-      `- OpenClaw hook (legacy): ${openclawHookState?.configured ? "set" : "unset"}`,
+      `- Codex notify: ${renderIntegrationStatus(descriptors.get("codex"), codexProbe)}`,
+      `- Every Code notify: ${renderIntegrationStatus(descriptors.get("every-code"), everyCodeProbe)}`,
+      `- Claude hooks: ${renderIntegrationStatus(descriptors.get("claude"), claudeProbe)}`,
+      `- Gemini hooks: ${renderIntegrationStatus(descriptors.get("gemini"), geminiProbe)}`,
+      `- Opencode plugin: ${renderIntegrationStatus(descriptors.get("opencode"), opencodeProbe)}`,
+      `- OpenClaw session plugin: ${renderIntegrationStatus(
+        descriptors.get("openclaw-session"),
+        openclawSessionProbe,
+      )}`,
+      `- OpenClaw hook (legacy): ${renderIntegrationStatus(
+        descriptors.get("openclaw-legacy"),
+        openclawLegacyProbe,
+      )}`,
       ...subscriptionLines,
       "",
     ]
@@ -141,6 +116,16 @@ async function cmdStatus(argv = []) {
   );
 }
 
+function renderIntegrationStatus(descriptor, probe) {
+  if (!probe) return "unknown";
+  if (descriptor && typeof descriptor.renderStatusValue === "function") {
+    return descriptor.renderStatusValue(probe);
+  }
+  if (probe.status === "ready") return "set";
+  if (probe.status === "not_installed") return "unset";
+  return probe.status || "unknown";
+}
+
 function formatSubscriptionLine(entry = {}) {
   const tool = String(entry.tool || "");
   const provider = String(entry.provider || "");

package/src/commands/sync.js

@@ -69,8 +69,9 @@ async function cmdSync(argv) {
     const opencodeHome = process.env.OPENCODE_HOME || path.join(xdgDataHome, "opencode");
     const opencodeStorageDir = path.join(opencodeHome, "storage");
 
-    // OpenClaw hook integration: allow a hook to request incremental parsing for a single session jsonl.
-    // We still parse all regular sources so model/source attribution stays complete (e.g. Kimi sessions).
+    // OpenClaw session-plugin integration: allow a plugin-triggered sync to request incremental parsing
+    // for a single session jsonl. We still parse all regular sources so model/source attribution stays
+    // complete (e.g. Kimi sessions).
     const openclawSignal = opts.fromOpenclaw
       ? resolveOpenclawSignal({ home, env: process.env })
       : null;
@@ -119,7 +120,7 @@ async function cmdSync(argv) {
 
     let openclawResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
     if (openclawFiles.length > 0) {
-      // Only runs when explicitly triggered by OpenClaw hooks.
+      // Only runs when explicitly triggered by OpenClaw session-plugin events.
       openclawResult = await parseOpenclawIncremental({
         sessionFiles: openclawFiles,
         cursors,

package/src/commands/uninstall.js

@@ -2,73 +2,27 @@ const os = require("node:os");
 const path = require("node:path");
 const fs = require("node:fs/promises");
 
-const { restoreCodexNotify, restoreEveryCodeNotify } = require("../lib/codex-config");
-const { removeClaudeHook, buildClaudeHookCommand } = require("../lib/claude-config");
-const {
-  resolveGeminiConfigDir,
-  resolveGeminiSettingsPath,
-  buildGeminiHookCommand,
-  removeGeminiHook,
-} = require("../lib/gemini-config");
-const { resolveOpencodeConfigDir, removeOpencodePlugin } = require("../lib/opencode-config");
-const { removeOpenclawHookConfig } = require("../lib/openclaw-hook");
-const { removeOpenclawSessionPluginConfig } = require("../lib/openclaw-session-plugin");
 const { resolveTrackerPaths } = require("../lib/tracker-paths");
+const { createIntegrationContext, uninstallIntegrations } = require("../lib/integrations");
 
 async function cmdUninstall(argv) {
   const opts = parseArgs(argv);
   const home = os.homedir();
   const { trackerDir, binDir } = await resolveTrackerPaths({ home });
-  const codexHome = process.env.CODEX_HOME || path.join(home, ".codex");
-  const codexConfigPath = path.join(codexHome, "config.toml");
-  const codeHome = process.env.CODE_HOME || path.join(home, ".code");
-  const codeConfigPath = path.join(codeHome, "config.toml");
-  const claudeSettingsPath = path.join(home, ".claude", "settings.json");
-  const geminiConfigDir = resolveGeminiConfigDir({ home, env: process.env });
-  const geminiSettingsPath = resolveGeminiSettingsPath({ configDir: geminiConfigDir });
-  const opencodeConfigDir = resolveOpencodeConfigDir({ home, env: process.env });
   const notifyPath = path.join(binDir, "notify.cjs");
-  const notifyOriginalPath = path.join(trackerDir, "codex_notify_original.json");
-  const codeNotifyOriginalPath = path.join(trackerDir, "code_notify_original.json");
-  const codexNotifyCmd = ["/usr/bin/env", "node", notifyPath];
-  const codeNotifyCmd = ["/usr/bin/env", "node", notifyPath, "--source=every-code"];
-  const claudeHookCommand = buildClaudeHookCommand(notifyPath);
-  const geminiHookCommand = buildGeminiHookCommand(notifyPath);
-
-  const codexConfigExists = await isFile(codexConfigPath);
-  const codeConfigExists = await isFile(codeConfigPath);
-  const claudeConfigExists = await isFile(claudeSettingsPath);
-  const geminiConfigExists = await isDir(geminiConfigDir);
-  const opencodeConfigExists = await isDir(opencodeConfigDir);
-  const codexRestore = codexConfigExists
-    ? await restoreCodexNotify({
-        codexConfigPath,
-        notifyOriginalPath,
-        notifyCmd: codexNotifyCmd,
-      })
-    : { restored: false, skippedReason: "config-missing" };
-  const codeRestore = codeConfigExists
-    ? await restoreEveryCodeNotify({
-        codeConfigPath,
-        notifyOriginalPath: codeNotifyOriginalPath,
-        notifyCmd: codeNotifyCmd,
-      })
-    : { restored: false, skippedReason: "config-missing" };
-  const claudeRemove = claudeConfigExists
-    ? await removeClaudeHook({ settingsPath: claudeSettingsPath, hookCommand: claudeHookCommand })
-    : { removed: false, skippedReason: "config-missing" };
-  const geminiRemove = geminiConfigExists
-    ? await removeGeminiHook({ settingsPath: geminiSettingsPath, hookCommand: geminiHookCommand })
-    : { removed: false, skippedReason: "config-missing" };
-  const opencodeRemove = opencodeConfigExists
-    ? await removeOpencodePlugin({ configDir: opencodeConfigDir })
-    : { removed: false, skippedReason: "config-missing" };
-  const openclawSessionPluginRemove = await removeOpenclawSessionPluginConfig({
+  const integrationContext = await createIntegrationContext({
     home,
-    trackerDir,
     env: process.env,
+    trackerPaths: { trackerDir, binDir, rootDir: path.dirname(trackerDir) },
+    notifyPath,
   });
-  const openclawHookRemove = await removeOpenclawHookConfig({ home, trackerDir, env: process.env });
+  const codexConfigExists = await isFile(integrationContext.codex.configPath);
+  const codeConfigExists = await isFile(integrationContext.everyCode.configPath);
+  const claudeConfigExists = await isFile(integrationContext.claude.settingsPath);
+  const geminiConfigExists = await isDir(integrationContext.gemini.configDir);
+  const opencodeConfigExists = await isDir(integrationContext.opencode.configDir);
+  const integrationResults = await uninstallIntegrations(integrationContext);
+  const resultByName = new Map(integrationResults.map((result) => [result.name, result]));
 
   // Remove installed notify handler.
   await fs.unlink(notifyPath).catch(() => {});
@@ -83,53 +37,73 @@ async function cmdUninstall(argv) {
   process.stdout.write(
     [
       "Uninstalled:",
-      codexConfigExists
-        ? codexRestore?.restored
-          ? `- Codex notify restored: ${codexConfigPath}`
-          : codexRestore?.skippedReason === "no-backup-not-installed"
-            ? "- Codex notify: skipped (no backup; not installed)"
-            : "- Codex notify: no change"
-        : "- Codex notify: skipped (config.toml not found)",
-      codeConfigExists
-        ? codeRestore?.restored
-          ? `- Every Code notify restored: ${codeConfigPath}`
-          : codeRestore?.skippedReason === "no-backup-not-installed"
-            ? "- Every Code notify: skipped (no backup; not installed)"
-            : "- Every Code notify: no change"
-        : "- Every Code notify: skipped (config.toml not found)",
-      claudeConfigExists
-        ? claudeRemove?.removed
-          ? `- Claude hooks removed: ${claudeSettingsPath}`
-          : claudeRemove?.skippedReason === "hook-missing"
-            ? "- Claude hooks: no change"
-            : "- Claude hooks: skipped"
-        : "- Claude hooks: skipped (settings.json not found)",
-      geminiConfigExists
-        ? geminiRemove?.removed
-          ? `- Gemini hooks removed: ${geminiSettingsPath}`
-          : geminiRemove?.skippedReason === "hook-missing"
-            ? "- Gemini hooks: no change"
-            : "- Gemini hooks: skipped"
-        : `- Gemini hooks: skipped (${geminiConfigDir} not found)`,
-      opencodeConfigExists
-        ? opencodeRemove?.removed
-          ? `- Opencode plugin removed: ${opencodeConfigDir}`
-          : opencodeRemove?.skippedReason === "plugin-missing"
-            ? "- Opencode plugin: no change"
-            : opencodeRemove?.skippedReason === "unexpected-content"
-              ? "- Opencode plugin: skipped (unexpected content)"
-              : "- Opencode plugin: skipped"
-        : `- Opencode plugin: skipped (${opencodeConfigDir} not found)`,
-      openclawSessionPluginRemove?.removed
-        ? `- OpenClaw session plugin removed: ${openclawSessionPluginRemove.openclawConfigPath}`
-        : openclawSessionPluginRemove?.skippedReason === "openclaw-config-missing"
-          ? "- OpenClaw session plugin: skipped (openclaw config not found)"
-          : "- OpenClaw session plugin: no change",
-      openclawHookRemove?.removed
-        ? `- OpenClaw hook (legacy) removed: ${openclawHookRemove.openclawConfigPath}`
-        : openclawHookRemove?.skippedReason === "openclaw-config-missing"
-          ? "- OpenClaw hook (legacy): skipped (openclaw config not found)"
-          : "- OpenClaw hook (legacy): no change",
+      renderRestoreLine({
+        exists: codexConfigExists,
+        result: resultByName.get("codex"),
+        missingText: "- Codex notify: skipped (config.toml not found)",
+        restoredText: (result) =>
+          `- Codex notify restored: ${result.detail || integrationContext.codex.configPath}`,
+        noChangeText: "- Codex notify: no change",
+        skippedText: "- Codex notify: skipped (no backup; not installed)",
+      }),
+      renderRestoreLine({
+        exists: codeConfigExists,
+        result: resultByName.get("every-code"),
+        missingText: "- Every Code notify: skipped (config.toml not found)",
+        restoredText: (result) =>
+          `- Every Code notify restored: ${result.detail || integrationContext.everyCode.configPath}`,
+        noChangeText: "- Every Code notify: no change",
+        skippedText: "- Every Code notify: skipped (no backup; not installed)",
+      }),
+      renderHookLine({
+        exists: claudeConfigExists,
+        result: resultByName.get("claude"),
+        missingText: "- Claude hooks: skipped (settings.json not found)",
+        removedText: (result) =>
+          `- Claude hooks removed: ${result.detail || integrationContext.claude.settingsPath}`,
+        noChangeText: "- Claude hooks: no change",
+        skippedText: "- Claude hooks: skipped",
+      }),
+      renderHookLine({
+        exists: geminiConfigExists,
+        result: resultByName.get("gemini"),
+        missingText: `- Gemini hooks: skipped (${integrationContext.gemini.configDir} not found)`,
+        removedText: (result) =>
+          `- Gemini hooks removed: ${result.detail || integrationContext.gemini.settingsPath}`,
+        noChangeText: "- Gemini hooks: no change",
+        skippedText: "- Gemini hooks: skipped",
+      }),
+      renderHookLine({
+        exists: opencodeConfigExists,
+        result: resultByName.get("opencode"),
+        missingText: `- Opencode plugin: skipped (${integrationContext.opencode.configDir} not found)`,
+        removedText: (result) =>
+          `- Opencode plugin removed: ${result.detail || integrationContext.opencode.configDir}`,
+        noChangeText: "- Opencode plugin: no change",
+        skippedText: "- Opencode plugin: skipped (unexpected content)",
+      }),
+      renderHookLine({
+        exists: true,
+        result: resultByName.get("openclaw-session"),
+        missingText: "- OpenClaw session plugin: skipped (openclaw config not found)",
+        removedText: (result) =>
+          `- OpenClaw session plugin removed: ${result.detail || result.openclawConfigPath || "unknown"}`,
+        noChangeText: "- OpenClaw session plugin: no change",
+        skippedText: "- OpenClaw session plugin: no change",
+        unreadableText: (result) =>
+          `- OpenClaw session plugin: skipped (${result.detail || "openclaw config unreadable"})`,
+      }),
+      renderHookLine({
+        exists: true,
+        result: resultByName.get("openclaw-legacy"),
+        missingText: "- OpenClaw hook (legacy): skipped (openclaw config not found)",
+        removedText: (result) =>
+          `- OpenClaw hook (legacy) removed: ${result.detail || result.openclawConfigPath || "unknown"}`,
+        noChangeText: "- OpenClaw hook (legacy): no change",
+        skippedText: "- OpenClaw hook (legacy): no change",
+        unreadableText: (result) =>
+          `- OpenClaw hook (legacy): skipped (${result.detail || "openclaw config unreadable"})`,
+      }),
       opts.purge ? `- Purged: ${path.join(home, ".vibeusage")}` : "- Purge: skipped (use --purge)",
       "",
     ].join("\n"),
@@ -157,6 +131,49 @@ async function isFile(p) {
   }
 }
 
+function renderRestoreLine({ exists, result, missingText, restoredText, noChangeText, skippedText }) {
+  if (!exists) return missingText;
+  if (!result) return noChangeText;
+  if (result.status === "restored" || result.status === "removed") {
+    return restoredText(result);
+  }
+  if (result.skippedReason === "no-backup-not-installed") {
+    return skippedText;
+  }
+  return noChangeText;
+}
+
+function renderHookLine({
+  exists,
+  result,
+  missingText,
+  removedText,
+  noChangeText,
+  skippedText,
+  unreadableText = null,
+}) {
+  if (!exists) return missingText;
+  if (!result) return noChangeText;
+  if (result.status === "removed" || result.status === "updated") {
+    return removedText(result);
+  }
+  if (result.skippedReason === "hook-missing") {
+    return noChangeText;
+  }
+  if (result.skippedReason === "unexpected-content") {
+    return skippedText;
+  }
+  if (result.skippedReason === "openclaw-config-missing") {
+    return missingText;
+  }
+  if (result.skippedReason === "openclaw-config-unreadable") {
+    return typeof unreadableText === "function"
+      ? unreadableText(result)
+      : unreadableText || skippedText;
+  }
+  return noChangeText;
+}
+
 async function isDir(p) {
   try {
     const st = await fs.stat(p);

package/src/lib/claude-config.js

@@ -3,57 +3,64 @@ const path = require("node:path");
 
 const { ensureDir, readJson, writeJson } = require("./fs");
 
-const DEFAULT_EVENT = "SessionEnd";
+const DEFAULT_EVENTS = ["Stop", "SessionEnd"];
 
-async function upsertClaudeHook({ settingsPath, hookCommand, event = DEFAULT_EVENT }) {
+async function upsertClaudeHook({ settingsPath, hookCommand, events = DEFAULT_EVENTS }) {
   const existing = await readJson(settingsPath);
   const settings = normalizeSettings(existing);
   const hooks = normalizeHooks(settings.hooks);
-  const entries = normalizeEntries(hooks[event]);
-
-  const normalized = normalizeEntriesForCommand(entries, hookCommand);
-  if (normalized.changed) {
-    const nextHooks = { ...hooks, [event]: normalized.entries };
-    const nextSettings = { ...settings, hooks: nextHooks };
-    const backupPath = await writeClaudeSettings({ settingsPath, settings: nextSettings });
-    return { changed: true, backupPath };
-  }
+  const targetEvents = normalizeEvents(events);
+  let changed = false;
+  const nextHooks = { ...hooks };
+
+  for (const event of targetEvents) {
+    const entries = normalizeEntries(nextHooks[event]);
+    const normalized = normalizeEntriesForCommand(entries, hookCommand);
+    if (normalized.changed) {
+      nextHooks[event] = normalized.entries;
+      changed = true;
+      continue;
+    }
+
+    if (hasHook(entries, hookCommand)) continue;
 
-  if (hasHook(entries, hookCommand)) {
-    return { changed: false, backupPath: null };
+    nextHooks[event] = entries.concat([{ hooks: [{ type: "command", command: hookCommand }] }]);
+    changed = true;
   }
 
-  const nextEntries = entries.concat([{ hooks: [{ type: "command", command: hookCommand }] }]);
-  const nextHooks = { ...hooks, [event]: nextEntries };
-  const nextSettings = { ...settings, hooks: nextHooks };
+  if (!changed) return { changed: false, backupPath: null };
 
+  const nextSettings = { ...settings, hooks: nextHooks };
   const backupPath = await writeClaudeSettings({ settingsPath, settings: nextSettings });
   return { changed: true, backupPath };
 }
 
-async function removeClaudeHook({ settingsPath, hookCommand, event = DEFAULT_EVENT }) {
+async function removeClaudeHook({ settingsPath, hookCommand, events = DEFAULT_EVENTS }) {
   const existing = await readJson(settingsPath);
   if (!existing) return { removed: false, skippedReason: "settings-missing" };
 
   const settings = normalizeSettings(existing);
   const hooks = normalizeHooks(settings.hooks);
-  const entries = normalizeEntries(hooks[event]);
-  if (entries.length === 0) return { removed: false, skippedReason: "hook-missing" };
-
+  const targetEvents = normalizeEvents(events);
   let removed = false;
-  const nextEntries = [];
-  for (const entry of entries) {
-    const res = stripHookFromEntry(entry, hookCommand);
-    if (res.removed) removed = true;
-    if (res.entry) nextEntries.push(res.entry);
+  const nextHooks = { ...hooks };
+  for (const event of targetEvents) {
+    const entries = normalizeEntries(hooks[event]);
+    if (entries.length === 0) continue;
+
+    const nextEntries = [];
+    for (const entry of entries) {
+      const res = stripHookFromEntry(entry, hookCommand);
+      if (res.removed) removed = true;
+      if (res.entry) nextEntries.push(res.entry);
+    }
+
+    if (nextEntries.length > 0) nextHooks[event] = nextEntries;
+    else delete nextHooks[event];
   }
 
   if (!removed) return { removed: false, skippedReason: "hook-missing" };
 
-  const nextHooks = { ...hooks };
-  if (nextEntries.length > 0) nextHooks[event] = nextEntries;
-  else delete nextHooks[event];
-
   const nextSettings = { ...settings };
   if (Object.keys(nextHooks).length > 0) nextSettings.hooks = nextHooks;
   else delete nextSettings.hooks;
@@ -62,13 +69,31 @@ async function removeClaudeHook({ settingsPath, hookCommand, event = DEFAULT_EVE
   return { removed: true, skippedReason: null, backupPath };
 }
 
-async function isClaudeHookConfigured({ settingsPath, hookCommand, event = DEFAULT_EVENT }) {
+async function isClaudeHookConfigured({ settingsPath, hookCommand, events = DEFAULT_EVENTS }) {
+  const probe = await probeClaudeHook({ settingsPath, hookCommand, events });
+  return probe.configured;
+}
+
+async function probeClaudeHook({ settingsPath, hookCommand, events = DEFAULT_EVENTS }) {
   const settings = await readJson(settingsPath);
-  if (!settings || typeof settings !== "object") return false;
+  if (!settings || typeof settings !== "object") {
+    return { configured: false, anyPresent: false, eventStates: {} };
+  }
   const hooks = settings.hooks;
-  if (!hooks || typeof hooks !== "object") return false;
-  const entries = normalizeEntries(hooks[event]);
-  return hasHook(entries, hookCommand);
+  if (!hooks || typeof hooks !== "object") {
+    return { configured: false, anyPresent: false, eventStates: {} };
+  }
+  const targetEvents = normalizeEvents(events);
+  const eventStates = {};
+  for (const event of targetEvents) {
+    eventStates[event] = hasHook(normalizeEntries(hooks[event]), hookCommand);
+  }
+  const anyPresent = Object.values(eventStates).some(Boolean);
+  return {
+    configured: targetEvents.every((event) => eventStates[event] === true),
+    anyPresent,
+    eventStates,
+  };
 }
 
 function buildClaudeHookCommand(notifyPath) {
@@ -88,9 +113,27 @@ function normalizeEntries(raw) {
   return Array.isArray(raw) ? raw.slice() : [];
 }
 
+function normalizeEvents(raw) {
+  const values = Array.isArray(raw) ? raw : [raw];
+  const out = [];
+  for (const value of values) {
+    if (typeof value !== "string") continue;
+    const normalized = value.trim();
+    if (!normalized || out.includes(normalized)) continue;
+    out.push(normalized);
+  }
+  return out.length > 0 ? out : DEFAULT_EVENTS.slice();
+}
+
 function normalizeCommand(cmd) {
   if (Array.isArray(cmd)) return cmd.map((v) => String(v)).join("\u0000");
-  if (typeof cmd === "string") return cmd.trim();
+  if (typeof cmd === "string") {
+    const raw = cmd.trim();
+    if (!raw) return null;
+    const parsed = splitShellCommand(raw);
+    if (parsed) return parsed.join("\u0000");
+    return raw;
+  }
   return null;
 }
 
@@ -166,6 +209,56 @@ function quoteArg(value) {
   return `"${v.replace(/"/g, '\\"')}"`;
 }
 
+function splitShellCommand(raw) {
+  const parts = [];
+  let current = "";
+  let quote = null;
+  let escaping = false;
+
+  for (let i = 0; i < raw.length; i += 1) {
+    const ch = raw[i];
+
+    if (escaping) {
+      current += ch;
+      escaping = false;
+      continue;
+    }
+
+    if (ch === "\\") {
+      escaping = true;
+      continue;
+    }
+
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else {
+        current += ch;
+      }
+      continue;
+    }
+
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+
+    if (/\s/.test(ch)) {
+      if (current) {
+        parts.push(current);
+        current = "";
+      }
+      continue;
+    }
+
+    current += ch;
+  }
+
+  if (escaping || quote) return null;
+  if (current) parts.push(current);
+  return parts.length > 0 ? parts : null;
+}
+
 async function writeClaudeSettings({ settingsPath, settings }) {
   await ensureDir(path.dirname(settingsPath));
   let backupPath = null;
@@ -183,8 +276,10 @@ async function writeClaudeSettings({ settingsPath, settings }) {
 }
 
 module.exports = {
+  DEFAULT_EVENTS,
   upsertClaudeHook,
   removeClaudeHook,
   isClaudeHookConfigured,
+  probeClaudeHook,
   buildClaudeHookCommand,
 };