failproofai 1.0.11 → 1.0.12-beta.1

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

@@ -13,7 +13,7 @@ import json as _json
 import math
 import re
 from datetime import datetime, timezone
-from typing import Any, List, Optional, Sequence
+from typing import Any, Dict, List, Optional, Sequence
 
 import typer
 from rich.box import ROUNDED, SIMPLE_HEAD
@@ -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 diff history rollback rename"),
+        ("fleet", "Deploy policies to machines.", "list show deploy jev-mode diff history rollback rename"),
         ("guardrails", "What enforcement actually blocked.", "summary timeline"),
     ]),
     ("MANAGE", [
@@ -5918,6 +5918,10 @@ def _policy_cell(ref: Any) -> Text:
     return t
 
 
+#: A policy version's kind, as `fp policies list` colours it.
+_KIND_STYLE = {"regex": theme.TEXT_DIM, "jev": theme.ACCENT, "both": theme.AMBER}
+
+
 def render_policies(items: Sequence[Any]) -> None:
     """``fp policies`` — every published VERSION, newest of each policy first.
 
@@ -5938,11 +5942,25 @@ def render_policies(items: Sequence[Any]) -> None:
             state = Text("archived", style=theme.FAINT)
         elif p.disabled:
             state = Text("disabled", style=theme.AMBER)
+        kind = getattr(p, "kind", None) or "regex"
+        names = list(getattr(p, "jev_names", None) or [])
+        desc = Text()
+        if names:
+            # The checks first: for a `jev` policy they ARE the policy, and a
+            # long description would otherwise push them off the ellipsis.
+            desc.append(", ".join(names), style=theme.ACCENT)
+            chars = getattr(p, "jev_chars", None)
+            if chars is not None:
+                desc.append(f"  {chars:,} chars", style=theme.LABEL)
+            if p.description:
+                desc.append("  ·  ", style=theme.FAINT)
+        desc.append(p.description or "", style=theme.TEXT_DIM)
         rows.append([
             Text(p.id, style=theme.TEXT),
             Text(f"v{p.version}", style=theme.TEXT_DIM),
+            Text(kind, style=_KIND_STYLE.get(kind, theme.TEXT_DIM)),
             state,
-            Text(p.description or "", style=theme.TEXT_DIM),
+            desc,
         ])
     distinct = len({p.id for p in items})
     title = Text()
@@ -5952,7 +5970,7 @@ def render_policies(items: Sequence[Any]) -> None:
     if len(rows) != distinct:
         title.append(" · ", style=theme.FAINT)
         title.append(f"{len(rows)} versions", style=theme.LABEL)
-    render_list_panel("policies", header=["policy", "version", "state", "description"],
+    render_list_panel("policies", header=["policy", "version", "kind", "state", "description"],
                       rows=rows, days=set(), order=None,
                       empty_message="no policies published — `fp policies publish <id> <file>`",
                       last_col="ellipsis", title=title)
@@ -5974,17 +5992,41 @@ def render_policy_published(p: Any, *, carriers: Optional[dict] = None,
     """
     line1 = Text(p.id, style=f"bold {theme.TEXT}")
     line1.append(f"  v{p.version}", style=f"bold {theme.ACCENT}")
+    kind = getattr(p, "kind", None) or "regex"
+    line1.append(f"  {kind}", style=_KIND_STYLE.get(kind, theme.TEXT_DIM))
     body = [line1]
     if p.description:
         body.append(Text(p.description, style=theme.TEXT))
+    names = list(getattr(p, "jev_names", None) or [])
+    if names:
+        checks = Text("jev checks  ", style=theme.LABEL)
+        checks.append(", ".join(names), style=theme.ACCENT)
+        chars = getattr(p, "jev_chars", None)
+        if chars is not None:
+            # What these checks take of the ONE Jev question budget a machine
+            # has for every check it asks — Cloud's and its installed packs'.
+            checks.append("  ·  ", style=theme.FAINT)
+            checks.append(f"{chars:,} question chars", style=theme.LABEL)
+        body.append(checks)
+    if kind == "both":
+        # Derived by the server from the kind, never sent: said so the author
+        # knows what the JavaScript's verdict now is.
+        body.append(Text("its JavaScript is reviewable by exactly these checks", style=theme.LABEL))
     body.append(Text())
 
     meta = Text()
     if source_bytes:
         meta.append(f"{source_bytes:,} bytes", style=theme.LABEL)
         meta.append("  ·  ", style=theme.FAINT)
-    meta.append("sha256 ", style=theme.LABEL)
-    meta.append((p.sha256 or "")[:12] + "…", style=theme.TEXT_DIM)
+    if p.sha256:
+        meta.append("sha256 ", style=theme.LABEL)
+        meta.append((p.sha256 or "")[:12] + "…", style=theme.TEXT_DIM)
+    semantic_sha = getattr(p, "semantic_sha256", None)
+    if semantic_sha:
+        if p.sha256:
+            meta.append("  ·  ", style=theme.FAINT)
+        meta.append("jev sha256 ", style=theme.LABEL)
+        meta.append(semantic_sha[:12] + "…", style=theme.TEXT_DIM)
     body.append(meta)
     body.append(Text())
 
@@ -6053,8 +6095,7 @@ def render_fleet(machines: Sequence[Any]) -> None:
             Text(seen or "never", style=theme.FAINT if stale else theme.TEXT_DIM),
             Text(f"{m.event_count:,}" if m.event_count else "—",
                  style=theme.TEXT_DIM if m.event_count else theme.FAINT),
-            Text("drifted" if m.drifted else ("ok" if m.deployed else "—"),
-                 style=theme.AMBER if m.drifted else (theme.SUCCESS if m.deployed else theme.FAINT)),
+            _machine_state(m),
         ])
     title = Text()
     title.append("fleet", style=f"bold {theme.ACCENT}")
