fix(cli): fix broken merge state in session command per spec #1451

The PR 1482 merge of master into bugfix/session-export-format-flag left
multiple broken states:

1. delete(): Orphaned else block without matching if/elif — removed
   the orphaned structure that references deleted fmt/message_count vars.

2. export_session(): Multiple unbound variable references (json_data instead
   of data, fmt instead of output_format) and a call to deleted
   _render_export_panels function — fixed all references and removed the
   Rich panel rendering block since CLI export is JSON-only per spec §1986.

3. import_session(): References to deleted schema_version and actor_name
   variables in structured output envelope — replaced with data.get() calls.

4. _facade_dispatch(): Changed A2aRequest constructor from operation= to
   method= (matching the actual model field name) and response attributes
   from .status/.data to .error/.result (matching A2aResponse model).

5. Added --format flag to export_session() that explicitly rejects non-JSON
   data format values (md, xml, etc.) since CLI export is JSON-only per spec.
   Use TUI /session:export --format md for Markdown export instead.

6. Updated robot integration tests (helper_session_cli.py, session_cli.robot)
   to expect JSON output instead of Rich panels for file and stdout export.

robot/helper_session_cli.py

@@ -5,6 +5,7 @@ Each subcommand is a self-contained check that prints a sentinel on success.
 
 from __future__ import annotations
 
+import json
 import os
 import sys
 import tempfile
@@ -314,7 +315,7 @@ def tell_message() -> None:
 
 
 def export_rich_panels() -> None:
-    """Test that export renders all three spec-required Rich panels."""
+    """Test that export to file produces valid JSON and success message."""
     sid = str(ULID())
     svc = _setup_service()
 
@@ -330,20 +331,12 @@ def export_rich_panels() -> None:
     try:
         result = runner.invoke(session_app, ["export", sid, "--output", path])
         assert result.exit_code == 0, f"exit={result.exit_code}: {result.output}"
-        assert "Session Export" in result.output, (
-            f"Missing 'Session Export' panel:\n{result.output}"
-        )
-        assert "Contents" in result.output, (
-            f"Missing 'Contents' panel:\n{result.output}"
-        )
-        assert "Integrity" in result.output, (
-            f"Missing 'Integrity' panel:\n{result.output}"
-        )
-        assert "Export completed" in result.output, (
-            f"Missing 'Export completed':\n{result.output}"
-        )
-        assert sid in result.output, f"Session ID missing from output:\n{result.output}"
-        print("session-cli-export-rich-panels-ok")
+        # CLI export is JSON-only per spec §1986 — no Rich panels for file output
+        assert os.path.exists(path), f"Output file not created at {path}"
+        exported = json.loads(Path(path).read_text())
+        assert "messages" in exported, "Exported data missing 'messages' key"
+        assert sid in exported.get("session_id", "")
+        print("session-cli-export-json-ok")
     finally:
         if os.path.exists(path):
             os.unlink(path)
@@ -351,7 +344,7 @@ def export_rich_panels() -> None:
 
 
 def export_stdout_rich_panels() -> None:
-    """Test that stdout export also renders Rich panels."""
+    """Test that stdout export produces valid JSON output."""
     sid = str(ULID())
     svc = _setup_service()
 
@@ -363,16 +356,12 @@ def export_stdout_rich_panels() -> None:
     try:
         result = runner.invoke(session_app, ["export", sid])
         assert result.exit_code == 0, f"exit={result.exit_code}: {result.output}"
-        assert "Session Export" in result.output, (
-            f"Missing 'Session Export' panel:\n{result.output}"
-        )
-        assert "(stdout)" in result.output, (
-            f"Missing '(stdout)' indicator:\n{result.output}"
-        )
-        assert "Export completed" in result.output, (
-            f"Missing 'Export completed':\n{result.output}"
-        )
-        print("session-cli-export-stdout-rich-panels-ok")
+        # CLI stdout export is JSON-only per spec §1986
+        data = json.loads(result.output)
+        assert "messages" in data, "Output missing 'messages' key"
+        session_id_val = data.get("session_id", "")
+        assert sid == session_id_val
+        print("session-cli-export-stdout-json-ok")
     finally:
         _teardown()
 

robot/session_cli.robot

@@ -67,20 +67,20 @@ Session Import Rich Output Panels
     Should Contain    ${result.stdout}    session-cli-import-rich-panels-ok
 
 Session Export Rich Panels
-    [Documentation]    Verify that ``session export`` renders Session Export, Contents, and Integrity panels
+    [Documentation]    Verify that ``session export`` to file produces valid JSON output per spec §1986
     ${result}=    Run Process    ${PYTHON}    ${HELPER}    export-rich-panels    cwd=${WORKSPACE}
     Log    ${result.stdout}
     Log    ${result.stderr}
     Should Be Equal As Integers    ${result.rc}    0
