codeer-cli 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

codeer_cli/_http_contracts.py

@@ -0,0 +1,109 @@
+"""HTTP input *configuration* checks; value conversion belongs to the server.
+
+Key generation follows collect_http_request_agent_placeholders in the backend's
+http_request/execution.py. Keep its traversal and collision rules in sync.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+
+_AGENT_PLACEHOLDER_RE = re.compile(r"\{\{\s*agent\[(.*?)\]\s*\}\}")
+_CONTRACT_FIELDS = {
+    "type": ("string", "number", "integer", "boolean", "object", "array"),
+    "format": ("text", "json"),
+    "json_type": ("any", "object", "array"),
+}
+
+
+def _contract_defaults(contract: Any, key: str) -> dict[str, str]:
+    prefix = f"input_contracts[{key!r}]"
+    if not isinstance(contract, dict):
+        raise ValueError(f"{prefix} must be an object.")
+    if any(field not in _CONTRACT_FIELDS for field in contract):
+        raise ValueError(
+            f"{prefix} accepts only type, format, json_type (snake_case, not jsonType)."
+        )
+    resolved = {}
+    for field, choices in _CONTRACT_FIELDS.items():
+        value = contract.get(field, choices[0])
+        if not isinstance(value, str) or value not in choices:
+            raise ValueError(f"{prefix}.{field} must be one of: {', '.join(choices)}.")
+        resolved[field] = value
+    if resolved["format"] == "json" and resolved["type"] != "string":
+        raise ValueError(f"{prefix}: format=json is only available for type=string.")
+    if resolved["format"] != "json" and resolved["json_type"] != "any":
+        raise ValueError(f"{prefix}: json_type requires format=json unless it is any.")
+    return resolved
+
+
+def validate_http_input_contracts(body: Any) -> list[dict[str, Any]]:
+    """Validate without mutation and return value-free input format summaries.
+
+    An omitted body is supplied as {} by callers; template may be null/absent.
+    Unconfigured placeholders retain string/text/any, including mixed text.
+    Unknown body fields follow the backend's existing ignore policy, except the
+    frontend alias inputContracts: reject it rather than silently losing intent.
+    Contract entries themselves are strict and reject all unknown fields.
+    """
+    if not isinstance(body, dict):
+        raise ValueError("body must be an object; omit it for no body.")
+    if "inputContracts" in body:
+        raise ValueError("use input_contracts (snake_case), not inputContracts.")
+    contracts = body.get("input_contracts", {})
+    if not isinstance(contracts, dict) or any(
+        not isinstance(key, str) for key in contracts
+    ):
+        raise ValueError("input_contracts must be an object with string keys.")
+    resolved = {
+        key: _contract_defaults(contract, key) for key, contract in contracts.items()
+    }
+    summaries: list[dict[str, Any]] = []
+    used_keys: set[str] = set()
+
+    def walk(value: Any, path: str) -> None:
+        if isinstance(value, dict):
+            for key, item in value.items():
+                walk(item, f"{path}.{key}" if path else key)
+            return
+        if isinstance(value, list):
+            for index, item in enumerate(value):
+                walk(item, f"{path}[{index}]")
+            return
+        if not isinstance(value, str):
+            return
+
+        matches = list(_AGENT_PLACEHOLDER_RE.finditer(value))
+        for index, match in enumerate(matches):
+            if not match.group(1).strip():
+                raise ValueError("Agent placeholder instruction cannot be empty.")
+            base = (
+                re.sub(r"[^a-zA-Z0-9]+", "_", path or "body").strip("_").lower()
+                or "body"
+            )
+            if len(matches) > 1:
+                base = f"{base}_{index + 1}"
+            key = base
+            suffix = 2
+            while key in used_keys:
+                key = f"{base}_{suffix}"
+                suffix += 1
+            used_keys.add(key)
+            contract = resolved.get(key) or _contract_defaults({}, key)
+            if (contract["type"] != "string" or contract["format"] == "json") and (
+                len(matches) != 1 or match.group(0) != value
+            ):
+                raise ValueError(
+                    f"Input {key!r}: typed and JSON-text inputs must occupy the entire template value."
+                )
+            summaries.append({"key": key, **contract, "configured": key in contracts})
+
+    walk(body.get("template"), "")
+    if set(contracts) - used_keys:
+        raise ValueError(
+            "input_contracts contains keys that do not match current placeholders; "
+            "remove stale contracts or regenerate keys after changing template paths/order."
+        )
+    return summaries

codeer_cli/_validate.py

@@ -3,13 +3,15 @@
 These checks exist because the backend's form-schema validator is lenient
 (``extra="allow"``) and silently accepts unknown ``type`` strings, which then
 render as blank fields in the web builder. Catching the common mistakes here
-gives actionable errors before the PUT/POST round-trip.
+gives actionable errors before the PATCH/POST round-trip. HTTP input contracts
+also need strict configuration checks before a draft is saved.
 """
 
 from __future__ import annotations
 
 from typing import Any, Iterable
 
