failproofai 1.0.12-beta.1 → 1.0.12

package/src/hooks/fp-config.ts

@@ -940,6 +940,25 @@ export function readCredentials(): FpCredentials {
   }
 }
 
+/**
+ * Whether FailproofAI Cloud sets this machine's Jev mode: it is connected for
+ * policies (a machine id in `credentials.json`). Cloud then runs Jev in enforce
+ * while a Jev policy is deployed here and switches it off when none is; local
+ * mode settings do not apply. Never throws.
+ */
+export function cloudManagesJevMode(): boolean {
+  try {
+    const cloud = readCredentials().cloud;
+    return Boolean(cloud?.url && cloud.machineId);
+  } catch {
+    return false;
+  }
+}
+
+/** The one line a local mode switch answers with on such a machine. */
+export const CLOUD_MANAGED_JEV_MODE =
+  "Jev mode is managed by FailproofAI Cloud on this machine: enforce while a Jev policy is deployed here, off when none is.";
+
 /**
  * Project a parsed credentials object onto {@link FpCredentials}.
  *

package/src/hooks/fp-home.ts

@@ -410,7 +410,7 @@ export const collectorHealthFile = (home?: string) => resolve(stateDir(home), "c
 /** Per-session enforcement pauses, keyed by a hash of the session id. */
 export const sessionPauseDir = () => resolve(stateDir(), "sessions");
 /**
- * The semantic (Jev) evaluator's local state: `sessions/<id>.json` holds the
+ * The semantic (Jev) evaluator's local state: `sessions/<profile>/<id>.json` holds the
  * human prompts recorded at `UserPromptSubmit`, and `verdicts.jsonl` one row
  * per semantic evaluation. Written only when a Jev config (BYOK) is present.
  */

package/src/hooks/handler.ts

@@ -38,7 +38,7 @@ import type { JevActivityFields } from "./semantic/combine";
 import type { JevConfig } from "./semantic/jev-config";
 import { clearPolicies, registerPolicy, getPoliciesForEvent } from "./policy-registry";
 import { loadAllCustomHooks, type LoadAllResult } from "./custom-hooks-loader";