@@ -6067,6 +6108,18 @@ def render_fleet(machines: Sequence[Any]) -> None:
                       empty_message="no machines have checked in yet", title=title)
 
 
+def _machine_state(m: Any) -> Text:
+    """`fp fleet list`'s state cell. Reported policy errors outrank drift: a
+    machine that says it cannot apply part of its set is not enforcing it,
+    whichever generation it is on."""
+    errors = getattr(m, "policy_errors", None) or []
+    if errors:
+        n = len(errors)
+        return Text(f"{n} error{'s' if n != 1 else ''}", style=theme.ERROR)
+    return Text("drifted" if m.drifted else ("ok" if m.deployed else "—"),
+                style=theme.AMBER if m.drifted else (theme.SUCCESS if m.deployed else theme.FAINT))
+
+
 def _compact_age(ms: Optional[int]) -> str:
     """`5h`, `7d`, `just now` — the column form of `_epoch_age`.
 
@@ -6097,7 +6150,33 @@ def _epoch_age(ms: Optional[int]) -> str:
     return _relative_age(datetime.fromtimestamp(ms / 1000, tz=timezone.utc).isoformat())
 
 
-def render_machine_policies(machine_id: str, dep: Any, machine: Any = None) -> None:
+def _agent_target_label(targets: Any, labels: Optional[Dict[str, str]] = None,
+                        *, with_id: bool = False) -> str:
+    """One assignment's scope, unscoped only when the field is absent.
+
+    ``labels`` maps an exact profile's ``agt_…`` id to the profile label the
+    machine reported (`.claude-work`), so the target reads as the profile a
+    person recognises. ``with_id`` keeps the id beside it, for the views a
+    selector is copied from. An id with no label stays the bare id.
+    """
+    if not targets:
+        return "all agents"
+    labels = labels or {}
+
+    def one(target: Dict[str, Any]) -> str:
+        instance = target.get("instanceId")
+        if not instance:
+            return f"all {target['integration']}"
+        name = labels.get(instance)
+        if not name:
+            return f"{target['integration']}/{instance}"
+        return f"{target['integration']}/{name}" + (f" ({instance})" if with_id else "")
+
+    return ", ".join(one(target) for target in targets)
+
+
+def render_machine_policies(machine_id: str, dep: Any, machine: Any = None,
+                            agent_labels: Optional[Dict[str, str]] = None) -> None:
     """``fp fleet show`` — what a machine is told to run, and whether it has it.
 
     The first version printed the id, the generation and the policy list, which
