failproofai 1.0.0-beta.2 → 1.0.0-beta.21

package/dist/worker.mjs

@@ -362,6 +362,43 @@ function normalizeCliPayload(cli, parsed) {
   }
 }
 
+// src/hooks/fp-home.ts
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+function failproofaiHome(home) {
+  if (home)
+    return resolve(home, ".failproofai");
+  return process.env.FAILPROOFAI_HOME || resolve(homedir(), ".failproofai");
+}
+var LAYOUT_VERSION = 3, at = (...parts) => resolve(failproofaiHome(), ...parts), atHome = (home, ...parts) => home ? resolve(failproofaiHome(home), ...parts) : at(...parts), versionFile = (home) => atHome(home, "VERSION"), configFile = (home) => atHome(home, "config.json"), policiesDir = (home) => atHome(home, "policies"), customPoliciesDir, globalPolicyConfigFile = (home) => atHome(home, "policies-config.json"), cloudPoliciesDir = (home) => resolve(policiesDir(home), "cloud-policies"), hookActivityDir = (home) => atHome(home, "hook-activity"), stateDir = (home) => atHome(home, "state"), shimsDir = (home) => resolve(stateDir(home), "shims"), sessionPauseDir = () => resolve(stateDir(), "sessions"), telemetryIdFile = (home) => resolve(stateDir(home), "telemetry-id"), codexSessionPathsFile = (home) => resolve(stateDir(home), "codex-session-paths.json"), logsDir = (home) => atHome(home, "logs"), legacy;
+var init_fp_home = __esm(() => {
+  customPoliciesDir = policiesDir;
+  legacy = {
+    policyConfig: () => at("policies-config.json"),
+    configToml: () => at("config.toml"),
+    credentialsToml: () => at("credentials.toml"),
+    localPoliciesDir: () => at("policies", "local-policies"),
+    localPolicyConfig: () => at("policies", "local-policies", "policies-config.json"),
+    customPoliciesDir: () => at("policies", "custom-policies"),
+    policyConfigLocal: () => at("policies-config.local.json"),
+    cloudCredentials: () => at("cloud.json"),
+    ingestCredentials: () => at("ingest.json"),
+    launcherMarker: () => at(".launcher-configured"),
+    lastVersion: () => at("last-version"),
+    auditDashboard: () => at("audit-dashboard.json"),
+    cacheDir: () => at("cache"),
+    hookActivityDir: () => at("cache", "hook-activity"),
+    auditCacheDir: () => at("cache", "audit"),
+    codexSessionPaths: () => at("cache", "codex-session-paths.json"),
+    spoolDir: () => at("spool"),
+    failedDir: () => at("failed"),
+    collectorHealth: () => at("collector-health.json"),
+    sessionPauseDir: () => at("state", "sessions"),
+    cloudManagedPolicies: () => at("policies", "cloud-managed"),
+    onboardingLock: () => at(".onboarding.lock")
+  };
+});
+
 // src/hooks/hook-logger.ts
 import {
   appendFileSync,
@@ -371,7 +408,6 @@ import {
   statSync
 } from "node:fs";
 import { join } from "node:path";
-import { homedir } from "node:os";
 function ensureResolved() {
   if (resolved)
     return;
@@ -443,15 +479,16 @@ function hookLogError(msg) {
 }
 var LEVEL_ORDER, MAX_FILE_SIZE, LOG_FILENAME = "hooks.log", DEFAULT_LOG_DIR, resolved = false, currentLevel = "warn", fileLoggingEnabled = false, logDir;
 var init_hook_logger = __esm(() => {
+  init_fp_home();
   LEVEL_ORDER = { info: 0, warn: 1, error: 2 };
   MAX_FILE_SIZE = 512 * 1024;
-  DEFAULT_LOG_DIR = join(homedir(), ".failproofai", "logs");
+  DEFAULT_LOG_DIR = logsDir();
   logDir = DEFAULT_LOG_DIR;
 });
 
 // src/hooks/hooks-config.ts
 import { readFileSync, writeFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, statSync as statSync2 } from "node:fs";
-import { resolve, dirname } from "node:path";
+import { resolve as resolve2, dirname } from "node:path";
 import { homedir as homedir2 } from "node:os";
 function readConfigAt(path) {
   if (!existsSync2(path))
@@ -466,9 +503,9 @@ function readConfigAt(path) {
 }
 function findProjectConfigDir(start) {
   const home = homedir2();
-  let dir = resolve(start);
+  let dir = resolve2(start);
   while (dir !== home) {
-    const marker = resolve(dir, ".failproofai");
+    const marker = resolve2(dir, ".failproofai");
     try {
       if (statSync2(marker).isDirectory())
         return dir;
@@ -478,13 +515,13 @@ function findProjectConfigDir(start) {
       break;
     dir = parent;
   }
-  return resolve(start);
+  return resolve2(start);
 }
 function readMergedHooksConfig(cwd) {
   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(homedir2(), ".failproofai", "policies-config.json");
+  const projectPath = resolve2(base, ".failproofai", "policies-config.json");
+  const localPath = resolve2(base, ".failproofai", "policies-config.local.json");
+  const globalPath = globalPolicyConfigFile();
   const project = readConfigAt(projectPath);
   const local = readConfigAt(localPath);
   const global_ = readConfigAt(globalPath);
@@ -522,6 +559,7 @@ function readMergedHooksConfig(cwd) {
 }
 var init_hooks_config = __esm(() => {
   init_hook_logger();
+  init_fp_home();
 });
 
 // src/hooks/policy-helpers.ts
@@ -596,7 +634,7 @@ function clearPolicies() {
 var REGISTRY_KEY = "__FAILPROOFAI_POLICY_REGISTRY__", INDEX_CACHE_KEY = "__FAILPROOFAI_POLICY_INDEX_CACHE__", DEFAULT_POLICY_NAMESPACE = "failproofai";
 
 // src/hooks/builtin-policies.ts
-import { resolve as resolve2, join as join2 } from "node:path";
+import { resolve as resolve3, join as join2 } from "node:path";
 import { statSync as statSync3 } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { execSync, execFileSync } from "node:child_process";
@@ -655,6 +693,65 @@ function getFilePath(ctx) {
 function parseArgvTokens(cmd) {
   return cmd.trim().split(/\s+/).map((t) => t.replace(/^['"]|['"]$/g, ""));
 }
+function namesSelfPause(command) {
+  for (const segment of command.split(SEGMENT_SEPARATORS)) {
+    const tokens = segment.split(/\s+/).filter(Boolean);
+    let i = 0;
+    while (i < tokens.length) {
+      const token = tokens[i];
+      const isSkippable = ENV_ASSIGNMENT_RE.test(token) || token.startsWith("-") || token.startsWith(">") || token.startsWith("<") || RUNNER_OPERAND_RE.test(token) || COMMAND_PREFIX_TOKENS.has(token.slice(token.lastIndexOf("/") + 1));
+      if (!isSkippable)
+        break;
+      i++;
+    }
+    if (i >= tokens.length)
+      continue;
+    if (!SELF_BINARY_TOKEN_RE.test(tokens[i]))
+      continue;
+    const args = tokens.slice(i + 1);
+    const configAt = args.findIndex((a) => CONFIG_SUBCOMMAND_RE.test(a));
+    if (configAt === -1)
+      continue;
+    if (args.slice(configAt + 1).some((a) => PAUSE_FLAG_RE.test(a)))
+      return true;
+  }
+  return false;
+}
+function decodeAnsiC(body) {
+  return body.replace(/\\(x[0-9A-Fa-f]{1,2}|u[0-9A-Fa-f]{1,4}|U[0-9A-Fa-f]{1,8}|[0-7]{1,3}|.)/g, (_, seq) => {
+    try {
+      if (seq[0] === "x")
+        return String.fromCharCode(parseInt(seq.slice(1), 16));
+      if (seq[0] === "u" || seq[0] === "U")
+        return String.fromCodePoint(parseInt(seq.slice(1), 16));
+      if (/^[0-7]+$/.test(seq))
+        return String.fromCharCode(parseInt(seq, 8));
+    } catch {
+      return seq;
+    }
+    const named = {
+      a: "\x07",
+      b: "\b",
+      e: "\x1B",
+      f: "\f",
+      n: `
+`,
+      r: "\r",
+      t: "\t",
+      v: "\v",
+      "\\": "\\",
+      "'": "'",
+      '"': '"',
+      "?": "?"
+    };
+    return named[seq] ?? seq;
+  });
+}
+function stripShellQuoting(command) {
+  const joined = command.replace(/\\\r?\n/g, "");
+  const ansiDecoded = joined.replace(/\$'((?:[^'\\]|\\.)*)'/g, (_, body) => decodeAnsiC(body));
+  return ansiDecoded.replace(/\\(.)/g, "$1").replace(/['"]/g, "");
+}
 function statGitHeadMtimeMs(cwd) {
   try {
     return statSync3(join2(cwd, ".git", "HEAD")).mtimeMs;
@@ -899,11 +996,82 @@ function blockEnvFiles(ctx) {
   }
   return allow();
 }
+function quoteAwareSegments(command) {
+  const segments = [];
+  let tokens = [];
+  let token = "";
+  let quote = null;
+  const endToken = () => {
+    if (token)
+      tokens.push(token);
+    token = "";
+  };
+  const endSegment = () => {
+    endToken();
+    if (tokens.length)
+      segments.push(tokens);
+    tokens = [];
+  };
+  for (let i = 0;i < command.length; i++) {
+    const c = command[i];
+    if (quote) {
+      if (c === "\\" && quote === '"' && i + 1 < command.length) {
+        token += command[++i];
+        continue;
+      }
+      if (c === quote) {
+        quote = null;
+        continue;
+      }
+      token += c;
+      continue;
+    }
+    if (c === "\\" && i + 1 < command.length) {
+      token += command[++i];
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      quote = c;
+      continue;
+    }
+    if (/\s/.test(c)) {
+      endToken();
+      continue;
+    }
+    if (/[;&|\n\r(){}`]/.test(c)) {
+      endSegment();
+      continue;
+    }
+    token += c;
+  }
+  endSegment();
+  return segments;
+}
+function namesElevation(command, depth = 0) {
+  for (const tokens of quoteAwareSegments(command)) {
+    let i = 0;
+    while (i < tokens.length) {
+      const token = tokens[i];
+      const base = token.slice(token.lastIndexOf("/") + 1);
+      if (base === "sudo" || base === "doas")
+        return true;
+      const isSkippable = ENV_ASSIGNMENT_RE.test(token) || token.startsWith("-") || token.startsWith(">") || token.startsWith("<") || RUNNER_OPERAND_RE.test(token) || COMMAND_PREFIX_TOKENS.has(base);
+      if (!isSkippable)
+        break;
+      if (EVAL_FLAG_RE.test(token) && depth < 3 && i + 1 < tokens.length) {
+        if (namesElevation(tokens[i + 1], depth + 1))
+          return true;
+      }
+      i++;
+    }
+  }
+  return false;
+}
 function blockSudo(ctx) {
   if (ctx.toolName !== "Bash")
     return allow();
   const cmd = getCommand(ctx).trimStart();
-  if (SUDO_RE.test(cmd) || cmd.startsWith("sudo ")) {
+  if (namesElevation(cmd)) {
     const allowPatterns = ctx.params?.allowPatterns ?? [];
     if (allowPatterns.some((p) => matchesAllowedPattern(cmd, p)))
       return allow();
@@ -917,6 +1085,15 @@ function blockSudo(ctx) {
   }
   return allow();
 }
+function blockSelfPause(ctx) {
+  if (ctx.toolName !== "Bash")
+    return allow();
+  const cmd = getCommand(ctx);
+  if (namesSelfPause(cmd) || namesSelfPause(stripShellQuoting(cmd))) {
+    return deny("Pausing failproofai enforcement is a human action, not an agent one. " + "If a policy is blocking legitimate work, say so and let the operator decide.");
+  }
+  return allow();
+}
 function blockCurlPipeSh(ctx) {
   if (ctx.toolName !== "Bash")
     return allow();
@@ -1142,7 +1319,7 @@ function blockReadOutsideCwd(ctx) {
     const paths = extractAbsolutePaths(cmd);
     const cwdWithSep2 = cwd.endsWith("/") ? cwd : cwd + "/";
     for (const p of paths) {
-      const resolved3 = resolve2(cwd, p);
+      const resolved3 = resolve3(cwd, p);
       if (isClaudeSettingsFile(resolved3)) {
         return deny(`Reading agent settings file blocked: ${resolved3}`);
       }
@@ -1163,7 +1340,7 @@ function blockReadOutsideCwd(ctx) {
   const target = filePath || searchPath;
   if (!target)
     return allow();
-  const resolved2 = resolve2(cwd, target);
+  const resolved2 = resolve3(cwd, target);
   if (isClaudeSettingsFile(resolved2)) {
     return deny(`Reading agent settings file blocked: ${resolved2}`);
   }
@@ -1654,7 +1831,7 @@ function registerBuiltinPolicies(enabledNames) {
     }
   }
 }
-var isClaudeInternalPath, isClaudeSettingsFile, SHELL_OPERATORS, SHELL_METACHAR_RE, JWT_RE, API_KEY_PATTERNS, CONNECTION_STRING_RE, PRIVATE_KEY_RE, BEARER_TOKEN_RE, SQL_TOOL_RE, DESTRUCTIVE_SQL_RE, DELETE_NO_WHERE_RE, SQL_WHERE_RE, SCHEMA_ALTER_RE, PUBLISH_CMD_RE, ENV_PRINTENV_RE, ECHO_ENV_RE, EXPORT_RE, PS_ENV_VAR_RE, PS_CHILDITEM_ENV_RE, DOTNET_GETENV_RE, CMD_ECHO_ENV_RE, ENV_FILE_PATH_RE, ENV_CMD_RE, SUDO_RE, PS_ELEVATION_RE, RUNAS_RE, CURL_PIPE_SH_RE, PS_WEB_PIPE_RE, SHORT_FLAG_BUNDLE_RE, SAFE_FORCE_PREFIXES, SECRET_FILE_RE, SECRET_FILE_ID_RSA_RE, SECRET_FILE_CREDENTIALS_RE, GIT_COMMIT_MERGE_RE, FAILPROOFAI_CLI_RE, FAILPROOFAI_UNINSTALL_RE, GIT_AMEND_RE, GIT_STASH_DROP_RE, GIT_ADD_ALL_RE, NPM_GLOBAL_RE, YARN_GLOBAL_RE, PNPM_GLOBAL_RE, BUN_GLOBAL_RE, CARGO_INSTALL_RE, PIP_SYSTEM_RE, PKG_MANAGER_DETECTORS, NOHUP_RE, SCREEN_DETACH_RE, TMUX_DETACH_RE, DISOWN_RE, BACKGROUND_AMPERSAND_RE, KUBECTL_RE, TERRAFORM_RE, AWS_CLI_RE, GCLOUD_RE, AZ_CLI_RE, HELM_RE, GH_PIPELINE_RE, gitBranchCache, GIT_BRANCH_CACHE_MAX_ENTRIES = 500, HOME_PREFIX_RE, RM_CMD_RE, FIND_CMD_RE, FIND_EXEC_RE, FIND_GLOBAL_OPT_RE, FIND_EXPR_START_RE, SCRATCH_ROOTS, CATASTROPHIC_DEPTH = 2, READ_LIKE_CMDS, TOOL_CALL_TRACKER_MAX_BYTES = 65536, SEGMENT_SPLIT_RE, BUILTIN_POLICIES;
+var isClaudeInternalPath, isClaudeSettingsFile, SHELL_OPERATORS, SHELL_METACHAR_RE, JWT_RE, API_KEY_PATTERNS, CONNECTION_STRING_RE, PRIVATE_KEY_RE, BEARER_TOKEN_RE, SQL_TOOL_RE, DESTRUCTIVE_SQL_RE, DELETE_NO_WHERE_RE, SQL_WHERE_RE, SCHEMA_ALTER_RE, PUBLISH_CMD_RE, ENV_PRINTENV_RE, ECHO_ENV_RE, EXPORT_RE, PS_ENV_VAR_RE, PS_CHILDITEM_ENV_RE, DOTNET_GETENV_RE, CMD_ECHO_ENV_RE, ENV_FILE_PATH_RE, ENV_CMD_RE, PS_ELEVATION_RE, RUNAS_RE, CURL_PIPE_SH_RE, SEGMENT_SEPARATORS, COMMAND_PREFIX_TOKENS, SELF_BINARY_TOKEN_RE, CONFIG_SUBCOMMAND_RE, PAUSE_FLAG_RE, ENV_ASSIGNMENT_RE, RUNNER_OPERAND_RE, PS_WEB_PIPE_RE, SHORT_FLAG_BUNDLE_RE, SAFE_FORCE_PREFIXES, SECRET_FILE_RE, SECRET_FILE_ID_RSA_RE, SECRET_FILE_CREDENTIALS_RE, GIT_COMMIT_MERGE_RE, FAILPROOFAI_CLI_RE, FAILPROOFAI_UNINSTALL_RE, GIT_AMEND_RE, GIT_STASH_DROP_RE, GIT_ADD_ALL_RE, NPM_GLOBAL_RE, YARN_GLOBAL_RE, PNPM_GLOBAL_RE, BUN_GLOBAL_RE, CARGO_INSTALL_RE, PIP_SYSTEM_RE, PKG_MANAGER_DETECTORS, NOHUP_RE, SCREEN_DETACH_RE, TMUX_DETACH_RE, DISOWN_RE, BACKGROUND_AMPERSAND_RE, KUBECTL_RE, TERRAFORM_RE, AWS_CLI_RE, GCLOUD_RE, AZ_CLI_RE, HELM_RE, GH_PIPELINE_RE, gitBranchCache, GIT_BRANCH_CACHE_MAX_ENTRIES = 500, EVAL_FLAG_RE, HOME_PREFIX_RE, RM_CMD_RE, FIND_CMD_RE, FIND_EXEC_RE, FIND_GLOBAL_OPT_RE, FIND_EXPR_START_RE, SCRATCH_ROOTS, CATASTROPHIC_DEPTH = 2, READ_LIKE_CMDS, TOOL_CALL_TRACKER_MAX_BYTES = 65536, SEGMENT_SPLIT_RE, BUILTIN_POLICIES;
 var init_builtin_policies = __esm(() => {
   init_hook_logger();
   isClaudeInternalPath = isAgentInternalPath;
@@ -1691,10 +1868,48 @@ var init_builtin_policies = __esm(() => {
   CMD_ECHO_ENV_RE = /echo\s+%[A-Za-z_]/i;
   ENV_FILE_PATH_RE = /(?:^|[\\/])\.env(?:\.|$)/;
   ENV_CMD_RE = /\.env(?:\b|\s|$|\.)/;
-  SUDO_RE = /(?:^|;|&&|\|\|)\s*sudo\s/;
   PS_ELEVATION_RE = /Start-Process\s+.*-Verb\s+RunAs/i;
   RUNAS_RE = /(?:^|;|&&|\|\|)\s*runas\s/i;
   CURL_PIPE_SH_RE = /(?:curl|wget)\s.*\|\s*(?:sh|bash|zsh|dash|ksh|csh|tcsh|fish|ash)\b/;
+  SEGMENT_SEPARATORS = /[;&|\n\r(){}`]+/;
+  COMMAND_PREFIX_TOKENS = new Set([
+    "npx",
+    "bunx",
+    "pnpx",
+    "npm",
+    "pnpm",
+    "yarn",
+    "dlx",
+    "exec",
+    "run",
+    "node",
+    "bun",
+    "deno",
+    "env",
+    "command",
+    "builtin",
+    "nohup",
+    "setsid",
+    "time",
+    "timeout",
+    "nice",
+    "stdbuf",
+    "xargs",
+    "sudo",
+    "doas",
+    "sh",
+    "bash",
+    "zsh",
+    "dash",
+    "ksh",
+    "fish",
+    "ash"
+  ]);
+  SELF_BINARY_TOKEN_RE = /(?:^|\/)failproofai[^/]*$/;
+  CONFIG_SUBCOMMAND_RE = /^(?:config|configure|setup)$/;
+  PAUSE_FLAG_RE = /^--pause(?:=|$)/;
+  ENV_ASSIGNMENT_RE = /^[A-Za-z_][A-Za-z0-9_]*=/;
+  RUNNER_OPERAND_RE = /^\d+[a-z]*$/i;
   PS_WEB_PIPE_RE = /(?:Invoke-WebRequest|iwr|Invoke-RestMethod|irm)\s+.*\|\s*(?:Invoke-Expression|iex)/i;
   SHORT_FLAG_BUNDLE_RE = /^-[a-zA-Z]*f[a-zA-Z]*$/;
   SAFE_FORCE_PREFIXES = ["--force-with-lease", "--force-if-includes"];
@@ -1738,6 +1953,7 @@ var init_builtin_policies = __esm(() => {
   HELM_RE = /(?:^|[;\n]|&&|\|\|?|&)\s*helm(?:\s|$)/;
   GH_PIPELINE_RE = /(?:^|[;\n]|&&|\|\|?|&)\s*gh\s+(?:workflow\s+(?:run|enable|disable)|run\s+(?:rerun|cancel)|pr\s+merge|release\s+(?:create|delete)|cache\s+delete|secret\s+(?:set|delete))\b/;
   gitBranchCache = new Map;
+  EVAL_FLAG_RE = /^-{1,2}c$/;
   HOME_PREFIX_RE = /^(?:~[A-Za-z0-9_.-]*|\$HOME|\$\{HOME\})(?=$|\/)/;
   RM_CMD_RE = /^(?:\/\S*\/)?rm$/;
   FIND_CMD_RE = /^(?:\/\S*\/)?find$/;
@@ -1842,6 +2058,16 @@ var init_builtin_policies = __esm(() => {
         }
       }
     },
+    {
+      name: "block-self-pause",
+      displayTitle: "Tried to pause failproofai enforcement",
+      impact: "An agent that can pause enforcement can switch off every other policy.",
+      description: "Block agents from pausing failproofai enforcement",
+      fn: blockSelfPause,
+      match: { events: ["PreToolUse", "PermissionRequest"], toolNames: ["Bash"] },
+      defaultEnabled: true,
+      category: "Dangerous Commands"
+    },
     {
       name: "block-sudo",
       displayTitle: "Tried to run a command with sudo",
@@ -2285,12 +2511,154 @@ var init_builtin_policies = __esm(() => {
 });
 
 // package.json
-var version = "1.0.0-beta.2";
+var version = "1.0.0-beta.21";
 var init_package = () => {};
 
 // src/posthog-key.ts
 var POSTHOG_API_KEY = "phc_Ac1Ww1GqKc0z1SyrRWbmatEeQdlOQIsDEEdP8l8JRgX", POSTHOG_PRODUCT = "failproofai-oss";
 
+// src/hooks/fp-config.ts
+import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, statSync as statSync4, writeFileSync as writeFileSync2 } from "node:fs";
+function detectLayout() {
+  const raw = readVersionFile();
+  if (raw) {
+    if (raw.layout === LAYOUT_VERSION)
+      return { kind: "current", version: raw };
+    return raw.layout > LAYOUT_VERSION ? { kind: "future", found: raw.layout } : { kind: "stale", found: raw.layout };
+  }
+  if (existsSync3(configFile())) {
+    return { kind: "current", version: { layout: LAYOUT_VERSION, cli: "" }, inferred: true };
+  }
+  if (existsSync3(legacy.configToml()))
+    return { kind: "stale", found: LAYOUT_VERSION - 1 };
+  const layoutOneMarkers = [
+    legacy.policyConfig(),
+    legacy.cacheDir(),
+    legacy.launcherMarker(),
+    legacy.lastVersion(),
+    legacy.cloudCredentials(),
+    legacy.ingestCredentials(),
+    legacy.auditDashboard()
+  ];
+  return layoutOneMarkers.some((p) => existsSync3(p)) ? { kind: "stale", found: 1 } : { kind: "absent" };
+}
+function readLegacyTomlVersion(text) {
+  const layout = Number(/^\s*layout\s*=\s*(\d+)\s*$/m.exec(text)?.[1]);
+  if (!Number.isFinite(layout))
+    return null;
+  const str = (key) => new RegExp(`^\\s*${key}\\s*=\\s*"([^"]*)"`, "m").exec(text)?.[1];
+  return { layout, cli: str("cli") ?? "", daemon: str("daemon") };
+}
+function readVersionFile() {
+  let text;
+  try {
+    text = readFileSync2(versionFile(), "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(text);
+    const layout = Number(parsed.layout);
+    if (!Number.isFinite(layout))
+      return null;
+    return {
+      layout,
+      cli: typeof parsed.cli === "string" ? parsed.cli : "",
+      daemon: typeof parsed.daemon === "string" ? parsed.daemon : undefined
+    };
+  } catch {
+    return readLegacyTomlVersion(text);
+  }
+}
+function readIntervalDays(raw) {
+  if (typeof raw !== "number" || !Number.isFinite(raw))
+    return DEFAULT_AUDIT_INTERVAL_DAYS;
+  const days = Math.floor(raw);
+  if (days < MIN_AUDIT_INTERVAL_DAYS)
+    return DEFAULT_AUDIT_INTERVAL_DAYS;
+  return Math.min(days, MAX_AUDIT_INTERVAL_DAYS);
+}
+function readSources(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return;
+  const out = {};
+  for (const [name, table] of Object.entries(raw)) {
+    if (!table || typeof table !== "object" || Array.isArray(table))
+      continue;
+    const entries = table.extra_paths;
+    if (!Array.isArray(entries))
+      continue;
+    const paths = entries.filter((e) => typeof e === "string" && e.trim() !== "");
+    if (paths.length > 0)
+      out[name] = { extraPaths: paths };
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+function readConfig() {
+  try {
+    const parsed = JSON.parse(readFileSync2(configFile(), "utf8"));
+    return projectConfig(parsed);
+  } catch {
+    return structuredClone(DEFAULT_CONFIG);
+  }
+}
+function projectConfig(parsed) {
+  {
+    const mode = parsed.mode?.kind;
+    const daemon = parsed.daemon ?? {};
+    const collector = parsed.collector ?? {};
+    const telemetry = parsed.telemetry ?? {};
+    const audit = parsed.audit ?? {};
+    return {
+      mode: mode === "cloud" ? "cloud" : "oss",
+      daemon: { configured: daemon.configured === true },
+      collector: {
+        sessions: collector.sessions === true,
+        hooks: collector.hooks !== false,
+        hooksVerbosity: collector.hooks_verbosity === "all" || collector.hooks_verbosity === "off" ? collector.hooks_verbosity : "decisions",
+        redact: collector.redact === "off" ? "off" : "minimal",
+        environment: typeof collector.environment === "string" ? collector.environment : "local",
+        machineId: typeof collector.machine_id === "string" ? collector.machine_id : undefined,
+        sources: readSources(collector.sources)
+      },
+      telemetry: { enabled: telemetry.enabled !== false },
+      audit: { auto: audit.auto === true, intervalDays: readIntervalDays(audit.interval_days) }
+    };
+  }
+}
+var DEFAULT_AUDIT_INTERVAL_DAYS = 7, MIN_AUDIT_INTERVAL_DAYS = 1, MAX_AUDIT_INTERVAL_DAYS = 90, DEFAULT_CONFIG;
+var init_fp_config = __esm(() => {
+  init_package();
+  init_fp_home();
+  DEFAULT_CONFIG = {
+    mode: "oss",
+    daemon: { configured: false },
+    collector: {
+      sessions: false,
+      hooks: true,
+      hooksVerbosity: "decisions",
+      redact: "minimal",
+      environment: "local"
+    },
+    telemetry: { enabled: true },
+    audit: { auto: false, intervalDays: DEFAULT_AUDIT_INTERVAL_DAYS }
+  };
+});
+
+// lib/telemetry-enabled.ts
+function isTelemetryEnabled() {
+  if (process.env.FAILPROOFAI_TELEMETRY_DISABLED === "1")
+    return false;
+  try {
+    return readConfig().telemetry.enabled;
+  } catch {
+    return true;
+  }
+}
+var init_telemetry_enabled = __esm(() => {
+  init_fp_config();
+});
+
 // src/hooks/hook-telemetry.ts
 async function sendEvent(distinctId, event, properties) {
   const body = JSON.stringify({
@@ -2309,7 +2677,7 @@ async function sendEvent(distinctId, event, properties) {
   } catch {}
 }
 async function trackHookEvent(distinctId, event, properties) {
-  if (process.env.FAILPROOFAI_TELEMETRY_DISABLED === "1")
+  if (!isTelemetryEnabled())
     return;
   const p = sendEvent(distinctId, event, properties);
   pending.add(p);
@@ -2324,6 +2692,7 @@ async function flushHookTelemetry() {
 var API_KEY, CAPTURE_URL = "https://us.i.posthog.com/capture/", pending;
 var init_hook_telemetry = __esm(() => {
   init_package();
+  init_telemetry_enabled();
   API_KEY = POSTHOG_API_KEY;
   pending = new Set;
 });
@@ -2387,24 +2756,48 @@ function getFileBasedId() {
   } catch {}
   return id;
 }
+function publishInstanceId(id) {
+  let target;
+  try {
+    target = telemetryIdFile();
+    if (fs.readFileSync(target, "utf-8").trim() === id)
+      return;
+  } catch {
+    try {
+      target = telemetryIdFile();
+    } catch {
+      return;
+    }
+  }
+  try {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    const tmp = `${target}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, id, { encoding: "utf-8", mode: 384 });
+    fs.renameSync(tmp, target);
+  } catch {}
+}
 function getInstanceId() {
   if (cachedId)
     return cachedId;
   const machineId = getPlatformMachineId();
   if (machineId) {
     cachedId = hashToId(machineId);
+    publishInstanceId(cachedId);
     return cachedId;
   }
   const sysProps = getSystemPropertiesId();
   if (sysProps) {
     cachedId = hashToId(sysProps);
+    publishInstanceId(cachedId);
     return cachedId;
   }
   cachedId = getFileBasedId();
+  publishInstanceId(cachedId);
   return cachedId;
 }
 var NAMESPACE = "failproofai-telemetry-v1", ID_DIR, ID_FILE, cachedId;
 var init_telemetry_id = __esm(() => {
+  init_fp_home();
   ID_DIR = path.join(os.homedir(), ".failproofai");
   ID_FILE = path.join(ID_DIR, "instance-id");
 });
@@ -3158,13 +3551,43 @@ function clearCustomHooks() {
   const g = globalThis;
   g[REGISTRY_KEY2] = [];
 }
-var REGISTRY_KEY2 = "__failproofai_custom_hooks__";
-var init_custom_hooks_registry = () => {};
+var REGISTRY_KEY2 = "__failproofai_custom_hooks__", customPolicies;
+var init_custom_hooks_registry = __esm(() => {
+  customPolicies = {
+    add(hook) {
+      getRegistry2().push(hook);
+    }
+  };
+});
 
 // src/hooks/loader-utils.ts
-import { readFile as readFile2, writeFile as writeFile2, unlink, access } from "fs/promises";
-import { resolve as resolve3, dirname as dirname2, relative } from "path";
+import { readFile as readFile2, writeFile as writeFile2, unlink, access, mkdir, lstat } from "fs/promises";
+import { tmpdir } from "os";
+import { resolve as resolve4, dirname as dirname2, relative, join as join3 } from "path";
 import { pathToFileURL } from "url";
+import { createHash } from "crypto";
+function isTmpArtifact(name) {
+  return TMP_ARTIFACT_RE.test(name);
+}
+async function sweepStaleTmpArtifacts(dir, now = Date.now()) {
+  let removed = 0;
+  try {
+    const { readdir, stat } = await import("fs/promises");
+    for (const name of await readdir(dir)) {
+      if (!isTmpArtifact(name))
+        continue;
+      const path2 = resolve4(dir, name);
+      try {
+        const info = await stat(path2);
+        if (now - info.mtimeMs < TMP_SWEEP_MIN_AGE_MS)
+          continue;
+        await unlink(path2);
+        removed++;
+      } catch {}
+    }
+  } catch {}
+  return removed;
+}
 async function fileExists(path2) {
   try {
     await access(path2);
@@ -3176,14 +3599,14 @@ async function fileExists(path2) {
 async function findDistIndex() {
   const distPath = process.env.FAILPROOFAI_DIST_PATH;
   if (distPath) {
-    const candidate = resolve3(distPath, "index.js");
+    const candidate = resolve4(distPath, "index.js");
     if (await fileExists(candidate))
       return candidate;
   }
   const candidates = [
-    resolve3(dirname2(process.execPath), "..", "assets", "dist", "index.js"),
-    resolve3(process.cwd(), "dist", "index.js"),
-    resolve3(process.cwd(), "node_modules", "failproofai", "dist", "index.js")
+    resolve4(dirname2(process.execPath), "..", "assets", "dist", "index.js"),
+    resolve4(process.cwd(), "dist", "index.js"),
+    resolve4(process.cwd(), "node_modules", "failproofai", "dist", "index.js")
   ];
   for (const c of candidates) {
     if (await fileExists(c))
@@ -3192,16 +3615,24 @@ async function findDistIndex() {
   return null;
 }
 async function resolveLocalImport(fromDir, specifier) {
-  const base = resolve3(fromDir, specifier);
-  const candidates = [base, `${base}.js`, `${base}.mjs`, `${base}.ts`, resolve3(base, "index.js")];
+  const base = resolve4(fromDir, specifier);
+  const candidates = [base, `${base}.js`, `${base}.mjs`, `${base}.ts`, resolve4(base, "index.js")];
   for (const c of candidates) {
     if (await fileExists(c))
       return c;
   }
   return null;
 }
-async function createEsmShim(distIndex, distUrl) {
-  const shimPath = distIndex + ".__failproofai_esm_shim__.mjs";
+async function writeShim(dir, name, code, exclusive) {
+  const shimPath = join3(dir, name);
+  await writeFile2(shimPath, code, {
+    encoding: "utf-8",
+    mode: 384,
+    ...exclusive ? { flag: "wx" } : {}
+  });
+  return shimPath;
+}
+async function createEsmShim(_distIndex, distUrl, tmpSuffix = TMP_SUFFIX) {
   const shimCode = [
     `import _cjs from '${distUrl}';`,
     `export const customPolicies = _cjs.customPolicies;`,
@@ -3213,16 +3644,30 @@ async function createEsmShim(distIndex, distUrl) {
     `export default _cjs;`
   ].join(`
 `);
-  await writeFile2(shimPath, shimCode, "utf-8");
+  const name = `failproofai-dist${tmpSuffix}.shim.mjs`;
+  try {
+    const dir = shimsDir();
+    await mkdir(dir, { recursive: true, mode: 448 });
+    const st = await lstat(dir);
+    const uid = typeof process.getuid === "function" ? process.getuid() : null;
+    if (!st.isDirectory() || st.isSymbolicLink() || uid !== null && st.uid !== uid || st.mode & 63) {
+      throw new Error(`${dir} is not a private directory owned by this user`);
+    }
+    const shimPath2 = await writeShim(dir, name, shimCode, false);
+    return { shimPath: shimPath2, shimUrl: pathToFileURL(shimPath2).href };
+  } catch (err) {
+    hookLogWarn(`policy shim directory unusable (${err instanceof Error ? err.message : String(err)}); falling back to ${tmpdir()}`);
+  }
+  const shimPath = await writeShim(tmpdir(), name, shimCode, true);
   return { shimPath, shimUrl: pathToFileURL(shimPath).href };
 }
-async function rewriteFileTree(entryPath, distUrl, distIndex) {
+async function rewriteFileTree(entryPath, distUrl, distIndex, tmpSuffix = TMP_SUFFIX, entrySha256) {
   const queue = [entryPath];
   const visited = new Set;
   const tmpFiles = [];
   let esmShimUrl = null;
   if (distIndex && distUrl) {
-    const shim = await createEsmShim(distIndex, distUrl);
+    const shim = await createEsmShim(distIndex, distUrl, tmpSuffix);
     tmpFiles.push(shim.shimPath);
     esmShimUrl = shim.shimUrl;
   }
@@ -3231,7 +3676,17 @@ async function rewriteFileTree(entryPath, distUrl, distIndex) {
     if (visited.has(filePath))
       continue;
     visited.add(filePath);
-    let code = await readFile2(filePath, "utf-8");
+    let code;
+    if (entrySha256 && filePath === entryPath) {
+      const buf = await readFile2(filePath);
+      const actual = createHash("sha256").update(buf).digest("hex");
+      if (actual !== entrySha256) {
+        throw new Error(`cloud-managed policy failed integrity re-verification at load: expected ${entrySha256}, got ${actual}`);
+      }
+      code = buf.toString("utf-8");
+    } else {
+      code = await readFile2(filePath, "utf-8");
+    }
     if (esmShimUrl) {
       code = code.replace(/from\s+(['"])(?:claudeye|failproofai)\1/g, `from '${esmShimUrl}'`);
     }
@@ -3253,7 +3708,7 @@ async function rewriteFileTree(entryPath, distUrl, distIndex) {
         if (!visited.has(resolved2) && !queue.includes(resolved2)) {
           queue.push(resolved2);
         }
-        let relPath = relative(dir, resolved2 + TMP_SUFFIX).split("\\").join("/");
+        let relPath = relative(dir, resolved2 + tmpSuffix).split("\\").join("/");
         if (!relPath.startsWith("."))
           relPath = "./" + relPath;
         rewrites.set(specifier, relPath);
@@ -3266,7 +3721,7 @@ async function rewriteFileTree(entryPath, distUrl, distIndex) {
       code = code.replace(new RegExp(`'${escaped}'`, "g"), `'${replacement}'`);
       code = code.replace(new RegExp(`"${escaped}"`, "g"), `"${replacement}"`);
     }
-    const tmpPath = filePath + TMP_SUFFIX;
+    const tmpPath = filePath + tmpSuffix;
     await writeFile2(tmpPath, code, "utf-8");
     tmpFiles.push(tmpPath);
   }
@@ -3279,36 +3734,61 @@ async function cleanupTmpFiles(tmpFiles) {
     } catch {}
   }
 }
-var TMP_SUFFIX = ".__failproofai_tmp__.mjs", LOCAL_IMPORT_RE, LOCAL_REQUIRE_RE;
+var TMP_SUFFIX = ".__failproofai_tmp__.mjs", TMP_ARTIFACT_RE, TMP_SWEEP_MIN_AGE_MS = 60000, LOCAL_IMPORT_RE, LOCAL_REQUIRE_RE;
 var init_loader_utils = __esm(() => {
+  init_fp_home();
+  init_hook_logger();
+  TMP_ARTIFACT_RE = /\.__failproofai_tmp__\./;
   LOCAL_IMPORT_RE = /(?:import\s+(?:[\s\S]*?\s+from\s+)?|export\s+(?:[\s\S]*?\s+from\s+))(['"])(\.\.?\/[^'"]+)\1/g;
   LOCAL_REQUIRE_RE = /require\s*\(\s*(['"])(\.\.?\/[^'"]+)\1\s*\)/g;
 });
 
 // src/hooks/custom-hooks-loader.ts
-import { resolve as resolve4, isAbsolute, basename } from "node:path";
-import { existsSync as existsSync3, readdirSync } from "node:fs";
+import { resolve as resolve5, isAbsolute, basename } from "node:path";
+import { randomUUID } from "crypto";
+import { existsSync as existsSync4, readdirSync } from "node:fs";
+import { readFile as readFile3 } from "node:fs/promises";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
-import { homedir as homedir4 } from "node:os";
+import { createHash as createHash2 } from "node:crypto";
 function discoverPolicyFiles(dir) {
-  if (!existsSync3(dir))
+  if (!existsSync4(dir))
     return [];
   try {
     const entries = readdirSync(dir, { withFileTypes: true });
-    return entries.filter((e) => e.isFile() && CONVENTION_FILE_RE.test(e.name)).sort((a, b) => a.name.localeCompare(b.name)).map((e) => resolve4(dir, e.name));
+    return entries.filter((e) => e.isFile() && CONVENTION_FILE_RE.test(e.name)).sort((a, b) => a.name.localeCompare(b.name)).map((e) => resolve5(dir, e.name));
   } catch {
     return [];
   }
 }
 function findSkippedPolicyFiles(dir) {
-  if (!existsSync3(dir))
+  if (!existsSync4(dir))
     return [];
   try {
-    return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && LOADABLE_EXT_RE.test(e.name) && !CONVENTION_FILE_RE.test(e.name) && !e.name.endsWith(".d.ts")).map((e) => e.name).sort((a, b) => a.localeCompare(b));
+    return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && LOADABLE_EXT_RE.test(e.name) && !CONVENTION_FILE_RE.test(e.name) && !e.name.endsWith(".d.ts") && !isTmpArtifact(e.name)).map((e) => e.name).sort((a, b) => a.localeCompare(b));
   } catch {
     return [];
   }
 }
+function moduleLoadTimeoutMs() {
+  const override = Number(process.env.FAILPROOFAI_POLICY_LOAD_TIMEOUT_MS);
+  return Number.isFinite(override) && override > 0 ? override : 1e4;
+}
+async function importWithDeadline(fileUrl) {
+  const budget = moduleLoadTimeoutMs();
+  let timer;
+  try {
+    await Promise.race([
+      import(fileUrl),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`timed out loading module after ${budget}ms`)), budget);
+        timer.unref?.();
+      })
+    ]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
 async function loadSingleFile(absPath, opts) {
   const g = globalThis;
   g[LOADING_KEY] = true;
@@ -3316,13 +3796,29 @@ async function loadSingleFile(absPath, opts) {
   try {
     const distIndex = await findDistIndex();
     const distUrl = distIndex ? pathToFileURL2(distIndex).href : null;
-    tmpFiles = await rewriteFileTree(absPath, distUrl, distIndex);
-    const entryTmp = absPath + TMP_SUFFIX;
-    const fileUrl = `${pathToFileURL2(entryTmp).href}?v=${++loadSequence}`;
-    await import(fileUrl);
+    const sequence = ++loadSequence;
+    const tmpSuffix = `${TMP_SUFFIX}.${process.pid}.${sequence}.${randomUUID()}.mjs`;
+    tmpFiles = await rewriteFileTree(absPath, distUrl, distIndex, tmpSuffix, opts?.verifyEntrySha);
+    const fingerprint = await fingerprintTemporaryTree(tmpFiles, tmpSuffix);
+    const cached = policyModuleCache.get(absPath);
+    if (cached?.fingerprint === fingerprint) {
+      for (const hook of cached.hooks)
+        customPolicies.add({ ...hook });
+      return;
+    }
+    const entryTmp = absPath + tmpSuffix;
+    const fileUrl = pathToFileURL2(entryTmp).href;
+    const hooksBefore = getCustomHooks().length;
+    await importWithDeadline(fileUrl);
+    if (policyModuleCache.size >= POLICY_MODULE_CACHE_MAX_ENTRIES)
+      policyModuleCache.clear();
+    policyModuleCache.set(absPath, {
+      fingerprint,
+      hooks: getCustomHooks().slice(hooksBefore).map((hook) => ({ ...hook }))
+    });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    const errorType = /Cannot find module|MODULE_NOT_FOUND|ENOENT/i.test(msg) ? "module_not_found" : /SyntaxError|Unexpected token/i.test(msg) ? "syntax_error" : "runtime_error";
+    const errorType = /Cannot find module|MODULE_NOT_FOUND|ENOENT/i.test(msg) ? "module_not_found" : /SyntaxError|Unexpected token/i.test(msg) ? "syntax_error" : /timed out loading module/i.test(msg) ? "load_timeout" : "runtime_error";
     trackHookEvent(getInstanceId(), "custom_hooks_load_error", {
       error_type: errorType,
       is_convention: !!opts?.conventionScope,
@@ -3337,6 +3833,15 @@ async function loadSingleFile(absPath, opts) {
     await cleanupTmpFiles(tmpFiles);
   }
 }
+async function fingerprintTemporaryTree(tmpFiles, tmpSuffix) {
+  const hash = createHash2("sha256");
+  for (const tmpFile of [...tmpFiles].sort()) {
+    hash.update(tmpFile.replaceAll(tmpSuffix, TMP_SUFFIX));
+    const contents = await readFile3(tmpFile, "utf8");
+    hash.update(contents.replaceAll(tmpSuffix, TMP_SUFFIX));
+  }
+  return hash.digest("hex");
+}
 function customPolicyId(file, name) {
   return `custom:${file}:${name}`;
 }
@@ -3356,15 +3861,37 @@ async function loadAllCustomHooks(customPoliciesPaths, opts) {
   const projectRoot = findProjectConfigDir(opts?.sessionCwd ?? process.cwd());
   const conventionEnabled = opts?.customPoliciesEnabled !== false;
   const loadedPaths = new Set;
+  const cloudManagedByPath = new Map;
+  for (const policy of opts?.cloudManagedPolicies ?? []) {
+    const key = resolve5(policy.path);
+    const existing = cloudManagedByPath.get(key);
+    if (!existing) {
+      cloudManagedByPath.set(key, policy);
+      continue;
+    }
+    hookLogWarn(`cloud-managed policies ${existing.id} and ${policy.id} have identical source, so they share ` + `one artifact and load as one policy; enforcing it if either asks to enforce`);
+    if (existing.effect !== "enforce" && policy.effect === "enforce") {
+      cloudManagedByPath.set(key, policy);
+    }
+  }
   for (const customPoliciesPath of typeof customPoliciesPaths === "string" ? [customPoliciesPaths] : customPoliciesPaths ?? []) {
-    const absPath = resolve4(projectRoot, customPoliciesPath);
-    if (existsSync3(absPath)) {
+    const absPath = resolve5(projectRoot, customPoliciesPath);
+    if (existsSync4(absPath)) {
       if (!loadedPaths.has(absPath)) {
         loadedPaths.add(absPath);
         const hooksBefore = getCustomHooks().length;
-        await loadSingleFile(absPath);
+        await loadSingleFile(absPath, {
+          verifyEntrySha: cloudManagedByPath.get(absPath)?.sha256
+        });
         for (const hook of getCustomHooks().slice(hooksBefore)) {
-          hook.__policyId = customPolicyId(absPath, hook.name);
+          const cloudManaged = cloudManagedByPath.get(absPath);
+          const tagged = hook;
+          if (cloudManaged) {
+            tagged.__cloudManaged = cloudManaged;
+            tagged.__policyId = `cloud:${cloudManaged.id}@${cloudManaged.version}:${hook.name}`;
+          } else {
+            tagged.__policyId = customPolicyId(absPath, hook.name);
+          }
         }
       }
     } else {
@@ -3372,29 +3899,35 @@ async function loadAllCustomHooks(customPoliciesPaths, opts) {
     }
   }
   const hooksBeforeConvention = getCustomHooks().length;
-  const projectDir = resolve4(projectRoot, ".failproofai", "policies");
-  if (conventionEnabled)
-    warnSkippedPolicyFiles(projectDir, "project");
+  const projectDir = resolve5(projectRoot, ".failproofai", "policies");
+  const projectScope = projectDir === customPoliciesDir() ? "user" : "project";
+  if (conventionEnabled) {
+    sweepStaleTmpArtifacts(projectDir);
+    warnSkippedPolicyFiles(projectDir, projectScope);
+  }
+  sweepStaleTmpArtifacts(shimsDir());
   const projectFiles = conventionEnabled ? discoverPolicyFiles(projectDir).filter((f) => !loadedPaths.has(f)) : [];
   for (const file of projectFiles) {
     loadedPaths.add(file);
     const hooksBefore = getCustomHooks().length;
-    await loadSingleFile(file, { conventionScope: "project" });
+    await loadSingleFile(file, { conventionScope: projectScope });
     const newHooks = getCustomHooks().slice(hooksBefore);
     for (const hook of newHooks) {
-      hook.__policyId = conventionPolicyId("project", basename(file), hook.name);
+      hook.__policyId = conventionPolicyId(projectScope, basename(file), hook.name);
     }
     if (newHooks.length > 0) {
       conventionSources.push({
-        scope: "project",
+        scope: projectScope,
         file: basename(file),
         hookNames: newHooks.map((h) => h.name)
       });
     }
   }
-  const userDir = resolve4(homedir4(), ".failproofai", "policies");
-  if (conventionEnabled && userDir !== projectDir)
+  const userDir = customPoliciesDir();
+  if (conventionEnabled && userDir !== projectDir) {
+    sweepStaleTmpArtifacts(userDir);
     warnSkippedPolicyFiles(userDir, "user");
+  }
   const userFiles = conventionEnabled && userDir !== projectDir ? discoverPolicyFiles(userDir).filter((f) => !loadedPaths.has(f)) : [];
   for (const file of userFiles) {
     loadedPaths.add(file);
@@ -3436,7 +3969,7 @@ async function loadAllCustomHooks(customPoliciesPaths, opts) {
   }
   return { hooks: allHooks, conventionSources };
 }
-var LOADING_KEY = "__FAILPROOFAI_LOADING_HOOKS__", CONVENTION_FILE_RE, loadSequence = 0, LOADABLE_EXT_RE;
+var LOADING_KEY = "__FAILPROOFAI_LOADING_HOOKS__", CONVENTION_FILE_RE, loadSequence = 0, policyModuleCache, POLICY_MODULE_CACHE_MAX_ENTRIES = 500, LOADABLE_EXT_RE;
 var init_custom_hooks_loader = __esm(() => {
   init_hook_logger();
   init_custom_hooks_registry();
@@ -3444,44 +3977,45 @@ var init_custom_hooks_loader = __esm(() => {
   init_hooks_config();
   init_hook_telemetry();
   init_telemetry_id();
+  init_fp_home();
   CONVENTION_FILE_RE = /policies\.(js|mjs|ts)$/;
+  policyModuleCache = new Map;
   LOADABLE_EXT_RE = /\.(js|mjs|ts)$/;
 });
 
 // src/hooks/hook-activity-store.ts
 import {
-  readFileSync as readFileSync2,
-  writeFileSync as writeFileSync2,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync3,
   appendFileSync as appendFileSync2,
   renameSync as renameSync2,
   readdirSync as readdirSync2,
-  mkdirSync as mkdirSync3,
-  existsSync as existsSync4,
-  statSync as statSync4,
+  mkdirSync as mkdirSync4,
+  existsSync as existsSync5,
+  statSync as statSync5,
   unlinkSync
 } from "node:fs";
-import { join as join3 } from "node:path";
-import { homedir as homedir5 } from "node:os";
+import { join as join4 } from "node:path";
 function ensureDir() {
-  if (!existsSync4(storeDir)) {
-    mkdirSync3(storeDir, { recursive: true });
+  if (!existsSync5(storeDirValue())) {
+    mkdirSync4(storeDirValue(), { recursive: true });
   }
 }
 function acquireLock() {
   ensureDir();
-  const lockPath = join3(storeDir, LOCK_FILE);
+  const lockPath = join4(storeDirValue(), LOCK_FILE);
   const deadline = Date.now() + LOCK_STALE_MS;
   while (Date.now() < deadline) {
     try {
-      writeFileSync2(lockPath, String(process.pid), { flag: "wx" });
+      writeFileSync3(lockPath, String(process.pid), { flag: "wx" });
       return;
     } catch (e) {
       if (e.code !== "EEXIST")
         return;
       try {
-        const s = statSync4(lockPath);
+        const s = statSync5(lockPath);
         if (Date.now() - s.mtimeMs > LOCK_STALE_MS) {
-          writeFileSync2(lockPath, String(process.pid), "utf-8");
+          writeFileSync3(lockPath, String(process.pid), "utf-8");
           return;
         }
       } catch {}
@@ -3490,15 +4024,15 @@ function acquireLock() {
 }
 function releaseLock() {
   try {
-    unlinkSync(join3(storeDir, LOCK_FILE));
+    unlinkSync(join4(storeDirValue(), LOCK_FILE));
   } catch {}
 }
 function persistHookActivity(entry) {
   ensureDir();
   acquireLock();
   try {
-    const currentPath = join3(storeDir, CURRENT_FILE);
-    const countPath = join3(storeDir, COUNT_FILE);
+    const currentPath = join4(storeDirValue(), CURRENT_FILE);
+    const countPath = join4(storeDirValue(), COUNT_FILE);
     const lineCount = readCount(countPath);
     if (lineCount >= PAGE_SIZE) {
       try {
@@ -3518,13 +4052,13 @@ function persistHookActivity(entry) {
 }
 function rotate(currentPath, countPath) {
   const archiveName = `page-${Date.now()}-${rotateSeq++}.jsonl`;
-  const archivePath = join3(storeDir, archiveName);
+  const archivePath = join4(storeDirValue(), archiveName);
   renameSync2(currentPath, archivePath);
   writeCount(countPath, 0);
 }
 function readCount(countPath) {
   try {
-    const n = parseInt(readFileSync2(countPath, "utf-8"), 10);
+    const n = parseInt(readFileSync3(countPath, "utf-8"), 10);
     return isNaN(n) ? 0 : n;
   } catch {
     return 0;
@@ -3532,18 +4066,17 @@ function readCount(countPath) {
 }
 function writeCount(countPath, n) {
   try {
-    writeFileSync2(countPath, String(n), "utf-8");
+    writeFileSync3(countPath, String(n), "utf-8");
   } catch {}
 }
 function readStoredStats() {
   try {
-    return JSON.parse(readFileSync2(join3(storeDir, STATS_FILE), "utf-8"));
+    return JSON.parse(readFileSync3(join4(storeDirValue(), STATS_FILE), "utf-8"));
   } catch {
     return { totalEvents: 0, denyCount: 0, policyMap: {} };
   }
 }
-function updateStats(entry) {
-  const s = readStoredStats();
+function foldEntry(s, entry) {
   s.totalEvents += 1;
   if (entry.decision === "deny")
     s.denyCount += 1;
@@ -3554,20 +4087,28 @@ function updateStats(entry) {
   } else if (entry.policyName) {
     s.policyMap[entry.policyName] = (s.policyMap[entry.policyName] ?? 0) + 1;
   }
-  const tmpPath = join3(storeDir, `stats.json.${process.pid}.tmp`);
+}
+function writeStoredStats(s) {
+  const tmpPath = join4(storeDirValue(), `stats.json.${process.pid}.tmp`);
   try {
-    writeFileSync2(tmpPath, JSON.stringify(s), "utf-8");
-    renameSync2(tmpPath, join3(storeDir, STATS_FILE));
+    writeFileSync3(tmpPath, JSON.stringify(s), "utf-8");
+    renameSync2(tmpPath, join4(storeDirValue(), STATS_FILE));
+    return true;
   } catch {
     try {
       unlinkSync(tmpPath);
     } catch {}
+    return false;
   }
 }
-var PAGE_SIZE = 25, DEFAULT_STORE_DIR, CURRENT_FILE = "current.jsonl", COUNT_FILE = "current.count", STATS_FILE = "stats.json", LOCK_FILE = "current.lock", LOCK_STALE_MS = 2000, storeDir, rotateSeq = 0;
+function updateStats(entry) {
+  const s = readStoredStats();
+  foldEntry(s, entry);
+  writeStoredStats(s);
+}
+var PAGE_SIZE = 25, defaultStoreDir = () => hookActivityDir(), CURRENT_FILE = "current.jsonl", COUNT_FILE = "current.count", STATS_FILE = "stats.json", LOCK_FILE = "current.lock", LOCK_STALE_MS = 2000, storeDirOverride = null, storeDirValue = () => storeDirOverride ?? defaultStoreDir(), rotateSeq = 0;
 var init_hook_activity_store = __esm(() => {
-  DEFAULT_STORE_DIR = join3(homedir5(), ".failproofai", "cache", "hook-activity");
-  storeDir = DEFAULT_STORE_DIR;
+  init_fp_home();
 });
 
 // src/hooks/resolve-cwd.ts
@@ -3616,10 +4157,10 @@ function runtimeCache(fn, revalidateSeconds, options) {
 }
 
 // lib/paths.ts
-import { homedir as homedir6 } from "os";
-import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join5 } from "path";
 function getDefaultClaudeProjectsPath() {
-  return join4(homedir6(), ".claude", "projects");
+  return join5(homedir4(), ".claude", "projects");
 }
 function decodeFolderName(name) {
   if (/^[A-Za-z]--/.test(name)) {
@@ -3712,9 +4253,9 @@ __export(exports_codex_projects, {
   getCachedCodexSessionsByEncodedName: () => getCachedCodexSessionsByEncodedName,
   getCachedCodexProjects: () => getCachedCodexProjects
 });
-import { open as open2, readdir } from "node:fs/promises";
-import { homedir as homedir7 } from "node:os";
-import { join as join5 } from "node:path";
+import { open, readdir } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { join as join6 } from "node:path";
 async function safeReaddir(dir) {
   try {
     return await readdir(dir, { withFileTypes: true });
@@ -3725,7 +4266,7 @@ async function safeReaddir(dir) {
 async function readFirstLine(filePath) {
   let fh = null;
   try {
-    fh = await open2(filePath, "r");
+    fh = await open(filePath, "r");
     const buf = Buffer.alloc(FIRST_LINE_CHUNK_BYTES);
     const { bytesRead } = await fh.read(buf, 0, FIRST_LINE_CHUNK_BYTES, 0);
     if (bytesRead === 0)
@@ -3762,7 +4303,7 @@ async function listJsonlFiles(dir) {
   const entries = await safeReaddir(dir);
   if (!entries)
     return [];
-  return entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => join5(dir, e.name));
+  return entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => join6(dir, e.name));
 }
 async function scanCodexSessions() {
   const yearDirs = await safeReaddir(CODEX_SESSIONS_ROOT);
@@ -3772,19 +4313,19 @@ async function scanCodexSessions() {
   for (const y of yearDirs) {
     if (!y.isDirectory())
       continue;
-    const monthDirs = await safeReaddir(join5(CODEX_SESSIONS_ROOT, y.name));
+    const monthDirs = await safeReaddir(join6(CODEX_SESSIONS_ROOT, y.name));
     if (!monthDirs)
       continue;
     for (const m of monthDirs) {
       if (!m.isDirectory())
         continue;
-      const dayDirs = await safeReaddir(join5(CODEX_SESSIONS_ROOT, y.name, m.name));
+      const dayDirs = await safeReaddir(join6(CODEX_SESSIONS_ROOT, y.name, m.name));
       if (!dayDirs)
         continue;
       for (const d of dayDirs) {
         if (!d.isDirectory())
           continue;
-        const dayPath = join5(CODEX_SESSIONS_ROOT, y.name, m.name, d.name);
+        const dayPath = join6(CODEX_SESSIONS_ROOT, y.name, m.name, d.name);
         filePaths.push(...await listJsonlFiles(dayPath));
       }
     }
@@ -3803,10 +4344,10 @@ async function scanCodexSessions() {
       return null;
     let fileMtime;
     try {
-      const fh = await open2(filePath, "r");
+      const fh = await open(filePath, "r");
       try {
-        const stat2 = await fh.stat();
-        fileMtime = stat2.mtime;
+        const stat = await fh.stat();
+        fileMtime = stat.mtime;
       } finally {
         await fh.close().catch(() => {});
       }
@@ -3892,7 +4433,7 @@ var CODEX_SESSIONS_ROOT, SESSION_ID_RE, FIRST_LINE_CHUNK_BYTES, cachedScan, getC
 var init_codex_projects = __esm(() => {
   init_paths();
   init_logger();
-  CODEX_SESSIONS_ROOT = join5(homedir7(), ".codex", "sessions");
+  CODEX_SESSIONS_ROOT = join6(homedir5(), ".codex", "sessions");
   SESSION_ID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
   FIRST_LINE_CHUNK_BYTES = 256 * 1024;
   cachedScan = runtimeCache(scanCodexSessions, 30);
@@ -3911,11 +4452,11 @@ __export(exports_copilot_projects, {
   getCachedCopilotSessionsByEncodedName: () => getCachedCopilotSessionsByEncodedName,
   getCachedCopilotProjects: () => getCachedCopilotProjects
 });
-import { readdir as readdir2, readFile as readFile3, stat as stat2 } from "node:fs/promises";
-import { homedir as homedir8 } from "node:os";
-import { join as join6 } from "node:path";
+import { readdir as readdir2, readFile as readFile4, stat } from "node:fs/promises";
+import { homedir as homedir6 } from "node:os";
+import { join as join7 } from "node:path";
 function getCopilotSessionStateRoot() {
-  return join6(process.env.COPILOT_HOME || join6(homedir8(), ".copilot"), "session-state");
+  return join7(process.env.COPILOT_HOME || join7(homedir6(), ".copilot"), "session-state");
 }
 async function safeReaddir2(dir) {
   try {
@@ -3932,7 +4473,7 @@ function parseCwdFromWorkspace(text) {
 }
 async function statMtime(path2) {
   try {
-    return (await stat2(path2)).mtime;
+    return (await stat(path2)).mtime;
   } catch {
     return null;
   }
@@ -3944,13 +4485,13 @@ async function scanCopilotSessions() {
     return [];
   const candidates = entries.filter((e) => e.isDirectory()).map((e) => ({
     sessionId: e.name,
-    workspacePath: join6(root, e.name, "workspace.yaml"),
-    eventsPath: join6(root, e.name, "events.jsonl")
+    workspacePath: join7(root, e.name, "workspace.yaml"),
+    eventsPath: join7(root, e.name, "events.jsonl")
   }));
   const settled = await batchAll(candidates.map((c) => async () => {
     let workspaceText;
     try {
-      workspaceText = await readFile3(c.workspacePath, "utf-8");
+      workspaceText = await readFile4(c.workspacePath, "utf-8");
     } catch {
       return null;
     }
@@ -4059,11 +4600,11 @@ __export(exports_cursor_projects, {
   getCachedCursorSessionsByEncodedName: () => getCachedCursorSessionsByEncodedName,
   getCachedCursorProjects: () => getCachedCursorProjects
 });
-import { readdir as readdir3, readFile as readFile4, stat as stat3 } from "node:fs/promises";
-import { homedir as homedir9 } from "node:os";
-import { join as join7 } from "node:path";
+import { readdir as readdir3, readFile as readFile5, stat as stat2 } from "node:fs/promises";
+import { homedir as homedir7 } from "node:os";
+import { join as join8 } from "node:path";
 function getCursorHome() {
-  return process.env.CURSOR_HOME || join7(homedir9(), ".cursor");
+  return process.env.CURSOR_HOME || join8(homedir7(), ".cursor");
 }
 async function safeReaddir3(dir) {
   try {
@@ -4074,7 +4615,7 @@ async function safeReaddir3(dir) {
 }
 async function statMtime2(path2) {
   try {
-    return (await stat3(path2)).mtime;
+    return (await stat2(path2)).mtime;
   } catch {
     return null;
   }
@@ -4095,12 +4636,12 @@ function parseCwdFromMetaText(text) {
 }
 async function findFirstUsableMeta(dir, candidates) {
   for (const name of candidates) {
-    const path2 = join7(dir, name);
+    const path2 = join8(dir, name);
     if (await statMtime2(path2) === null)
       continue;
     let text;
     try {
-      text = await readFile4(path2, "utf-8");
+      text = await readFile5(path2, "utf-8");
     } catch {
       continue;
     }
@@ -4112,7 +4653,7 @@ async function findFirstUsableMeta(dir, candidates) {
 }
 async function findFirstExistingPath(dir, candidates) {
   for (const name of candidates) {
-    const path2 = join7(dir, name);
+    const path2 = join8(dir, name);
     if (await statMtime2(path2) !== null)
       return path2;
   }
@@ -4122,7 +4663,7 @@ async function scanCursorSessions() {
   const home = getCursorHome();
   const newCandidates = [];
   const legacyCandidates = [];
-  const projectsRoot = join7(home, NEW_PROJECTS_DIR);
+  const projectsRoot = join8(home, NEW_PROJECTS_DIR);
   const projectEntries = await safeReaddir3(projectsRoot);
   if (projectEntries) {
     for (const proj of projectEntries) {
@@ -4130,7 +4671,7 @@ async function scanCursorSessions() {
         continue;
       const decoded = decodeFolderName(proj.name);
       const cwd = decoded.startsWith("/") || /^[A-Za-z]:\//.test(decoded) ? decoded : `/${decoded}`;
-      const transcriptsRoot = join7(projectsRoot, proj.name, NEW_AGENT_TRANSCRIPTS_DIR);
+      const transcriptsRoot = join8(projectsRoot, proj.name, NEW_AGENT_TRANSCRIPTS_DIR);
       const sessionDirs = await safeReaddir3(transcriptsRoot);
       if (!sessionDirs)
         continue;
@@ -4139,28 +4680,28 @@ async function scanCursorSessions() {
           continue;
         newCandidates.push({
           sessionId: sd.name,
-          dir: join7(transcriptsRoot, sd.name),
+          dir: join8(transcriptsRoot, sd.name),
           cwd
         });
       }
     }
   }
   for (const sub of LEGACY_SESSION_ROOT_CANDIDATES) {
-    const root = join7(home, sub);
+    const root = join8(home, sub);
     const entries = await safeReaddir3(root);
     if (!entries)
       continue;
     for (const e of entries) {
       if (!e.isDirectory())
         continue;
-      legacyCandidates.push({ sessionId: e.name, dir: join7(root, e.name) });
+      legacyCandidates.push({ sessionId: e.name, dir: join8(root, e.name) });
     }
   }
   if (newCandidates.length === 0 && legacyCandidates.length === 0)
     return [];
   const settled = await batchAll([
     ...newCandidates.map((c) => async () => {
-      const transcriptPath = join7(c.dir, `${c.sessionId}.jsonl`);
+      const transcriptPath = join8(c.dir, `${c.sessionId}.jsonl`);
       const transcriptMtime = await statMtime2(transcriptPath);
       if (!transcriptMtime)
         return null;
@@ -4432,11 +4973,11 @@ __export(exports_pi_projects, {
   getCachedPiSessionsByEncodedName: () => getCachedPiSessionsByEncodedName,
   getCachedPiProjects: () => getCachedPiProjects
 });
-import { readdir as readdir4, readFile as readFile5, stat as stat4 } from "node:fs/promises";
-import { homedir as homedir10 } from "node:os";
-import { join as join8 } from "node:path";
+import { readdir as readdir4, readFile as readFile6, stat as stat3 } from "node:fs/promises";
+import { homedir as homedir8 } from "node:os";
+import { join as join9 } from "node:path";
 function getPiSessionsRoot() {
-  return process.env.PI_SESSIONS_DIR || join8(homedir10(), ".pi", "agent", "sessions");
+  return process.env.PI_SESSIONS_DIR || join9(homedir8(), ".pi", "agent", "sessions");
 }
 async function safeReaddir4(dir) {
   try {
@@ -4447,7 +4988,7 @@ async function safeReaddir4(dir) {
 }
 async function statMtime3(path2) {
   try {
-    return (await stat4(path2)).mtime;
+    return (await stat3(path2)).mtime;
   } catch {
     return null;
   }
@@ -4455,7 +4996,7 @@ async function statMtime3(path2) {
 async function readSessionCwd(filePath) {
   let text;
   try {
-    text = await readFile5(filePath, "utf-8");
+    text = await readFile6(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -4484,7 +5025,7 @@ async function scanPiSessions() {
   for (const cwdDir of cwdDirs) {
     if (!cwdDir.isDirectory())
       continue;
-    const cwdPath = join8(root, cwdDir.name);
+    const cwdPath = join9(root, cwdDir.name);
     const sessionFiles = await safeReaddir4(cwdPath);
     if (!sessionFiles)
       continue;
@@ -4494,7 +5035,7 @@ async function scanPiSessions() {
       const m = SESSION_FILE_RE.exec(f.name);
       if (!m)
         continue;
-      candidates.push({ sessionId: m[1], filePath: join8(cwdPath, f.name) });
+      candidates.push({ sessionId: m[1], filePath: join9(cwdPath, f.name) });
     }
   }
   if (candidates.length === 0)
@@ -4596,7 +5137,7 @@ var init_pi_projects = __esm(() => {
 });
 
 // lib/sqlite-reader.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:fs";
 import initSqlJs from "sql.js/dist/sql-asm.js";
 async function tryNodeSqlite(dbPath) {
   try {
@@ -4623,7 +5164,7 @@ function loadSqlJs() {
 async function trySqlJs(dbPath) {
   try {
     const SQL = await loadSqlJs();
-    const db = new SQL.Database(readFileSync3(dbPath));
+    const db = new SQL.Database(readFileSync4(dbPath));
     return {
       query(sql, params) {
         const stmt = db.prepare(sql);
@@ -4647,7 +5188,7 @@ async function trySqlJs(dbPath) {
   }
 }
 async function openSqliteReadonly(dbPath) {
-  if (!existsSync5(dbPath))
+  if (!existsSync6(dbPath))
     return null;
   return await tryNodeSqlite(dbPath) ?? await trySqlJs(dbPath);
 }
@@ -4656,18 +5197,18 @@ var init_sqlite_reader = () => {};
 
 // lib/hermes-profiles.ts
 import { readdirSync as readdirSync3 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
-import { basename as basename2, dirname as dirname3, join as join9, resolve as resolve5 } from "node:path";
+import { homedir as homedir9 } from "node:os";
+import { basename as basename2, dirname as dirname3, join as join10, resolve as resolve6 } from "node:path";
 function hermesRoot() {
   const env = (process.env.HERMES_HOME || "").trim();
   if (env) {
-    const home = resolve5(env);
+    const home = resolve6(env);
     const parent = dirname3(home);
     if (basename2(parent) === PROFILES_DIR)
       return dirname3(parent);
     return home;
   }
-  return join9(homedir11(), ".hermes");
+  return join10(homedir9(), ".hermes");
 }
 function listHermesProfiles() {
   const root = hermesRoot();
@@ -4675,7 +5216,7 @@ function listHermesProfiles() {
   const seen = new Set([HERMES_DEFAULT_PROFILE]);
   let names;
   try {
-    names = readdirSync3(join9(root, PROFILES_DIR), { withFileTypes: true }).filter((e) => (e.isDirectory() || e.isSymbolicLink()) && !e.name.startsWith(".")).map((e) => e.name).sort();
+    names = readdirSync3(join10(root, PROFILES_DIR), { withFileTypes: true }).filter((e) => (e.isDirectory() || e.isSymbolicLink()) && !e.name.startsWith(".")).map((e) => e.name).sort();
   } catch {
     return out;
   }
@@ -4683,7 +5224,7 @@ function listHermesProfiles() {
     if (seen.has(name))
       continue;
     seen.add(name);
-    out.push({ name, home: join9(root, PROFILES_DIR, name) });
+    out.push({ name, home: join10(root, PROFILES_DIR, name) });
   }
   return out;
 }
@@ -4734,14 +5275,14 @@ function formatDuration(ms) {
 }
 
 // lib/hermes-sessions.ts
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function hermesDbPaths() {
   const override = process.env.HERMES_DB_PATH;
   if (override)
     return [{ profile: HERMES_DEFAULT_PROFILE, dbPath: override }];
   return listHermesProfiles().map((p) => ({
     profile: p.name,
-    dbPath: join10(p.home, "state.db")
+    dbPath: join11(p.home, "state.db")
   }));
 }
 function epochToMs(value) {
@@ -5037,12 +5578,12 @@ var init_hermes_projects = __esm(() => {
 });
 
 // lib/openclaw-sessions.ts
-import { readFile as readFile6 } from "node:fs/promises";
-import { readdirSync as readdirSync4, statSync as statSync5 } from "node:fs";
-import { homedir as homedir12 } from "node:os";
-import { join as join11 } from "node:path";
+import { readFile as readFile7 } from "node:fs/promises";
+import { readdirSync as readdirSync4, statSync as statSync6 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { join as join12 } from "node:path";
 function openclawHome() {
-  return process.env.OPENCLAW_HOME || join11(homedir12(), ".openclaw");
+  return process.env.OPENCLAW_HOME || join12(homedir10(), ".openclaw");
 }
 function isPlainObject2(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
@@ -5157,13 +5698,13 @@ function openclawLinesToLogEntries(lines, source = "session") {
 }
 function listOpenClawAgents() {
   try {
-    return readdirSync4(join11(openclawHome(), "agents"), { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => d.name).sort();
+    return readdirSync4(join12(openclawHome(), "agents"), { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => d.name).sort();
   } catch {
     return [];
   }
 }
 function listOpenClawTranscripts() {
-  const agentsDir = join11(openclawHome(), "agents");
+  const agentsDir = join12(openclawHome(), "agents");
   const out = [];
   let agentIds;
   try {
@@ -5172,7 +5713,7 @@ function listOpenClawTranscripts() {
     return out;
   }
   for (const agentId of agentIds) {
-    const sessionsDir = join11(agentsDir, agentId, "sessions");
+    const sessionsDir = join12(agentsDir, agentId, "sessions");
     let files;
     try {
       files = readdirSync4(sessionsDir);
@@ -5185,9 +5726,9 @@ function listOpenClawTranscripts() {
       const sessionId = file.slice(0, -".jsonl".length);
       if (!OPENCLAW_SESSION_ID_RE.test(sessionId))
         continue;
-      const transcriptPath = join11(sessionsDir, file);
+      const transcriptPath = join12(sessionsDir, file);
       try {
-        const st = statSync5(transcriptPath);
+        const st = statSync6(transcriptPath);
         out.push({ agentId, sessionId, transcriptPath, mtimeMs: st.mtimeMs, sizeBytes: st.size });
       } catch {}
     }
@@ -5209,7 +5750,7 @@ async function getOpenClawSessionLog(sessionId) {
     return null;
   let content;
   try {
-    content = await readFile6(filePath, "utf-8");
+    content = await readFile7(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -5245,17 +5786,17 @@ __export(exports_openclaw_projects, {
   getCachedOpenClawSessions: () => getCachedOpenClawSessions,
   getCachedOpenClawProjects: () => getCachedOpenClawProjects
 });
-import { readFileSync as readFileSync4 } from "node:fs";
-import { join as join12 } from "node:path";
+import { readFileSync as readFileSync5 } from "node:fs";
+import { join as join13 } from "node:path";
 function str(v) {
   return typeof v === "string" && v.length > 0 ? v : undefined;
 }
 function readSessionsIndex(agentId) {
   const out = new Map;
-  const indexPath = join12(openclawHome(), "agents", agentId, "sessions", "sessions.json");
+  const indexPath = join13(openclawHome(), "agents", agentId, "sessions", "sessions.json");
   let raw;
   try {
-    raw = JSON.parse(readFileSync4(indexPath, "utf-8"));
+    raw = JSON.parse(readFileSync5(indexPath, "utf-8"));
   } catch {
     return out;
   }
@@ -5406,15 +5947,15 @@ var init_openclaw_projects = __esm(() => {
 });
 
 // lib/factory-sessions.ts
-import { readFile as readFile7 } from "node:fs/promises";
-import { readdirSync as readdirSync5, statSync as statSync6 } from "node:fs";
-import { homedir as homedir13 } from "node:os";
-import { join as join13 } from "node:path";
+import { readFile as readFile8 } from "node:fs/promises";
+import { readdirSync as readdirSync5, statSync as statSync7 } from "node:fs";
+import { homedir as homedir11 } from "node:os";
+import { join as join14 } from "node:path";
 function factoryHome() {
-  return process.env.FACTORY_HOME || join13(homedir13(), ".factory");
+  return process.env.FACTORY_HOME || join14(homedir11(), ".factory");
 }
 function factorySessionsRoot() {
-  return join13(factoryHome(), "sessions");
+  return join14(factoryHome(), "sessions");
 }
 function isPlainObject3(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
@@ -5560,7 +6101,7 @@ function listFactoryTranscripts() {
   for (const dir of projectDirs) {
     const projectName = dir.name;
     const cwd = decodeFolderName(projectName);
-    const projectPath = join13(root, projectName);
+    const projectPath = join14(root, projectName);
     let files;
     try {
       files = readdirSync5(projectPath);
@@ -5573,9 +6114,9 @@ function listFactoryTranscripts() {
       const sessionId = file.slice(0, -".jsonl".length);
       if (!FACTORY_SESSION_ID_RE.test(sessionId))
         continue;
-      const transcriptPath = join13(projectPath, file);
+      const transcriptPath = join14(projectPath, file);
       try {
-        const st = statSync6(transcriptPath);
+        const st = statSync7(transcriptPath);
         out.push({ projectName, cwd, sessionId, transcriptPath, mtimeMs: st.mtimeMs, sizeBytes: st.size });
       } catch {}
     }
@@ -5597,7 +6138,7 @@ async function getFactorySessionLog(sessionId) {
     return null;
   let content;
   try {
-    content = await readFile7(filePath, "utf-8");
+    content = await readFile8(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -5699,13 +6240,13 @@ var init_factory_projects = __esm(() => {
 });
 
 // lib/devin-sessions.ts
-import { homedir as homedir14 } from "node:os";
-import { join as join14 } from "node:path";
+import { homedir as homedir12 } from "node:os";
+import { join as join15 } from "node:path";
 function devinHome() {
-  return process.env.DEVIN_HOME || join14(homedir14(), ".local", "share", "devin");
+  return process.env.DEVIN_HOME || join15(homedir12(), ".local", "share", "devin");
 }
 function devinDbPath() {
-  return process.env.DEVIN_DB_PATH || join14(devinHome(), "cli", "sessions.db");
+  return process.env.DEVIN_DB_PATH || join15(devinHome(), "cli", "sessions.db");
 }
 function devinEpochToMs(value) {
   if (typeof value === "number" && Number.isFinite(value)) {
@@ -6001,18 +6542,18 @@ var init_devin_projects = __esm(() => {
 });
 
 // lib/antigravity-sessions.ts
-import { readFile as readFile8 } from "node:fs/promises";
-import { readdirSync as readdirSync6, statSync as statSync7 } from "node:fs";
-import { homedir as homedir15 } from "node:os";
-import { join as join15 } from "node:path";
+import { readFile as readFile9 } from "node:fs/promises";
+import { readdirSync as readdirSync6, statSync as statSync8 } from "node:fs";
+import { homedir as homedir13 } from "node:os";
+import { join as join16 } from "node:path";
 function antigravityHome() {
-  return process.env.ANTIGRAVITY_HOME || join15(homedir15(), ".gemini", "antigravity-cli");
+  return process.env.ANTIGRAVITY_HOME || join16(homedir13(), ".gemini", "antigravity-cli");
 }
 function antigravityBrainRoot() {
-  return join15(antigravityHome(), "brain");
+  return join16(antigravityHome(), "brain");
 }
 function antigravityTranscriptRelPath() {
-  return join15(".system_generated", "logs", "transcript_full.jsonl");
+  return join16(".system_generated", "logs", "transcript_full.jsonl");
 }
 function isPlainObject5(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
@@ -6135,9 +6676,9 @@ function listAntigravityTranscripts() {
     const conversationId = dir.name;
     if (!ANTIGRAVITY_CONVERSATION_ID_RE.test(conversationId))
       continue;
-    const transcriptPath = join15(root, conversationId, rel);
+    const transcriptPath = join16(root, conversationId, rel);
     try {
-      const st = statSync7(transcriptPath);
+      const st = statSync8(transcriptPath);
       if (!st.isFile())
         continue;
       out.push({ conversationId, transcriptPath, mtimeMs: st.mtimeMs, sizeBytes: st.size });
@@ -6148,9 +6689,9 @@ function listAntigravityTranscripts() {
 function findAntigravityTranscript(conversationId) {
   if (!ANTIGRAVITY_CONVERSATION_ID_RE.test(conversationId))
     return null;
-  const transcriptPath = join15(antigravityBrainRoot(), conversationId, antigravityTranscriptRelPath());
+  const transcriptPath = join16(antigravityBrainRoot(), conversationId, antigravityTranscriptRelPath());
   try {
-    if (statSync7(transcriptPath).isFile())
+    if (statSync8(transcriptPath).isFile())
       return transcriptPath;
   } catch {}
   return null;
@@ -6161,7 +6702,7 @@ async function getAntigravitySessionLog(conversationId) {
     return null;
   let content;
   try {
-    content = await readFile8(filePath, "utf-8");
+    content = await readFile9(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -6188,9 +6729,9 @@ __export(exports_antigravity_projects, {
   getAntigravityIndex: () => getAntigravityIndex,
   antigravitySummariesDbPath: () => antigravitySummariesDbPath
 });
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function antigravitySummariesDbPath() {
-  return join16(antigravityHome(), "conversation_summaries.db");
+  return join17(antigravityHome(), "conversation_summaries.db");
 }
 function parseWorkspaceCwd(raw) {
   if (!raw)
@@ -6333,16 +6874,16 @@ var init_antigravity_projects = __esm(() => {
 });
 
 // lib/goose-sessions.ts
-import { homedir as homedir16 } from "node:os";
-import { join as join17 } from "node:path";
+import { homedir as homedir14 } from "node:os";
+import { join as join18 } from "node:path";
 function gooseHome() {
   if (process.env.GOOSE_HOME)
     return process.env.GOOSE_HOME;
   const xdg = process.env.XDG_DATA_HOME;
-  return join17(xdg && xdg.length > 0 ? xdg : join17(homedir16(), ".local", "share"), "goose");
+  return join18(xdg && xdg.length > 0 ? xdg : join18(homedir14(), ".local", "share"), "goose");
 }
 function gooseDbPath() {
-  return process.env.GOOSE_DB_PATH || join17(gooseHome(), "sessions", "sessions.db");
+  return process.env.GOOSE_DB_PATH || join18(gooseHome(), "sessions", "sessions.db");
 }
 function gooseTimestampToMs(value) {
   if (typeof value === "number" && Number.isFinite(value)) {
@@ -6609,11 +7150,11 @@ var init_goose_projects = __esm(() => {
 });
 
 // lib/projects.ts
-import { readdir as readdir5, stat as stat5 } from "node:fs/promises";
-import { join as join18, resolve as resolve6, sep } from "node:path";
+import { readdir as readdir5, stat as stat4 } from "node:fs/promises";
+import { join as join19, resolve as resolve7, sep } from "node:path";
 async function getMtime(path2, label) {
   try {
-    return (await stat5(path2)).mtime;
+    return (await stat4(path2)).mtime;
   } catch (error) {
     logWarn(`Failed to stat ${label}:`, error);
     return new Date(0);
@@ -6621,7 +7162,7 @@ async function getMtime(path2, label) {
 }
 async function safeReaddir5(dirPath) {
   try {
-    const s = await stat5(dirPath);
+    const s = await stat4(dirPath);
     if (!s.isDirectory())
       return null;
     return await readdir5(dirPath, { withFileTypes: true });
@@ -6636,7 +7177,7 @@ async function getClaudeProjectFolders() {
     if (!entries)
       return [];
     const settled = await batchAll(entries.filter((entry) => entry.isDirectory()).map((entry) => async () => {
-      const folderPath = join18(projectsPath, entry.name);
+      const folderPath = join19(projectsPath, entry.name);
       const mtime = await getMtime(folderPath, entry.name);
       return {
         name: entry.name,
@@ -6762,8 +7303,8 @@ function resolveProjectPath(projectName) {
     throw new RangeError("Empty project name");
   if (/^[/\\]/.test(projectName))
     throw new RangeError("Absolute project name");
-  const projectsPath = resolve6(getClaudeProjectsPath());
-  const candidate = resolve6(join18(projectsPath, projectName));
+  const projectsPath = resolve7(getClaudeProjectsPath());
+  const candidate = resolve7(join19(projectsPath, projectName));
   if (!candidate.startsWith(projectsPath + sep)) {
     throw new RangeError("Project path escapes root");
   }
@@ -6781,7 +7322,7 @@ async function getSessionFiles(projectPath) {
       return [];
     const jsonlEntries = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl") && extractSessionId2(entry.name));
     const settled = await batchAll(jsonlEntries.map((entry) => async () => {
-      const filePath = join18(projectPath, entry.name);
+      const filePath = join19(projectPath, entry.name);
       const mtime = await getMtime(filePath, entry.name);
       return {
         name: entry.name,
@@ -6810,13 +7351,13 @@ var init_projects = __esm(() => {
 
 // lib/resolve-subagent-path.ts
 import { access as access2 } from "fs/promises";
-import { join as join19, relative as relative2 } from "path";
+import { join as join20, relative as relative2 } from "path";
 async function resolveSubagentPath(projectsPath, projectName, sessionId, agentId) {
   const fileName = `agent-${agentId}.jsonl`;
   const candidatePaths = [
-    join19(projectsPath, projectName, fileName),
-    join19(projectsPath, projectName, sessionId, fileName),
-    join19(projectsPath, projectName, sessionId, "subagents", fileName)
+    join20(projectsPath, projectName, fileName),
+    join20(projectsPath, projectName, sessionId, fileName),
+    join20(projectsPath, projectName, sessionId, "subagents", fileName)
   ];
   for (const candidatePath of candidatePaths) {
     if (relative2(projectsPath, candidatePath).startsWith("..")) {
@@ -6837,8 +7378,8 @@ async function resolveSubagentPath(projectsPath, projectName, sessionId, agentId
 var init_resolve_subagent_path = () => {};
 
 // lib/log-entries.ts
-import { readFile as readFile9 } from "fs/promises";
-import { join as join20 } from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { join as join21 } from "path";
 function formatTimestamp(date) {
   const base = formatDate(date);
   const ms = date.getMilliseconds().toString().padStart(3, "0");
@@ -7032,8 +7573,8 @@ async function parseFileContent(fileContent, source) {
 async function parseSessionLog(projectName, sessionId) {
   const projectDir = resolveProjectPath(projectName);
   const projectsPath = getClaudeProjectsPath();
-  const filePath = join20(projectDir, `${sessionId}.jsonl`);
-  const fileContent = await readFile9(filePath, "utf-8");
+  const filePath = join21(projectDir, `${sessionId}.jsonl`);
+  const fileContent = await readFile10(filePath, "utf-8");
   const { entries: sessionEntries, rawLines: sessionRawLines, subagentIds } = await parseFileContent(fileContent, "session");
   if (subagentIds.length === 0) {
     return { entries: sessionEntries, rawLines: sessionRawLines, subagentIds: [] };
@@ -7043,7 +7584,7 @@ async function parseSessionLog(projectName, sessionId) {
     const agentPath = await resolveSubagentPath(projectsPath, projectName, sessionId, agentId);
     if (!agentPath)
       return null;
-    const agentContent = await readFile9(agentPath, "utf-8");
+    const agentContent = await readFile10(agentPath, "utf-8");
     const { entries, rawLines } = await parseFileContent(agentContent, agentSource);
     return { entries, rawLines };
   }), SUBAGENT_CONCURRENCY);
@@ -7069,32 +7610,32 @@ var init_log_entries = __esm(() => {
 });
 
 // lib/codex-sessions.ts
-import { readFileSync as readFileSync5, readdirSync as readdirSync7, existsSync as existsSync6, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, statSync as statSync8 } from "node:fs";
-import { readFile as readFile10 } from "node:fs/promises";
-import { dirname as dirname4, join as join21 } from "node:path";
-import { homedir as homedir17 } from "node:os";
+import { readFileSync as readFileSync6, readdirSync as readdirSync7, existsSync as existsSync7, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, statSync as statSync9 } from "node:fs";
+import { readFile as readFile11 } from "node:fs/promises";
+import { dirname as dirname4, join as join22 } from "node:path";
+import { homedir as homedir15 } from "node:os";
 function readCache() {
   try {
-    if (!existsSync6(CACHE_PATH))
+    if (!existsSync7(CACHE_PATH))
       return {};
-    return JSON.parse(readFileSync5(CACHE_PATH, "utf-8"));
+    return JSON.parse(readFileSync6(CACHE_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeCacheEntry(sessionId, path2) {
   try {
-    mkdirSync4(dirname4(CACHE_PATH), { recursive: true });
+    mkdirSync5(dirname4(CACHE_PATH), { recursive: true });
     const cache = readCache();
     cache[sessionId] = path2;
-    writeFileSync3(CACHE_PATH, JSON.stringify(cache), "utf-8");
+    writeFileSync4(CACHE_PATH, JSON.stringify(cache), "utf-8");
   } catch {}
 }
 function dirSearch(dir, sessionId) {
   try {
     for (const f of readdirSync7(dir, { withFileTypes: true })) {
       if (f.isFile() && f.name.includes(sessionId) && f.name.endsWith(".jsonl")) {
-        return join21(dir, f.name);
+        return join22(dir, f.name);
       }
     }
   } catch {}
@@ -7103,16 +7644,16 @@ function dirSearch(dir, sessionId) {
 function findCodexTranscript(sessionId) {
   const cache = readCache();
   const cached = cache[sessionId];
-  if (cached && existsSync6(cached))
+  if (cached && existsSync7(cached))
     return cached;
-  const root = join21(homedir17(), ".codex", "sessions");
+  const root = join22(homedir15(), ".codex", "sessions");
   const today = new Date;
   const yesterday = new Date(today.getTime() - 24 * 60 * 60 * 1000);
   const datedDirs = [today, yesterday].map((d) => {
     const y = String(d.getUTCFullYear());
     const m = String(d.getUTCMonth() + 1).padStart(2, "0");
     const day = String(d.getUTCDate()).padStart(2, "0");
-    return join21(root, y, m, day);
+    return join22(root, y, m, day);
   });
   for (const dir of datedDirs) {
     const hit = dirSearch(dir, sessionId);
@@ -7125,13 +7666,13 @@ function findCodexTranscript(sessionId) {
     for (const y of readdirSync7(root, { withFileTypes: true })) {
       if (!y.isDirectory())
         continue;
-      for (const m of readdirSync7(join21(root, y.name), { withFileTypes: true })) {
+      for (const m of readdirSync7(join22(root, y.name), { withFileTypes: true })) {
         if (!m.isDirectory())
           continue;
-        for (const d of readdirSync7(join21(root, y.name, m.name), { withFileTypes: true })) {
+        for (const d of readdirSync7(join22(root, y.name, m.name), { withFileTypes: true })) {
           if (!d.isDirectory())
             continue;
-          const hit = dirSearch(join21(root, y.name, m.name, d.name), sessionId);
+          const hit = dirSearch(join22(root, y.name, m.name, d.name), sessionId);
           if (hit) {
             writeCacheEntry(sessionId, hit);
             return hit;
@@ -7344,19 +7885,20 @@ async function getCodexSessionLog(sessionId) {
   const filePath = findCodexTranscript(sessionId);
   if (!filePath)
     return null;
-  const fileContent = await readFile10(filePath, "utf-8");
+  const fileContent = await readFile11(filePath, "utf-8");
   const { entries, rawLines, cwd } = await parseCodexLog(fileContent, "session");
   return { entries, rawLines, cwd, filePath };
 }
 var CACHE_PATH, getCachedCodexSessionLog;
 var init_codex_sessions = __esm(() => {
   init_log_entries();
-  CACHE_PATH = join21(homedir17(), ".failproofai", "cache", "codex-session-paths.json");
+  init_fp_home();
+  CACHE_PATH = codexSessionPathsFile();
   getCachedCodexSessionLog = runtimeCache((sessionId) => getCodexSessionLog(sessionId), 60, { maxSize: 50 });
 });
 
 // src/hooks/resolve-permission-mode.ts
-import { readFileSync as readFileSync6 } from "node:fs";
+import { readFileSync as readFileSync7 } from "node:fs";
 function resolvePermissionMode(integration, parsed, sessionId) {
   if (integration === "claude") {
     return parsed.permission_mode ?? "default";
@@ -7371,7 +7913,7 @@ function resolveCodexMode(sessionId) {
     const path2 = findCodexTranscript(sessionId);
     if (!path2)
       return;
-    for (const line of readFileSync6(path2, "utf-8").split(`
+    for (const line of readFileSync7(path2, "utf-8").split(`
 `)) {
       if (!line.includes("turn_context"))
         continue;
@@ -7396,21 +7938,21 @@ var init_resolve_permission_mode = __esm(() => {
 });
 
 // lib/copilot-sessions.ts
-import { readFileSync as readFileSync7, readdirSync as readdirSync8, existsSync as existsSync7, statSync as statSync9 } from "node:fs";
-import { readFile as readFile11 } from "node:fs/promises";
-import { join as join22, resolve as resolve7, sep as sep2 } from "node:path";
-import { homedir as homedir18 } from "node:os";
+import { readFileSync as readFileSync8, readdirSync as readdirSync8, existsSync as existsSync8, statSync as statSync10 } from "node:fs";
+import { readFile as readFile12 } from "node:fs/promises";
+import { join as join23, resolve as resolve8, sep as sep2 } from "node:path";
+import { homedir as homedir16 } from "node:os";
 function getCopilotHome() {
-  return process.env.COPILOT_HOME || join22(homedir18(), ".copilot");
+  return process.env.COPILOT_HOME || join23(homedir16(), ".copilot");
 }
 function getCopilotSessionStateRoot2() {
-  return join22(getCopilotHome(), "session-state");
+  return join23(getCopilotHome(), "session-state");
 }
 function getCopilotSessionDir(sessionId) {
   if (!sessionId)
     return null;
-  const root = resolve7(getCopilotSessionStateRoot2());
-  const candidate = resolve7(root, sessionId);
+  const root = resolve8(getCopilotSessionStateRoot2());
+  const candidate = resolve8(root, sessionId);
   if (candidate === root || !candidate.startsWith(`${root}${sep2}`))
     return null;
   return candidate;
@@ -7419,23 +7961,23 @@ function resolveSessionFile(sessionId, filename) {
   const dir = getCopilotSessionDir(sessionId);
   if (!dir)
     return null;
-  return join22(dir, filename);
+  return join23(dir, filename);
 }
 function findCopilotTranscript(sessionId) {
   const candidate = resolveSessionFile(sessionId, "events.jsonl");
   if (!candidate)
     return null;
-  return existsSync7(candidate) ? candidate : null;
+  return existsSync8(candidate) ? candidate : null;
 }
 function findCopilotWorkspace(sessionId) {
   const candidate = resolveSessionFile(sessionId, "workspace.yaml");
   if (!candidate)
     return null;
-  return existsSync7(candidate) ? candidate : null;
+  return existsSync8(candidate) ? candidate : null;
 }
 function readYamlScalar(path2, key) {
   try {
-    const text = readFileSync7(path2, "utf-8");
+    const text = readFileSync8(path2, "utf-8");
     const re = new RegExp(`^${key}\\s*:\\s*(.+?)\\s*$`, "m");
     const m = text.match(re);
     if (!m)
@@ -7598,7 +8140,7 @@ async function getCopilotSessionLog(sessionId) {
     return null;
   let fileContent;
   try {
-    fileContent = await readFile11(filePath, "utf-8");
+    fileContent = await readFile12(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -7613,18 +8155,18 @@ var init_copilot_sessions = __esm(() => {
 });
 
 // lib/cursor-sessions.ts
-import { readFileSync as readFileSync8, readdirSync as readdirSync9, existsSync as existsSync8, statSync as statSync10 } from "node:fs";
-import { readFile as readFile12 } from "node:fs/promises";
-import { basename as basename3, join as join23, resolve as resolve8, sep as sep3 } from "node:path";
-import { homedir as homedir19 } from "node:os";
+import { readFileSync as readFileSync9, readdirSync as readdirSync9, existsSync as existsSync9, statSync as statSync11 } from "node:fs";
+import { readFile as readFile13 } from "node:fs/promises";
+import { basename as basename3, join as join24, resolve as resolve9, sep as sep3 } from "node:path";
+import { homedir as homedir17 } from "node:os";
 function getCursorHome2() {
-  return process.env.CURSOR_HOME || join23(homedir19(), ".cursor");
+  return process.env.CURSOR_HOME || join24(homedir17(), ".cursor");
 }
 function getCursorSessionDir(sessionId) {
   if (!sessionId)
     return null;
-  const home = resolve8(getCursorHome2());
-  const projectsRoot = resolve8(home, NEW_PROJECTS_DIR2);
+  const home = resolve9(getCursorHome2());
+  const projectsRoot = resolve9(home, NEW_PROJECTS_DIR2);
   let projectEntries = [];
   try {
     projectEntries = readdirSync9(projectsRoot, { withFileTypes: true });
@@ -7632,19 +8174,19 @@ function getCursorSessionDir(sessionId) {
   for (const entry of projectEntries) {
     if (!entry.isDirectory())
       continue;
-    const candidate = resolve8(projectsRoot, entry.name, NEW_AGENT_TRANSCRIPTS_DIR2, sessionId);
-    const transcriptRoot = resolve8(projectsRoot, entry.name, NEW_AGENT_TRANSCRIPTS_DIR2);
+    const candidate = resolve9(projectsRoot, entry.name, NEW_AGENT_TRANSCRIPTS_DIR2, sessionId);
+    const transcriptRoot = resolve9(projectsRoot, entry.name, NEW_AGENT_TRANSCRIPTS_DIR2);
     if (candidate === transcriptRoot || !candidate.startsWith(`${transcriptRoot}${sep3}`))
       continue;
-    if (existsSync8(candidate))
+    if (existsSync9(candidate))
       return candidate;
   }
   for (const sub of LEGACY_SESSION_ROOT_CANDIDATES2) {
-    const root = resolve8(home, sub);
-    const candidate = resolve8(root, sessionId);
+    const root = resolve9(home, sub);
+    const candidate = resolve9(root, sessionId);
     if (candidate === root || !candidate.startsWith(`${root}${sep3}`))
       continue;
-    if (existsSync8(candidate))
+    if (existsSync9(candidate))
       return candidate;
   }
   return null;
@@ -7653,12 +8195,12 @@ function findCursorTranscript(sessionId) {
   const dir = getCursorSessionDir(sessionId);
   if (!dir)
     return null;
-  const newCandidate = join23(dir, `${basename3(dir)}.jsonl`);
-  if (existsSync8(newCandidate))
+  const newCandidate = join24(dir, `${basename3(dir)}.jsonl`);
+  if (existsSync9(newCandidate))
     return newCandidate;
   for (const name of LEGACY_TRANSCRIPT_FILE_CANDIDATES2) {
-    const candidate = join23(dir, name);
-    if (existsSync8(candidate))
+    const candidate = join24(dir, name);
+    if (existsSync9(candidate))
       return candidate;
   }
   return null;
@@ -7853,7 +8395,7 @@ async function getCursorSessionLog(sessionId) {
     return null;
   let fileContent;
   try {
-    fileContent = await readFile12(filePath, "utf-8");
+    fileContent = await readFile13(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -7869,12 +8411,12 @@ var init_cursor_sessions = __esm(() => {
 });
 
 // lib/pi-sessions.ts
-import { readFileSync as readFileSync9, readdirSync as readdirSync10, existsSync as existsSync9, statSync as statSync11 } from "node:fs";
-import { readFile as readFile13 } from "node:fs/promises";
-import { join as join24, resolve as resolve9, sep as sep4 } from "node:path";
-import { homedir as homedir20 } from "node:os";
+import { readFileSync as readFileSync10, readdirSync as readdirSync10, existsSync as existsSync10, statSync as statSync12 } from "node:fs";
+import { readFile as readFile14 } from "node:fs/promises";
+import { join as join25, resolve as resolve10, sep as sep4 } from "node:path";
+import { homedir as homedir18 } from "node:os";
 function getPiSessionStateRoot() {
-  return process.env.PI_SESSIONS_DIR || join24(homedir20(), ".pi", "agent", "sessions");
+  return process.env.PI_SESSIONS_DIR || join25(homedir18(), ".pi", "agent", "sessions");
 }
 function isSafeSessionId(sessionId) {
   return UUID_RE.test(sessionId);
@@ -7882,7 +8424,7 @@ function isSafeSessionId(sessionId) {
 function findPiTranscript(sessionId) {
   if (!isSafeSessionId(sessionId))
     return null;
-  const root = resolve9(getPiSessionStateRoot());
+  const root = resolve10(getPiSessionStateRoot());
   let cwdDirs;
   try {
     cwdDirs = readdirSync10(root);
@@ -7890,7 +8432,7 @@ function findPiTranscript(sessionId) {
     return null;
   }
   for (const cwdDir of cwdDirs) {
-    const cwdPath = resolve9(root, cwdDir);
+    const cwdPath = resolve10(root, cwdDir);
     if (!cwdPath.startsWith(`${root}${sep4}`))
       continue;
     let files;
@@ -7903,10 +8445,10 @@ function findPiTranscript(sessionId) {
       const m = SESSION_FILE_RE2.exec(f);
       if (!m || m[1].toLowerCase() !== sessionId.toLowerCase())
         continue;
-      const candidate = resolve9(cwdPath, f);
+      const candidate = resolve10(cwdPath, f);
       if (!candidate.startsWith(`${cwdPath}${sep4}`))
         continue;
-      if (existsSync9(candidate))
+      if (existsSync10(candidate))
         return candidate;
     }
   }
@@ -7924,7 +8466,7 @@ function extractMessageText(content) {
 
 `);
 }
-function buildAssistantContent(content) {
+function buildAssistantContent(content, onToolUse) {
   if (!Array.isArray(content))
     return [];
   const blocks = [];
@@ -7935,6 +8477,14 @@ function buildAssistantContent(content) {
     if (block?.type === "thinking" && typeof block.thinking === "string" && block.thinking.length > 0) {
       blocks.push({ type: "text", text: `[thinking] ${block.thinking}` });
     }
+    if (block?.type === "toolCall") {
+      const id = typeof block.id === "string" && block.id.length > 0 ? block.id : `${typeof block.name === "string" ? block.name : "tool"}-${blocks.length}`;
+      const name = typeof block.name === "string" ? block.name : "tool";
+      const input = block.arguments && typeof block.arguments === "object" && !Array.isArray(block.arguments) ? block.arguments : {};
+      const toolUse = { type: "tool_use", id, name, input };
+      blocks.push(toolUse);
+      onToolUse?.(toolUse);
+    }
   }
   return blocks;
 }
@@ -7945,6 +8495,8 @@ async function parsePiLog(fileContent, source = "session") {
   const rawLines = [];
   let cwd;
   let seenSessionStart = false;
+  const toolUseById = new Map;
+  const toolUseStartMs = new Map;
   for (let i = 0;i < lines.length; i++) {
     if (i > 0 && i % 200 === 0)
       await new Promise((r) => setImmediate(r));
@@ -7992,7 +8544,10 @@ async function parsePiLog(fileContent, source = "session") {
         continue;
       }
       if (role === "assistant") {
-        const blocks = buildAssistantContent(content);
+        const blocks = buildAssistantContent(content, (block) => {
+          toolUseById.set(block.id, block);
+          toolUseStartMs.set(block.id, date.getTime());
+        });
         if (blocks.length === 0) {
           entries.push({
             type: "system",
@@ -8008,6 +8563,22 @@ async function parsePiLog(fileContent, source = "session") {
         });
         continue;
       }
+      if (role === "toolResult") {
+        const callId = raw.message.toolCallId;
+        const block = typeof callId === "string" ? toolUseById.get(callId) : undefined;
+        if (block) {
+          const startMs = typeof callId === "string" && toolUseStartMs.get(callId) || date.getTime();
+          const durationMs = Math.max(0, date.getTime() - startMs);
+          block.result = {
+            timestamp,
+            timestampFormatted: formatTimestamp(date),
+            content: extractMessageText(content),
+            durationMs,
+            durationFormatted: formatDuration(durationMs)
+          };
+          continue;
+        }
+      }
       entries.push({
         type: "system",
         ...baseEntry(rawCopy, timestamp, date, source),
@@ -8032,7 +8603,7 @@ async function getPiSessionLog(sessionId) {
     return null;
   let fileContent;
   try {
-    fileContent = await readFile13(filePath, "utf-8");
+    fileContent = await readFile14(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -8101,6 +8672,214 @@ var init_resolve_transcript_path = __esm(() => {
   init_factory_sessions();
   init_antigravity_sessions();
 });
+// src/hooks/cloud-managed-policies.ts
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync11, readFileSync as readFileSync11, realpathSync, rmSync } from "node:fs";
+import { isAbsolute as isAbsolute2, relative as relative3, resolve as resolve11 } from "node:path";
+function cloudManagedPolicyRoot() {
+  return process.env.FAILPROOFAI_CLOUD_POLICY_DIR ?? cloudPoliciesDir();
+}
+function parseManifest(value) {
+  if (!value || typeof value !== "object")
+    throw new Error("active manifest is not an object");
+  const raw = value;
+  if (!ACCEPTED_ACTIVE_SCHEMA_VERSIONS.includes(raw.schemaVersion)) {
+    throw new Error(`unsupported active manifest schema ${String(raw.schemaVersion)} ` + `(supported: ${ACCEPTED_ACTIVE_SCHEMA_VERSIONS.join(", ")})`);
+  }
+  const deployment = raw.deployment ?? raw.generation;
+  if (!Number.isSafeInteger(deployment) || (deployment ?? -1) < 0) {
+    throw new Error("active manifest deployment is invalid");
+  }
+  if (!Array.isArray(raw.policies))
+    throw new Error("active manifest policies is not an array");
+  const policies = raw.policies.map((p) => {
+    const entry = p;
+    return { ...entry, version: entry.version ?? entry.revision };
+  });
+  return { schemaVersion: raw.schemaVersion, deployment, policies };
+}
+function resolveManagedPath(root, candidate) {
+  if (!candidate || isAbsolute2(candidate))
+    throw new Error(`unsafe managed policy path ${JSON.stringify(candidate)}`);
+  const absolute = resolve11(root, candidate);
+  const lexicalRelative = relative3(root, absolute);
+  if (lexicalRelative.startsWith("..") || isAbsolute2(lexicalRelative)) {
+    throw new Error(`managed policy path escapes its root: ${JSON.stringify(candidate)}`);
+  }
+  const realRoot = realpathSync(root);
+  const realFile = realpathSync(absolute);
+  const physicalRelative = relative3(realRoot, realFile);
+  if (physicalRelative.startsWith("..") || isAbsolute2(physicalRelative)) {
+    throw new Error(`managed policy symlink escapes its root: ${JSON.stringify(candidate)}`);
+  }
+  return realFile;
+}
+function readActiveCloudManagedPolicies() {
+  const root = cloudManagedPolicyRoot();
+  const activePath = resolve11(root, "active.json");
+  if (!existsSync11(activePath))
+    return [];
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync11(activePath, "utf8"));
+  } catch (err) {
+    throw new Error(`failed to read cloud-managed active manifest: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const manifest = parseManifest(raw);
+  const seen = new Set;
+  return manifest.policies.map((policy) => {
+    if (!POLICY_ID_RE.test(policy.id) || policy.id === "." || policy.id === "..") {
+      throw new Error(`unsafe cloud-managed policy id ${JSON.stringify(policy.id)}`);
+    }
+    if (!Number.isSafeInteger(policy.version) || policy.version < 0) {
+      throw new Error(`invalid version for cloud-managed policy ${policy.id}`);
+    }
+    if (!SHA256_RE.test(policy.sha256)) {
+      throw new Error(`invalid SHA-256 for cloud-managed policy ${policy.id}`);
+    }
+    if (seen.has(policy.id))
+      throw new Error(`duplicate cloud-managed policy id ${policy.id}`);
+    seen.add(policy.id);
+    const path2 = resolveManagedPath(root, policy.path);
+    const bytes = readFileSync11(path2);
+    const actual = createHash3("sha256").update(bytes).digest("hex");
+    if (actual !== policy.sha256) {
+      throw new Error(`cloud-managed policy ${policy.id} failed integrity verification: expected ${policy.sha256}, got ${actual}`);
+    }
+    if (policy.effect !== undefined && policy.effect !== "enforce" && policy.effect !== "observe") {
+      throw new Error(`unknown effect ${JSON.stringify(policy.effect)} for cloud-managed policy ${policy.id}`);
+    }
+    return {
+      id: policy.id,
+      version: policy.version,
+      effect: policy.effect ?? "enforce",
+      sha256: policy.sha256,
+      path: path2,
+      deployment: manifest.deployment
+    };
+  });
+}
+var ACCEPTED_ACTIVE_SCHEMA_VERSIONS, SHA256_RE, POLICY_ID_RE;
+var init_cloud_managed_policies = __esm(() => {
+  init_fp_home();
+  ACCEPTED_ACTIVE_SCHEMA_VERSIONS = [1, 2];
+  SHA256_RE = /^[a-f0-9]{64}$/;
+  POLICY_ID_RE = /^[A-Za-z0-9._-]{1,128}$/;
+});
+
+// lib/atomic-write.ts
+var init_atomic_write = () => {};
+
+// src/hooks/session-pause.ts
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, readdirSync as readdirSync11, readFileSync as readFileSync12, rmSync as rmSync2 } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { join as join26, resolve as resolve12 } from "node:path";
+function pauseStateDir() {
+  const override = process.env.FAILPROOFAI_STATE_DIR;
+  if (override)
+    return resolve12(override, "sessions");
+  return sessionPauseDir();
+}
+function pauseFilePath(sessionId) {
+  const digest = createHash4("sha256").update(sessionId).digest("hex").slice(0, 32);
+  return join26(pauseStateDir(), `${digest}.json`);
+}
+function parseStored(raw) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const p = raw;
+  if (p.schemaVersion !== SCHEMA_VERSION)
+    return null;
+  if (typeof p.sessionId !== "string" || p.sessionId.length === 0)
+    return null;
+  if (!Number.isFinite(p.pausedAt) || !Number.isFinite(p.expiresAt))
+    return null;
+  const pausedAt = p.pausedAt;
+  const firstPausedAt = Number.isFinite(p.firstPausedAt) ? p.firstPausedAt : pausedAt;
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    sessionId: p.sessionId,
+    pausedAt,
+    firstPausedAt,
+    expiresAt: Math.min(p.expiresAt, firstPausedAt + PAUSE_CEILING_MS),
+    setBy: typeof p.setBy === "string" ? p.setBy : "unknown",
+    ...typeof p.cwd === "string" ? { cwd: p.cwd } : {}
+  };
+}
+function readActivePause(sessionId, now = Date.now()) {
+  if (!sessionId)
+    return null;
+  try {
+    const path2 = pauseFilePath(sessionId);
+    if (!existsSync12(path2))
+      return null;
+    const stored = parseStored(JSON.parse(readFileSync12(path2, "utf8")));
+    if (!stored)
+      return null;
+    if (stored.expiresAt <= now)
+      return null;
+    const { schemaVersion: _ignored, ...pause } = stored;
+    return pause;
+  } catch {
+    return null;
+  }
+}
+var SCHEMA_VERSION = 1, PAUSE_DEFAULT_MS, PAUSE_CEILING_MS;
+var init_session_pause = __esm(() => {
+  init_atomic_write();
+  init_hook_activity_store();
+  init_fp_home();
+  PAUSE_DEFAULT_MS = 30 * 60000;
+  PAUSE_CEILING_MS = 8 * 60 * 60000;
+});
+
+// src/hooks/daemon-download.ts
+var init_daemon_download = __esm(() => {
+  init_package();
+  init_package();
+  init_fp_home();
+});
+
+// src/hooks/daemon-service.ts
+var init_daemon_service = __esm(() => {
+  init_hook_logger();
+  init_daemon_download();
+  init_fp_home();
+  init_package();
+  init_fp_config();
+});
+
+// src/hooks/fp-reset.ts
+import {
+  copyFileSync,
+  existsSync as existsSync13,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync13,
+  readdirSync as readdirSync12,
+  renameSync as renameSync3,
+  rmSync as rmSync3,
+  rmdirSync,
+  statSync as statSync13,
+  writeFileSync as writeFileSync5
+} from "node:fs";
+function layoutWarningForHook() {
+  const state = detectLayout();
+  if (state.kind === "current" || state.kind === "absent")
+    return null;
+  if (state.kind === "future") {
+    return `[failproofai] this directory was written by a newer version (layout ${state.found} vs ${LAYOUT_VERSION}) — policies are NOT being enforced. ` + `Upgrade failproofai.`;
+  }
+  if (existsSync13(globalPolicyConfigFile()))
+    return null;
+  return `[failproofai] setup predates this version — global policies are NOT being enforced. ` + `Run \`failproofai config\` to re-create it.`;
+}
+var init_fp_reset = __esm(() => {
+  init_hook_activity_store();
+  init_fp_home();
+  init_fp_config();
+  init_daemon_service();
+});
+
 // src/hooks/handler.ts
 function canonicalizeEventType(raw, cli) {
   if (cli === "codex") {
@@ -8135,8 +8914,29 @@ function canonicalizeEventType(raw, cli) {
   }
   return raw;
 }
+async function runObserved(hook, ctx, hookName, eventType, cli) {
+  try {
+    return await Promise.race([
+      hook.fn(ctx),
+      new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), 1e4))
+    ]);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    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" };
+  }
+}
 async function evaluateHookEvent(eventType, cli = "claude", stdinPayload, opts) {
   const startTime = performance.now();
+  const layoutWarning = layoutWarningForHook();
+  if (layoutWarning)
+    hookLogWarn(layoutWarning);
   try {
     let parsed = {};
     if (stdinPayload) {
@@ -8176,6 +8976,10 @@ async function evaluateHookEvent(eventType, cli = "claude", stdinPayload, opts)
     let config;
     let customHooksList = [];
     let conventionHookNames = new Set;
+    let activePause = null;
+    const policyAttribution = new Map;
+    let cloudDeployment;
+    const observedResults = [];
     if (opts?.forceDecision) {
       config = { enabledPolicies: [] };
       clearPolicies();
@@ -8184,23 +8988,59 @@ async function evaluateHookEvent(eventType, cli = "claude", stdinPayload, opts)
     } else {
       config = readMergedHooksConfig(session.cwd);
       clearPolicies();
-      registerBuiltinPolicies(config.enabledPolicies);
-      const loadResult = await loadAllCustomHooks(config.customPoliciesPaths ?? config.customPoliciesPath, {
+      activePause = readActivePause(session.sessionId);
+      registerBuiltinPolicies(activePause ? [] : config.enabledPolicies);
+      let cloudManagedPolicies = [];
+      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.`);
+        trackHookEvent(getInstanceId(), "cloud_managed_load_error", {
+          event_type: eventType,
+          cli
+        });
+      }
+      cloudDeployment = cloudManagedPolicies[0]?.deployment;
+      const configuredCustomPaths = config.customPoliciesPaths ?? config.customPoliciesPath;
+      const allExplicitPaths = cloudManagedPolicies.length === 0 ? configuredCustomPaths : [
+        ...typeof configuredCustomPaths === "string" ? [configuredCustomPaths] : configuredCustomPaths ?? [],
+        ...cloudManagedPolicies.map((policy) => policy.path)
+      ];
+      const loadResult = await loadAllCustomHooks(allExplicitPaths, {
         sessionCwd: session.cwd,
-        customPoliciesEnabled: config.customPoliciesEnabled
+        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.__policyId;
-        if (policyId && disabledCustomPolicies.has(policyId))
+        const taggedHook = hook;
+        const policyId = taggedHook.__policyId;
+        const cloudManaged = taggedHook.__cloudManaged;
+        if (!cloudManaged && policyId && disabledCustomPolicies.has(policyId))
+          continue;
+        if (!cloudManaged && activePause)
           continue;
         const hookName = hook.name;
         const conventionScope = hook.__conventionScope;
         const isConvention = !!conventionScope;
-        const prefix = isConvention ? `.failproofai-${conventionScope}` : "custom";
+        const prefix = cloudManaged ? `cloud/${cloudManaged.id}@${cloudManaged.version}` : isConvention ? `.failproofai-${conventionScope}` : "custom";
+        const observeOnly = cloudManaged?.effect === "observe";
         const fn = async (ctx) => {
+          if (observeOnly) {
+            const shadow = await runObserved(hook, ctx, hookName, eventType, cli);
+            if (shadow.decision !== "allow") {
+              observedResults.push({
+                policyId: cloudManaged.id,
+                version: cloudManaged.version,
+                decision: shadow.decision,
+                reason: shadow.reason ?? null
+              });
+            }
+            return { decision: "allow" };
+          }
           try {
             const result2 = await Promise.race([
               hook.fn(ctx),
@@ -8222,7 +9062,12 @@ async function evaluateHookEvent(eventType, cli = "claude", stdinPayload, opts)
             return { decision: "allow" };
           }
         };
-        registerPolicy(`${prefix}/${hookName}`, hook.description ?? "", fn, hook.match ?? {}, -1);
+        const registeredName = `${prefix}/${hookName}`;
+        policyAttribution.set(registeredName, {
+          source: cloudManaged ? "cloud" : isConvention ? "convention" : "custom",
+          ...cloudManaged ? { cloudPolicyId: cloudManaged.id, cloudVersion: cloudManaged.version } : {}
+        });
+        registerPolicy(registeredName, hook.description ?? "", fn, hook.match ?? {}, -1);
       }
       if (customHooksList.length > 0) {
         trackHookEvent(getInstanceId(), "custom_hooks_loaded", {
@@ -8263,7 +9108,18 @@ async function evaluateHookEvent(eventType, cli = "claude", stdinPayload, opts)
       transcriptPath: session.transcriptPath,
       cwd: session.cwd,
       permissionMode: session.permissionMode,
-      hookEventName: session.hookEventName
+      hookEventName: session.hookEventName,
+      ...result.policyName ? (() => {
+        const attribution = policyAttribution.get(result.policyName);
+        return {
+          policySource: attribution?.source ?? "builtin",
+          ...attribution?.cloudPolicyId ? { cloudPolicyId: attribution.cloudPolicyId } : {},
+          ...attribution?.cloudVersion !== undefined ? { cloudVersion: attribution.cloudVersion } : {}
+        };
+      })() : {},
+      ...cloudDeployment !== undefined ? { cloudDeployment } : {},
+      ...observedResults.length > 0 ? { observed: observedResults } : {},
+      ...activePause ? { pausedBy: activePause.setBy, pauseExpiresAt: activePause.expiresAt } : {}
     };
     try {
       persistHookActivity(activityEntry);
@@ -8315,6 +9171,9 @@ var init_handler = __esm(() => {
   init_resolve_transcript_path();
   init_telemetry_id();
   init_hook_logger();
+  init_cloud_managed_policies();
+  init_session_pause();
+  init_fp_reset();
 });
 
 // src/hooks/worker-server.ts
@@ -8322,13 +9181,13 @@ var exports_worker_server = {};
 __export(exports_worker_server, {
   startWorkerServer: () => startWorkerServer
 });
-import { createServer } from "node:net";
-import { existsSync as existsSync10, unlinkSync as unlinkSync2 } from "node:fs";
+import { createConnection, createServer } from "node:net";
+import { existsSync as existsSync14, unlinkSync as unlinkSync2 } from "node:fs";
 function isWorkerHookRequest(msg) {
   if (!msg || typeof msg !== "object")
     return false;
   const m = msg;
-  return m.type === "hook" && typeof m.hookEvent === "string" && typeof m.cli === "string" && typeof m.stdin === "string" && (m.cwd === undefined || typeof m.cwd === "string");
+  return m.type === "hook" && typeof m.hookEvent === "string" && typeof m.cli === "string" && typeof m.stdin === "string" && (m.cwd === undefined || m.cwd === null || typeof m.cwd === "string");
 }
 function encodeFrame(value) {
   const body = Buffer.from(JSON.stringify(value), "utf8");
@@ -8337,9 +9196,20 @@ function encodeFrame(value) {
   return Buffer.concat([header, body]);
 }
 function enqueue(task) {
-  processingChain = processingChain.then(task).catch(() => {});
+  processingChain = processingChain.then(() => new Promise((settle) => {
+    const timer = setTimeout(() => {
+      hookLogWarn(`worker: a request did not settle within ${TASK_DEADLINE_MS}ms; ` + `exiting so the supervisor can respawn a clean worker`);
+      process.exit(WEDGED_EXIT_CODE);
+    }, TASK_DEADLINE_MS);
+    timer.unref?.();
+    const done = () => {
+      clearTimeout(timer);
+      settle();
+    };
+    task().then(done, done);
+  })).catch(() => {});
 }
-function handleConnection(socket) {
+function handleConnection(socket, shutdown) {
   let recvBuf = Buffer.alloc(0);
   let declaredLen = null;
   socket.on("data", (chunk) => {
@@ -8367,6 +9237,10 @@ function handleConnection(socket) {
         socket.write(encodeFrame({ type: "error", message: "malformed request frame" }));
         continue;
       }
+      if (message && typeof message === "object" && message.type === "shutdown") {
+        socket.end(encodeFrame({ type: "shutdownAccepted" }), shutdown);
+        return;
+      }
       if (!isWorkerHookRequest(message)) {
         socket.write(encodeFrame({ type: "error", message: "unrecognized request shape" }));
         continue;
@@ -8376,7 +9250,7 @@ function handleConnection(socket) {
         try {
           const result = await evaluateHookEvent(request.hookEvent, request.cli, request.stdin, {
             awaitTelemetryFlush: false,
-            fallbackCwd: request.cwd
+            fallbackCwd: request.cwd ?? undefined
           });
           socket.write(encodeFrame({
             type: "hookResult",
@@ -8394,17 +9268,67 @@ function handleConnection(socket) {
   });
   socket.on("error", () => {});
 }
-function startWorkerServer(socketPath) {
-  if (existsSync10(socketPath)) {
-    try {
-      unlinkSync2(socketPath);
-    } catch {}
-  }
-  const server = createServer(handleConnection);
-  server.listen(socketPath);
+function requestExistingWorkerShutdown(socketPath) {
+  return new Promise((resolvePromise, reject) => {
+    const socket = createConnection({ path: socketPath });
+    let recvBuf = Buffer.alloc(0);
+    let settled = false;
+    const timer = setTimeout(() => finish(new Error("existing worker did not acknowledge shutdown")), STALE_WORKER_SHUTDOWN_TIMEOUT_MS);
+    timer.unref?.();
+    const finish = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      if (result instanceof Error)
+        reject(result);
+      else
+        resolvePromise(result);
+    };
+    socket.on("connect", () => socket.write(encodeFrame({ type: "shutdown" })));
+    socket.on("data", (chunk) => {
+      recvBuf = Buffer.concat([recvBuf, chunk]);
+      if (recvBuf.length < 4)
+        return;
+      const len = recvBuf.readUInt32BE(0);
+      if (len > MAX_FRAME_LEN || recvBuf.length < 4 + len)
+        return;
+      try {
+        const response = JSON.parse(recvBuf.subarray(4, 4 + len).toString("utf8"));
+        if (response.type === "shutdownAccepted")
+          finish("stopped");
+        else
+          finish(new Error("existing socket belongs to a process that does not support shutdown"));
+      } catch {
+        finish(new Error("existing worker returned a malformed shutdown response"));
+      }
+    });
+    socket.on("error", (err) => {
+      if (err.code === "ECONNREFUSED" || err.code === "ENOENT")
+        finish("stale");
+      else
+        finish(err);
+    });
+  });
+}
+function startWorkerServer(socketPath, shutdown) {
+  const server = createServer((socket) => handleConnection(socket, shutdown ?? (() => server.close())));
+  const listen = () => {
+    if (existsSync14(socketPath)) {
+      try {
+        unlinkSync2(socketPath);
+      } catch {}
+    }
+    server.listen(socketPath);
+  };
+  if (!existsSync14(socketPath))
+    listen();
+  else
+    requestExistingWorkerShutdown(socketPath).then(listen, (err) => server.emit("error", err));
   return server;
 }
-var MAX_FRAME_LEN, processingChain;
+var MAX_FRAME_LEN, TASK_DEADLINE_MS = 60000, WEDGED_EXIT_CODE = 75, processingChain, STALE_WORKER_SHUTDOWN_TIMEOUT_MS = 2000;
 var init_worker_server = __esm(() => {
   init_handler();
   init_hook_logger();
@@ -8413,14 +9337,14 @@ var init_worker_server = __esm(() => {
 });
 
 // bin/failproofai-worker.mjs
-import { realpathSync } from "node:fs";
-import { dirname as dirname5, resolve as resolve10 } from "node:path";
+import { realpathSync as realpathSync2 } from "node:fs";
+import { dirname as dirname5, resolve as resolve13 } from "node:path";
 import { fileURLToPath } from "node:url";
 if (!process.env.FAILPROOFAI_PACKAGE_ROOT) {
-  process.env.FAILPROOFAI_PACKAGE_ROOT = resolve10(dirname5(realpathSync(fileURLToPath(import.meta.url))), "..");
+  process.env.FAILPROOFAI_PACKAGE_ROOT = resolve13(dirname5(realpathSync2(fileURLToPath(import.meta.url))), "..");
 }
 if (!process.env.FAILPROOFAI_DIST_PATH) {
-  process.env.FAILPROOFAI_DIST_PATH = resolve10(dirname5(realpathSync(fileURLToPath(import.meta.url))), "..", "dist");
+  process.env.FAILPROOFAI_DIST_PATH = resolve13(dirname5(realpathSync2(fileURLToPath(import.meta.url))), "..", "dist");
 }
 var socketPath = process.env.FAILPROOFAI_WORKER_SOCKET;
 if (!socketPath) {
@@ -8428,7 +9352,7 @@ if (!socketPath) {
   process.exit(1);
 }
 var { startWorkerServer: startWorkerServer2 } = await Promise.resolve().then(() => (init_worker_server(), exports_worker_server));
-var server = startWorkerServer2(socketPath);
+var server = startWorkerServer2(socketPath, shutdown);
 server.on("error", (err) => {
   console.error(`[failproofai-worker] server error: ${err.message}`);
   process.exit(1);