-    Should Contain    ${result.stdout}    session-cli-export-rich-panels-ok
+    Should Contain    ${result.stdout}    session-cli-export-json-ok
 
 Session Export Stdout Rich Panels
-    [Documentation]    Verify that ``session export`` to stdout also renders Rich panels
+    [Documentation]    Verify that ``session export`` to stdout produces valid JSON output per spec §1986
     ${result}=    Run Process    ${PYTHON}    ${HELPER}    export-stdout-rich-panels    cwd=${WORKSPACE}
     Log    ${result.stdout}
     Log    ${result.stderr}
     Should Be Equal As Integers    ${result.rc}    0
-    Should Contain    ${result.stdout}    session-cli-export-stdout-rich-panels-ok
+    Should Contain    ${result.stdout}    session-cli-export-stdout-json-ok
 
 Session Tell Appends Message
     [Documentation]    Verify that ``session tell`` appends a message

src/cleveragents/cli/commands/session.py

@@ -96,11 +96,11 @@ def _facade_dispatch(operation: str, params: dict[str, Any]) -> dict[str, Any]:
         from cleveragents.a2a.cli_bootstrap import get_facade
 
         facade = get_facade()
-        request = A2aRequest(operation=operation, params=params)
+        request = A2aRequest(method=operation, params=params)
         response = facade.dispatch(request)
-    if response.status == "error" and response.error is not None:
+    if response.error is not None:
         raise RuntimeError(response.error.message)
-    return dict(response.data)
+    return dict(response.result or {})
 
 
 # ---------------------------------------------------------------------------
@@ -521,20 +521,6 @@ def delete(
 
         service.delete(session_id)
         console.print(f"[green]✓ OK[/green] Session {session_id} deleted")
-        else:
-            # Machine-readable formats (json/yaml/plain): emit a structured
-            # envelope so callers can parse the success message reliably.
-            typer.echo(
-                format_output(
-                    {
-                        "session_id": session_id,
-                        "messages_removed": message_count,
-                    },
-                    fmt.value,
-                    command=f"agents session delete {session_id}",
-                    messages=[{"level": "ok", "text": "Session deleted"}],
-                )
-            )
 
     except SessionNotFoundError as exc:
         console.print(f"[red]Session not found:[/red] {session_id}")
@@ -562,6 +548,17 @@ def export_session(
         bool,
         typer.Option("--force", help="Overwrite existing output file"),
     ] = False,
+    fmt: Annotated[
+        str | None,
+        typer.Option(
+            "--format",
+            "-f",
+            help=(
+                "Output data format (JSON only). Use --output-format for CLI "
+                "presentation style (rich/json/yaml/plain)."
+            ),
+        ),
+    ] = None,
     output_format: Annotated[
         str | None,
         typer.Option(
@@ -588,6 +585,13 @@ def export_session(
         agents session export 01HXYZ... -o session.json --force
         agents session export 01HXYZ... --output-format json
     """
+    # CLI export produces JSON data only — reject incompatible data formats.
+    if fmt is not None and fmt != "json":
+        console.print(
+            f"[red]Error:[/red] Invalid format {fmt!r}. "
+            "CLI export supports JSON only. Use the TUI for Markdown export."
+        )
+        raise typer.Exit(1)
     structured_output = output_format in ("json", "yaml", "plain")
     try:
         service = _get_session_service()
@@ -616,9 +620,9 @@ def export_session(
             envelope_data: dict[str, Any] = {
                 "session_id": session_id,
                 "output": str(output) if output is not None else None,
-                "format": fmt,
-                "messages_exported": len(json_data.get("messages", [])),
-                "schema_version": json_data.get("schema_version", "v1"),
+                "format": output_format,
+                "messages_exported": len(data.get("messages", [])),
+                "schema_version": data.get("schema_version", "v1"),
             }
             typer.echo(
                 format_output(
@@ -628,15 +632,6 @@ def export_session(
                     messages=[{"level": "ok", "text": "Export completed"}],
                 )
             )
-        else:
-            # Render Rich panels for both file and stdout export paths
-            _render_export_panels(
-                session_id=session_id,
-                output=output,
-                content=content,
-                export_data=json_data,
-                fmt=fmt,
-            )
 
     except SessionNotFoundError as exc:
         console.print(f"[red]Session not found:[/red] {session_id}")
@@ -693,8 +688,8 @@ def import_session(
                 "session_id": session.session_id,
                 "input": str(input_file),
                 "message_count": session.message_count,
-                "schema_version": schema_version,
-                "actor_ref": "resolved" if actor_name else "none",
+                "schema_version": data.get("schema_version", "v1"),
+                "actor_ref": "resolved" if data.get("actor_name") else "none",
             }
             typer.echo(
                 format_output(