-import { contestedReviewerNames, effectiveReviewerNames, jevChecksInstalled } from "./effective-reviewers";
+import { contestedReviewerNames, effectiveReviewerNames, jevChecksInstalled, packJevChecksInstalled } from "./effective-reviewers";
 import {
   authorityDeclarationFor,
   refusedAuthorityWarning,
@@ -58,6 +58,7 @@ import { hookLogInfo, hookLogWarn } from "./hook-logger";
 import { readStdinPayload } from "./read-stdin";
 import {
   cloudJevAsks,
+  cloudJevAssignmentsFor,
   withCloudAuthority,
   readActiveCloudManagedPolicies,
   readCloudJevMode,
@@ -305,6 +306,8 @@ interface CloudJevRoute {
   deployment: number | null;
   mode: "observe" | "enforce";
   agent: AgentIdentity | null;
+  /** Cloud policies whose Jev assignment here is `observe`: their answers are recorded, never applied. */
+  observedPolicies: string[];
 }
 
 /**
@@ -346,7 +349,13 @@ async function readJevConfig(agent?: AgentIdentity | null): Promise<{
       return {
         config: resolved.config,
         defaultMode: DEFAULT_JEV_MODE,
-        cloud: { machineId: resolved.machineId, deployment: cloud.deployment, mode: cloud.jevMode, agent: agent ?? null },
+        cloud: {
+          machineId: resolved.machineId,
+          deployment: cloud.deployment,
+          mode: cloud.jevMode,
+          agent: agent ?? null,
+          observedPolicies: (cloudJevAssignmentsFor(agent ?? null) ?? []).filter((a) => a.effect === "observe").map((a) => a.id),
+        },
       };
     }
     if (!existsSync(jevConfigFile())) return null;
@@ -475,6 +484,11 @@ async function startTwoTier(
   // must not switch off what the org assigned centrally).
   if (activePause && !cloudAsks) return null;
   if (!cloudAsks && !jevChecksInstalled()) return null;
+  // No Cloud Jev check is assigned to this agent (the deployment says so) and
+  // no installed pack's check takes part: nothing to ask, so no Cloud call
+  // and no Jev fields on the row. An older deployment without the list
+  // (`null`) still sends every call, as before.
+  if (cloudAsks && cloudJevAssignmentsFor(agent)?.length === 0 && (activePause || !packJevChecksInstalled())) return null;
   const loaded = await readJevConfig(agent);
   if (!loaded) return null;
   // Paused, and the config is not Cloud's after all (read in between): the
@@ -491,6 +505,8 @@ async function startTwoTier(
       permissionMode: session.permissionMode,
       sessionId: session.sessionId,
       cli,
+      // The profile the intent store is read under: the one capture used.
+      agent,
       ...(loaded.cloud ? { cloud: loaded.cloud } : {}),
       // Cloud's checks are still asked; the installed packs' are not.
       ...(activePause ? { localPaused: true } : {}),
@@ -557,6 +573,15 @@ function jevTelemetry(activity: JevActivityFields | undefined): Record<string, u
  * marks that tell a human's prompt from a subagent's or an extension's are
  * elsewhere in it. `prompt` is §7's original field, still read by the
  * contract stub; T4's implementation reads `payload` and ignores it.
+ *
+ * The prompt is stored under the agent profile (`agent`, the runtime identity
+ * Cloud's targeting matches on) and read back by `startTwoTier` under the same
+ * one, so a prompt typed into one profile is never another's stated intent.
+ * Under a Cloud mode, a profile the deployment assigns no Cloud Jev check to,
+ * with no installed pack's check to review it either, has nothing that will
+ * ever read the prompt (`startTwoTier` returns before Jev for it), so nothing
+ * is kept: FailproofAI does not hold prompt text from a profile the
+ * deployment did not target.
  */
 async function captureJevIntent(
   canonicalEventType: string,
@@ -565,13 +590,20 @@ async function captureJevIntent(
   session: SessionMetadata,
   cli: IntegrationType,
   opts: EvaluateHookEventOptions | undefined,
+  agent: AgentIdentity | null,
 ): Promise<void> {
   if (canonicalEventType !== "UserPromptSubmit" || jevForcedOff(opts)) return;
   try {
     // Same gate as `startTwoTier`: a Cloud mode that asks needs what the human
     // typed whatever the installed packs declare.
-    if (!cloudJevAsks(readCloudJevMode()) && !jevChecksInstalled()) return;
-    if (!(await readJevConfig())) return;
+    const cloudAsks = cloudJevAsks(readCloudJevMode());
+    if (!cloudAsks && !jevChecksInstalled()) return;
+    // ...but not for a profile no Cloud Jev check targets and no installed
+    // pack's check reviews: `startTwoTier`'s own skip, without the pause
+    // (a pause can end while the session goes on). An older deployment with
+    // no assignment list (`null`) captures as before.
+    if (cloudAsks && cloudJevAssignmentsFor(agent)?.length === 0 && !packJevChecksInstalled()) return;
+    if (!(await readJevConfig(agent))) return;
     if (decision === "deny") {
       const { ENFORCEMENT_CAPABILITY } = await import("./enforcement-capability");
       if (ENFORCEMENT_CAPABILITY[cli]?.UserPromptSubmit === "block") return;
@@ -585,6 +617,7 @@ async function captureJevIntent(
       cli,
       payload: parsed,
       prompt: parsed.prompt,
+      profile: { cli, agent },
     };
     captureIntent(event);
   } catch (err) {
@@ -1158,10 +1191,15 @@ export async function evaluateHookEvent(
         reason: observeVerdict.reason,
       });
     }
+    // An `observe` Cloud Jev assignment's checks: filed under their Cloud
+    // policy, like an observe Cloud JS policy's verdict.
+    for (const o of result.twoTier?.observedCloud ?? []) {
+      observedResults.push({ policyId: o.cloudPolicyId, version: o.cloudVersion, decision: o.decision, reason: o.reason });
+    }
     const durationMs = Math.round(performance.now() - startTime);
     hookLogInfo(`result=${result.decision} policy=${result.policyName ?? "none"} duration=${durationMs}ms`);
 
-    await captureJevIntent(canonicalEventType, result.decision, parsed, session, cli, opts);
+    await captureJevIntent(canonicalEventType, result.decision, parsed, session, cli, opts, runtimeAgent);
 
     // Which policies actually ran for this event, regardless of how they
     // decided. `result.policyName` names only the decider — null on a plain

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

@@ -24,7 +24,7 @@ import {
 import { join } from "node:path";
 import type { IntegrationType } from "./types";
 import { hookActivityDir } from "./fp-home";
-import { sanitizeJevActivity } from "./jev-activity";
+import { sanitizeJevActivity, type JevCheckRecord } from "./jev-activity";
 
 export const PAGE_SIZE = 25;
 
@@ -107,6 +107,12 @@ export interface HookActivityEntry {
   jevModel?: string;
   /** `observe` logs Jev but enforces the regex result; `enforce` applies the combine rules. */
   jevMode?: "observe" | "enforce";
+  /**
+   * Every Jev check asked on an answered call and what it concluded (verdict,
+   * why, evidence, exempt and probe answers) — names, codes and numbers only.
+   * `[]`: the request carried no check, so Jev decided nothing (`no-request`).
+   */
+  jevChecks?: JevCheckRecord[];
   durationMs: number;
   sessionId?: string;
   transcriptPath?: string;

package/src/hooks/integrations.ts

@@ -26,7 +26,7 @@ import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
 import { parseDocument, type Document } from "yaml";
 import { writeConfigFileAtomic } from "./safe-config-write";
-import { codexSystemHooksPresent, type CodexSystemHookEntry } from "./codex-system-hooks";
+import { codexHome, codexSystemHooksPresent, type CodexSystemHookEntry } from "./codex-system-hooks";
 import { listHermesProfiles, hermesRoot } from "../../lib/hermes-profiles";
 import { listOpenClawProfiles } from "../../lib/openclaw-profiles";
 import {
@@ -253,6 +253,21 @@ export function settingsPathsFor(
   return paths && paths.length > 0 ? paths : [integration.getSettingsPath(scope, cwd)];
 }
 
+// ── Agent profile homes ─────────────────────────────────────────────────────
+
+/**
+ * The user-scope config folder of the Claude Code profile this command runs
+ * for: `CLAUDE_CONFIG_DIR` when set (`~/.claude-work`), else `~/.claude`. The
+ * hook resolves the same variable (`runtimeAgentSettingsPath`), so install,
+ * uninstall and the roster all name one file per profile.
+ */
+export function claudeConfigDir(): string {
+  const dir = process.env.CLAUDE_CONFIG_DIR?.trim();
+  return dir ? resolve(dir) : resolve(homedir(), ".claude");
+}
+
+export { codexHome };
+
 // ── Claude Code integration ─────────────────────────────────────────────────
 
 export const claudeCode: Integration = {
@@ -265,7 +280,7 @@ export const claudeCode: Integration = {
     const base = cwd ? resolve(cwd) : process.cwd();
     switch (scope) {
       case "user":
-        return resolve(homedir(), ".claude", "settings.json");
+        return resolve(claudeConfigDir(), "settings.json");
       case "project":
         return resolve(base, ".claude", "settings.json");
       case "local":
@@ -439,7 +454,7 @@ export const codex: Integration = {
     const base = cwd ? resolve(cwd) : process.cwd();
     switch (scope) {
       case "user":
-        return resolve(homedir(), ".codex", "hooks.json");
+        return resolve(codexHome(), "hooks.json");
       case "project":
         return resolve(base, ".codex", "hooks.json");
       case "local":

package/src/hooks/jev-activity.ts

@@ -41,7 +41,7 @@ import type { HookActivityEntry } from "./hook-activity-store";
 
 export type JevActivityFields = Pick<
   HookActivityEntry,
-  "evaluator" | "jevDecision" | "jevCleared" | "jevFallbackReason" | "jevLatencyMs" | "jevModel" | "jevMode"
+  "evaluator" | "jevDecision" | "jevCleared" | "jevFallbackReason" | "jevLatencyMs" | "jevModel" | "jevMode" | "jevChecks"
 >;
 
 /** Every Jev key on an activity row, in the order they are documented. */
@@ -53,6 +53,7 @@ export const JEV_ACTIVITY_KEYS = [
   "jevLatencyMs",
   "jevModel",
   "jevMode",
+  "jevChecks",
 ] as const satisfies ReadonlyArray<keyof JevActivityFields>;
 
 const EVALUATORS = new Set(["jev", "jev-fallback"]);
@@ -219,6 +220,113 @@ export function normalizeJevFallbackReason(raw: unknown): string | undefined {
   return JEV_REASON_CODES.has(code) ? code : JEV_REASON_OTHER;
 }
 
+// ── Per-check answers ────────────────────────────────────────────────────────
+
+/** What one asked Jev check concluded. */
+export const JEV_CHECK_VERDICTS = ["none", "deny", "instruct", "overridden"] as const;
+
+/**
+ * Why a check ended where it did, as a closed code (read off its outcome,
+ * never text from the call):
+ * - `not-detected`: its probes did not hold (evidence under the fire threshold);
+ * - `exempt`: it fired, and its `exempt` question held;
+ * - `fired`: it fired and nothing softened it;
+ * - `injection`: it fired and the request also argued for its own approval;
+ * - `user-asked` (v0), `op-requested`, `task-step` (v1): the human's consent cleared it;
+ * - `downgraded`: a deny the human's task softened to a warning;
+ * - `scan-incomplete`: a clear withheld because the command scan may have missed a target.
+ */
+export const JEV_CHECK_WHY = [
+  "not-detected",
+  "exempt",
+  "fired",
+  "injection",
+  "user-asked",
+  "op-requested",
+  "task-step",
+  "downgraded",
+  "scan-incomplete",
+] as const;
+
+/**
+ * One Jev check that was asked on this call, and its answer: names, closed
+ * codes and probabilities only — never question text, the command or the
+ * human's words. Jev answers yes/no probabilities, not reasons, so `why` is
+ * the decider's own reading of them.
+ */
+export interface JevCheckRecord {
+  /** The check's name (`semantic/<check>` without the prefix). */
+  check: string;
+  /** Who declared it: `cloud/<policyId>@<version>` or `pack/<packId>@<version>`. Absent for a caller-supplied set. */
+  policy?: string;
+  verdict: (typeof JEV_CHECK_VERDICTS)[number];
+  why: (typeof JEV_CHECK_WHY)[number];
+  /** Evidence: the minimum over its probes, 2 decimals. */
+  p: number;
+  /** Its `exempt` answer, when it declares one. */
+  exempt?: number;
+  /** Each probe's answer by probe id, when the answers came back. */
+  probes?: Record<string, number>;
+  /** A check of a watched (observe) Cloud policy: recorded, never enforced. */
+  watched?: true;
+}
+
+export const JEV_CHECKS_MAX = 32;
+export const JEV_CHECK_PROBES_MAX = 8;
+/** A check name: a slug, `.` allowed (a Cloud check name may carry one). */
+export const JEV_CHECK_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+/** A probe id, as declarations allow it. */
+export const JEV_PROBE_ID_RE = /^[a-z][a-z0-9_]{0,31}$/;
+const CHECK_VERDICT_SET: ReadonlySet<string> = new Set(JEV_CHECK_VERDICTS);
+const CHECK_WHY_SET: ReadonlySet<string> = new Set(JEV_CHECK_WHY);
+
+const isP = (v: unknown): v is number => typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= 1;
+/** A probability at 2 decimals — what the reason strings print. */
+export const round2 = (v: number): number => Math.round(v * 100) / 100;
+
+/** One record, rebuilt field by field, or null when it is not one. */
+function sanitizeCheck(raw: unknown): JevCheckRecord | null {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const r = raw as Record<string, unknown>;
+  if (typeof r.check !== "string" || !JEV_CHECK_NAME_RE.test(r.check)) return null;
+  if (typeof r.verdict !== "string" || !CHECK_VERDICT_SET.has(r.verdict)) return null;
+  if (typeof r.why !== "string" || !CHECK_WHY_SET.has(r.why)) return null;
+  if (!isP(r.p)) return null;
+  const out: JevCheckRecord = {
+    check: r.check,
+    verdict: r.verdict as JevCheckRecord["verdict"],
+    why: r.why as JevCheckRecord["why"],
+    p: round2(r.p),
+  };
+  if (typeof r.policy === "string" && isJevPolicyName(r.policy) && !/\s/.test(r.policy) && /^(?:cloud|pack)\//.test(r.policy)) {
+    out.policy = r.policy;
+  }
+  if (isP(r.exempt)) out.exempt = round2(r.exempt);
+  if (r.watched === true) out.watched = true;
+  if (r.probes && typeof r.probes === "object" && !Array.isArray(r.probes)) {
+    const probes: Record<string, number> = {};
+    for (const [id, v] of Object.entries(r.probes as Record<string, unknown>)) {
+      if (Object.keys(probes).length >= JEV_CHECK_PROBES_MAX) break;
+      if (JEV_PROBE_ID_RE.test(id) && isP(v)) probes[id] = round2(v);
+    }
+    if (Object.keys(probes).length > 0) out.probes = probes;
+  }
+  return out;
+}
+
+/** A row's `jevChecks`, valid records only (at most {@link JEV_CHECKS_MAX}), or undefined when it is not a list. */
+export function sanitizeJevChecks(raw: unknown): JevCheckRecord[] | undefined {
+  if (!Array.isArray(raw)) return undefined;
+  const out: JevCheckRecord[] = [];
+  for (const item of raw) {
+    if (out.length >= JEV_CHECKS_MAX) break;
+    const rec = sanitizeCheck(item);
+    if (rec) out.push(rec);
+  }
+  // Every entry invalid: not "nothing asked" — the list is unreadable, so it goes.
+  return raw.length > 0 && out.length === 0 ? undefined : out;
+}
+
 /**
  * The Jev fields of `entry`, each one valid or absent. Non-Jev keys pass
  * through untouched, and an entry with no Jev keys comes back as the same
@@ -265,6 +373,11 @@ export function sanitizeJevActivity<T extends JevActivityFields>(entry: T): T {
   if (typeof out.jevModel === "string" && JEV_MODEL_RE.test(out.jevModel.trim())) out.jevModel = out.jevModel.trim();
   else drop("jevModel");
 
+  // Only on an answered call: a fallback or an unconsulted call asked nothing.
+  const checks = out.evaluator === "jev" ? sanitizeJevChecks(out.jevChecks) : undefined;
+  if (checks === undefined) drop("jevChecks");
+  else out.jevChecks = checks;
+
   return out;
 }
 
@@ -307,6 +420,9 @@ export function jevOutcome(raw: JevActivityFields): JevOutcome | null {
 function outcomeOf(e: JevActivityFields): JevOutcome | null {
   if (e.evaluator === "jev-fallback") return "fallback";
   if (e.evaluator !== "jev") return null;
+  // A request that carried no check (only the global intent questions, or a
+  // FailproofAI Cloud short-circuit) decided nothing: Jev had nothing to ask.
+  if (Array.isArray(e.jevChecks) && e.jevChecks.length === 0) return "no-request";
   if (e.jevCleared !== undefined || e.jevLatencyMs !== undefined || e.jevModel !== undefined) return "answered";
   if (e.jevDecision === "deny" || e.jevDecision === "instruct") return "answered";
   if (e.jevDecision === "allow") return "no-request";

package/src/hooks/jev-cli.ts

@@ -147,7 +147,7 @@ import {
 } from "./policy-reviewability";
 import { jevStats, type JevStats } from "./semantic/jev-stats";
 import { listActiveCloudManagedPolicies, readCloudJevState, type CloudJevState } from "./cloud-managed-policies";
-import { readCredentials, readJevCloudCredential, type JevCloudCredential } from "./fp-config";
+import { CLOUD_MANAGED_JEV_MODE, cloudManagesJevMode, readCredentials, readJevCloudCredential, type JevCloudCredential } from "./fp-config";
 import type { JevRequest } from "./semantic/types";
 import { TOKEN_ON_ARGV, optsFor, paint, screenKit, stack, wrap, type RenderOpts } from "./tui";
 
@@ -367,6 +367,9 @@ function cloudConnection(): { cloudConnected: boolean; keyCarriesJev: boolean }
   }
 }
 
+/** What `jev setup --mode` says on a machine whose Jev mode FailproofAI Cloud sets. */
+const CLOUD_MANAGED_MODE_LINES = [CLOUD_MANAGED_JEV_MODE, "Deploy or remove Jev policies in FailproofAI Cloud to change it. Nothing was written."];
+
 /** The one line `status` titles a connected machine whose key has no Jev with. */
 const KEY_LACKS_JEV_TITLE = "off — no Jev key is stored for this machine's FailproofAI Cloud connection";
 
@@ -689,6 +692,9 @@ async function setupRun(argv: string[], deps: JevCliDeps, opts: RenderOpts): Pro
   if (typeof parsed === "string") return fail([parsed, "", ...JEV_USAGE]);
   if (parsed.positionals.length > 0) return fail([STRAY_ARGUMENT, "", ...JEV_USAGE]);
   const { values, bools } = parsed;
+  // A machine connected for policies has its Jev mode set by FailproofAI Cloud
+  // alone: enforce while a Jev policy is deployed to it, off when none is.
+  if (values.has("--mode") && cloudManagesJevMode()) return fail(CLOUD_MANAGED_MODE_LINES);
   if (bools.has("--key-stdin") && bools.has("--key-from-env")) return fail(["Use one of --key-stdin and --key-from-env, not both."]);
   // One source for the key, so no run has to decide which of two the person
   // meant. The message names the recommended one first.
@@ -1479,14 +1485,6 @@ function cloudProblemAdvice(problem: string): string[] {
       "To use FailproofAI Cloud's Jev checks, reconnect without --no-transcripts (failproofai config --token <key>).",
     ];
   }
-  // Over plain http the credential is fine; enforce is what http refuses.
-  // Asking for another key there sent people after the wrong fix.
-  if (/plain http/.test(problem)) {
-    return [
-      "Jev does not run here: FailproofAI Cloud set enforce, and this machine is connected over plain http, where Jev runs only in observe mode.",
-      "Reconnect to an https FailproofAI Cloud URL (failproofai config --token <key> --url https://…), or set the machine's Jev mode to observe from FailproofAI Cloud.",
-    ];
-  }
   return [
     `Jev cannot run here: ${problem}.`,
     "Connect with a key that carries jev:evaluate (failproofai config --token <key>). A local jev.json is not used while FailproofAI Cloud sets the mode.",

package/src/hooks/manager.ts

@@ -32,8 +32,8 @@ import { getInstanceId, hashToId } from "../../lib/telemetry-id";
 import { CliError } from "../cli-error";
 import { hookLogWarn } from "./hook-logger";
 import { customPoliciesDir } from "./fp-home";
-import { listActiveCloudManagedPolicies, readCloudJevState, type CloudJevMode } from "./cloud-managed-policies";
-import { readCloudLoadChecked, readCloudPolicyErrors } from "./cloud-policy-errors";
+import { listActiveCloudManagedPolicies, readCloudJevAssignments, readCloudJevState, type CloudJevMode } from "./cloud-managed-policies";
+import { readCloudPolicyErrors } from "./cloud-policy-errors";
 import { readRosterLabels } from "./agent-roster";
 import { CORE_SOURCE, addPack, setPackPolicyEnabled } from "./pack-store";
 import type { ResolvedPack } from "./pack-manifest";
@@ -334,6 +334,35 @@ export function integrationsInstalledAt(scope: HookScope, cwd?: string): Integra
  */
 export type NotEnforcingReason = "no-hooks" | "no-policies" | "observe-only";
 
+/** Machine-wide assignments, like the listing: a `both` policy counts once. */
+function cloudPolicyStatus(): { count: number; observing: boolean } {
+  let count = 0;
+  let observing = false;
+  const jsIds = new Set<string>();
+  try {
+    for (const artifact of listActiveCloudManagedPolicies()) {
+      jsIds.add(artifact.id);
+      if (artifact.effect === "observe") observing = true;
+      else count++;
+    }
+  } catch {
+    // The listing reports an unreadable JS deployment; Jev is read independently.
+  }
+  try {
+    const { jevMode } = readCloudJevState();
+    if (jevMode === "enforce" || jevMode === "observe") {
+      for (const assignment of readCloudJevAssignments() ?? []) {
+        if (jsIds.has(assignment.id)) continue;
+        if (jevMode === "observe" || assignment.effect === "observe") observing = true;
+        else count++;
+      }
+    }
+  } catch {
+    // No readable Jev state: neither enforcement nor observation is known.
+  }
+  return { count, observing };
+}
+
 export function notEnforcingReason(cwd?: string): NotEnforcingReason | null {
   const wired = deduplicateScopes(HOOK_SCOPES, cwd).some((scope) => hooksInstalledInSettings(scope, cwd));
   if (!wired) return "no-hooks";
@@ -363,15 +392,11 @@ export function notEnforcingReason(cwd?: string): NotEnforcingReason | null {
     // An unreadable manifest is reported by the listing itself.
   }
 
-  // Cloud-managed policies, pushed from a deployment.
-  try {
-    for (const artifact of listActiveCloudManagedPolicies()) {
-      if (artifact.effect === "observe") observing = true;
-      else return null;
-    }
-  } catch {
-    // No deployment, or an unreadable one: nothing enforces from there.
-  }
+  // Cloud JS enforces independently of Jev mode. Jev-only assignments enforce
+  // only in Cloud's enforce mode, and watch only while Jev is not off.
+  const cloud = cloudPolicyStatus();
+  if (cloud.count > 0) return null;
+  observing ||= cloud.observing;
 
   // A configured custom policy file, or convention files on disk. Loading them
   // to ask what they hold would import user code on every launch, so their
@@ -392,10 +417,11 @@ export function notEnforcingReason(cwd?: string): NotEnforcingReason | null {
  * How many policies enforce on this machine, for the line that says so.
  *
  * Counted the same way `notEnforcingReason` decides, so the two never disagree:
- * pack policies that are taken and not switched off, cloud-managed policies, and
- * the legacy builtins of a machine still on the migration shim — observe-only
- * ones excluded. Custom policy files cannot be counted without importing them,
- * so their presence is reported on its own.
+ * pack policies that are taken and not switched off, Cloud JS policies and
+ * Jev-only assignments in Cloud's enforce mode, and the legacy builtins of a
+ * machine still on the migration shim — observe-only ones excluded, `both`
+ * assignments counted once. Custom policy files cannot be counted without
+ * importing them, so their presence is reported on its own.
  */
 export function enforcingPolicyCount(cwd?: string): { count: number; custom: boolean } {
   const config = readMergedHooksConfig(cwd);
@@ -410,13 +436,7 @@ export function enforcingPolicyCount(cwd?: string): { count: number; custom: boo
   } catch {
     // An unreadable manifest counts nothing, as it enforces nothing.
   }
-  try {
-    for (const artifact of listActiveCloudManagedPolicies()) {
-      if (artifact.effect !== "observe") count++;
-    }
-  } catch {
-    // No deployment.
-  }
+  count += cloudPolicyStatus().count;
   if (!hasInstalledRegexPacks()) count += config.enabledPolicies.length;
   const projectDir = resolve(findProjectConfigDir(cwd ?? process.cwd()), ".failproofai", "policies");
   const custom =
@@ -1254,6 +1274,8 @@ export interface PoliciesScreen {
     jevMode?: CloudJevMode | null;
     /** Problems reading the deployment, each one line. */
     problems?: string[];
+    /** The manifest names its Jev assignments (`jevPolicies`), so Jev-only policies are among `rows`. */
+    jevListed?: boolean;
   } | null;
   /**
    * Builtins this build enforces itself because no pack is installed: the
@@ -1392,9 +1414,12 @@ export function renderPoliciesScreen(
       out.push(`${INDENT}Jev mode: off, set by FailproofAI Cloud (overrides jev.json).`);
     } else if (jevMode) {
       out.push(`${INDENT}Jev mode: ${jevMode}, set by FailproofAI Cloud. Jev checks run on FailproofAI Cloud; nothing of them is installed here.`);
-      // Jev-only Cloud policies never reach the machine (N6): say so, or an
-      // empty section reads as "Cloud deployed nothing".
-      out.push(`${INDENT}Jev-only Cloud policies are not listed here; see them with ${kit.cmd("fp fleet show")} or on the dashboard.`);
+      // A manifest from a server that predates `jevPolicies` does not name its
+      // Jev-only policies: say so, or an empty section reads as "Cloud
+      // deployed nothing".
+      if (!screen.cloud.jevListed) {
+        out.push(`${INDENT}Jev-only Cloud policies are not listed here; see them with ${kit.cmd("fp fleet show")} or on the dashboard.`);
+      }
     }
     for (const problem of problems ?? []) out.push(kit.caution(problem));
   }
@@ -1616,8 +1641,9 @@ export async function listHooks(cwd?: string, { all = false }: { all?: boolean }
   // Each policy's KIND is shown — `regex` (JS) or `both` (JS whose verdict
   // its own Jev checks may clear) — with the Jev check names a `both` policy
   // is reviewed by. Those checks, and every `jev` policy, run on FailproofAI
-  // Cloud (CONTRACT C10): nothing of them is on this machine, so no Jev-only
-  // policy is listed here, and the machine cannot count them.
+  // Cloud (CONTRACT C10): no question is on this machine, but the manifest's
+  // `jevPolicies` names each Jev assignment, so a Jev-only policy gets a row
+  // (tagged `jev`) like the JS ones.
   let cloud: PoliciesScreen["cloud"] = null;
   try {
     // Every assignment, agent-scoped ones included (B4): this lists the
@@ -1650,25 +1676,41 @@ export async function listHooks(cwd?: string, { all = false }: { all?: boolean }
     } catch {
       // No report: every row reads as the deployment says.
     }
-    // Only the hook path imports Cloud JavaScript (N4): a policy no hook has
-    // load-checked under this deployment is not yet known to load, so it is
-    // not drawn as ● on.
-    let loadChecked: Set<string> | null = null;
+    // A policy deployed here is drawn ● on. Only the hook path imports Cloud
+    // JavaScript, so one that fails to load is known only after a tool call,
+    // and then shows as not loaded (errors.json, above) — never as a transient
+    // "not loaded yet" state of its own.
+    // Jev-only assignments (`jevPolicies`): ids, versions, effects and scopes,
+    // never a question. A `both` policy is in both lists and is drawn once,
+    // from its JS row. Null from a server that predates the list.
+    let jevAssignments: ReturnType<typeof readCloudJevAssignments> = null;
     try {
-      const record = readCloudLoadChecked();
-      loadChecked = new Set(record && record.deployment === active[0]?.deployment ? record.checked : []);
+      jevAssignments = readCloudJevAssignments();
     } catch {
-      loadChecked = new Set();
+      // Never throws by contract.
     }
-    const labels = active.some((a) => a.agentTargets?.some((tg) => tg.instanceId)) ? readRosterLabels() : new Map<string, string>();
+    const jsIds = new Set(active.map((a) => a.id));
+    const jevOnly = (jevAssignments ?? []).filter((a) => !jsIds.has(a.id));
+    const labels = [...active, ...jevOnly].some((a) => a.agentTargets?.some((tg) => tg.instanceId))
+      ? readRosterLabels()
+      : new Map<string, string>();
     const targetText = (targets: NonNullable<(typeof active)[number]["agentTargets"]>): string =>
       `for ${targets
         .map((tg) => (tg.instanceId ? `${tg.integration} / ${labels.get(tg.instanceId) ?? tg.instanceId}` : tg.integration))
         .join(", ")}`;
-    if (active.length > 0 || jev.jevMode !== null) {
+    if (active.length > 0 || jevOnly.length > 0 || jev.jevMode !== null) {
+      const jevRows: PoliciesScreenRow[] = jevOnly.map((a) => {
+        const tags = [
+          ...(a.effect === "observe" ? ["observe"] : []),
+          "jev",
+          ...(a.agentTargets?.length ? [targetText(a.agentTargets)] : []),
+        ];
+        return { state: "on" as const, name: a.id, description: `v${a.version}`, tag: tags.join(" · ") };
+      });
       cloud = {
         deployment: active[0]?.deployment ?? jev.deployment ?? null,
-        rows: active.map((artifact) => {
+        jevListed: jevAssignments !== null,
+        rows: [...active.map((artifact) => {
           // Only a `both` policy carries a server-derived reviewer list (C1).
           const both = artifact.authority === "reviewable" && (artifact.reviewedBy?.length ?? 0) > 0;
           const checks = both ? (artifact.reviewedBy ?? []).join(", ") : "";
@@ -1691,21 +1733,13 @@ export async function listHooks(cwd?: string, { all = false }: { all?: boolean }
               tag: [...tags, `not loaded: ${failed}`].join(" · "),
             };
           }
-          if (!loadChecked?.has(`${artifact.id}@${artifact.version}`)) {
-            return {
-              state: "off" as const,
-              name: artifact.id,
-              description: `v${artifact.version}`,
-              tag: [...tags, "not loaded yet: it loads at the next agent tool call"].join(" · "),
-            };
-          }
           return {
             state: "on" as const,
             name: artifact.id,
             description: `v${artifact.version}`,
             ...(tags.length > 0 ? { tag: tags.join(" · ") } : {}),
           };
-        }),
+        }), ...jevRows],
         jevMode: jev.jevMode,
         problems: [
           ...(jsProblem !== null ? [`The Cloud JavaScript policies could not be read, so none of them is enforcing: ${jsProblem}`] : []),