failproofai 1.0.5 → 1.0.6-beta.1

package/src/hooks/handler.ts

@@ -102,6 +102,21 @@ export interface HookEventOutcome {
   exitCode: number;
   stdout: string;
   stderr: string;
+  /**
+   * Structured policy metadata for in-process adapters. Existing shell-hook
+   * callers intentionally ignore this and keep consuming stdout/stderr.
+   */
+  evaluation?: HookEvaluationSummary;
+}
+
+export interface HookEvaluationSummary {
+  decision: "allow" | "deny" | "instruct";
+  policyName: string | null;
+  policyNames: string[];
+  reason: string | null;
+  matchedPolicies: string[];
+  durationMs: number;
+  toolName: string | null;
 }
 
 export interface EvaluateHookEventOptions {
@@ -757,7 +772,20 @@ export async function evaluateHookEvent(
       }
     }
 
-    return { exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr };
+    return {
+      exitCode: result.exitCode,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      evaluation: {
+        decision: result.decision,
+        policyName: result.policyName,
+        policyNames: result.policyNames ?? (result.policyName ? [result.policyName] : []),
+        reason: result.reason,
+        matchedPolicies,
+        durationMs,
+        toolName: (parsed.tool_name as string) ?? null,
+      },
+    };
   } finally {
     if (opts?.awaitTelemetryFlush ?? true) {
       // Await any un-awaited (`void trackHookEvent(...)`) events fired during

package/src/hooks/integrations.ts

@@ -7,7 +7,17 @@
  * is agent-agnostic — only install/uninstall plumbing varies.
  */
 import { execSync } from "node:child_process";
-import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from "node:fs";
+import {
+  cpSync,
+  readFileSync,
+  writeFileSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  renameSync,
+  rmSync,
+  unlinkSync,
+} from "node:fs";
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
@@ -112,6 +122,12 @@ function binaryExists(name: string): boolean {
 export interface Integration {
   id: IntegrationType;
   displayName: string;
+  /**
+   * This integration has no in-process/CLI fallback and cannot evaluate policy
+   * unless failproofaid answers an end-to-end probe. Installation must stop
+   * before writing any hook or plugin when the daemon is unavailable.
+   */
+  requiresHealthyDaemon?: boolean;
   /** Settings scopes this integration supports (e.g. claude: user/project/local; codex: user/project). */
   scopes: readonly HookScope[];
   /** Hook events this integration fires (Claude: PascalCase, Codex: snake_case stored as Pascal in settings). */
@@ -135,6 +151,9 @@ export interface Integration {
   /** Read the raw settings/hooks file (returns {} when missing). */
   readSettings(settingsPath: string): Record<string, unknown>;
 
+  /** Install integration-owned files before enabling them in settings. */
+  prepareInstall?(settingsPath: string): void;
+
   /** Write the settings/hooks file. */
   writeSettings(settingsPath: string, settings: Record<string, unknown>): void;
 
@@ -1363,14 +1382,14 @@ function makePiProjectRelativeEntry(extPath: string): string {
   // works for the local user.
   return extResolved;
 }
-// ── Hermes (hermes-agent) — live hooks (Pillar 1) ────────────────────────────
+// ── Hermes (hermes-agent) — native plugin (Pillar 1) ────────────────────────
 //
-// External-command CLI like codex/cursor, but its config is YAML
-// (`~/.hermes/config.yaml`) under a `hooks:` map, so the I/O layer uses the yaml
-// Document API (comment-preserving). Flat per-event arrays like cursor:
-// `hooks: { pre_tool_call: [ { command, timeout, <marker> } ], … }`. Hermes
-// reads a `{"decision":"block",…}` JSON response on stdout (see
-// policy-evaluator.ts); exit codes are ignored. User-scope only.
+// Hermes loads trusted Python plugins from `<HERMES_HOME>/plugins/<name>/`.
+// The shipped plugin registers Hermes-native hooks and talks directly to the
+// local failproofaid socket, avoiding a fresh CLI process per event. Config is
+// YAML and profile-scoped; install copies the plugin into every profile and
+// adds `failproofai` to `plugins.enabled`. Legacy shell-hook entries are removed
+// during migration so one tool call is never evaluated twice.
 
 /** One hook entry as stored under a `hooks:` event key in config.yaml. */
 interface HermesHookEntry {
@@ -1379,9 +1398,204 @@ interface HermesHookEntry {
   [key: string]: unknown;
 }
 
+interface HermesPluginsConfig {
+  enabled?: unknown[];
+  disabled?: unknown[];
+  entries?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+const HERMES_PLUGIN_ID = "failproofai";
+const HERMES_PLUGIN_MARKER = ".failproofai-managed";
+const HERMES_PLUGIN_FILES = ["plugin.yaml", "__init__.py", "client.py", "ledger.py"] as const;
+
+function getHermesPluginSourcePath(): string {
+  const fromEnv = process.env.FAILPROOFAI_PACKAGE_ROOT;
+  if (fromEnv) return resolve(fromEnv, "hermes-plugin");
+  return resolve(fileURLToPath(import.meta.url), "..", "..", "..", "hermes-plugin");
+}
+
+export function hermesPluginPathForSettings(settingsPath: string): string {
+  return resolve(dirname(settingsPath), "plugins", HERMES_PLUGIN_ID);
+}
+
+function hasManagedHermesPlugin(settingsPath: string): boolean {
+  const pluginPath = hermesPluginPathForSettings(settingsPath);
+  try {
+    if (lstatSync(pluginPath).isSymbolicLink()) return false;
+    if (!existsSync(resolve(pluginPath, HERMES_PLUGIN_MARKER))) return false;
+    return HERMES_PLUGIN_FILES.every((file) => existsSync(resolve(pluginPath, file)));
+  } catch {
+    return false;
+  }
+}
+
+function hasHermesPluginMarker(settingsPath: string): boolean {
+  const pluginPath = hermesPluginPathForSettings(settingsPath);
+  try {
+    return !lstatSync(pluginPath).isSymbolicLink() && existsSync(resolve(pluginPath, HERMES_PLUGIN_MARKER));
+  } catch {
+    return false;
+  }
+}
+
+function installHermesPlugin(settingsPath: string): void {
+  const source = getHermesPluginSourcePath();
+  for (const file of HERMES_PLUGIN_FILES) {
+    if (!existsSync(resolve(source, file))) {
+      throw new Error(`Hermes plugin asset is missing from the failproofai package: ${file}`);
+    }
+  }
+
+  const destination = hermesPluginPathForSettings(settingsPath);
+  if (existsSync(destination)) {
+    if (lstatSync(destination).isSymbolicLink() || !existsSync(resolve(destination, HERMES_PLUGIN_MARKER))) {
+      throw new Error(
+        `Refusing to overwrite an unmanaged Hermes plugin at ${destination}. ` +
+          `Move it aside or install FailproofAI under a different Hermes profile.`,
+      );
+    }
+  }
+
+  mkdirSync(dirname(destination), { recursive: true });
+  const suffix = `${process.pid}-${Date.now()}`;
+  const temporary = `${destination}.install-${suffix}`;
+  const backup = `${destination}.backup-${suffix}`;
+  let movedExisting = false;
+  try {
+    mkdirSync(temporary, { recursive: true });
+    for (const file of HERMES_PLUGIN_FILES) {
+      cpSync(resolve(source, file), resolve(temporary, file));
+    }
+    writeFileSync(
+      resolve(temporary, HERMES_PLUGIN_MARKER),
+      "Managed by failproofai. Remove with `failproofai policies --uninstall --cli hermes`.\n",
+      { encoding: "utf8", mode: 0o600 },
+    );
+    if (existsSync(destination)) {
+      renameSync(destination, backup);
+      movedExisting = true;
+    }
+    renameSync(temporary, destination);
+    if (movedExisting) rmSync(backup, { recursive: true, force: true });
+  } catch (err) {
+    rmSync(temporary, { recursive: true, force: true });
+    if (movedExisting && !existsSync(destination) && existsSync(backup)) {
+      renameSync(backup, destination);
+    }
+    throw err;
+  }
+}
+
+function removeManagedHermesPlugin(settingsPath: string): boolean {
+  const pluginPath = hermesPluginPathForSettings(settingsPath);
+  // The marker is the ownership boundary. Remove even an incomplete managed
+  // install so an interrupted copy can always be repaired or uninstalled.
+  if (!hasHermesPluginMarker(settingsPath)) return false;
+  rmSync(pluginPath, { recursive: true, force: true });
+  return true;
+}
+
+function removeLegacyHermesHooks(doc: Document): number {
+  const js = (doc.toJS() ?? {}) as { hooks?: Record<string, HermesHookEntry[]> };
+  const hooks = js.hooks;
+  let removed = 0;
+  if (hooks && typeof hooks === "object") {
+    for (const eventType of Object.keys(hooks)) {
+      const entries = hooks[eventType];
+      if (!Array.isArray(entries)) continue;
+      const before = entries.length;
+      const filtered = entries.filter((hook) => !isMarkedHook(hook));
+      removed += before - filtered.length;
+      if (filtered.length === 0) delete hooks[eventType];
+      else hooks[eventType] = filtered;
+    }
+    if (Object.keys(hooks).length === 0) {
+      doc.delete("hooks");
+      // Older FailproofAI installs set this broad Hermes switch so headless
+      // shell hooks could run. It is safe to remove only when no operator hook
+      // remains that may rely on it.
+      if (removed > 0) doc.delete("hooks_auto_accept");
+    } else {
+      doc.set("hooks", hooks);
+    }
+  }
+  return removed;
+}
+
+function hermesConfigState(settingsPath: string): {
+  pluginEnabled: boolean;
+  legacyShellHookPresent: boolean;
+} {
+  if (!existsSync(settingsPath)) {
+    return { pluginEnabled: false, legacyShellHookPresent: false };
+  }
+  const doc = readYamlDoc(settingsPath);
+  const js = (doc.toJS() ?? {}) as {
+    hooks?: Record<string, HermesHookEntry[]>;
+    plugins?: HermesPluginsConfig;
+  };
+  const enabled = js.plugins?.enabled;
+  const legacyShellHookPresent =
+    !!js.hooks &&
+    typeof js.hooks === "object" &&
+    Object.values(js.hooks).some(
+      (entries) => Array.isArray(entries) && entries.some((entry) => isMarkedHook(entry)),
+    );
+  return {
+    pluginEnabled: Array.isArray(enabled) && enabled.includes(HERMES_PLUGIN_ID),
+    legacyShellHookPresent,
+  };
+}
+
+export interface HermesProfileHealth {
+  name: string;
+  home: string;
+  settingsPath: string;
+  pluginInstalled: boolean;
+  pluginEnabled: boolean;
+  legacyShellHookPresent: boolean;
+  healthy: boolean;
+}
+
+/** Read-only, per-profile Hermes installation health for setup/status surfaces. */
+export function hermesProfileHealth(): HermesProfileHealth[] {
+  return listHermesProfiles().map((profile) => {
+    const settingsPath = resolve(profile.home, "config.yaml");
+    const config = hermesConfigState(settingsPath);
+    const pluginInstalled = hasManagedHermesPlugin(settingsPath);
+    return {
+      name: profile.name,
+      home: profile.home,
+      settingsPath,
+      pluginInstalled,
+      pluginEnabled: config.pluginEnabled,
+      legacyShellHookPresent: config.legacyShellHookPresent,
+      healthy: pluginInstalled && config.pluginEnabled && !config.legacyShellHookPresent,
+    };
+  });
+}
+
+/** Compact rows for the machine-status display; absent Hermes homes produce no noise. */
+export function hermesProfileStatusRows(): Array<[string, string]> {
+  return hermesProfileHealth()
+    .filter((profile) => existsSync(profile.home))
+    .map((profile) => {
+      const problems: string[] = [];
+      if (!profile.pluginInstalled) problems.push("plugin files missing or incomplete");
+      if (!profile.pluginEnabled) problems.push("plugin not enabled");
+      if (profile.legacyShellHookPresent) problems.push("legacy shell hook also present");
+      return [
+        "hermes/" + profile.name,
+        problems.length === 0 ? "native plugin enabled" : "UNHEALTHY — " + problems.join("; "),
+      ];
+    });
+}
+
 export const hermes: Integration = {
   id: "hermes",
   displayName: "Hermes",
+  requiresHealthyDaemon: true,
   scopes: HERMES_HOOK_SCOPES,
   eventTypes: HERMES_HOOK_EVENT_TYPES,
 
@@ -1410,75 +1624,66 @@ export const hermes: Integration = {
     writeYamlDoc(settingsPath, settings as unknown as Document);
   },
 
-  buildHookEntry(binaryPath, eventType, scope) {
-    // No matcher → fires for ALL tools / all platforms (slack/telegram/cli/cron)
-    // and internal subagents. `timeout` is in seconds; Hermes runs the command
-    // via shlex.split (shell=false).
-    const command =
-      scope === "project"
-        ? `npx -y failproofai --hook ${eventType} --cli hermes`
-        : `"${binaryPath}" --hook ${eventType} --cli hermes`;
+  prepareInstall(settingsPath) {
+    installHermesPlugin(settingsPath);
+  },
+
+  buildHookEntry(_binaryPath, _eventType, _scope) {
+    // Native plugins are package-level registrations. This sentinel preserves
+    // the common Integration interface; writeHookEntries does the real work.
     return {
-      command,
-      timeout: 30,
       [FAILPROOFAI_HOOK_MARKER]: true,
+      _hermesPluginPath: getHermesPluginSourcePath(),
     };
   },
 
   isFailproofaiHook: isMarkedHook,
 
-  writeHookEntries(settings, binaryPath, scope) {
+  writeHookEntries(settings) {
     const doc = settings as unknown as Document;
-    // Read the current hooks map as plain JS, then re-set ONLY the `hooks` key —
-    // preserving comments on every other part of config.yaml.
-    const js = (doc.toJS() ?? {}) as { hooks?: Record<string, HermesHookEntry[]> };
-    const hooks: Record<string, HermesHookEntry[]> =
-      js.hooks && typeof js.hooks === "object" ? js.hooks : {};
-
-    for (const eventType of HERMES_HOOK_EVENT_TYPES) {
-      const entry = this.buildHookEntry(binaryPath, eventType, scope) as unknown as HermesHookEntry;
-      const arr = Array.isArray(hooks[eventType]) ? hooks[eventType] : [];
-      const idx = arr.findIndex((h) => isMarkedHook(h));
-      if (idx >= 0) arr[idx] = entry;
-      else arr.push(entry);
-      hooks[eventType] = arr;
+    // A native plugin and the legacy shell bridge running together would
+    // evaluate every event twice. Remove only failproofai-owned shell entries;
+    // unrelated operator hooks remain intact.
+    removeLegacyHermesHooks(doc);
+
+    const js = (doc.toJS() ?? {}) as { plugins?: HermesPluginsConfig };
+    const plugins: HermesPluginsConfig =
+      js.plugins && typeof js.plugins === "object" ? js.plugins : {};
+    const enabled = Array.isArray(plugins.enabled) ? [...plugins.enabled] : [];
+    if (!enabled.includes(HERMES_PLUGIN_ID)) enabled.push(HERMES_PLUGIN_ID);
+    plugins.enabled = enabled;
+    if (Array.isArray(plugins.disabled)) {
+      plugins.disabled = plugins.disabled.filter((name) => name !== HERMES_PLUGIN_ID);
+      if (plugins.disabled.length === 0) delete plugins.disabled;
     }
-    doc.set("hooks", hooks);
-    // The headless gateway has no TTY to answer Hermes's first-use hook-consent
-    // prompt, so auto-accept declared hooks. Tradeoff: also auto-accepts any
-    // other hook the operator adds; a targeted `shell-hooks-allowlist.json`
-    // pre-seed is a future refinement.
-    doc.set("hooks_auto_accept", true);
+    doc.set("plugins", plugins);
   },
 
   removeHooksFromFile(settingsPath) {
-    if (!existsSync(settingsPath)) return 0;
     const doc = readYamlDoc(settingsPath);
-    const js = (doc.toJS() ?? {}) as { hooks?: Record<string, HermesHookEntry[]> };
-    const hooks = js.hooks;
-
-    let removed = 0;
-    if (hooks && typeof hooks === "object") {
-      for (const eventType of Object.keys(hooks)) {
-        const entries = hooks[eventType];
-        if (!Array.isArray(entries)) continue;
-        const before = entries.length;
-        const filtered = entries.filter((h) => !isMarkedHook(h));
-        removed += before - filtered.length;
-        if (filtered.length === 0) delete hooks[eventType];
-        else hooks[eventType] = filtered;
+    let removed = removeLegacyHermesHooks(doc);
+    const js = (doc.toJS() ?? {}) as { plugins?: HermesPluginsConfig };
+    const plugins = js.plugins;
+    let configChanged = removed > 0;
+    if (plugins && typeof plugins === "object") {
+      if (Array.isArray(plugins.enabled)) {
+        const before = plugins.enabled.length;
+        plugins.enabled = plugins.enabled.filter((name) => name !== HERMES_PLUGIN_ID);
+        if (plugins.enabled.length !== before) {
+          removed += 1;
+          configChanged = true;
+        }
+        if (plugins.enabled.length === 0) delete plugins.enabled;
       }
-      if (removed > 0) {
-        if (Object.keys(hooks).length === 0) doc.delete("hooks");
-        else doc.set("hooks", hooks);
+      if (plugins.entries && HERMES_PLUGIN_ID in plugins.entries) {
+        delete plugins.entries[HERMES_PLUGIN_ID];
+        configChanged = true;
       }
+      if (Object.keys(plugins).length === 0) doc.delete("plugins");
+      else doc.set("plugins", plugins);
     }
-
-    // Always drop our headless-consent flag on uninstall — even if the hooks were
-    // already removed manually — so it can't silently auto-accept future operator
-    // hooks. `doc.delete` returns true iff the key was present.
-    const droppedAutoAccept = doc.delete("hooks_auto_accept");
-    if (removed > 0 || droppedAutoAccept) writeYamlDoc(settingsPath, doc);
+    if (configChanged) writeYamlDoc(settingsPath, doc);
+    if (removeManagedHermesPlugin(settingsPath)) removed += 1;
     return removed;
   },
 
@@ -1497,15 +1702,9 @@ export const hermes: Integration = {
 };
 
 function hermesConfigHasHooks(settingsPath: string): boolean {
-  if (!existsSync(settingsPath)) return false;
   try {
-    const doc = readYamlDoc(settingsPath);
-    const js = (doc.toJS() ?? {}) as { hooks?: Record<string, HermesHookEntry[]> };
-    const hooks = js.hooks;
-    if (!hooks || typeof hooks !== "object") return false;
-    for (const entries of Object.values(hooks)) {
-      if (Array.isArray(entries) && entries.some((h) => isMarkedHook(h))) return true;
-    }
+    const state = hermesConfigState(settingsPath);
+    return state.pluginEnabled && hasManagedHermesPlugin(settingsPath) && !state.legacyShellHookPresent;
   } catch {
     // Corrupt config — treat as not installed.
   }
@@ -1523,10 +1722,9 @@ function hermesConfigHasHooks(settingsPath: string): boolean {
  * warning.
  */
 export function unhookedHermesProfiles(): string[] {
-  return listHermesProfiles()
-    .filter((p) => existsSync(p.home))
-    .filter((p) => !hermesConfigHasHooks(resolve(p.home, "config.yaml")))
-    .map((p) => p.name);
+  return hermesProfileHealth()
+    .filter((profile) => existsSync(profile.home) && !profile.healthy)
+    .map((profile) => profile.name);
 }
 
 // ── OpenClaw integration ────────────────────────────────────────────────────

package/src/hooks/manager.ts

@@ -29,6 +29,7 @@ import { CORE_SOURCE, addPack, setPackPolicyEnabled } from "./pack-store";
 import type { ResolvedPack } from "./pack-manifest";
 import { hasInstalledPacks, readInstalledPacks } from "./pack-manifest";
 import { packPolicyParamKey } from "./policy-evaluator";
+import { probeDaemonEndToEnd } from "./daemon-service";
 import {
   chip,
   note,
@@ -446,9 +447,13 @@ async function installHooksImpl(
   // the user for multi-CLI selection before reaching here when --cli is omitted.
   const selectedClis: IntegrationType[] = cli && cli.length > 0 ? [...new Set(cli)] : ["claude"];
 
+  const selectedIntegrations = selectedClis.map((cliId) => ({
+    cliId,
+    integration: getIntegration(cliId),
+  }));
+
   // Per-CLI scope validation: Codex doesn't have a "local" scope.
-  for (const cliId of selectedClis) {
-    const integration = getIntegration(cliId);
+  for (const { cliId, integration } of selectedIntegrations) {
     if (!integration.scopes.includes(scope)) {
       try {
         await trackHookEvent(getInstanceId(), "scope_validation_failed", {
@@ -464,6 +469,23 @@ async function installHooksImpl(
     }
   }
 
+  // Daemon-only native integrations fail closed when their evaluator cannot be
+  // reached. Never enable one until a real policy request succeeds; otherwise
+  // a direct `policies --install` can lock every tool call. Shell-hook and CLI-
+  // backed integrations retain their local evaluator fallback and therefore do
+  // not opt into this requirement.
+  const daemonRequiredBy = selectedIntegrations
+    .map(({ integration }) => integration)
+    .filter((integration) => integration.requiresHealthyDaemon);
+  if (daemonRequiredBy.length > 0 && !(await probeDaemonEndToEnd())) {
+    const names = daemonRequiredBy.map((integration) => integration.displayName).join(", ");
+    const verb = daemonRequiredBy.length === 1 ? "requires" : "require";
+    throw new CliError(
+      `${names} ${verb} a healthy failproofaid daemon before FailproofAI enforcement can be enabled.\n` +
+        "Run `failproofai config` to install and configure the daemon, then retry.",
+    );
+  }
+
   const binaryPath = resolveFailproofaiBinary();
 
   // Capture existing config before overwriting (used for telemetry diff)
@@ -672,6 +694,7 @@ async function installHooksImpl(
     const settingsPaths = settingsPathsFor(integration, scope, cwd);
     try {
       for (const settingsPath of settingsPaths) {
+        integration.prepareInstall?.(settingsPath);
         const settings = integration.readSettings(settingsPath);
         integration.writeHookEntries(settings, binaryPath, scope);
         integration.writeSettings(settingsPath, settings);
@@ -738,10 +761,17 @@ async function installHooksImpl(
 
   for (const { cli: cliId, path } of writtenSettingsPaths) {
     const integration = getIntegration(cliId);
-    console.log(
-      `Failproof AI hooks installed for ${integration.displayName} ` +
-        `(${integration.eventTypes.length} event types, scope: ${scope}).`
-    );
+    if (cliId === "hermes") {
+      console.log(
+        `Failproof AI native plugin installed for ${integration.displayName} ` +
+          `(8 registered hooks, scope: ${scope}).`
+      );
+    } else {
+      console.log(
+        `Failproof AI hooks installed for ${integration.displayName} ` +
+          `(${integration.eventTypes.length} event types, scope: ${scope}).`
+      );
+    }
     console.log(`Settings: ${path}`);
   }
   if (scope === "project") {
@@ -876,7 +906,11 @@ export async function removeHooks(policyNames?: string[], scope: HookScope | "al
     for (const s of scopesToRemove) {
       // Usually one path; Hermes returns one per profile.
       const settingsPaths = settingsPathsFor(integration, s, cwd);
-      const existing = settingsPaths.filter((p) => existsSync(p));
+      // A Hermes install copies its managed plugin before updating config.yaml.
+      // If the config write is interrupted, uninstall must still call the
+      // integration so it can remove that orphaned managed directory.
+      const existing =
+        cliId === "hermes" ? settingsPaths : settingsPaths.filter((p) => existsSync(p));
 
       if (existing.length === 0) {
         if (scope !== "all" && selectedClis.length === 1) {

package/src/hooks/types.ts

@@ -113,13 +113,13 @@ export const HERMES_TOOL_INPUT_MAP: Record<string, Record<string, string>> = {
   Edit: { path: "file_path" },
 };
 
-// Hermes live-hook (Pillar 1) events + scopes. Hermes fires these snake_case
-// events with a JSON payload on stdin; the command we install runs
-// `failproofai --hook <event> --cli hermes`. Config is USER-scope only
-// (`~/.hermes/config.yaml`; Hermes has no project scope). `pre_tool_call` is the
-// core deny point — it fires for tool calls from every source
-// (slack/telegram/cli/cron) and internal subagents, so a single install
-// intercepts all platforms.
+// Hermes live-hook (Pillar 1) events + scopes. The native Python plugin sends
+// these events to failproofaid's warm worker. It also handles `pre_llm_call`,
+// `on_session_reset`, and `on_session_finalize` locally for instruction context
+// and ledger cleanup, so those do not need canonical policy-event mappings.
+// Config is USER-scope only (`~/.hermes/config.yaml`; Hermes has no project
+// scope). `pre_tool_call` is the core gate and fires for tool calls from every
+// source (Slack/Telegram/CLI/cron) and internal subagents.
 //
 // `pre_verify` IS a turn-end gate — the earlier claim here that Hermes has none
 // was wrong. We deliberately do NOT install it (product decision, 2026-07-29);
@@ -143,7 +143,7 @@ export const HERMES_TOOL_INPUT_MAP: Record<string, Record<string, string>> = {
 //   2. Capped at 3 nudges per turn (`DEFAULT_MAX_VERIFY_NUDGES`,
 //      `agent/verify_hooks.py:21`), operator-overridable; resets each turn.
 //   3. It landed upstream ~2026-06-30. Older Hermes fails the key against
-//      VALID_HOOKS and warn-and-skips it SILENTLY (`agent/shell_hooks.py:325`).
+//      VALID_HOOKS and warn-and-skips it silently.
 //
 // Until it is installed, `HERMES_EVENT_MAP` emits no `Stop` and those 5
 // builtins remain inapplicable on Hermes.

package/src/hooks/worker-server.ts

@@ -192,6 +192,7 @@ function handleConnection(socket: Socket, shutdown: () => void): void {
               exitCode: result.exitCode,
               stdout: result.stdout,
               stderr: result.stderr,
+              evaluation: result.evaluation,
             }),
           );
         } catch (err) {

package/.next/standalone/.next/server/chunks/[externals]__157pf8j._.js

@@ -1,3 +0,0 @@
-module.exports=[78500,(e,o,r)=>{o.exports=e.x("node:async_hooks",()=>require("node:async_hooks"))},2157,(e,o,r)=>{o.exports=e.x("node:fs",()=>require("node:fs"))},12714,(e,o,r)=>{o.exports=e.x("node:fs/promises",()=>require("node:fs/promises"))},50227,(e,o,r)=>{o.exports=e.x("node:path",()=>require("node:path"))},1457,(e,o,r)=>{o.exports=e.x("node:readline",()=>require("node:readline"))},12057,(e,o,r)=>{o.exports=e.x("node:util",()=>require("node:util"))},27028,(e,o,r)=>{o.exports=e.x("node:zlib",()=>require("node:zlib"))},14747,(e,o,r)=>{o.exports=e.x("path",()=>require("path"))}];
-
-//# sourceMappingURL=%5Bexternals%5D__157pf8j._.js.map

package/.next/standalone/.next/server/chunks/ssr/[root-of-the-server]__0oa1lav._.js

@@ -1,3 +0,0 @@
-module.exports=[44376,(a,b,c)=>{b.exports=a.x("node:module",()=>require("node:module"))},36119,81243,a=>{"use strict";var b=a.i(37936),c=a.i(21572),d=a.i(2157),e=a.i(75818),f=a.i(60526),g=a.i(50227),h=a.i(74533);function i(){return(0,f.userInfo)().username}function j(a=i()){return`failproofaid@${a}.service`}function k(a=i()){return(0,g.resolve)(process.env.FAILPROOFAI_SYSTEMD_DIR||"/etc/systemd/system",j(a))}function l(){try{var a;return a=(0,h.execFileSync)("systemctl",["show",j(),"--property=ConditionResult","--value"],{stdio:["ignore","pipe","ignore"],timeout:1e4}).toString(),"no"===a.trim()?"condition-failed":"stopped"}catch{return"stopped"}}a.i(10695),a.i(66680),a.i(44376),a.i(27028);var m=a.i(15501),n=a.i(8674),o=a.i(93328);function p(){return(process.env.FAILPROOF_API_URL??process.env.FAILPROOFAI_API_URL??"https://api.befailproof.ai").replace(/\/+$/,"")}class q extends Error{status;code;retryAfterSecs;constructor(a,b,c,d){super(c),this.status=a,this.code=b,this.retryAfterSecs=d,this.name="AuthApiError"}}async function r(a){let b={};try{b=await a.json()}catch{}let c=b.code??`http_${a.status}`,d=b.message??b.detail??a.statusText??"request failed",e=b.retry_after_secs;if(void 0===e){let b=a.headers.get("retry-after");if(b){let a=Number(b);Number.isFinite(a)&&(e=a)}}return void 0!==e&&(e=Math.max(0,Math.min(86400,e))),new q(a.status,c,d,e)}async function s(a,b){try{return await fetch(a,{...b,signal:function(a){let b=AbortSignal.timeout(1e4);if(!a)return b;let c=AbortSignal.any;if(c)return c([b,a]);let d=new AbortController;if(b.aborted)d.abort(b.reason);else b.addEventListener("abort",()=>d.abort(b.reason),{once:!0});if(a.aborted)d.abort(a.reason);else a.addEventListener("abort",()=>d.abort(a.reason),{once:!0});return d.signal}(b.signal??void 0)})}catch(d){let c=function(a){if(null===a||"object"!=typeof a)return!1;let b=a.name;return"AbortError"===b||"TimeoutError"===b}(d);if((0,o.trackEvent)("api_server_unreachable",{kind:c?"timeout":"network",path:function(a){try{return new URL(a).pathname}catch{return a}}(a),method:"string"==typeof b.method?b.method:"GET"}),c)throw new q(0,"timeout",`request to ${a} timed out after 10000ms`);throw d}}async function t(a,b,c){let d={"content-type":"application/json"};c?.accessToken&&(d.authorization=`Bearer ${c.accessToken}`);let e=await s(`${p()}${a}`,{method:"POST",headers:d,body:JSON.stringify(b)});if(204!==e.status){if(!e.ok)throw await r(e);return await e.json()}}async function u(a,b){let c=await s(`${p()}${a}`,{method:"GET",headers:{authorization:`Bearer ${b}`}});if(!c.ok)throw await r(c);return await c.json()}async function v(a){return t("/v0/auth/token/refresh",{refresh_token:a})}async function w(a){return u("/v0/auth/me",a)}function x(){let a=process.env.FAILPROOFAI_AUTH_DIR;return a?(0,g.join)(a,"session.json"):(0,e.auditSessionFile)()}function y(){let a=x();if(!(0,d.existsSync)(a))return null;try{let b=(0,d.readFileSync)(a,"utf-8"),c=JSON.parse(b);if("string"!=typeof c.access_token||"string"!=typeof c.refresh_token||"number"!=typeof c.access_expires_at||"object"!=typeof c.user||!c.user||"string"!=typeof c.user.id||"string"!=typeof c.user.email)return null;return{access_token:c.access_token,refresh_token:c.refresh_token,access_expires_at:c.access_expires_at,refresh_expires_at:"number"==typeof c.refresh_expires_at?c.refresh_expires_at:c.access_expires_at,user:{id:c.user.id,email:c.user.email}}}catch{return null}}function z(){let a=x();(0,d.existsSync)(a)&&(0,d.rmSync)(a,{force:!0});try{let a=(0,e.migrationsDir)();if(!(0,d.existsSync)(a))return;for(let b of(0,d.readdirSync)(a)){if(!b.startsWith("backup-layout"))continue;let c=(0,g.resolve)(a,b,"auth.json");(0,d.existsSync)(c)&&(0,d.rmSync)(c,{force:!0})}}catch{}}let A=new Map;async function B(a){let b=A.get(a.refresh_token);if(b)return b;let c=(async()=>{let b=function(a,b){let c=Math.floor(Date.now()/1e3),d=a.user??b;if(!d)throw Error("authFromTokenResponse: missing user identity");return{access_token:a.access_token,refresh_token:a.refresh_token,access_expires_at:c+a.access_expires_in,refresh_expires_at:c+a.refresh_expires_in,user:d}}(await v(a.refresh_token),a.user);return(0,n.writeJsonAtomically)(x(),b),b})();A.set(a.refresh_token,c);try{return await c}finally{A.delete(a.refresh_token)}}async function C(){let a=y();if(!a)return null;let b=Math.floor(Date.now()/1e3);if(a.access_expires_at-b>60)return a;try{return await B(a)}catch(a){return a instanceof q&&401===a.status&&z(),null}}async function D(){let a=await C();if(!a)return null;try{return{me:await w(a.access_token),auth:a}}catch(a){if(a instanceof q&&401===a.status){let a=y();if(!a)return null;try{let b=await B(a);return{me:await w(b.access_token),auth:b}}catch(a){a instanceof q&&401===a.status&&z()}}return null}}async function E(){let a=(0,c.readConfig)(),b=function(){let a,b;try{a=(0,d.readFileSync)((0,e.auditScheduleFile)(void 0),"utf8")}catch{return null}try{b=JSON.parse(a)}catch{return null}if(!b||"object"!=typeof b||Array.isArray(b))return null;let c=b,f=a=>"number"==typeof a&&Number.isFinite(a)?a:null,g=f(c.schema);return{schema:g,nextDueAtMs:f(c.next_due_at_ms),lastAttemptAtMs:f(c.last_attempt_at_ms),lastRunAtMs:f(c.last_run_at_ms),lastExitCode:f(c.last_exit_code),schemaAhead:null!==g&&g>1}}(),f=(0,m.readDashboardCacheMeta)(),g=y(),i=function(){if("linux"!==process.platform&&process.platform,!(0,d.existsSync)(k()))return"not-installed";try{let a=(0,h.execFileSync)("systemctl",["is-active",j()],{stdio:["ignore","pipe","ignore"],timeout:1e4}).toString().trim();return"active"===a?"running":l()}catch{return l()}}();return{auto:a.audit.auto,intervalDays:a.audit.intervalDays,signedInAs:g?{id:g.user.id,email:g.user.email}:null,daemon:i,schedule:b?{nextDueAtMs:b.nextDueAtMs,lastAttemptAtMs:b.lastAttemptAtMs,lastRunAtMs:b.lastRunAtMs,lastExitCode:b.lastExitCode,schemaAhead:b.schemaAhead}:null,lastResultAt:f?.cachedAt??null,lastScan:f?{finishedAt:f.cachedAt,findings:f.findings,sessionsScanned:f.sessionsScanned,eventsScanned:f.eventsScanned}:null,daemonStartedAtMs:"running"===i?function(){if(!(0,d.existsSync)(k()))return null;try{let a=(0,h.execFileSync)("systemctl",["show",j(),"-p","ActiveEnterTimestampMonotonic","--value"],{stdio:["ignore","pipe","ignore"],timeout:1e4}).toString().trim();return function(a,b,c){if(!Number.isFinite(a)||a<=0||!Number.isFinite(b)||b<=0)return null;let d=(b-a)/1e3;return d<0?null:Math.round(c-d)}(Number(a),Math.floor(Number(process.hrtime.bigint())/1e3),Date.now())}catch{return null}}():null}}a.s(["readAuth",0,y,"whoAmI",0,D],81243),(0,a.i(13095).ensureServerEntryExports)([E]),(0,b.registerServerReference)(E,"00063bb359b039d550f793409319d65c11c5b57371",null),a.s(["getScheduledAuditAction",0,E],36119)}];
-
-//# sourceMappingURL=%5Broot-of-the-server%5D__0oa1lav._.js.map