failproofai 1.0.11 → 1.0.12-beta.1

package/src/hooks/jev-cli.ts

@@ -108,6 +108,8 @@ import {
   inspectJevConfig,
   jevCloudBaseUrl,
   jevConfigPath,
+  loadJevConfigForCloudMode,
+  TRANSCRIPTS_DISABLED_PROBLEM,
   providerForUrl,
   providerHostConflict,
   readJevConfigFileForUpdate,
@@ -144,6 +146,7 @@ import {
   type ReviewableCoverage,
 } 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 type { JevRequest } from "./semantic/types";
 import { TOKEN_ON_ARGV, optsFor, paint, screenKit, stack, wrap, type RenderOpts } from "./tui";
@@ -1418,7 +1421,201 @@ function safeCoverage(): ReviewableCoverage | null {
   }
 }
 
+// ── status: FailproofAI Cloud ────────────────────────────────────────────────
+//
+// FailproofAI Cloud can SET this machine's Jev mode (`active.json` `jevMode`).
+// With `observe`/`enforce` the Jev checks Cloud deployed here run ON Cloud —
+// nothing of them is on this machine (CONTRACT C10) — every gated tool call
+// goes there on the Cloud Jev credential, and `jev.json` is not used. With
+// `off`, Jev is off whatever `jev.json` says. So `status` answers from Cloud
+// first; without a Cloud mode the local answer stands.
+//
+// What it can show about Cloud's checks is only what the machine knows: the
+// mode, and the `reviewedBy` names of the deployment's `both` policies — the
+// Cloud checks that may clear their regex half. Never a check's contents: the
+// machine does not have them.
+
+/** Label for everything Cloud decided here. Customer-facing: never "AgentEye". */
+const MODE_SET_BY_CLOUD = "mode set by FailproofAI Cloud";
+
+/** The one sentence the contract fixes for `jev status` under a Cloud mode (C10.5). */
+export function jevRunsOnCloudLine(mode: string): string {
+  return `Jev checks run on FailproofAI Cloud (mode: ${mode})`;
+}
+
+function safeCloudJev(): CloudJevState {
+  try {
+    return readCloudJevState();
+  } catch {
+    return { jevMode: null, deployment: null, errors: [] };
+  }
+}
+
+/** A `both` policy's Cloud reviewers, as the deployment names them. */
+interface CloudReviewers {
+  policy: string;
+  version: number;
+  effect: "enforce" | "observe";
+  reviewedBy: string[];
+}
+
+/** Every Cloud JS policy that names Cloud checks in `reviewedBy` — a `both` policy. Never throws. */
+function cloudReviewers(): CloudReviewers[] {
+  try {
+    // Every assignment, agent-scoped ones included: this describes the machine.
+    return listActiveCloudManagedPolicies()
+      .filter((p) => p.authority === "reviewable" && (p.reviewedBy?.length ?? 0) > 0)
+      .map((p) => ({ policy: p.id, version: p.version, effect: p.effect, reviewedBy: [...(p.reviewedBy ?? [])] }));
+  } catch {
+    return [];
+  }
+}
+
+/** What to do about a Cloud mode this machine cannot act on. */
+function cloudProblemAdvice(problem: string): string[] {
+  if (problem === TRANSCRIPTS_DISABLED_PROBLEM) {
+    return [
+      "Jev does not run here: this machine was connected for decisions only (--no-transcripts), and a Jev call sends each checked tool call and the recent prompt to FailproofAI Cloud.",
+      "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.",
+  ];
+}
+
 async function status(argv: string[], opts: RenderOpts): Promise<JevCliResult> {
+  const cloud = safeCloudJev();
+  if (cloud.jevMode === null && cloud.errors.length === 0) return localStatus(argv, opts);
+  const parsed = parseFlags(argv, new Set(["--json"]));
+  if (typeof parsed === "string" || parsed.positionals.length > 0) return localStatus(argv, opts);
+  const asJson = parsed.bools.has("--json");
+
+  if (cloud.jevMode === null) {
+    // A mode this build cannot read is no mode: jev.json decides. Said beside it.
+    const local = await localStatus(argv, opts);
+    if (asJson && local.json !== undefined) {
+      const body = JSON.parse(local.json) as Record<string, unknown>;
+      body.cloud = { jevMode: null, modeSetBy: null, errors: cloud.errors };
+      return { ...local, json: JSON.stringify(body, null, 2) };
+    }
+    return { ...local, lines: [...local.lines, ...jevWarn(cloud.errors.map((e) => `${e.id}: ${e.message}`), opts)] };
+  }
+
+  const mode = cloud.jevMode;
+  const resolved = loadJevConfigForCloudMode(mode);
+  const reviewers = cloudReviewers();
+  let stats: JevStats | null = null;
+  try {
+    stats = await jevStats();
+  } catch {
+    stats = null;
+  }
+  const cfg = resolved.config;
+  const coverage = cfg ? safeCoverage() : null;
+  const route = cfg ? jevRoute(cfg) : null;
+  const running = cfg !== null;
+
+  if (asJson) {
+    const body: Record<string, unknown> = {
+      path: jevConfigPath(),
+      status: running ? "ok" : mode === "off" ? "off" : "unconfigured",
+      mode,
+      modeSetBy: "FailproofAI Cloud",
+      ...(mode !== "off" ? { runsOn: "FailproofAI Cloud" } : {}),
+      ...(cfg && route
+        ? {
+            provider: cfg.provider,
+            providerLabel: providerLabel(cfg.provider),
+            endpoint: shownEndpoint(cfg.provider, route.endpoint),
+            model: route.model,
+            modelIsDefault: route.modelIsDefault,
+            timeoutMs: cfg.timeoutMs,
+          }
+        : {}),
+      ...(resolved.problem ? { problem: resolved.problem } : {}),
+      cloud: { jevMode: mode, modeSetBy: "FailproofAI Cloud", reviewers, errors: cloud.errors },
+      ...(coverage
+        ? {
+            reviewablePolicies: {
+              enabled: coverage.enabled,
+              reviewable: coverage.reviewable,
+              customPolicyFiles: coverage.customFiles,
+              // The checks THIS machine's packs give; Cloud's are asked on Cloud.
+              jevChecks: coverage.jevChecks,
+              // "No checks installed" is not a problem here: FailproofAI Cloud's
+              // checks are asked whatever this machine has installed.
+              problem: coverage.jevChecks === 0 ? null : reviewableProblem(coverage),
+            },
+          }
+        : {}),
+      stats,
+    };
+    return ok([], JSON.stringify(body, null, 2));
+  }
+
+  const head =
+    mode === "off"
+      ? jevHeader("Jev status", `off — ${MODE_SET_BY_CLOUD}`, opts)
+      : running
+        ? jevHeader("Jev status", `on · ${mode} — ${jevRunsOnCloudLine(mode)}`, opts)
+        : jevHeader("Jev status", `off — FailproofAI Cloud set ${mode}, and this machine cannot run it`, opts);
+  const reviewerRows = reviewers.map((r): [string, string] => [
+    `${r.policy} v${r.version}`,
+    `${r.reviewedBy.join(", ")}${r.effect === "observe" ? " (not asked while observed)" : ""}`,
+  ]);
+  return ok(
+    stack(
+      head,
+      mode === "off"
+        ? jevNote(
+            `FailproofAI Cloud switched Jev off on this machine. That overrides ${jevConfigPath()} for as long as this machine is connected.`,
+            opts,
+          )
+        : jevNote(
+            `${jevRunsOnCloudLine(mode)}. Every checked tool call goes to FailproofAI Cloud, which asks the Jev checks it ` +
+              "deployed to this machine and this machine's installed packs' checks in one request; nothing of Cloud's checks is " +
+              `installed here. ${jevConfigPath()} is not used while FailproofAI Cloud sets the mode. In enforce, Jev's own deny ` +
+              "checks block calls as well as clearing the regex policies they review. Jev-only Cloud policies are not on this machine, so they are " +
+              "not listed here; fp fleet show and the dashboard list them.",
+            opts,
+          ),
+      cfg && route
+        ? jevRows(
+            [
+              ["runs on", "FailproofAI Cloud"],
+              ["endpoint", shownEndpoint(cfg.provider, route.endpoint)],
+              ["model", route.modelIsDefault ? `${route.model} (provider default)` : route.model],
+              ["mode", `${modeLine(mode)} (${MODE_SET_BY_CLOUD})`],
+              ["timeout", `${cfg.timeoutMs} ms`],
+            ],
+            opts,
+          )
+        : jevRows([["mode", mode === "off" ? `${modeLine("off")} (${MODE_SET_BY_CLOUD})` : `${mode} (${MODE_SET_BY_CLOUD}) — not running`]], opts),
+      resolved.problem ? jevWarn(cloudProblemAdvice(resolved.problem), opts) : null,
+      reviewerRows.length > 0
+        ? stack(
+            [screenKit(opts).head("Cloud reviewers", "FailproofAI Cloud policies reviewed by their Cloud Jev checks")],
+            jevRows(reviewerRows, opts),
+          )
+        : [],
+      cloud.errors.length > 0 ? jevWarn(cloud.errors.map((e) => `${e.id}: ${e.message}`), opts) : null,
+      coverage ? jevNote(reviewableSummary(coverage), opts) : null,
+      jevStatsLines(stats, opts),
+    ),
+  );
+}
+
+async function localStatus(argv: string[], opts: RenderOpts): Promise<JevCliResult> {
   const parsed = parseFlags(argv, new Set(["--json"]));
   if (typeof parsed === "string") return fail([parsed, "", ...JEV_USAGE]);
   if (parsed.positionals.length > 0) return fail([STRAY_ARGUMENT, "", ...JEV_USAGE]);

package/src/hooks/jev-cloud-connection.ts

@@ -86,8 +86,100 @@ export type CloudJevConfigWrite =
       /** Set when the kept file leaves Jev off here: refused, or switched off. */
       jevOff?: { why: "refused"; problem: string; fix?: string } | { why: "off" };
     }
+  /**
+   * The Cloud's own `jev.json` (provider `failproofai`, as `config` writes it)
+   * named another FailproofAI Cloud origin, and was pointed at this one: same
+   * mode, same everything else. A BYOK file is never touched.
+   */
+  | { status: "repointed"; path: string; from: string; baseUrl: string; mode: string }
   | { status: "error"; path: string; problem: string };
 
+/**
+ * Create `jev.json` for the Cloud provider unless one exists. Never throws and
+ * never replaces a file — except the Cloud's own file pointing at another
+ * FailproofAI Cloud origin, which is re-pointed here (`repointCloudJevConfig`):
+ * a reconnect on a new URL (http → https) otherwise left Jev off, refused for
+ * naming an origin the key was not issued for.
+ */
+export function writeCloudJevConfig(cloudBase: string): CloudJevConfigWrite {
+  const first = writeCloudJevConfigIfAbsent(cloudBase);
+  if (first.status === "kept" && first.provider === JEV_CLOUD_PROVIDER && first.otherOrigin) {
+    return repointCloudJevConfig(cloudBase, first);
+  }
+  return first;
+}
+
+/**
+ * Point the Cloud's `jev.json` at `cloudBase`, keeping every other field. The
+ * file is moved aside first and judged there (as `removeCloudJevConfig` does),
+ * so a BYOK file renamed into place meanwhile is never the one rewritten, and
+ * the new file is linked in no-clobber.
+ */
+function repointCloudJevConfig(cloudBase: string, found: Extract<CloudJevConfigWrite, { status: "kept" }>): CloudJevConfigWrite {
+  const path = jevConfigPath();
+  let baseUrl: string;
+  try {
+    baseUrl = jevCloudBaseUrl(cloudBase);
+  } catch {
+    return found;
+  }
+  let st: Stats;
+  try {
+    st = lstatSync(path);
+  } catch {
+    return found;
+  }
+  if (!st.isFile()) return found;
+  const aside = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.repointing`;
+  try {
+    renameSync(path, aside);
+  } catch {
+    return found;
+  }
+  let raw: Record<string, unknown> | null = null;
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(aside, "utf8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) raw = parsed as Record<string, unknown>;
+  } catch {
+    raw = null;
+  }
+  if (!raw || raw.provider !== JEV_CLOUD_PROVIDER) {
+    // Not the Cloud's after all: back exactly as it was.
+    putBack(aside, path, st.mode & 0o777);
+    return found;
+  }
+  const body = `${JSON.stringify({ ...raw, baseUrl }, null, 2)}\n`;
+  const tmp = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+  try {
+    writeFileSync(tmp, body, { mode: 0o600, flag: "wx" });
+    chmodSync(tmp, 0o600);
+    linkSync(tmp, path);
+  } catch {
+    // Something landed at the path meanwhile, or the write failed: the old
+    // file goes back (never over the new one) and nothing was re-pointed.
+    putBack(aside, path, st.mode & 0o777);
+    return found;
+  } finally {
+    try {
+      rmSync(tmp, { force: true });
+    } catch {
+      // A stray temp file holds no key.
+    }
+  }
+  try {
+    unlinkSync(aside);
+  } catch {
+    // The aside copy is the old URL only; harmless if it lingers.
+  }
+  return {
+    status: "repointed",
+    path,
+    from: found.otherOrigin ?? "",
+    baseUrl,
+    mode: typeof raw.mode === "string" ? raw.mode : DEFAULT_JEV_MODE,
+  };
+}
+
 /**
  * Create `jev.json` for the Cloud provider unless one exists. Never throws and
  * never replaces a file.

package/src/hooks/manager.ts

@@ -32,7 +32,9 @@ import { getInstanceId, hashToId } from "../../lib/telemetry-id";
 import { CliError } from "../cli-error";
 import { hookLogWarn } from "./hook-logger";
 import { customPoliciesDir } from "./fp-home";
-import { readActiveCloudManagedPolicies } from "./cloud-managed-policies";
+import { listActiveCloudManagedPolicies, readCloudJevState, type CloudJevMode } from "./cloud-managed-policies";
+import { readCloudLoadChecked, readCloudPolicyErrors } from "./cloud-policy-errors";
+import { readRosterLabels } from "./agent-roster";
 import { CORE_SOURCE, addPack, setPackPolicyEnabled } from "./pack-store";
 import type { ResolvedPack } from "./pack-manifest";
 import { hasInstalledRegexPacks, readInstalledPacks } from "./pack-manifest";
@@ -363,7 +365,7 @@ export function notEnforcingReason(cwd?: string): NotEnforcingReason | null {
 
   // Cloud-managed policies, pushed from a deployment.
   try {
-    for (const artifact of readActiveCloudManagedPolicies()) {
+    for (const artifact of listActiveCloudManagedPolicies()) {
       if (artifact.effect === "observe") observing = true;
       else return null;
     }
@@ -409,7 +411,7 @@ export function enforcingPolicyCount(cwd?: string): { count: number; custom: boo
     // An unreadable manifest counts nothing, as it enforces nothing.
   }
   try {
-    for (const artifact of readActiveCloudManagedPolicies()) {
+    for (const artifact of listActiveCloudManagedPolicies()) {
       if (artifact.effect !== "observe") count++;
     }
   } catch {
@@ -1245,7 +1247,14 @@ export interface PoliciesScreen {
   attention: { failed: boolean; text: string; fix?: string } | null;
   custom: PoliciesScreenRow[];
   convention: Array<{ scope: string; rows: PoliciesScreenRow[] }>;
-  cloud: { deployment: number; rows: PoliciesScreenRow[] } | null;
+  cloud: {
+    deployment: number | null;
+    rows: PoliciesScreenRow[];
+    /** FailproofAI Cloud's Jev mode for this machine, when the deployment sets one. */
+    jevMode?: CloudJevMode | null;
+    /** Problems reading the deployment, each one line. */
+    problems?: string[];
+  } | null;
   /**
    * Builtins this build enforces itself because no pack is installed: the
    * migration shim (`handler.ts` registers `enabledPolicies` when
@@ -1376,7 +1385,19 @@ export function renderPoliciesScreen(
   }
   if (screen.custom.length > 0) plain("Custom policies", undefined, screen.custom);
   for (const { scope, rows } of screen.convention) plain("Convention policies", scope, rows);
-  if (screen.cloud) plain("Cloud-managed", `deployment ${screen.cloud.deployment}`, screen.cloud.rows);
+  if (screen.cloud) {
+    const { deployment, rows, jevMode, problems } = screen.cloud;
+    plain("Cloud-managed", deployment !== null ? `deployment ${deployment}` : undefined, rows);
+    if (jevMode === "off") {
+      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.`);
+    }
+    for (const problem of problems ?? []) out.push(kit.caution(problem));
+  }
 
   if (folded > 0) out.push("", `See all ${total} with ${kit.cmd("failproofai policies --all")}`);
   return out;