+from ._http_contracts import validate_http_input_contracts
 from .constants import (
     FORM_FIELD_TYPES,
     MAX_CALL_AGENT_TOOLS,
@@ -121,10 +123,14 @@ def _validate_single_tool(tool: dict[str, Any], index: int) -> None:
             raise ToolValidationError(f"{prefix}: call_agent tool requires agent_id.")
     elif tool_type == "http_request":
         cfg = tool.get("http_request")
-        if not cfg or not cfg.get("method") or not cfg.get("url_template"):
+        if not isinstance(cfg, dict) or not cfg.get("method") or not cfg.get("url_template"):
             raise ToolValidationError(
                 f"{prefix}: http_request tool requires http_request.method and http_request.url_template."
             )
+        try:
+            validate_http_input_contracts(cfg.get("body", {}))
+        except ValueError as exc:
+            raise ToolValidationError(f"{prefix}.http_request.body: {exc}") from None
 
 
 def _validate_form_schema(schema: Any, prefix: str) -> None:

codeer_cli/agents.py

@@ -66,7 +66,7 @@ def update(
     attachment_ids: Optional[List[str]] = None,
     human_handoff: Optional[dict[str, Any]] = None,
 ) -> dict:
-    """PUT creates a new AgentHistory snapshot (draft)."""
+    """PATCH replaces settings and creates a draft; unified_tools is the full list."""
     validated_tools = validate_unified_tools(unified_tools)
     validated_handoff = validate_human_handoff(human_handoff)
     body: dict[str, Any] = {

codeer_cli/cli.py

@@ -3,9 +3,9 @@
     codeer check
     codeer agent list|get|apply|diff|versions
     codeer model list
-    codeer kb list|files|upload|node-rename|node-delete|faq-list|faq-get|faq-create|faq-update|faq-delete
+    codeer kb list|files|export|upload|node-rename|node-delete|faq-list|faq-get|faq-create|faq-update|faq-delete
     codeer eval list|label-list|label-create|label-update|label-delete|case-update|case-delete|evaluators|evaluator-create|evaluator-update|run|export|reconcile|cases-apply|rubrics|rubrics-apply
-    codeer history list|get|conversations|negative-feedback|create|send
+    codeer history list|get|conversations|ai-drafts|negative-feedback|create|send
 """
 
 from __future__ import annotations
@@ -16,6 +16,7 @@ import sys
 
 from .client import AuthError, CodeerClient, CodeerError
 from .commands import check
+from .histories import HistoryExportError
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -31,6 +32,8 @@ Safe workflow for coding agents:
   codeer agent get <agent-id> --full
   codeer kb list
   codeer kb files --kb-id <kb-id>
+  codeer kb export --node-id <file-id> --file guide.md
+  codeer kb export --node-id <folder-id> --dir kb-export
   codeer eval list --agent <agent-id>
   codeer eval label-list
   codeer eval case-update --case <case-id> --input "..." --dry-run
@@ -125,6 +128,9 @@ Use --out <path> for large raw artifacts; stdout defaults to compact summaries.
 
     try:
         return args.func(args, client)
+    except HistoryExportError as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1
     except AuthError as e:
         print(f"auth: {e}", file=sys.stderr)
         return 3

codeer_cli/client.py

@@ -161,6 +161,7 @@ class CodeerClient:
         files: Any = None,
         data: Any = None,
         timeout: Optional[float] = None,
+        unwrap: bool = True,
     ) -> Any:
         url = _api_url(path, api_version=api_version)
         request_kwargs: dict[str, Any] = {}
@@ -186,7 +187,7 @@ class CodeerClient:
             ) from exc
         except httpx.RequestError as exc:
             raise self._transport_error(method_upper, path, exc) from exc
-        return self._parse(r)
+        return self._parse(r, unwrap=unwrap)
 
     def get(self, path: str, **kwargs: Any) -> Any:
         return self.request("GET", path, **kwargs)
@@ -290,7 +291,7 @@ class CodeerClient:
             },
         )
 
-    def _parse(self, r: httpx.Response) -> Any:
+    def _parse(self, r: httpx.Response, *, unwrap: bool = True) -> Any:
         text = r.text
         try:
             payload = r.json() if text else None
@@ -306,7 +307,7 @@ class CodeerClient:
         if isinstance(payload, dict) and "error_code" in payload and "data" in payload:
             if payload.get("error_code") not in (0, None):
                 raise CodeerError(r.status_code, payload.get("message") or "error", payload)
-            return payload["data"]
+            return payload["data"] if unwrap else payload
         return payload
 
     def _raise_for_error(self, status: int, payload: Any) -> None:

codeer_cli/commands/_util.py

@@ -34,7 +34,12 @@ NOISY_KEYS = {
 
 
 def strip_noisy_fields(value: Any) -> Any:
-    """Remove server/account metadata that is not useful for agent lifecycle work."""
+    """Simplify metadata on one API resource (or a list of resources).
+
+    Callers pass unwrapped resource records, not response envelopes. Nested
+    dictionaries are opaque content: templates, schemas, tool results and other
+    user data can legally contain any of the metadata names. Do not recurse.
+    """
     if isinstance(value, list):
         return [strip_noisy_fields(item) for item in value]
     if not isinstance(value, dict):
@@ -51,7 +56,7 @@ def strip_noisy_fields(value: Any) -> Any:
                 if item.get(k) is not None
             }
             continue
-        out[key] = strip_noisy_fields(item)
+        out[key] = item
     return out
 
 

codeer_cli/commands/agent.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from typing import Optional
 
 from .. import agents as agents_mod
+from .._http_contracts import validate_http_input_contracts
 from .._validate import validate_human_handoff, validate_unified_tools
 from ..client import CodeerClient
 from ._util import log, print_json, strip_noisy_fields, truncate, write_json
@@ -32,6 +33,7 @@ def register(subparsers):
         help="Read one agent. Defaults to summary; use --full for prompt/tool detail or --out for an artifact.",
     )
     p.add_argument("agent_id")
+    p.add_argument("--history", default=None, help="Read this exact AgentHistory UUID instead of the editable agent.")
     p.add_argument("--full", action="store_true",
                    help="Print stripped full agent config, including system_prompt and tools.")
     p.add_argument("--out", default=None,
@@ -41,8 +43,8 @@ def register(subparsers):
     # codeer agent apply --payload agent.json
     p = sub.add_parser("apply", help="Create or update agent from JSON payload; run --dry-run first")
     p.add_argument("--payload", required=True, help="Path to agent payload JSON")
-    p.add_argument("--agent-id", default=None, help="If set, PUT (update). Else POST (create).")
-    p.add_argument("--note", default="", help="version_note for PUT")
+    p.add_argument("--agent-id", default=None, help="If set, PATCH (update). Else POST (create).")
+    p.add_argument("--note", default="", help="version_note for PATCH")
     p.add_argument("--dry-run", action="store_true",
                    help="Validate payload and print intended mutation without writing server state.")
     p.add_argument("--out", default=None, help="Write result JSON to this file too")
@@ -61,13 +63,13 @@ def register(subparsers):
     # codeer agent versions --agent <id>
     p = sub.add_parser(
         "versions",
-        help="List version history. Defaults to version metadata only; use --out for full snapshots.",
+        help="List version metadata; use agent get --history <id> for a stored snapshot.",
     )
     p.add_argument("--agent", required=True)
     p.add_argument("--full", action="store_true",
-                   help="Add bounded prompt/tool size metadata; full snapshots still require --out.")
+                   help="Add prompt/tool size metadata when included by the server.")
     p.add_argument("--out", default=None,
-                   help="Write stripped full version snapshots to this file; stdout stays compact.")
+                   help="Write the full version listing (metadata, not snapshots); stdout stays compact.")
     p.set_defaults(func=run_versions)
 
     p = sub.add_parser("impact", help="Check downstream agents affected by this agent")
@@ -130,6 +132,8 @@ def _agent_summary(agent: dict, *, full: bool = False) -> dict:
         "human_handoff_enabled": bool(human_handoff.get("enabled")),
         "system_prompt_chars": len(agent.get("system_prompt") or ""),
     }
+    if "version_number" in agent:
+        row.update({key: agent.get(key) for key in ("agent_id", "version_number", "status")})
     if full:
         row["description"] = agent.get("description") or ""
         row["use_search"] = agent.get("use_search")
@@ -150,7 +154,11 @@ def run_list(args, client) -> int:
 
 
 def run_get(args, client) -> int:
-    result = agents_mod.get(client, args.agent_id)
+    history_id = getattr(args, "history", None)
+    result = (
+        agents_mod.get_version(client, args.agent_id, history_id)
+        if history_id else agents_mod.get(client, args.agent_id)
+    )
     full_result = strip_noisy_fields(result)
     write_json(args.out, full_result)
     print_json(full_result if args.full else _agent_summary(result))
@@ -183,6 +191,15 @@ def run_apply(args, client) -> int:
             "name": body.get("name"),
             "system_prompt_chars": len(body.get("system_prompt") or ""),
             "tool_count": len(validated_tools),
+            "http_inputs": [
+                {
+                    "tool_index": index,
+                    "body_inputs_used": tool["http_request"]["method"] not in ("GET", "HEAD"),
+                    "inputs": validate_http_input_contracts(tool["http_request"].get("body", {})),
+                }
+                for index, tool in enumerate(validated_tools)
+                if tool.get("type") == "http_request"
+            ],
             "use_search": body.get("use_search", False),
             "llm_model": body.get("llm_model"),
             "llm_model_settings_provided": llm_model_settings_provided,
@@ -223,7 +240,7 @@ def run_apply(args, client) -> int:
             **model_settings_kwargs,
         )
         agent_id = args.agent_id
-        log(f"PUT /agents/{agent_id} ok")
+        log(f"PATCH /agents/{agent_id} ok")
     else:
         if not body.get("workspace_id"):
             body["workspace_id"] = client.resolve_scope()[0]
@@ -274,8 +291,10 @@ def run_versions(args, client) -> int:
             "created_at": v.get("created_at"),
         }
         if args.full:
-            row["system_prompt_chars"] = len(v.get("system_prompt") or "")
-            row["tool_count"] = len(v.get("unified_tools") or v.get("tools") or [])
+            if "system_prompt" in v:
+                row["system_prompt_chars"] = len(v.get("system_prompt") or "")
+            if "unified_tools" in v or "tools" in v:
+                row["tool_count"] = len(v.get("unified_tools") or v.get("tools") or [])
         rows.append(row)
     print_json(rows)
     return 0
@@ -371,7 +390,9 @@ def _summarize_tool(t: dict) -> str:
                  "knowledge_node_ids", "domain", "agent_id",
                  "custom_form_schema", "http_request")
     safe = {k: t.get(k) for k in keep_keys if t.get(k) is not None}
-    return json.dumps(safe, ensure_ascii=False, indent=2, sort_keys=True)
+    # HTTP placeholder keys depend on template insertion order. Sorting would
+    # hide a reordering that changes which input receives a collision suffix.
+    return json.dumps(safe, ensure_ascii=False, indent=2, sort_keys=t.get("type") != "http_request")
 
 
 def run_diff(args, client) -> int:

codeer_cli/commands/history.py

@@ -23,6 +23,8 @@ def register(subparsers):
     p.add_argument("--agent", default=None)
     p.add_argument("--user", default=None, help="Filter by external_user_id")
     p.add_argument("--feedback", default=None, help="positive / negative / any")
+    p.add_argument("--has-ai-drafts", action="store_true",
+                   help="Only list histories with at least one AI Draft.")
     p.add_argument("--exclude-users", default=None,
                    help="Comma-separated external_user_ids to exclude")
     p.add_argument("--version", type=int, default=None,
@@ -48,15 +50,31 @@ def register(subparsers):
     # codeer history conversations <id>
     p = sub.add_parser(
         "conversations",
-        help="Summarize all Chat V2 parts in a history. Complete parts/tool payloads require --out.",
+        help="Summarize persisted History parts. Complete parts/tool payloads require --out.",
     )
     p.add_argument("history_id", type=int)
     p.add_argument("--full", action="store_true",
                    help="Require --out and include longer stdout previews; the artifact is always complete.")
     p.add_argument("--out", default=None,
-                   help="Write every unmodified client-visible Chat V2 part to this file.")
+                   help="Write every persisted part allowed by the selected export contract.")
+    p.add_argument("--client-visible", action="store_true",
+                   help="Use the external client-owner Chat V2 contract instead of the management export.")
+    p.add_argument("--user", default=None,
+                   help="external_user_id required with --client-visible.")
     p.set_defaults(func=run_conversations)
 
+    # codeer history ai-drafts <id>
+    p = sub.add_parser(
+        "ai-drafts",
+        help="Export every paginated AI Draft lifecycle record returned for one History.",
+    )
+    p.add_argument("history_id", type=int)
+    p.add_argument("--full", action="store_true",
+                   help="Require --out and opt into sensitive content previews on stdout.")
+    p.add_argument("--out", default=None,
+                   help="Write every AI Draft record, refinement signal, outcome, tool activity, and delivery.")
+    p.set_defaults(func=run_ai_drafts)
+
     # codeer history negative-feedback
     p = sub.add_parser("negative-feedback", help="Surface assistant turns with negative feedback")
     p.add_argument("--agent", required=True)
@@ -144,6 +162,15 @@ def _history_summary(row: dict, *, full: bool = False) -> dict:
         "feedback_counts": _feedback_counts(row),
         "snippet_preview": truncate(row.get("snippet") or "", 240),
     }
+    for key in (
+        "ai_draft_count",
+        "dismissed_draft_count",
+        "regenerated_draft_count",
+        "applied_draft_count",
+        "sent_from_ai_draft_count",
+    ):
+        if key in row:
+            out[key] = row.get(key)
     if full:
         out["share_type"] = row.get("share_type")
         meta = row.get("meta") or {}
@@ -158,10 +185,12 @@ def _history_summary(row: dict, *, full: bool = False) -> dict:
 
 def _part_summary(part: dict, idx: int, *, full: bool = False) -> dict:
     raw_content = part.get("content")
-    if isinstance(raw_content, dict):
+    part_kind = part.get("part_kind")
+    is_tool_part = part_kind in {"tool-call", "tool-return"}
+    if is_tool_part:
+        content_value = None
+    elif isinstance(raw_content, dict):
         content_value = raw_content.get("content")
-        if content_value is None and part.get("part_kind") == "tool-call":
-            content_value = raw_content.get("args")
     else:
         content_value = raw_content
     if isinstance(content_value, str):
@@ -176,7 +205,7 @@ def _part_summary(part: dict, idx: int, *, full: bool = False) -> dict:
         "conversation_id": part.get("conversation_id"),
         "conversation_group_id": part.get("conversation_group_id"),
         "sequence": part.get("sequence"),
-        "part_kind": part.get("part_kind"),
+        "part_kind": part_kind,
         "source": part.get("source"),
         "created_at": part.get("created_at"),
         "content_preview": truncate(content, 600 if full else 240),
@@ -184,6 +213,15 @@ def _part_summary(part: dict, idx: int, *, full: bool = False) -> dict:
         "attachment_count": len(part.get("attached_files") or []),
         "feedback_count": len(part.get("feedbacks") or []),
     }
+    if is_tool_part:
+        # Exact tool payloads belong in the artifact, never terminal previews.
+        row.pop("content_preview", None)
+    if is_tool_part and isinstance(raw_content, dict):
+        row.update({
+            "tool_name": raw_content.get("tool_name"),
+            "tool_call_id": raw_content.get("tool_call_id"),
+            "outcome": raw_content.get("outcome"),
+        })
     if full:
         row["feedbacks"] = [
             {
@@ -212,6 +250,7 @@ def run_list(args, client) -> int:
         organization_id=organization_id,
         external_user_id=args.user,
         feedback_filter=args.feedback,
+        has_ai_drafts=True if getattr(args, "has_ai_drafts", False) else None,
         exclude_users=exclude,
         limit=args.limit,
         offset=args.offset,
@@ -247,24 +286,118 @@ def run_get(args, client) -> int:
 
 
 def run_conversations(args, client) -> int:
-    result = chats_mod.list_messages(client, args.history_id)
-    parts = result.get("messages") or []
     if args.full and not args.out:
         log("error: full conversation payloads are unbounded; pass --out <path>")
         return 2
+    client_visible = bool(getattr(args, "client_visible", False))
+    external_user_id = getattr(args, "user", None)
+    if client_visible and not external_user_id:
+        log("error: --client-visible requires --user <external_user_id>")
+        return 2
+    if external_user_id and not client_visible:
+        log("error: --user is only valid with --client-visible")
+        return 2
+
+    if client_visible:
+        result = chats_mod.list_messages(
+            client,
+            args.history_id,
+            external_user_id=external_user_id,
+        )
+        export_mode = "client-visible"
+    else:
+        result = hist_mod.list_messages(client, args.history_id)
+        export_mode = "management"
+    parts = result.get("messages") or []
     write_json(args.out, result)
     group_ids = {
         p.get("conversation_group_id")
         for p in parts
         if p.get("conversation_group_id")
     }
+    stdout_limit = 50 if args.full else 20
+    shown_parts = parts[:stdout_limit]
     print_json({
         "history_id": args.history_id,
+        "export_mode": export_mode,
+        "export_contract": result.get("export_contract"),
+        "part_revision": result.get("part_revision"),
         "turn_count": len(group_ids),
         "part_count": len(parts),
+        "part_summaries_shown": len(shown_parts),
+        "part_summaries_truncated": len(parts) > len(shown_parts),
+        "wrote_full_detail": bool(args.out),
+        "stdout_is_summary": True,
+        "read_contract": result.get("export_contract") or "client-visible-chat-v2",
+        "provider_raw_trace": result.get("provider_raw_trace", "not_included"),
+        "missing_parts_do_not_prove_non_execution": True,
+        "omitted_part_summaries": len(parts) - len(shown_parts),
+        "parts": [_part_summary(p, i, full=args.full) for i, p in enumerate(shown_parts)],
+    })
+    return 0
+
+
+def _ai_draft_summary(draft: dict, *, full: bool = False) -> dict:
+    delivery = draft.get("delivery") or {}
+    row = {
+        "id": draft.get("id"),
+        "history_id": draft.get("history_id"),
+        "thread_key": draft.get("thread_key"),
+        "context_through_sequence": draft.get("context_through_sequence"),
+        "outcome": draft.get("outcome"),
+        "result_type": draft.get("result_type"),
+        "refinement_source_draft_id": draft.get("refinement_source_draft_id"),
+        "has_generation_instruction": bool(draft.get("generation_instruction")),
+        "dismiss_reason": draft.get("dismiss_reason"),
+        "has_dismiss_feedback": bool(draft.get("dismiss_feedback")),
+        "has_generated_content": bool(draft.get("content")),
+        "has_actual_content": bool(delivery.get("actual_content")),
+        "delivery_status": delivery.get("status"),
+        "tool_activity_count": len(draft.get("tool_activities") or []),
+        "has_proposed_actions": draft.get("proposed_actions") is not None,
+        "created_at": draft.get("created_at"),
+    }
+    if full:
+        row.update({
+            "generation_instruction_preview": truncate(draft.get("generation_instruction") or "", 600),
+            "dismiss_feedback_preview": truncate(draft.get("dismiss_feedback") or "", 600),
+            "content_preview": truncate(draft.get("content") or "", 600),
+            "actual_content_preview": truncate(delivery.get("actual_content") or "", 600),
+        })
+    return row
+
+
+def run_ai_drafts(args, client) -> int:
+    if args.full and not args.out:
+        log("error: AI Draft content previews require --out <path>")
+        return 2
+
+    result = hist_mod.list_ai_drafts(client, args.history_id)
+    drafts = result["drafts"]
+    write_json(args.out, result)
+    stdout_limit = 50 if args.full else 20
+    shown_drafts = drafts[:stdout_limit]
+    outcome_counts: dict[str, int] = {}
+    for draft in drafts:
+        outcome = str(draft.get("outcome") or "unknown")
+        outcome_counts[outcome] = outcome_counts.get(outcome, 0) + 1
+    print_json({
+        "history_id": args.history_id,
+        "draft_count": len(drafts),
+        "outcome_counts": outcome_counts,
+        "regenerated_draft_count": sum(
+            1 for draft in drafts if draft.get("refinement_source_draft_id") is not None
+        ),
+        "sent_from_ai_draft_count": sum(
+            1 for draft in drafts if (draft.get("delivery") or {}).get("status") == "sent"
+        ),
+        "draft_summaries_shown": len(shown_drafts),
+        "draft_summaries_truncated": len(drafts) > len(shown_drafts),
+        "pages_fetched": result["pages_fetched"],
+        "snapshot_consistency": result.get("snapshot_consistency", "best-effort"),
         "wrote_full_detail": bool(args.out),
         "stdout_is_summary": True,
-        "parts": [_part_summary(p, i, full=args.full) for i, p in enumerate(parts)],
+        "drafts": [_ai_draft_summary(draft, full=args.full) for draft in shown_drafts],
     })
     return 0