@@ -6148,6 +6227,27 @@ def render_machine_policies(machine_id: str, dep: Any, machine: Any = None) -> N
             act.append(f"  ·  {machine.event_count} events", style=theme.LABEL)
         field("last seen", act)
 
+    mode = (getattr(dep, "jev_mode", None) if dep is not None else None) or (
+        getattr(machine, "jev_mode", None) if machine is not None else None
+    )
+    jev = Text(mode or "local", style=theme.ACCENT if mode else theme.TEXT_DIM)
+    jev.append("  ·  set by FailproofAI Cloud" if mode else "  ·  the machine's own", style=theme.LABEL)
+    field("jev mode", jev)
+
+    errors = (getattr(machine, "policy_errors", None) or []) if machine is not None else []
+    if errors:
+        body.append(Text())
+        head = Text(f"{len(errors)} policy error{'s' if len(errors) != 1 else ''}", style=f"bold {theme.ERROR}")
+        head.append("  ·  reported by the machine — these are not enforcing", style=theme.LABEL)
+        body.append(head)
+        for e in errors:
+            line = Text("  ")
+            ver = e.get("version")
+            line.append(f"{e.get('id', '?')}{f' v{ver}' if ver is not None else ''}", style=theme.TEXT)
+            line.append(f"  {e.get('kind', '')}", style=theme.FAINT)
+            line.append(f"  {e.get('message', '')}", style=theme.TEXT_DIM)
+            body.append(line)
+
     body.append(Text())
     pols = sorted(dep.policies, key=lambda x: x.id) if dep is not None else []
     if pols:
@@ -6156,13 +6256,15 @@ def render_machine_policies(machine_id: str, dep: Any, machine: Any = None) -> N
         # padded to the header's width — otherwise the effect column steps left
         # by one on every row and the table reads as misaligned.
         vwidth = max(3, max(len(f"v{p.version}") for p in pols))
-        head = Text(f"  {'policy'.ljust(width)}   {'ver'.ljust(vwidth)}  effect", style=theme.LABEL)
+        head = Text(f"  {'policy'.ljust(width)}   {'ver'.ljust(vwidth)}  effect    agents", style=theme.LABEL)
         body.append(head)
         for p in pols:
             row = Text("  ")
             row.append(p.id.ljust(width), style=theme.TEXT)
             row.append(f"   {f'v{p.version}'.ljust(vwidth)}  ", style=theme.TEXT_DIM)
             row.append_text(_effect(p.effect))
+            row.append("    " + _agent_target_label(getattr(p, "agent_targets", None), agent_labels,
+                                                    with_id=True), style=theme.TEXT_DIM)
             body.append(row)
     else:
         body.append(Text("  no policies deployed", style=theme.FAINT))
@@ -6183,18 +6285,24 @@ def render_deploy_plan(plan: Any, *, applied: bool = False) -> None:
     lines = []
     for p in plan.added:
         t = Text("  + ", style=theme.SUCCESS); t.append_text(_policy_cell(p))
-        t.append("  "); t.append_text(_effect(p.effect)); lines.append(t)
+        t.append("  "); t.append_text(_effect(p.effect))
+        t.append("  " + _agent_target_label(getattr(p, "agent_targets", None)), style=theme.TEXT_DIM)
+        lines.append(t)
     for was, now in plan.changed:
         t = Text("  ~ ", style=theme.AMBER); t.append_text(_policy_cell(now))
         t.append("  "); t.append_text(_effect(now.effect))
-        t.append(f"   (was v{was.version} {was.effect})", style=theme.FAINT); lines.append(t)
+        t.append("  " + _agent_target_label(getattr(now, "agent_targets", None)), style=theme.TEXT_DIM)
+        t.append(f"   (was v{was.version} {was.effect}; {_agent_target_label(getattr(was, 'agent_targets', None))})", style=theme.FAINT)
+        lines.append(t)
     for p in plan.removed:
         t = Text("  - ", style=theme.ERROR)
         t.append(p.id, style=theme.TEXT_DIM); t.append(f" v{p.version}", style=theme.FAINT)
         lines.append(t)
     for p in plan.unchanged:
         t = Text("  = ", style=theme.FAINT); t.append_text(_policy_cell(p))
