failproofai 1.0.7-beta.2 → 1.0.8-beta.0

package/.next/standalone/app/actions/get-jev-config.ts

@@ -45,10 +45,14 @@
  * value `jev setup` would also have printed. See `JevModelView`.
  */
 
+import { readCredentials, readJevCloudCredential } from "@/src/hooks/fp-config";
 import {
+  CLOUDFLARE_ACCOUNT_ID_RE,
   DEFAULT_JEV_MODE,
   JEV_API_KEY_ENV,
+  JEV_CLOUD_PROVIDER,
   JEV_PROVIDER_KINDS,
+  baseUrlWithoutQuery,
   inspectJevConfig,
   looksLikeCredential,
   readJevConfigForUpdate,
@@ -63,8 +67,8 @@ import {
   surveyReviewableCoverage,
 } from "@/src/hooks/policy-reviewability";
 
-/** The loader's four answers, unchanged — see `JevConfigInspection`. */
-export type JevSettingsStatus = "absent" | "ok" | "key-missing" | "refused";
+/** The loader's answers, unchanged — see `JevConfigInspection`. */
+export type JevSettingsStatus = "absent" | "ok" | "key-missing" | "refused" | "off" | "not-connected" | "key-lacks-jev";
 
 /** What Jev has been doing lately, from `jevStats()`. Not a new pipeline. */
 export interface JevSettingsStats {
@@ -89,7 +93,8 @@ export interface JevSettingsStats {
  * not computed and not sent.
  */
 export interface JevTokenPresence {
-  source: "file" | "env";
+  /** `cloud`: the key is this machine's FailproofAI Cloud key, held in `credentials.json`. */
+  source: "file" | "env" | "cloud";
 }
 
 /**
@@ -139,10 +144,35 @@ export interface JevReviewabilityView {
   problem: string | null;
 }
 
+/**
+ * This machine's FailproofAI Cloud connection, as far as Jev is concerned —
+ * read from `credentials.json` on every render, with NO network call and
+ * nothing secret in it: the org as the server named it at connect time, the
+ * host, and whether the key carries Jev. Every token in that file is read and
+ * dropped inside `cloudConnectionView`; none of it, nor any piece of it, is in
+ * this object.
+ */
+export interface JevCloudConnectionView {
+  /** A Cloud credential (policy or reporting) is stored on this machine. */
+  connected: boolean;
+  /** "Acme Inc (acme)" — recorded at connect time; null when it was not. */
+  org: string | null;
+  /** The Cloud host, e.g. `app.befailproof.ai`. */
+  host: string | null;
+  /**
+   * Whether the key this machine connected with carries `jev:evaluate` — which
+   * is exactly whether connect stored a `jev` slot. `refused`: a slot may be
+   * there, but `credentials.json` is not owner-only, so Jev will not read it.
+   */
+  jev: "yes" | "no" | "refused";
+}
+
 export interface JevSettingsView {
   status: JevSettingsStatus;
   /** True only when a hook running right now would consult Jev. */
   on: boolean;
+  /** See `JevCloudConnectionView`. Present on every status. */
+  cloud: JevCloudConnectionView;
   /**
    * `~/.failproofai/jev.json`, whether or not it exists, and its permission
    * bits as `0600` when it has some.
@@ -158,8 +188,24 @@ export interface JevSettingsView {
   path: string;
   permissions: string | null;
   provider: JevProviderKind | null;
-  /** The stored base URL, or "" for the provider's own API. Form value. */
+  /**
+   * The stored base URL, or "" for the provider's own API. Form value, and
+   * NEVER its query string — see `baseUrlView` below for why, and
+   * `baseUrlQueryWithheld` for what the panel says about the part it did not
+   * get.
+   */
   baseUrl: string;
+  /**
+   * True when the stored base URL carries a query string that `baseUrl` above
+   * does not.
+   *
+   * The panel needs it to avoid lying twice over: the field would otherwise
+   * show a URL that is not the stored one, and an untouched save would look
+   * like it kept a query string the person never saw. `update-jev-config.ts`
+   * keeps a stored query that the loader accepts when the field comes back
+   * unchanged, and this is how the panel can say so.
+   */
+  baseUrlQueryWithheld: boolean;
   /** Cloudflare only; "" otherwise. Form value. */
   accountId: string;
   /**
@@ -213,6 +259,27 @@ function modelView(stored: string): JevModelView {
   return { kind: "id", id: stored };
 }
 
+/**
+ * A stored base URL as the browser may see it: never its query string.
+ *
+ * `validateBaseUrl` now refuses a credential-bearing query parameter, so a file
+ * written by THIS build cannot carry one. A file written by an older one can,
+ * and that file is precisely the one this module hands back for repair — the
+ * refused branch below copies the raw routing fields out on purpose. Only the
+ * derived `endpoint` was elided (`displayEndpoint`), so the base URL carried
+ * the secret through a response whose whole documented rule is that the
+ * credential never comes back.
+ *
+ * Every branch goes through this one function rather than reading `baseUrl`
+ * itself, for the reason `routingFromRaw` copies field by field: the next field
+ * added should not be able to quietly reintroduce it.
+ */
+function baseUrlView(stored: string | undefined): { baseUrl: string; baseUrlQueryWithheld: boolean } {
+  if (!stored) return { baseUrl: "", baseUrlQueryWithheld: false };
+  const { url, hadQuery } = baseUrlWithoutQuery(stored);
+  return { baseUrl: url, baseUrlQueryWithheld: hadQuery };
+}
+
 function octal(mode: number | null): string | null {
   return mode === null ? null : mode.toString(8).padStart(4, "0");
 }
@@ -244,25 +311,65 @@ function routingFromRaw(raw: Record<string, unknown> | null): {
   return {
     provider,
     baseUrl: asString(raw?.baseUrl),
-    accountId: asString(raw?.accountId),
+    // An account id is 32 hex characters; anything else in that slot of a
+    // refused file may be a pasted key, and is not shown.
+    accountId: CLOUDFLARE_ACCOUNT_ID_RE.test(asString(raw?.accountId)) ? asString(raw?.accountId) : "",
     model: asString(raw?.model),
-    mode: modeRaw === "shadow" || modeRaw === "enforce" ? modeRaw : DEFAULT_JEV_MODE,
+    mode: modeRaw === "off" || modeRaw === "shadow" || modeRaw === "enforce" ? modeRaw : DEFAULT_JEV_MODE,
   };
 }
 
-/** `jevRoute` for display, swallowing the throw a file that names no usable route produces. */
+/**
+ * Whether a switched-off file still has a key to switch back on with — as a
+ * SOURCE, like every other token field here. The routing the loader reports
+ * for an `off` file deliberately carries no key, so this is read for presence
+ * only: the raw file's `apiKey` is tested and dropped, and the Cloud
+ * credential's status is read and its key never touched.
+ */
+function offTokenPresence(provider: JevProviderKind): JevTokenPresence | null {
+  if (provider === JEV_CLOUD_PROVIDER) {
+    try {
+      return readJevCloudCredential().status === "ok" ? { source: "cloud" } : null;
+    } catch {
+      return null;
+    }
+  }
+  const raw = readJevConfigForUpdate();
+  return typeof raw?.apiKey === "string" && raw.apiKey !== "" ? { source: "file" } : null;
+}
+
+/**
+ * `jevRoute` for display, swallowing the throw a file that names no usable
+ * route produces.
+ *
+ * A FailproofAI Cloud config is only routed against the origin of the
+ * credential it was validated with (`validateLoadedJevConfig`). The loaded
+ * config carries it; a display stand-in built here — for a file that is off,
+ * refused, or has no credential behind it — gets the file's own origin, like
+ * the stand-in key beside it. Nothing built here is ever sent.
+ */
 function endpointFor(cfg: JevConfig): string | null {
   try {
-    return displayEndpoint(jevRoute(cfg).endpoint);
+    return displayEndpoint(jevRoute(displayOnlyCloudOrigin(cfg)).endpoint);
   } catch {
     return null;
   }
 }
 
+function displayOnlyCloudOrigin(cfg: JevConfig): JevConfig {
+  if (cfg.provider !== JEV_CLOUD_PROVIDER || cfg.credentialOrigin || typeof cfg.baseUrl !== "string") return cfg;
+  try {
+    return { ...cfg, credentialOrigin: new URL(cfg.baseUrl).origin };
+  } catch {
+    return cfg;
+  }
+}
+
 /**
  * The fallback rate and the counts behind it, for the one line on the panel
- * that says whether Jev is working. Read only when Jev is actually on: on a
- * machine with no config the numbers are all zero and the line would be noise.
+ * that says whether Jev is working. Read only when Jev is on, or may be for
+ * hooks whose environment has the key: on a machine with no config the numbers
+ * are all zero and the line would be noise.
  *
  * `jevStats()` never throws and derives from the activity store the activity
  * tab already reads, so this adds no pipeline and no persisted state.
@@ -295,7 +402,10 @@ async function statsOrNull(on: boolean): Promise<JevSettingsStats | null> {
 function reviewableOrNull(on: boolean): JevReviewabilityView | null {
   if (!on) return null;
   try {
-    const coverage = surveyReviewableCoverage();
+    // The launch directory, as every other dashboard read resolves project
+    // config: the standalone server chdirs into the package, and `jev status`
+    // counts the project it is run in.
+    const coverage = surveyReviewableCoverage(process.env.FAILPROOFAI_LAUNCH_CWD || process.cwd());
     return {
       enabled: coverage.enabled,
       reviewable: coverage.reviewable,
@@ -307,6 +417,42 @@ function reviewableOrNull(on: boolean): JevReviewabilityView | null {
   }
 }
 
+/**
+ * The Cloud connection row, from the local files only. `readCredentials`
+ * returns every token on the machine; this function takes the three
+ * non-secret facts out and lets the rest go, so the object it returns — and
+ * therefore the page — never holds a key. Never throws.
+ */
+function cloudConnectionView(): JevCloudConnectionView {
+  let connected = false;
+  let org: string | null = null;
+  let host: string | null = null;
+  try {
+    const creds = readCredentials();
+    const url = creds.cloud?.url ?? creds.ingest?.url ?? null;
+    connected = url !== null;
+    if (url !== null) {
+      try {
+        host = new URL(url).host;
+      } catch {
+        host = null;
+      }
+    }
+    const o = creds.org;
+    org = o ? (o.name && o.slug ? `${o.name} (${o.slug})` : (o.name ?? o.slug ?? o.id ?? null)) : null;
+  } catch {
+    // An unreadable file is "not connected" here, as it is to `config --status`.
+  }
+  let jev: JevCloudConnectionView["jev"] = "no";
+  try {
+    const slot = readJevCloudCredential().status;
+    jev = slot === "ok" ? "yes" : slot === "refused" ? "refused" : "no";
+  } catch {
+    jev = "no";
+  }
+  return { connected, org, host, jev };
+}
+
 /**
  * Everything /settings shows about Jev, and nothing it must not.
  *
@@ -317,10 +463,12 @@ function reviewableOrNull(on: boolean): JevReviewabilityView | null {
 export async function getJevSettingsAction(): Promise<JevSettingsView> {
   const inspection = inspectJevConfig();
   const base = {
+    cloud: cloudConnectionView(),
     path: inspection.path,
     permissions: null as string | null,
     provider: null as JevProviderKind | null,
     baseUrl: "",
+    baseUrlQueryWithheld: false,
     accountId: "",
     model: { kind: "default" } as JevModelView,
     endpoint: null as string | null,
@@ -340,7 +488,7 @@ export async function getJevSettingsAction(): Promise<JevSettingsView> {
       on: true,
       permissions: octal(inspection.mode),
       provider: cfg.provider,
-      baseUrl: cfg.baseUrl ?? "",
+      ...baseUrlView(cfg.baseUrl),
       accountId: cfg.accountId ?? "",
       // A loadable config's model already passed `validateModel`, so this can
       // only be an id — run through the same gate anyway, because the gate is
@@ -365,7 +513,7 @@ export async function getJevSettingsAction(): Promise<JevSettingsView> {
       on: false,
       permissions: octal(inspection.mode),
       provider: r.provider,
-      baseUrl: r.baseUrl ?? "",
+      ...baseUrlView(r.baseUrl),
       accountId: r.accountId ?? "",
       model: modelView(r.model ?? ""),
       endpoint: endpointFor({ ...r, apiKey: KEY_STAND_IN }),
@@ -376,6 +524,38 @@ export async function getJevSettingsAction(): Promise<JevSettingsView> {
       token: null,
       problem: inspection.problem,
       fix: `set ${JEV_API_KEY_ENV}, or save a token here`,
+      // Off in THIS process's environment only; hooks that have the variable
+      // still consult Jev, and the activity store records what they did.
+      stats: await statsOrNull(true),
+    };
+  }
+
+  if (inspection.status === "off" || inspection.status === "not-connected" || inspection.status === "key-lacks-jev") {
+    // Configured, and not running: switched off by its owner, or a FailproofAI
+    // Cloud file on a machine with no Cloud key — not connected at all, or
+    // connected with a key that has no Jev. Routing only, as for
+    // `key-missing` — the loader's routing object carries no key to leak.
+    const r = inspection.routing;
+    return {
+      ...base,
+      status: inspection.status,
+      on: false,
+      permissions: octal(inspection.mode),
+      provider: r.provider,
+      ...baseUrlView(r.baseUrl),
+      accountId: r.accountId ?? "",
+      model: modelView(r.model ?? ""),
+      endpoint: endpointFor({ ...r, apiKey: KEY_STAND_IN }),
+      mode: r.mode ?? DEFAULT_JEV_MODE,
+      timeoutMs: r.timeoutMs ?? null,
+      token: inspection.status === "off" ? offTokenPresence(r.provider) : null,
+      problem: inspection.status === "off" ? null : inspection.problem,
+      fix:
+        inspection.status === "not-connected"
+          ? "connect this machine with a key that carries jev:evaluate: failproofai config --token <key>"
+          : inspection.status === "key-lacks-jev"
+            ? "reconnect this machine with a key that carries jev:evaluate: failproofai config --token <key>"
+            : null,
       stats: null,
     };
   }
@@ -390,7 +570,7 @@ export async function getJevSettingsAction(): Promise<JevSettingsView> {
       on: false,
       permissions: octal(inspection.mode),
       provider: r.provider,
-      baseUrl: r.baseUrl,
+      ...baseUrlView(r.baseUrl),
       accountId: r.accountId,
       // This is the branch the rule exists for: a file whose `model` slot holds
       // a pasted key IS a refused file, and these fields are copied raw.

package/.next/standalone/app/actions/update-jev-config.ts

@@ -107,13 +107,18 @@ import {
   resolveDashboardHost,
 } from "@/lib/dashboard-host";
 import {
+  JEV_CLOUD_PROVIDER,
   JEV_PROVIDER_KINDS,
+  baseUrlWithoutQuery,
+  endpointGivenAsBase,
   jevConfigPath,
+  providerHostConflict,
   readJevConfigFileForUpdate,
   validateApiKey,
   validateBaseUrl,
   validateJevConfig,
 } from "@/src/hooks/semantic/jev-config";
+import { endpointAsBaseReason } from "@/src/hooks/semantic/jev-client";
 import { getJevSettingsAction, type JevSettingsView } from "./get-jev-config";
 
 /**
@@ -129,7 +134,7 @@ export interface JevConfigInput {
   baseUrl: string;
   /** Cloudflare only. */
   accountId: string;
-  /** "shadow" | "enforce". */
+  /** "off" | "shadow" | "enforce". */
   mode: string;
   /** "" keeps the key where it is: the stored one, or the environment's. */
   token: string;
@@ -225,6 +230,32 @@ function originOf(raw: string): string | null {
   }
 }
 
+/**
+ * The base URL to WRITE for a submitted one.
+ *
+ * The panel is never sent a stored query string (`baseUrlView` in
+ * `get-jev-config.ts`), so what comes back from an untouched field is the stored
+ * URL with its query removed. Writing that verbatim would delete a query the
+ * person never saw — `?api-version=`, which some proxies route on — on any save
+ * that only meant to change the mode. So a submission that is exactly the
+ * stored URL minus its query keeps the stored one, and anything else is a URL
+ * they actually typed and is written as typed.
+ *
+ * Only a stored query the LOADER accepts is carried back. One it refuses is a
+ * credential in a base URL (`validateBaseUrl`), which is the very thing the
+ * person is on this page to repair: dropping it is the repair, and re-saving the
+ * file is the only way the panel has to perform it.
+ */
+function baseUrlToStore(submitted: string, stored: unknown): string {
+  if (typeof stored !== "string" || stored === "") return submitted;
+  const keep = validateBaseUrl(stored);
+  if (!keep.ok) return submitted;
+  const shown = baseUrlWithoutQuery(keep.value);
+  if (!shown.hadQuery) return submitted;
+  const typed = validateBaseUrl(submitted);
+  return typed.ok && typed.value === shown.url ? keep.value : submitted;
+}
+
 /**
  * `~/.failproofai` at the umask is group-writable on a umask-002 machine, and a
  * directory others can write into defeats the file's 0600 — they unlink it and
@@ -259,21 +290,55 @@ export async function saveJevConfigAction(input: JevConfigInput): Promise<JevWri
   if (!(JEV_PROVIDER_KINDS as readonly string[]).includes(provider)) {
     return { ok: false, problem: `provider must be one of ${JEV_PROVIDER_KINDS.join(", ")}` };
   }
+  if (provider === JEV_CLOUD_PROVIDER) {
+    // Its endpoint and key come from this machine's FailproofAI Cloud
+    // connection, not from a form: `config --token` writes both, and the only
+    // thing this page may change about it is the mode (`setJevModeAction`).
+    return {
+      ok: false,
+      problem:
+        "FailproofAI Cloud's Jev is turned on by connecting this machine (failproofai config --token <key>), and switched with the mode control — not saved from this form.",
+    };
+  }
 
-  const baseUrl = input.baseUrl.trim();
-  if (baseUrl) {
-    // Checked here, before anything is decided about the token, so an
-    // unparseable URL is reported as an unparseable URL rather than as "that
-    // endpoint is not the one the token was given for" — which is what a URL
-    // that resolves to no origin would otherwise look like below.
-    const url = validateBaseUrl(baseUrl);
-    if (!url.ok) return { ok: false, problem: url.problem };
+  // Refused, as `setJevModeAction` and `jev setup --mode` refuse it — not
+  // skipped, which kept the old mode or wrote none (and none loads as enforce).
+  if (input.mode !== "off" && input.mode !== "shadow" && input.mode !== "enforce") {
+    return { ok: false, problem: 'mode must be "off", "shadow" or "enforce".' };
   }
 
+  const baseUrl = input.baseUrl.trim();
+  // Checked here, before anything is decided about the token, so an
+  // unparseable URL is reported as an unparseable URL rather than as "that
+  // endpoint is not the one the token was given for" — which is what a URL
+  // that resolves to no origin would otherwise look like below.
+  const url = baseUrl ? validateBaseUrl(baseUrl) : null;
+  if (url && !url.ok) return { ok: false, problem: url.problem };
+
   const existingFile = readJevConfigFileForUpdate();
   const existing = existingFile?.raw ?? null;
   const sameProvider = existing !== null && existing.provider === provider;
 
+  // `jev setup`'s refusal of an endpoint where a base belongs (`…/v1/models`):
+  // every call would go to `<that>/systemone` and 404 back to regex. Only for a
+  // URL typed here, as the CLI checks only a `--base-url` it was given — an
+  // older file whose base already ends in `/systemone` routes correctly and the
+  // loader takes it, so re-saving it untouched (a mode switch) must still work.
+  if (url?.ok) {
+    const stored = validateBaseUrl(existing?.baseUrl);
+    const untouched =
+      sameProvider && stored.ok && baseUrlWithoutQuery(stored.value).url === baseUrlWithoutQuery(url.value).url;
+    const conflict = untouched ? null : providerHostConflict(provider, url.value);
+    if (conflict) return { ok: false, problem: `${conflict}.` };
+    const asEndpoint = untouched ? null : endpointGivenAsBase(url.value);
+    if (asEndpoint) {
+      return {
+        ok: false,
+        problem: `that url is an endpoint, not an api base — its path ends in ${asEndpoint.suffix}. ${endpointAsBaseReason(url.value)} Use ${baseUrlWithoutQuery(asEndpoint.base).url} instead.`,
+      };
+    }
+  }
+
   // Same provider: update in place, keeping every field not named here —
   // `model`, a `timeoutMs` set from the CLI, and ones a newer failproofai wrote,
   // none of which this form knows about or may drop. A different provider starts
@@ -287,7 +352,7 @@ export async function saveJevConfigAction(input: JevConfigInput): Promise<JevWri
   }
   next.provider = provider;
 
-  if (baseUrl) next.baseUrl = baseUrl;
+  if (baseUrl) next.baseUrl = baseUrlToStore(baseUrl, existing?.baseUrl);
   else delete next.baseUrl;
 
   // `model` is NOT touched here, and that is the point: `JevConfigInput` has no
@@ -305,7 +370,7 @@ export async function saveJevConfigAction(input: JevConfigInput): Promise<JevWri
     delete next.accountId;
   }
 
-  if (input.mode === "shadow" || input.mode === "enforce") next.mode = input.mode;
+  next.mode = input.mode;
 
   // Where the key may travel. Unchanged provider AND unchanged origin, from a
   // file only its owner could have written — anything else asks again.
@@ -393,6 +458,86 @@ export async function saveJevConfigAction(input: JevConfigInput): Promise<JevWri
   return { ok: true, view: await getJevSettingsAction() };
 }
 
+/**
+ * Switch Jev's mode — `off`, `shadow` or `enforce` — and change NOTHING else.
+ *
+ * This is the on/off switch for FailproofAI Cloud's Jev, whose `jev.json` the
+ * page must not delete: its endpoint and key are not this page's to re-enter,
+ * so "off" by deletion would be off until the owner re-ran `config --token`
+ * with the key in hand. `off` keeps the file and runs no Jev at all
+ * (`loadJevConfig` returns null for it), which is the switch this needs.
+ * It works on a BYOK file too, where it keeps the key.
+ *
+ * What "nothing else" means, precisely: the existing object is spread and only
+ * `mode` is set — no field is added, dropped or normalised, and the key, the
+ * endpoint and the provider are exactly what they were. It is written the way
+ * every other write here is (`writeJsonAtomically`, 0600, owner-only
+ * directory), after the loader's own validator has checked the result with
+ * stand-ins in the key slots, so `enforce` is refused where the loader would
+ * refuse it (plain http to localhost) rather than written and then ignored.
+ *
+ * Refused for a file the loader calls too open: someone else may have written
+ * the endpoint it names, and re-saving it at 0600 would start trusting that
+ * endpoint. Jev is already off for such a file; the page shows why and how.
+ */
+export async function setJevModeAction(mode: string): Promise<JevWriteResult> {
+  const refusal = await crossOriginRefusal();
+  if (refusal) return { ok: false, problem: refusal };
+  if (mode !== "off" && mode !== "shadow" && mode !== "enforce") {
+    return { ok: false, problem: 'mode must be "off", "shadow" or "enforce".' };
+  }
+
+  const existingFile = readJevConfigFileForUpdate();
+  if (existingFile === null) {
+    return {
+      ok: false,
+      problem: `there is no readable ${jevConfigPath()} to switch. connect this machine (failproofai config --token <key>) or set up your own endpoint below.`,
+    };
+  }
+  if (existingFile.tooOpen) {
+    return {
+      ok: false,
+      problem: `${jevConfigPath()} is open to other users, so Jev is already off and the endpoint it names is not trusted. fix its permissions first (chmod 600, and chmod 700 on its directory).`,
+    };
+  }
+
+  const next: Record<string, unknown> = { ...existingFile.raw, mode };
+
+  // The file as the loader would judge it, keys aside: a stored key is checked
+  // for real, a missing one (key-from-env, or the Cloud's) gets a stand-in —
+  // whether this machine is connected right now is not what a mode switch is
+  // about, and the page says so separately.
+  const cloud = next.provider === JEV_CLOUD_PROVIDER;
+  const checked = validateJevConfig(
+    next,
+    cloud || typeof next.apiKey === "string" ? null : ENV_KEY_STAND_IN,
+    cloud ? { url: originOrEmpty(next.baseUrl), key: ENV_KEY_STAND_IN } : null,
+  );
+  if (!checked.ok) return { ok: false, problem: checked.problem };
+
+  const path = jevConfigPath();
+  try {
+    writeJsonAtomically(path, next, { mode: 0o600, dirMode: 0o700 });
+  } catch (err) {
+    return {
+      ok: false,
+      problem: `could not write ${path} (${(err as NodeJS.ErrnoException).code ?? "error"}).`,
+    };
+  }
+  tightenConfigDir(path);
+  return { ok: true, view: await getJevSettingsAction() };
+}
+
+/** A stored base URL's origin, for a stand-in credential; "" when it has none. */
+function originOrEmpty(raw: unknown): string {
+  if (typeof raw !== "string") return "";
+  try {
+    return new URL(raw).origin;
+  } catch {
+    return "";
+  }
+}
+
 /**
  * Delete `~/.failproofai/jev.json`. Hooks go back to the regex engine on the
  * very next tool call — the loader reads the file per event, so there is
@@ -400,6 +545,10 @@ export async function saveJevConfigAction(input: JevConfigInput): Promise<JevWri
  *
  * Removing a file that is not there succeeds: the user asked for Jev to be off,
  * and it is.
+ *
+ * The BYOK "turn jev off". The FailproofAI Cloud route is switched off with
+ * `setJevModeAction("off")` instead — see there for why deleting its file is
+ * the wrong switch.
  */
 export async function removeJevConfigAction(): Promise<JevWriteResult> {
   const refusal = await crossOriginRefusal();

package/.next/standalone/app/policies/hooks-client.tsx

@@ -492,9 +492,9 @@ function ActivityTab({
     const v = url.get("cli");
     return isKnownCli(v) ? v : "";
   });
-  const [filterSource, setFilterSource] = useState<"" | "custom" | "convention" | "cloud" | "pack">(() => {
+  const [filterSource, setFilterSource] = useState<"" | "custom" | "convention" | "cloud" | "pack" | "jev">(() => {
     const v = url.get("source");
-    return v === "custom" || v === "convention" || v === "cloud" || v === "pack" ? v : "";
+    return v === "custom" || v === "convention" || v === "cloud" || v === "pack" || v === "jev" ? v : "";
   });
   const debounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const filterTelemetryFirstRunRef = useRef(true);
@@ -665,7 +665,7 @@ function ActivityTab({
               onChange={(e) => {
                 const v = e.target.value;
                 setFilterSource(
-                  v === "custom" || v === "convention" || v === "cloud" || v === "pack" ? v : "",
+                  v === "custom" || v === "convention" || v === "cloud" || v === "pack" || v === "jev" ? v : "",
                 );
               }}
               className="filter-input"
@@ -676,6 +676,8 @@ function ActivityTab({
               <option value="convention">convention</option>
               <option value="cloud">cloud</option>
               <option value="pack">pack</option>
+              {/* Jev's own verdict, in enforce mode: no registered policy decided. */}
+              <option value="jev">jev</option>
             </select>
           </div>
           <div className="filter-group">