@@ -1591,20 +1612,105 @@ export async function listHooks(cwd?: string, { all = false }: { all?: boolean }
   // pushed to a fleet were the ones invisible to the person running the
   // command on it. Read-only: they belong to the deployment, which the heading
   // says, and `--uninstall <name>` cannot switch one off.
+  //
+  // 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.
   let cloud: PoliciesScreen["cloud"] = null;
   try {
-    const active = readActiveCloudManagedPolicies();
-    if (active.length > 0) {
+    // Every assignment, agent-scoped ones included (B4): this lists the
+    // machine's deployment, not what one hook would load.
+    let active: ReturnType<typeof listActiveCloudManagedPolicies> = [];
+    let jsProblem: string | null = null;
+    try {
+      active = listActiveCloudManagedPolicies();
+    } catch (err) {
+      // The Jev mode is read independently below; a machine Cloud set one on
+      // still gets its section, with this said.
+      jsProblem = err instanceof Error ? err.message : String(err);
+    }
+    let jev: ReturnType<typeof readCloudJevState> = { jevMode: null, deployment: null, errors: [] };
+    try {
+      jev = readCloudJevState();
+    } catch {
+      // Never throws by contract; guarded anyway, for the same reason as above.
+    }
+    // A Cloud JS policy that did not load (B5): the hook path records it in
+    // errors.json for the deployment in force, so the row says "not loaded"
+    // rather than ● on.
+    const loadErrors = new Map<string, string>();
+    try {
+      for (const e of readCloudPolicyErrors() ?? []) {
+        if (e.kind !== "regex" && e.kind !== "both") continue;
+        const artifact = active.find((a) => a.id === e.id);
+        if (artifact && (e.version === null || e.version === artifact.version)) loadErrors.set(e.id, e.message);
+      }
+    } 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;
+    try {
+      const record = readCloudLoadChecked();
+      loadChecked = new Set(record && record.deployment === active[0]?.deployment ? record.checked : []);
+    } catch {
+      loadChecked = new Set();
+    }
+    const labels = active.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) {
       cloud = {
-        deployment: active[0].deployment,
-        rows: active.map((artifact) => ({
-          state: "on" as const,
-          name: artifact.id,
-          description: `v${artifact.version}`,
-          // `observe` is evaluated and then has its verdict discarded, so the
-          // row says so rather than reading as plain enforcement.
-          ...(artifact.effect === "observe" ? { tag: "observe" } : {}),
-        })),
+        deployment: active[0]?.deployment ?? jev.deployment ?? 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(", ") : "";
+          const tags = [
+            // `observe` is evaluated and then has its verdict discarded, so the
+            // row says so rather than reading as plain enforcement.
+            ...(artifact.effect === "observe" ? ["observe"] : []),
+            // A plain JS policy stays the plain row it always was.
+            ...(both ? ["both"] : []),
+            // An observe `both` has its Jev half withheld by Cloud (C9.3).
+            ...(both ? [artifact.effect === "observe" ? `${checks} (not asked while observed)` : `Jev checks: ${checks}`] : []),
+            ...(artifact.agentTargets?.length ? [targetText(artifact.agentTargets)] : []),
+          ];
+          const failed = loadErrors.get(artifact.id);
+          if (failed !== undefined) {
+            return {
+              state: "failed" as const,
+              name: artifact.id,
+              description: `v${artifact.version}`,
+              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(" · ") } : {}),
+          };
+        }),
+        jevMode: jev.jevMode,
+        problems: [
+          ...(jsProblem !== null ? [`The Cloud JavaScript policies could not be read, so none of them is enforcing: ${jsProblem}`] : []),
+          ...jev.errors.map((e) => `${e.id}${e.version === null ? "" : ` v${e.version}`}: ${e.message}`),
+        ],
       };
     }
   } catch {

package/src/hooks/pack-failclosed.ts

@@ -54,6 +54,8 @@ export interface MissingGuard {
  */
 export const PERMANENT_LOAD_FAILURES: ReadonlySet<string> = new Set([
   "module_not_found",
+  // A data file the policy reads at load is as missing on the next call.
+  "file_not_found",
   "syntax_error",
   "runtime_error",
   "path_missing",

package/src/hooks/pack-manifest.ts

@@ -738,8 +738,15 @@ export function semanticQuestions(
  * Per ENTRY, not per pack: one malformed question set must not take the rest of
  * a publisher's semantic policies with it, for the same reason one malformed
  * pack does not take the other packs with it.
+ *
+ * Exported for one reader outside this file: the shared FailproofAI Cloud
+ * fixtures test (`cloud-jev-policies.test.ts`). A Cloud Jev declaration is
+ * exactly a manifest semantic entry, and Cloud's publish validation mirrors
+ * this parser — so the test pins that both accept and refuse the same
+ * declarations, and measure their questions alike. The machine itself never
+ * parses a Cloud declaration: those checks run on FailproofAI Cloud (C10).
  */
-function parsePackSemantic(packId: string, value: unknown, warnings: string[]): SemanticManifestEntry[] {
+export function parsePackSemantic(packId: string, value: unknown, warnings: string[]): SemanticManifestEntry[] {
   if (value === undefined) return [];
   if (!Array.isArray(value)) {
     warnings.push(`pack ${packId} semantic is not an array, so none of it was loaded`);

package/src/hooks/policy-evaluator.ts

@@ -250,7 +250,11 @@ export async function evaluatePolicies(
     twoTier: {
       activity: combined.activity,
       decidedByJev: combined.decidedByJev,
-      ...(combined.decidedByJev && review.kind === "answered" && review.origin ? { jevOrigin: review.origin } : {}),
+      // The deciding check's origin — and, in observe mode, the origin of the
+      // check that WOULD have decided (B12), so that row names its policy too.
+      ...((combined.decidedByJev || combined.observeVerdict) && review.kind === "answered" && review.origin
+        ? { jevOrigin: review.origin }
+        : {}),
       ...(combined.observeVerdict ? { observeVerdict: combined.observeVerdict } : {}),
     },
   };

package/src/hooks/policy-registry.ts

@@ -8,6 +8,7 @@
 import type { HookEventType } from "./types";
 import type { PolicyFunction, PolicyMatcher, PolicyParamsSchema, RegisteredPolicy } from "./policy-types";
 import { effectiveReviewerNames, forgetEffectiveReviewerNames } from "./effective-reviewers";
+import type { AgentIdentity } from "./agent-targets";
 import { resolvePolicyAuthority, type AuthorityDeclaration } from "./policy-authority";
 
 const REGISTRY_KEY = "__FAILPROOFAI_POLICY_REGISTRY__";
@@ -126,14 +127,14 @@ export function getPoliciesForEvent(
 }
 
 /** `cli`: the agent this pass registers for, which scopes the Jev reviewer set. */
-export function clearPolicies(cli?: string): void {
+export function clearPolicies(cli?: string, agent: AgentIdentity | null = null): void {
   const g = globalThis as GlobalWithRegistry;
   g[REGISTRY_KEY] = [];
   setIndexCache(null);
   // The reviewer set describes the policies that are about to be registered, so
   // it is rebuilt with them. Dropping it here is also what keeps one read per
   // evaluation instead of one per policy.
-  forgetEffectiveReviewerNames(cli);
+  forgetEffectiveReviewerNames(cli, agent);
 }
 
 /**

package/src/hooks/policy-reviewability.ts

@@ -55,7 +55,12 @@
  * - **A session pause.** It suspends local policy for minutes, and a warning
  *   about a policy set that is coming back shortly would be noise.
  */
-import { readActiveCloudManagedPolicies } from "./cloud-managed-policies";
+import {
+  cloudAuthorityDeclaration,
+  cloudReviewerNames,
+  readActiveCloudManagedPolicies,
+  readCloudJevMode,
+} from "./cloud-managed-policies";
 import { jevPacks } from "./effective-reviewers";
 import { resolve } from "node:path";
 import { discoverPolicyFiles } from "./custom-hooks-loader";
@@ -202,9 +207,15 @@ export function surveyReviewableCoverage(cwd?: string): ReviewableCoverage {
   }
 
   try {
-    for (const assignment of readActiveCloudManagedPolicies()) {
-      records.push({ authority: assignment.authority, reviewedBy: assignment.reviewedBy });
-    }
+    // Exactly as `handler.ts` registers them: a `both` policy is reviewable
+    // only while FailproofAI Cloud's Jev mode asks, and then only by its own
+    // Cloud checks (`cloud:<id>/<name>`), which this machine cannot list but
+    // Cloud answers for. No mode, `off`, or an `observe` assignment: hard.
+    const mode = readCloudJevMode();
+    const assignments = readActiveCloudManagedPolicies();
+    const cloudReviewers = cloudReviewerNames(assignments, mode);
+    if (cloudReviewers.length > 0) reviewers = new Set([...(reviewers ?? []), ...cloudReviewers]);
+    for (const assignment of assignments) records.push(cloudAuthorityDeclaration(assignment, mode));
   } catch {
     // Same fail-open as the handler's own read of this file.
   }
@@ -225,7 +236,12 @@ export function surveyReviewableCoverage(cwd?: string): ReviewableCoverage {
     customFiles = 0;
   }
 
-  return { ...countReviewable(records, reviewers), customFiles, jevChecks: reviewers?.size ?? 0 };
+  return {
+    ...countReviewable(records, reviewers),
+    customFiles,
+    // The checks THIS machine asks; a Cloud policy's checks are FailproofAI Cloud's.
+    jevChecks: reviewers ? [...reviewers].filter((name) => !name.startsWith("cloud:")).length : 0,
+  };
 }
 
 /**