-        t.append("  "); t.append_text(_effect(p.effect)); lines.append(t)
+        t.append("  "); t.append_text(_effect(p.effect))
+        t.append("  " + _agent_target_label(getattr(p, "agent_targets", None)), style=theme.TEXT_DIM)
+        lines.append(t)
     if not lines:
         lines = [Text("  (no policies)", style=theme.FAINT)]
 
@@ -6204,6 +6312,16 @@ 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:
@@ -6333,7 +6451,18 @@ def deployment_applied(machine_id: str, generation: int, count: int) -> None:
     _notice_box(body, color=theme.SUCCESS, title="deployed")
 
 
-def deployment_rolled_back(machine_id: str, restored: int, generation: int) -> None:
+def deployment_rolled_back(
+    machine_id: str,
+    restored: int,
+    generation: int,
+    *,
+    jev_from: Optional[str] = None,
+    jev_to: Optional[str] = None,
+) -> None:
+    """``✓ restored the set from #R on <machine> · minted as #G``, plus the Jev
+    mode the rollback brought back when it changed — a rollback restores the
+    generation's mode too, and saying nothing is how `off` silently became
+    `enforce` again."""
     body = Text()
     body.append("✓ ", style=theme.SUCCESS)
     body.append("restored the set from ", style=theme.TEXT)
@@ -6342,9 +6471,76 @@ def deployment_rolled_back(machine_id: str, restored: int, generation: int) -> N
     body.append(machine_id, style=theme.ACCENT)
     body.append("  ·  ", style=theme.FAINT)
     body.append(f"minted as deployment #{generation}", style=theme.LABEL)
+    if jev_from is not None and jev_to is not None:
+        body.append("  ·  ", style=theme.FAINT)
+        if jev_from != jev_to:
+            body.append("jev mode ", style=theme.LABEL)
+            body.append(f"{jev_from} → ", style=theme.FAINT)
+            body.append(jev_to, style=f"bold {theme.AMBER}")
+        else:
+            body.append(f"jev mode {jev_to} (unchanged)", style=theme.LABEL)
     _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)
@@ -6581,7 +6777,8 @@ def policy_published_brief(p: Any) -> None:
     _notice_box(body, color=theme.SUCCESS, title="published")
 
 
-def render_deployment_history(machine_id: str, entries: Sequence[dict]) -> None:
+def render_deployment_history(machine_id: str, entries: Sequence[dict],
+                              agent_labels: Optional[Dict[str, str]] = None) -> None:
     """``fp fleet history`` — one row per generation, newest first.
 
     Was a bare `print` per line, which put an unaligned wall of timestamps and
@@ -6595,6 +6792,7 @@ def render_deployment_history(machine_id: str, entries: Sequence[dict]) -> None:
     """
     rows = []
     prev = None
+    prev_mode = "local"
     # oldest first so each row can be diffed against the one before it, then
     # reversed for display — newest first is how you read a history.
     ordered = sorted(entries, key=lambda e: e.get("deployment") or 0)
@@ -6605,17 +6803,28 @@ def render_deployment_history(machine_id: str, entries: Sequence[dict]) -> None:
         # that STOPPED BLOCKING, and it rendered as "no change". It also split a
         # version bump into a "+x" and a "-x" for the same policy, which reads
         # as removed-and-re-added rather than moved.
