failproofai 1.0.11 → 1.0.12-beta.1

package/dist/worker.mjs

@@ -26,8 +26,9 @@ var __esm = (fn, res, err) => () => {
 };
 
 // src/hooks/types.ts
-var CODEX_EVENT_MAP, CODEX_TOOL_MAP, HERMES_TOOL_MAP, HERMES_TOOL_INPUT_MAP, HERMES_EVENT_MAP, COPILOT_TOOL_MAP, COPILOT_TOOL_INPUT_MAP, CURSOR_EVENT_MAP, CURSOR_TOOL_MAP, OPENCODE_TOOL_MAP, OPENCODE_TOOL_INPUT_MAP, PI_EVENT_MAP, PI_TOOL_MAP, PI_TOOL_INPUT_MAP, OPENCLAW_EVENT_MAP, OPENCLAW_TOOL_MAP, OPENCLAW_TOOL_INPUT_MAP, FACTORY_TOOL_MAP, DEVIN_TOOL_MAP, ANTIGRAVITY_EVENT_MAP, ANTIGRAVITY_TOOL_MAP, ANTIGRAVITY_TOOL_INPUT_MAP, GOOSE_TOOL_MAP, GOOSE_TOOL_INPUT_MAP, HOOK_EVENT_TYPES, CLAUDE_INSTALL_EVENT_TYPES;
+var INTEGRATION_TYPES, CODEX_EVENT_MAP, CODEX_TOOL_MAP, HERMES_TOOL_MAP, HERMES_TOOL_INPUT_MAP, HERMES_EVENT_MAP, COPILOT_TOOL_MAP, COPILOT_TOOL_INPUT_MAP, CURSOR_EVENT_MAP, CURSOR_TOOL_MAP, OPENCODE_TOOL_MAP, OPENCODE_TOOL_INPUT_MAP, PI_EVENT_MAP, PI_TOOL_MAP, PI_TOOL_INPUT_MAP, OPENCLAW_EVENT_MAP, OPENCLAW_TOOL_MAP, OPENCLAW_TOOL_INPUT_MAP, FACTORY_TOOL_MAP, DEVIN_TOOL_MAP, ANTIGRAVITY_EVENT_MAP, ANTIGRAVITY_TOOL_MAP, ANTIGRAVITY_TOOL_INPUT_MAP, GOOSE_TOOL_MAP, GOOSE_TOOL_INPUT_MAP, HOOK_EVENT_TYPES, CLAUDE_INSTALL_EVENT_TYPES;
 var init_types = __esm(() => {
+  INTEGRATION_TYPES = ["claude", "codex", "copilot", "cursor", "opencode", "pi", "hermes", "openclaw", "factory", "devin", "antigravity", "goose"];
   CODEX_EVENT_MAP = {
     session_start: "SessionStart",
     pre_tool_use: "PreToolUse",
@@ -381,7 +382,7 @@ function failproofaiHome(home) {
     return resolve(home, ".failproofai");
   return process.env.FAILPROOFAI_HOME || resolve(homedir(), ".failproofai");
 }
-var LAYOUT_VERSION = 4, at = (...parts) => resolve(failproofaiHome(), ...parts), atHome = (home, ...parts) => home ? resolve(failproofaiHome(home), ...parts) : at(...parts), versionFile = (home) => atHome(home, "VERSION"), configFile = (home) => atHome(home, "config.json"), credentialsFile = (home) => atHome(home, "credentials.json"), jevConfigFile = (home) => atHome(home, "jev.json"), policiesDir = (home) => atHome(home, "policies"), customPoliciesDir, globalPolicyConfigFile = (home) => atHome(home, "policies-config.json"), cloudPoliciesDir = (home) => resolve(policiesDir(home), "cloud-policies"), packsDir = (home) => resolve(policiesDir(home), "packs"), packsInstalledFile = (home) => resolve(packsDir(home), "installed.json"), hookActivityDir = (home) => atHome(home, "hook-activity"), stateDir = (home) => atHome(home, "state"), shimsDir = (home) => resolve(stateDir(home), "shims"), sessionPauseDir = () => resolve(stateDir(), "sessions"), semanticDir = () => resolve(stateDir(), "semantic"), telemetryIdFile = (home) => resolve(stateDir(home), "telemetry-id"), codexSessionPathsFile = (home) => resolve(stateDir(home), "codex-session-paths.json"), logsDir = (home) => atHome(home, "logs"), legacy;
+var LAYOUT_VERSION = 4, at = (...parts) => resolve(failproofaiHome(), ...parts), atHome = (home, ...parts) => home ? resolve(failproofaiHome(home), ...parts) : at(...parts), versionFile = (home) => atHome(home, "VERSION"), configFile = (home) => atHome(home, "config.json"), credentialsFile = (home) => atHome(home, "credentials.json"), jevConfigFile = (home) => atHome(home, "jev.json"), agentRosterFile = (home) => atHome(home, "agents", "roster.json"), policiesDir = (home) => atHome(home, "policies"), customPoliciesDir, globalPolicyConfigFile = (home) => atHome(home, "policies-config.json"), cloudPoliciesDir = (home) => resolve(policiesDir(home), "cloud-policies"), packsDir = (home) => resolve(policiesDir(home), "packs"), packsInstalledFile = (home) => resolve(packsDir(home), "installed.json"), hookActivityDir = (home) => atHome(home, "hook-activity"), stateDir = (home) => atHome(home, "state"), shimsDir = (home) => resolve(stateDir(home), "shims"), sessionPauseDir = () => resolve(stateDir(), "sessions"), semanticDir = () => resolve(stateDir(), "semantic"), telemetryIdFile = (home) => resolve(stateDir(home), "telemetry-id"), codexSessionPathsFile = (home) => resolve(stateDir(home), "codex-session-paths.json"), logsDir = (home) => atHome(home, "logs"), legacy;
 var init_fp_home = __esm(() => {
   customPoliciesDir = policiesDir;
   legacy = {
@@ -1165,9 +1166,55 @@ function instruct(reason) {
 }
 
 // package.json
-var version = "1.0.11";
+var version = "1.0.12-beta.1";
 var init_package = () => {};
 
+// src/hooks/agent-targets.ts
+function validAgentIdentity(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const agent = value;
+  return Object.keys(agent).every((key) => key === "integration" || key === "instanceId") && typeof agent.integration === "string" && integrations.has(agent.integration) && typeof agent.instanceId === "string" && INSTANCE_ID_RE.test(agent.instanceId);
+}
+function parseAgentTargets(value, schemaVersion) {
+  if (value === undefined || value === null)
+    return;
+  if (schemaVersion < 3 || !Array.isArray(value) || value.length < 1 || value.length > 32) {
+    throw new Error("invalid agentTargets in cloud-managed active manifest");
+  }
+  const seen = new Set;
+  return value.map((raw) => {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+      throw new Error("invalid agentTargets in cloud-managed active manifest");
+    }
+    const entry = raw;
+    if (Object.keys(entry).some((key) => key !== "integration" && key !== "instanceId") || typeof entry.integration !== "string" || !integrations.has(entry.integration) || entry.instanceId !== undefined && (typeof entry.instanceId !== "string" || !INSTANCE_ID_RE.test(entry.instanceId))) {
+      throw new Error("invalid agentTargets in cloud-managed active manifest");
+    }
+    const key = `${entry.integration}\x00${entry.instanceId ?? ""}`;
+    if (seen.has(key))
+      throw new Error("duplicate agentTargets in cloud-managed active manifest");
+    seen.add(key);
+    return {
+      integration: entry.integration,
+      ...entry.instanceId !== undefined ? { instanceId: entry.instanceId } : {}
+    };
+  });
+}
+function agentTargetsMatch(targets, agent) {
+  if (targets === undefined)
+    return true;
+  if (!validAgentIdentity(agent))
+    return false;
+  return targets.some((target) => target.integration === agent.integration && (target.instanceId === undefined || target.instanceId === agent.instanceId));
+}
+var INSTANCE_ID_RE, integrations;
+var init_agent_targets = __esm(() => {
+  init_types();
+  INSTANCE_ID_RE = /^agt_[0-9a-f]{16,32}$/;
+  integrations = new Set(INTEGRATION_TYPES);
+});
+
 // src/hooks/policy-types.ts
 function effectiveAuthority(p) {
   if (p.alwaysOn === true)
@@ -1298,11 +1345,22 @@ var init_policy_authority = __esm(() => {
 
 // src/hooks/cloud-managed-policies.ts
 import { createHash } from "node:crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync2, realpathSync, rmSync } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync2, realpathSync, rmSync, statSync as statSync3 } from "node:fs";
 import { isAbsolute, relative, resolve as resolve3 } from "node:path";
 function cloudManagedPolicyRoot() {
   return process.env.FAILPROOFAI_CLOUD_POLICY_DIR ?? cloudPoliciesDir();
 }
+function disconnectedByConfig() {
+  try {
+    const raw = JSON.parse(readFileSync2(configFile(), "utf8"));
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+      return false;
+    const mode = raw.mode;
+    return !!mode && typeof mode === "object" && !Array.isArray(mode) && mode.kind === "oss";
+  } catch {
+    return false;
+  }
+}
 function parseManifest(value) {
   if (!value || typeof value !== "object")
     throw new Error("active manifest is not an object");
@@ -1338,20 +1396,150 @@ function resolveManagedPath(root, candidate) {
   }
   return realFile;
 }
-function readActiveCloudManagedPolicies() {
-  const root = cloudManagedPolicyRoot();
-  const activePath = resolve3(root, "active.json");
-  if (!existsSync4(activePath))
+function parseCloudJevMode(raw) {
+  return raw === "off" || raw === "observe" || raw === "enforce" ? raw : null;
+}
+function cloudJevAsks(mode) {
+  return mode === "observe" || mode === "enforce";
+}
+function fileVersion(path) {
+  try {
+    const s = statSync3(path, { bigint: true });
+    return `${s.dev}:${s.ino}:${s.mode}:${s.size}:${s.mtimeNs}:${s.ctimeNs}`;
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT" || code === "ENOTDIR")
+      return null;
+    throw err;
+  }
+}
+function readActiveJson() {
+  if (disconnectedByConfig()) {
+    activeJsonCache = null;
+    return;
+  }
+  const path = resolve3(cloudManagedPolicyRoot(), "active.json");
+  const version = fileVersion(path);
+  if (version === null) {
+    activeJsonCache = null;
+    return;
+  }
+  if (activeJsonCache && activeJsonCache.path === path && activeJsonCache.version === version)
+    return activeJsonCache.value;
+  const value = JSON.parse(readFileSync2(path, "utf8"));
+  activeJsonCache = { path, version, value };
+  return value;
+}
+function readActiveRaw() {
+  const raw = readActiveJson();
+  if (raw === undefined)
+    return null;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    throw new Error("active manifest is not an object");
+  const record = raw;
+  if (!ACCEPTED_ACTIVE_SCHEMA_VERSIONS.includes(record.schemaVersion)) {
+    throw new Error(`unsupported active manifest schema ${String(record.schemaVersion)}`);
+  }
+  return record;
+}
+function readCloudAgentScopeRequired() {
+  try {
+    return readActiveRaw()?.schemaVersion === 3;
+  } catch {
+    return false;
+  }
+}
+function readCloudJevMode() {
+  try {
+    return parseCloudJevMode(readActiveRaw()?.jevMode);
+  } catch {
+    return null;
+  }
+}
+function readCloudJevState() {
+  let active;
+  try {
+    active = readActiveRaw();
+  } catch {
+    return noCloudJev();
+  }
+  if (!active)
+    return noCloudJev();
+  const rawMode = active.jevMode;
+  const jevMode = parseCloudJevMode(rawMode);
+  const errors = [];
+  if (rawMode !== undefined && rawMode !== null && jevMode === null) {
+    errors.push({ id: "jevMode", version: null, kind: "daemon", message: `unknown Jev mode ${JSON.stringify(rawMode)} ignored` });
+  }
+  const deployment = Number.isSafeInteger(active.deployment) ? active.deployment : null;
+  return { jevMode, deployment, errors };
+}
+function cloudReviewerName(policyId, name) {
+  return `cloud:${policyId}/${name}`;
+}
+function cloudAuthorityDeclaration(policy, mode) {
+  if (policy.authority !== "reviewable")
+    return policy.authority ? { authority: policy.authority } : {};
+  if (policy.effect === "observe" || !cloudJevAsks(mode))
+    return { authority: "hard" };
+  return {
+    authority: "reviewable",
+    reviewedBy: (policy.reviewedBy ?? []).map((n) => CLOUD_REVIEWER_RE.test(n) ? n : cloudReviewerName(policy.id, n))
+  };
+}
+function withCloudAuthority(policy, mode) {
+  const { authority: _authority, reviewedBy: _reviewedBy, ...rest } = policy;
+  return { ...rest, ...cloudAuthorityDeclaration(policy, mode) };
+}
+function cloudReviewerNames(policies, mode) {
+  const out = [];
+  for (const policy of policies) {
+    const declared = cloudAuthorityDeclaration(policy, mode);
+    if (declared.authority === "reviewable")
+      out.push(...declared.reviewedBy ?? []);
+  }
+  return out;
+}
+function readCloudAuthorityInputs(agent = null) {
+  try {
+    const raw = readActiveJson();
+    if (raw === undefined)
+      return [];
+    const manifest = parseManifest(raw);
+    return manifest.policies.flatMap((policy) => {
+      if (typeof policy.id !== "string")
+        return [];
+      const targets = parseAgentTargets(policy.agentTargets, manifest.schemaVersion);
+      if (!agentTargetsMatch(targets, agent))
+        return [];
+      return [{
+        id: policy.id,
+        effect: policy.effect === "observe" ? "observe" : "enforce",
+        ...targets ? { agentTargets: targets } : {},
+        ...authorityFieldsOf(policy)
+      }];
+    });
+  } catch {
     return [];
+  }
+}
+function readActiveCloudManagedPolicies(agent = null) {
+  return readActiveCloudManagedPoliciesFor((targets) => agentTargetsMatch(targets, agent));
+}
+function readActiveCloudManagedPoliciesFor(applies) {
+  const root = cloudManagedPolicyRoot();
   let raw;
   try {
-    raw = JSON.parse(readFileSync2(activePath, "utf8"));
+    raw = readActiveJson();
   } catch (err) {
     throw new Error(`failed to read cloud-managed active manifest: ${err instanceof Error ? err.message : String(err)}`);
   }
+  if (raw === undefined)
+    return [];
   const manifest = parseManifest(raw);
+  const applicable = manifest.policies.filter((policy) => applies(parseAgentTargets(policy.agentTargets, manifest.schemaVersion)));
   const seen = new Set;
-  return manifest.policies.map((policy) => {
+  return applicable.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)}`);
     }
@@ -1380,17 +1568,20 @@ function readActiveCloudManagedPolicies() {
       sha256: policy.sha256,
       path,
       deployment: manifest.deployment,
+      ...parseAgentTargets(policy.agentTargets, manifest.schemaVersion) ? { agentTargets: parseAgentTargets(policy.agentTargets, manifest.schemaVersion) } : {},
       ...authorityFieldsOf(policy)
     };
   });
 }
-var ACCEPTED_ACTIVE_SCHEMA_VERSIONS, SHA256_RE, POLICY_ID_RE;
+var ACCEPTED_ACTIVE_SCHEMA_VERSIONS, SHA256_RE, POLICY_ID_RE, CLOUD_POLICY_ERRORS_FILE = "errors.json", JEV_BUDGET_FILE = "jev-budget.json", noCloudJev = () => ({ jevMode: null, deployment: null, errors: [] }), activeJsonCache = null, CLOUD_REVIEWER_RE;
 var init_cloud_managed_policies = __esm(() => {
   init_fp_home();
+  init_agent_targets();
   init_policy_authority();
-  ACCEPTED_ACTIVE_SCHEMA_VERSIONS = [1, 2];
+  ACCEPTED_ACTIVE_SCHEMA_VERSIONS = [1, 2, 3];
   SHA256_RE = /^[a-f0-9]{64}$/;
   POLICY_ID_RE = /^[A-Za-z0-9._-]{1,128}$/;
+  CLOUD_REVIEWER_RE = /^cloud:[^/]+\/./;
 });
 
 // src/hooks/semver-precedence.ts
@@ -1918,6 +2109,11 @@ function effectiveReviewerNames() {
     names = reviewerNamesFor(packs);
     cachedContested = contestedSemanticNames(packs);
   } catch {}
+  try {
+    const cloud = cloudReviewerNames(readCloudAuthorityInputs(reviewerAgent), readCloudJevMode());
+    if (cloud.length > 0)
+      names = new Set([...names, ...cloud]);
+  } catch {}
   cached = names;
   return names;
 }
@@ -1935,14 +2131,16 @@ function reviewerNamesFor(packs) {
     return NO_REVIEWERS;
   return new Set(declared);
 }
-function forgetEffectiveReviewerNames(cli) {
+function forgetEffectiveReviewerNames(cli, agent = null) {
   cached = null;
   reviewerCli = cli;
+  reviewerAgent = agent;
 }
-var cached = null, cachedContested, reviewerCli;
+var cached = null, cachedContested, reviewerCli, reviewerAgent = null;
 var init_effective_reviewers = __esm(() => {
   init_pack_manifest();
   init_policy_authority();
+  init_cloud_managed_policies();
   cachedContested = new Map;
 });
 
@@ -2009,11 +2207,11 @@ function getPoliciesForEvent(eventType, toolName) {
   cache.set(key, result);
   return result;
 }
-function clearPolicies(cli) {
+function clearPolicies(cli, agent = null) {
   const g = globalThis;
   g[REGISTRY_KEY] = [];
   setIndexCache(null);
-  forgetEffectiveReviewerNames(cli);
+  forgetEffectiveReviewerNames(cli, agent);
 }
 var REGISTRY_KEY = "__FAILPROOFAI_POLICY_REGISTRY__", INDEX_CACHE_KEY = "__FAILPROOFAI_POLICY_INDEX_CACHE__", DEFAULT_POLICY_NAMESPACE = "failproofai";
 var init_policy_registry = __esm(() => {
@@ -2023,7 +2221,7 @@ var init_policy_registry = __esm(() => {
 
 // src/hooks/builtin-policies.ts
 import { resolve as resolve5, join as join2 } from "node:path";
-import { statSync as statSync3 } from "node:fs";
+import { statSync as statSync4 } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { execSync, execFileSync } from "node:child_process";
 import { homedir as homedir3 } from "node:os";
@@ -2568,7 +2766,7 @@ function destroysFailproofaiState(command, depth = 0) {
 }
 function statGitHeadMtimeMs(cwd) {
   try {
-    return statSync3(join2(cwd, ".git", "HEAD")).mtimeMs;
+    return statSync4(join2(cwd, ".git", "HEAD")).mtimeMs;
   } catch {
     return null;
   }
@@ -4386,7 +4584,7 @@ import {
   mkdirSync as mkdirSync3,
   renameSync as renameSync2,
   rmSync as rmSync2,
-  statSync as statSync4,
+  statSync as statSync5,
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { dirname as dirname2 } from "node:path";
@@ -4401,12 +4599,12 @@ function writeJsonAtomically(filePath, value, opts = {}) {
   try {
     writeFileSync2(tmp, JSON.stringify(value, null, 2), { mode });
     try {
-      if ((statSync4(tmp).mode & 63) !== 0)
+      if ((statSync5(tmp).mode & 63) !== 0)
         chmodSync(tmp, mode);
     } catch {}
     renameSync2(tmp, filePath);
     try {
-      if ((statSync4(filePath).mode & 63) !== 0)
+      if ((statSync5(filePath).mode & 63) !== 0)
         chmodSync(filePath, mode);
     } catch {}
   } catch (err) {
@@ -4429,7 +4627,7 @@ import {
   openSync,
   readFileSync as readFileSync4,
   readSync,
-  statSync as statSync5,
+  statSync as statSync6,
   writeFileSync as writeFileSync3
 } from "node:fs";
 import { dirname as dirname3 } from "node:path";
@@ -4586,6 +4784,13 @@ function projectConfig(parsed) {
 function isAgentTraced(id, config = readConfig()) {
   return !config.agents || config.agents.selected.includes(id);
 }
+function readCredentials() {
+  try {
+    return projectCredentials(JSON.parse(readFileSync4(credentialsFile(), "utf8")));
+  } catch {
+    return {};
+  }
+}
 function projectCredentials(parsed) {
   {
     const cloud = parsed.cloud;
@@ -4661,7 +4866,7 @@ function readJevCloudCredential() {
     if (meaningful) {
       let dirMode = null;
       try {
-        const m = statSync5(dirname3(path)).mode & 511;
+        const m = statSync6(dirname3(path)).mode & 511;
         if ((m & DIR_WRITABLE_BY_OTHERS) !== 0)
           dirMode = m;
       } catch {}
@@ -5008,7 +5213,7 @@ async function evaluatePolicies(eventType, payload, session, config, twoTier) {
     twoTier: {
       activity: combined.activity,
       decidedByJev: combined.decidedByJev,
-      ...combined.decidedByJev && review.kind === "answered" && review.origin ? { jevOrigin: review.origin } : {},
+      ...(combined.decidedByJev || combined.observeVerdict) && review.kind === "answered" && review.origin ? { jevOrigin: review.origin } : {},
       ...combined.observeVerdict ? { observeVerdict: combined.observeVerdict } : {}
     }
   };
@@ -6069,7 +6274,7 @@ async function loadSingleFile(absPath, opts) {
     return null;
   } 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" : /timed out loading module/i.test(msg) ? "load_timeout" : "runtime_error";
+    const errorType = /Cannot find module|MODULE_NOT_FOUND|Cannot find package/i.test(msg) ? "module_not_found" : /ENOENT/i.test(msg) ? "file_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,
@@ -6129,8 +6334,11 @@ async function loadAllCustomHooks(customPoliciesPaths, opts) {
   const conventionEnabled = opts?.customPoliciesEnabled !== false;
   const loadedPaths = new Set;
   const cloudManagedByPath = new Map;
+  const cloudIdsByPath = new Map;
+  const cloudFailures = new Map;
   for (const policy of opts?.cloudManagedPolicies ?? []) {
     const key = resolve7(policy.path);
+    cloudIdsByPath.set(key, [...cloudIdsByPath.get(key) ?? [], policy.id]);
     const existing = cloudManagedByPath.get(key);
     if (!existing) {
       cloudManagedByPath.set(key, policy);
@@ -6211,6 +6419,10 @@ async function loadAllCustomHooks(customPoliciesPaths, opts) {
           for (const id of packIdsByPath.get(absPath) ?? [pack.id])
             packFailures.set(id, failure);
         }
+        if (failure && cloudManaged) {
+          for (const id of cloudIdsByPath.get(absPath) ?? [cloudManaged.id])
+            cloudFailures.set(id, failure);
+        }
         for (const hook of getCustomHooks().slice(hooksBefore)) {
           const tagged = hook;
           if (cloudManaged) {
@@ -6227,6 +6439,11 @@ async function loadAllCustomHooks(customPoliciesPaths, opts) {
       }
     } else {
       hookLogWarn(`custom policy path not found: ${absPath}`);
+      if (cloudManaged) {
+        const missing = { type: "path_missing", reason: `path missing: ${absPath}` };
+        for (const id of cloudIdsByPath.get(absPath) ?? [cloudManaged.id])
+          cloudFailures.set(id, missing);
+      }
       if (pack) {
         const missing = { type: "path_missing", reason: `path missing: ${absPath}` };
         for (const id of packIdsByPath.get(absPath) ?? [pack.id])
@@ -6309,7 +6526,7 @@ async function loadAllCustomHooks(customPoliciesPaths, opts) {
     if (winner && ids.length > 1)
       packAliases.set(winner.id, ids);
   }
-  return { hooks: allHooks, conventionSources, packFailures, packAliases };
+  return { hooks: allHooks, conventionSources, packFailures, packAliases, cloudFailures };
 }
 var LOADING_KEY = "__FAILPROOFAI_LOADING_HOOKS__", CONVENTION_FILE_RE, loadSequence = 0, policyModuleCache, POLICY_MODULE_CACHE_MAX_ENTRIES = 500, LOADABLE_EXT_RE, warnedSemanticOutsidePack;
 var init_custom_hooks_loader = __esm(() => {
@@ -6337,7 +6554,7 @@ import {
   readdirSync as readdirSync2,
   mkdirSync as mkdirSync5,
   existsSync as existsSync9,
-  statSync as statSync6,
+  statSync as statSync7,
   unlinkSync
 } from "node:fs";
 import { join as join4 } from "node:path";
@@ -6358,7 +6575,7 @@ function acquireLock() {
       if (e.code !== "EEXIST")
         return;
       try {
-        const s = statSync6(lockPath);
+        const s = statSync7(lockPath);
         if (Date.now() - s.mtimeMs > LOCK_STALE_MS) {
           writeFileSync4(lockPath, String(process.pid), "utf-8");
           return;
@@ -7156,7 +7373,7 @@ var init_cursor_projects = __esm(() => {
 });
 
 // lib/sqlite-reader.ts
-import { existsSync as existsSync10, readFileSync as readFileSync6, statSync as statSync7 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync6, statSync as statSync8 } from "node:fs";
 import initSqlJs from "sql.js/dist/sql-asm.js";
 async function tryNodeSqlite(dbPath) {
   try {
@@ -7180,8 +7397,8 @@ function loadSqlJs() {
     sqlPromise = initSqlJs();
   return sqlPromise;
 }
-function fileVersion(path) {
-  const stat = statSync7(path);
+function fileVersion2(path) {
+  const stat = statSync8(path);
   return { size: stat.size, mtimeMs: stat.mtimeMs, ctimeMs: stat.ctimeMs };
 }
 function sameVersion(a, b) {
@@ -7268,9 +7485,9 @@ function applyCommittedWal(db, wal) {
 function readPortableSnapshot(dbPath) {
   const walPath = `${dbPath}-wal`;
   for (let attempt = 0;attempt < 3; attempt += 1) {
-    const before = fileVersion(dbPath);
+    const before = fileVersion2(dbPath);
     const main = readFileSync6(dbPath);
-    const afterMain = fileVersion(dbPath);
+    const afterMain = fileVersion2(dbPath);
     if (!sameVersion(before, afterMain))
       continue;
     let wal = null;
@@ -7280,7 +7497,7 @@ function readPortableSnapshot(dbPath) {
       if (error.code !== "ENOENT")
         throw error;
     }
-    const afterWal = fileVersion(dbPath);
+    const afterWal = fileVersion2(dbPath);
     if (!sameVersion(before, afterWal))
       continue;
     return wal ? applyCommittedWal(main, wal) : main;
@@ -8218,7 +8435,7 @@ var init_openclaw_db = __esm(() => {
 
 // lib/openclaw-sessions.ts
 import { readFile as readFile7 } from "node:fs/promises";
-import { readdirSync as readdirSync4, statSync as statSync8 } from "node:fs";
+import { readdirSync as readdirSync4, statSync as statSync9 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
 import { join as join14 } from "node:path";
 function openclawHome() {
@@ -8371,7 +8588,7 @@ function listOpenClawTranscripts() {
         continue;
       const transcriptPath = join14(sessionsDir, file);
       try {
-        const st = statSync8(transcriptPath);
+        const st = statSync9(transcriptPath);
         out.push({
           agentId,
           sessionId,
@@ -8614,7 +8831,7 @@ var init_openclaw_projects = __esm(() => {
 
 // lib/factory-sessions.ts
 import { readFile as readFile8 } from "node:fs/promises";
-import { readdirSync as readdirSync5, statSync as statSync9 } from "node:fs";
+import { readdirSync as readdirSync5, statSync as statSync10 } from "node:fs";
 import { homedir as homedir12 } from "node:os";
 import { join as join16 } from "node:path";
 function factoryHome() {
@@ -8782,7 +8999,7 @@ function listFactoryTranscripts() {
         continue;
       const transcriptPath = join16(projectPath, file);
       try {
-        const st = statSync9(transcriptPath);
+        const st = statSync10(transcriptPath);
         out.push({ projectName, cwd, sessionId, transcriptPath, mtimeMs: st.mtimeMs, sizeBytes: st.size });
       } catch {}
     }
@@ -9201,7 +9418,7 @@ var init_devin_projects = __esm(() => {
 
 // lib/antigravity-sessions.ts
 import { readFile as readFile9 } from "node:fs/promises";
-import { readdirSync as readdirSync6, statSync as statSync10 } from "node:fs";
+import { readdirSync as readdirSync6, statSync as statSync11 } from "node:fs";
 import { homedir as homedir14 } from "node:os";
 import { join as join18 } from "node:path";
 function antigravityHome() {
@@ -9336,7 +9553,7 @@ function listAntigravityTranscripts() {
       continue;
     const transcriptPath = join18(root, conversationId, rel);
     try {
-      const st = statSync10(transcriptPath);
+      const st = statSync11(transcriptPath);
       if (!st.isFile())
         continue;
       out.push({ conversationId, transcriptPath, mtimeMs: st.mtimeMs, sizeBytes: st.size });
@@ -9349,7 +9566,7 @@ function findAntigravityTranscript(conversationId) {
     return null;
   const transcriptPath = join18(antigravityBrainRoot(), conversationId, antigravityTranscriptRelPath());
   try {
-    if (statSync10(transcriptPath).isFile())
+    if (statSync11(transcriptPath).isFile())
       return transcriptPath;
   } catch {}
   return null;
@@ -10258,7 +10475,7 @@ var init_log_entries = __esm(() => {
 });
 
 // lib/codex-sessions.ts
-import { readFileSync as readFileSync8, readdirSync as readdirSync7, existsSync as existsSync13, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, statSync as statSync11 } from "node:fs";
+import { readFileSync as readFileSync8, readdirSync as readdirSync7, existsSync as existsSync13, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, statSync as statSync12 } from "node:fs";
 import { readFile as readFile11 } from "node:fs/promises";
 import { dirname as dirname6, join as join24 } from "node:path";
 import { homedir as homedir16 } from "node:os";
@@ -10586,7 +10803,7 @@ var init_resolve_permission_mode = __esm(() => {
 });
 
 // lib/copilot-sessions.ts
-import { readFileSync as readFileSync10, readdirSync as readdirSync8, existsSync as existsSync14, statSync as statSync12 } from "node:fs";
+import { readFileSync as readFileSync10, readdirSync as readdirSync8, existsSync as existsSync14, statSync as statSync13 } from "node:fs";
 import { readFile as readFile12 } from "node:fs/promises";
 import { join as join25, resolve as resolve10, sep as sep2 } from "node:path";
 import { homedir as homedir17 } from "node:os";
@@ -10803,7 +11020,7 @@ var init_copilot_sessions = __esm(() => {
 });
 
 // lib/cursor-sessions.ts
-import { readFileSync as readFileSync11, readdirSync as readdirSync9, existsSync as existsSync15, statSync as statSync13 } from "node:fs";
+import { readFileSync as readFileSync11, readdirSync as readdirSync9, existsSync as existsSync15, statSync as statSync14 } from "node:fs";
 import { readFile as readFile13 } from "node:fs/promises";
 import { basename as basename3, join as join26, resolve as resolve11, sep as sep3 } from "node:path";
 import { homedir as homedir18 } from "node:os";
@@ -11059,7 +11276,7 @@ var init_cursor_sessions = __esm(() => {
 });
 
 // lib/pi-sessions.ts
-import { readFileSync as readFileSync12, readdirSync as readdirSync10, existsSync as existsSync16, statSync as statSync14 } from "node:fs";
+import { readFileSync as readFileSync12, readdirSync as readdirSync10, existsSync as existsSync16, statSync as statSync15 } from "node:fs";
 import { readFile as readFile14 } from "node:fs/promises";
 import { join as join27, resolve as resolve12, sep as sep4 } from "node:path";
 import { homedir as homedir19 } from "node:os";
@@ -11320,6 +11537,238 @@ var init_resolve_transcript_path = __esm(() => {
   init_factory_sessions();
   init_antigravity_sessions();
 });
+// src/hooks/cloud-policy-errors.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { chmodSync as chmodSync3, existsSync as existsSync17, readFileSync as readFileSync13, renameSync as renameSync4, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "node:fs";
+import { homedir as homedir20 } from "node:os";
+import { resolve as resolve13 } from "node:path";
+function isPackDropEntry(e) {
+  return e.id.startsWith("pack:") && (e.message.startsWith(JEV_BUDGET) || e.message.startsWith(JEV_NAME_CLASH));
+}
+function redactLocalPaths(message, home = safeHomedir()) {
+  let text = message;
+  const base = home?.replace(/\/+$/, "") ?? "";
+  if (base.length > 1) {
+    let out = "";
+    let rest = text;
+    for (let at = rest.indexOf(base);at >= 0; at = rest.indexOf(base)) {
+      const next = rest.charAt(at + base.length);
+      const whole = next === "" || next === "/" || next === ":" || PATH_END.test(next);
+      out += rest.slice(0, at) + (whole ? "~" : base);
+      rest = rest.slice(at + base.length);
+    }
+    text = out + rest;
+  }
+  return text.replace(/(^|[\s"'`(\[<{=,]|:(?!\/\/(?!\/)))(\/[^\s"'`)\]>},;]*)/g, (_m, lead, path) => {
+    const last = path.replace(/\/+$/, "").split("/").pop() ?? "";
+    return lead + (last === "" ? "/" : last);
+  });
+}
+function safeHomedir() {
+  try {
+    return homedir20();
+  } catch {
+    return null;
+  }
+}
+function cloudPolicyErrorsPath() {
+  return resolve13(cloudManagedPolicyRoot(), CLOUD_POLICY_ERRORS_FILE);
+}
+function readCloudPolicyErrors() {
+  try {
+    const raw = JSON.parse(readFileSync13(cloudPolicyErrorsPath(), "utf8"));
+    if (!Array.isArray(raw.errors))
+      return null;
+    return raw.errors.filter((e) => !!e && typeof e === "object" && typeof e.id === "string" && typeof e.message === "string" && KINDS.has(e.kind) && (e.version === null || Number.isSafeInteger(e.version)));
+  } catch {
+    return null;
+  }
+}
+function serialize(errors) {
+  const list = errors.map((e) => ({ id: e.id, version: e.version, kind: e.kind, message: redactLocalPaths(e.message) }));
+  return `${JSON.stringify({ errors: list }, null, 2)}
+`;
+}
+function writeCloudPolicyErrors(errors) {
+  try {
+    const root = cloudManagedPolicyRoot();
+    if (!existsSync17(resolve13(root, "active.json")))
+      return "skipped";
+    const path = cloudPolicyErrorsPath();
+    const text = serialize(errors);
+    if (lastWritten && lastWritten.path === path && lastWritten.text === text && existsSync17(path))
+      return "unchanged";
+    let current = null;
+    try {
+      current = readFileSync13(path, "utf8");
+    } catch {
+      current = null;
+    }
+    if (current === text) {
+      lastWritten = { path, text };
+      return "unchanged";
+    }
+    if (current === null && errors.length === 0)
+      return "skipped";
+    writeAtomic(path, text);
+    lastWritten = { path, text };
+    return "written";
+  } catch {
+    return "failed";
+  }
+}
+function cloudLoadCheckedPath() {
+  return resolve13(cloudManagedPolicyRoot(), CLOUD_LOAD_CHECKED_FILE);
+}
+function readCloudLoadChecked() {
+  try {
+    const raw = JSON.parse(readFileSync13(cloudLoadCheckedPath(), "utf8"));
+    if (!Number.isSafeInteger(raw.deployment) || !Array.isArray(raw.checked))
+      return null;
+    return { deployment: raw.deployment, checked: raw.checked.filter((c) => typeof c === "string") };
+  } catch {
+    return null;
+  }
+}
+function recordCloudLoadChecked(deployment, policies) {
+  try {
+    if (!existsSync17(resolve13(cloudManagedPolicyRoot(), "active.json")))
+      return;
+    const path = cloudLoadCheckedPath();
+    const prior = readCloudLoadChecked();
+    const base = prior && prior.deployment === deployment ? prior.checked : [];
+    const next = [...new Set([...base, ...policies.map((p) => `${p.id}@${p.version}`)])].sort();
+    if (prior && prior.deployment === deployment && next.length === base.length)
+      return;
+    const text = `${JSON.stringify({ deployment, checked: next }, null, 2)}
+`;
+    writeAtomic(path, text);
+  } catch {}
+}
+function kindOf(policy) {
+  return policy.authority === "reviewable" && (policy.reviewedBy?.length ?? 0) > 0 ? "both" : "regex";
+}
+function collectCloudPolicyErrors(input) {
+  const out = [];
+  if (input.manifestError) {
+    out.push({ id: "active.json", version: null, kind: "daemon", message: `Cloud policies could not be loaded: ${input.manifestError}` });
+  }
+  if (input.agentScopeUnresolved) {
+    out.push({
+      id: "agentScope",
+      version: null,
+      kind: "daemon",
+      message: "agent_scope_unresolved: this hook's agent profile is unknown; targeted Cloud policies did not match"
+    });
+  }
+  for (const policy of input.jsPolicies) {
+    const failure = input.jsFailures?.get(policy.id);
+    if (failure) {
+      out.push({ id: policy.id, version: policy.version, kind: kindOf(policy), message: `policy did not load (${failure.type}): ${failure.reason}` });
+    }
+  }
+  out.push(...input.jev.errors);
+  out.push(...input.budgetDrops ?? []);
+  if (input.jevProblem) {
+    out.push({ id: "jevMode", version: null, kind: "daemon", message: input.jevProblem });
+  }
+  out.push(...input.health ?? []);
+  const seen = new Set;
+  return out.map((e) => ({ ...e, message: redactLocalPaths(e.message) })).filter((e) => {
+    const key = `${e.id}\x00${e.version}\x00${e.kind}\x00${e.message}`;
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+}
+function jevBudgetPath() {
+  return resolve13(cloudManagedPolicyRoot(), JEV_BUDGET_FILE);
+}
+function readJevBudgetRecord() {
+  try {
+    const raw = JSON.parse(readFileSync13(jevBudgetPath(), "utf8"));
+    if (typeof raw.machineId !== "string" || !(raw.deployment === null || Number.isSafeInteger(raw.deployment)) || raw.jevMode !== "observe" && raw.jevMode !== "enforce" || !Array.isArray(raw.dropped)) {
+      return null;
+    }
+    const dropped = raw.dropped.filter((d) => !!d && typeof d.packId === "string" && typeof d.name === "string").map((d) => ({ packId: d.packId, name: d.name, ...d.clash === true ? { clash: true } : {} }));
+    return { machineId: raw.machineId, deployment: raw.deployment, jevMode: raw.jevMode, dropped };
+  } catch {
+    return null;
+  }
+}
+function budgetEntries(dropped) {
+  return [...dropped].sort((a, b) => dropKey(a) < dropKey(b) ? -1 : dropKey(a) > dropKey(b) ? 1 : 0).map((d) => ({
+    id: `pack:${d.packId}`,
+    version: null,
+    kind: "daemon",
+    message: d.clash ? `${JEV_NAME_CLASH}: ${d.name} (the FailproofAI Cloud check is used)` : `${JEV_BUDGET}: dropped ${d.name}`
+  }));
+}
+function installedPackIds() {
+  try {
+    const path = resolve13(packsRoot(), "installed.json");
+    if (!existsSync17(path))
+      return new Set;
+    const raw = JSON.parse(readFileSync13(path, "utf8"));
+    if (!Array.isArray(raw.packs))
+      return null;
+    return new Set(raw.packs.map((p) => p && typeof p === "object" ? p.id : null).filter((id) => typeof id === "string"));
+  } catch {
+    return null;
+  }
+}
+function readJevBudgetDrops(key, installed = null) {
+  const record = readJevBudgetRecord();
+  if (!record || !sameKey(record, key))
+    return [];
+  return budgetEntries(installed ? record.dropped.filter((d) => installed.has(d.packId)) : record.dropped);
+}
+function recordJevBudgetDrops(key, drops) {
+  try {
+    if (drops.length === 0 || !existsSync17(resolve13(cloudManagedPolicyRoot(), "active.json")))
+      return;
+    const current = readJevBudgetRecord();
+    const base = current && sameKey(current, key) ? current.dropped : [];
+    const seen = new Set(base.map(dropKey));
+    const added = [];
+    for (const d of drops) {
+      const id = dropKey(d);
+      if (seen.has(id))
+        continue;
+      seen.add(id);
+      added.push({ packId: d.packId, name: d.name, ...d.clash === true ? { clash: true } : {} });
+    }
+    if (current && sameKey(current, key) && added.length === 0)
+      return;
+    const record = { ...key, dropped: [...base, ...added] };
+    writeAtomic(jevBudgetPath(), `${JSON.stringify(record, null, 2)}
+`);
+    const report = (readCloudPolicyErrors() ?? []).filter((e) => !isPackDropEntry(e));
+    writeCloudPolicyErrors([...report, ...budgetEntries(record.dropped)]);
+  } catch {}
+}
+function writeAtomic(path, text) {
+  const tmp = `${path}.tmp-${process.pid}-${randomUUID2()}`;
+  try {
+    writeFileSync6(tmp, text, { mode: 384, flag: "wx" });
+    chmodSync3(tmp, 384);
+    renameSync4(tmp, path);
+  } catch (err) {
+    try {
+      rmSync3(tmp, { force: true });
+    } catch {}
+    throw err;
+  }
+}
+var JEV_BUDGET = "jev_budget", JEV_NAME_CLASH = "jev_name_clash", PATH_END, KINDS, lastWritten = null, CLOUD_LOAD_CHECKED_FILE = "load-checked.json", sameKey = (a, b) => a.machineId === b.machineId && a.deployment === b.deployment && a.jevMode === b.jevMode, dropKey = (d) => `${d.packId}\x00${d.name}\x00${d.clash === true}`;
+var init_cloud_policy_errors = __esm(() => {
+  init_cloud_managed_policies();
+  init_pack_manifest();
+  PATH_END = /[\s"'`)\]>},;]/;
+  KINDS = new Set(["regex", "jev", "both", "daemon"]);
+});
+
 // src/hooks/pack-failclosed.ts
 function declaredList(value) {
   if (value === undefined || value === null)
@@ -11448,6 +11897,7 @@ var PERMANENT_LOAD_FAILURES;
 var init_pack_failclosed = __esm(() => {
   PERMANENT_LOAD_FAILURES = new Set([
     "module_not_found",
+    "file_not_found",
     "syntax_error",
     "runtime_error",
     "path_missing"
@@ -11455,13 +11905,13 @@ var init_pack_failclosed = __esm(() => {
 });
 
 // src/hooks/session-pause.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync7, readdirSync as readdirSync11, readFileSync as readFileSync13, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync7, readdirSync as readdirSync11, readFileSync as readFileSync14, rmSync as rmSync4 } from "node:fs";
 import { createHash as createHash5 } from "node:crypto";
-import { join as join28, resolve as resolve13 } from "node:path";
+import { join as join28, resolve as resolve14 } from "node:path";
 function pauseStateDir() {
   const override = process.env.FAILPROOFAI_STATE_DIR;
   if (override)
-    return resolve13(override, "sessions");
+    return resolve14(override, "sessions");
   return sessionPauseDir();
 }
 function pauseFilePath(sessionId) {
@@ -11495,9 +11945,9 @@ function readActivePause(sessionId, now = Date.now()) {
     return null;
   try {
     const path = pauseFilePath(sessionId);
-    if (!existsSync17(path))
+    if (!existsSync18(path))
       return null;
-    const stored = parseStored(JSON.parse(readFileSync13(path, "utf8")));
+    const stored = parseStored(JSON.parse(readFileSync14(path, "utf8")));
     if (!stored)
       return null;
     if (stored.expiresAt <= now)
@@ -11517,6 +11967,12 @@ var init_session_pause = __esm(() => {
   PAUSE_CEILING_MS = 8 * 60 * 60000;
 });
 
+// src/hooks/health-probe.ts
+function isHealthProbe(eventType, parsed) {
+  return eventType === "SessionStart" && parsed.source === HEALTH_PROBE_SOURCE && parsed.session_id === undefined;
+}
+var HEALTH_PROBE_SOURCE = "failproofai-health-probe";
+
 // src/hooks/daemon-download.ts
 var init_daemon_download = __esm(() => {
   init_package();
@@ -11536,15 +11992,15 @@ var init_daemon_service = __esm(() => {
 // src/hooks/fp-reset.ts
 import {
   copyFileSync,
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   readdirSync as readdirSync12,
-  renameSync as renameSync4,
-  rmSync as rmSync4,
+  renameSync as renameSync5,
+  rmSync as rmSync5,
   rmdirSync,
-  statSync as statSync15,
-  writeFileSync as writeFileSync6
+  statSync as statSync16,
+  writeFileSync as writeFileSync7
 } from "node:fs";
 function layoutWarningForHook() {
   const state = detectLayout();
@@ -11553,7 +12009,7 @@ function layoutWarningForHook() {
   if (state.kind === "future") {
     return `[failproofai] this directory was written by a newer version (layout ${state.found} vs ${LAYOUT_VERSION}) — policies are NOT being enforced. ` + `Upgrade failproofai.`;
   }
-  if (existsSync18(globalPolicyConfigFile()))
+  if (existsSync19(globalPolicyConfigFile()))
     return null;
   return `[failproofai] setup predates this version — global policies are NOT being enforced. ` + `Run \`failproofai config\` to re-create it.`;
 }
@@ -11565,7 +12021,7 @@ var init_fp_reset = __esm(() => {
 });
 
 // src/hooks/untraced-note.ts
-import { existsSync as existsSync19, readFileSync as readFileSync15 } from "node:fs";
+import { existsSync as existsSync20, readFileSync as readFileSync16 } from "node:fs";
 import { join as join29 } from "node:path";
 function untracedNotePath(home) {
   return join29(stateDir(home), "untraced-notes.json");
@@ -11577,8 +12033,8 @@ function noteUntracedAgent(cli, sessionId, config) {
     const key = `${cli}:${sessionId ?? "no-session"}`;
     const path = untracedNotePath();
     let seen = [];
-    if (existsSync19(path)) {
-      const parsed = JSON.parse(readFileSync15(path, "utf8"));
+    if (existsSync20(path)) {
+      const parsed = JSON.parse(readFileSync16(path, "utf8"));
       if (Array.isArray(parsed))
         seen = parsed.filter((k) => typeof k === "string");
     }
@@ -11599,12 +12055,142 @@ var init_untraced_note = __esm(() => {
   init_hook_logger();
 });
 
+// src/hooks/agent-roster.ts
+import { lstatSync, readFileSync as readFileSync17, statSync as statSync17 } from "node:fs";
+import { homedir as homedir21 } from "node:os";
+import { dirname as dirname7, resolve as resolve15 } from "node:path";
+function installedHookAt(path, cli) {
+  try {
+    const stat = statSync17(path);
+    if (!stat.isFile() || stat.size > 131072)
+      return false;
+    const text = readFileSync17(path, "utf8");
+    if (text.includes("failproofai"))
+      return true;
+    if (cli !== "pi")
+      return false;
+    const config = JSON.parse(text);
+    if (!config || typeof config !== "object" || Array.isArray(config))
+      return false;
+    const packages = config.packages;
+    return Array.isArray(packages) && packages.some((entry) => typeof entry === "string" && /(?:^|\/)pi-extension\/?$/.test(entry));
+  } catch {
+    return false;
+  }
+}
+function runtimeAgentSettingsPath(cli, cwd, userHome = homedir21(), hookScope) {
+  if (cli === "hermes") {
+    if (hookScope && hookScope !== "user")
+      return null;
+    const home = process.env.HERMES_HOME;
+    return resolve15(home?.trim() ? home : resolve15(userHome, ".hermes"), "config.yaml");
+  }
+  if (cli === "openclaw") {
+    if (hookScope && hookScope !== "user")
+      return null;
+    const config = process.env.OPENCLAW_CONFIG_PATH;
+    if (config?.trim())
+      return resolve15(config);
+    const state = process.env.OPENCLAW_STATE_DIR || process.env.OPENCLAW_HOME;
+    return resolve15(state?.trim() ? state : resolve15(userHome, ".openclaw"), "openclaw.json");
+  }
+  const relative = USER_SETTINGS[cli];
+  if (!relative)
+    return null;
+  const override = cli === "codex" ? process.env.CODEX_HOME : cli === "claude" ? process.env.CLAUDE_CONFIG_DIR : undefined;
+  const user = resolve15(override?.trim() ? override : userHome, override?.trim() ? cli === "codex" ? "hooks.json" : "settings.json" : relative);
+  if (hookScope === "user")
+    return user;
+  const scopeFiles = hookScope === "local" ? cli === "claude" ? [".claude/settings.local.json"] : [] : hookScope === "project" ? (PROJECT_SETTINGS[cli] ?? []).filter((name) => name !== ".claude/settings.local.json") : PROJECT_SETTINGS[cli] ?? [];
+  const matches = new Set;
+  if (hookScope === undefined && installedHookAt(user, cli))
+    matches.add(user);
+  let dir = resolve15(cwd ?? process.cwd());
+  const userRoot = resolve15(userHome);
+  for (let depth = 0;depth < 16 && dir !== userRoot; depth++) {
+    for (const candidate of scopeFiles) {
+      const path = resolve15(dir, candidate);
+      if (installedHookAt(path, cli))
+        matches.add(path);
+    }
+    const parent = dirname7(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  if (matches.size > 1)
+    return null;
+  if (hookScope === "project" || hookScope === "local")
+    return matches.values().next().value ?? null;
+  return matches.values().next().value ?? user;
+}
+function readRuntimeAgentIdentity(cli, settingsPath) {
+  if (!settingsPath)
+    return null;
+  try {
+    const path = agentRosterFile();
+    const stat = lstatSync(path);
+    if (!stat.isFile() || (stat.mode & 63) !== 0 || stat.size > MAX_ROSTER_BYTES)
+      return null;
+    const roster = JSON.parse(readFileSync17(path, "utf8"));
+    if (!roster || typeof roster !== "object" || Array.isArray(roster))
+      return null;
+    const data = roster;
+    if (data.schemaVersion !== 1 || !Array.isArray(data.agents) || data.agents.length > MAX_ROSTER_AGENTS)
+      return null;
+    const absolute = resolve15(settingsPath);
+    const agent = data.agents.find((entry) => {
+      if (!entry || typeof entry !== "object" || Array.isArray(entry))
+        return false;
+      const record = entry;
+      return record.integration === cli && record.settingsPath === absolute && validAgentIdentity({ integration: record.integration, instanceId: record.instanceId });
+    });
+    const instanceId = agent?.instanceId;
+    return validAgentIdentity({ integration: cli, instanceId }) ? { integration: cli, instanceId } : null;
+  } catch {
+    return null;
+  }
+}
+var MAX_ROSTER_AGENTS = 256, MAX_ROSTER_BYTES = 4000000, USER_SETTINGS, PROJECT_SETTINGS;
+var init_agent_roster = __esm(() => {
+  init_fp_home();
+  init_agent_targets();
+  USER_SETTINGS = {
+    claude: ".claude/settings.json",
+    codex: ".codex/hooks.json",
+    copilot: ".copilot/hooks/failproofai.json",
+    cursor: ".cursor/hooks.json",
+    opencode: ".config/opencode/opencode.json",
+    pi: ".pi/agent/settings.json",
+    factory: ".factory/hooks.json",
+    devin: ".config/devin/config.json",
+    antigravity: ".gemini/config/hooks.json",
+    goose: ".agents/plugins/failproofai/hooks/hooks.json"
+  };
+  PROJECT_SETTINGS = {
+    claude: [".claude/settings.local.json", ".claude/settings.json"],
+    codex: [".codex/hooks.json"],
+    copilot: [".github/hooks/failproofai.json"],
+    cursor: [".cursor/hooks.json"],
+    opencode: [".opencode/opencode.json"],
+    pi: [".pi/settings.json"],
+    factory: [".factory/hooks.json"],
+    devin: [".devin/config.json"],
+    antigravity: [".agents/hooks.json"],
+    goose: [".agents/plugins/failproofai/hooks/hooks.json"]
+  };
+});
+
 // src/hooks/semantic/jev-config.ts
-import { closeSync as closeSync2, constants as fsConstants2, fstatSync as fstatSync2, openSync as openSync2, readSync as readSync2, statSync as statSync16 } from "node:fs";
-import { dirname as dirname7 } from "node:path";
+import { closeSync as closeSync2, constants as fsConstants2, fstatSync as fstatSync2, openSync as openSync2, readSync as readSync2, statSync as statSync18 } from "node:fs";
+import { dirname as dirname8 } from "node:path";
 function parseJevMode(raw) {
   return raw === "off" || raw === "observe" || raw === "enforce" ? raw : null;
 }
+function jevCloudBaseUrl(cloudBase) {
+  const url = new URL(cloudBase);
+  return `${url.origin}${url.pathname.replace(/\/+$/, "")}${JEV_CLOUD_BASE_PATH}`;
+}
 function jevConfigPath() {
   return jevConfigFile();
 }
@@ -11746,7 +12332,12 @@ function validateJevConfig(raw, envKey, cloud) {
       missingKey: true
     };
   }
-  const cfg = { provider: kind, apiKey, mode: DEFAULT_JEV_MODE, timeoutMs: JEV_CONFIG_DEFAULT_TIMEOUT_MS };
+  const cfg = {
+    provider: kind,
+    apiKey,
+    mode: DEFAULT_JEV_MODE,
+    timeoutMs: kind === JEV_CLOUD_PROVIDER ? CLOUD_JEV_TIMEOUT_MS : JEV_CONFIG_DEFAULT_TIMEOUT_MS
+  };
   if (o.baseUrl !== undefined) {
     const r = validateBaseUrl(o.baseUrl);
     if (!r.ok)
@@ -11832,7 +12423,7 @@ function looseConfigDirMode(path) {
   if (!modesAreMeaningful())
     return null;
   try {
-    const mode = statSync16(dirname7(path)).mode & 511;
+    const mode = statSync18(dirname8(path)).mode & 511;
     return (mode & DIR_WRITABLE_BY_OTHERS2) !== 0 ? mode : null;
   } catch {
     return null;
@@ -11893,8 +12484,8 @@ function inspectJevConfig() {
         path,
         mode,
         reason: "too-open",
-        problem: `its directory ${dirname7(path)} is ${dirMode.toString(8).padStart(4, "0")} — other users can write there, ` + `so they can put their own config in its place; it must be owner-only (chmod 700 ${dirname7(path)})`,
-        fix: `chmod 700 ${dirname7(path)}`
+        problem: `its directory ${dirname8(path)} is ${dirMode.toString(8).padStart(4, "0")} — other users can write there, ` + `so they can put their own config in its place; it must be owner-only (chmod 700 ${dirname8(path)})`,
+        fix: `chmod 700 ${dirname8(path)}`
       };
     }
     if (st.size > MAX_CONFIG_BYTES)
@@ -11996,7 +12587,80 @@ function loadJevConfig() {
     return null;
   }
 }
-var DEFAULT_JEV_MODE = "enforce", JEV_PROVIDER_KINDS, JEV_CLOUD_PROVIDER = "failproofai", JEV_API_KEY_ENV = "FAILPROOFAI_JEV_API_KEY", JEV_CONFIG_DEFAULT_TIMEOUT_MS = 3000, MIN_JEV_TIMEOUT_MS = 100, MAX_JEV_TIMEOUT_MS = 1e4, JEV_CALIBRATED_FAMILY, MAX_CONFIG_BYTES, OPEN_FLAGS, VERSIONED_MODEL_RE, CLOUDFLARE_ACCOUNT_ID_RE, API_KEY_RE, MODEL_RE, LOOPBACK_HOSTS, CREDENTIAL_PARAM_PARTS, CREDENTIAL_PARAM_NAMES, QUOTABLE_PARAM_RE, CREDENTIAL_PREFIX_RE, KEY_STAND_IN = "supplied-by-the-environment", DIR_WRITABLE_BY_OTHERS2 = 18, KEY_LACKS_JEV_PROBLEM = "this machine is connected to FailproofAI Cloud, but no Jev key is stored for that connection (its key lacks jev:evaluate, or the connect could not confirm it)";
+function loadJevConfigForCloudMode(mode) {
+  if (mode === "off")
+    return { config: null, machineId: null, problem: null };
+  const key = `${mode}\x00${jevInputsVersion()}`;
+  if (cloudModeMemo?.key === key)
+    return cloudModeMemo.value;
+  const value = computeCloudModeConfig(mode);
+  cloudModeMemo = { key, value };
+  return value;
+}
+function jevInputsVersion() {
+  const credentials = credentialsFile();
+  const config = configFile();
+  return [
+    process.platform,
+    credentials,
+    statVersion(credentials),
+    statVersion(dirname8(credentials)),
+    config,
+    statVersion(config)
+  ].join("\x00");
+}
+function statVersion(path) {
+  try {
+    const st = statSync18(path, { bigint: true });
+    return `${st.dev}:${st.ino}:${st.mode}:${st.size}:${st.mtimeNs}:${st.ctimeNs}`;
+  } catch (err) {
+    return `-${err.code ?? "error"}`;
+  }
+}
+function computeCloudModeConfig(mode) {
+  try {
+    if (readConfig().collector.sessions !== true) {
+      return { config: null, machineId: null, problem: TRANSCRIPTS_DISABLED_PROBLEM };
+    }
+    const credential = readJevCloudCredential();
+    if (credential.status === "absent")
+      return { config: null, machineId: null, problem: JEV_UNCONFIGURED_PROBLEM };
+    if (credential.status === "refused") {
+      return {
+        config: null,
+        machineId: null,
+        problem: `${JEV_UNCONFIGURED_PROBLEM}: the FailproofAI Cloud Jev credential is refused — ${credential.problem}`
+      };
+    }
+    const machineId = readCredentials().cloud?.machineId || null;
+    if (!machineId) {
+      return {
+        config: null,
+        machineId: null,
+        problem: `${JEV_UNCONFIGURED_PROBLEM}: this machine has no FailproofAI Cloud machine id (no policy connection in credentials.json)`
+      };
+    }
+    const raw = {
+      provider: JEV_CLOUD_PROVIDER,
+      baseUrl: jevCloudBaseUrl(cloudBaseFor(credential.credential)),
+      mode,
+      timeoutMs: CLOUD_JEV_TIMEOUT_MS
+    };
+    const r = validateJevConfig(raw, null, credential.credential);
+    return r.ok ? { config: r.value, machineId, problem: null } : { config: null, machineId, problem: `${JEV_UNCONFIGURED_PROBLEM}: the FailproofAI Cloud Jev credential — ${r.problem}` };
+  } catch (err) {
+    return { config: null, machineId: null, problem: `${JEV_UNCONFIGURED_PROBLEM}: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+function cloudBaseFor(credential) {
+  try {
+    const cloud = readCredentials().cloud;
+    if (cloud?.url && new URL(cloud.url).origin === new URL(credential.url).origin)
+      return cloud.url;
+  } catch {}
+  return credential.url;
+}
+var DEFAULT_JEV_MODE = "enforce", JEV_PROVIDER_KINDS, JEV_CLOUD_PROVIDER = "failproofai", JEV_CLOUD_BASE_PATH = "/enforcement/v1/jev", JEV_API_KEY_ENV = "FAILPROOFAI_JEV_API_KEY", JEV_CONFIG_DEFAULT_TIMEOUT_MS = 3000, CLOUD_JEV_TIMEOUT_MS = 5000, MIN_JEV_TIMEOUT_MS = 100, MAX_JEV_TIMEOUT_MS = 1e4, JEV_CALIBRATED_FAMILY, MAX_CONFIG_BYTES, OPEN_FLAGS, VERSIONED_MODEL_RE, CLOUDFLARE_ACCOUNT_ID_RE, API_KEY_RE, MODEL_RE, LOOPBACK_HOSTS, CREDENTIAL_PARAM_PARTS, CREDENTIAL_PARAM_NAMES, QUOTABLE_PARAM_RE, CREDENTIAL_PREFIX_RE, KEY_STAND_IN = "supplied-by-the-environment", DIR_WRITABLE_BY_OTHERS2 = 18, KEY_LACKS_JEV_PROBLEM = "this machine is connected to FailproofAI Cloud, but no Jev key is stored for that connection (its key lacks jev:evaluate, or the connect could not confirm it)", JEV_UNCONFIGURED_PROBLEM = "jev_unconfigured", TRANSCRIPTS_DISABLED_PROBLEM = "transcripts_disabled", cloudModeMemo = null;
 var init_jev_config = __esm(() => {
   init_fp_config();
   init_fp_home();
@@ -12015,10 +12679,127 @@ var init_jev_config = __esm(() => {
   CREDENTIAL_PREFIX_RE = /^(?:(?:sk|rk)[-_]|gh[pousr]_|github_pat_|glpat-|xox[abprs]-|AKIA[0-9A-Z]{12}|AIza[0-9A-Za-z_-]{20}|hf_[A-Za-z0-9]{16}|vck_)/;
 });
 
+// src/hooks/semantic/cloud-jev-health.ts
+function forScope(scope) {
+  if (state.scope !== scope)
+    state = fresh(scope);
+  return state;
+}
+function cloudJevGate(scope, at = clock()) {
+  const s = forScope(scope);
+  if (s.openUntil === null)
+    return { ask: true, probe: false };
+  if (at < s.openUntil || s.probing)
+    return { ask: false };
+  s.probing = true;
+  return { ask: true, probe: true };
+}
+function classifyCloudJevReview(review, opts = { reachedCloud: true }) {
+  if (review.kind === "answered")
+    return opts.reachedCloud ? "answered" : "neutral";
+  if (review.kind !== "fallback")
+    return "neutral";
+  const code = review.reason;
+  if (code === "http-429" || code === "rate-limited")
+    return "rate-limited";
+  if (FAILURES.has(code) || /^http-5\d\d$/.test(code))
+    return "failed";
+  return "neutral";
+}
+function recordCloudJevResult(scope, result, code, probe, at = clock()) {
+  if (state.scope !== scope)
+    return;
+  const s = state;
+  if (probe)
+    s.probing = false;
+  switch (result) {
+    case "answered":
+      s.failures = 0;
+      s.lastFailure = null;
+      s.openUntil = null;
+      s.rateLimited = [];
+      break;
+    case "rate-limited":
+      s.rateLimited.push(at);
+      if (code === "http-429") {
+        s.failures = 0;
+        s.openUntil = null;
+      }
+      break;
+    case "failed":
+      s.failures += 1;
+      s.lastFailure = code;
+      if (probe || s.failures >= BREAKER_FAILURES)
+        s.openUntil = at + BREAKER_OPEN_MS;
+      break;
+    case "neutral":
+      break;
+  }
+}
+function isCloudJevHealthMessage(message) {
+  return message.startsWith(JEV_RATE_LIMITED) || message.startsWith(JEV_UNAVAILABLE);
+}
+function cloudJevHealthErrors(at = clock()) {
+  const s = state;
+  const out = [];
+  s.rateLimited = s.rateLimited.filter((t) => at - t < RATE_LIMIT_WINDOW_MS);
+  const n = s.rateLimited.length;
+  if (n === 0) {
+    s.reportedRate = null;
+  } else {
+    if (s.reportedRate === null || at - s.reportedRate.at >= REPORT_REFRESH_MS)
+      s.reportedRate = { n, at };
+    const minutes = Math.round(RATE_LIMIT_WINDOW_MS / 60000);
+    const count = s.reportedRate.n;
+    out.push({
+      id: "jevMode",
+      version: null,
+      kind: "daemon",
+      message: `${JEV_RATE_LIMITED}: ${count} call${count === 1 ? "" : "s"} fell back to regex in the last ${minutes} min`
+    });
+  }
+  if (s.openUntil !== null) {
+    out.push({
+      id: "jevMode",
+      version: null,
+      kind: "daemon",
+      message: `${JEV_UNAVAILABLE}: FailproofAI Cloud Jev failed ${BREAKER_FAILURES} or more calls in a row ` + `(last: ${s.lastFailure ?? "error"}), so tool calls skip it for ${BREAKER_OPEN_MS / 1000} s at a time ` + "and the regex decides alone"
+    });
+  }
+  return out;
+}
+function reportCloudJevHealth(at = clock()) {
+  try {
+    const entries = cloudJevHealthErrors(at);
+    const text = JSON.stringify(entries);
+    if (text === state.lastReport)
+      return;
+    state.lastReport = text;
+    const report = (readCloudPolicyErrors() ?? []).filter((e) => !(e.id === "jevMode" && isCloudJevHealthMessage(e.message)));
+    writeCloudPolicyErrors([...report, ...entries]);
+  } catch {}
+}
+var BREAKER_FAILURES = 3, BREAKER_OPEN_MS = 60000, RATE_LIMIT_WINDOW_MS, REPORT_REFRESH_MS = 30000, JEV_RATE_LIMITED = "jev_rate_limited", JEV_UNAVAILABLE = "jev_unavailable", BREAKER_SKIP_REASON = "unavailable", fresh = (scope) => ({
+  scope,
+  failures: 0,
+  lastFailure: null,
+  openUntil: null,
+  probing: false,
+  rateLimited: [],
+  reportedRate: null,
+  lastReport: "[]"
+}), state, clock = () => performance.now(), FAILURES;
+var init_cloud_jev_health = __esm(() => {
+  init_cloud_policy_errors();
+  RATE_LIMIT_WINDOW_MS = 10 * 60000;
+  state = fresh("");
+  FAILURES = new Set(["timeout", "network", "malformed", "model-mismatch", "upstream-error", "error"]);
+});
+
 // src/hooks/semantic/facts.ts
-import { existsSync as existsSync20, readFileSync as readFileSync16, statSync as statSync17 } from "node:fs";
-import { homedir as homedir20 } from "node:os";
-import { dirname as dirname8, isAbsolute as isAbsolute3, resolve as resolve14 } from "node:path";
+import { existsSync as existsSync21, readFileSync as readFileSync18, statSync as statSync19 } from "node:fs";
+import { homedir as homedir22 } from "node:os";
+import { dirname as dirname9, isAbsolute as isAbsolute3, resolve as resolve16 } from "node:path";
 function classifyTool(toolName) {
   if (SHELL_TOOLS.has(toolName))
     return { toolClass: "shell", toolIsKnown: true };
@@ -12197,10 +12978,10 @@ function pathFact(token, base, projectRoot, home) {
     const slash = t.lastIndexOf("/");
     t = slash === -1 ? "." : slash === 0 ? "/" : t.slice(0, slash);
   }
-  const resolved = isAbsolute3(t) ? resolve14(t) : resolve14(base, t);
+  const resolved = isAbsolute3(t) ? resolve16(t) : resolve16(base, t);
   return { asWritten: token, resolved, relation: relationOf(resolved, projectRoot, home) };
 }
-function extractPaths(toolInput, cwd, projectRoot, scanned, home = homedir20()) {
+function extractPaths(toolInput, cwd, projectRoot, scanned, home = homedir22()) {
   const base0 = cwd ?? home;
   const facts = [];
   const seen = new Set;
@@ -12242,10 +13023,10 @@ function extractPaths(toolInput, cwd, projectRoot, scanned, home = homedir20())
 function findGitDir(start) {
   let dir = start;
   for (let i = 0;i < 40; i++) {
-    const candidate = resolve14(dir, ".git");
-    if (existsSync20(candidate))
+    const candidate = resolve16(dir, ".git");
+    if (existsSync21(candidate))
       return candidate;
-    const parent = dirname8(dir);
+    const parent = dirname9(dir);
     if (parent === dir)
       return null;
     dir = parent;
@@ -12256,7 +13037,7 @@ function findProjectRoot(cwd) {
   if (!cwd)
     return null;
   const gitDir = findGitDir(cwd);
-  return gitDir ? dirname8(gitDir) : cwd;
+  return gitDir ? dirname9(gitDir) : cwd;
 }
 function readCurrentBranch(cwd) {
   if (!cwd)
@@ -12265,15 +13046,15 @@ function readCurrentBranch(cwd) {
     const gitPath = findGitDir(cwd);
     if (!gitPath)
       return null;
-    let headFile = resolve14(gitPath, "HEAD");
-    if (statSync17(gitPath).isFile()) {
-      const pointer = readFileSync16(gitPath, "utf8").trim();
+    let headFile = resolve16(gitPath, "HEAD");
+    if (statSync19(gitPath).isFile()) {
+      const pointer = readFileSync18(gitPath, "utf8").trim();
       const m = /^gitdir:\s*(.+)$/.exec(pointer);
       if (!m)
         return null;
-      headFile = resolve14(dirname8(gitPath), m[1], "HEAD");
+      headFile = resolve16(dirname9(gitPath), m[1], "HEAD");
     }
-    const head = readFileSync16(headFile, "utf8").trim();
+    const head = readFileSync18(headFile, "utf8").trim();
     const ref = /^ref:\s*refs\/heads\/(.+)$/.exec(head);
     return ref ? ref[1] : null;
   } catch {
@@ -14815,31 +15596,31 @@ __export(exports_intent, {
   readIntent: () => readIntent
 });
 import {
-  chmodSync as chmodSync3,
+  chmodSync as chmodSync4,
   closeSync as closeSync3,
   mkdirSync as mkdirSync9,
   openSync as openSync3,
   readdirSync as readdirSync13,
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync19,
   readSync as readSync3,
-  renameSync as renameSync5,
-  statSync as statSync18,
+  renameSync as renameSync6,
+  statSync as statSync20,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "node:fs";
-import { dirname as dirname9, resolve as resolve15 } from "node:path";
+import { dirname as dirname10, resolve as resolve17 } from "node:path";
 function modesAreMeaningful2() {
   return process.platform !== "win32";
 }
 function storeDirChain() {
-  const home = resolve15(failproofaiHome());
+  const home = resolve17(failproofaiHome());
   const chain = [];
   let dir = sessionsDir();
   for (let i = 0;i < 8; i++) {
     chain.push(dir);
     if (dir === home)
       break;
-    const parent = dirname9(dir);
+    const parent = dirname10(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -14852,15 +15633,15 @@ function looseIntentStoreDir() {
   for (const dir of storeDirChain()) {
     let mode;
     try {
-      mode = statSync18(dir).mode & 511;
+      mode = statSync20(dir).mode & 511;
     } catch {
       continue;
     }
     if ((mode & DIR_WRITABLE_BY_OTHERS3) === 0)
       continue;
     try {
-      chmodSync3(dir, mode & ~DIR_WRITABLE_BY_OTHERS3);
-      if ((statSync18(dir).mode & DIR_WRITABLE_BY_OTHERS3) !== 0)
+      chmodSync4(dir, mode & ~DIR_WRITABLE_BY_OTHERS3);
+      if ((statSync20(dir).mode & DIR_WRITABLE_BY_OTHERS3) !== 0)
         return dir;
     } catch {
       return dir;
@@ -14870,7 +15651,7 @@ function looseIntentStoreDir() {
 }
 function readIntentFile(sessionId) {
   try {
-    const parsed = JSON.parse(readFileSync17(intentFile(sessionId), "utf8"));
+    const parsed = JSON.parse(readFileSync19(intentFile(sessionId), "utf8"));
     return Array.isArray(parsed?.prompts) ? parsed : { prompts: [] };
   } catch {
     return { prompts: [] };
@@ -14887,8 +15668,8 @@ function appendPrompt(sessionId, entry) {
     const target = intentFile(sessionId);
     const isNew = !fileExists2(target);
     const tmp = `${target}.${process.pid}.tmp`;
-    writeFileSync7(tmp, JSON.stringify(file), { mode: 384 });
-    renameSync5(tmp, target);
+    writeFileSync8(tmp, JSON.stringify(file), { mode: 384 });
+    renameSync6(tmp, target);
     if (isNew)
       pruneExpiredSessions(entry.at);
     return true;
@@ -14898,7 +15679,7 @@ function appendPrompt(sessionId, entry) {
 }
 function fileExists2(path) {
   try {
-    statSync18(path);
+    statSync20(path);
     return true;
   } catch {
     return false;
@@ -14911,9 +15692,9 @@ function pruneExpiredSessions(now = Date.now()) {
     for (const name of readdirSync13(dir)) {
       if (!SESSION_FILE_RE3.test(name))
         continue;
-      const path = resolve15(dir, name);
+      const path = resolve17(dir, name);
       try {
-        const st = statSync18(path);
+        const st = statSync20(path);
         if (st.isFile() && now - st.mtimeMs > INTENT_MAX_AGE_MS) {
           unlinkSync2(path);
           removed++;
@@ -15222,7 +16003,7 @@ function visitLinesBackwards(transcriptPath, maxBytes, visit) {
     return;
   let fd;
   try {
-    const st = statSync18(path);
+    const st = statSync20(path);
     if (!st.isFile() || st.size === 0)
       return;
     fd = openSync3(path, "r");
@@ -15295,7 +16076,7 @@ function readIntent(sessionId, now = Date.now()) {
   const agent = latest && typeof latest.agent === "string" && latest.agent.length > 0 ? latest.agent : null;
   return { userSaid: prompts.map((p) => p.text), agentLastMessage: agent };
 }
-var MAX_RECORDED_PROMPTS = 5, INTENT_MAX_AGE_MS, MAX_CLOCK_SKEW_MS, SESSION_ID_RE2, sessionsDir = () => resolve15(semanticDir(), "sessions"), intentFile = (sessionId) => resolve15(sessionsDir(), `${sessionId}.json`), DIR_WRITABLE_BY_OTHERS3 = 18, SESSION_FILE_RE3, NON_HUMAN_PREFIXES, CONTINUATION_PREFIX = "This session is being continued from a previous conversation", IDE_MACHINE_OPENERS, IDE_AMBIGUOUS_OPENERS, IDE_REQUEST_HEADINGS, obj = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : undefined, CLAUDE_MACHINE_SOURCES, claudeMachineTurn = (payload) => typeof payload.source === "string" && CLAUDE_MACHINE_SOURCES.has(payload.source), piMachineTurn = (payload) => payload.input_source === "extension" || payload.source === "extension", openclawMachineRun = (payload) => {
+var MAX_RECORDED_PROMPTS = 5, INTENT_MAX_AGE_MS, MAX_CLOCK_SKEW_MS, SESSION_ID_RE2, sessionsDir = () => resolve17(semanticDir(), "sessions"), intentFile = (sessionId) => resolve17(sessionsDir(), `${sessionId}.json`), DIR_WRITABLE_BY_OTHERS3 = 18, SESSION_FILE_RE3, NON_HUMAN_PREFIXES, CONTINUATION_PREFIX = "This session is being continued from a previous conversation", IDE_MACHINE_OPENERS, IDE_AMBIGUOUS_OPENERS, IDE_REQUEST_HEADINGS, obj = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : undefined, CLAUDE_MACHINE_SOURCES, claudeMachineTurn = (payload) => typeof payload.source === "string" && CLAUDE_MACHINE_SOURCES.has(payload.source), piMachineTurn = (payload) => payload.input_source === "extension" || payload.source === "extension", openclawMachineRun = (payload) => {
   const meta = obj(payload.openclaw);
   if (!meta)
     return false;
@@ -15485,6 +16266,10 @@ function normalizeNative(body, sentModel, opts) {
   if (!body || typeof body !== "object" || Array.isArray(body))
     throw new JevError("malformed", "Jev returned no object");
   const b = body;
+  const cloud = opts.cloudReply && b.cloud !== undefined ? { cloud: b.cloud } : {};
+  if ((typeof b.answers !== "object" || b.answers === null) && "cloud" in cloud && b.error === undefined) {
+    return { model: typeof b.model === "string" ? scrubSecret(b.model, opts.apiKey) : "", answers: {}, ...cloud };
+  }
   if (typeof b.answers !== "object" || b.answers === null) {
     if (b.error !== undefined) {
       const code = typeof b.error === "object" && b.error !== null ? b.error.code : undefined;
@@ -15512,7 +16297,8 @@ function normalizeNative(body, sentModel, opts) {
     model,
     answers: b.answers,
     ...usage ? { usage } : {},
-    ...unverified ? { modelUnverified: true } : {}
+    ...unverified ? { modelUnverified: true } : {},
+    ...cloud
   };
 }
 function nativeTransport(opts) {
@@ -15710,7 +16496,8 @@ function transportForConfig(input) {
           apiKey: cfg.apiKey,
           model: route.model,
           allowUnreported: false,
-          derivedBase: true
+          derivedBase: true,
+          cloudReply: true
         })),
         via: "failproofai",
         model: route.model
@@ -15880,8 +16667,8 @@ var init_pack_policies = __esm(() => {
 
 // src/hooks/semantic/evaluator.ts
 import { createHash as createHash6 } from "node:crypto";
-import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync10, renameSync as renameSync6, statSync as statSync19 } from "node:fs";
-import { resolve as resolve16 } from "node:path";
+import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync10, renameSync as renameSync7, statSync as statSync21 } from "node:fs";
+import { resolve as resolve18 } from "node:path";
 function storeCut(message) {
   return typeof message === "string" && message.length >= MAX_USER_MESSAGE_CHARS - STORE_CUT_SLACK && OMISSION_MARK.test(message);
 }
@@ -16054,14 +16841,14 @@ function appendVerdictLog(row) {
     const file = verdictLogFile();
     mkdirSync10(semanticDir(), { recursive: true, mode: 448 });
     try {
-      if (statSync19(file).size > VERDICT_LOG_MAX_BYTES)
-        renameSync6(file, `${file}.1`);
+      if (statSync21(file).size > VERDICT_LOG_MAX_BYTES)
+        renameSync7(file, `${file}.1`);
     } catch {}
     appendFileSync3(file, JSON.stringify(row) + `
 `, { mode: 384 });
   } catch {}
 }
-var DEFAULT_JEV_TIMEOUT_MS = 3000, OMISSION_MARK, STORE_CUT_SLACK = 64, VERDICT_LOG_MAX_BYTES, verdictLogFile = () => resolve16(semanticDir(), "verdicts.jsonl");
+var DEFAULT_JEV_TIMEOUT_MS = 3000, OMISSION_MARK, STORE_CUT_SLACK = 64, VERDICT_LOG_MAX_BYTES, verdictLogFile = () => resolve18(semanticDir(), "verdicts.jsonl");
 var init_evaluator = __esm(() => {
   init_fp_home();
   init_compile();
@@ -16075,6 +16862,387 @@ var init_evaluator = __esm(() => {
   VERDICT_LOG_MAX_BYTES = 5 * 1024 * 1024;
 });
 
+// src/hooks/semantic/cloud-jev.ts
+function noul2(probe) {
+  return {
+    type: "noul",
+    instructions: probe.instructions,
+    ...probe.criteria ? { criteria: { ...probe.criteria } } : {}
+  };
+}
+function cloudGlobalQuestions(intent, userSaidCount) {
+  const questions = { [INJECTION_PROBE.id]: noul2(INJECTION_PROBE) };
+  if (userSaidCount > 0) {
+    if (intent === "v1")
+      for (const probe of TASK_PROBES)
+        questions[probe.id] = noul2(probe);
+    else
+      questions[SCOPE_PROBE.id] = noul2(SCOPE_PROBE);
+  }
+  return questions;
+}
+function secretWords(toolInput) {
+  const text = (typeof toolInput.command === "string" ? toolInput.command : Object.entries(toolInput).filter(([key, v]) => typeof v === "string" && v.length <= 300 && !/content|old_string|new_string|body|text|prompt/i.test(key)).map(([, v]) => v).join(`
+`)).slice(0, MAX_SECRET_SCAN_CHARS);
+  try {
+    return redactSecretsDetailed(text, { blunt: false }).found.map((s) => s.toLowerCase()).filter((s) => s.length > 0);
+  } catch {
+    return [];
+  }
+}
+function cloudTargetScan(toolInput, scan = scanTargets(toolInput)) {
+  const secrets = scan.groups.length > 0 ? secretWords(toolInput) : [];
+  const hidden = (word) => secrets.some((s) => s === word || word.length >= 8 && s.includes(word) || s.length >= 8 && word.includes(s));
+  const groups = [];
+  let chars = 2;
+  let complete = scan.complete;
+  for (const group of scan.groups) {
+    const words = [...new Set([...group].map((w) => hidden(w) ? REDACTED_TARGET_WORD : w))].sort();
+    const cost = JSON.stringify(words).length + 1;
+    if (chars + cost > MAX_TARGET_SCAN_CHARS) {
+      complete = false;
+      break;
+    }
+    chars += cost;
+    groups.push(words);
+  }
+  return { groups, complete };
+}
+function cloudFacts(facts) {
+  const scrub = (s) => s === null ? null : redactSecrets(s, { blunt: false }).text;
+  return {
+    toolName: facts.toolName,
+    toolClass: facts.toolClass,
+    toolIsKnown: facts.toolIsKnown,
+    cwd: scrub(facts.cwd),
+    projectRoot: scrub(facts.projectRoot),
+    currentGitBranch: scrub(facts.currentGitBranch),
+    paths: facts.paths.map((p) => ({ asWritten: scrub(p.asWritten) ?? "", resolved: scrub(p.resolved) ?? "", relation: p.relation })),
+    permissionMode: facts.permissionMode
+  };
+}
+function buildCloudBlock(prepared, input, machineId, agent) {
+  const scan = scanTargets(input.toolInput);
+  const block = {
+    v: agent === undefined ? CLOUD_BLOCK_VERSION : 2,
+    machineId,
+    ...agent ? { agent } : {},
+    intentMode: prepared.intent,
+    facts: cloudFacts(prepared.facts),
+    targetScan: cloudTargetScan(input.toolInput, scan),
+    userSaid: prepared.userSaid.map((turn) => redactSecrets(turn, { blunt: true }).text.replace(REDACTION_MARKER, REDACTED_SAID)),
+    agentLastMessage: prepared.agentLastMessage,
+    userSaidCut: prepared.userSaidCut,
+    localPolicies: prepared.selected.map((p) => p.name)
+  };
+  if (blockBytes(block) > MAX_CLOUD_BLOCK_BYTES) {
+    block.userSaid = prepared.userSaid.length > 0 ? [""] : [];
+    block.userSaidCut = false;
+    block.targetScan = { ...block.targetScan, complete: false };
+  }
+  if (blockBytes(block) > MAX_CLOUD_BLOCK_BYTES) {
+    block.targetScan = { groups: [], complete: false };
+  }
+  if (block.targetScan.complete && namingReadings(block.intentMode, scan.groups, prepared.userSaid, prepared.agentLastMessage) !== namingReadings(block.intentMode, block.targetScan.groups.map((g) => new Set(g)), block.userSaid, block.agentLastMessage)) {
+    block.targetScan = { ...block.targetScan, complete: false };
+  }
+  return block;
+}
+function namingReadings(intent, groups, userSaid, agentLastMessage) {
+  const scan = { targets: new Set, groups, complete: true };
+  const said = intent === "v1" && agentLastMessage ? [...userSaid, agentLastMessage] : userSaid;
+  return [groups.length, userSaid.length > 0, everyTargetNamed(scan, said), intent === "v1" && partlyNamed(scan, said)].join();
+}
+function buildCloudRequest(prepared, input, machineId, agent) {
+  const own = prepared.compiled.request;
+  return {
+    model: own.model,
+    state: own.state,
+    questions: { ...own.questions, ...cloudGlobalQuestions(prepared.intent, prepared.userSaid.length) },
+    cloud: buildCloudBlock(prepared, input, machineId, agent)
+  };
+}
+function malformed(what) {
+  throw new JevError("malformed", `FailproofAI Cloud's reply: ${what}`);
+}
+function nullableProbability(v, what) {
+  if (v === null || v === undefined)
+    return null;
+  if (!isProbability(v))
+    malformed(`${what} is not a probability`);
+  return v;
+}
+function names(v, what) {
+  if (v === undefined || v === null)
+    return [];
+  if (!Array.isArray(v) || v.length > MAX_LIST || !v.every(isName2))
+    malformed(`${what} is not a list of names`);
+  return [...v];
+}
+function parseOutcome(raw, i) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    malformed(`outcome ${i} is not an object`);
+  const o = raw;
+  if (!isName2(o.policy))
+    malformed(`outcome ${i} has no policy name`);
+  if (o.mode !== "deny" && o.mode !== "instruct")
+    malformed(`outcome ${i} has no mode`);
+  if (!isProbability(o.evidence))
+    malformed(`outcome ${i} has no evidence`);
+  if (typeof o.targetNamedByUser !== "boolean" || typeof o.escalatedByInjection !== "boolean") {
+    malformed(`outcome ${i} is missing a flag`);
+  }
+  if (typeof o.verdict !== "string" || !VERDICTS.has(o.verdict))
+    malformed(`outcome ${i} has no verdict`);
+  if (o.intent !== undefined && (typeof o.intent !== "string" || !INTENTS.has(o.intent)))
+    malformed(`outcome ${i} has an unknown intent`);
+  if (o.targetScanIncomplete !== undefined && o.targetScanIncomplete !== true)
+    malformed(`outcome ${i} has a bad targetScanIncomplete`);
+  if (o.userCanOverride !== undefined && typeof o.userCanOverride !== "boolean")
+    malformed(`outcome ${i} has a bad userCanOverride`);
+  const origin = o.origin;
+  if (!origin || typeof origin !== "object" || typeof origin.cloudPolicyId !== "string" || !POLICY_ID_RE2.test(origin.cloudPolicyId) || !Number.isSafeInteger(origin.cloudVersion) || origin.cloudVersion < 0) {
+    malformed(`outcome ${i} has no Cloud origin`);
+  }
+  return {
+    policy: o.policy,
+    mode: o.mode,
+    ...typeof o.userCanOverride === "boolean" ? { userCanOverride: o.userCanOverride } : {},
+    origin: { packId: `cloud:${origin.cloudPolicyId}`, packVersion: String(origin.cloudVersion) },
+    evidence: o.evidence,
+    exempt: nullableProbability(o.exempt, `outcome ${i} exempt`),
+    userAsked: nullableProbability(o.userAsked, `outcome ${i} userAsked`),
+    targetNamedByUser: o.targetNamedByUser,
+    escalatedByInjection: o.escalatedByInjection,
+    verdict: o.verdict,
+    ...o.intent !== undefined ? { intent: o.intent } : {},
+    ...o.targetScanIncomplete === true ? { targetScanIncomplete: true } : {}
+  };
+}
+function parseCloudReply(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    malformed("no cloud block");
+  const block = raw;
+  const v = block.verdict;
+  if (!v || typeof v !== "object" || Array.isArray(v))
+    malformed("no verdict");
+  if (typeof v.decision !== "string" || !DECISIONS2.has(v.decision))
+    malformed("verdict has no decision");
+  if (v.reason !== null && v.reason !== undefined && typeof v.reason !== "string")
+    malformed("verdict reason is not text");
+  if (!Array.isArray(v.outcomes) || v.outcomes.length > MAX_LIST)
+    malformed("verdict has no outcomes list");
+  if (v.beyondTask !== undefined && typeof v.beyondTask !== "boolean")
+    malformed("verdict beyondTask is not a flag");
+  const outcomes = v.outcomes.map(parseOutcome);
+  const asked = names(block.asked, "asked");
+  const askedSet = new Set(asked);
+  const seen = new Set;
+  outcomes.forEach((o, i) => {
+    if (!askedSet.has(o.policy))
+      malformed(`outcome ${i} answers ${JSON.stringify(o.policy)}, which Cloud did not ask`);
+    const key = `${o.origin?.packId ?? ""}\x00${o.policy}`;
+    if (seen.has(key))
+      malformed(`outcome ${i} answers ${JSON.stringify(o.policy)} twice`);
+    seen.add(key);
+  });
+  if (outcomes.some((o) => o.verdict === "deny") && v.decision !== "deny")
+    malformed("a check denied but the verdict does not");
+  return {
+    verdict: {
+      decision: v.decision,
+      reason: typeof v.reason === "string" ? v.reason.length > MAX_CLOUD_REASON_CHARS ? `${v.reason.slice(0, MAX_CLOUD_REASON_CHARS - 1)}…` : v.reason : null,
+      outcomes,
+      injectionSuspected: nullableProbability(v.injectionSuspected, "injectionSuspected"),
+      scopeWithinRequest: nullableProbability(v.scopeWithinRequest, "scopeWithinRequest"),
+      beyondTask: v.beyondTask === true
+    },
+    asked,
+    droppedLocal: names(block.droppedLocal, "droppedLocal"),
+    droppedCloud: names(block.droppedCloud, "droppedCloud")
+  };
+}
+function joinLines(reasons) {
+  const lines = [];
+  for (const reason of reasons) {
+    if (!reason)
+      continue;
+    for (const line of reason.split(`
+`))
+      if (!lines.includes(line))
+        lines.push(line);
+  }
+  return lines.length > 0 ? lines.join(`
+`) : null;
+}
+function mergeCloudVerdict(cloud, local) {
+  const decision = RANK2[cloud.decision] >= RANK2[local.decision] ? cloud.decision : local.decision;
+  let reason;
+  if (decision === "deny") {
+    reason = cloud.decision === "deny" ? cloud.reason ?? local.reason : local.reason;
+  } else if (decision === "instruct") {
+    reason = joinLines([cloud, local].filter((v) => v.decision === "instruct").map((v) => v.reason));
+  } else {
+    reason = joinLines([cloud.reason, local.reason]);
+  }
+  const beyond = cloud.beyondTask === undefined && local.beyondTask === undefined ? undefined : cloud.beyondTask === true || local.beyondTask === true;
+  return {
+    decision,
+    reason,
+    outcomes: [...cloud.outcomes, ...local.outcomes],
+    injectionSuspected: local.injectionSuspected ?? cloud.injectionSuspected,
+    scopeWithinRequest: local.scopeWithinRequest ?? cloud.scopeWithinRequest,
+    ...beyond !== undefined ? { beyondTask: beyond } : {}
+  };
+}
+function envNumber2(name, fallback) {
+  const n = Number(process.env[name]);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+function expectedQuestions(request, prepared, dropped) {
+  if (dropped.size === 0)
+    return request;
+  const questions = Object.fromEntries(Object.entries(request.questions).filter(([id]) => {
+    const owner = prepared.compiled.owners.get(id);
+    return !(typeof owner === "string" && dropped.has(owner));
+  }));
+  return { ...request, questions };
+}
+function presentAnswers(response) {
+  const out = {};
+  const answers = response.answers && typeof response.answers === "object" ? response.answers : {};
+  for (const [id, a] of Object.entries(answers)) {
+    const p = a?.noul;
+    if (isProbability(p))
+      out[id] = p;
+  }
+  return out;
+}
+async function evaluateCloudSemantic(input, opts) {
+  const started = performance.now();
+  const elapsed = () => Math.round(performance.now() - started);
+  const tool = classifyTool(input.toolName);
+  if (tool.toolIsKnown && tool.toolClass === "other") {
+    return {
+      status: "ok",
+      verdict: { ...EMPTY_ALLOW, outcomes: [] },
+      answers: {},
+      latencyMs: elapsed(),
+      inputTokens: null,
+      questionCount: 0,
+      truncated: false,
+      requestCut: false,
+      redactions: 0,
+      model: opts.model ?? DEFAULT_JEV_MODEL,
+      modelVerified: true,
+      via: "none",
+      cloud: { asked: [], droppedLocal: [], droppedCloud: [] }
+    };
+  }
+  let prepared;
+  let request;
+  try {
+    prepared = prepareSemantic(input, opts);
+    request = buildCloudRequest(prepared, input, opts.machineId, opts.agent);
+  } catch (err) {
+    return {
+      status: "degraded",
+      reason: `prepare: ${err instanceof Error ? err.message : String(err)}`,
+      latencyMs: elapsed(),
+      questionCount: 0,
+      truncated: false,
+      requestCut: false
+    };
+  }
+  const questionCount = Object.keys(request.questions).length;
+  const { cloud: _block, ...forwarded } = request;
+  const oversized = prepared.oversized || JSON.stringify(forwarded).length > MAX_REQUEST_CHARS;
+  const truncated = prepared.truncated || oversized;
+  const requestCut = prepared.requestCut || oversized;
+  const degraded = (reason) => ({
+    status: "degraded",
+    reason,
+    latencyMs: elapsed(),
+    questionCount,
+    truncated,
+    requestCut
+  });
+  const transport = opts.transport;
+  if (!transport)
+    return degraded("no-transport");
+  const via = opts.via ?? "failproofai";
+  if (opts.signal?.aborted)
+    return degraded("aborted");
+  try {
+    const timeout = AbortSignal.timeout(opts.timeoutMs ?? envNumber2("FAILPROOFAI_JEV_TIMEOUT_MS", DEFAULT_JEV_TIMEOUT_MS));
+    const signal = opts.signal ? AbortSignal.any([timeout, opts.signal]) : timeout;
+    const response = await transport(request, signal);
+    const reply = parseCloudReply(response.cloud);
+    const own = new Map(prepared.selected.map((p) => [p.name, p]));
+    const dropped = new Set(reply.droppedLocal.filter((name) => own.has(name)));
+    const kept = prepared.selected.filter((p) => !dropped.has(p.name));
+    const shortCircuit = kept.length === 0 && reply.asked.length === 0 && reply.verdict.outcomes.length === 0;
+    const answers = shortCircuit ? presentAnswers(response) : readAnswers(expectedQuestions(request, prepared, dropped), response);
+    const local = prepared.intent === "v1" ? decideV1(kept, answers, input.toolInput, prepared.userSaid, prepared.agentLastMessage, {
+      ...opts.v1,
+      userSaidCut: prepared.userSaidCut
+    }) : decide(kept, answers, input.toolInput, prepared.userSaid, opts.thresholds ?? DEFAULT_THRESHOLDS, prepared.userSaidCut);
+    return {
+      status: "ok",
+      verdict: mergeCloudVerdict(reply.verdict, local),
+      answers,
+      latencyMs: elapsed(),
+      inputTokens: typeof response.usage?.input_tokens === "number" ? response.usage.input_tokens : null,
+      questionCount,
+      truncated,
+      requestCut,
+      redactions: prepared.envelope.redactions,
+      model: response.model || request.model,
+      modelVerified: response.modelUnverified !== true,
+      via,
+      cloud: {
+        asked: reply.asked,
+        droppedLocal: [...dropped].map((name) => ({ name, packId: own.get(name)?.origin?.packId ?? null })),
+        droppedCloud: reply.droppedCloud
+      }
+    };
+  } catch (err) {
+    if (opts.signal?.aborted)
+      return degraded("aborted");
+    if (err instanceof JevError)
+      return degraded(err.code);
+    if (err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError"))
+      return degraded("timeout");
+    return degraded(`error: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+var CLOUD_BLOCK_VERSION = 1, MAX_TARGET_SCAN_CHARS = 64000, MAX_CLOUD_BLOCK_BYTES = 240000, blockBytes = (block) => Buffer.byteLength(JSON.stringify(block), "utf8"), REDACTED_TARGET_WORD = "\x00redacted", MAX_SECRET_SCAN_CHARS, REDACTION_MARKER, REDACTED_SAID = "\x00", POLICY_ID_RE2, MAX_NAME_CHARS = 256, MAX_LIST = 4096, MAX_CLOUD_REASON_CHARS = 8192, isProbability = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= 1, isName2 = (v) => typeof v === "string" && v.length > 0 && v.length <= MAX_NAME_CHARS, DECISIONS2, VERDICTS, INTENTS, RANK2, EMPTY_ALLOW;
+var init_cloud_jev = __esm(() => {
+  init_compile();
+  init_decide();
+  init_envelope();
+  init_facts();
+  init_evaluator();
+  init_jev_client();
+  init_policies();
+  init_redact();
+  MAX_SECRET_SCAN_CHARS = 4 * MAX_TARGET_SCAN_CHARS;
+  REDACTION_MARKER = /<redacted:[^>]*>/g;
+  POLICY_ID_RE2 = /^[A-Za-z0-9._-]{1,128}$/;
+  DECISIONS2 = new Set(["allow", "deny", "instruct"]);
+  VERDICTS = new Set(["deny", "instruct", "overridden", "none"]);
+  INTENTS = new Set(["op-requested", "task-step", "downgraded-task-step"]);
+  RANK2 = { allow: 0, instruct: 1, deny: 2 };
+  EMPTY_ALLOW = {
+    decision: "allow",
+    reason: null,
+    outcomes: [],
+    injectionSuspected: null,
+    scopeWithinRequest: null,
+    beyondTask: false
+  };
+});
+
 // src/hooks/semantic/jev-throttle.ts
 var exports_jev_throttle = {};
 __export(exports_jev_throttle, {
@@ -16285,10 +17453,10 @@ var init_jev_throttle = __esm(() => {
 });
 
 // src/hooks/semantic/session-root.ts
-import { mkdirSync as mkdirSync11, readdirSync as readdirSync14, readFileSync as readFileSync18, statSync as statSync20, unlinkSync as unlinkSync3, writeFileSync as writeFileSync8 } from "node:fs";
-import { isAbsolute as isAbsolute4, resolve as resolve17 } from "node:path";
+import { mkdirSync as mkdirSync11, readdirSync as readdirSync14, readFileSync as readFileSync20, statSync as statSync22, unlinkSync as unlinkSync3, writeFileSync as writeFileSync9 } from "node:fs";
+import { isAbsolute as isAbsolute4, resolve as resolve19 } from "node:path";
 function validRoot(v) {
-  return typeof v === "string" && isAbsolute4(v) && resolve17(v) === v && v !== "/";
+  return typeof v === "string" && isAbsolute4(v) && resolve19(v) === v && v !== "/";
 }
 function storeIsOurs() {
   if (process.platform === "win32")
@@ -16296,7 +17464,7 @@ function storeIsOurs() {
   if (looseIntentStoreDir() !== null)
     return false;
   try {
-    const mode = statSync20(rootsDir()).mode & 511;
+    const mode = statSync22(rootsDir()).mode & 511;
     return (mode & DIR_WRITABLE_BY_OTHERS4) === 0;
   } catch {
     return true;
@@ -16304,7 +17472,7 @@ function storeIsOurs() {
 }
 function readPinned(sessionId) {
   try {
-    const parsed = JSON.parse(readFileSync18(rootFile(sessionId), "utf8"));
+    const parsed = JSON.parse(readFileSync20(rootFile(sessionId), "utf8"));
     return validRoot(parsed?.root) ? parsed.root : null;
   } catch {
     return null;
@@ -16317,9 +17485,9 @@ function pruneSessionRoots(now = Date.now()) {
     for (const name of readdirSync14(dir)) {
       if (!ROOT_FILE_RE.test(name))
         continue;
-      const path = resolve17(dir, name);
+      const path = resolve19(dir, name);
       try {
-        const st = statSync20(path);
+        const st = statSync22(path);
         if (st.isFile() && now - st.mtimeMs > SESSION_ROOT_MAX_AGE_MS) {
           unlinkSync3(path);
           removed++;
@@ -16344,12 +17512,12 @@ function sessionProjectRoot(sessionId, cwd, now = Date.now()) {
     if (!validRoot(live))
       return live;
     mkdirSync11(rootsDir(), { recursive: true, mode: 448 });
-    writeFileSync8(rootFile(sessionId), JSON.stringify({ root: live, at: now }), { mode: 384, flag: "wx" });
+    writeFileSync9(rootFile(sessionId), JSON.stringify({ root: live, at: now }), { mode: 384, flag: "wx" });
     pruneSessionRoots(now);
   } catch {}
   return live;
 }
-var SESSION_ID_RE3, ROOT_FILE_RE, SESSION_ROOT_MAX_AGE_MS, DIR_WRITABLE_BY_OTHERS4 = 18, rootsDir = () => resolve17(semanticDir(), "roots"), rootFile = (sessionId) => resolve17(rootsDir(), `${sessionId}.json`);
+var SESSION_ID_RE3, ROOT_FILE_RE, SESSION_ROOT_MAX_AGE_MS, DIR_WRITABLE_BY_OTHERS4 = 18, rootsDir = () => resolve19(semanticDir(), "roots"), rootFile = (sessionId) => resolve19(rootsDir(), `${sessionId}.json`);
 var init_session_root = __esm(() => {
   init_fp_home();
   init_facts();
@@ -16387,6 +17555,13 @@ function resolveTimeout(cfg) {
     return DEFAULT_JEV_TIMEOUT_MS;
   return Math.min(MAX_JEV_TIMEOUT_MS2, Math.max(MIN_JEV_TIMEOUT_MS2, t));
 }
+function reviewerKey(o) {
+  const packId = o.origin?.packId;
+  return packId !== undefined && packId.startsWith("cloud:") ? cloudReviewerName(packId.slice("cloud:".length), o.policy) : o.policy;
+}
+function isCloudOutcome(o) {
+  return o.origin?.packId?.startsWith("cloud:") === true;
+}
 function jevDecider(outcome) {
   const wanted = outcome.verdict.decision === "deny" ? "deny" : "instruct";
   return outcome.verdict.outcomes.find((o) => o.verdict === wanted);
@@ -16409,6 +17584,10 @@ function toReview(outcome, cached = false) {
   const latencyMs = sent && !cached ? outcome.latencyMs : null;
   const model = sent ? outcome.model : null;
   const outcomes = outcome.verdict.outcomes;
+  const cloudAsked = "cloud" in outcome ? new Set(outcome.cloud.asked) : null;
+  const unvouched = outcomes.some((o) => isCloudOutcome(o) && !(cloudAsked?.has(o.policy) ?? false));
+  if (unvouched)
+    return { kind: "fallback", reason: "malformed", latencyMs, model: null };
   const injection = sent ? outcome.verdict.injectionSuspected : null;
   const warned = (o) => o.verdict === "instruct" && o.intent !== "downgraded-task-step";
   return {
@@ -16417,8 +17596,8 @@ function toReview(outcome, cached = false) {
     reason: outcome.verdict.reason,
     policyName: jevPolicyName(outcome),
     ...jevDecider(outcome)?.origin ? { origin: jevDecider(outcome)?.origin } : {},
-    asked: sent ? outcomes.map((o) => o.policy) : [],
-    notDenied: sent ? outcomes.filter((o) => o.verdict !== "deny" && !warned(o)).map((o) => o.policy) : [],
+    asked: sent ? outcomes.map(reviewerKey) : [],
+    notDenied: sent ? outcomes.filter((o) => o.verdict !== "deny" && !warned(o)).map(reviewerKey) : [],
     injectionAsked: injection !== null,
     injected: injection !== null && injection >= DEFAULT_THRESHOLDS_V1.injection,
     unclearableWarned: outcomes.some((o) => o.mode === "deny" && warned(o)),
@@ -16450,11 +17629,22 @@ function startJevReview(cfg, call) {
   let throttled;
   try {
     route = transportForConfig(cfg);
-    throttled = throttle.throttleTransport(route.transport, { scope: throttleScope(cfg, route) });
+    const scope = call.cloud ? `${throttleScope(cfg, route)}\x00cloud\x00${call.cloud.machineId}\x00${call.cloud.deployment ?? "-"}` : throttleScope(cfg, route);
+    throttled = throttle.throttleTransport(route.transport, { scope });
   } catch (err) {
     const reason = err instanceof JevError ? err.code : "config";
     return handle(Promise.resolve({ kind: "fallback", reason, latencyMs: null, model: null }));
   }
+  const cloud = call.cloud;
+  const healthScope = cloud ? JSON.stringify([cfg.baseUrl ?? null, cloud.machineId]) : "";
+  let probe = false;
+  if (cloud) {
+    const gate = cloudJevGate(healthScope);
+    if (!gate.ask) {
+      return handle(Promise.resolve({ kind: "fallback", reason: BREAKER_SKIP_REASON, latencyMs: null, model: null }));
+    }
+    probe = gate.probe;
+  }
   let intent;
   try {
     intent = intentReader.readIntent(call.sessionId);
@@ -16473,6 +17663,7 @@ function startJevReview(cfg, call) {
     agentLastMessage: intent.agentLastMessage
   };
   let cached = false;
+  let reachedCloud = false;
   const transport = async (request, signal) => {
     const response = await throttled(request, signal);
     cached = servedFromCache2(response);
@@ -16480,7 +17671,7 @@ function startJevReview(cfg, call) {
   };
   const timeoutMs = resolveTimeout(cfg);
   let abandoned = false;
-  const answered = evaluateSemantic(input, {
+  const options = {
     transport,
     cli: call.cli,
     via: route.via,
@@ -16489,9 +17680,25 @@ function startJevReview(cfg, call) {
     intent: "v1",
     v1: { thresholds: DEFAULT_THRESHOLDS_V1 },
     signal: controller.signal
-  }).then((outcome) => {
+  };
+  const evaluated = cloud ? evaluateCloudSemantic(input, {
+    ...options,
+    machineId: cloud.machineId,
+    agent: cloud.agent,
+    ...call.localPaused ? { policies: [] } : {}
+  }) : evaluateSemantic(input, options);
+  const answered = evaluated.then((outcome) => {
     const hit = cached && outcome.status === "ok";
+    reachedCloud = outcome.status === "ok" && !hit && outcome.via !== "none";
     const review = toReview(outcome, hit);
+    if (cloud && !abandoned && outcome.status === "ok" && "cloud" in outcome && outcome.cloud.droppedLocal.length > 0) {
+      const cloudNames = new Set([...outcome.cloud.asked, ...outcome.cloud.droppedCloud]);
+      recordJevBudgetDrops({ machineId: cloud.machineId, deployment: cloud.deployment, jevMode: cloud.mode }, outcome.cloud.droppedLocal.map((d) => ({
+        packId: d.packId ?? "unknown",
+        name: d.name,
+        ...cloudNames.has(d.name) ? { clash: true } : {}
+      })));
+    }
     if (!(outcome.status === "degraded" && outcome.reason === "aborted")) {
       const row = verdictLogRow(input, hit ? { ...outcome, inputTokens: null } : outcome, {
         sessionId: call.sessionId,
@@ -16499,7 +17706,8 @@ function startJevReview(cfg, call) {
         eventType: call.eventType,
         applied: abandoned || review.kind !== "answered" ? "legacy-fallback" : mode === "observe" ? "observe" : "two-tier"
       });
-      appendVerdictLog(hit ? { ...row, cached: true } : row);
+      const withCloud = outcome.status === "ok" && "cloud" in outcome ? { ...row, cloud: outcome.cloud } : row;
+      appendVerdictLog(hit ? { ...withCloud, cached: true } : withCloud);
     }
     return review;
   }).catch(() => ({ kind: "fallback", reason: "error", latencyMs: null, model: null }));
@@ -16511,16 +17719,27 @@ function startJevReview(cfg, call) {
       resolve({ kind: "fallback", reason: "timeout", latencyMs: timeoutMs + JEV_DEADLINE_GRACE_MS, model: null });
     }, timeoutMs + JEV_DEADLINE_GRACE_MS);
   });
-  return handle(Promise.race([answered, expired]).finally(() => {
+  const raced = Promise.race([answered, expired]).finally(() => {
     if (deadline !== undefined)
       clearTimeout(deadline);
+  });
+  if (!cloud)
+    return handle(raced);
+  return handle(raced.then((review) => {
+    recordCloudJevResult(healthScope, classifyCloudJevReview(review, { reachedCloud }), review.kind === "fallback" ? review.reason : null, probe);
+    reportCloudJevHealth();
+    return review;
   }));
 }
 var throttle, intentReader, ALWAYS_ON, MIN_JEV_TIMEOUT_MS2 = 100, MAX_JEV_TIMEOUT_MS2 = 1e4, JEV_DEADLINE_GRACE_MS = 250;
 var init_jev_review = __esm(() => {
   init_builtin_policies();
+  init_cloud_managed_policies();
+  init_cloud_policy_errors();
   init_policy_registry();
   init_decide();
+  init_cloud_jev();
+  init_cloud_jev_health();
   init_evaluator();
   init_intent();
   init_jev_client();
@@ -16669,7 +17888,7 @@ var init_enforcement_capability = __esm(() => {
 });
 
 // src/hooks/handler.ts
-import { existsSync as existsSync21 } from "node:fs";
+import { existsSync as existsSync22 } from "node:fs";
 function canonicalizeEventType(raw, cli) {
   if (cli === "codex") {
     const mapped = CODEX_EVENT_MAP[raw];
@@ -16727,9 +17946,23 @@ function isHumanAuthoredGate(rawEventType, cli) {
 function jevForcedOff(opts) {
   return process.env.FAILPROOFAI_EVALUATOR === "legacy" || !!opts?.forceDecision;
 }
-async function readJevConfig() {
+async function readJevConfig(agent) {
   try {
-    if (!existsSync21(jevConfigFile()))
+    const cloud = readCloudJevState();
+    if (cloud.jevMode === "off")
+      return null;
+    if (cloudJevAsks(cloud.jevMode)) {
+      await Promise.resolve().then(() => init_jev_config());
+      const resolved = loadJevConfigForCloudMode(cloud.jevMode);
+      if (!resolved.config || !resolved.machineId)
+        return null;
+      return {
+        config: resolved.config,
+        defaultMode: DEFAULT_JEV_MODE,
+        cloud: { machineId: resolved.machineId, deployment: cloud.deployment, mode: cloud.jevMode, agent: agent ?? null }
+      };
+    }
+    if (!existsSync22(jevConfigFile()))
       return null;
     await Promise.resolve().then(() => init_jev_config());
     const config = loadJevConfig();
@@ -16739,20 +17972,72 @@ async function readJevConfig() {
     return null;
   }
 }
-async function startTwoTier(canonicalEventType, parsed, session, cli, opts, activePause) {
+function jevAttribution(origin) {
+  if (!origin)
+    return {};
+  if (origin.packId.startsWith("cloud:")) {
+    const version = Number(origin.packVersion);
+    return {
+      cloudPolicyId: origin.packId.slice("cloud:".length),
+      ...Number.isSafeInteger(version) ? { cloudVersion: version } : {}
+    };
+  }
+  return origin;
+}
+async function recordCloudPolicyErrors(input) {
+  try {
+    const jev = readCloudJevState();
+    const managed = input.manifestError !== null || input.jsPolicies.length > 0 || jev.jevMode !== null || jev.errors.length > 0 || input.agentScopeUnresolved === true;
+    if (!managed && !existsSync22(cloudPolicyErrorsPath()))
+      return;
+    let jevProblem = null;
+    let budgetDrops = [];
+    let health = [];
+    if (cloudJevAsks(jev.jevMode)) {
+      await Promise.resolve().then(() => init_jev_config());
+      const resolved = loadJevConfigForCloudMode(jev.jevMode);
+      jevProblem = resolved.problem;
+      if (resolved.machineId) {
+        budgetDrops = existsSync22(jevBudgetPath()) ? readJevBudgetDrops({ machineId: resolved.machineId, deployment: jev.deployment, jevMode: jev.jevMode }, installedPackIds()) : [];
+      }
+      await Promise.resolve().then(() => init_cloud_jev_health());
+      health = cloudJevHealthErrors();
+    }
+    writeCloudPolicyErrors(collectCloudPolicyErrors({
+      manifestError: input.manifestError,
+      jsPolicies: input.jsPolicies,
+      jsFailures: input.jsFailures,
+      jev,
+      jevProblem,
+      budgetDrops,
+      health,
+      agentScopeUnresolved: input.agentScopeUnresolved
+    }));
+    if (input.jsPolicies.length > 0)
+      recordCloudLoadChecked(input.jsPolicies[0].deployment, input.jsPolicies);
+  } catch (err) {
+    hookLogInfo(`could not record Cloud policy errors: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function startTwoTier(canonicalEventType, parsed, session, cli, opts, activePause, agent) {
   if (!JEV_GATE_EVENTS.has(canonicalEventType))
     return null;
   if (isHumanAuthoredGate(session.rawHookEventName, cli))
     return null;
   if (typeof parsed.tool_name !== "string" || parsed.tool_name.length === 0)
     return null;
-  if (jevForcedOff(opts) || activePause)
+  if (jevForcedOff(opts))
+    return null;
+  const cloudAsks = cloudJevAsks(readCloudJevMode());
+  if (activePause && !cloudAsks)
     return null;
-  if (!jevChecksInstalled())
+  if (!cloudAsks && !jevChecksInstalled())
     return null;
-  const loaded = await readJevConfig();
+  const loaded = await readJevConfig(agent);
   if (!loaded)
     return null;
+  if (activePause && !loaded.cloud)
+    return null;
   const cfg = loaded.config;
   try {
     await Promise.resolve().then(() => init_jev_review());
@@ -16763,7 +18048,9 @@ async function startTwoTier(canonicalEventType, parsed, session, cli, opts, acti
       cwd: session.cwd,
       permissionMode: session.permissionMode,
       sessionId: session.sessionId,
-      cli
+      cli,
+      ...loaded.cloud ? { cloud: loaded.cloud } : {},
+      ...activePause ? { localPaused: true } : {}
     });
   } catch (err) {
     hookLogInfo(`Jev review could not start (${err instanceof Error ? err.message : String(err)})`);
@@ -16792,7 +18079,7 @@ async function captureJevIntent(canonicalEventType, decision, parsed, session, c
   if (canonicalEventType !== "UserPromptSubmit" || jevForcedOff(opts))
     return;
   try {
-    if (!jevChecksInstalled())
+    if (!cloudJevAsks(readCloudJevMode()) && !jevChecksInstalled())
       return;
     if (!await readJevConfig())
       return;
@@ -16834,6 +18121,9 @@ async function evaluateHookEvent(eventType, cli = "claude", stdinPayload, opts)
         });
       }
     }
+    if (isHealthProbe(eventType, parsed)) {
+      return { exitCode: 0, stdout: "", stderr: "" };
+    }
     normalizeCliPayload(cli, parsed);
     const canonicalEventType = canonicalizeEventType(eventType, cli);
     const rawToolName = parsed.tool_name;
@@ -16857,6 +18147,7 @@ async function evaluateHookEvent(eventType, cli = "claude", stdinPayload, opts)
       rawHookEventName: eventType,
       cli
     };
+    const runtimeAgent = readRuntimeAgentIdentity(cli, opts?.agentSettingsPath ?? runtimeAgentSettingsPath(cli, session.cwd));
     let config;
     let customHooksList = [];
     let conventionHookNames = new Set;
@@ -16873,7 +18164,7 @@ async function evaluateHookEvent(eventType, cli = "claude", stdinPayload, opts)
       registerPolicy("failproofai/daemon-unreachable", "Fail-closed: the failproofaid daemon could not be reached for this daemon-configured scope.", async () => ({ decision: decision.decision, reason: decision.reason }), {});
     } else {
       config = readMergedHooksConfig(session.cwd);
-      clearPolicies(cli);
+      clearPolicies(cli, runtimeAgent);
       activePause = readActivePause(session.sessionId);
       const packsInstalledHere = hasInstalledRegexPacks();
       const legacyNames = activePause || packsInstalledHere ? [] : config.enabledPolicies;
@@ -16883,17 +18174,19 @@ async function evaluateHookEvent(eventType, cli = "claude", stdinPayload, opts)
       }
       const enabledBuiltinNames = new Set(legacyNames);
       let cloudManagedPolicies = [];
+      let cloudManifestError = null;
       try {
-        cloudManagedPolicies = readActiveCloudManagedPolicies();
+        cloudManagedPolicies = readActiveCloudManagedPolicies(runtimeAgent);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
+        cloudManifestError = msg;
         hookLogWarn(`[failproofai] cloud-managed policies could NOT be loaded and are not being enforced: ${msg}. Local policies are unaffected. Run \`failproofai config --status\` to check this machine's enrolment.`);
         trackHookEvent(getInstanceId(), "cloud_managed_load_error", {
           event_type: eventType,
           cli
         });
       }
-      cloudDeployment = cloudManagedPolicies[0]?.deployment;
+      cloudDeployment = cloudManagedPolicies[0]?.deployment ?? readCloudJevState().deployment ?? undefined;
       let installedPacks = [];
       try {
         const packResult = readInstalledPacks();
@@ -16911,10 +18204,12 @@ async function evaluateHookEvent(eventType, cli = "claude", stdinPayload, opts)
         ...cloudManagedPolicies.map((policy) => policy.path),
         ...installedPacks.map((pack) => pack.path)
       ];
+      const cloudJevMode = readCloudJevMode();
+      const cloudForLoading = cloudManagedPolicies.map((policy) => withCloudAuthority(policy, cloudJevMode));
       const loadResult = await loadAllCustomHooks(allExplicitPaths, {
         sessionCwd: session.cwd,
         customPoliciesEnabled: config.customPoliciesEnabled,
-        ...cloudManagedPolicies.length > 0 ? { cloudManagedPolicies } : {},
+        ...cloudForLoading.length > 0 ? { cloudManagedPolicies: cloudForLoading } : {},
         ...installedPacks.length > 0 ? { packs: installedPacks } : {}
       });
       customHooksList = loadResult.hooks;
@@ -16994,6 +18289,12 @@ async function evaluateHookEvent(eventType, cli = "claude", stdinPayload, opts)
           warnAuthority(refusedAuthorityWarning(registeredName, refused));
         registerPolicy(registeredName, hook.description ?? "", fn, hook.match ?? {}, -1, pack?.policies.find((p) => p.name === hook.name)?.params, authority);
       }
+      await recordCloudPolicyErrors({
+        manifestError: cloudManifestError,
+        jsPolicies: cloudManagedPolicies,
+        jsFailures: loadResult.cloudFailures,
+        agentScopeUnresolved: runtimeAgent === null && readCloudAgentScopeRequired()
+      });
       if (!activePause) {
         const guards = missingGuards({
           errors: packErrors,
@@ -17040,7 +18341,7 @@ async function evaluateHookEvent(eventType, cli = "claude", stdinPayload, opts)
       }
       hookLogInfo(`event=${canonicalEventType} cli=${cli} policies=${config.enabledPolicies.length} custom=${customHooksList.length} convention=${conventionHookNames.size}`);
     }
-    const twoTier = await startTwoTier(canonicalEventType, parsed, session, cli, opts, activePause);
+    const twoTier = await startTwoTier(canonicalEventType, parsed, session, cli, opts, activePause, runtimeAgent);
     const matchedBeforeRelease = twoTier ? getPoliciesForEvent(canonicalEventType, parsed.tool_name).map((p) => p.name) : null;
     const result = twoTier ? await evaluatePolicies(canonicalEventType, parsed, session, config, {
       ...twoTier,
@@ -17077,7 +18378,7 @@ async function evaluateHookEvent(eventType, cli = "claude", stdinPayload, opts)
       cwd: session.cwd,
       permissionMode: session.permissionMode,
       hookEventName: session.hookEventName,
-      ...result.policyName && result.twoTier?.decidedByJev ? { policySource: "jev", ...jevOrigin } : {},
+      ...result.policyName && result.twoTier?.decidedByJev ? { policySource: "jev", ...jevAttribution(jevOrigin) } : {},
       ...result.policyName && !result.twoTier?.decidedByJev ? (() => {
         const attribution = policyAttribution.get(result.policyName);
         return {
@@ -17088,6 +18389,7 @@ async function evaluateHookEvent(eventType, cli = "claude", stdinPayload, opts)
           ...attribution?.packVersion ? { packVersion: attribution.packVersion } : {}
         };
       })() : {},
+      ...!result.policyName && observeVerdict ? { policyName: observeVerdict.policyName, ...jevAttribution(result.twoTier?.jevOrigin) } : {},
       ...cloudDeployment !== undefined ? { cloudDeployment } : {},
       ...observedResults.length > 0 ? { observed: observedResults } : {},
       ...activePause ? { pausedBy: activePause.setBy, pauseExpiresAt: activePause.expiresAt } : {}
@@ -17163,23 +18465,25 @@ var init_handler = __esm(() => {
   init_telemetry_id();
   init_hook_logger();
   init_cloud_managed_policies();
+  init_cloud_policy_errors();
   init_pack_manifest();
   init_pack_failclosed();
   init_session_pause();
   init_fp_home();
   init_fp_reset();
   init_untraced_note();
+  init_agent_roster();
   JEV_GATE_EVENTS = new Set(["PreToolUse", "PermissionRequest"]);
 });
 
 // src/hooks/worker-server.ts
 import { createConnection, createServer } from "node:net";
-import { existsSync as existsSync22, unlinkSync as unlinkSync4 } from "node:fs";
+import { existsSync as existsSync23, unlinkSync as unlinkSync4 } 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 || m.cwd === null || 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") && (m.agentSettingsPath === undefined || m.agentSettingsPath === null || typeof m.agentSettingsPath === "string");
 }
 function encodeFrame(value) {
   const body = Buffer.from(JSON.stringify(value), "utf8");
@@ -17274,6 +18578,7 @@ function handleConnection(socket, shutdown) {
           const result = await evaluateHookEvent(request.hookEvent, request.cli, request.stdin, {
             awaitTelemetryFlush: false,
             fallbackCwd: request.cwd ?? undefined,
+            agentSettingsPath: request.agentSettingsPath ?? undefined,
             releaseRegistry: release
           });
           deliver(encodeFrame({
@@ -17340,14 +18645,14 @@ function requestExistingWorkerShutdown(socketPath) {
 function startWorkerServer(socketPath, shutdown) {
   const server = createServer((socket) => handleConnection(socket, shutdown ?? (() => server.close())));
   const listen = () => {
-    if (existsSync22(socketPath)) {
+    if (existsSync23(socketPath)) {
       try {
         unlinkSync4(socketPath);
       } catch {}
     }
     server.listen(socketPath);
   };
-  if (!existsSync22(socketPath))
+  if (!existsSync23(socketPath))
     listen();
   else
     requestExistingWorkerShutdown(socketPath).then(listen, (err) => server.emit("error", err));
@@ -17363,13 +18668,13 @@ var init_worker_server = __esm(() => {
 
 // bin/failproofai-worker.mjs
 import { realpathSync as realpathSync2 } from "node:fs";
-import { dirname as dirname10, resolve as resolve18 } from "node:path";
+import { dirname as dirname11, resolve as resolve20 } from "node:path";
 import { fileURLToPath } from "node:url";
 if (!process.env.FAILPROOFAI_PACKAGE_ROOT) {
-  process.env.FAILPROOFAI_PACKAGE_ROOT = resolve18(dirname10(realpathSync2(fileURLToPath(import.meta.url))), "..");
+  process.env.FAILPROOFAI_PACKAGE_ROOT = resolve20(dirname11(realpathSync2(fileURLToPath(import.meta.url))), "..");
 }
 if (!process.env.FAILPROOFAI_DIST_PATH) {
-  process.env.FAILPROOFAI_DIST_PATH = resolve18(dirname10(realpathSync2(fileURLToPath(import.meta.url))), "..", "dist");
+  process.env.FAILPROOFAI_DIST_PATH = resolve20(dirname11(realpathSync2(fileURLToPath(import.meta.url))), "..", "dist");
 }
 var socketPath = process.env.FAILPROOFAI_WORKER_SOCKET;
 if (!socketPath) {