failproofai 1.0.0-beta.0 → 1.0.0-beta.10

package/src/hooks/handler.ts

@@ -41,6 +41,9 @@ import { resolveTranscriptPath } from "./resolve-transcript-path";
 import { getInstanceId } from "../../lib/telemetry-id";
 import { hookLogInfo, hookLogWarn } from "./hook-logger";
 import { readStdinPayload } from "./read-stdin";
+import { readActiveCloudManagedPolicies, type CloudManagedPolicyArtifact } from "./cloud-managed-policies";
+import { readActivePause, type ActivePause } from "./session-pause";
+import { layoutWarningForHook } from "./fp-reset";
 
 /**
  * Canonicalize an event name to PascalCase. Codex sends snake_case event names
@@ -134,6 +137,37 @@ export interface EvaluateHookEventOptions {
   fallbackCwd?: string;
 }
 
+/**
+ * Runs an observe-mode policy under the same timeout and error handling as an
+ * enforcing one, so what gets measured is what would actually have happened —
+ * including a policy that times out, which in enforce mode is an allow and must
+ * be recorded as one rather than as a would-deny.
+ */
+async function runObserved(
+  hook: CustomHook,
+  ctx: Parameters<CustomHook["fn"]>[0],
+  hookName: string,
+  eventType: string,
+  cli: IntegrationType,
+): Promise<PolicyResult> {
+  try {
+    return await Promise.race([
+      hook.fn(ctx),
+      new Promise<PolicyResult>((_, reject) => setTimeout(() => reject(new Error("timeout")), 10_000)),
+    ]);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    void trackHookEvent(getInstanceId(), "custom_hook_error", {
+      hook_name: hookName,
+      error_type: msg === "timeout" ? "timeout" : "exception",
+      event_type: eventType,
+      cli,
+      is_observe_mode: true,
+    });
+    return { decision: "allow" };
+  }
+}
+
 /**
  * The core hook-evaluation logic, decoupled from process stdin/stdout so it
  * can be called repeatedly inside a long-lived process (the daemon's warm
@@ -149,6 +183,13 @@ export async function evaluateHookEvent(
   opts?: EvaluateHookEventOptions,
 ): Promise<HookEventOutcome> {
   const startTime = performance.now();
+  // A home from another layout resolves to no global config, so every builtin
+  // silently stops firing — the machine looks protected and is not. Say so on
+  // every call rather than deleting anything (a hook is unattended) or denying
+  // (a blanket deny takes UserPromptSubmit with it and locks the user out of
+  // their agent entirely — demonstrated on a real machine during this work).
+  const layoutWarning = layoutWarningForHook();
+  if (layoutWarning) hookLogWarn(layoutWarning);
   try {
     let parsed: Record<string, unknown> = {};
     if (stdinPayload) {
@@ -209,6 +250,20 @@ export async function evaluateHookEvent(
     let config: HooksConfig;
     let customHooksList: CustomHook[] = [];
     let conventionHookNames = new Set<string>();
+    let activePause: ActivePause | null = null;
+    /** Registered policy name → where it came from. See the set() below. */
+    const policyAttribution = new Map<
+      string,
+      { source: "custom" | "convention" | "cloud"; cloudPolicyId?: string; cloudRevision?: number }
+    >();
+    let cloudGeneration: number | undefined;
+    /** What observe-mode policies WOULD have done, had they been enforcing. */
+    const observedResults: Array<{
+      policyId: string;
+      revision: number;
+      decision: "deny" | "instruct";
+      reason: string | null;
+    }> = [];
 
     if (opts?.forceDecision) {
       // Fail-closed: no config/custom-hook loading at all — a daemon that
@@ -228,25 +283,113 @@ export async function evaluateHookEvent(
       // Load enabled policies (merge across project/local/global scopes)
       config = readMergedHooksConfig(session.cwd);
       clearPolicies();
-      registerBuiltinPolicies(config.enabledPolicies);
+
+      // A session pause suspends LOCAL policy only, for a bounded time. Cloud
+      // assignments are exempt below for the same reason `disabledCustomPolicies`
+      // already exempts them: a locally-issued command that could switch off a
+      // centrally assigned policy would make cloud enforcement decorative.
+      activePause = readActivePause(session.sessionId);
+      registerBuiltinPolicies(activePause ? [] : config.enabledPolicies);
+
+      // Cloud-managed policies are daemon-reconciled artifacts, but they use
+      // the same public JS policy API as local custom policies. Verify and add
+      // only the paths referenced by the atomically active generation.
+      //
+      // Wrapped, like `readConfigAt` and `readActivePause` above it. This call
+      // has fourteen throw sites — a malformed manifest, an unsafe id, an
+      // integrity mismatch, an unknown effect — and it sat bare inside a `try`
+      // whose only handler is a `finally`, so any of them aborted the entire
+      // evaluation. What that cost depended on where the hook ran, and none of
+      // the outcomes were the intended one: on a daemon machine the client
+      // fail-closed denies every tool call, and off the daemon path the throw
+      // reaches `bin/failproofai.mjs`'s outer catch, which exits 2 with nothing
+      // on stdout — a deny on Claude and Factory, but a logged warning followed
+      // by an ALLOW on Copilot, Cursor, Goose, Pi and Hermes, which read a
+      // decision off stdout and ignore the exit code. One corrupt byte was
+      // either a permanent machine-wide lockout or silent non-enforcement,
+      // depending on the CLI.
+      //
+      // Failing open here degrades ONE layer: builtins and local custom
+      // policies were already registered above and keep enforcing. That is the
+      // same trade `2ad735e5` made on the Rust side, and it is strictly better
+      // than the status quo, which already failed open on five of the twelve —
+      // just accidentally, and without saying so.
+      let cloudManagedPolicies: CloudManagedPolicyArtifact[] = [];
+      try {
+        cloudManagedPolicies = readActiveCloudManagedPolicies();
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        hookLogWarn(
+          `[failproofai] cloud-managed policies could NOT be loaded and are not being enforced: ${msg}. ` +
+            `Local policies are unaffected. Run \`failproofai config --status\` to check this machine's enrolment.`,
+        );
+        void trackHookEvent(getInstanceId(), "cloud_managed_load_error", {
+          event_type: eventType,
+          cli,
+        });
+      }
+      // Recorded on every row once a machine is managed, whether or not a cloud
+      // policy decided this event: "what was deployed here at the time" is a
+      // separate question from "what decided", and only the former can tell a
+      // rollout that changed nothing from one that never reached the machine.
+      cloudGeneration = cloudManagedPolicies[0]?.generation;
+      const configuredCustomPaths = config.customPoliciesPaths ?? config.customPoliciesPath;
+      const allExplicitPaths =
+        cloudManagedPolicies.length === 0
+          ? configuredCustomPaths
+          : [
+              ...(typeof configuredCustomPaths === "string" ? [configuredCustomPaths] : configuredCustomPaths ?? []),
+              ...cloudManagedPolicies.map((policy) => policy.path),
+            ];
 
       // Load and register custom hooks (layer 2, after builtins)
-      const loadResult = await loadAllCustomHooks(config.customPoliciesPaths ?? config.customPoliciesPath, {
+      const loadResult = await loadAllCustomHooks(allExplicitPaths, {
         sessionCwd: session.cwd,
         customPoliciesEnabled: config.customPoliciesEnabled,
+        ...(cloudManagedPolicies.length > 0 ? { cloudManagedPolicies } : {}),
       });
       customHooksList = loadResult.hooks;
       const disabledCustomPolicies = new Set(config.disabledCustomPolicies ?? []);
       conventionHookNames = new Set(loadResult.conventionSources.flatMap((s) => s.hookNames));
 
       for (const hook of customHooksList) {
-        const policyId = (hook as CustomHook & { __policyId?: string }).__policyId;
-        if (policyId && disabledCustomPolicies.has(policyId)) continue;
+        const taggedHook = hook as CustomHook & {
+          __policyId?: string;
+          __cloudManaged?: CloudManagedPolicyArtifact;
+        };
+        const policyId = taggedHook.__policyId;
+        const cloudManaged = taggedHook.__cloudManaged;
+        // Local config cannot disable a centrally assigned policy merely by
+        // copying its generated ID into disabledCustomPolicies.
+        if (!cloudManaged && policyId && disabledCustomPolicies.has(policyId)) continue;
+        // Same rule for a session pause — it suspends local policy, never cloud.
+        if (!cloudManaged && activePause) continue;
         const hookName = hook.name;
         const conventionScope = (hook as CustomHook & { __conventionScope?: string }).__conventionScope;
         const isConvention = !!conventionScope;
-        const prefix = isConvention ? `.failproofai-${conventionScope}` : "custom";
+        const prefix = cloudManaged
+          ? `cloud/${cloudManaged.id}@${cloudManaged.revision}`
+          : isConvention
+            ? `.failproofai-${conventionScope}`
+            : "custom";
+        // Observe mode: run it for real, record what it decided, then hand back
+        // an allow. Evaluating and discarding is the whole point — a rollout is
+        // measured against real traffic before it can break anyone's work, and
+        // a policy that did not actually run would measure nothing.
+        const observeOnly = cloudManaged?.effect === "observe";
         const fn: PolicyFunction = async (ctx): Promise<PolicyResult> => {
+          if (observeOnly) {
+            const shadow = await runObserved(hook, ctx, hookName, eventType, cli);
+            if (shadow.decision !== "allow") {
+              observedResults.push({
+                policyId: cloudManaged!.id,
+                revision: cloudManaged!.revision,
+                decision: shadow.decision,
+                reason: shadow.reason ?? null,
+              });
+            }
+            return { decision: "allow" };
+          }
           try {
             const result = await Promise.race([
               hook.fn(ctx),
@@ -268,8 +411,18 @@ export async function evaluateHookEvent(
             return { decision: "allow" };
           }
         };
+        const registeredName = `${prefix}/${hookName}`;
+        // Record where this policy came from as structured data, keyed by the
+        // exact name the evaluator will report back. The display name already
+        // encodes it ("cloud/org-guard@7/…"), but only as a string — so the one
+        // question cloud attribution has to answer, "which rollout produced
+        // this decision", could only be answered by re-parsing our own label.
+        policyAttribution.set(registeredName, {
+          source: cloudManaged ? "cloud" : isConvention ? "convention" : "custom",
+          ...(cloudManaged ? { cloudPolicyId: cloudManaged.id, cloudRevision: cloudManaged.revision } : {}),
+        });
         registerPolicy(
-          `${prefix}/${hookName}`,
+          registeredName,
           hook.description ?? "",
           fn,
           hook.match ?? {},
@@ -335,6 +488,32 @@ export async function evaluateHookEvent(
       cwd: session.cwd,
       permissionMode: session.permissionMode,
       hookEventName: session.hookEventName,
+      // Attribution. A builtin is anything registered that is not in the map,
+      // so its absence is meaningful rather than missing — but only when a
+      // policy actually decided; a plain allow names nobody.
+      ...(result.policyName
+        ? (() => {
+            const attribution = policyAttribution.get(result.policyName);
+            return {
+              policySource: attribution?.source ?? ("builtin" as const),
+              ...(attribution?.cloudPolicyId ? { cloudPolicyId: attribution.cloudPolicyId } : {}),
+              ...(attribution?.cloudRevision !== undefined
+                ? { cloudRevision: attribution.cloudRevision }
+                : {}),
+            };
+          })()
+        : {}),
+      ...(cloudGeneration !== undefined ? { cloudGeneration } : {}),
+      // The point of observe mode is this record. Without it the rollout is
+      // unmeasurable and the row is indistinguishable from one where the policy
+      // never matched at all.
+      ...(observedResults.length > 0 ? { observed: observedResults } : {}),
+      // Without these, a row logged during a pause is indistinguishable from
+      // one where every policy ran and allowed — the log would assert a clean
+      // window over exactly the window that was not enforced.
+      ...(activePause
+        ? { pausedBy: activePause.setBy, pauseExpiresAt: activePause.expiresAt }
+        : {}),
     };
     try {
       persistHookActivity(activityEntry);

package/src/hooks/hook-activity-store.ts

@@ -1,7 +1,7 @@
 /**
  * Disk persistence for hook activity entries using page-sized JSONL files.
  *
- * Storage location: ~/.failproofai/cache/hook-activity/
+ * Storage location: ~/.failproofai/hook-activity/ (see fp-home.ts)
  *
  * File structure:
  * - current.jsonl — actively written to, 0–PAGE_SIZE entries
@@ -22,19 +22,32 @@ import {
   unlinkSync,
 } from "node:fs";
 import { join } from "node:path";
-import { homedir } from "node:os";
 import type { IntegrationType } from "./types";
+import { hookActivityDir } from "./fp-home";
 
 export const PAGE_SIZE = 25;
 
-const DEFAULT_STORE_DIR = join(homedir(), ".failproofai", "cache", "hook-activity");
+/**
+ * Layout 2 promoted this out of `cache/`. It was never a cache — nothing
+ * regenerates it, and deleting it loses the decision history the dashboard's
+ * activity tab is built on. Resolved lazily (not at module load) so
+ * FAILPROOFAI_HOME is honoured by tests and containers that set it after
+ * import.
+ */
+const defaultStoreDir = () => hookActivityDir();
 const CURRENT_FILE = "current.jsonl";
 const COUNT_FILE = "current.count"; // tracks line count; O(1) read/write vs rereading current.jsonl
 const STATS_FILE = "stats.json";
 const LOCK_FILE = "current.lock";  // advisory lock for concurrent hook processes
 const LOCK_STALE_MS = 2000;        // steal lock if older than 2 s (covers crashed processes)
 
-let storeDir = DEFAULT_STORE_DIR;
+let storeDirOverride: string | null = null;
+/**
+ * A getter, not a module-load constant: `FAILPROOFAI_HOME` is routinely set by
+ * a test or a container AFTER this module is imported, and a value captured at
+ * import time would silently point every write at the real home.
+ */
+const storeDirValue = () => storeDirOverride ?? defaultStoreDir();
 let rotateSeq = 0;
 
 // ── Types ──
@@ -69,6 +82,45 @@ export interface HookActivityEntry {
   cwd?: string;
   permissionMode?: string;
   hookEventName?: string;
+  /**
+   * Set only on events evaluated while a session pause was active. Absent on
+   * every ordinary row and on every row written before pausing existed, so —
+   * like `matchedPolicies` — consumers must treat `undefined` as "not paused"
+   * rather than rendering it as unknown.
+   */
+  pausedBy?: string;
+  /** Epoch ms the pause lifts. Present iff `pausedBy` is. */
+  pauseExpiresAt?: number;
+  /**
+   * Where the policy that DECIDED came from. Absent when nothing decided (a
+   * plain allow) and on rows written before this existed — so, like
+   * `matchedPolicies`, `undefined` means "unknown", not "builtin".
+   */
+  policySource?: "builtin" | "custom" | "convention" | "cloud";
+  /** Cloud policy id of the decider. Present only when `policySource` is "cloud". */
+  cloudPolicyId?: string;
+  /** Immutable revision of that policy — the half of attribution that identifies WHICH version ran. */
+  cloudRevision?: number;
+  /**
+   * The cloud generation active when this event was evaluated, recorded on
+   * every row of a managed machine regardless of what decided. "What was
+   * deployed here" is a different question from "what decided", and only this
+   * distinguishes a rollout that changed no outcomes from one that never
+   * arrived.
+   */
+  cloudGeneration?: number;
+  /**
+   * What observe-mode policies WOULD have done, had they been enforcing. This
+   * record is the entire point of observe mode: without it the row is
+   * indistinguishable from one where the policy never matched, and the rollout
+   * being trialled is unmeasurable.
+   */
+  observed?: Array<{
+    policyId: string;
+    revision: number;
+    decision: "deny" | "instruct";
+    reason: string | null;
+  }>;
 }
 
 export interface HookActivityFilters {
@@ -77,6 +129,12 @@ export interface HookActivityFilters {
   policyName?: string;
   sessionId?: string;
   integration?: IntegrationType;
+  /**
+   * Filter by where the deciding policy came from. "Show me everything my
+   * organization's policies decided" is the question cloud rollout reporting
+   * is built on, and it is unanswerable without this.
+   */
+  source?: "builtin" | "custom" | "convention" | "cloud";
 }
 
 export interface HookActivityStats {
@@ -89,8 +147,8 @@ export interface HookActivityStats {
 // ── Directory setup ──
 
 function ensureDir(): void {
-  if (!existsSync(storeDir)) {
-    mkdirSync(storeDir, { recursive: true });
+  if (!existsSync(storeDirValue())) {
+    mkdirSync(storeDirValue(), { recursive: true });
   }
 }
 
@@ -98,7 +156,7 @@ function ensureDir(): void {
 
 function acquireLock(): void {
   ensureDir();
-  const lockPath = join(storeDir, LOCK_FILE);
+  const lockPath = join(storeDirValue(), LOCK_FILE);
   const deadline = Date.now() + LOCK_STALE_MS;
   while (Date.now() < deadline) {
     try {
@@ -121,7 +179,7 @@ function acquireLock(): void {
 }
 
 function releaseLock(): void {
-  try { unlinkSync(join(storeDir, LOCK_FILE)); } catch { /* ignore */ }
+  try { unlinkSync(join(storeDirValue(), LOCK_FILE)); } catch { /* ignore */ }
 }
 
 // ── Writing (synchronous — hook handler is short-lived) ──
@@ -130,8 +188,8 @@ export function persistHookActivity(entry: HookActivityEntry): void {
   ensureDir();
   acquireLock();
   try {
-    const currentPath = join(storeDir, CURRENT_FILE);
-    const countPath = join(storeDir, COUNT_FILE);
+    const currentPath = join(storeDirValue(), CURRENT_FILE);
+    const countPath = join(storeDirValue(), COUNT_FILE);
 
     const lineCount = readCount(countPath);
     if (lineCount >= PAGE_SIZE) {
@@ -153,7 +211,7 @@ export function persistHookActivity(entry: HookActivityEntry): void {
 
 function rotate(currentPath: string, countPath: string): void {
   const archiveName = `page-${Date.now()}-${rotateSeq++}.jsonl`;
-  const archivePath = join(storeDir, archiveName);
+  const archivePath = join(storeDirValue(), archiveName);
   renameSync(currentPath, archivePath);
   // Reset count for the fresh file (write 0 — next append will set it to 1)
   writeCount(countPath, 0);
@@ -195,7 +253,7 @@ interface StoredStats {
 
 function readStoredStats(): StoredStats {
   try {
-    return JSON.parse(readFileSync(join(storeDir, STATS_FILE), "utf-8")) as StoredStats;
+    return JSON.parse(readFileSync(join(storeDirValue(), STATS_FILE), "utf-8")) as StoredStats;
   } catch {
     return { totalEvents: 0, denyCount: 0, policyMap: {} };
   }
@@ -213,10 +271,10 @@ function updateStats(entry: HookActivityEntry): void {
     s.policyMap[entry.policyName] = (s.policyMap[entry.policyName] ?? 0) + 1;
   }
   // Write atomically: write to a PID-unique temp file then rename — prevents partial reads.
-  const tmpPath = join(storeDir, `stats.json.${process.pid}.tmp`);
+  const tmpPath = join(storeDirValue(), `stats.json.${process.pid}.tmp`);
   try {
     writeFileSync(tmpPath, JSON.stringify(s), "utf-8");
-    renameSync(tmpPath, join(storeDir, STATS_FILE));
+    renameSync(tmpPath, join(storeDirValue(), STATS_FILE));
   } catch {
     try { unlinkSync(tmpPath); } catch { /* ignore */ }
     // Non-fatal: stats file write failure doesn't block the hook
@@ -243,7 +301,7 @@ export function getHookActivityPage(page: number): HookActivityEntry[] {
   if (page < 1) return [];
 
   if (page === 1) {
-    const currentPath = join(storeDir, CURRENT_FILE);
+    const currentPath = join(storeDirValue(), CURRENT_FILE);
     return readJsonlFile(currentPath).reverse();
   }
 
@@ -251,7 +309,7 @@ export function getHookActivityPage(page: number): HookActivityEntry[] {
   const archiveIndex = page - 2;
   if (archiveIndex >= archives.length) return [];
 
-  return readJsonlFile(join(storeDir, archives[archiveIndex])).reverse();
+  return readJsonlFile(join(storeDirValue(), archives[archiveIndex])).reverse();
 }
 
 export function getHookActivityPageCount(): number {
@@ -262,13 +320,13 @@ export function getHookActivityPageCount(): number {
 export function getAllHookActivityEntries(): HookActivityEntry[] {
   ensureDir();
 
-  const currentPath = join(storeDir, CURRENT_FILE);
+  const currentPath = join(storeDirValue(), CURRENT_FILE);
   const currentEntries = readJsonlFile(currentPath).reverse();
 
   const archives = getArchiveFiles();
   const archiveEntries: HookActivityEntry[] = [];
   for (const file of archives) {
-    const entries = readJsonlFile(join(storeDir, file));
+    const entries = readJsonlFile(join(storeDirValue(), file));
     archiveEntries.push(...entries.reverse());
   }
 
@@ -298,6 +356,11 @@ export function searchHookActivity(
       return false;
     }
     if (filters.integration && entry.integration !== filters.integration) return false;
+    // Rows written before attribution existed have no policySource. They are
+    // excluded from every source filter rather than guessed at — a wrong
+    // attribution is worse than a missing one when the point is proving which
+    // rollout decided something.
+    if (filters.source && entry.policySource !== filters.source) return false;
     return true;
   });
 
@@ -342,7 +405,7 @@ function readJsonlFile(filePath: string): HookActivityEntry[] {
 
 function getArchiveFiles(): string[] {
   try {
-    const files = readdirSync(storeDir);
+    const files = readdirSync(storeDirValue());
     return files
       .filter((f) => f.startsWith("page-") && f.endsWith(".jsonl"))
       .sort((a, b) => {
@@ -364,5 +427,7 @@ function getArchiveFiles(): string[] {
 
 export function _resetForTest(testDir?: string): void {
   rotateSeq = 0;
-  storeDir = testDir ?? DEFAULT_STORE_DIR;
+  // null, not the default path: clearing the override lets the getter re-read
+  // FAILPROOFAI_HOME, which a test may have changed since this module loaded.
+  storeDirOverride = testDir ?? null;
 }

package/src/hooks/hook-logger.ts

@@ -22,13 +22,14 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
+import { logsDir } from "./fp-home";
 
 export type LogLevel = "info" | "warn" | "error";
 
 const LEVEL_ORDER: Record<LogLevel, number> = { info: 0, warn: 1, error: 2 };
 const MAX_FILE_SIZE = 512 * 1024; // 500 KB
 const LOG_FILENAME = "hooks.log";
-const DEFAULT_LOG_DIR = join(homedir(), ".failproofai", "logs");
+const DEFAULT_LOG_DIR = logsDir();
 
 // ── State (lazy-initialized) ──
 

package/src/hooks/hook-telemetry.ts

@@ -7,6 +7,7 @@
 
 import { version } from "../../package.json";
 import { POSTHOG_API_KEY, POSTHOG_PRODUCT } from "../posthog-key";
+import { isTelemetryEnabled } from "../../lib/telemetry-enabled";
 
 const API_KEY = POSTHOG_API_KEY;
 const CAPTURE_URL = "https://us.i.posthog.com/capture/";
@@ -57,7 +58,10 @@ export async function trackHookEvent(
   event: string,
   properties?: Record<string, unknown>,
 ): Promise<void> {
-  if (process.env.FAILPROOFAI_TELEMETRY_DISABLED === "1") return;
+  // Honours the config file as well as the env var — the env var alone cannot
+  // reach a system-scope daemon. Memoised, so this stays off the hook path's
+  // latency budget. See lib/telemetry-enabled.ts.
+  if (!isTelemetryEnabled()) return;
 
   const p = sendEvent(distinctId, event, properties);
   pending.add(p);

package/src/hooks/hooks-config.ts

@@ -7,6 +7,7 @@ import { homedir } from "node:os";
 import type { HooksConfig, ConventionPolicyRecord } from "./policy-types";
 import type { HookScope } from "./types";
 import { hookLogInfo, hookLogWarn } from "./hook-logger";
+import { globalPolicyConfigFile } from "./fp-home";
 
 /** Normalize plural and legacy singular explicit policy paths for consumers. */
 export function configuredCustomPolicyPaths(
@@ -69,7 +70,7 @@ export function readMergedHooksConfig(cwd?: string): HooksConfig {
   const base = findProjectConfigDir(cwd ?? process.cwd());
   const projectPath = resolve(base, ".failproofai", "policies-config.json");
   const localPath = resolve(base, ".failproofai", "policies-config.local.json");
-  const globalPath = resolve(homedir(), ".failproofai", "policies-config.json");
+  const globalPath = globalPolicyConfigFile();
 
   const project = readConfigAt(projectPath);
   const local = readConfigAt(localPath);
@@ -128,7 +129,7 @@ export function readMergedHooksConfig(cwd?: string): HooksConfig {
 }
 
 function getConfigPath(): string {
-  return resolve(homedir(), ".failproofai", "policies-config.json");
+  return globalPolicyConfigFile();
 }
 
 export function readHooksConfig(): HooksConfig {
@@ -160,7 +161,7 @@ export function writeHooksConfig(config: HooksConfig): void {
 export function getConfigPathForScope(scope: HookScope, cwd?: string): string {
   switch (scope) {
     case "user":
-      return resolve(homedir(), ".failproofai", "policies-config.json");
+      return globalPolicyConfigFile();
     case "project":
       return resolve(findProjectConfigDir(cwd ?? process.cwd()), ".failproofai", "policies-config.json");
     case "local":