-        cur = {p.get("id"): (p.get("version"), p.get("effect"))
+        cur = {p.get("id"): (p.get("version"), p.get("effect"),
+                            tuple(sorted(
+                                (t.get("integration") or "", t.get("instanceId") or "")
+                                for t in (p.get("agentTargets") or [])
+                            )))
                for p in (e.get("policies") or [])}
+        scope = {p.get("id"): _agent_target_label(p.get("agentTargets"), agent_labels)
+                 for p in (e.get("policies") or [])}
+        mode = e.get("jevMode") or "local"
         if prev is None:
-            diffs[e.get("deployment")] = [("+", i) for i in sorted(cur)]
+            diffs[e.get("deployment")] = [("+", f"{i} → {scope[i]}") for i in sorted(cur)]
         else:
             diffs[e.get("deployment")] = (
-                [("+", i) for i in sorted(set(cur) - set(prev))]
+                [("+", f"{i} → {scope[i]}") for i in sorted(set(cur) - set(prev))]
                 + [("-", i) for i in sorted(set(prev) - set(cur))]
-                + [("~", i) for i in sorted(set(cur) & set(prev)) if cur[i] != prev[i]]
+                + [("~", 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
+                # change", which is exactly the change a rollback brings back.
+                + ([("~", f"jev {prev_mode}→{mode}")] if mode != prev_mode else [])
             )
         prev = cur
+        prev_mode = mode
 
     newest_first = sorted(entries, key=lambda e: e.get("deployment") or 0, reverse=True)
     # The shared time column: clock time, with the date folded in only when the
@@ -6636,10 +6845,14 @@ def render_deployment_history(machine_id: str, entries: Sequence[dict]) -> None:
             change.append(ref, style=theme.TEXT_DIM)
         if not change.plain:
             change = Text("no change", style=theme.FAINT)
+        mode = e.get("jevMode") or "local"
         rows.append([
             Text(f"#{gen}", style=theme.TEXT),
             Text(tcell or (e.get("updatedAt", "") or "-"), style=theme.TEXT_DIM),
             Text(str(len(pols)), style=theme.TEXT_DIM if pols else theme.FAINT),
+            # The mode FailproofAI Cloud set with this generation — what a
+            # rollback to it restores.
+            Text(mode, style=theme.FAINT if mode == "local" else theme.TEXT),
             change,
             Text(", ".join(pols) or "(none)", style=theme.TEXT_DIM if pols else theme.FAINT),
         ])
@@ -6647,9 +6860,34 @@ def render_deployment_history(machine_id: str, entries: Sequence[dict]) -> None:
     title.append(machine_id, style=f"bold {theme.ACCENT}")
     title.append(" · ", style=theme.FAINT)
     title.append(f"{len(rows)} generations", style=theme.LABEL)
-    render_list_panel("history", header=["gen", "when", "n", "change", "policies"],
+    header = ["gen", "when", "n", "jev", "change", "policies"]
+    # Fit the panel to the terminal by giving up the expendable columns first.
+    # Every cell is no_wrap, so a table wider than the terminal had Rich shave
+    # ALL columns at once — and at 80 columns `gen`, `when` and `jev` were the
+    # ones that vanished, though `gen` is the argument `fp fleet rollback` takes.
+    # `policies` goes first (`n` still counts it, `change` says what moved),
+    # then `change` wraps rather than squeezing the four short columns.
+    last_col, last_col_max = "ellipsis", None
+    if rows:
+        def natural(i: int) -> int:
+            return max([len(header[i])] + [r[i].cell_len for r in rows])
+        # indent 2 + border 2 + panel padding 2, two spaces between columns,
+        # and a little slack for Rich's rounding.
+        chrome = 6 + 2
+        fixed = sum(natural(i) for i in range(4)) + 2 * 4 + chrome
+        room = _stdout.width - fixed
+        change_w, policies_w = natural(4), natural(5)
+        if change_w + 2 + policies_w > room:
+            if room - change_w - 2 >= 12:
+                last_col_max = room - change_w - 2
+            else:
+                header = header[:5]
+                rows = [r[:5] for r in rows]
+                last_col = "wrap"
+    render_list_panel("history", header=header,
                       rows=rows, days=days, order=None,
-                      empty_message="no deployment history", last_col="ellipsis", title=title)
+                      empty_message="no deployment history", last_col=last_col,
+                      last_col_max=last_col_max, title=title)
 
 
 def render_fleet_diff(rows: Sequence[dict]) -> None:

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

@@ -446,14 +446,17 @@ def cloud_publish_problem(source: str) -> Optional[str]:
     if not source or len(source) > _MAX_SCAN:
         return None
     if _find_call(source, _SEMANTIC_CALL) != -1:
-        return ("semanticPolicies.add does nothing in a cloud policy: Jev reads semantic checks only "
-                "from a failproofai pack. Remove it to publish the rest, or ship the file with "
-                "`failproofai publish`.")
+        return ("semanticPolicies.add does nothing in a cloud policy's JavaScript: Jev reads semantic "
+                "checks only from a failproofai pack or from the policy's own Jev declarations. Put the "
+                "check in a JSON file and publish with `--kind both --semantic checks.json` (or `--kind "
+                "jev`), or ship the file with `failproofai publish`.")
     # Every registration: any of them can carry a reviewable declaration.
     at = _find_call(source, _ADD_CALL)
     while at != -1:
         if _direct_props(source, at).get("authority") == "reviewable":
-            return ("a cloud policy is always hard, so Jev never clears it and authority/reviewedBy "
-                    "are ignored. Remove them to publish it as a hard policy.")
+            return ("a cloud policy's JavaScript is always hard as written: its authority comes from "
+                    "its kind, never from the source, so authority/reviewedBy here are ignored. Remove "
+                    "them, and publish with `--kind both --semantic checks.json` to make it reviewable "
+                    "by its own Jev checks.")
         at = _find_call(source, _ADD_CALL, at + len(_ADD))
     return None

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

@@ -196,8 +196,8 @@ you need a flag you don't already know.
 - `audits list|show|create|edit|delete|run|runs` — scheduled sweeps, referenced by **name**; `audits findings|finding` + the triage verbs `ack|mute|dismiss|resolve|reopen|assign` act on a finding **id**. `audits run <name>` only *queues* a run (poll `audits runs <name>` for completion). See §8.
 
 **Enforce (cloud-managed policy, session-only — see §2):**
-- `policies list|show|publish|enable|disable|delete|test|compose` — policy versions. `publish` mints a version from a local `.mjs`; `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|diff|history|rollback|rename` — which machines run which policies. **`deploy` REPLACES a machine's whole set** (`--add`/`--remove` amend it, `--set` replaces, `--create` mints a deployment); 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.
+- `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.
 - `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

@@ -220,22 +220,29 @@ Built-in assistant. Chats referenced by a **short chat-id** (first 8 hex; prefix
 Cloud-managed enforcement, split the way the dashboard splits it: `policies` writes a version, `fleet` decides which machines run it, `guardrails` reports what it blocked. Needs `policies:read` to read, `policies:write` to change anything.
 
 ### policies
-- `policies list` — one row per published VERSION (versions are immutable and all stay addressable), newest of each policy first; the title counts distinct policies and captions the version total. `state` is active / disabled / archived. JSON `{policies:[…]}` — also every version, so deduplicate on `id` for one row per policy.
-- `policies show <id>` — the NEWEST version, including the full `source`.
-- `policies publish <id> [SOURCE] [--description "…"] [--no-verify]` — mints a **new version**; never edits one. SOURCE is a path, `@path`, `-`, a pipe, or omitted to paste on a TTY (Ctrl-D ends). The source is **parse-checked with node** before it is sent; nothing downstream does this, and a broken policy otherwise fails on the machine at enforcement time. `--no-verify` skips it, and a host without node publishes with a warning rather than a block. A source with Jev fields a cloud policy never reads — `semanticPolicies.add(...)`, or `authority: "reviewable"` on a registration — is refused before sending (**exit 1**, not skipped by `--no-verify`; commented-out code does not count): Jev checks ship in a pack via `failproofai publish`. **Publishing deploys nothing** — the version is unused until `fleet deploy` puts it on a machine.
+- `policies list` — one row per published VERSION (versions are immutable and all stay addressable), newest of each policy first; the title counts distinct policies and captions the version total. `kind` is `regex` / `jev` / `both`, and a `jev`/`both` row names its Jev checks before the description. `state` is active / disabled / archived. JSON `{policies:[…]}` — also every version, so deduplicate on `id` for one row per policy; each carries `kind`, and for `jev`/`both` `semantic`, `semanticSha256`, and the server-derived `authority`/`reviewedBy`.
+- `policies show <id>` — the NEWEST version: its kind, its Jev check names, the full `source`, and the Jev declarations.
+- `policies publish <id> [SOURCE] [--kind regex|jev|both] [--source FILE] [--semantic FILE] [--description "…"] [--no-verify]` — mints a **new version**; never edits one. A policy's **kind** says what it carries:
+  - `regex` — JavaScript only (SOURCE or `--source`): what publish has always done, and the default.
+  - `jev` — Jev checks only (`--semantic checks.json`, no JavaScript): a JSON array (or `{"semantic": [...]}`) of 1–24 Jev declarations, each exactly a failproofai pack manifest's semantic entry — `{name, title, appliesTo:[shell|write|read|network|other], mode:deny|instruct, userCanOverride, probes:[{id, instructions, criteria:{true,false}}] (≤6), guidance, precondition?, exempt?}`.
+  - `both` — JavaScript plus its own Jev checks, deployed and toggled as one. FailproofAI Cloud makes the JavaScript's verdict `reviewable` by exactly its own checks (`authority`/`reviewedBy` are derived by the server, never sent).
+
+  Without `--kind` it follows from what you give (`--semantic` alone is `jev`, with source `both`); a kind that contradicts its inputs is **exit 2**, before anything is sent. `fp` checks only the shape of the file (a non-empty list of named objects, ≤24); the server checks the rest — the limits, FailproofAI's 16 reserved check names (**422 `reserved_jev_name`**), and names unique across the org — and names the declaration it refused. SOURCE is a path, `@path`, `-`, a pipe, or omitted to paste on a TTY (Ctrl-D ends); `--semantic` takes a path, `@path` or `-` (only one of the two may be stdin). The JavaScript is **parse-checked with node** before it is sent; nothing downstream does this, and a broken policy otherwise fails on the machine at enforcement time. `--no-verify` skips it, and a host without node publishes with a warning rather than a block. JavaScript carrying Jev fields — `semanticPolicies.add(...)`, or `authority: "reviewable"` on a registration — is refused before sending (**exit 1**, not skipped by `--no-verify`; commented-out code does not count): put Jev checks in `--semantic` (`--kind both`), where they take effect. **Publishing deploys nothing** — the version is unused until `fleet deploy` puts it on a machine.
 - `policies enable <id>` · `policies disable <id> [-y]` — **disable REMOVES the policy from every deployment carrying it**, reissuing each affected machine at a new generation (visible in `fleet history`). `enable` is the exact inverse — it puts the policy back into every deployment it was removed from, reissuing those machines again. Nothing needs redeploying by hand, and `machinesUpdated` in the JSON reports the count for both directions.
 - `policies test [SOURCE] [--tool Bash] [--command "…"] [--file PATH] [--event PreToolUse] [--expect allow|deny|instruct]` — run a policy LOCALLY and print what it decides. Executes the real file (bare `import { deny } from "failproofai"` and all) against a synthetic context; nothing is published, nothing installed. Needs `node`. `--expect` asserts the decision and exits 1 when it differs — a correct `deny` is a PASSING test, so the decision alone never sets the exit code. JSON `{ok, decision, policies:[{name,decision,reason}], expected, met}`; `decision` is the strictest any registered policy returned.
 - `policies compose "<description>" [--out FILE] [--publish ID]` — the assistant drafts policy source from plain English. Prints it and stops by default: a generated policy that deploys itself is one nobody read. `--publish` still syntax-checks first. Needs `policies:write` for BOTH the draft and the publish — `POST /api/agent/compose-policy` is `withAuth("policies:write")`; `agent:use` gates the assistant's other routes and is not checked on this one. The composer has a **30s server-side limit** — a long or vague description simply does not finish, and raising `--timeout` does not help because the cut is not client-side. Retry with something shorter and more specific.
 - `policies delete <id> [-y]` — archives. **A machine already carrying the policy keeps enforcing it** until redeployed; `disable` is what stops enforcement everywhere.
 
 ### 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. JSON `{machines, deployments}` with raw epoch-ms timestamps plus the computed `drifted`.
-- `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. 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]`
+- `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]`
 
   **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.
+  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.
+
+  `--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`.
 
   Deploying to an id that has never checked in is refused (a typo would mint a machine); `--create` allows it for pre-staging.
 
@@ -245,9 +252,10 @@ 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}, deployment, applied}` — the plan is included so a harness does not recompute the diff.
+  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?}]}`.
 - `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").
+- `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 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