vibeusage 0.2.23 → 0.3.0

package/src/lib/diagnostics.js

@@ -3,26 +3,23 @@ const path = require("node:path");
 const fs = require("node:fs/promises");
 
 const { readJson } = require("./fs");
-const { readCodexNotify, readEveryCodeNotify } = require("./codex-config");
-const { isClaudeHookConfigured, buildClaudeHookCommand } = require("./claude-config");
-const {
-  resolveGeminiConfigDir,
-  resolveGeminiSettingsPath,
-  buildGeminiHookCommand,
-  isGeminiHookConfigured,
-} = require("./gemini-config");
-const { resolveOpencodeConfigDir, isOpencodePluginInstalled } = require("./opencode-config");
 const { normalizeState: normalizeUploadState } = require("./upload-throttle");
-const { probeOpenclawHookState } = require("./openclaw-hook");
-const { probeOpenclawSessionPluginState } = require("./openclaw-session-plugin");
-const { resolveTrackerPaths } = require("./tracker-paths");
+const { createIntegrationContext, probeIntegrations } = require("./integrations");
 
 async function collectTrackerDiagnostics({
   home = os.homedir(),
   codexHome = process.env.CODEX_HOME || path.join(home, ".codex"),
   codeHome = process.env.CODE_HOME || path.join(home, ".code"),
 } = {}) {
-  const { trackerDir, binDir } = await resolveTrackerPaths({ home });
+  const integrationContext = await createIntegrationContext({
+    home,
+    env: {
+      ...process.env,
+      CODEX_HOME: codexHome,
+      CODE_HOME: codeHome,
+    },
+  });
+  const trackerDir = integrationContext.trackerPaths.trackerDir;
   const configPath = path.join(trackerDir, "config.json");
   const queuePath = path.join(trackerDir, "queue.jsonl");
   const queueStatePath = path.join(trackerDir, "queue.state.json");
@@ -34,16 +31,14 @@ async function collectTrackerDiagnostics({
   const autoRetryPath = path.join(trackerDir, "auto.retry.json");
   const codexConfigPath = path.join(codexHome, "config.toml");
   const codeConfigPath = path.join(codeHome, "config.toml");
-  const claudeConfigPath = 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 config = await readJson(configPath);
   const cursors = await readJson(cursorsPath);
   const queueState = (await readJson(queueStatePath)) || { offset: 0 };
   const uploadThrottle = normalizeUploadState(await readJson(uploadThrottlePath));
   const autoRetry = await readJson(autoRetryPath);
+  const probes = await probeIntegrations(integrationContext);
+  const probeByName = new Map(probes.map((probe) => [probe.name, probe]));
 
   const queueSize = await safeStatSize(queuePath);
   const offsetBytes = Number(queueState.offset || 0);
@@ -53,33 +48,20 @@ async function collectTrackerDiagnostics({
   const lastOpenclawSync = (await safeReadText(openclawSignalPath))?.trim() || null;
   const lastNotifySpawn = parseEpochMsToIso((await safeReadText(throttlePath))?.trim() || null);
 
-  const codexNotifyRaw = await readCodexNotify(codexConfigPath);
-  const notifyConfigured = Array.isArray(codexNotifyRaw) && codexNotifyRaw.length > 0;
-  const codexNotify = notifyConfigured ? codexNotifyRaw.map((v) => redactValue(v, home)) : null;
-  const everyCodeNotifyRaw = await readEveryCodeNotify(codeConfigPath);
-  const everyCodeConfigured = Array.isArray(everyCodeNotifyRaw) && everyCodeNotifyRaw.length > 0;
-  const everyCodeNotify = everyCodeConfigured
-    ? everyCodeNotifyRaw.map((v) => redactValue(v, home))
+  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");
+
+  const codexNotify = Array.isArray(codexProbe?.currentNotify)
+    ? codexProbe.currentNotify.map((value) => redactValue(value, home))
+    : null;
+  const everyCodeNotify = Array.isArray(everyCodeProbe?.currentNotify)
+    ? everyCodeProbe.currentNotify.map((value) => redactValue(value, home))
     : null;
-  const claudeHookCommand = buildClaudeHookCommand(path.join(binDir, "notify.cjs"));
-  const claudeHookConfigured = await isClaudeHookConfigured({
-    settingsPath: claudeConfigPath,
-    hookCommand: claudeHookCommand,
-  });
-  const geminiHookCommand = buildGeminiHookCommand(path.join(binDir, "notify.cjs"));
-  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 lastSuccessAt = uploadThrottle.lastSuccessMs
     ? new Date(uploadThrottle.lastSuccessMs).toISOString()
@@ -101,9 +83,9 @@ async function collectTrackerDiagnostics({
       codex_config: redactValue(codexConfigPath, home),
       code_home: redactValue(codeHome, home),
       code_config: redactValue(codeConfigPath, home),
-      claude_config: redactValue(claudeConfigPath, home),
-      gemini_config: redactValue(geminiSettingsPath, home),
-      opencode_config: redactValue(opencodeConfigDir, home),
+      claude_config: redactValue(integrationContext.claude.settingsPath, home),
+      gemini_config: redactValue(integrationContext.gemini.settingsPath, home),
+      opencode_config: redactValue(integrationContext.opencode.configDir, home),
     },
     config: {
       base_url: typeof config?.baseUrl === "string" ? config.baseUrl : null,
@@ -128,19 +110,34 @@ async function collectTrackerDiagnostics({
       last_notify: lastNotify,
       last_openclaw_triggered_sync: lastOpenclawSync,
       last_notify_triggered_sync: lastNotifySpawn,
-      codex_notify_configured: notifyConfigured,
+      codex_notify_status: codexProbe?.status || "unknown",
+      codex_notify_configured: Boolean(codexProbe?.configured),
       codex_notify: codexNotify,
-      every_code_notify_configured: everyCodeConfigured,
+      every_code_notify_status: everyCodeProbe?.status || "unknown",
+      every_code_notify_configured: Boolean(everyCodeProbe?.configured),
       every_code_notify: everyCodeNotify,
-      claude_hook_configured: claudeHookConfigured,
-      gemini_hook_configured: geminiHookConfigured,
-      opencode_plugin_configured: opencodePluginConfigured,
-      openclaw_session_plugin_configured: Boolean(openclawSessionPluginState?.configured),
-      openclaw_session_plugin_linked: Boolean(openclawSessionPluginState?.linked),
-      openclaw_session_plugin_enabled: Boolean(openclawSessionPluginState?.enabled),
-      openclaw_hook_configured: Boolean(openclawHookState?.configured),
-      openclaw_hook_linked: Boolean(openclawHookState?.linked),
-      openclaw_hook_enabled: Boolean(openclawHookState?.enabled),
+      claude_hook_status: claudeProbe?.status || "unknown",
+      claude_hook_configured: Boolean(claudeProbe?.configured),
+      gemini_hook_status: geminiProbe?.status || "unknown",
+      gemini_hook_configured: Boolean(geminiProbe?.configured),
+      opencode_plugin_status: opencodeProbe?.status || "unknown",
+      opencode_plugin_configured: Boolean(opencodeProbe?.configured),
+      openclaw_session_plugin_status: openclawSessionProbe?.status || "unknown",
+      openclaw_session_plugin_configured: Boolean(openclawSessionProbe?.configured),
+      openclaw_session_plugin_linked: Boolean(openclawSessionProbe?.linked),
+      openclaw_session_plugin_enabled: Boolean(openclawSessionProbe?.enabled),
+      openclaw_session_plugin_detail:
+        typeof openclawSessionProbe?.detail === "string"
+          ? redactError(openclawSessionProbe.detail, home)
+          : null,
+      openclaw_hook_status: openclawLegacyProbe?.status || "unknown",
+      openclaw_hook_configured: Boolean(openclawLegacyProbe?.configured),
+      openclaw_hook_linked: Boolean(openclawLegacyProbe?.linked),
+      openclaw_hook_enabled: Boolean(openclawLegacyProbe?.enabled),
+      openclaw_hook_detail:
+        typeof openclawLegacyProbe?.detail === "string"
+          ? redactError(openclawLegacyProbe.detail, home)
+          : null,
     },
     upload: {
       last_success_at: lastSuccessAt,

package/src/lib/doctor.js

@@ -313,6 +313,7 @@ function buildDiagnosticsChecks(diagnostics) {
     notify.claude_hook_configured ||
     notify.gemini_hook_configured ||
     notify.opencode_plugin_configured ||
+    notify.openclaw_session_plugin_configured ||
     notify.openclaw_hook_configured,
   );
 
@@ -324,6 +325,32 @@ function buildDiagnosticsChecks(diagnostics) {
     meta: { configured: notifyConfigured },
   });
 
+  if (notify.openclaw_session_plugin_status === "unreadable") {
+    checks.push({
+      id: "notify.openclaw_session_plugin",
+      status: "warn",
+      detail: "OpenClaw session plugin config unreadable",
+      critical: false,
+      meta: {
+        status: notify.openclaw_session_plugin_status,
+        detail: notify.openclaw_session_plugin_detail || null,
+      },
+    });
+  }
+
+  if (notify.openclaw_hook_status === "unreadable") {
+    checks.push({
+      id: "notify.openclaw_hook",
+      status: "warn",
+      detail: "OpenClaw hook config unreadable",
+      critical: false,
+      meta: {
+        status: notify.openclaw_hook_status,
+        detail: notify.openclaw_hook_detail || null,
+      },
+    });
+  }
+
   const uploadError = diagnostics?.upload?.last_error || null;
   checks.push({
     id: "upload.last_error",

package/src/lib/integrations/claude.js

@@ -0,0 +1,106 @@
+const { probeClaudeHook, upsertClaudeHook, removeClaudeHook } = require("../claude-config");
+const { isDir, isFile } = require("./utils");
+
+module.exports = {
+  name: "claude",
+  summaryLabel: "Claude",
+  statusLabel: "Claude hooks",
+  async probe(ctx) {
+    const hasConfigDir = await isDir(ctx.claude.configDir);
+    if (!hasConfigDir) {
+      return baseProbe(this, { status: "not_installed", detail: "Config not found" });
+    }
+
+    const hasSettings = await isFile(ctx.claude.settingsPath);
+    if (!hasSettings) {
+      return baseProbe(this, { status: "drifted", detail: "Run vibeusage init to install hooks" });
+    }
+
+    const hookState = await probeClaudeHook({
+      settingsPath: ctx.claude.settingsPath,
+      hookCommand: ctx.claude.hookCommand,
+    });
+
+    if (hookState.configured) {
+      return baseProbe(this, {
+        status: "ready",
+        detail: "Hooks installed",
+        configured: true,
+        hookState,
+      });
+    }
+
+    const sessionEndPresent = hookState.eventStates?.SessionEnd === true;
+    const stopPresent = hookState.eventStates?.Stop === true;
+    const status = hookState.anyPresent && sessionEndPresent && !stopPresent
+      ? "unsupported_legacy"
+      : "drifted";
+    return baseProbe(this, {
+      status,
+      detail:
+        status === "unsupported_legacy"
+          ? "Legacy hook config detected; run vibeusage init"
+          : "Run vibeusage init to reconcile hooks",
+      hookState,
+    });
+  },
+  async install(ctx) {
+    if (!(await isDir(ctx.claude.configDir))) {
+      return action(this, "skipped", false, "Config not found");
+    }
+    const result = await upsertClaudeHook({
+      settingsPath: ctx.claude.settingsPath,
+      hookCommand: ctx.claude.hookCommand,
+    });
+    return action(
+      this,
+      result.changed ? "installed" : "set",
+      Boolean(result.changed),
+      result.changed ? "Hooks installed" : "Hooks already installed",
+    );
+  },
+  async uninstall(ctx) {
+    if (!(await isFile(ctx.claude.settingsPath))) {
+      return action(this, "skipped", false, "settings.json not found");
+    }
+    const result = await removeClaudeHook({
+      settingsPath: ctx.claude.settingsPath,
+      hookCommand: ctx.claude.hookCommand,
+    });
+    if (result.removed) {
+      return action(this, "removed", true, ctx.claude.settingsPath);
+    }
+    if (result.skippedReason === "hook-missing") {
+      return action(this, "unchanged", false, "no change", {
+        skippedReason: result.skippedReason,
+      });
+    }
+    return action(this, "skipped", false, "settings.json not found");
+  },
+  renderStatusValue(probe) {
+    if (probe.status === "ready") return "set";
+    if (probe.status === "not_installed") return "unset";
+    return probe.status;
+  },
+};
+
+function baseProbe(descriptor, values) {
+  return {
+    name: descriptor.name,
+    summaryLabel: descriptor.summaryLabel,
+    statusLabel: descriptor.statusLabel,
+    configured: false,
+    ...values,
+  };
+}
+
+function action(descriptor, status, changed, detail, extras = {}) {
+  return {
+    name: descriptor.name,
+    label: descriptor.summaryLabel,
+    status,
+    changed,
+    detail,
+    ...extras,
+  };
+}

package/src/lib/integrations/codex.js

@@ -0,0 +1,88 @@
+const {
+  readCodexNotify,
+  upsertCodexNotify,
+  restoreCodexNotify,
+} = require("../codex-config");
+const { arraysEqual, isFile } = require("./utils");
+
+module.exports = {
+  name: "codex",
+  summaryLabel: "Codex CLI",
+  statusLabel: "Codex notify",
+  async probe(ctx) {
+    const installed = await isFile(ctx.codex.configPath);
+    if (!installed) {
+      return baseProbe(this, { status: "not_installed", detail: "Config not found" });
+    }
+
+    const currentNotify = await readCodexNotify(ctx.codex.configPath);
+    const ready = arraysEqual(currentNotify, ctx.codex.notifyCmd);
+    return baseProbe(this, {
+      status: ready ? "ready" : "drifted",
+      detail: ready ? "Config already set" : "Run vibeusage init to reconcile notify",
+      configured: ready,
+      currentNotify,
+    });
+  },
+  async install(ctx) {
+    if (!(await isFile(ctx.codex.configPath))) {
+      return action(this, "skipped", false, "Config not found");
+    }
+    const result = await upsertCodexNotify({
+      codexConfigPath: ctx.codex.configPath,
+      notifyCmd: ctx.codex.notifyCmd,
+      notifyOriginalPath: ctx.codex.notifyOriginalPath,
+    });
+    return action(
+      this,
+      result.changed ? "updated" : "set",
+      Boolean(result.changed),
+      result.changed ? "Updated config" : "Config already set",
+    );
+  },
+  async uninstall(ctx) {
+    if (!(await isFile(ctx.codex.configPath))) {
+      return action(this, "skipped", false, "config.toml not found");
+    }
+    const result = await restoreCodexNotify({
+      codexConfigPath: ctx.codex.configPath,
+      notifyOriginalPath: ctx.codex.notifyOriginalPath,
+      notifyCmd: ctx.codex.notifyCmd,
+    });
+    if (result.restored) {
+      return action(this, "restored", true, ctx.codex.configPath);
+    }
+    if (result.skippedReason === "no-backup-not-installed") {
+      return action(this, "skipped", false, "no backup; not installed", {
+        skippedReason: result.skippedReason,
+      });
+    }
+    return action(this, "unchanged", false, "no change");
+  },
+  renderStatusValue(probe) {
+    if (probe.status === "ready") return JSON.stringify(probe.currentNotify || []);
+    if (probe.status === "not_installed") return "unset";
+    return probe.status;
+  },
+};
+
+function baseProbe(descriptor, values) {
+  return {
+    name: descriptor.name,
+    summaryLabel: descriptor.summaryLabel,
+    statusLabel: descriptor.statusLabel,
+    configured: false,
+    ...values,
+  };
+}
+
+function action(descriptor, status, changed, detail, extras = {}) {
+  return {
+    name: descriptor.name,
+    label: descriptor.summaryLabel,
+    status,
+    changed,
+    detail,
+    ...extras,
+  };
+}

package/src/lib/integrations/context.js

@@ -0,0 +1,76 @@
+const os = require("node:os");
+const path = require("node:path");
+
+const { buildClaudeHookCommand } = require("../claude-config");
+const {
+  resolveGeminiConfigDir,
+  resolveGeminiSettingsPath,
+  buildGeminiHookCommand,
+} = require("../gemini-config");
+const { resolveOpencodeConfigDir } = require("../opencode-config");
+const { resolveOpenclawHookPaths } = require("../openclaw-hook");
+const { resolveOpenclawSessionPluginPaths } = require("../openclaw-session-plugin");
+const { resolveTrackerPaths } = require("../tracker-paths");
+
+async function createIntegrationContext({
+  home = os.homedir(),
+  env = process.env,
+  trackerPaths = null,
+  notifyPath = null,
+} = {}) {
+  const resolvedTrackerPaths = trackerPaths || (await resolveTrackerPaths({ home }));
+  const resolvedNotifyPath = notifyPath || path.join(resolvedTrackerPaths.binDir, "notify.cjs");
+
+  const codexHome = env.CODEX_HOME || path.join(home, ".codex");
+  const codeHome = env.CODE_HOME || path.join(home, ".code");
+  const claudeDir = path.join(home, ".claude");
+  const geminiConfigDir = resolveGeminiConfigDir({ home, env });
+  const opencodeConfigDir = resolveOpencodeConfigDir({ home, env });
+
+  return {
+    home,
+    env,
+    trackerPaths: resolvedTrackerPaths,
+    notifyPath: resolvedNotifyPath,
+    codex: {
+      configPath: path.join(codexHome, "config.toml"),
+      notifyCmd: ["/usr/bin/env", "node", resolvedNotifyPath],
+      notifyOriginalPath: path.join(resolvedTrackerPaths.trackerDir, "codex_notify_original.json"),
+    },
+    everyCode: {
+      configPath: path.join(codeHome, "config.toml"),
+      notifyCmd: ["/usr/bin/env", "node", resolvedNotifyPath, "--source=every-code"],
+      notifyOriginalPath: path.join(
+        resolvedTrackerPaths.trackerDir,
+        "code_notify_original.json",
+      ),
+    },
+    claude: {
+      configDir: claudeDir,
+      settingsPath: path.join(claudeDir, "settings.json"),
+      hookCommand: buildClaudeHookCommand(resolvedNotifyPath),
+    },
+    gemini: {
+      configDir: geminiConfigDir,
+      settingsPath: resolveGeminiSettingsPath({ configDir: geminiConfigDir }),
+      hookCommand: buildGeminiHookCommand(resolvedNotifyPath),
+    },
+    opencode: {
+      configDir: opencodeConfigDir,
+    },
+    openclawSession: resolveOpenclawSessionPluginPaths({
+      home,
+      trackerDir: resolvedTrackerPaths.trackerDir,
+      env,
+    }),
+    openclawLegacy: resolveOpenclawHookPaths({
+      home,
+      trackerDir: resolvedTrackerPaths.trackerDir,
+      env,
+    }),
+  };
+}
+
+module.exports = {
+  createIntegrationContext,
+};

package/src/lib/integrations/every-code.js

@@ -0,0 +1,88 @@
+const {
+  readEveryCodeNotify,
+  upsertEveryCodeNotify,
+  restoreEveryCodeNotify,
+} = require("../codex-config");
+const { arraysEqual, isFile } = require("./utils");
+
+module.exports = {
+  name: "every-code",
+  summaryLabel: "Every Code",
+  statusLabel: "Every Code notify",
+  async probe(ctx) {
+    const installed = await isFile(ctx.everyCode.configPath);
+    if (!installed) {
+      return baseProbe(this, { status: "not_installed", detail: "Config not found" });
+    }
+
+    const currentNotify = await readEveryCodeNotify(ctx.everyCode.configPath);
+    const ready = arraysEqual(currentNotify, ctx.everyCode.notifyCmd);
+    return baseProbe(this, {
+      status: ready ? "ready" : "drifted",
+      detail: ready ? "Config already set" : "Run vibeusage init to reconcile notify",
+      configured: ready,
+      currentNotify,
+    });
+  },
+  async install(ctx) {
+    if (!(await isFile(ctx.everyCode.configPath))) {
+      return action(this, "skipped", false, "Config not found");
+    }
+    const result = await upsertEveryCodeNotify({
+      codeConfigPath: ctx.everyCode.configPath,
+      notifyCmd: ctx.everyCode.notifyCmd,
+      notifyOriginalPath: ctx.everyCode.notifyOriginalPath,
+    });
+    return action(
+      this,
+      result.changed ? "updated" : "set",
+      Boolean(result.changed),
+      result.changed ? "Updated config" : "Config already set",
+    );
+  },
+  async uninstall(ctx) {
+    if (!(await isFile(ctx.everyCode.configPath))) {
+      return action(this, "skipped", false, "config.toml not found");
+    }
+    const result = await restoreEveryCodeNotify({
+      codeConfigPath: ctx.everyCode.configPath,
+      notifyOriginalPath: ctx.everyCode.notifyOriginalPath,
+      notifyCmd: ctx.everyCode.notifyCmd,
+    });
+    if (result.restored) {
+      return action(this, "restored", true, ctx.everyCode.configPath);
+    }
+    if (result.skippedReason === "no-backup-not-installed") {
+      return action(this, "skipped", false, "no backup; not installed", {
+        skippedReason: result.skippedReason,
+      });
+    }
+    return action(this, "unchanged", false, "no change");
+  },
+  renderStatusValue(probe) {
+    if (probe.status === "ready") return JSON.stringify(probe.currentNotify || []);
+    if (probe.status === "not_installed") return "unset";
+    return probe.status;
+  },
+};
+
+function baseProbe(descriptor, values) {
+  return {
+    name: descriptor.name,
+    summaryLabel: descriptor.summaryLabel,
+    statusLabel: descriptor.statusLabel,
+    configured: false,
+    ...values,
+  };
+}
+
+function action(descriptor, status, changed, detail, extras = {}) {
+  return {
+    name: descriptor.name,
+    label: descriptor.summaryLabel,
+    status,
+    changed,
+    detail,
+    ...extras,
+  };
+}

package/src/lib/integrations/gemini.js

@@ -0,0 +1,86 @@
+const {
+  isGeminiHookConfigured,
+  upsertGeminiHook,
+  removeGeminiHook,
+} = require("../gemini-config");
+const { isDir, isFile } = require("./utils");
+
+module.exports = {
+  name: "gemini",
+  summaryLabel: "Gemini",
+  statusLabel: "Gemini hooks",
+  async probe(ctx) {
+    const hasConfigDir = await isDir(ctx.gemini.configDir);
+    if (!hasConfigDir) {
+      return baseProbe(this, { status: "not_installed", detail: "Config not found" });
+    }
+    const configured = await isGeminiHookConfigured({
+      settingsPath: ctx.gemini.settingsPath,
+      hookCommand: ctx.gemini.hookCommand,
+    });
+    return baseProbe(this, {
+      status: configured ? "ready" : "drifted",
+      detail: configured ? "Hooks installed" : "Run vibeusage init to reconcile hooks",
+      configured,
+    });
+  },
+  async install(ctx) {
+    if (!(await isDir(ctx.gemini.configDir))) {
+      return action(this, "skipped", false, "Config not found");
+    }
+    const result = await upsertGeminiHook({
+      settingsPath: ctx.gemini.settingsPath,
+      hookCommand: ctx.gemini.hookCommand,
+    });
+    return action(
+      this,
+      result.changed ? "installed" : "set",
+      Boolean(result.changed),
+      result.changed ? "Hooks installed" : "Hooks already installed",
+    );
+  },
+  async uninstall(ctx) {
+    if (!(await isDir(ctx.gemini.configDir))) {
+      return action(this, "skipped", false, "config dir not found");
+    }
+    const result = await removeGeminiHook({
+      settingsPath: ctx.gemini.settingsPath,
+      hookCommand: ctx.gemini.hookCommand,
+    });
+    if (result.removed) {
+      return action(this, "removed", true, ctx.gemini.settingsPath);
+    }
+    if (result.skippedReason === "hook-missing") {
+      return action(this, "unchanged", false, "no change", {
+        skippedReason: result.skippedReason,
+      });
+    }
+    return action(this, "skipped", false, "settings.json not found");
+  },
+  renderStatusValue(probe) {
+    if (probe.status === "ready") return "set";
+    if (probe.status === "not_installed") return "unset";
+    return probe.status;
+  },
+};
+
+function baseProbe(descriptor, values) {
+  return {
+    name: descriptor.name,
+    summaryLabel: descriptor.summaryLabel,
+    statusLabel: descriptor.statusLabel,
+    configured: false,
+    ...values,
+  };
+}
+
+function action(descriptor, status, changed, detail, extras = {}) {
+  return {
+    name: descriptor.name,
+    label: descriptor.summaryLabel,
+    status,
+    changed,
+    detail,
+    ...extras,
+  };
+}