fruxon 0.7.2__tar.gz → 0.8.0__tar.gz

{fruxon-0.7.2 → fruxon-0.8.0}/HISTORY.md

@@ -1,5 +1,28 @@
 # History
 
+## Unreleased — naming + response-metadata polish
+
+- **Renamed `fruxon agents test` → `fruxon agents draft run`.** The
+  old verb was awkward: structurally a draft operation but living
+  outside the `draft` group; semantically *running* the draft but
+  named *test*; and one letter away from the `agents tests` history
+  group (different concept). The rename collapses the authoring loop
+  under a single subgroup — pull / push / status / run / evaluate /
+  discard — and removes the singular/plural ambiguity. `fruxon run`
+  stays as the production verb against the deployed revision; the
+  invariant is now clean: anything draft-y is under `draft`.
+- **Surface response metadata in the human footer.** The done event
+  carries `agentRevision` (which revision actually ran) — useful
+  context that the footer dropped on the floor. Now reads
+  `<duration> · $<cost> · rev <N> · record <id>`. Both `run` and
+  `draft run` benefit.
+- **Production-bucket label in the streaming banner.** `fruxon run`'s
+  subtitle now reads `production · streaming` / `production · sync`
+  / `production · revision N` (when pinned). `agents draft run`
+  mirrors with `draft · <agent> · base rev N`. The bucket is visible
+  at a glance, mirroring the CLI's typed-exit-codes posture: the
+  expensive operation should be the visible one.
+
 ## Unreleased — agent-first overhaul
 
 The CLI is now a first-class surface for AI-agent drivers (Claude

{fruxon-0.7.2 → fruxon-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fruxon
-Version: 0.7.2
+Version: 0.8.0
 Summary: The Fruxon SDK is a lightweight Python client for integrating with the Fruxon platform.
 Project-URL: bugs, https://github.com/fruxon-ai/fruxon-sdk/issues
 Project-URL: changelog, https://github.com/fruxon-ai/fruxon-sdk/blob/main/HISTORY.md
@@ -96,7 +96,7 @@ Agent authoring + management:
 | `fruxon agents schema <id>` | Typed parameter metadata — names, types, required, options. The shape `fruxon run` will accept. |
 | `fruxon agents validate <id> -p k=v` | Pre-flight a payload against the schema. Catches missing-required / wrong-type / invalid-option client-side, surfacing every finding in one pass. |
 | `fruxon agents create --file <body.json>` | Provision a new agent shell. Pair with `--schema` to print the JSON schema for the body first. |
-| `fruxon agents test <id> --file <def.json>` | Run a draft flow definition against an existing agent without publishing it. A CI gate for agent changes. |
+| `fruxon agents draft run <id> --file <def.json>` | Run a draft flow definition against an existing agent without publishing it. A CI gate for agent changes. |
 | `fruxon agents revisions create/get/deploy` | Mint and deploy immutable revisions. `create --deploy` does both in one step. |
 | `fruxon agents draft pull/push/status/undo/redo/reset/discard` | Local working-copy authoring loop — same draft an open studio tab edits. |
 | `fruxon agents draft evaluate <id> --dataset <uuid>` | Score the draft against a golden dataset (expensive — every sample is a full agent run). |

{fruxon-0.7.2 → fruxon-0.8.0}/README.md

@@ -64,7 +64,7 @@ Agent authoring + management:
 | `fruxon agents schema <id>` | Typed parameter metadata — names, types, required, options. The shape `fruxon run` will accept. |
 | `fruxon agents validate <id> -p k=v` | Pre-flight a payload against the schema. Catches missing-required / wrong-type / invalid-option client-side, surfacing every finding in one pass. |
 | `fruxon agents create --file <body.json>` | Provision a new agent shell. Pair with `--schema` to print the JSON schema for the body first. |
-| `fruxon agents test <id> --file <def.json>` | Run a draft flow definition against an existing agent without publishing it. A CI gate for agent changes. |
+| `fruxon agents draft run <id> --file <def.json>` | Run a draft flow definition against an existing agent without publishing it. A CI gate for agent changes. |
 | `fruxon agents revisions create/get/deploy` | Mint and deploy immutable revisions. `create --deploy` does both in one step. |
 | `fruxon agents draft pull/push/status/undo/redo/reset/discard` | Local working-copy authoring loop — same draft an open studio tab edits. |
 | `fruxon agents draft evaluate <id> --dataset <uuid>` | Score the draft against a golden dataset (expensive — every sample is a full agent run). |

{fruxon-0.7.2 → fruxon-0.8.0}/src/fruxon/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.7.2'
-__version_tuple__ = version_tuple = (0, 7, 2)
+__version__ = version = '0.8.0'
+__version_tuple__ = version_tuple = (0, 8, 0)
 
 __commit_id__ = commit_id = None

{fruxon-0.7.2 → fruxon-0.8.0}/src/fruxon/cli/agents.py

@@ -19,10 +19,9 @@ import typer
 
 from fruxon.cli import app
 from fruxon.cli._shared import build_client, load_json_body
-from fruxon.exceptions import FruxonError, NotFoundError, StaleDraftError
+from fruxon.exceptions import FruxonError, NotFoundError
 from fruxon.fruxon import Agent, FruxonClient
 from fruxon.ui import (
-    EXIT_CONFLICT,
     EXIT_VALIDATION,
     dashboard_url,
     fail,
@@ -523,181 +522,6 @@ def _strip_markup(text: str) -> str:
     return _RICH_MARKUP_RE.sub("", text)
 
 
-@agents_app.command("test")
-def agents_test(
-    agent: Annotated[str, typer.Argument(help="Agent identifier the draft belongs to.")],
-    file: Annotated[
-        str | None,
-        typer.Option(
-            "--file",
-            "-f",
-            help=(
-                "Draft head JSON to push before running (same shape as `draft pull`/`push`). "
-                "Pass `-` to read from stdin. Omit to test the server-side draft as-is."
-            ),
-        ),
-    ] = None,
-    param: Annotated[
-        list[str] | None,
-        typer.Option(
-            "--param",
-            "-p",
-            help=(
-                "Runtime parameter — `key=value` (string) or `key:=42` (typed JSON). "
-                "Repeatable. Overlays the file's parameters."
-            ),
-        ),
-    ] = None,
-    base_revision: Annotated[
-        int | None,
-        typer.Option(
-            "--base-revision",
-            help=(
-                "Revision the draft is based on — masked secrets resolve from its stored "
-                "configs. Overrides the file; defaults to the agent's current revision."
-            ),
-        ),
-    ] = None,
-    session_id: Annotated[
-        str | None,
-        typer.Option("--session", "-s", help="Session ID for multi-turn continuity."),
-    ] = None,
-    org: Annotated[str | None, typer.Option("--org", help="Organization identifier override.")] = None,
-    base_url: Annotated[str | None, typer.Option("--base-url", help="API base URL override.")] = None,
-    stream: Annotated[
-        bool,
-        typer.Option(
-            "--stream/--no-stream",
-            help=(
-                "Stream the run as it happens (default). --no-stream waits for the full "
-                "result; implied by --output json/table."
-            ),
-        ),
-    ] = True,
-    output: Annotated[
-        str | None,
-        typer.Option(
-            "--output",
-            "-o",
-            help="Output format: text (default), json, table. json/table imply --no-stream.",
-        ),
-    ] = None,
-    verbose: Annotated[
-        bool,
-        typer.Option("--verbose", "-v", help="Expand tool calls in the streaming view (full args + results)."),
-    ] = False,
-):
-    """Run the server-side draft for an agent without publishing it.
-
-    This is the "validate before you ship" loop. The server-side draft
-    must already exist (``draft pull`` seeds it, ``draft push`` updates
-    it). With ``--file`` the local draft head is pushed first, so the
-    edit-then-test cycle is one command. Without ``--file`` the existing
-    draft is tested as-is.
-
-    The result is identical in shape to ``fruxon run`` — same streaming
-    view, same ``--output`` formats, same duration/cost/record footer —
-    because ``draft:test`` returns the same envelope as ``:execute``.
-    The only difference is *what* runs: the agent's draft revision, not
-    the deployed one.
-
-    Examples:
-        fruxon agents draft pull my-agent
-        # edit my-agent.draft.json
-        fruxon agents test my-agent --file my-agent.draft.json -p query="hello"
-        fruxon agents test my-agent --no-stream -o json
-
-    Procedural guide:
-        fruxon guides show fruxon-build-agent       # how to author the flow
-        fruxon guides show fruxon-debug-revision    # if validation fails
-    """
-    from fruxon.cli.run import _hint_for_run_error, _render_sync_result, _run_stream
-    from fruxon.output import FORMATS
-    from fruxon.params import ParamError
-    from fruxon.params import parse as parse_params
-
-    output = resolve_output_format(output, human_default="text", agent_default="json")
-    if output not in FORMATS:
-        fail(
-            f"Unknown output format: [bold]{output}[/bold]",
-            hint=f"Valid formats: {', '.join(FORMATS)}.",
-            code=EXIT_VALIDATION,
-        )
-    # json/table need the full result envelope — silently drop streaming
-    # rather than making the user also type --no-stream (same rule as run).
-    if output != "text":
-        stream = False
-
-    try:
-        flag_params = parse_params(flag_values=param, params_file=None, stdin_input=False)
-    except ParamError as exc:
-        fail(
-            str(exc),
-            hint="Run [bold]fruxon agents test --help[/bold] for accepted parameter forms.",
-            code=EXIT_VALIDATION,
-        )
-
-    client = build_client(org, base_url)
-
-    # Resolve the draft's base revision and current version. The sidecar
-    # — written by ``draft pull`` / ``draft push`` — is the source of
-    # truth so a CI run doesn't have to thread these through flags.
-    meta = _read_sidecar(agent) if base_revision is None or file else None
-    base_rev: int | str
-    if base_revision is not None:
-        base_rev = base_revision
-    else:
-        base_rev = meta["baseRevision"]  # type: ignore[index]
-    version: int | None = meta.get("version") if meta else None
-
-    # With --file: push the local draft head first so the test runs
-    # against exactly what's on disk. Idempotent — if the file matches
-    # the last push, the server just bumps the version.
-    if file:
-        head = load_json_body(file, what="a draft head object")
-        try:
-            result_put = client.put_draft(agent, base_rev, head, if_match=version)
-        except StaleDraftError:
-            fail(
-                "The draft changed on the server since you pulled.",
-                hint=(
-                    f"Your local file is untouched. Run [bold]fruxon agents draft pull {agent}[/bold] "
-                    "to get the latest, reconcile your edits, then test again."
-                ),
-                code=EXIT_CONFLICT,
-            )
-        except FruxonError as e:
-            fail_from_api_error(e, hint=_hint_for_run_error(e, agent=agent, client=client))
-        version = result_put.get("version")
-        _write_sidecar(agent, base_revision=int(base_rev), version=version, file=str(file))
-
-    request: dict[str, object] = {}
-    if flag_params:
-        request["parameters"] = flag_params
-    if session_id is not None:
-        request["sessionId"] = session_id
-
-    if stderr.is_terminal:
-        print_banner(subtitle=f"test · {agent}")
-
-    if stream:
-        _run_stream(
-            lambda: client.stream_test(agent, base_rev, request, if_match=version),
-            agent=agent,
-            client=client,
-            verbose=verbose,
-        )
-        return
-
-    with stderr.status(f"[bold]Testing draft against [cyan]{agent}[/cyan]…[/bold]"):
-        try:
-            result = client.test(agent, base_rev, request, if_match=version)
-        except FruxonError as e:
-            fail_from_api_error(e, hint=_hint_for_run_error(e, agent=agent, client=client))
-
-    _render_sync_result(result, output, agent=agent)
-
-
 def _fetch_parameters_safely(client: FruxonClient, fetched: Agent) -> list[str]:
     """Fetch the deployed revision's parameter names, swallowing errors.
 

{fruxon-0.7.2 → fruxon-0.8.0}/src/fruxon/cli/agents_draft.py

@@ -36,6 +36,7 @@ from fruxon.ui import (
     fail,
     fail_from_api_error,
     is_agent_mode,
+    print_banner,
     resolve_output_format,
     say_info,
     say_ok,
@@ -396,6 +397,191 @@ def draft_reset(
     _draft_step(agent, org, base_url, "reset", output)
 
 
+@draft_app.command("run")
+def draft_run(
+    agent: Annotated[str, typer.Argument(help="Agent identifier the draft belongs to.")],
+    file: Annotated[
+        str | None,
+        typer.Option(
+            "--file",
+            "-f",
+            help=(
+                "Draft head JSON to push before running (same shape as `draft pull`/`push`). "
+                "Pass `-` to read from stdin. Omit to run the server-side draft as-is."
+            ),
+        ),
+    ] = None,
+    param: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--param",
+            "-p",
+            help=(
+                "Runtime parameter — `key=value` (string) or `key:=42` (typed JSON). "
+                "Repeatable. Overlays the file's parameters."
+            ),
+        ),
+    ] = None,
+    base_revision: Annotated[
+        int | None,
+        typer.Option(
+            "--base-revision",
+            help=(
+                "Revision the draft is based on — masked secrets resolve from its stored "
+                "configs. Overrides the file; defaults to the agent's current revision."
+            ),
+        ),
+    ] = None,
+    session_id: Annotated[
+        str | None,
+        typer.Option("--session", "-s", help="Session ID for multi-turn continuity."),
+    ] = None,
+    org: Annotated[str | None, typer.Option("--org", help="Organization identifier override.")] = None,
+    base_url: Annotated[str | None, typer.Option("--base-url", help="API base URL override.")] = None,
+    stream: Annotated[
+        bool,
+        typer.Option(
+            "--stream/--no-stream",
+            help=(
+                "Stream the run as it happens (default). --no-stream waits for the full "
+                "result; implied by --output json/table."
+            ),
+        ),
+    ] = True,
+    output: Annotated[
+        str | None,
+        typer.Option(
+            "--output",
+            "-o",
+            help="Output format: text (default), json, table. json/table imply --no-stream.",
+        ),
+    ] = None,
+    verbose: Annotated[
+        bool,
+        typer.Option("--verbose", "-v", help="Expand tool calls in the streaming view (full args + results)."),
+    ] = False,
+):
+    """Run the agent's draft revision — same shape as ``fruxon run``, on the draft.
+
+    This is the "validate before you ship" loop. The server-side draft
+    must already exist (``draft pull`` seeds it, ``draft push`` updates
+    it). With ``--file`` the local draft head is pushed first, so the
+    edit-then-run cycle is one command. Without ``--file`` the existing
+    draft is run as-is.
+
+    The result is identical in shape to ``fruxon run`` — same streaming
+    view, same ``--output`` formats, same duration/cost/record footer —
+    because ``draft:test`` returns the same envelope as ``:execute``.
+    The only difference is *what* runs: the agent's draft revision (Origin=
+    TEST, owner-scoped, doesn't pollute prod metrics or budgets), not the
+    deployed one.
+
+    The split mirrors the rest of ``draft``: every operation against the
+    working copy lives under this group. ``fruxon run`` (no subgroup) is
+    reserved for production traffic against the deployed revision.
+
+    Examples:
+        fruxon agents draft pull my-agent
+        # edit my-agent.draft.json
+        fruxon agents draft run my-agent --file my-agent.draft.json -p query="hello"
+        fruxon agents draft run my-agent --no-stream -o json
+
+    Procedural guide:
+        fruxon guides show fruxon-build-agent       # how to author the flow
+        fruxon guides show fruxon-debug-revision    # if validation fails
+    """
+    from fruxon.cli._shared import load_json_body
+    from fruxon.cli.run import _hint_for_run_error, _render_sync_result, _run_stream
+    from fruxon.output import FORMATS
+    from fruxon.params import ParamError
+    from fruxon.params import parse as parse_params
+
+    output = resolve_output_format(output, human_default="text", agent_default="json")
+    if output not in FORMATS:
+        fail(
+            f"Unknown output format: [bold]{output}[/bold]",
+            hint=f"Valid formats: {', '.join(FORMATS)}.",
+            code=EXIT_VALIDATION,
+        )
+    # json/table need the full result envelope — silently drop streaming
+    # rather than making the user also type --no-stream (same rule as run).
+    if output != "text":
+        stream = False
+
+    try:
+        flag_params = parse_params(flag_values=param, params_file=None, stdin_input=False)
+    except ParamError as exc:
+        fail(
+            str(exc),
+            hint="Run [bold]fruxon agents draft run --help[/bold] for accepted parameter forms.",
+            code=EXIT_VALIDATION,
+        )
+
+    client = build_client(org, base_url)
+
+    # Resolve the draft's base revision and current version. The sidecar
+    # — written by ``draft pull`` / ``draft push`` — is the source of
+    # truth so a CI run doesn't have to thread these through flags.
+    meta = _read_sidecar(agent) if base_revision is None or file else None
+    base_rev: int | str
+    if base_revision is not None:
+        base_rev = base_revision
+    else:
+        base_rev = meta["baseRevision"]  # type: ignore[index]
+    version: int | None = meta.get("version") if meta else None
+
+    # With --file: push the local draft head first so the run uses
+    # exactly what's on disk. Idempotent — if the file matches the
+    # last push, the server just bumps the version.
+    if file:
+        head = load_json_body(file, what="a draft head object")
+        try:
+            result_put = client.put_draft(agent, base_rev, head, if_match=version)
+        except StaleDraftError:
+            fail(
+                "The draft changed on the server since you pulled.",
+                hint=(
+                    f"Your local file is untouched. Run [bold]fruxon agents draft pull {agent}[/bold] "
+                    "to get the latest, reconcile your edits, then run again."
+                ),
+                code=EXIT_CONFLICT,
+            )
+        except FruxonError as e:
+            fail_from_api_error(e, hint=_hint_for_run_error(e, agent=agent, client=client))
+        version = result_put.get("version")
+        _write_sidecar(agent, base_revision=int(base_rev), version=version, file=str(file))
+
+    request: dict[str, object] = {}
+    if flag_params:
+        request["parameters"] = flag_params
+    if session_id is not None:
+        request["sessionId"] = session_id
+
+    if stderr.is_terminal:
+        # Surface ``draft · rev N`` in the header so the user (or a code
+        # reviewer reading scrollback) can tell at a glance which bucket
+        # this ran against. ``fruxon run`` mirrors the same pattern with
+        # ``production · rev N`` — keeps the two paths visibly distinct.
+        print_banner(subtitle=f"draft · {agent} · base rev {base_rev}")
+
+    if stream:
+        _run_stream(
+            lambda: client.stream_test(agent, base_rev, request, if_match=version),
+            agent=agent,
+            client=client,
+            verbose=verbose,
+        )
+        return
+
+    with stderr.status(f"[bold]Running draft for [cyan]{agent}[/cyan]…[/bold]"):
+        try:
+            result = client.test(agent, base_rev, request, if_match=version)
+        except FruxonError as e:
+            fail_from_api_error(e, hint=_hint_for_run_error(e, agent=agent, client=client))
+
+    _render_sync_result(result, output, agent=agent)
+
+
 @draft_app.command("evaluate")
 def draft_evaluate(
     agent: Annotated[str, typer.Argument(help="Agent identifier the draft belongs to.")],

{fruxon-0.7.2 → fruxon-0.8.0}/src/fruxon/cli/run.py

@@ -230,8 +230,19 @@ def run(
     # stdout are all unaffected. Skip when stderr is being redirected too —
     # if both streams are captured the user is almost certainly scripting
     # and doesn't want ANSI chrome in their log file.
+    #
+    # ``production`` label is on the subtitle so the bucket is visible
+    # at a glance — the mirror of ``draft · …`` on ``agents draft run``.
+    # When a revision is pinned explicitly we surface its number; the
+    # deployed-revision number isn't known until the ``done`` event
+    # arrives, so for the default path we just say "production".
     if stderr.is_terminal:
-        mode_subtitle = "streaming" if stream else (f"revision {revision}" if revision else "sync")
+        if revision:
+            mode_subtitle = f"production · revision {revision}"
+        elif stream:
+            mode_subtitle = "production · streaming"
+        else:
+            mode_subtitle = "production · sync"
         print_banner(subtitle=mode_subtitle)
 
     # Parse all the param input forms — flag values, JSON file, stdin —
@@ -1257,25 +1268,32 @@ def _truncate(text: str, max_len: int) -> str:
 
 
 def _render_done(data: dict[str, object], *, agent: str | None = None) -> None:
-    """Render the final-event footer with duration, cost, and record ID.
-
-    The execution record ID is the user's handle to follow up via
-    ``fruxon trace`` — printing it here is what makes that command
-    discoverable in practice. When the agent name is known we follow up
-    with a copy-pasteable ``fruxon trace`` line so the user doesn't have
-    to assemble it themselves. Falls back gracefully when any of the
-    three are absent so partial server payloads still produce a useful
-    line.
+    """Render the final-event footer with duration, cost, revision, and record ID.
+
+    Pulls the headline fields from the done event's ``trace`` envelope.
+    Each field is included only when the server actually returned it —
+    a partial payload (older backend, abbreviated stream) still produces
+    a useful line. The order is read-left-to-right "what cost what":
+    duration → cost → which revision ran → record id → trace pointer.
+
+    ``agentRevision`` matters because the user needs to know *what*
+    just executed — same agent id can be a draft run, a pinned old
+    revision, or the currently-deployed one. Without surfacing it,
+    "did my new revision actually run?" becomes a separate ``trace``
+    call.
     """
     trace = data.get("trace") if isinstance(data.get("trace"), dict) else {}
     duration = trace.get("duration") if isinstance(trace, dict) else None
     total_cost = trace.get("totalCost") if isinstance(trace, dict) else None
+    agent_revision = trace.get("agentRevision") if isinstance(trace, dict) else None
     record_id = data.get("executionRecordId")
     parts: list[str] = []
     if isinstance(duration, (int, float)) and duration:
         parts.append(format_duration(duration))
     if isinstance(total_cost, (int, float)) and total_cost:
         parts.append(f"${float(total_cost):.4f}")
+    if isinstance(agent_revision, (int, float)) and agent_revision:
+        parts.append(f"rev [bold]{int(agent_revision)}[/bold]")
     if isinstance(record_id, str) and record_id:
         parts.append(f"record [cyan]{record_id}[/cyan]")
     if parts:

{fruxon-0.7.2 → fruxon-0.8.0}/src/fruxon/skills/fruxon-agent-mode/SKILL.md

@@ -164,7 +164,7 @@ of the trace fields — same `type: "done"`, distinguished by the
   "status":"waiting_for_human","human_approval_request_id":"har-7"}
 ```
 
-**Step traces.** `fruxon agents test` additionally emits
+**Step traces.** `fruxon agents draft run` additionally emits
 `{"type":"step_trace","id":"…","name":"…","step_type":"LlmStep",
 "status":"succeeded","duration_ms":1234}` when each flow step
 finishes — useful for CI gates that need per-step cost attribution.
@@ -221,7 +221,7 @@ the bypass flag.
 | `fruxon login` (key already stored) | Pass `--api-key …` to replace, or `fruxon logout` first |
 | `fruxon run --edit` | Pass the value via `-p key=value` or `--params file.json` |
 | `keys delete` (no --yes) | Pass `--yes` |
-| `agents test chats delete` (no --yes) | Pass `--yes` |
+| `agents tests delete` (no --yes) | Pass `--yes` |
 | `agents budget delete` (no --yes) | Pass `--yes` |
 | `agents draft evaluate` (no --yes) | Pass `--yes` — it costs real money |
 

{fruxon-0.7.2 → fruxon-0.8.0}/src/fruxon/skills/fruxon-build-agent/SKILL.md

@@ -42,7 +42,7 @@ revision from it.
 5. **Sync the draft**: `fruxon agents draft push <agent>` saves your
    edits to the server-side draft. It is visible in an open studio
    within ~1s, and reversible with `fruxon agents draft undo`.
-6. **Test**: `fruxon agents test <agent> --file <agent>.draft.json -p k=v`
+6. **Test**: `fruxon agents draft run <agent> --file <agent>.draft.json -p k=v`
    runs the body like a normal run. The execution IS persisted, but
    stamped with `Origin=TEST` so it never mixes with production
    metrics (see "Origins" below). In agent mode this emits NDJSON
@@ -79,7 +79,7 @@ Every execution is tagged with an **origin** at the moment it runs:
 
 - **`PRODUCTION`** — real end-user traffic from a connector, the
   gateway, scheduled triggers, etc. The `:execute` path.
-- **`TEST`** — your own development runs from `fruxon agents test`
+- **`TEST`** — your own development runs from `fruxon agents draft run`
   / `:streamTest` / the studio "Run test" button. Owner-scoped
   (you only ever see your own test rows; admins see the org-wide
   total).

{fruxon-0.7.2 → fruxon-0.8.0}/src/fruxon/skills/fruxon-debug-revision/SKILL.md

@@ -13,7 +13,7 @@ You are now operating as a Fruxon revision debugging specialist.
 1. Read the exact error from the failing CLI call (don't guess).
 2. Map the error to one of the categories below.
 3. Apply the targeted fix.
-4. Re-run with `fruxon agents test <agent> --file fixed.json` first;
+4. Re-run with `fruxon agents draft run <agent> --file fixed.json` first;
    only re-create the revision when the test passes.
 
 ## Reading errors (agent mode vs human mode)
@@ -90,7 +90,7 @@ integration tool on `step.tools` references an
 `integrationConfigId` that doesn't appear in
 `revision.integrationConfigs`. Add the config or remove the tool.
 
-## Runtime errors during `fruxon agents test`
+## Runtime errors during `fruxon agents draft run`
 **Tool unknown / no LLM tool registered for X** — usually means a
 built-in tool ended up on `step.tools` instead of
 `step.provider.builtInTools`. Move it.
@@ -114,7 +114,7 @@ shows whether the local and server versions have diverged.
   missing required / unknown / wrong-type / invalid-option errors
   client-side, surfacing every finding in one pass (no round-trip
   per error). Exits 12 on failure with a structured `errors` list.
-- **Test before you create**: `fruxon agents test` catches most
+- **Test before you create**: `fruxon agents draft run` catches most
   errors without persisting a bad revision.
 - **Diff against the schema**: re-run `fruxon agents revisions create
   --schema` and compare your body field-by-field for missing /
@@ -124,7 +124,7 @@ shows whether the local and server versions have diverged.
 - **Read the trace**: after a failed run,
   `fruxon trace <agent> <record-id>` shows step-by-step status —
   which step failed and why.
-- **Replay your test history**: every `fruxon agents test` run
+- **Replay your test history**: every `fruxon agents draft run` run
   persists server-side tagged `Origin=TEST` (owner-scoped). Useful
   when iterating on a hard-to-reproduce issue:
   ```

{fruxon-0.7.2 → fruxon-0.8.0}/tests/test_cli.py

@@ -1555,7 +1555,7 @@ class TestAgents:
         self._seed_sidecar(monkeypatch, tmp_path)
         draft = tmp_path / "agent.json"
         draft.write_text('{"flow": {}}')
-        result = runner.invoke(app, ["agents", "test", "agent-1", "--file", str(draft)])
+        result = runner.invoke(app, ["agents", "draft", "run", "agent-1", "--file", str(draft)])
         assert result.exit_code == EXIT_AUTH_REQUIRED
         assert "No API key" in result.stderr or "fruxon login" in result.stderr
 
@@ -1565,7 +1565,7 @@ class TestAgents:
         draft = tmp_path / "agent.json"
         draft.write_text('{"flow": {"steps": []}}')
         captured = self._patch_client(monkeypatch, test_result=_result("draft says hi"))
-        result = runner.invoke(app, ["agents", "test", "agent-1", "--file", str(draft), "--no-stream"])
+        result = runner.invoke(app, ["agents", "draft", "run", "agent-1", "--file", str(draft), "--no-stream"])
         assert result.exit_code == 0, result.stderr
         # File pushed via put_draft using sidecar's base revision + version.
         put_agent, put_rev, put_head, put_if_match = captured["put_draft_args"]
@@ -1589,7 +1589,7 @@ class TestAgents:
         captured = self._patch_client(monkeypatch, test_result=_result())
         result = runner.invoke(
             app,
-            ["agents", "test", "agent-1", "--file", str(draft), "--no-stream", "-p", "q=hi", "-p", "lang=en"],
+            ["agents", "draft", "run", "agent-1", "--file", str(draft), "--no-stream", "-p", "q=hi", "-p", "lang=en"],
         )
         assert result.exit_code == 0, result.stderr
         _, request = captured["test_args"]
@@ -1605,7 +1605,8 @@ class TestAgents:
             app,
             [
                 "agents",
-                "test",
+                "draft",
+                "run",
                 "agent-1",
                 "--file",
                 str(draft),
@@ -1627,7 +1628,7 @@ class TestAgents:
         credentials.save(credentials.StoredCredentials(api_key="fxn_x", org="acme"))
         self._seed_sidecar(monkeypatch, tmp_path)
         captured = self._patch_client(monkeypatch, test_result=_result())
-        result = runner.invoke(app, ["agents", "test", "agent-1", "--no-stream"])
+        result = runner.invoke(app, ["agents", "draft", "run", "agent-1", "--no-stream"])
         assert result.exit_code == 0, result.stderr
         assert "put_draft_args" not in captured
         assert captured["test_base_revision"] == 2
@@ -1647,7 +1648,7 @@ class TestAgents:
             StreamEvent(event="done", data={"trace": {}, "executionRecordId": "rec-stream-9"}),
         ]
         self._patch_client(monkeypatch, test_stream=events)
-        result = runner.invoke(app, ["agents", "test", "agent-1", "--file", str(draft)])
+        result = runner.invoke(app, ["agents", "draft", "run", "agent-1", "--file", str(draft)])
         assert result.exit_code == 0, result.stderr
         assert "draft output" in result.stdout
         assert "rec-stream-9" in result.stderr
@@ -1658,7 +1659,7 @@ class TestAgents:
         draft = tmp_path / "agent.json"
         draft.write_text('{"flow": {}}')
         captured = self._patch_client(monkeypatch, test_result=_result("json body"))
-        result = runner.invoke(app, ["agents", "test", "agent-1", "--file", str(draft), "--output", "json"])
+        result = runner.invoke(app, ["agents", "draft", "run", "agent-1", "--file", str(draft), "--output", "json"])
         assert result.exit_code == 0, result.stderr
         assert "test_args" in captured
         import json as json_mod
@@ -1672,7 +1673,7 @@ class TestAgents:
         captured = self._patch_client(monkeypatch, test_result=_result())
         result = runner.invoke(
             app,
-            ["agents", "test", "agent-1", "--file", "-", "--no-stream"],
+            ["agents", "draft", "run", "agent-1", "--file", "-", "--no-stream"],
             input='{"flow": {"piped": true}}',
         )
         assert result.exit_code == 0, result.stderr
@@ -1685,7 +1686,7 @@ class TestAgents:
         draft = tmp_path / "agent.json"
         draft.write_text("{not valid json")
         self._patch_client(monkeypatch, test_result=_result())
-        result = runner.invoke(app, ["agents", "test", "agent-1", "--file", str(draft), "--no-stream"])
+        result = runner.invoke(app, ["agents", "draft", "run", "agent-1", "--file", str(draft), "--no-stream"])
         assert result.exit_code == EXIT_VALIDATION
         assert "not valid JSON" in result.stderr
 
@@ -1695,7 +1696,7 @@ class TestAgents:
         draft = tmp_path / "agent.json"
         draft.write_text('["a", "list"]')
         self._patch_client(monkeypatch, test_result=_result())
-        result = runner.invoke(app, ["agents", "test", "agent-1", "--file", str(draft), "--no-stream"])
+        result = runner.invoke(app, ["agents", "draft", "run", "agent-1", "--file", str(draft), "--no-stream"])
         assert result.exit_code == EXIT_VALIDATION
         assert "must contain a JSON object" in result.stderr
 
@@ -1703,7 +1704,9 @@ class TestAgents:
         credentials.save(credentials.StoredCredentials(api_key="fxn_x", org="acme"))
         self._seed_sidecar(monkeypatch, tmp_path)
         self._patch_client(monkeypatch, test_result=_result())
-        result = runner.invoke(app, ["agents", "test", "agent-1", "--file", "/nonexistent/agent.json", "--no-stream"])
+        result = runner.invoke(
+            app, ["agents", "draft", "run", "agent-1", "--file", "/nonexistent/agent.json", "--no-stream"]
+        )
         assert result.exit_code == EXIT_VALIDATION
         assert "Couldn't read file" in result.stderr
 
@@ -1712,7 +1715,7 @@ class TestAgents:
         credentials.save(credentials.StoredCredentials(api_key="fxn_x", org="acme"))
         monkeypatch.chdir(tmp_path)
         self._patch_client(monkeypatch, test_result=_result())
-        result = runner.invoke(app, ["agents", "test", "agent-1", "--no-stream"])
+        result = runner.invoke(app, ["agents", "draft", "run", "agent-1", "--no-stream"])
         assert result.exit_code == EXIT_VALIDATION
         assert "draft pull" in result.stderr
 
@@ -1727,7 +1730,7 @@ class TestAgents:
             monkeypatch,
             test_raises=ForbiddenError(status=403, title="Forbidden", detail="not an editor"),
         )
-        result = runner.invoke(app, ["agents", "test", "agent-1", "--file", str(draft), "--no-stream"])
+        result = runner.invoke(app, ["agents", "draft", "run", "agent-1", "--file", str(draft), "--no-stream"])
         # 403 maps to auth_required — same class as 401, since recovery
         # is the same (rotate creds / get the right scope).
         assert result.exit_code == EXIT_AUTH_REQUIRED