vibeusage 0.2.23 → 0.3.1

package/src/lib/diagnostics.js

@@ -3,26 +3,27 @@ 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 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");
+  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 +35,17 @@ 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 opencodeSqliteCursor =
+    cursors?.opencodeSqlite && typeof cursors.opencodeSqlite === "object" ? cursors.opencodeSqlite : {};
+  const opencodeDbStat = await safeStat(opencodeDbPath);
 
   const queueSize = await safeStatSize(queuePath);
   const offsetBytes = Number(queueState.offset || 0);
@@ -53,33 +55,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 +90,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,
@@ -124,23 +113,57 @@ async function collectTrackerDiagnostics({
       pending_bytes: pendingBytes,
       updated_at: typeof queueState.updatedAt === "string" ? queueState.updatedAt : null,
     },
+    opencode: {
+      storage_dir: redactValue(opencodeStorageDir, home),
+      db_path: redactValue(opencodeDbPath, home),
+      sqlite_db_present: Boolean(opencodeDbStat?.isFile?.()),
+      sqlite_status:
+        typeof opencodeSqliteCursor.lastStatus === "string" && opencodeSqliteCursor.lastStatus.trim()
+          ? opencodeSqliteCursor.lastStatus.trim()
+          : "never_checked",
+      sqlite_last_checked_at:
+        typeof opencodeSqliteCursor.lastCheckedAt === "string"
+          ? opencodeSqliteCursor.lastCheckedAt
+          : null,
+      sqlite_cursor_updated_at:
+        typeof opencodeSqliteCursor.updatedAt === "string" ? opencodeSqliteCursor.updatedAt : null,
+      sqlite_error_code:
+        typeof opencodeSqliteCursor.lastErrorCode === "string"
+          ? opencodeSqliteCursor.lastErrorCode
+          : null,
+    },
     notify: {
       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,
@@ -197,6 +220,14 @@ async function safeStatSize(p) {
   }
 }
 
+async function safeStat(p) {
+  try {
+    return await fs.stat(p);
+  } catch (_e) {
+    return null;
+  }
+}
+
 async function safeReadText(p) {
   try {
     return await fs.readFile(p, "utf8");

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",
@@ -333,6 +360,29 @@ function buildDiagnosticsChecks(diagnostics) {
     meta: { last_error: uploadError ? uploadError.message || null : null },
   });
 
+  const opencode = diagnostics?.opencode || {};
+  const sqliteStatus =
+    typeof opencode.sqlite_status === "string" && opencode.sqlite_status.trim()
+      ? opencode.sqlite_status.trim()
+      : "never_checked";
+  let opencodeStatus = "warn";
+  if (sqliteStatus === "ok") opencodeStatus = "ok";
+  else if (sqliteStatus === "missing-sqlite3" || sqliteStatus === "query-failed") {
+    opencodeStatus = "fail";
+  }
+  checks.push({
+    id: "opencode.sqlite_support",
+    status: opencodeStatus,
+    detail: `OpenCode SQLite reader ${sqliteStatus}`,
+    critical: false,
+    meta: {
+      sqlite_status: sqliteStatus,
+      sqlite_db_present: Boolean(opencode.sqlite_db_present),
+      sqlite_last_checked_at: opencode.sqlite_last_checked_at || null,
+      sqlite_error_code: opencode.sqlite_error_code || null,
+    },
+  });
+
   return checks;
 }
 

package/src/lib/insforge-client.js

@@ -1,13 +1,17 @@
 "use strict";
 
-function loadInsforgeSdk() {
-  try {
-    return require("@insforge/sdk");
-  } catch (err) {
-    const wrapped = new Error("Missing dependency @insforge/sdk. Please reinstall vibeusage.");
-    wrapped.cause = err;
-    throw wrapped;
+let sdkModulePromise = null;
+
+async function loadInsforgeSdk() {
+  if (!sdkModulePromise) {
+    sdkModulePromise = import("@insforge/sdk").catch((err) => {
+      sdkModulePromise = null;
+      const wrapped = new Error("Missing dependency @insforge/sdk. Please reinstall vibeusage.");
+      wrapped.cause = err;
+      throw wrapped;
+    });
   }
+  return sdkModulePromise;
 }
 
 function getAnonKey({ env = process.env } = {}) {
@@ -45,9 +49,9 @@ function createTimeoutFetch(baseFetch) {
   };
 }
 
-function createInsforgeClient({ baseUrl, accessToken } = {}) {
+async function createInsforgeClient({ baseUrl, accessToken } = {}) {
   if (!baseUrl) throw new Error("Missing baseUrl");
-  const { createClient } = loadInsforgeSdk();
+  const { createClient } = await loadInsforgeSdk();
   const anonKey = getAnonKey();
   return createClient({
     baseUrl,

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