vibeusage 0.2.23 → 0.3.1

package/src/commands/sync.js

@@ -68,9 +68,11 @@ async function cmdSync(argv) {
     const xdgDataHome = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
     const opencodeHome = process.env.OPENCODE_HOME || path.join(xdgDataHome, "opencode");
     const opencodeStorageDir = path.join(opencodeHome, "storage");
+    const opencodeDbPath = path.join(opencodeHome, "opencode.db");
 
-    // 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 +121,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,
@@ -194,29 +196,28 @@ async function cmdSync(argv) {
 
     const opencodeFiles = await listOpencodeMessageFiles(opencodeStorageDir);
     let opencodeResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
-    if (opencodeFiles.length > 0) {
-      if (progress?.enabled) {
-        progress.start(
-          `Parsing Opencode ${renderBar(0)} 0/${formatNumber(opencodeFiles.length)} files | buckets 0`,
-        );
-      }
-      opencodeResult = await parseOpencodeIncremental({
-        messageFiles: opencodeFiles,
-        cursors,
-        queuePath,
-        projectQueuePath,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing Opencode ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
-              p.total,
-            )} files | buckets ${formatNumber(p.bucketsQueued)}`,
-          );
-        },
-        source: "opencode",
-      });
+    if (progress?.enabled && opencodeFiles.length > 0) {
+      progress.start(
+        `Parsing Opencode ${renderBar(0)} 0/${formatNumber(opencodeFiles.length)} files | buckets 0`,
+      );
     }
+    opencodeResult = await parseOpencodeIncremental({
+      messageFiles: opencodeFiles,
+      opencodeDbPath,
+      cursors,
+      queuePath,
+      projectQueuePath,
+      onProgress: (p) => {
+        if (!progress?.enabled) return;
+        const pct = p.total > 0 ? p.index / p.total : 1;
+        progress.update(
+          `Parsing Opencode ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
+            p.total,
+          )} files | buckets ${formatNumber(p.bucketsQueued)}`,
+        );
+      },
+      source: "opencode",
+    });
 
     if (cursors?.projectHourly?.projects && projectQueuePath && projectQueueStatePath) {
       for (const [projectKey, meta] of Object.entries(cursors.projectHourly.projects)) {
@@ -414,6 +415,17 @@ async function cmdSync(argv) {
           .filter(Boolean)
           .join("\n"),
       );
+      if (
+        opencodeResult.sqliteStatus === "missing-sqlite3" ||
+        opencodeResult.sqliteStatus === "query-failed"
+      ) {
+        const reason = opencodeResult.sqliteErrorCode
+          ? `${opencodeResult.sqliteStatus} (${opencodeResult.sqliteErrorCode})`
+          : opencodeResult.sqliteStatus;
+        process.stderr.write(
+          `Warning: OpenCode usage may be incomplete because the SQLite reader is ${reason}. Run \`vibeusage doctor\` for details.\n`,
+        );
+      }
     }
   } finally {
     progress?.stop();

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,
 };