failproofai 1.0.11 → 1.0.12-beta.1

package/.next/standalone/fp-cloud-cli/fp_cli/commands/fleet_cmds.py

@@ -1,4 +1,4 @@
-"""The fleet: fleet list / show / deploy / diff / history / rollback / rename.
+"""The fleet: fleet list / show / deploy / jev-mode / diff / history / rollback / rename.
 
 What each machine is TOLD to enforce. Authoring the policies is `fp policies`;
 what they actually did is `fp guardrails`.
@@ -26,14 +26,18 @@ from .. import output
 from .._context import GLOBALS_EPILOG, AppState, deny_in_key_mode, require_auth
 from .. import _click_compat as click  # the Click Typer is running; see _click_compat
 from ..enforcement import (
+    JEV_MODES,
     RefError,
     RefUsageError,
     check_race,
     disabled_ids,
+    jev_mode_after,
     latest_versions,
     plan_deploy,
+    version_kinds,
 )
-from ..errors import ApiError, NotFoundError
+from ..errors import ApiError, AuthError, FpCliError, NotFoundError
+from ..models import PolicyRef
 from . import _write
 
 _KEY_MODE_REASON = (
@@ -62,6 +66,8 @@ def fleet_list(ctx: typer.Context) -> None:
     `intended` is the generation deployed, `applied` is the one the machine last
     collected, and `seen` is when it last reported anything — a machine can be
     in sync and dead, or alive and behind, and those are different problems.
+    `state` reads `N errors` when the machine reported policies it could not
+    apply (`fp fleet show <machine>` lists them).
 
     A machine appears from its very first check-in, including the poll that
     finds nothing deployed — that is exactly the machine you are usually looking
@@ -101,10 +107,22 @@ def fleet_show(
     machine can be told to run a policy and not yet have it; the policy list
     alone cannot tell you which, and that is usually the question.
 
+    Shows the Jev mode FailproofAI Cloud sets on the machine (`local` when it
+    sets none) and the policy errors the machine last reported: a policy it
+    could not load, a Jev mode it cannot act on (`jev_unconfigured`: its key
+    does not carry Jev; `transcripts_disabled`: it was connected with
+    `--no-transcripts`), FailproofAI Cloud Jev refusing or failing its calls
+    (`jev_rate_limited`: over the organization's Jev rate limit;
+    `jev_unavailable`: it skips a failing Cloud Jev for a minute at a time), an
+    installed pack's check left out for the question budget (`jev_budget`) or
+    because an organization Cloud check has its name (`jev_name_clash`).
+    Anything listed there is not enforcing, whatever the deployment says.
+
     Needs `policies:read`. With `--json`: `{machine, deployment}` — the machine
-    record (including `appliedDeployment`, `drifted`, `lastSeen` and both label
-    fields, with raw timestamps) and the deployment, or `deployment: null` when
-    nothing is deployed.
+    record (including `appliedDeployment`, `drifted`, `lastSeen`, both label
+    fields, `jevMode` and `policyErrors`/`policyErrorsAt` when reported, with raw
+    timestamps) and the deployment, or `deployment: null` when nothing is
+    deployed.
 
     Example:
 
@@ -129,7 +147,8 @@ def fleet_show(
             "deployment": dep.to_dict() if dep else None,
         })
         return
-    output.render_machine_policies(machine_id, dep, machine)
+    output.render_machine_policies(machine_id, dep, machine,
+                                   agent_labels=api.agent_labels(cctx, machine_id))
 
 
 def fleet_deploy(
@@ -137,17 +156,34 @@ def fleet_deploy(
     machine_id: str = typer.Argument(..., help="Machine id."),
     add: Optional[List[str]] = typer.Option(
         None, "--add",
-        help="Add or update a policy: `id`, `id@version`, `id:effect` or `id@version:effect`.",
+        help="Add or update a policy: `id`, `id@version`, `id:effect` or `id@version:effect`. "
+             "`observe` on a `both` policy observes its JavaScript and withholds its Jev checks.",
     ),
     remove: Optional[List[str]] = typer.Option(None, "--remove", help="Remove a policy by id."),
     replace: Optional[List[str]] = typer.Option(
         None, "--set",
         help="REPLACE the whole set with exactly these. Cannot be combined with --add/--remove.",
     ),
+    targets: Optional[List[str]] = typer.Option(
+        None, "--target",
+        help="Scope one assigned policy: POLICY=INTEGRATION or POLICY=INTEGRATION/agt_ID. Repeat to OR selectors.",
+    ),
+    all_agents: Optional[List[str]] = typer.Option(
+        None, "--all-agents",
+        help="Clear one policy's targeting back to every agent on this machine.",
+    ),
     create: bool = typer.Option(
         False, "--create",
         help="Allow deploying to a machine id that has not checked in yet (pre-staging).",
     ),
+    jev_mode: Optional[str] = typer.Option(
+        None, "--jev-mode",
+        help="Set the machine's Jev mode from FailproofAI Cloud: off, observe, enforce (Jev's "
+             "checks BLOCK calls as well as clearing what they review) — or local to stop "
+             "overriding the machine's own. Jev checks run on FailproofAI Cloud; nothing is "
+             "installed on the machine. Machine-wide: installed packs' checks too. "
+             "Omitted: unchanged.",
+    ),
     yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt. The prompt only appears on an interactive terminal: under --json, or with stdin redirected, this command proceeds without asking."),
 ) -> None:
     """Change what a machine enforces, showing the full resulting set first.
@@ -159,6 +195,24 @@ def fleet_deploy(
 
     `--set` replaces everything — the only way to drop policies you do not name.
 
+    Any kind deploys the same way. Jev checks run on FailproofAI Cloud; nothing
+    is installed on the machine: a `both` policy sends the machine its
+    JavaScript, and the machine asks FailproofAI Cloud about each checked tool
+    call while its Jev mode is `observe` or `enforce`. An effect applies to
+    JavaScript only — an `observe` `both` policy observes its JavaScript and its
+    Jev checks are not asked — and a `jev` policy is watched through the Jev
+    MODE instead: `--jev-mode observe` asks Jev and logs what it says 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 on the machine; `local` hands the choice back to the machine. The
+    mode is the MACHINE's: it also governs the checks of any pack installed
+    there, and it overrides the machine's own mode and `jev.json`, a local
+    `off` included. Without `--jev-mode` it is left as it is.
+
+    `--jev-mode` with no change to the set changes ONLY the mode (the same as
+    `fp fleet jev-mode`): the policy set — disabled policies' assignments
+    included — is not read back and rewritten.
+
     **Concurrency.** The write is a full replace with no server-side lock, so the
     CLI records the generation it read and refuses if the result is not exactly
     one higher: that means somebody else deployed in between and a replace does
@@ -170,17 +224,19 @@ def fleet_deploy(
     * `fp fleet deploy ci-runner-01 --add no-force-push`
     * `fp fleet deploy ci-runner-01 --add prod-guard@1:observe --remove old-rule`
     * `fp fleet deploy ci-runner-01 --set no-force-push --set no-secret-echo`
+    * `fp fleet deploy ci-runner-01 --add prod-db-intent --jev-mode observe`
+    * `fp fleet deploy ci-runner-01 --jev-mode local`
     """
     state: AppState = ctx.obj
     deny_in_key_mode(state, "fleet deploy", _KEY_MODE_REASON)
     cctx = require_auth(state)
 
-    if not add and not remove and replace is None:
+    if not add and not remove and replace is None and jev_mode is None and not targets and not all_agents:
         # Exit 2 for the same reason `--set` with `--add` is: no flag
         # combination was given that this command can act on. Both are the
         # caller's command line, not the server's answer.
         raise click.UsageError(
-            "nothing to do — pass --add, --remove, or --set. "
+            "nothing to do — pass --add, --remove, --set, --target, --all-agents, or --jev-mode. "
             "`fp fleet show <machine>` prints the current set."
         )
 
@@ -212,6 +268,11 @@ def fleet_deploy(
             replace=replace,
             latest=latest,
             disabled=disabled_ids(published),
+            jev_mode=jev_mode,
+            current_jev_mode=current.jev_mode if current else None,
+            kinds=version_kinds(published),
+            targets=targets or (),
+            all_agents=all_agents or (),
         )
     except RefUsageError as exc:
         # Exit 2, like every other bad flag value in this CLI (`--since`,
@@ -237,6 +298,16 @@ def fleet_deploy(
         output.deployment_unchanged(machine_id)
         return
 
+    # The mode alone: its own route, which never touches the policy set. A
+    # deploy is a full replace of the set the CLI read, and that set leaves out
+    # disabled policies' assignments — so a mode change sent as a deploy deleted
+    # them, and reverted anything changed since the read (CONTRACT C9.1). A
+    # machine with no deployment yet has nothing to lose and no mode to change:
+    # its first deploy, carrying the mode, is how it gets one.
+    if plan.jev_mode is not None and not plan.set_changes and current is not None:
+        _apply_jev_modes(state, cctx, [(machine_id, current.jev_mode)], plan.jev_mode, yes=yes, plan=plan)
+        return
+
     if not output.is_json():
         output.render_deploy_plan(plan)
     dropped = len(plan.removed)
@@ -252,7 +323,7 @@ def fleet_deploy(
             output.print_cancelled()
         return
 
-    result = api.deploy_policies(cctx, machine_id, plan.result)
+    result = api.deploy_policies(cctx, machine_id, plan.result, jev_mode=jev_mode)
     check_race(plan.base, result.deployment)
 
     if output.is_json():
@@ -265,6 +336,176 @@ def fleet_deploy(
     output.deployment_applied(machine_id, result.deployment, len(result.policies))
 
 
+def _jev_mode_consequence(mode: str, count: int) -> str:
+    what = f"{count} machine{'s' if count != 1 else ''}"
+    tail = {
+        "enforce": "; in enforce Jev's deny checks BLOCK calls, and it covers installed packs' checks too",
+        "observe": "; in observe Jev only records what it would have decided",
+        "off": "; Jev stops on them, a local jev.json included",
+        "local": "; each machine's own jev.json decides again",
+    }.get(mode, "")
+    return f"this sets the Jev mode to {mode} on {what} and leaves their policy sets untouched{tail}"
+
+
+def _apply_jev_modes(
+    state: AppState,
+    cctx,
+    targets: List[tuple],
+    mode: str,
+    *,
+    yes: bool,
+    plan=None,
+) -> None:
+    """Set `mode` on each `(machine_id, current_mode)`, through the mode-only route.
+
+    Shared by `fleet jev-mode` and `fleet deploy --jev-mode` with no set change.
+    A machine already on `mode` is left alone; one that fails is reported and
+    the rest still go ahead (exit 1 at the end, naming them).
+    """
+    after = jev_mode_after(mode)
+    rows = [
+        {"machineId": mid, "from": cur or "local", "to": after or "local", "changed": (cur or None) != after}
+        for mid, cur in targets
+    ]
+    todo = [r for r in rows if r["changed"]]
+    if not todo:
+        if output.is_json():
+            out = {"mode": mode, "machines": rows, "applied": False}
+            if plan is not None:
+                out = {"plan": plan.to_dict(), "deployment": None, "applied": False}
+            output.emit_json(out)
+            return
+        output.jev_mode_unchanged([r["machineId"] for r in rows], mode)
+        return
+
+    if not output.is_json():
+        output.render_jev_mode_plan(rows)
+    if not _write.confirm_destructive(
+        state, "change the Jev mode on",
+        todo[0]["machineId"] if len(todo) == 1 else f"{len(todo)} machines",
+        consequence=_jev_mode_consequence(mode, len(todo)),
+        assume_yes=yes,
+    ):
+        if output.is_json():
+            output.emit_json({"cancelled": True, "applied": False, "machines": rows})
+        else:
+            output.print_cancelled()
+        return
+
+    failed = []
+    last = None
+    for row in todo:
+        try:
+            result, changed = api.set_jev_mode(cctx, row["machineId"], mode)
+        except AuthError:
+            raise
+        except FpCliError as exc:
+            # One machine's refusal (a 404, a 403, a 422) is that machine's;
+            # the rest still go ahead, and the exit code says it was not all.
+            row["error"] = exc.format_message() if hasattr(exc, "format_message") else str(exc)
+            failed.append(row["machineId"])
+            continue
+        last = result
+        row["deployment"] = result.deployment
+        row["changed"] = changed
+
+    if output.is_json():
+        if plan is not None:
+            output.emit_json({
+                "plan": plan.to_dict(),
+                "deployment": last.to_dict() if last is not None else None,
+                "applied": last is not None,
+                "jevModeOnly": True,
+            })
+        else:
+            output.emit_json({"mode": mode, "machines": rows, "applied": not failed})
+    else:
+        output.jev_mode_applied(rows)
+    if failed:
+        raise ApiError(
+            f"the Jev mode could not be changed on {', '.join(failed)}"
+            + ("" if len(failed) == len(todo) else " — the other machines were changed"),
+        )
+
+
+def fleet_jev_mode(
+    ctx: typer.Context,
+    args: Optional[List[str]] = typer.Argument(
+        None, metavar="[MACHINE]... MODE",
+        help="The machines, then the mode: off, observe, enforce or local. With --all, just the mode.",
+    ),
+    all_machines: bool = typer.Option(
+        False, "--all", help="Every machine that has a deployment (machines with none are skipped).",
+    ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip the confirmation prompt. The prompt only appears on an interactive terminal: under --json, or with stdin redirected, this command proceeds without asking."),
+) -> None:
+    """Set the Jev mode FailproofAI Cloud gives machines, and nothing else.
+
+    `off`, `observe` or `enforce` override each machine's own mode and
+    `jev.json`, a local `off` included; `local` hands the choice back to the
+    machine. Jev checks run on FailproofAI Cloud; nothing is installed on the
+    machine: under `observe` or `enforce` it sends each checked tool call to
+    FailproofAI Cloud. `observe` asks Jev and records what it says 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. The
+    mode is the machine's: it also governs the checks of every pack installed
+    there. A machine connected with `--no-transcripts` never asks, and reports
+    `transcripts_disabled`.
+
+    Only the mode changes: each machine's policy set, disabled policies'
+    assignments included, is left exactly as it is, and a machine already on
+    the mode is skipped. Each change is a new generation in `fp fleet history`.
+    A machine with no deployment has no mode to change — `fp fleet deploy
+    <machine> --jev-mode <mode>` gives it its first deployment with one.
+
+    Needs `policies:write`. With `--json`: `{mode, applied, machines:[{machineId,
+    from, to, changed, deployment?, error?}]}`.
+
+    Examples:
+
+    * `fp fleet jev-mode ci-runner-01 observe`
+    * `fp fleet jev-mode ci-runner-01 ci-runner-02 enforce`
+    * `fp fleet jev-mode --all local`
+    """
+    state: AppState = ctx.obj
+    deny_in_key_mode(state, "fleet jev-mode", _KEY_MODE_REASON)
+    words = list(args or [])
+    if not words:
+        raise click.UsageError("pass the mode: off, observe, enforce or local")
+    mode, machine_ids = words[-1], list(dict.fromkeys(words[:-1]))
+    if mode not in JEV_MODES:
+        raise click.UsageError(f"{mode!r} is not a Jev mode — one of {', '.join(JEV_MODES)}")
+    if all_machines and machine_ids:
+        raise click.UsageError("--all sets every machine; do not name machines as well")
+    if not all_machines and not machine_ids:
+        raise click.UsageError("name at least one machine, or pass --all")
+    cctx = require_auth(state)
+
+    deployments = {d.machine_id: d for d in api.list_deployments(cctx)}
+    if all_machines:
+        targets = [(mid, deployments[mid].jev_mode) for mid in sorted(deployments)]
+    else:
+        known = {m.machine_id for m in api.list_machines(cctx)} | set(deployments)
+        unknown = [mid for mid in machine_ids if mid not in known]
+        if unknown:
+            raise NotFoundError(f"no machine {', '.join(repr(u) for u in unknown)} has checked in")
+        bare = [mid for mid in machine_ids if mid not in deployments]
+        if bare:
+            raise ApiError(
+                f"{', '.join(bare)} {'has' if len(bare) == 1 else 'have'} no deployment, so there is no Jev "
+                "mode to change",
+                hint=f"`fp fleet deploy <machine> --jev-mode {mode}` gives a machine its first deployment with the mode",
+            )
+        targets = [(mid, deployments[mid].jev_mode) for mid in machine_ids]
+    if not targets:
+        if output.is_json():
+            output.emit_json({"mode": mode, "machines": [], "applied": False})
+        else:
+            output.info("no machine has a deployment yet — nothing to set")
+        return
+    _apply_jev_modes(state, cctx, targets, mode, yes=yes)
+
+
 def fleet_diff(
     ctx: typer.Context,
     machine_id: Optional[str] = typer.Argument(None, help="Machine id. Omit for the whole fleet."),
@@ -314,8 +555,11 @@ def fleet_history(
     """List a machine's deployment generations, newest first.
 
     A reissue — the server rewriting a deployment because a policy was disabled
-    — appears as an ordinary entry. Needs `policies:read`. With `--json`:
-    `{machineId, history:[{deployment, policies, updatedAt}]}`.
+    — appears as an ordinary entry, and so does a Jev mode change. Each
+    generation shows the Jev mode FailproofAI Cloud set with it (`local` when it
+    set none), which is the mode a rollback to it restores. Needs
+    `policies:read`. With `--json`: `{machineId, history:[{deployment, policies,
+    updatedAt, jevMode}]}`.
 
     Example:
 
@@ -329,7 +573,8 @@ def fleet_history(
     if output.is_json():
         output.emit_json({"machineId": machine_id, "history": entries})
         return
-    output.render_deployment_history(machine_id, entries)
+    output.render_deployment_history(machine_id, entries,
+                                     agent_labels=api.agent_labels(cctx, machine_id))
 
 
 def fleet_rollback(
@@ -344,8 +589,12 @@ def fleet_rollback(
     counter, so history stays append-only. A generation containing a policy that
     has since been disabled or deleted cannot be reinstated; the server says so.
 
-    Needs `policies:write`. With `--json`: the resulting deployment, or
-    `{"cancelled": true}` if you decline.
+    It restores that generation's Jev mode too, `local` included: the prompt
+    and the result say `jev mode <now> → <then>` when that changes it.
+
+    Needs `policies:write`. With `--json`: the resulting deployment plus
+    `jevModeBefore` (the mode it replaced), or `{"cancelled": true}` if you
+    decline.
 
     Example:
 
@@ -356,9 +605,22 @@ def fleet_rollback(
     cctx = require_auth(state)
     _require_machine(cctx, machine_id)
     current = api.get_deployment(cctx, machine_id)
+    # The mode that generation carried comes back with it, NULL (`local`)
+    # included — a rollback past an `--jev-mode off` turns enforcement back on.
+    # Read it first, so the prompt says so rather than the fleet finding out.
+    target = next(
+        (e for e in api.deployment_history(cctx, machine_id) if e.get("deployment") == deployment), None)
+    mode_before = (current.jev_mode if current else None) or "local"
+    mode_target = (target.get("jevMode") or "local") if target is not None else None
+    consequence = "this REPLACES the machine's current set with the one from that generation"
+    if target is not None:
+        refs = [PolicyRef.from_dict(ref).label for ref in (target.get("policies") or [])]
+        consequence += "; assignments: " + ("; ".join(refs) if refs else "no policies")
+    if mode_target is not None and mode_target != mode_before:
+        consequence += f", and its Jev mode: jev mode {mode_before} → {mode_target}"
     if not _write.confirm_destructive(
         state, f"reinstate deployment #{deployment} on", machine_id,
-        consequence="this REPLACES the machine's current set with the one from that generation",
+        consequence=consequence,
         assume_yes=yes,
     ):
         if output.is_json():
@@ -369,9 +631,12 @@ def fleet_rollback(
     result = api.rollback_deployment(cctx, machine_id, deployment)
     check_race(current.deployment if current else None, result.deployment)
     if output.is_json():
-        output.emit_json(result.to_dict())
+        output.emit_json({**result.to_dict(), "jevModeBefore": mode_before})
         return
-    output.deployment_rolled_back(machine_id, deployment, result.deployment)
+    output.deployment_rolled_back(
+        machine_id, deployment, result.deployment,
+        jev_from=mode_before, jev_to=result.jev_mode or "local",
+    )
 
 
 def fleet_rename(
@@ -404,11 +669,12 @@ def register(app: typer.Typer) -> None:
         no_args_is_help=True,
         rich_markup_mode="markdown",
         context_settings={"help_option_names": ["-h", "--help"]},
-        help="The fleet and what each machine enforces (list / show / deploy / diff / history / rollback / rename).",
+        help="The fleet and what each machine enforces (list / show / deploy / jev-mode / diff / history / rollback / rename).",
     )
     fleet_app.command("list", epilog=GLOBALS_EPILOG)(fleet_list)
     fleet_app.command("show", epilog=GLOBALS_EPILOG)(fleet_show)
     fleet_app.command("deploy", epilog=GLOBALS_EPILOG)(fleet_deploy)
+    fleet_app.command("jev-mode", epilog=GLOBALS_EPILOG)(fleet_jev_mode)
     fleet_app.command("diff", epilog=GLOBALS_EPILOG)(fleet_diff)
     fleet_app.command("history", epilog=GLOBALS_EPILOG)(fleet_history)
     fleet_app.command("rollback", epilog=GLOBALS_EPILOG)(fleet_rollback)

package/.next/standalone/fp-cloud-cli/fp_cli/commands/policies_cmds.py

@@ -10,6 +10,7 @@ single most surprising thing here, so every success path says so.
 """
 from __future__ import annotations
 
+import json
 from typing import Optional
 
 import typer
@@ -18,8 +19,8 @@ from .. import client as api
 from .. import output, theme
 from .._context import GLOBALS_EPILOG, AppState, deny_in_key_mode, require_auth
 from .. import _click_compat as click  # the Click Typer is running; see _click_compat
-from ..enforcement import RefError, RefUsageError, read_source
-from ..policy_check import check_syntax, run_policy
+from ..enforcement import RefError, RefUsageError, parse_semantic, read_source, resolve_kind
+from ..policy_check import SyntaxResult, check_syntax, run_policy
 from ..errors import ApiError, NotFoundError
 from . import _write
 
@@ -36,11 +37,15 @@ _KEY_MODE_REASON = (
 def policies_list(ctx: typer.Context) -> None:
     """List every published policy version, newest of each policy first.
 
-    Shows `policy · version · state · description`, one row per VERSION —
+    Shows `policy · version · kind · state · description`, one row per VERSION —
     versions are immutable and every one stays addressable, so a policy
     published three times is three rows. The title counts distinct policies and
     captions the version total, the way the dashboard's library does.
 
+    `kind` is `regex` (JavaScript), `jev` (Jev checks only) or `both`
+    (JavaScript its own Jev checks may clear); a `jev`/`both` row names its
+    checks and the characters they take of a machine's Jev question budget.
+
     `state` is active, disabled (kept but not enforced) or archived (deleted;
     machines already carrying it keep it until redeployed). Needs
     `policies:read`. With `--json`: the server's policy list verbatim — also
@@ -64,9 +69,11 @@ def policies_show(
     ctx: typer.Context,
     policy_id: str = typer.Argument(..., help="Policy id."),
 ) -> None:
-    """Show one policy, including its full source.
+    """Show one policy, including its full source and its Jev checks.
 
-    Needs `policies:read`. With `--json`: the policy object with `source`.
+    Needs `policies:read`. With `--json`: the policy object with `source`,
+    `kind`, and for `jev`/`both` its `semantic` declarations, `semanticSha256`
+    and the server-derived `authority`/`reviewedBy`.
 
     Example:
 
@@ -96,6 +103,8 @@ def policies_show(
                                    source_bytes=len((match.source or "").encode("utf-8")))
     if match.source:
         output.info(match.source)
+    if match.semantic:
+        output.info(json.dumps(match.semantic, indent=2))
 
 
 def policies_publish(
@@ -103,7 +112,19 @@ def policies_publish(
     policy_id: str = typer.Argument(..., help="Policy id (letters, numbers, '.', '_', '-')."),
     source: Optional[str] = typer.Argument(
         None,
-        help="Path to the policy source, @path, or - for stdin. Omit to paste it.",
+        help="Path to the JavaScript source, @path, or - for stdin. Omit to paste it. Same as --source.",
+    ),
+    kind: Optional[str] = typer.Option(
+        None, "--kind",
+        help="regex (JavaScript), jev (Jev checks only) or both (JavaScript its own Jev checks may "
+             "clear). Default: follows from what you give — --semantic alone is jev, with source both.",
+    ),
+    source_opt: Optional[str] = typer.Option(
+        None, "--source", help="The JavaScript source: a path, @path, or - for stdin.",
+    ),
+    semantic_path: Optional[str] = typer.Option(
+        None, "--semantic",
+        help="A JSON file holding the Jev declarations (a JSON array): a path, @path, or - for stdin.",
     ),
     description: str = typer.Option("", "--description", help="One-line description."),
     no_verify: bool = typer.Option(
@@ -112,13 +133,29 @@ def policies_publish(
 ) -> None:
     """Publish a policy — mints a NEW VERSION; it never edits one in place.
 
-    The source is parse-checked with node before it is sent. Nothing downstream
-    does this: the server validates the id and a size ceiling, and a broken
-    policy otherwise fails on the machine at enforcement time. `--no-verify`
-    skips it; a host without node publishes with a warning rather than a block.
-    Jev fields a cloud policy never reads (`semanticPolicies.add`, `authority:
-    "reviewable"`) are refused regardless — ship those in a pack with
-    `failproofai publish`.
+    A policy has a **kind**:
+
+    * `regex` — JavaScript (`--source`, or the positional source): what publish
+      has always done, and the default.
+    * `jev` — Jev checks only (`--semantic checks.json`): a JSON array of Jev
+      declarations, each `{name, title, appliesTo, mode, userCanOverride,
+      probes:[{id, instructions, criteria:{true,false}}], guidance, ...}` —
+      exactly a failproofai pack manifest's semantic entry. No JavaScript.
+    * `both` — the two together. FailproofAI Cloud makes the JavaScript's
+      verdict reviewable by exactly its own checks, and deploys them as one.
+
+    Jev checks run on FailproofAI Cloud; nothing is installed on the machine.
+    A machine gets a `both` policy's JavaScript, and asks FailproofAI Cloud
+    about each checked tool call while its Jev mode is `observe` or `enforce`.
+
+    The JavaScript is parse-checked with node before it is sent. Nothing
+    downstream does this: the server validates the id and a size ceiling, and a
+    broken policy otherwise fails on the machine at enforcement time.
+    `--no-verify` skips it; a host without node publishes with a warning rather
+    than a block. Jev fields in the JavaScript (`semanticPolicies.add`,
+    `authority: "reviewable"`) are refused regardless — put Jev checks in
+    `--semantic`. The server checks each declaration (limits, reserved
+    FailproofAI names, names unique in the org) and says which one it refused.
 
     Source can come from a path, `@path`, a pipe, `-`, or an interactive paste
     when you give none and stdin is a terminal.
@@ -134,21 +171,42 @@ def policies_publish(
     * `fp policies publish no-force-push ./rule.mjs`
     * `cat rule.mjs | fp policies publish no-force-push`
     * `fp policies publish no-force-push -` — read stdin explicitly
+    * `fp policies publish prod-db-intent --kind jev --semantic ./checks.json`
+    * `fp policies publish no-prod-db --kind both --source ./rule.mjs --semantic ./checks.json`
     """
     state: AppState = ctx.obj
     deny_in_key_mode(state, "policies publish", _KEY_MODE_REASON)
     cctx = require_auth(state)
 
+    if source is not None and source_opt is not None:
+        raise click.UsageError("give the JavaScript source once — positionally or with --source, not both")
+    source = source if source is not None else source_opt
+    if source == "-" and semantic_path == "-":
+        raise click.UsageError("only one of the JavaScript source and --semantic can come from stdin")
+
+    # Whether JavaScript is coming is decided WITHOUT reading stdin: a Jev-only
+    # publish must not sit waiting for a paste nobody is going to give.
+    wants_source = source is not None or kind in ("regex", "both") or (kind is None and semantic_path is None)
+    try:
+        resolved_kind = resolve_kind(kind, has_source=wants_source, has_semantic=semantic_path is not None)
+    except RefUsageError as exc:
+        raise click.UsageError(str(exc))
+
     def _paste_prompt() -> None:
         output.hint("paste the policy source, then press Ctrl-D")
 
+    text: Optional[str] = None
+    semantic = None
     try:
-        text = read_source(source, prompt=_paste_prompt)
+        if semantic_path is not None:
+            semantic = parse_semantic(read_source(semantic_path, isatty=False))
+        if wants_source:
+            text = read_source(source, prompt=_paste_prompt)
     except RefUsageError as exc:
         raise click.UsageError(str(exc))
     except RefError as exc:
         raise ApiError(str(exc))
-    if not text.strip():
+    if wants_source and not (text or "").strip():
         raise ApiError("policy source is empty — nothing to publish")
 
     # Nothing downstream parses this. The server checks the id and a size
@@ -156,7 +214,9 @@ def policies_publish(
     # place for a syntax error to surface. `--no-verify` exists because a
     # machine without node should still be able to publish, not because
     # skipping is ever a good idea.
-    if not no_verify:
+    syn = SyntaxResult(ok=True, checked=False,
+                       message="not checked" if text else "no JavaScript source")
+    if text and not no_verify:
         syn = check_syntax(text)
         if not syn.ok:
             raise ApiError(
@@ -167,7 +227,13 @@ def policies_publish(
         if not syn.checked and not output.is_json():
             output.warn(syn.message)
 
-    created = api.publish_policy(cctx, policy_id, text, description)
+    created = api.publish_policy(
+        cctx, policy_id, text, description,
+        # Sent only when it says something the server's default does not, so a
+        # plain JavaScript publish is the same request it has always been.
+        kind=None if resolved_kind == "regex" and kind is None else resolved_kind,
+        semantic=semantic,
+    )
 
     # Which machines already carry this policy, and at which version. Publishing
     # deploys nothing, so this is the one thing the card must not guess at: it
@@ -191,7 +257,7 @@ def policies_publish(
         output.emit_json({**created.to_dict(), "carriers": carriers, "syntax": syn.to_dict()})
         return
     output.render_policy_published(created, carriers=carriers,
-                                   source_bytes=len(text.encode("utf-8")))
+                                   source_bytes=len((text or "").encode("utf-8")))
 
 
 def policies_enable(