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

package/dist/worker.mjs

@@ -362,6 +362,37 @@ 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 = 2, 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.toml"), policiesDir = (home) => atHome(home, "policies"), localPoliciesDir = (home) => atHome(home, "policies", "local-policies"), globalPolicyConfigFile = (home) => resolve(localPoliciesDir(home), "policies-config.json"), cloudPoliciesDir = (home) => resolve(policiesDir(home), "cloud-policies"), customPoliciesDir = (home) => resolve(policiesDir(home), "custom-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(() => {
+  legacy = {
+    policyConfig: () => at("policies-config.json"),
+    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 +402,6 @@ import {
   statSync
 } from "node:fs";
 import { join } from "node:path";
-import { homedir } from "node:os";
 function ensureResolved() {
   if (resolved)
     return;
@@ -443,15 +473,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 +497,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 +509,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 +553,7 @@ function readMergedHooksConfig(cwd) {
 }
 var init_hooks_config = __esm(() => {
   init_hook_logger();
+  init_fp_home();
 });
 
 // src/hooks/policy-helpers.ts
@@ -596,7 +628,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 +687,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 +990,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 +1079,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 +1313,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 +1334,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 +1825,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 +1862,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 +1947,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 +2052,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 +2505,1080 @@ var init_builtin_policies = __esm(() => {
 });
 
 // package.json
-var version = "1.0.0-beta.0";
+var version = "1.0.0-beta.10";
 var init_package = () => {};
 
 // src/posthog-key.ts
 var POSTHOG_API_KEY = "phc_Ac1Ww1GqKc0z1SyrRWbmatEeQdlOQIsDEEdP8l8JRgX", POSTHOG_PRODUCT = "failproofai-oss";
 
+// node_modules/smol-toml/dist/date.js
+var DATE_TIME_RE, TomlDate;
+var init_date = __esm(() => {
+  /*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+  DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+  TomlDate = class TomlDate extends Date {
+    #hasDate = false;
+    #hasTime = false;
+    #offset = null;
+    constructor(date) {
+      let hasDate = true;
+      let hasTime = true;
+      let offset = "Z";
+      if (typeof date === "string") {
+        let match = date.match(DATE_TIME_RE);
+        if (match) {
+          if (!match[1]) {
+            hasDate = false;
+            date = `0000-01-01T${date}`;
+          }
+          hasTime = !!match[2];
+          hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+          if (match[2] && +match[2] > 23) {
+            date = "";
+          } else {
+            offset = match[3] || null;
+            date = date.toUpperCase();
+            if (!offset && hasTime)
+              date += "Z";
+          }
+        } else {
+          date = "";
+        }
+      }
+      super(date);
+      if (!isNaN(this.getTime())) {
+        this.#hasDate = hasDate;
+        this.#hasTime = hasTime;
+        this.#offset = offset;
+      }
+    }
+    isDateTime() {
+      return this.#hasDate && this.#hasTime;
+    }
+    isLocal() {
+      return !this.#hasDate || !this.#hasTime || !this.#offset;
+    }
+    isDate() {
+      return this.#hasDate && !this.#hasTime;
+    }
+    isTime() {
+      return this.#hasTime && !this.#hasDate;
+    }
+    isValid() {
+      return this.#hasDate || this.#hasTime;
+    }
+    toISOString() {
+      let iso = super.toISOString();
+      if (this.isDate())
+        return iso.slice(0, 10);
+      if (this.isTime())
+        return iso.slice(11, 23);
+      if (this.#offset === null)
+        return iso.slice(0, -1);
+      if (this.#offset === "Z")
+        return iso;
+      let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+      offset = this.#offset[0] === "-" ? offset : -offset;
+      let offsetDate = new Date(this.getTime() - offset * 60000);
+      return offsetDate.toISOString().slice(0, -1) + this.#offset;
+    }
+    static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+      let date = new TomlDate(jsDate);
+      date.#offset = offset;
+      return date;
+    }
+    static wrapAsLocalDateTime(jsDate) {
+      let date = new TomlDate(jsDate);
+      date.#offset = null;
+      return date;
+    }
+    static wrapAsLocalDate(jsDate) {
+      let date = new TomlDate(jsDate);
+      date.#hasTime = false;
+      date.#offset = null;
+      return date;
+    }
+    static wrapAsLocalTime(jsDate) {
+      let date = new TomlDate(jsDate);
+      date.#hasDate = false;
+      date.#offset = null;
+      return date;
+    }
+  };
+});
+
+// node_modules/smol-toml/dist/error.js
+function getLineColFromPtr(string, ptr) {
+  let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+  return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+  let lines = string.split(/\r\n|\n|\r/g);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1;i <= line + 1; i++) {
+    let l = lines[i - 1];
+    if (!l)
+      continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += `
+`;
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += `^
+`;
+    }
+  }
+  return codeblock;
+}
+var TomlError;
+var init_error = __esm(() => {
+  /*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+  TomlError = class TomlError extends Error {
+    line;
+    column;
+    codeblock;
+    constructor(message, options) {
+      const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+      const codeblock = makeCodeBlock(options.toml, line, column);
+      super(`Invalid TOML document: ${message}
+
+${codeblock}`, options);
+      this.line = line;
+      this.column = column;
+      this.codeblock = codeblock;
+    }
+  };
+});
+
+// node_modules/smol-toml/dist/primitive.js
+function parseString(str, ptr) {
+  let c = str[ptr++];
+  let first = c;
+  let isLiteral = c === "'";
+  let isMultiline = c === str[ptr] && c === str[ptr + 1];
+  if (isMultiline) {
+    if (str[ptr += 2] === `
+`)
+      ptr++;
+    else if (str[ptr] === "\r" && str[ptr + 1] === `
+`)
+      ptr += 2;
+  }
+  let parsed = "";
+  let sliceStart = ptr;
+  let state = 0;
+  for (let i = ptr;i < str.length; i++) {
+    c = str[i];
+    if (isMultiline && (c === `
+` || c === "\r" && str[i + 1] === `
+`)) {
+      state = state && 3;
+    } else if (c < " " && c !== "\t" || c === "") {
+      throw new TomlError("control characters are not allowed in strings", {
+        toml: str,
+        ptr: i
+      });
+    } else if ((!state || state === 3) && c === first && (!isMultiline || str[i + 1] === first && str[i + 2] === first)) {
+      if (isMultiline) {
+        if (str[i + 3] === first)
+          i++;
+        if (str[i + 3] === first)
+          i++;
+      }
+      return [
+        state ? parsed : parsed + str.slice(sliceStart, i),
+        i + (isMultiline ? 3 : 1)
+      ];
+    } else if (!state) {
+      if (!isLiteral && c === "\\") {
+        parsed += str.slice(sliceStart, sliceStart = i);
+        state = 1;
+      }
+    } else if (state === 1) {
+      if (c === "x" || c === "u" || c === "U") {
+        let value = 0;
+        let len = c === "x" ? 2 : c === "u" ? 4 : 8;
+        for (let j = 0;j < len; j++, i++) {
+          let hex = str.charCodeAt(i + 1);
+          let digit = hex >= 48 && hex <= 57 ? hex - 48 : hex >= 65 && hex <= 70 ? hex - 65 + 10 : hex >= 97 && hex <= 102 ? hex - 97 + 10 : -1;
+          if (digit < 0)
+            throw new TomlError("invalid non-hex character in unicode escape", { toml: str, ptr: i + 1 });
+          value = value << 4 | digit;
+        }
+        if (value < 0 || value > 1114111 || value >= 55296 && value <= 57343) {
+          throw new TomlError("invalid unicode escape", { toml: str, ptr: i });
+        }
+        parsed += String.fromCodePoint(value);
+        sliceStart = i + 1;
+        state = 0;
+      } else if (c === " " || c === "\t") {
+        state = 2;
+      } else {
+        if (c === "b")
+          parsed += "\b";
+        else if (c === "t")
+          parsed += "\t";
+        else if (c === "n")
+          parsed += `
+`;
+        else if (c === "f")
+          parsed += "\f";
+        else if (c === "r")
+          parsed += "\r";
+        else if (c === "e")
+          parsed += "\x1B";
+        else if (c === '"')
+          parsed += '"';
+        else if (c === "\\")
+          parsed += "\\";
+        else
+          throw new TomlError("unrecognized escape sequence", { toml: str, ptr: i });
+        sliceStart = i + 1;
+        state = 0;
+      }
+    } else if (c !== " " && c !== "\t") {
+      if (state === 2) {
+        throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+          toml: str,
+          ptr: sliceStart
+        });
+      }
+      state = !isLiteral && c === "\\" ? 1 : 0;
+      sliceStart = i;
+    }
+  }
+  throw new TomlError("unfinished string", { toml: str, ptr });
+}
+function parseValue(value, toml, ptr, integersAsBigInt) {
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (value === "-inf")
+    return -Infinity;
+  if (value === "inf" || value === "+inf")
+    return Infinity;
+  if (value === "nan" || value === "+nan" || value === "-nan")
+    return NaN;
+  if (value === "-0")
+    return integersAsBigInt ? 0n : 0;
+  let isInt = INT_REGEX.test(value);
+  if (isInt || FLOAT_REGEX.test(value)) {
+    if (LEADING_ZERO.test(value)) {
+      throw new TomlError("leading zeroes are not allowed", {
+        toml,
+        ptr
+      });
+    }
+    value = value.replace(/_/g, "");
+    let numeric = +value;
+    if (isNaN(numeric)) {
+      throw new TomlError("invalid number", {
+        toml,
+        ptr
+      });
+    }
+    if (isInt) {
+      if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
+        throw new TomlError("integer value cannot be represented losslessly", {
+          toml,
+          ptr
+        });
+      }
+      if (isInt || integersAsBigInt === true)
+        numeric = BigInt(value);
+    }
+    return numeric;
+  }
+  const date = new TomlDate(value);
+  if (!date.isValid()) {
+    throw new TomlError("invalid value", {
+      toml,
+      ptr
+    });
+  }
+  return date;
+}
+var INT_REGEX, FLOAT_REGEX, LEADING_ZERO;
+var init_primitive = __esm(() => {
+  init_date();
+  init_error();
+  /*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+  INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+  FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+  LEADING_ZERO = /^[+-]?0[0-9_]/;
+});
+
+// node_modules/smol-toml/dist/util.js
+function indexOfNewline(str, start = 0, end = str.length) {
+  let idx = str.indexOf(`
+`, start);
+  if (str[idx - 1] === "\r")
+    idx--;
+  return idx <= end ? idx : -1;
+}
+function skipComment(str, ptr) {
+  for (let i = ptr;i < str.length; i++) {
+    let c = str[i];
+    if (c === `
+`)
+      return i;
+    if (c === "\r" && str[i + 1] === `
+`)
+      return i + 1;
+    if (c < " " && c !== "\t" || c === "") {
+      throw new TomlError("control characters are not allowed in comments", {
+        toml: str,
+        ptr
+      });
+    }
+  }
+  return str.length;
+}
+function skipVoid(str, ptr, banNewLines, banComments) {
+  let c;
+  while (true) {
+    while ((c = str[ptr]) === " " || c === "\t" || !banNewLines && (c === `
+` || c === "\r" && str[ptr + 1] === `
+`))
+      ptr++;
+    if (banComments || c !== "#")
+      break;
+    ptr = skipComment(str, ptr);
+  }
+  return ptr;
+}
+function skipUntil(str, ptr, sep, end, banNewLines = false) {
+  if (!end) {
+    ptr = indexOfNewline(str, ptr);
+    return ptr < 0 ? str.length : ptr;
+  }
+  for (let i = ptr;i < str.length; i++) {
+    let c = str[i];
+    if (c === "#") {
+      i = indexOfNewline(str, i);
+      if (i < 0)
+        break;
+    } else if (c === sep) {
+      return i + 1;
+    } else if (c === end || banNewLines && (c === `
+` || c === "\r" && str[i + 1] === `
+`)) {
+      return i;
+    }
+  }
+  throw new TomlError("cannot find end of structure", {
+    toml: str,
+    ptr
+  });
+}
+var init_util = __esm(() => {
+  init_error();
+  /*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+});
+
+// node_modules/smol-toml/dist/extract.js
+function sliceAndTrimEndOf(str, startPtr, endPtr) {
+  let value = str.slice(startPtr, endPtr);
+  let commentIdx = value.indexOf("#");
+  if (commentIdx > -1) {
+    skipComment(str, commentIdx);
+    value = value.slice(0, commentIdx);
+  }
+  return [value.trimEnd(), commentIdx];
+}
+function extractValue(str, ptr, end, depth, integersAsBigInt) {
+  if (depth === 0) {
+    throw new TomlError("document contains excessively nested structures. aborting.", {
+      toml: str,
+      ptr
+    });
+  }
+  let c = str[ptr];
+  if (c === "[" || c === "{") {
+    let [value, endPtr2] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
+    if (end) {
+      endPtr2 = skipVoid(str, endPtr2);
+      if (str[endPtr2] === ",")
+        endPtr2++;
+      else if (str[endPtr2] !== end) {
+        throw new TomlError("expected comma or end of structure", {
+          toml: str,
+          ptr: endPtr2
+        });
+      }
+    }
+    return [value, endPtr2];
+  }
+  if (c === '"' || c === "'") {
+    let [parsed, endPtr2] = parseString(str, ptr);
+    if (end) {
+      endPtr2 = skipVoid(str, endPtr2);
+      if (str[endPtr2] && str[endPtr2] !== "," && str[endPtr2] !== end && str[endPtr2] !== `
+` && str[endPtr2] !== "\r") {
+        throw new TomlError("unexpected character encountered", {
+          toml: str,
+          ptr: endPtr2
+        });
+      }
+      if (str[endPtr2] === ",")
+        endPtr2++;
+    }
+    return [parsed, endPtr2];
+  }
+  let endPtr = skipUntil(str, ptr, ",", end);
+  let slice = sliceAndTrimEndOf(str, ptr, endPtr - (str[endPtr - 1] === "," ? 1 : 0));
+  if (!slice[0]) {
+    throw new TomlError("incomplete key-value declaration: no value specified", {
+      toml: str,
+      ptr
+    });
+  }
+  if (end && slice[1] > -1) {
+    endPtr = skipVoid(str, ptr + slice[1]);
+    if (str[endPtr] === ",")
+      endPtr++;
+  }
+  return [
+    parseValue(slice[0], str, ptr, integersAsBigInt),
+    endPtr
+  ];
+}
+var init_extract = __esm(() => {
+  init_primitive();
+  init_struct();
+  init_util();
+  init_error();
+  /*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+});
+
+// node_modules/smol-toml/dist/struct.js
+function parseKey(str, ptr, end = "=") {
+  let dot = ptr - 1;
+  let parsed = [];
+  let endPtr = str.indexOf(end, ptr);
+  if (endPtr < 0) {
+    throw new TomlError("incomplete key-value: cannot find end of key", {
+      toml: str,
+      ptr
+    });
+  }
+  do {
+    let c = str[ptr = ++dot];
+    if (c !== " " && c !== "\t") {
+      if (c === '"' || c === "'") {
+        if (c === str[ptr + 1] && c === str[ptr + 2]) {
+          throw new TomlError("multiline strings are not allowed in keys", {
+            toml: str,
+            ptr
+          });
+        }
+        let [part, eos] = parseString(str, ptr);
+        dot = str.indexOf(".", eos);
+        let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
+        let newLine = indexOfNewline(strEnd);
+        if (newLine > -1) {
+          throw new TomlError("newlines are not allowed in keys", {
+            toml: str,
+            ptr: ptr + dot + newLine
+          });
+        }
+        if (strEnd.trimStart()) {
+          throw new TomlError("found extra tokens after the string part", {
+            toml: str,
+            ptr: eos
+          });
+        }
+        if (endPtr < eos) {
+          endPtr = str.indexOf(end, eos);
+          if (endPtr < 0) {
+            throw new TomlError("incomplete key-value: cannot find end of key", {
+              toml: str,
+              ptr
+            });
+          }
+        }
+        parsed.push(part);
+      } else {
+        dot = str.indexOf(".", ptr);
+        let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
+        if (!KEY_PART_RE.test(part)) {
+          throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
+            toml: str,
+            ptr
+          });
+        }
+        parsed.push(part.trimEnd());
+      }
+    }
+  } while (dot + 1 && dot < endPtr);
+  return [parsed, skipVoid(str, endPtr + 1, true, true)];
+}
+function parseInlineTable(str, ptr, depth, integersAsBigInt) {
+  let res = {};
+  let seen = new Set;
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "}" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "\t" && c !== `
+` && c !== "\r") {
+      let k;
+      let t = res;
+      let hasOwn = false;
+      let [key, keyEndPtr] = parseKey(str, ptr - 1);
+      for (let i = 0;i < key.length; i++) {
+        if (i)
+          t = hasOwn ? t[k] : t[k] = {};
+        k = key[i];
+        if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+          throw new TomlError("trying to redefine an already defined value", {
+            toml: str,
+            ptr
+          });
+        }
+        if (!hasOwn && k === "__proto__") {
+          Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        }
+      }
+      if (hasOwn) {
+        throw new TomlError("trying to redefine an already defined value", {
+          toml: str,
+          ptr
+        });
+      }
+      let [value, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt);
+      seen.add(value);
+      t[k] = value;
+      ptr = valueEndPtr;
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished table encountered", {
+      toml: str,
+      ptr
+    });
+  }
+  return [res, ptr];
+}
+function parseArray(str, ptr, depth, integersAsBigInt) {
+  let res = [];
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "]" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "\t" && c !== `
+` && c !== "\r") {
+      let e = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt);
+      res.push(e[0]);
+      ptr = e[1];
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished array encountered", {
+      toml: str,
+      ptr
+    });
+  }
+  return [res, ptr];
+}
+var KEY_PART_RE;
+var init_struct = __esm(() => {
+  init_primitive();
+  init_extract();
+  init_util();
+  init_error();
+  /*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+  KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+});
+
+// node_modules/smol-toml/dist/parse.js
+function peekTable(key, table, meta, type) {
+  let t = table;
+  let m = meta;
+  let k;
+  let hasOwn = false;
+  let state;
+  for (let i = 0;i < key.length; i++) {
+    if (i) {
+      t = hasOwn ? t[k] : t[k] = {};
+      m = (state = m[k]).c;
+      if (type === 0 && (state.t === 1 || state.t === 2)) {
+        return null;
+      }
+      if (state.t === 2) {
+        let l = t.length - 1;
+        t = t[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i];
+    if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) {
+      return null;
+    }
+    if (!hasOwn) {
+      if (k === "__proto__") {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+      }
+      m[k] = {
+        t: i < key.length - 1 && type === 2 ? 3 : type,
+        d: false,
+        i: 0,
+        c: {}
+      };
+    }
+  }
+  state = m[k];
+  if (state.t !== type && !(type === 1 && state.t === 3)) {
+    return null;
+  }
+  if (type === 2) {
+    if (!state.d) {
+      state.d = true;
+      t[k] = [];
+    }
+    t[k].push(t = {});
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} };
+  }
+  if (state.d) {
+    return null;
+  }
+  state.d = true;
+  if (type === 1) {
+    t = hasOwn ? t[k] : t[k] = {};
+  } else if (type === 0 && hasOwn) {
+    return null;
+  }
+  return [k, t, state.c];
+}
+function parse(toml, { maxDepth = 1000, integersAsBigInt } = {}) {
+  let res = {};
+  let meta = {};
+  let tbl = res;
+  let m = meta;
+  for (let ptr = skipVoid(toml, 0);ptr < toml.length; ) {
+    if (toml[ptr] === "[") {
+      let isTableArray = toml[++ptr] === "[";
+      let k = parseKey(toml, ptr += +isTableArray, "]");
+      if (isTableArray) {
+        if (toml[k[1] - 1] !== "]") {
+          throw new TomlError("expected end of table declaration", {
+            toml,
+            ptr: k[1] - 1
+          });
+        }
+        k[1]++;
+      }
+      let p = peekTable(k[0], res, meta, isTableArray ? 2 : 1);
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      m = p[2];
+      tbl = p[1];
+      ptr = k[1];
+    } else {
+      let k = parseKey(toml, ptr);
+      let p = peekTable(k[0], tbl, m, 0);
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      let v = extractValue(toml, k[1], undefined, maxDepth, integersAsBigInt);
+      p[1][p[0]] = v[0];
+      ptr = v[1];
+    }
+    ptr = skipVoid(toml, ptr, true);
+    if (toml[ptr] && toml[ptr] !== `
+` && toml[ptr] !== "\r") {
+      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+        toml,
+        ptr
+      });
+    }
+    ptr = skipVoid(toml, ptr);
+  }
+  return res;
+}
+var init_parse = __esm(() => {
+  init_struct();
+  init_extract();
+  init_util();
+  init_error();
+  /*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+});
+
+// node_modules/smol-toml/dist/stringify.js
+var init_stringify = __esm(() => {
+  /*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+});
+
+// node_modules/smol-toml/dist/index.js
+var init_dist = __esm(() => {
+  init_parse();
+  init_stringify();
+  init_date();
+  init_error();
+  /*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+});
+
+// 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 };
+  }
+  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 readVersionFile() {
+  try {
+    const parsed = parse(readFileSync2(versionFile(), "utf8"));
+    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 null;
+  }
+}
+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 readConfig() {
+  try {
+    const parsed = parse(readFileSync2(configFile(), "utf8"));
+    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
+      },
+      telemetry: { enabled: telemetry.enabled !== false },
+      audit: { auto: audit.auto === true, intervalDays: readIntervalDays(audit.interval_days) }
+    };
+  } catch {
+    return structuredClone(DEFAULT_CONFIG);
+  }
+}
+var DEFAULT_AUDIT_INTERVAL_DAYS = 7, MIN_AUDIT_INTERVAL_DAYS = 1, MAX_AUDIT_INTERVAL_DAYS = 90, DEFAULT_CONFIG;
+var init_fp_config = __esm(() => {
+  init_dist();
+  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 +3597,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 +3612,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 +3676,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 +4471,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: stat2 } = await import("fs/promises");
+    for (const name of await readdir(dir)) {
+      if (!isTmpArtifact(name))
+        continue;
+      const path2 = resolve4(dir, name);
+      try {
+        const info = await stat2(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 +4519,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 +4535,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 +4564,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 +4596,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 +4628,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 +4641,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 +4654,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 +4716,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 +4753,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 +4781,25 @@ 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((opts?.cloudManagedPolicies ?? []).map((policy) => [resolve5(policy.path), 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.revision}:${hook.name}`;
+          } else {
+            tagged.__policyId = customPolicyId(absPath, hook.name);
+          }
         }
       }
     } else {
@@ -3372,9 +4807,12 @@ async function loadAllCustomHooks(customPoliciesPaths, opts) {
     }
   }
   const hooksBeforeConvention = getCustomHooks().length;
-  const projectDir = resolve4(projectRoot, ".failproofai", "policies");
-  if (conventionEnabled)
+  const projectDir = resolve5(projectRoot, ".failproofai", "policies");
+  if (conventionEnabled) {
+    sweepStaleTmpArtifacts(projectDir);
     warnSkippedPolicyFiles(projectDir, "project");
+  }
+  sweepStaleTmpArtifacts(shimsDir());
   const projectFiles = conventionEnabled ? discoverPolicyFiles(projectDir).filter((f) => !loadedPaths.has(f)) : [];
   for (const file of projectFiles) {
     loadedPaths.add(file);
@@ -3392,9 +4830,11 @@ async function loadAllCustomHooks(customPoliciesPaths, opts) {
       });
     }
   }
-  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 +4876,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 +4884,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 +4931,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 +4959,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,12 +4973,12 @@ 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: {} };
   }
@@ -3554,20 +4995,19 @@ 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`);
+  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));
   } catch {
     try {
       unlinkSync(tmpPath);
     } catch {}
   }
 }
-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;
+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 +5056,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)) {
@@ -3713,8 +5153,8 @@ __export(exports_codex_projects, {
   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 { homedir as homedir5 } from "node:os";
+import { join as join6 } from "node:path";
 async function safeReaddir(dir) {
   try {
     return await readdir(dir, { withFileTypes: true });
@@ -3762,7 +5202,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 +5212,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));
       }
     }
@@ -3892,7 +5332,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 +5351,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 as stat2 } 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 {
@@ -3944,13 +5384,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 +5499,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 stat3 } 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 {
@@ -4095,12 +5535,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 +5552,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 +5562,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 +5570,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 +5579,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 +5872,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 stat4 } 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 {
@@ -4455,7 +5895,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 +5924,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 +5934,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 +6036,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 +6063,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 +6087,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 +6096,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 +6115,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 +6123,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 +6174,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 +6477,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 +6597,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 +6612,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 +6625,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 +6649,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 +6685,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 +6846,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 +7000,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 +7013,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 +7037,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 +7139,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 +7441,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 +7575,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 +7588,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 +7601,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 +7628,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 +7773,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)) {
@@ -6610,7 +8050,7 @@ 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 { join as join19, resolve as resolve7, sep } from "node:path";
 async function getMtime(path2, label) {
   try {
     return (await stat5(path2)).mtime;
@@ -6636,7 +8076,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 +8202,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 +8221,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 +8250,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 +8277,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 +8472,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 +8483,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 +8509,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 +8543,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 +8565,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 +8784,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 +8812,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 +8837,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 +8860,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 +9039,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 +9054,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 +9073,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 +9094,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 +9294,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 +9310,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 +9323,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 +9331,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 +9344,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 +9365,7 @@ function extractMessageText(content) {
 
 `);
 }
-function buildAssistantContent(content) {
+function buildAssistantContent(content, onToolUse) {
   if (!Array.isArray(content))
     return [];
   const blocks = [];
@@ -7935,6 +9376,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 +9394,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 +9443,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 +9462,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 +9502,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 +9571,192 @@ 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 manifest = value;
+  if (manifest.schemaVersion !== ACTIVE_SCHEMA_VERSION) {
+    throw new Error(`unsupported active manifest schema ${String(manifest.schemaVersion)}`);
+  }
+  if (!Number.isSafeInteger(manifest.generation) || (manifest.generation ?? -1) < 0) {
+    throw new Error("active manifest generation is invalid");
+  }
+  if (!Array.isArray(manifest.policies))
+    throw new Error("active manifest policies is not an array");
+  return manifest;
+}
+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.revision) || policy.revision < 0) {
+      throw new Error(`invalid revision 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,
+      revision: policy.revision,
+      effect: policy.effect ?? "enforce",
+      sha256: policy.sha256,
+      path: path2,
+      generation: manifest.generation
+    };
+  });
+}
+var ACTIVE_SCHEMA_VERSION = 1, SHA256_RE, POLICY_ID_RE;
+var init_cloud_managed_policies = __esm(() => {
+  init_fp_home();
+  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_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
+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.`;
+  }
+  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_fp_home();
+  init_fp_config();
+  init_daemon_service();
+});
+
 // src/hooks/handler.ts
 function canonicalizeEventType(raw, cli) {
   if (cli === "codex") {
@@ -8135,8 +9791,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 +9853,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 cloudGeneration;
+    const observedResults = [];
     if (opts?.forceDecision) {
       config = { enabledPolicies: [] };
       clearPolicies();
@@ -8184,23 +9865,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
+        });
+      }
+      cloudGeneration = cloudManagedPolicies[0]?.generation;
+      const configuredCustomPaths = config.customPoliciesPaths ?? config.customPoliciesPath;
+      const allExplicitPaths = cloudManagedPolicies.length === 0 ? configuredCustomPaths : [
+        ...typeof configuredCustomPaths === "string" ? [configuredCustomPaths] : configuredCustomPaths ?? [],
+        ...cloudManagedPolicies.map((policy) => policy.path)
+      ];
+      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.revision}` : 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,
+                revision: cloudManaged.revision,
+                decision: shadow.decision,
+                reason: shadow.reason ?? null
+              });
+            }
+            return { decision: "allow" };
+          }
           try {
             const result2 = await Promise.race([
               hook.fn(ctx),
@@ -8222,7 +9939,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, cloudRevision: cloudManaged.revision } : {}
+        });
+        registerPolicy(registeredName, hook.description ?? "", fn, hook.match ?? {}, -1);
       }
       if (customHooksList.length > 0) {
         trackHookEvent(getInstanceId(), "custom_hooks_loaded", {
@@ -8263,7 +9985,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?.cloudRevision !== undefined ? { cloudRevision: attribution.cloudRevision } : {}
+        };
+      })() : {},
+      ...cloudGeneration !== undefined ? { cloudGeneration } : {},
+      ...observedResults.length > 0 ? { observed: observedResults } : {},
+      ...activePause ? { pausedBy: activePause.setBy, pauseExpiresAt: activePause.expiresAt } : {}
     };
     try {
       persistHookActivity(activityEntry);
@@ -8315,6 +10048,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
@@ -8323,12 +10059,12 @@ __export(exports_worker_server, {
   startWorkerServer: () => startWorkerServer
 });
 import { createServer } from "node:net";
-import { existsSync as existsSync10, unlinkSync as unlinkSync2 } from "node:fs";
+import { existsSync as existsSync13, 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,7 +10073,18 @@ 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) {
   let recvBuf = Buffer.alloc(0);
@@ -8376,7 +10123,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",
@@ -8395,7 +10142,7 @@ function handleConnection(socket) {
   socket.on("error", () => {});
 }
 function startWorkerServer(socketPath) {
-  if (existsSync10(socketPath)) {
+  if (existsSync13(socketPath)) {
     try {
       unlinkSync2(socketPath);
     } catch {}
@@ -8404,7 +10151,7 @@ function startWorkerServer(socketPath) {
   server.listen(socketPath);
   return server;
 }
-var MAX_FRAME_LEN, processingChain;
+var MAX_FRAME_LEN, TASK_DEADLINE_MS = 60000, WEDGED_EXIT_CODE = 75, processingChain;
 var init_worker_server = __esm(() => {
   init_handler();
   init_hook_logger();
@@ -8413,14 +10160,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) {