failproofai 1.0.12-beta.1 → 1.0.12-beta.2

package/.next/standalone/fp-cloud-cli/fp_cli/output.py

@@ -490,7 +490,7 @@ _TOP_LEVEL_GROUPS = [
     ]),
     ("ENFORCE", [
         ("policies", "Write cloud-managed policies.", "list show publish test compose enable disable delete"),
-        ("fleet", "Deploy policies to machines.", "list show deploy jev-mode diff history rollback rename"),
+        ("fleet", "Deploy policies to machines.", "list show deploy diff history rollback rename"),
         ("guardrails", "What enforcement actually blocked.", "summary timeline"),
     ]),
     ("MANAGE", [
@@ -6312,16 +6312,6 @@ def render_deploy_plan(plan: Any, *, applied: bool = False) -> None:
     footer.append(f"polic{'y' if n == 1 else 'ies'} after this change", style=theme.LABEL)
     lines.append(Text())
     lines.append(footer)
-    if getattr(plan, "jev_mode", None) is not None:
-        before = plan.jev_mode_before or "local"
-        after = plan.jev_mode_after or "local"
-        jev = Text("  jev mode  ", style=theme.LABEL)
-        if plan.jev_mode_changes:
-            jev.append(f"{before} → ", style=theme.FAINT)
-            jev.append(after, style=f"bold {theme.ACCENT}")
-        else:
-            jev.append(f"{after} (unchanged)", style=theme.TEXT_DIM)
-        lines.append(jev)
 
     head = Text(plan.machine_id, style=f"bold {theme.TEXT}")
     if plan.base is not None:
@@ -6482,65 +6472,6 @@ def deployment_rolled_back(
     _notice_box(body, color=theme.SUCCESS, title="rolled back")
 
 
-def render_jev_mode_plan(rows: Sequence[dict]) -> None:
-    """The mode-only change, per machine: ``from → to``, the set untouched."""
-    out = []
-    for r in rows:
-        changed = bool(r.get("changed"))
-        mode = Text()
-        if changed:
-            mode.append(f"{r.get('from')} → ", style=theme.FAINT)
-            mode.append(str(r.get("to")), style=f"bold {theme.ACCENT}")
-        else:
-            mode.append(f"{r.get('to')} (unchanged)", style=theme.TEXT_DIM)
-        out.append([Text(str(r.get("machineId")), style=theme.TEXT), mode])
-    n = sum(1 for r in rows if r.get("changed"))
-    title = Text()
-    title.append("jev mode", style=f"bold {theme.ACCENT}")
-    title.append(" · ", style=theme.FAINT)
-    title.append(f"{n} of {len(rows)} to change", style=theme.LABEL)
-    title.append(" · policy sets untouched", style=theme.FAINT)
-    render_list_panel("jev mode", header=["machine", "jev mode"], rows=out, days=set(), order=None,
-                      empty_message="no machines", title=title)
-
-
-def jev_mode_applied(rows: Sequence[dict]) -> None:
-    """``✓ jev mode observe → enforce on N machines``, and any that failed."""
-    done = [r for r in rows if r.get("changed") and not r.get("error")]
-    failed = [r for r in rows if r.get("error")]
-    for r in done:
-        body = Text()
-        body.append("✓ ", style=theme.SUCCESS)
-        body.append("jev mode ", style=theme.TEXT)
-        body.append(f"{r.get('from')} → ", style=theme.FAINT)
-        body.append(str(r.get("to")), style=f"bold {theme.ACCENT}")
-        body.append(" on ", style=theme.TEXT)
-        body.append(str(r.get("machineId")), style=theme.ACCENT)
-        if r.get("deployment") is not None:
-            body.append("  ·  ", style=theme.FAINT)
-            body.append(f"now on deployment #{r.get('deployment')}", style=theme.LABEL)
-        _notice_box(body, color=theme.SUCCESS, title="jev mode")
-    for r in failed:
-        body = Text()
-        body.append("✗ ", style=theme.ERROR)
-        body.append(str(r.get("machineId")), style=theme.ACCENT)
-        body.append("  ·  ", style=theme.FAINT)
-        body.append(str(r.get("error")), style=theme.TEXT)
-        _notice_box(body, color=theme.ERROR, title="jev mode not changed")
-
-
-def jev_mode_unchanged(machine_ids: Sequence[str], mode: str) -> None:
-    """Every machine already has the mode. Calm, like a no-op deploy."""
-    body = Text()
-    body.append("=  ", style=theme.FAINT)
-    body.append(", ".join(machine_ids) if len(machine_ids) <= 3 else f"{len(machine_ids)} machines",
-                style=theme.ACCENT)
-    body.append(f" already {'has' if len(machine_ids) == 1 else 'have'} jev mode {mode}", style=theme.TEXT)
-    body.append("  ·  ", style=theme.FAINT)
-    body.append("nothing changed", style=theme.LABEL)
-    _notice_box(body, color=theme.ACCENT, title="no change")
-
-
 def machine_renamed(machine_id: str, label: str) -> None:
     body = Text()
     body.append("✓ ", style=theme.SUCCESS)
@@ -6819,7 +6750,7 @@ def render_deployment_history(machine_id: str, entries: Sequence[dict],
                 [("+", f"{i} → {scope[i]}") for i in sorted(set(cur) - set(prev))]
                 + [("-", i) for i in sorted(set(prev) - set(cur))]
                 + [("~", f"{i} → {scope[i]}") for i in sorted(set(cur) & set(prev)) if cur[i] != prev[i]]
-                # A mode-only generation (`fp fleet jev-mode`) read as "no
+                # A mode-only generation (a legacy jev-mode change) read as "no
                 # change", which is exactly the change a rollback brings back.
                 + ([("~", f"jev {prev_mode}→{mode}")] if mode != prev_mode else [])
             )

package/.next/standalone/fp-cloud-cli/skill/SKILL.md

@@ -197,7 +197,7 @@ you need a flag you don't already know.
 
 **Enforce (cloud-managed policy, session-only — see §2):**
 - `policies list|show|publish|enable|disable|delete|test|compose` — policy versions. `publish` mints a version of a kind — `regex` (a local `.mjs`), `jev` (`--semantic checks.json`: Jev declarations, no JavaScript) or `both` (the two, the JavaScript reviewable by its own checks); list/show print the kind and the Jev check names; `test` runs one against a synthetic context locally (it applies each policy's `match` filter, so a policy that does not cover the `--event`/`--tool` you pass is reported `skipped`, not run). `enable`/`disable`/`delete` take `--yes`.
-- `fleet list|show|deploy|jev-mode|diff|history|rollback|rename` — which machines run which policies, and the policy errors each machine reports. **`deploy` REPLACES a machine's whole set** (`--add`/`--remove` amend it, `--set` replaces, `--create` mints a deployment, `--jev-mode off|observe|enforce|local` sets the machine's Jev mode from FailproofAI Cloud — overriding its own, machine-wide, and left alone when omitted; in `enforce` Jev's checks BLOCK calls as well as clear). `jev-mode <machine…|--all> <mode>` changes only the mode, never the set; `rollback` restores the generation's Jev mode too; it prints the plan and asks **only on an interactive terminal without `--json`** — under `--json` or with stdin redirected it applies immediately, so read `fleet show` first if you want review.
+- `fleet list|show|deploy|diff|history|rollback|rename` — which machines run which policies, and the policy errors each machine reports. **`deploy` REPLACES a machine's whole set** (`--add`/`--remove` amend it, `--set` replaces, `--create` mints a deployment). There is no Jev mode to set: FailproofAI Cloud turns Jev on for a machine while a `jev`/`both` policy is deployed to it (off otherwise); trial one with `:observe`. `deploy` prints the plan and asks **only on an interactive terminal without `--json`** — under `--json` or with stdin redirected it applies immediately, so read `fleet show` first if you want review.
 - `guardrails summary|timeline` — what enforcement actually did; `--since 1h|6h|24h|7d`, `--machine`.
 
 **Analytics & assistant:**

package/.next/standalone/fp-cloud-cli/skill/references/commands.md

@@ -235,14 +235,14 @@ Cloud-managed enforcement, split the way the dashboard splits it: `policies` wri
 
 ### fleet
 - `fleet list` — `machine · label · pol · intended · applied · seen · events · state`. `intended` is the generation deployed, `applied` what the machine last collected (they differ until it polls), and `seen` how long since it last reported anything — a machine can be in sync and dead, or alive and behind, which are different problems. `state` reads `N errors` when the machine reported policies it could not apply. JSON `{machines, deployments}` with raw epoch-ms timestamps plus the computed `drifted`; a machine carries `policyErrors`/`policyErrorsAt` and `jevMode` when the server has them.
-- `fleet show <machine>` — the set the machine is told to run, **and whether it has collected it**. Reads both the deployment and the machine record, so it reports `not yet collected` / `machine is on #N` / `collected` alongside who deployed it, when, and last-seen. A machine can be told to run a policy it has never picked up; the policy list alone cannot tell you which. Also the **Jev mode** FailproofAI Cloud sets on it (`local` when none) and the **policy errors** the machine last reported — `[{id, version, kind: regex|jev|both|daemon, message}]`: a policy that did not load, `jev_unconfigured` (a Jev mode, and the machine's key does not carry Jev), `transcripts_disabled` (a Jev mode on a machine connected with `--no-transcripts`, which never asks), `jev_budget: dropped <name>` (an installed pack's check FailproofAI Cloud left out of a request for the question budget). Whatever is listed there is not enforcing. JSON `{machine, deployment}` with raw timestamps and both label fields; `deployment: null` when nothing is deployed.
-- `fleet deploy <machine> [--add REF]… [--remove ID]… [--set REF]… [--jev-mode off|observe|enforce|local] [--create] [-y]`
+- `fleet show <machine>` — the set the machine is told to run, **and whether it has collected it**. Reads both the deployment and the machine record, so it reports `not yet collected` / `machine is on #N` / `collected` alongside who deployed it, when, and last-seen. A machine can be told to run a policy it has never picked up; the policy list alone cannot tell you which. Also the **Jev mode** FailproofAI Cloud derived for it from its policies (`local` when none) and the **policy errors** the machine last reported — `[{id, version, kind: regex|jev|both|daemon, message}]`: a policy that did not load, `jev_unconfigured` (a Jev mode, and the machine's key does not carry Jev), `transcripts_disabled` (a Jev mode on a machine connected with `--no-transcripts`, which never asks), `jev_budget: dropped <name>` (an installed pack's check FailproofAI Cloud left out of a request for the question budget). Whatever is listed there is not enforcing. JSON `{machine, deployment}` with raw timestamps and both label fields; `deployment: null` when nothing is deployed.
+- `fleet deploy <machine> [--add REF]… [--remove ID]… [--set REF]… [--create] [-y]`
 
   **A deploy REPLACES the whole set.** The endpoint takes the full list and does not merge. `--add`/`--remove` are a read-modify-write: the CLI reads the current set, applies the delta, prints the complete result, writes that. `--set` replaces everything and is refused alongside `--add`/`--remove`.
 
-  REF is `id`, `id@version`, `id:effect`, or `id@version:effect`. Effect is `enforce` (default) or `observe`. A bare `--add` of an already-deployed policy **keeps its pinned version** — pass `id@version` to move it. Every kind deploys the same way (a `both` policy's JavaScript and its checks go together); the effect applies to JavaScript only, so `observe` on a `jev` policy is refused (**exit 2**) — watch Jev through the mode instead — and an `observe` `both` policy sends only its (observed) JavaScript: its Jev checks are not asked while it is observed.
+  REF is `id`, `id@version`, `id:effect`, or `id@version:effect`. Effect is `enforce` (default) or `observe`. A bare `--add` of an already-deployed policy **keeps its pinned version** — pass `id@version` to move it. Every kind deploys the same way (a `both` policy's JavaScript and its checks go together), and `observe` applies to every kind: a `jev` policy's checks, or both halves of a `both` policy, are asked and recorded and decide nothing.
 
-  `--jev-mode` sets the machine's Jev mode from FailproofAI Cloud and **overrides the machine's own, a local `off` included**: `observe` asks Jev and logs it while the regex policies decide; `enforce` lets Jev's checks **block** calls (every `jev` policy's deny checks) as well as clear the regex verdicts they review; `off` stops Jev there; `local` hands the choice back to the machine. The mode is the **machine's**: it also governs the checks of every pack installed there. Omitted, it is left as it is (the request carries no `jevMode`). `--jev-mode` with no change to the set changes **only the mode**, through its own route (like `fleet jev-mode`), so disabled policies' assignments and any concurrent edit are untouched; the plan shows `jev mode <from> → <to>` and the JSON adds `jevModeOnly: true`. On a machine with no deployment yet, it deploys the (empty) set with the mode. Jev checks run on FailproofAI Cloud; nothing is installed on the machine. Under `observe`/`enforce` the machine sends each checked tool call to FailproofAI Cloud on its Cloud Jev credential (its `jev.json` is not used); without one it reports `jev_unconfigured`, and connected with `--no-transcripts` it never asks and reports `transcripts_disabled`.
+  There is no Jev mode to set: FailproofAI Cloud turns Jev on for a machine while a `jev` or `both` policy is deployed to it, and off when none is. Jev checks run on FailproofAI Cloud; nothing is installed on the machine. The machine sends each checked tool call of an agent such a policy targets to FailproofAI Cloud on its Cloud Jev credential; without one it reports `jev_unconfigured`, and connected with `--no-transcripts` it never asks and reports `transcripts_disabled`.
 
   Deploying to an id that has never checked in is refused (a typo would mint a machine); `--create` allows it for pre-staging.
 
@@ -252,10 +252,9 @@ Cloud-managed enforcement, split the way the dashboard splits it: `policies` wri
 
   **Exit codes.** A malformed ref (`bad ref!!`, `id:banana`, empty), or `--set` combined with `--add`/`--remove`, is a usage error → **exit 2**, like every other bad flag value. A ref that parses but names something that does not exist (`--add ghost-policy`, an unpublished `@version`) is **exit 1**; an unknown machine is **exit 6**. Branch on these rather than on the message.
 
-  JSON `{plan:{result,added,removed,changed,unchanged,noop[,jevMode:{from,to,changed}]}, deployment, applied}` — the plan is included so a harness does not recompute the diff.
-- `fleet jev-mode <machine>… <mode>` · `fleet jev-mode --all <mode> [-y]` — set the Jev mode FailproofAI Cloud gives machines (`off|observe|enforce|local`) and **nothing else**: the policy set is never read back or rewritten. A machine already on the mode is skipped; `--all` covers every machine with a deployment and skips the rest; a named machine with no deployment is refused before anything is written (`fleet deploy <machine> --jev-mode <mode>` gives it its first). Each change is a new generation in `fleet history`. One machine's failure does not stop the others; the exit code is 1 and the JSON row carries `error`. A bad mode, or `--all` with machine ids, is **exit 2**. JSON `{mode, applied, machines:[{machineId, from, to, changed, deployment?, error?}]}`.
+  JSON `{plan:{result,added,removed,changed,unchanged,noop}, deployment, applied}` — the plan is included so a harness does not recompute the diff.
 - `fleet diff [machine]` — intent vs delivery per machine, with a `drifted` flag. A machine id nobody has reported under is refused (exit 6), not rendered as an empty fleet.
-- `fleet history <machine>` · `fleet rollback <machine> <generation> [-y]` — rollback mints a NEW generation carrying the old set; history stays append-only. The `change` column uses the deploy plan's vocabulary: `+` added, `-` removed, `~` same policy at a different version or effect (an enforce → observe flip is a policy that stopped blocking, so it is never "no change"), and `~ jev <from>→<to>` for a Jev mode change. The `jev` column is the mode FailproofAI Cloud set with each generation (`local` = none). **A rollback restores that generation's Jev mode too**, `local` included: the prompt and the result say `jev mode <now> → <then>`, and the JSON adds `jevModeBefore`.
+- `fleet history <machine>` · `fleet rollback <machine> <generation> [-y]` — rollback mints a NEW generation carrying the old set; history stays append-only. The `change` column uses the deploy plan's vocabulary: `+` added, `-` removed, `~` same policy at a different version or effect (an enforce → observe flip is a policy that stopped blocking, so it is never "no change"), and `~ jev <from>→<to>` for a Jev mode change. The `jev` column is the mode FailproofAI Cloud had with each generation (`local` = none); a rollback's prompt and result say `jev mode <now> → <then>` when it differs, and the JSON adds `jevModeBefore`.
 - `fleet rename <machine> "<label>"` — a human label; the id never changes. The server stores it as an override beside the machine's self-asserted label. An empty label **clears** the override (the machine falls back to its own label, else its id) and the CLI says so rather than reporting a rename to nothing. A machine that has never checked in cannot be renamed → exit 6.
 
 ### guardrails

package/.next/standalone/fp-cloud-cli/tests/test_cloud_jev.py

@@ -1,8 +1,8 @@
 """FailproofAI Cloud Jev / regex / both policies in `fp` (CONTRACT C4, C6).
 
 `fp policies publish --kind regex|jev|both [--source] [--semantic]`, list/show
-carrying the kind and the Jev check names, `fp fleet deploy --jev-mode`, and
-machines showing the policy errors they report.
+carrying the kind and the Jev check names, deploys (no Jev mode: Cloud derives
+it), and machines showing the policy errors they report.
 """
 from __future__ import annotations
 
@@ -144,7 +144,7 @@ def test_semantic_refuses_what_is_not_a_declaration_list(text, needle):
         parse_semantic(text)
 
 
-# ── deploy plan: --jev-mode ───────────────────────────────────────────────────
+# ── deploy plan: no Jev mode ──────────────────────────────────────────────────
 
 
 def _plan(**kw):
@@ -153,38 +153,16 @@ def _plan(**kw):
     return plan_deploy("m1", **base)
 
 
-def test_jev_mode_alone_is_a_change_and_is_carried_in_the_plan():
-    plan = _plan(jev_mode="observe")
-    assert not plan.is_noop and plan.jev_mode_changes
-    assert plan.to_dict()["jevMode"] == {"from": "local", "to": "observe", "changed": True}
-
-
-def test_the_same_jev_mode_again_is_a_noop():
-    assert _plan(jev_mode="observe", current_jev_mode="observe").is_noop
-    assert _plan(jev_mode="local").is_noop  # already local
-
-
-def test_local_hands_the_mode_back_to_the_machine():
-    plan = _plan(jev_mode="local", current_jev_mode="enforce")
-    assert plan.jev_mode_changes and plan.jev_mode_after is None
-    assert plan.to_dict()["jevMode"] == {"from": "enforce", "to": "local", "changed": True}
-
-
-def test_no_jev_mode_says_nothing_and_changes_nothing():
-    plan = _plan(add=["a"], current_jev_mode="enforce")
+def test_a_plan_never_carries_a_jev_mode():
+    with pytest.raises(TypeError):
+        _plan(jev_mode="observe")
+    plan = _plan(add=["a"])
     assert plan.is_noop and "jevMode" not in plan.to_dict()
 
 
-def test_an_unknown_jev_mode_is_a_usage_error():
-    with pytest.raises(RefUsageError, match="not one of off, observe, enforce, local"):
-        _plan(jev_mode="shadow")
-
-
-def test_observe_on_a_jev_policy_is_refused_with_the_mode_that_does_it():
+def test_observe_applies_to_a_jev_policy_like_any_other():
     kinds = version_kinds([PolicyVersion.from_dict(dict(SERVER_JEV, id="j", version=2))])
-    with pytest.raises(RefUsageError, match="use --jev-mode observe"):
-        _plan(add=["j:observe"], kinds=kinds)
-    # enforce is fine, and so is observe on a `both` policy (it applies to the JS half).
+    assert _plan(add=["j:observe"], kinds=kinds).added[0].effect == "observe"
     assert _plan(add=["j"], kinds=kinds).added[0].effect == "enforce"
     both = version_kinds([PolicyVersion.from_dict(dict(SERVER_BOTH, id="j", version=2))])
     assert _plan(add=["j:observe"], kinds=both).added[0].effect == "observe"
@@ -213,14 +191,13 @@ def test_publish_still_refuses_jev_fields_in_the_javascript(monkeypatch):
     assert "--kind both --semantic" in (exc.value.hint or "")
 
 
-def test_deploy_sends_jev_mode_only_when_given(monkeypatch):
+def test_deploy_never_sends_a_jev_mode(monkeypatch):
     bodies = []
     monkeypatch.setattr(client, "_request_json",
                         lambda ctx, method, path, json_body=None: bodies.append(json_body) or {})
     client.deploy_policies(None, "m1", [PolicyRef("a", 1)])
-    client.deploy_policies(None, "m1", [PolicyRef("a", 1)], jev_mode="local")
     assert "jevMode" not in bodies[0]
-    assert bodies[1]["jevMode"] == "local"
+    assert not hasattr(client, "set_jev_mode")
 
 
 # ── the commands, over HTTP ───────────────────────────────────────────────────
@@ -365,25 +342,7 @@ def _fleet_routes(current_policies, jev_mode=None, errors=None):
 
 
 @respx.mock
-def test_fleet_deploy_jev_mode_alone_changes_only_the_mode_through_its_own_route(logged_in, runner):
-    # CONTRACT C9.1: a mode change sent as a deploy rewrote the set the CLI had
-    # read — which leaves out disabled policies' assignments, so they were lost.
-    _fleet_routes([{"id": "no-force-push", "version": 2, "effect": "enforce"}])
-    deploy = respx.put(f"{BASE}/api/enforcement/deployments/m1")
-    mode = respx.put(f"{BASE}/api/enforcement/deployments/m1/jev-mode").mock(return_value=httpx.Response(
-        200, json={"machineId": "m1", "deployment": 6, "jevMode": "observe", "changed": True,
-                   "policies": [{"id": "no-force-push", "version": 2, "effect": "enforce"}]}))
-    result = runner.invoke(app, ["--json", "fleet", "deploy", "m1", "--jev-mode", "observe", "--yes"])
-    assert result.exit_code == 0, result.output
-    assert not deploy.called
-    assert json.loads(mode.calls.last.request.content) == {"jevMode": "observe"}
-    out = json.loads(result.stdout)
-    assert out["applied"] is True and out["jevModeOnly"] is True
-    assert out["plan"]["jevMode"]["to"] == "observe" and out["deployment"]["deployment"] == 6
-
-
-@respx.mock
-def test_fleet_deploy_adds_a_jev_policy_and_leaves_the_mode_alone_without_the_flag(logged_in, runner):
+def test_fleet_deploy_adds_a_jev_policy_and_sends_no_mode(logged_in, runner):
     _fleet_routes([], jev_mode="enforce")
     put = respx.put(f"{BASE}/api/enforcement/deployments/m1").mock(return_value=httpx.Response(
         200, json={"machineId": "m1", "deployment": 6, "jevMode": "enforce",
@@ -395,13 +354,26 @@ def test_fleet_deploy_adds_a_jev_policy_and_leaves_the_mode_alone_without_the_fl
 
 
 @respx.mock
-def test_fleet_deploy_refuses_observe_on_a_jev_policy_before_writing(logged_in, runner):
+def test_fleet_deploy_observes_a_jev_policy(logged_in, runner):
     _fleet_routes([])
-    put = respx.put(f"{BASE}/api/enforcement/deployments/m1")
+    put = respx.put(f"{BASE}/api/enforcement/deployments/m1").mock(return_value=httpx.Response(
+        200, json={"machineId": "m1", "deployment": 6,
+                   "policies": [{"id": "secrets", "version": 1, "effect": "observe"}]}))
     result = runner.invoke(app, ["fleet", "deploy", "m1", "--add", "secrets:observe", "--yes"])
-    assert result.exit_code == 2
-    assert "--jev-mode observe" in result.output + (result.stderr or "")
-    assert not put.called
+    assert result.exit_code == 0, result.output
+    assert json.loads(put.calls.last.request.content) == {
+        "policies": [{"id": "secrets", "version": 1, "effect": "observe"}]}
+
+
+@pytest.mark.parametrize("argv", [
+    ["fleet", "jev-mode", "m1", "observe"],
+    ["fleet", "deploy", "m1", "--jev-mode", "observe"],
+])
+def test_the_jev_mode_cannot_be_set_by_hand(logged_in, runner, argv):
+    with respx.mock(assert_all_called=False) as mock:
+        result = runner.invoke(app, argv)
+        assert result.exit_code == 2, result.output
+        assert not mock.calls
 
 
 @respx.mock
@@ -424,7 +396,7 @@ def test_fleet_show_and_list_show_the_jev_mode_and_the_reported_errors(logged_in
     assert js["deployment"]["jevMode"] == "observe"
 
 
-# ── Review fixes: the Jev mode route (C9.1), rollback and history (m6), help (m7) ──
+# ── Rollback and history show the mode Cloud derived (m6) ────────────────────
 
 
 def _fleet_many(deployments, machines=None):
@@ -443,133 +415,6 @@ def _fleet_many(deployments, machines=None):
         return_value=httpx.Response(200, json=[SERVER_BOTH, SERVER_JEV, SERVER_REGEX_OLD]))
 
 
-def _mode_route(machine_id, mode, deployment=6, status=200):
-    body = ({"machineId": machine_id, "deployment": deployment, "jevMode": None if mode == "local" else mode,
-             "changed": True, "policies": []} if status == 200
-            else {"error": f"machine {machine_id} has no deployment", "code": "no_deployment"})
-    return respx.put(f"{BASE}/api/enforcement/deployments/{machine_id}/jev-mode").mock(
-        return_value=httpx.Response(status, json=body))
-
-
-def test_set_jev_mode_sends_only_the_mode(monkeypatch):
-    seen = {}
-
-    def fake(ctx, method, path, json_body=None, **kw):
-        seen.update(method=method, path=path, body=json_body)
-        return {"machineId": "m1", "deployment": 9, "jevMode": "enforce", "changed": False, "policies": []}
-
-    monkeypatch.setattr(client, "_request_json", fake)
-    dep, changed = client.set_jev_mode(object(), "m1", "enforce")
-    assert seen == {"method": "PUT", "path": "/api/enforcement/deployments/m1/jev-mode", "body": {"jevMode": "enforce"}}
-    assert (dep.deployment, dep.jev_mode, changed) == (9, "enforce", False)
-
-
-@respx.mock
-def test_fleet_deploy_jev_mode_on_a_machine_with_no_deployment_deploys_its_first(logged_in, runner):
-    respx.get(f"{BASE}/api/enforcement/machines").mock(return_value=httpx.Response(
-        200, json=[{"machineId": "m1", "deployment": None, "deployed": False}]))
-    respx.get(f"{BASE}/api/enforcement/deployments").mock(return_value=httpx.Response(200, json=[]))
-    respx.get(f"{BASE}/api/enforcement/policies").mock(return_value=httpx.Response(200, json=[SERVER_JEV]))
-    mode = respx.put(f"{BASE}/api/enforcement/deployments/m1/jev-mode")
-    deploy = respx.put(f"{BASE}/api/enforcement/deployments/m1").mock(return_value=httpx.Response(
-        200, json={"machineId": "m1", "deployment": 1, "jevMode": "observe", "policies": []}))
-    result = runner.invoke(app, ["--json", "fleet", "deploy", "m1", "--jev-mode", "observe", "--yes"])
-    assert result.exit_code == 0, result.output
-    assert not mode.called
-    assert json.loads(deploy.calls.last.request.content) == {"policies": [], "jevMode": "observe"}
-
-
-@respx.mock
-def test_fleet_deploy_with_a_set_change_and_a_mode_still_deploys_both_together(logged_in, runner):
-    _fleet_routes([{"id": "no-force-push", "version": 2, "effect": "enforce"}])
-    mode = respx.put(f"{BASE}/api/enforcement/deployments/m1/jev-mode")
-    deploy = respx.put(f"{BASE}/api/enforcement/deployments/m1").mock(return_value=httpx.Response(
-        200, json={"machineId": "m1", "deployment": 6, "jevMode": "enforce", "policies": []}))
-    result = runner.invoke(app, ["fleet", "deploy", "m1", "--add", "secrets", "--jev-mode", "enforce", "--yes"])
-    assert result.exit_code == 0, result.output
-    assert not mode.called
-    assert json.loads(deploy.calls.last.request.content)["jevMode"] == "enforce"
-
-
-@respx.mock
-def test_fleet_jev_mode_sets_named_machines_and_skips_one_already_there(logged_in, runner):
-    _fleet_many({"m1": None, "m2": "enforce", "m3": "observe"})
-    r1, r2, r3 = _mode_route("m1", "enforce"), _mode_route("m2", "enforce"), _mode_route("m3", "enforce", 7)
-    deploy = respx.put(f"{BASE}/api/enforcement/deployments/m1")
-    result = runner.invoke(app, ["--json", "fleet", "jev-mode", "m1", "m2", "m3", "enforce"])
-    assert result.exit_code == 0, result.output
-    assert r1.called and r3.called and not r2.called and not deploy.called
-    assert json.loads(r1.calls.last.request.content) == {"jevMode": "enforce"}
-    out = json.loads(result.stdout)
-    assert out["mode"] == "enforce" and out["applied"] is True
-    rows = {r["machineId"]: r for r in out["machines"]}
-    assert rows["m1"]["from"] == "local" and rows["m1"]["to"] == "enforce" and rows["m1"]["deployment"] == 6
-    assert rows["m2"]["changed"] is False
-    assert rows["m3"]["from"] == "observe" and rows["m3"]["deployment"] == 7
-
-
-@respx.mock
-def test_fleet_jev_mode_all_covers_every_machine_with_a_deployment_only(logged_in, runner):
-    _fleet_many({"m1": "enforce", "m2": "off"}, machines=["m1", "m2", "m-new"])
-    r1, r2 = _mode_route("m1", "local"), _mode_route("m2", "local")
-    fresh = respx.put(f"{BASE}/api/enforcement/deployments/m-new/jev-mode")
-    result = runner.invoke(app, ["fleet", "jev-mode", "--all", "local"])
-    assert result.exit_code == 0, result.output
-    assert r1.called and r2.called and not fresh.called
-    assert json.loads(r1.calls.last.request.content) == {"jevMode": "local"}
-    assert "enforce → local" in result.stdout and "off → local" in result.stdout
-
-
-@respx.mock
-def test_fleet_jev_mode_when_nothing_changes_writes_nothing(logged_in, runner):
-    _fleet_many({"m1": "observe"})
-    route = _mode_route("m1", "observe")
-    result = runner.invoke(app, ["fleet", "jev-mode", "m1", "observe"])
-    assert result.exit_code == 0, result.output
-    assert not route.called
-    assert "already has jev mode observe" in result.output + (result.stderr or "")
-
-
-@pytest.mark.parametrize("argv, needle", [
-    (["fleet", "jev-mode"], "pass the mode"),
-    (["fleet", "jev-mode", "m1", "shadow"], "is not a Jev mode"),
-    (["fleet", "jev-mode", "observe"], "name at least one machine"),
-    (["fleet", "jev-mode", "--all", "m1", "observe"], "do not name machines"),
-])
-def test_fleet_jev_mode_usage_errors_exit_2_before_any_request(logged_in, runner, argv, needle):
-    with respx.mock(assert_all_called=False) as mock:
-        result = runner.invoke(app, argv)
-        assert result.exit_code == 2, result.output
-        assert needle in result.output + (result.stderr or "")
-        assert not mock.calls
-
-
-@respx.mock
-def test_fleet_jev_mode_refuses_a_named_machine_with_no_deployment_before_writing(logged_in, runner):
-    _fleet_many({"m1": None}, machines=["m1", "m2"])
-    r1 = _mode_route("m1", "observe")
-    result = runner.invoke(app, ["fleet", "jev-mode", "m1", "m2", "observe"])
-    assert result.exit_code == 1, result.output
-    text = result.output + (result.stderr or "")
-    assert "m2 has no deployment" in text and "fp fleet deploy <machine> --jev-mode observe" in text
-    assert not r1.called
-
-
-@respx.mock
-def test_fleet_jev_mode_goes_on_past_a_machine_that_fails_and_names_it(logged_in, runner):
-    _fleet_many({"m1": None, "m2": None})
-    _mode_route("m1", "observe", status=404)
-    r2 = _mode_route("m2", "observe")
-    result = runner.invoke(app, ["--json", "fleet", "jev-mode", "m1", "m2", "observe"])
-    assert result.exit_code == 1, result.output
-    assert r2.called
-    # The result document, then the error document the exit code comes with.
-    out, end = json.JSONDecoder().raw_decode(result.stdout)
-    rows = {r["machineId"]: r for r in out["machines"]}
-    assert "error" in rows["m1"] and rows["m2"]["deployment"] == 6 and out["applied"] is False
-    assert "could not be changed on m1" in result.stdout[end:] + (result.stderr or "")
-
-
 @respx.mock
 def test_fleet_rollback_says_which_jev_mode_it_restores(logged_in, runner):
     _fleet_many({"m1": "off"})
@@ -607,15 +452,6 @@ def test_fleet_history_shows_each_generations_jev_mode_and_a_mode_only_change(lo
     assert any("local" in ln for ln in lines if "#5" in ln)
 
 
-def test_the_help_says_enforce_blocks_and_that_the_mode_is_machine_wide(runner):
-    for argv in (["fleet", "deploy", "--help"], ["fleet", "jev-mode", "--help"]):
-        result = runner.invoke(app, argv)
-        assert result.exit_code == 0, result.output
-        flat = " ".join(result.stdout.split())
-        assert "BLOCK" in flat, argv
-        assert "installed" in flat and "pack" in flat, argv
-
-
 # ── CONTRACT C10.6: Jev checks run on FailproofAI Cloud (help text only) ──────
 
 
@@ -623,7 +459,6 @@ def test_the_help_says_enforce_blocks_and_that_the_mode_is_machine_wide(runner):
     "argv",
     [
         ["fleet", "deploy", "--help"],
-        ["fleet", "jev-mode", "--help"],
         ["policies", "publish", "--help"],
     ],
 )
@@ -637,7 +472,7 @@ def test_the_help_says_jev_checks_run_on_cloud_and_nothing_is_installed(runner,
     assert "AgentEye" not in flat, argv
 
 
-@pytest.mark.parametrize("argv", [["fleet", "show", "--help"], ["fleet", "jev-mode", "--help"]])
+@pytest.mark.parametrize("argv", [["fleet", "show", "--help"]])
 def test_the_help_names_the_reasons_a_machine_cannot_ask(runner, argv):
     flat = " ".join(runner.invoke(app, argv).stdout.split())
     assert "transcripts_disabled" in flat, argv

package/.next/standalone/hermes-plugin/__init__.py

@@ -104,6 +104,17 @@ def _profile_name() -> str:
 
 def _profile_settings_path(profile: str) -> str | None:
     """Evidence of the profile running this plugin, not a transcript guess."""
+    try:
+        # The host's own resolver first: it honours a per-task profile
+        # override as well as HERMES_HOME, so each profile of a multi-profile
+        # gateway reports its own config (and roster identity), not the
+        # process-wide one.
+        from hermes_constants import get_hermes_home
+
+        hosted = Path(get_hermes_home()).expanduser() / "config.yaml"
+        return str(hosted.absolute()) if hosted.is_file() else None
+    except Exception:
+        pass
     configured = os.environ.get("HERMES_HOME", "").strip()
     if configured:
         selected = Path(configured).expanduser() / "config.yaml"

package/.next/standalone/hermes-plugin/plugin.yaml

@@ -1,5 +1,5 @@
 name: failproofai
-version: 1.0.12-beta.1
+version: 1.0.12-beta.2
 description: Real-time FailproofAI policy enforcement for Hermes
 manifest_version: 2
 api_version: 1

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "failproofai",
-  "version": "1.0.12-beta.1",
+  "version": "1.0.12-beta.2",
   "description": "Observability and enforcement for AI agent harnesses. 40 built-in policies hooked into 12 of them — Claude Code, Codex, Cursor, Hermes, OpenClaw and more — blocking the tool call before it runs. Local dashboard included, no account needed.",
   "bin": {
     "failproofai": "./dist/cli.mjs",
@@ -118,22 +118,23 @@
     "postcss": "8.5.26",
     "eslint-plugin-react-hooks": "7.0.1",
     "vite": "8.1.6",
-    "undici": "7.29.1",
+    "undici": "7.30.1",
+    "zod": "4.6.6",
     "brace-expansion": "5.0.12",
     "sharp": "0.35.5",
     "source-map-js": "1.2.2",
     "browserslist": "4.28.8"
   },
   "optionalDependencies": {
-    "@failproofai/failproofaid-linux-x64": "1.0.12-beta.1",
-    "@failproofai/failproofaid-linux-arm64": "1.0.12-beta.1",
-    "@failproofai/failproofaid-darwin-x64": "1.0.12-beta.1",
-    "@failproofai/failproofaid-darwin-arm64": "1.0.12-beta.1"
+    "@failproofai/failproofaid-linux-x64": "1.0.12-beta.2",
+    "@failproofai/failproofaid-linux-arm64": "1.0.12-beta.2",
+    "@failproofai/failproofaid-darwin-x64": "1.0.12-beta.2",
+    "@failproofai/failproofaid-darwin-arm64": "1.0.12-beta.2"
   },
   "failproofaidBinaries": {
-    "linux-x64": "df15e65b60066248038c8ac6d423bffcb0e38637e8a42fa22250afa111fd46ac",
-    "linux-arm64": "59d7ae758c8981c5e0a89eb64be18ebd278213525dd4447891a51be6bb018ed9",
-    "darwin-x64": "b0d3d39abaa02ed0a14dddc68277975a7a23e200830b7edbffdedde3af81ce73",
-    "darwin-arm64": "a6d343b5926e84c0eb437af307f85b69b3128f94c6e34acbf9d0b13a7c7e9d63"
+    "linux-x64": "4c09117fdb80d87792d1d2b77d9359cdbd0c522b5a6222ab7b927659130ddf54",
+    "linux-arm64": "dd390d76561267fc519ceb96fb90be340044e2f564bef36a44e284f227d93f29",
+    "darwin-x64": "62381f7ffe21d02289c36c4b205166b2867dbde986444d1ea185241b94fd04ef",
+    "darwin-arm64": "9ad798817d3048a5126e80dc71883538d37c1b6b6443e9c19389dc2583c8f675"
   }
 }

package/.next/standalone/sdk/python/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.14' and sys_platform == 'win32'",
@@ -1091,11 +1091,33 @@ provides-extras = ["dev", "langchain", "langgraph", "crewai", "llamaindex", "pyd
 
 [[package]]
 name = "filelock"
-version = "3.32.3"
+version = "4.1.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.11' and sys_platform == 'win32'",
+    "python_full_version < '3.11' and sys_platform != 'win32'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4c/58/6fd434bec86eff7c38a3168454cb132b762b2bea9b3ac094101a2f7bc32a/filelock-4.1.0.tar.gz", hash = "sha256:ad7f724afef953e731b1cc39bcd3a09166d72ed7fcdf29e6e88b1c3235c6715d", size = 561277, upload-time = "2026-10-09T19:57:20.34Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ee/86/032133892a5de43b5a98200b01aadcad68cc255e274a762f08b8a76d2912/filelock-4.1.0-py3-none-any.whl", hash = "sha256:2ce9818e3e2d8f284c1a964414447ef148d42a5fd5e2a477a7118e574b293ec1", size = 133003, upload-time = "2026-10-09T19:57:18.716Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "4.2.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7d/64/a02e6765de08964ed371eca577870593245afc9dfac16d037de7c10d18e6/filelock-3.32.3.tar.gz", hash = "sha256:0ffa185a3540854c95caa7fa76b76cb219d907415e2c5dc9af25fd970563487f", size = 218135, upload-time = "2026-08-13T16:00:05.577Z" }
+resolution-markers = [
+    "python_full_version >= '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.14' and sys_platform != 'win32'",
+    "python_full_version == '3.13.*'",
+    "python_full_version == '3.12.*' and sys_platform == 'win32'",
+    "python_full_version == '3.12.*' and sys_platform != 'win32'",
+    "python_full_version == '3.11.*' and sys_platform == 'win32'",
+    "python_full_version == '3.11.*' and sys_platform != 'win32'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d8/28/3893324bcadf8f89b1616637468d766af3f625008c0735bf704fdfa86617/filelock-4.2.4.tar.gz", hash = "sha256:c6d8663535e1650ee430507b4ffbac7b464dd64b7647ea0112a9f406499d163d", size = 652444, upload-time = "2026-10-19T01:57:51.001Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a7/8e/50f46a9c0ce8d2861a394c1347caae037ea0431d2f67d7feb151cbc4649a/filelock-3.32.3-py3-none-any.whl", hash = "sha256:7f0ca4bcc0e181c60dbbd8aa9ab5b120ebb99e4e064e83636340056f833a1f09", size = 98901, upload-time = "2026-08-13T16:00:03.974Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/1b/5e74289a1878e666bb4b65fe5805a04cafcac2aa5f519ef1ead67ef91c56/filelock-4.2.4-py3-none-any.whl", hash = "sha256:301241438c57936ef93f4243a94f2559022268bfcf9b375a9a72eb0f8db8358e", size = 162475, upload-time = "2026-10-19T01:57:49.419Z" },
 ]
 
 [[package]]
@@ -1679,7 +1701,8 @@ version = "1.28.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "click" },
-    { name = "filelock" },
+    { name = "filelock", version = "4.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "filelock", version = "4.2.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "fsspec" },
     { name = "hf-xet", marker = "platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" },
     { name = "httpx" },
@@ -4967,11 +4990,11 @@ wheels = [
 
 [[package]]
 name = "setuptools"
-version = "84.0.0"
+version = "84.2.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6d/44/f5da03a8ef95d369145c5bb53050e7877c9f3d312e128605fd9504829143/setuptools-84.0.0.tar.gz", hash = "sha256:f4695c21257f0d9b537ec2692c941d02ee143b7cc1276941349a546573b2ef73", size = 1168449, upload-time = "2026-08-08T18:27:58.365Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/70/b3/c19426f783614d625699a4b247faf628ea9ab1db228674491767b417f9e1/setuptools-84.2.1.tar.gz", hash = "sha256:3ff8b3b5492a0aa66960f4419365a86b84e013070d4313e4d4a6894f5d64d6bc", size = 1230289, upload-time = "2026-10-20T19:01:37.742Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/95/9c/c510029fc6ef33a6275cd2c5d3cecd6613dfd6aa401d57c54f1c18852ccf/setuptools-84.0.0-py3-none-any.whl", hash = "sha256:51a52592b3b99e102b609654876bd65f19f999935166d1352678931132b0c670", size = 818216, upload-time = "2026-08-08T18:27:56.719Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/55/6dc6d6bb953bdfc52519a0059592c52b6e3b8ad51cf8256dffceb55b0610/setuptools-84.2.1-py3-none-any.whl", hash = "sha256:ca140b45d5325a9478f880e351484f62fef15f336462e449ca0c03c873d589c2", size = 876263, upload-time = "2026-10-20T19:01:35.678Z" },
 ]
 
 [[package]]