vibeusage 0.3.3 → 0.3.5

package/src/lib/diagnostics.js

@@ -3,6 +3,7 @@ const path = require("node:path");
 const fs = require("node:fs/promises");
 
 const { readJson } = require("./fs");
+const { readLastHermesUsageEvent, resolveHermesUsageLedgerPaths } = require("./hermes-usage-ledger");
 const { normalizeState: normalizeUploadState } = require("./upload-throttle");
 const { createIntegrationContext, probeIntegrations } = require("./integrations");
 
@@ -25,6 +26,7 @@ async function collectTrackerDiagnostics({
   });
   const trackerDir = integrationContext.trackerPaths.trackerDir;
   const configPath = path.join(trackerDir, "config.json");
+  const { ledgerPath: hermesLedgerPath } = resolveHermesUsageLedgerPaths({ trackerDir });
   const queuePath = path.join(trackerDir, "queue.jsonl");
   const queueStatePath = path.join(trackerDir, "queue.state.json");
   const cursorsPath = path.join(trackerDir, "cursors.json");
@@ -45,7 +47,10 @@ async function collectTrackerDiagnostics({
   const probeByName = new Map(probes.map((probe) => [probe.name, probe]));
   const opencodeSqliteCursor =
     cursors?.opencodeSqlite && typeof cursors.opencodeSqlite === "object" ? cursors.opencodeSqlite : {};
+  const hermesLedgerCursor =
+    cursors?.hermesLedger && typeof cursors.hermesLedger === "object" ? cursors.hermesLedger : {};
   const opencodeDbStat = await safeStat(opencodeDbPath);
+  const hermesLedgerStat = await safeStat(hermesLedgerPath);
 
   const queueSize = await safeStatSize(queuePath);
   const offsetBytes = Number(queueState.offset || 0);
@@ -60,6 +65,7 @@ async function collectTrackerDiagnostics({
   const claudeProbe = probeByName.get("claude");
   const geminiProbe = probeByName.get("gemini");
   const opencodeProbe = probeByName.get("opencode");
+  const hermesProbe = probeByName.get("hermes");
   const openclawSessionProbe = probeByName.get("openclaw-session");
 
   const codexNotify = Array.isArray(codexProbe?.currentNotify)
@@ -73,6 +79,7 @@ async function collectTrackerDiagnostics({
     ? new Date(uploadThrottle.lastSuccessMs).toISOString()
     : null;
   const autoRetryAt = parseEpochMsToIso(autoRetry?.retryAtMs);
+  const hermesLastLedgerEvent = await readLastHermesUsageEvent({ trackerDir });
 
   return {
     ok: true,
@@ -92,6 +99,9 @@ async function collectTrackerDiagnostics({
       claude_config: redactValue(integrationContext.claude.settingsPath, home),
       gemini_config: redactValue(integrationContext.gemini.settingsPath, home),
       opencode_config: redactValue(integrationContext.opencode.configDir, home),
+      hermes_home: redactValue(integrationContext.hermes.hermesHome, home),
+      hermes_plugin_dir: redactValue(integrationContext.hermes.pluginDir, home),
+      hermes_ledger: redactValue(hermesLedgerPath, home),
     },
     config: {
       base_url: typeof config?.baseUrl === "string" ? config.baseUrl : null,
@@ -131,6 +141,22 @@ async function collectTrackerDiagnostics({
           ? opencodeSqliteCursor.lastErrorCode
           : null,
     },
+    hermes: {
+      ledger_present: Boolean(hermesLedgerStat?.isFile?.()),
+      ledger_size_bytes: hermesLedgerStat?.isFile?.() ? Number(hermesLedgerStat.size || 0) : 0,
+      ledger_offset:
+        Number.isFinite(Number(hermesLedgerCursor.offset)) ? Math.max(0, Number(hermesLedgerCursor.offset)) : 0,
+      ledger_updated_at:
+        typeof hermesLedgerCursor.updatedAt === "string" ? hermesLedgerCursor.updatedAt : null,
+      last_event_at:
+        typeof hermesLastLedgerEvent?.emitted_at === "string"
+          ? hermesLastLedgerEvent.emitted_at
+          : typeof hermesLedgerCursor.lastEventAt === "string"
+            ? hermesLedgerCursor.lastEventAt
+            : null,
+      last_event_type:
+        typeof hermesLastLedgerEvent?.type === "string" ? hermesLastLedgerEvent.type : null,
+    },
     notify: {
       last_notify: lastNotify,
       last_openclaw_triggered_sync: lastOpenclawSync,
@@ -141,12 +167,14 @@ async function collectTrackerDiagnostics({
       every_code_notify_status: everyCodeProbe?.status || "unknown",
       every_code_notify_configured: Boolean(everyCodeProbe?.configured),
       every_code_notify: everyCodeNotify,
-      claude_hook_status: claudeProbe?.status || "unknown",
-      claude_hook_configured: Boolean(claudeProbe?.configured),
+      claude_plugin_status: claudeProbe?.status || "unknown",
+      claude_plugin_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),
+      hermes_plugin_status: hermesProbe?.status || "unknown",
+      hermes_plugin_configured: Boolean(hermesProbe?.configured),
       openclaw_session_plugin_status: openclawSessionProbe?.status || "unknown",
       openclaw_session_plugin_configured: Boolean(openclawSessionProbe?.configured),
       openclaw_session_plugin_linked: Boolean(openclawSessionProbe?.linked),

package/src/lib/doctor.js

@@ -310,7 +310,7 @@ function buildDiagnosticsChecks(diagnostics) {
   const notifyConfigured = Boolean(
     notify.codex_notify_configured ||
     notify.every_code_notify_configured ||
-    notify.claude_hook_configured ||
+    notify.claude_plugin_configured ||
     notify.gemini_hook_configured ||
     notify.opencode_plugin_configured ||
     notify.openclaw_session_plugin_configured,

package/src/lib/hermes-config.js

@@ -0,0 +1,172 @@
+const os = require("node:os");
+const path = require("node:path");
+const fs = require("node:fs/promises");
+const fssync = require("node:fs");
+
+const { ensureDir, writeFileAtomic } = require("./fs");
+
+const HERMES_PLUGIN_ID = "vibeusage";
+const HERMES_PLUGIN_MARKER = "VIBEUSAGE_HERMES_PLUGIN";
+const HERMES_PLUGIN_TEMPLATE_VERSION = 1;
+
+function resolveHermesHome({ home = os.homedir(), env = process.env } = {}) {
+  const explicit = typeof env.HERMES_HOME === "string" ? env.HERMES_HOME.trim() : "";
+  if (explicit) return path.resolve(explicit);
+  return path.join(home, ".hermes");
+}
+
+function resolveHermesPluginPaths({ home = os.homedir(), env = process.env, trackerDir } = {}) {
+  if (!trackerDir) throw new Error("trackerDir is required");
+
+  const hermesHome = resolveHermesHome({ home, env });
+  const pluginDir = path.join(hermesHome, "plugins", HERMES_PLUGIN_ID);
+  return {
+    hermesHome,
+    pluginId: HERMES_PLUGIN_ID,
+    pluginDir,
+    pluginYamlPath: path.join(pluginDir, "plugin.yaml"),
+    pluginInitPath: path.join(pluginDir, "__init__.py"),
+    ledgerPath: path.join(trackerDir, "hermes.usage.jsonl"),
+  };
+}
+
+async function probeHermesPlugin({ home = os.homedir(), env = process.env, trackerDir } = {}) {
+  const paths = resolveHermesPluginPaths({ home, env, trackerDir });
+  const expectedYaml = buildHermesPluginYaml();
+  const expectedInit = buildHermesPluginInit({ ledgerPath: paths.ledgerPath });
+  const hermesHomeExists = await pathExists(paths.hermesHome);
+
+  if (!hermesHomeExists) {
+    return {
+      configured: false,
+      status: "not_installed",
+      detail: "Hermes home not found",
+      initPreviewStatus: "updated",
+      initPreviewDetail: "Will install plugin",
+      ...paths,
+    };
+  }
+
+  const pluginDirExists = await pathExists(paths.pluginDir);
+  if (!pluginDirExists) {
+    return {
+      configured: false,
+      status: "not_installed",
+      detail: "Plugin not installed",
+      initPreviewStatus: "updated",
+      initPreviewDetail: "Will install plugin",
+      ...paths,
+    };
+  }
+
+  const yamlState = await readTextStrict(paths.pluginYamlPath);
+  const initState = await readTextStrict(paths.pluginInitPath);
+  if (yamlState.status === "error" || initState.status === "error") {
+    return {
+      configured: false,
+      status: "unreadable",
+      detail: yamlState.error || initState.error || "Plugin unreadable",
+      ...paths,
+    };
+  }
+  if (yamlState.status === "missing" || initState.status === "missing") {
+    return {
+      configured: false,
+      status: "drifted",
+      detail: "Run vibeusage init to reconcile plugin",
+      ...paths,
+    };
+  }
+
+  const configured = yamlState.value === expectedYaml && initState.value === expectedInit;
+  return {
+    configured,
+    status: configured ? "ready" : "drifted",
+    detail: configured ? "Plugin installed" : "Run vibeusage init to reconcile plugin",
+    ...paths,
+  };
+}
+
+async function installHermesPlugin({ home = os.homedir(), env = process.env, trackerDir } = {}) {
+  const paths = resolveHermesPluginPaths({ home, env, trackerDir });
+  const nextYaml = buildHermesPluginYaml();
+  const nextInit = buildHermesPluginInit({ ledgerPath: paths.ledgerPath });
+  const currentYaml = await fs.readFile(paths.pluginYamlPath, "utf8").catch(() => null);
+  const currentInit = await fs.readFile(paths.pluginInitPath, "utf8").catch(() => null);
+  const changed = currentYaml !== nextYaml || currentInit !== nextInit;
+
+  await ensureDir(paths.pluginDir);
+  await writeFileAtomic(paths.pluginYamlPath, nextYaml);
+  await writeFileAtomic(paths.pluginInitPath, nextInit);
+  return { configured: true, changed, ...paths };
+}
+
+async function removeHermesPlugin({ home = os.homedir(), env = process.env, trackerDir } = {}) {
+  const paths = resolveHermesPluginPaths({ home, env, trackerDir });
+  const hadPluginDir = await pathExists(paths.pluginDir);
+  if (!hadPluginDir) {
+    return { removed: false, skippedReason: "plugin-missing", ...paths };
+  }
+
+  const yamlText = await fs.readFile(paths.pluginYamlPath, "utf8").catch(() => null);
+  const initText = await fs.readFile(paths.pluginInitPath, "utf8").catch(() => null);
+  const markerPresent = hasHermesPluginMarker(yamlText) && hasHermesPluginMarker(initText);
+  if (!markerPresent) {
+    return { removed: false, skippedReason: "unexpected-content", ...paths };
+  }
+
+  await fs.rm(paths.pluginDir, { recursive: true, force: true }).catch(() => {});
+  return { removed: true, ...paths };
+}
+
+function buildHermesPluginYaml() {
+  return readTemplateFile("plugin.yaml");
+}
+
+function buildHermesPluginInit({ ledgerPath }) {
+  const safeLedgerPath = typeof ledgerPath === "string" ? ledgerPath : "";
+  return readTemplateFile("__init__.py").replace("__LEDGER_PATH__", safeLedgerPath);
+}
+
+function hasHermesPluginMarker(text) {
+  return typeof text === "string" && text.includes(HERMES_PLUGIN_MARKER);
+}
+
+async function readTextStrict(filePath) {
+  try {
+    return { status: "ok", value: await fs.readFile(filePath, "utf8"), error: null };
+  } catch (err) {
+    if (err?.code === "ENOENT" || err?.code === "ENOTDIR") {
+      return { status: "missing", value: null, error: null };
+    }
+    return { status: "error", value: null, error: err?.message || String(err) };
+  }
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fs.stat(targetPath);
+    return true;
+  } catch (_err) {
+    return false;
+  }
+}
+
+function readTemplateFile(name) {
+  const templatePath = path.join(__dirname, "..", "templates", "hermes-vibeusage-plugin", name);
+  return fssync.readFileSync(templatePath, "utf8");
+}
+
+module.exports = {
+  HERMES_PLUGIN_ID,
+  HERMES_PLUGIN_MARKER,
+  HERMES_PLUGIN_TEMPLATE_VERSION,
+  resolveHermesHome,
+  resolveHermesPluginPaths,
+  probeHermesPlugin,
+  installHermesPlugin,
+  removeHermesPlugin,
+  buildHermesPluginYaml,
+  buildHermesPluginInit,
+  hasHermesPluginMarker,
+};

package/src/lib/hermes-usage-ledger.js

@@ -0,0 +1,123 @@
+const fs = require("node:fs/promises");
+const path = require("node:path");
+
+const ALLOWED_HERMES_LEDGER_FIELDS = [
+  "version",
+  "type",
+  "source",
+  "session_id",
+  "platform",
+  "model",
+  "provider",
+  "api_mode",
+  "api_call_count",
+  "input_tokens",
+  "output_tokens",
+  "cache_read_tokens",
+  "cache_write_tokens",
+  "reasoning_tokens",
+  "total_tokens",
+  "finish_reason",
+  "emitted_at",
+];
+
+function resolveHermesUsageLedgerPaths({ trackerDir } = {}) {
+  if (!trackerDir) throw new Error("trackerDir is required");
+  return {
+    ledgerPath: path.join(trackerDir, "hermes.usage.jsonl"),
+  };
+}
+
+async function readHermesUsageLedger({ trackerDir, offset = 0 } = {}) {
+  const { ledgerPath } = resolveHermesUsageLedgerPaths({ trackerDir });
+  const buffer = await fs.readFile(ledgerPath).catch((err) => {
+    if (err && err.code === "ENOENT") return null;
+    throw err;
+  });
+
+  if (!buffer) {
+    return { events: [], endOffset: 0 };
+  }
+
+  const startOffset = Math.max(0, Number(offset || 0));
+  const fileEndOffset = buffer.length;
+  if (startOffset >= fileEndOffset) {
+    return { events: [], endOffset: fileEndOffset };
+  }
+
+  const newlineIndex = buffer.lastIndexOf(0x0a);
+  if (newlineIndex < startOffset) {
+    return { events: [], endOffset: startOffset };
+  }
+
+  const endOffset = newlineIndex + 1;
+  const raw = buffer.subarray(startOffset, endOffset).toString("utf8");
+  const events = raw
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch (_err) {
+        return null;
+      }
+    })
+    .filter(Boolean)
+    .map(stripToAllowedHermesFields)
+    .filter(isHermesLedgerEvent);
+
+  return { events, endOffset };
+}
+
+async function readLastHermesUsageEvent({ trackerDir } = {}) {
+  const { ledgerPath } = resolveHermesUsageLedgerPaths({ trackerDir });
+  const text = await fs.readFile(ledgerPath, "utf8").catch((err) => {
+    if (err && err.code === "ENOENT") return null;
+    throw err;
+  });
+  if (!text) return null;
+
+  const lines = text.split(/\r?\n/);
+  for (let idx = lines.length - 1; idx >= 0; idx -= 1) {
+    const line = String(lines[idx] || "").trim();
+    if (!line) continue;
+    try {
+      const parsed = stripToAllowedHermesFields(JSON.parse(line));
+      if (isHermesLedgerEvent(parsed)) return parsed;
+    } catch (_err) {
+      // ignore malformed line
+    }
+  }
+  return null;
+}
+
+function stripToAllowedHermesFields(event) {
+  const out = {};
+  for (const field of ALLOWED_HERMES_LEDGER_FIELDS) {
+    if (!Object.prototype.hasOwnProperty.call(event, field)) continue;
+    out[field] = event[field];
+  }
+  return out;
+}
+
+function isHermesLedgerEvent(event) {
+  if (!event || typeof event !== "object") return false;
+  if (normalizeString(event.source) !== "hermes") return false;
+  const type = normalizeString(event.type);
+  if (!type || !["session_start", "usage", "session_end"].includes(type)) return false;
+  return true;
+}
+
+function normalizeString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+module.exports = {
+  ALLOWED_HERMES_LEDGER_FIELDS,
+  resolveHermesUsageLedgerPaths,
+  readHermesUsageLedger,
+  readLastHermesUsageEvent,
+};

package/src/lib/integrations/claude.js

@@ -1,81 +1,129 @@
-const { probeClaudeHook, upsertClaudeHook, removeClaudeHook } = require("../claude-config");
+const { probeClaudeHook, removeClaudeHook } = require("../claude-config");
+const {
+  installClaudePlugin,
+  probeClaudePluginState,
+  removeClaudePluginConfig,
+} = require("../claude-plugin");
 const { isDir, isFile } = require("./utils");
 
 module.exports = {
   name: "claude",
   summaryLabel: "Claude",
-  statusLabel: "Claude hooks",
+  statusLabel: "Claude plugin",
   async probe(ctx) {
     const hasConfigDir = await isDir(ctx.claude.configDir);
     if (!hasConfigDir) {
       return baseProbe(this, { status: "not_installed", detail: "Config not found" });
     }
 
+    const pluginState = await probeClaudePluginState({
+      home: ctx.home,
+      trackerDir: ctx.trackerPaths.trackerDir,
+    });
+    if (pluginState.unreadable) {
+      return baseProbe(this, { status: "unreadable", detail: pluginState.detail });
+    }
+    if (pluginState.configured) {
+      return baseProbe(this, {
+        status: "ready",
+        detail: "Plugin installed",
+        configured: true,
+        pluginState,
+      });
+    }
+
     const hasSettings = await isFile(ctx.claude.settingsPath);
     if (!hasSettings) {
-      return baseProbe(this, { status: "drifted", detail: "Run vibeusage init to install hooks" });
+      return baseProbe(this, {
+        status: pluginState.pluginFilesReady || pluginState.marketplaceDeclared ? "drifted" : "not_installed",
+        detail:
+          pluginState.pluginFilesReady || pluginState.marketplaceDeclared
+            ? "Run vibeusage init to reconcile plugin"
+            : "Run vibeusage init to install plugin",
+        pluginState,
+      });
     }
 
     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
+    const status = hookState.anyPresent
       ? "unsupported_legacy"
-      : "drifted";
+      : pluginState.installed || pluginState.marketplaceDeclared || pluginState.pluginFilesReady
+        ? "drifted"
+        : "not_installed";
     return baseProbe(this, {
       status,
       detail:
         status === "unsupported_legacy"
           ? "Legacy hook config detected; run vibeusage init"
-          : "Run vibeusage init to reconcile hooks",
+          : status === "drifted"
+            ? "Run vibeusage init to reconcile plugin"
+            : "Run vibeusage init to install plugin",
       hookState,
+      pluginState,
     });
   },
   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,
+    const result = await installClaudePlugin({
+      home: ctx.home,
+      trackerDir: ctx.trackerPaths.trackerDir,
+      notifyPath: ctx.notifyPath,
+      env: ctx.env,
     });
+    if (result.skippedReason === "claude-cli-missing") {
+      return action(this, "skipped", false, "Claude CLI not found", {
+        skippedReason: result.skippedReason,
+      });
+    }
+    if (!result.configured) {
+      return action(this, "skipped", false, result.error || "Claude plugin install incomplete", {
+        skippedReason: result.skippedReason || "claude-plugin-install-incomplete",
+      });
+    }
+    if (result.configured && (await isFile(ctx.claude.settingsPath))) {
+      await removeClaudeHook({
+        settingsPath: ctx.claude.settingsPath,
+        hookCommand: ctx.claude.hookCommand,
+      }).catch(() => {});
+    }
     return action(
       this,
       result.changed ? "installed" : "set",
       Boolean(result.changed),
-      result.changed ? "Hooks installed" : "Hooks already installed",
+      result.changed ? "Plugin installed" : "Plugin 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,
+    const result = await removeClaudePluginConfig({
+      home: ctx.home,
+      trackerDir: ctx.trackerPaths.trackerDir,
+      env: ctx.env,
     });
+    if (await isFile(ctx.claude.settingsPath)) {
+      await removeClaudeHook({
+        settingsPath: ctx.claude.settingsPath,
+        hookCommand: ctx.claude.hookCommand,
+      }).catch(() => {});
+    }
+    if (result.skippedReason === "claude-cli-missing") {
+      return action(this, "skipped", false, "Claude CLI not found", {
+        skippedReason: result.skippedReason,
+      });
+    }
     if (result.removed) {
-      return action(this, "removed", true, ctx.claude.settingsPath);
+      return action(this, "removed", true, result.pluginRef || "Claude plugin removed");
     }
-    if (result.skippedReason === "hook-missing") {
+    if (result.skippedReason === "plugin-missing") {
       return action(this, "unchanged", false, "no change", {
         skippedReason: result.skippedReason,
       });
     }
-    return action(this, "skipped", false, "settings.json not found");
+    return action(this, "skipped", false, "Claude plugin not found");
   },
   renderStatusValue(probe) {
     if (probe.status === "ready") return "set";

package/src/lib/integrations/context.js

@@ -9,6 +9,7 @@ const {
 } = require("../gemini-config");
 const { resolveOpencodeConfigDir } = require("../opencode-config");
 const { resolveOpenclawSessionPluginPaths } = require("../openclaw-session-plugin");
+const { resolveHermesPluginPaths } = require("../hermes-config");
 const { resolveTrackerPaths } = require("../tracker-paths");
 
 async function createIntegrationContext({
@@ -57,6 +58,11 @@ async function createIntegrationContext({
     opencode: {
       configDir: opencodeConfigDir,
     },
+    hermes: resolveHermesPluginPaths({
+      home,
+      env,
+      trackerDir: resolvedTrackerPaths.trackerDir,
+    }),
     openclawSession: resolveOpenclawSessionPluginPaths({
       home,
       trackerDir: resolvedTrackerPaths.trackerDir,

package/src/lib/integrations/hermes.js

@@ -0,0 +1,96 @@
+const { isDir } = require("./utils");
+const { probeHermesPlugin, installHermesPlugin, removeHermesPlugin } = require("../hermes-config");
+
+module.exports = {
+  name: "hermes",
+  summaryLabel: "Hermes Plugin",
+  statusLabel: "Hermes plugin",
+  async probe(ctx) {
+    const hermesHomeExists = await isDir(ctx.hermes.hermesHome);
+    if (!hermesHomeExists) {
+      return baseProbe(this, {
+        status: "not_installed",
+        detail: "Hermes home not found",
+        initPreviewStatus: "skipped",
+        initPreviewDetail: "Hermes not detected",
+      });
+    }
+
+    const state = await probeHermesPlugin({
+      home: ctx.home,
+      env: ctx.env,
+      trackerDir: ctx.trackerPaths.trackerDir,
+    });
+    return baseProbe(this, state);
+  },
+  async install(ctx) {
+    if (!(await isDir(ctx.hermes.hermesHome))) {
+      return action(this, "skipped", false, "Hermes home not found");
+    }
+    const result = await installHermesPlugin({
+      home: ctx.home,
+      env: ctx.env,
+      trackerDir: ctx.trackerPaths.trackerDir,
+    });
+    return action(
+      this,
+      result.changed ? "installed" : "set",
+      Boolean(result.changed),
+      result.changed ? "Plugin installed" : "Plugin already installed",
+    );
+  },
+  async uninstall(ctx) {
+    if (!(await isDir(ctx.hermes.hermesHome))) {
+      return action(this, "skipped", false, "Hermes home not found", {
+        skippedReason: "hermes-home-missing",
+      });
+    }
+    const result = await removeHermesPlugin({
+      home: ctx.home,
+      env: ctx.env,
+      trackerDir: ctx.trackerPaths.trackerDir,
+    });
+    if (result.removed) {
+      return action(this, "removed", true, result.pluginDir || ctx.hermes.pluginDir);
+    }
+    if (result.skippedReason === "plugin-missing") {
+      return action(this, "unchanged", false, "no change", {
+        skippedReason: result.skippedReason,
+      });
+    }
+    if (result.skippedReason === "unexpected-content") {
+      return action(this, "skipped", false, "unexpected content", {
+        skippedReason: result.skippedReason,
+      });
+    }
+    return action(this, "skipped", false, "Hermes home not found", {
+      skippedReason: result.skippedReason || "hermes-home-missing",
+    });
+  },
+  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/index.js

@@ -4,6 +4,7 @@ const everyCode = require("./every-code");
 const claude = require("./claude");
 const gemini = require("./gemini");
 const opencode = require("./opencode");
+const hermes = require("./hermes");
 const openclawSession = require("./openclaw-session");
 
 const INTEGRATIONS = [
@@ -12,6 +13,7 @@ const INTEGRATIONS = [
   claude,
   gemini,
   opencode,
+  hermes,
   openclawSession,
 ];