okstra 0.180.0 → 0.183.2

package/runtime/python/okstra_ctl/set_work_status.py

@@ -15,7 +15,9 @@ from datetime import datetime, timezone
 from pathlib import Path
 
 from okstra_ctl.ids import slugify_task_segment
+from okstra_ctl.fixed_text import line, scalar
 from okstra_ctl.paths import task_dir, task_manifest_file
+from okstra_ctl.json_boundary import load_owned_object, write_owned_object_atomic
 from okstra_project import (
     ResolverError,
     StateError,
@@ -26,8 +28,23 @@ from okstra_project import (
 ALLOWED_WORK_STATUSES = ("todo", "in-progress", "blocked", "done")
 
 
-def _emit(payload: dict) -> None:
-    print(json.dumps(payload, ensure_ascii=False, indent=2))
+def _emit(payload: dict, *, text: bool = False) -> None:
+    if not text:
+        print(json.dumps(payload, ensure_ascii=False, indent=2))
+        return
+    lines = ["# Okstra Work Status Result", ""]
+    for key, label in (
+        ("ok", "OK"), ("stage", "Stage"), ("reason", "Reason"),
+        ("taskKey", "Task key"), ("previousWorkStatus", "Previous work status"),
+        ("workStatus", "Work status"), ("workStatusUpdatedAt", "Updated at"),
+        ("workStatusNote", "Note"), ("taskManifestPath", "Task manifest"),
+    ):
+        if key in payload:
+            lines.append(line(label, payload.get(key)).rstrip("\n"))
+    for match in payload.get("matches", []) if isinstance(payload.get("matches"), list) else []:
+        if isinstance(match, dict):
+            lines.append(f"- Match: `{scalar(match.get('taskKey'))}`")
+    print("\n".join(lines))
 
 
 def _manifest_path(project_root: Path, entry: dict) -> Path:
@@ -44,7 +61,7 @@ def _manifest_path(project_root: Path, entry: dict) -> Path:
     return task_manifest_file(task_dir(project_root, group_seg, id_seg))
 
 
-def main(argv: list[str] | None = None) -> int:
+def _parse_args(argv: list[str] | None):
     parser = argparse.ArgumentParser(
         description="Set a task's user-managed workStatus in task-manifest.json."
     )
@@ -64,13 +81,16 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument("--project-root", default="", help="project root for catalog lookup")
     parser.add_argument("--cwd", default=".", help="cwd for project root resolution")
     parser.add_argument("--json", action="store_true", help="emit JSON (always on)")
-    args = parser.parse_args(argv)
+    parser.add_argument("--text", action="store_true", help="emit fixed text fields")
+    return parser.parse_args(argv)
+
 
+def _resolve_entry(args):
     try:
         project_root = resolve_project_root(explicit_root=args.project_root, cwd=args.cwd)
     except ResolverError as exc:
-        _emit({"ok": False, "stage": "resolve", "reason": str(exc)})
-        return 2
+        _emit({"ok": False, "stage": "resolve", "reason": str(exc)}, text=args.text)
+        return None, None, 2
 
     token = args.token
     task_group = args.task_group
@@ -84,17 +104,42 @@ def main(argv: list[str] | None = None) -> int:
             project_root, token, task_group=task_group or None
         )
     except StateError as exc:
-        _emit({"ok": False, "stage": "catalog", "reason": str(exc)})
-        return 2
+        _emit({"ok": False, "stage": "catalog", "reason": str(exc)}, text=args.text)
+        return None, None, 2
 
     if not matches:
-        _emit({"ok": False, "stage": "not-found", "token": args.token})
-        return 1
+        _emit({"ok": False, "stage": "not-found", "token": args.token}, text=args.text)
+        return None, None, 1
     if len(matches) > 1:
-        _emit({"ok": False, "stage": "ambiguous", "matches": matches})
-        return 2
+        _emit({"ok": False, "stage": "ambiguous", "matches": matches}, text=args.text)
+        return None, None, 2
+    return project_root, matches[0], 0
+
+
+def _updated_payload(manifest_path: Path, manifest: dict, entry: dict, args) -> dict:
+    previous = manifest.get("workStatus", "")
+    manifest["workStatus"] = args.status
+    manifest["workStatusUpdatedAt"] = datetime.now(timezone.utc).strftime(
+        "%Y-%m-%dT%H:%M:%SZ"
+    )
+    if args.note is not None:
+        manifest["workStatusNote"] = args.note
+    write_owned_object_atomic(manifest_path, manifest, artifact="task manifest")
+    return {
+        "ok": True, "taskKey": entry.get("taskKey", ""),
+        "previousWorkStatus": previous, "workStatus": args.status,
+        "workStatusUpdatedAt": manifest["workStatusUpdatedAt"],
+        "workStatusNote": manifest.get("workStatusNote", ""),
+        "taskManifestPath": str(manifest_path),
+    }
 
-    entry = matches[0]
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parse_args(argv)
+    project_root, entry, resolution_exit = _resolve_entry(args)
+    if resolution_exit:
+        return resolution_exit
+    assert project_root is not None and entry is not None
     manifest_path = _manifest_path(project_root, entry)
     if not manifest_path.exists():
         _emit(
@@ -103,11 +148,12 @@ def main(argv: list[str] | None = None) -> int:
                 "stage": "manifest-missing",
                 "taskKey": entry.get("taskKey", ""),
                 "taskManifestPath": str(manifest_path),
-            }
+            },
+            text=args.text,
         )
         return 1
     try:
-        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+        manifest = load_owned_object(manifest_path, artifact="task manifest")
     except ValueError as exc:
         _emit(
             {
@@ -115,32 +161,12 @@ def main(argv: list[str] | None = None) -> int:
                 "stage": "manifest-invalid",
                 "taskManifestPath": str(manifest_path),
                 "reason": str(exc),
-            }
+            },
+            text=args.text,
         )
         return 1
 
-    previous = manifest.get("workStatus", "")
-    manifest["workStatus"] = args.status
-    manifest["workStatusUpdatedAt"] = datetime.now(timezone.utc).strftime(
-        "%Y-%m-%dT%H:%M:%SZ"
-    )
-    if args.note is not None:
-        manifest["workStatusNote"] = args.note
-    manifest_path.write_text(
-        json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
-    )
-
-    _emit(
-        {
-            "ok": True,
-            "taskKey": entry.get("taskKey", ""),
-            "previousWorkStatus": previous,
-            "workStatus": args.status,
-            "workStatusUpdatedAt": manifest["workStatusUpdatedAt"],
-            "workStatusNote": manifest.get("workStatusNote", ""),
-            "taskManifestPath": str(manifest_path),
-        }
-    )
+    _emit(_updated_payload(manifest_path, manifest, entry, args), text=args.text)
     return 0
 
 

package/runtime/python/okstra_ctl/stage_fix_carry.py

@@ -14,6 +14,8 @@ import subprocess
 from dataclasses import dataclass
 from pathlib import Path
 
+from .json_boundary import JsonBoundaryError, load_owned_object
+
 _REPORT_RE = re.compile(r"final-report-implementation-(\d+)\.data\.json$")
 
 
@@ -60,8 +62,8 @@ def derive_stage_fix_carry(
     if report is None:
         return None
     try:
-        data = json.loads(report.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
+        data = load_owned_object(report, artifact="implementation final report")
+    except (OSError, JsonBoundaryError):
         return None
     impl = data.get("implementation")
     if not isinstance(impl, dict):

package/runtime/python/okstra_ctl/stage_map.py

@@ -8,6 +8,8 @@ from pathlib import Path
 from typing import Any, Iterable
 
 from .final_report_paths import final_report_data_path, is_full_reading_copy_path
+from .json_boundary import JsonBoundaryError, load_owned_object
+from .fixed_text import line, value_lines
 from .md_table import is_separator_row, split_pipe_row
 from .paths import RunRef
 from .plan_run_root import list_implementation_planning_reports
@@ -48,6 +50,24 @@ class StageMapSnapshot:
     stages: list[dict[str, Any]]
 
 
+def render_stage_map_text(payload: dict[str, Any]) -> str:
+    """모델 소비용 Stage Map 스냅샷을 고정 텍스트로 투영한다."""
+    rows = ["Okstra stage map\n"]
+    rows.append(line("Status", "ready" if payload.get("ok") else "error"))
+    for label, key in (
+        ("Task key", "taskKey"), ("Task root", "taskRoot"),
+        ("State", "state"), ("Source plan path", "sourcePlanPath"),
+    ):
+        rows.append(line(label, payload.get(key)))
+    for label, key in (("Stages", "stages"), ("Done stages", "doneStages"),
+                       ("Planning", "planning")):
+        rows.extend(value_lines(label, payload.get(key)))
+    if not payload.get("ok"):
+        rows.append(line("Failure stage", payload.get("stage")))
+        rows.append(line("Failure reason", payload.get("reason")))
+    return "".join(rows)
+
+
 # `stepwiseExecution` is what the stage DOES; the other three are what becomes
 # true when it is finished. A schedule carrying only the latter reads as an
 # analysis of a plan rather than the plan itself.
@@ -354,8 +374,8 @@ def parse_stage_map_file(plan_path: Path) -> list[StageMapStage]:
     resolved = Path(plan_path).resolve()
     if is_report_record_path(resolved):
         try:
-            data = json.loads(resolved.read_text(encoding="utf-8"))
-        except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+            data = load_owned_object(resolved, artifact="planning final report")
+        except (OSError, UnicodeError, JsonBoundaryError) as exc:
             raise StageMapError("stage_map", str(exc), str(resolved)) from exc
         if not isinstance(data, dict):
             raise StageMapError(
@@ -379,8 +399,8 @@ def structured_report(plan_path: Path) -> dict[str, Any]:
     if not is_report_record_path(resolved) or not resolved.exists():
         return {}
     try:
-        data = json.loads(resolved.read_text(encoding="utf-8"))
-    except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+        data = load_owned_object(resolved, artifact="planning final report")
+    except (OSError, UnicodeError, JsonBoundaryError) as exc:
         raise StageMapError("stage_map", str(exc), str(resolved)) from exc
     if not isinstance(data, dict) or data.get("schemaVersion") not in {"2.0", "3.0"}:
         return {}
@@ -518,8 +538,8 @@ def _unique_carry_source_paths(task_root: Path) -> list[Path]:
     paths: set[Path] = set()
     for carry_path in sorted(carry_dir.glob("stage-*.json")):
         try:
-            carry = json.loads(carry_path.read_text(encoding="utf-8"))
-        except (OSError, UnicodeError, json.JSONDecodeError):
+            carry = load_owned_object(carry_path, artifact="implementation stage carry")
+        except (OSError, UnicodeError, JsonBoundaryError):
             continue
         value = carry.get("sourcePlanPath") if isinstance(carry, dict) else None
         if isinstance(value, str) and value:

package/runtime/python/okstra_ctl/stage_targets.py

@@ -853,18 +853,17 @@ def integrate_and_teardown_whole_task(
     stage_map 은 done 행에서 만든다. 정리 대상은 완료된 stage 뿐이고, 계획에만 있고
     완료되지 않은 stage 는 Phase A 가 어차피 건너뛰기 때문이다.
     """
-    from json import loads as _loads
-
     from okstra_project.dirs import okstra_home, project_json_path
 
     from . import consumers, worktree_registry
+    from .json_boundary import load_owned_object
     from .locks import worktree_provision_mutex
     from .paths import task_runs_dir
     from .stage_integrate import integrate_stages
 
     try:
-        project_id = _loads(
-            project_json_path(project_root).read_text(encoding="utf-8")
+        project_id = load_owned_object(
+            project_json_path(project_root), artifact="project config"
         ).get("projectId", "")
     except (OSError, ValueError):
         project_id = ""

package/runtime/python/okstra_ctl/team.py

@@ -39,6 +39,7 @@ from .ports.worker_dispatch import WorkerDispatchRequest
 from .registry.host_registry import default_host_registry
 from .registry.provider_registry import default_provider_registry
 from .session import observe_lead_session
+from .json_boundary import load_owned_object
 
 
 _SUPPORTED_WRAPPERS = provider_worker_wrappers(default_provider_registry())
@@ -417,7 +418,7 @@ def _load_manifest(project_root: str, run_manifest: str) -> dict[str, Any]:
 def _load_json(path: Path, label: str) -> dict[str, Any]:
     if not path.is_file():
         raise DispatchError(f"{label} not found: {path}")
-    payload = json.loads(path.read_text(encoding="utf-8"))
+    payload = load_owned_object(path, artifact=label)
     if not isinstance(payload, dict):
         raise DispatchError(f"{label} must be a JSON object: {path}")
     return payload

package/runtime/python/okstra_ctl/team_reconcile.py

@@ -36,6 +36,11 @@ import tempfile
 from pathlib import Path
 
 from okstra_ctl.session import resolve_inproc_lead_session_id
+from okstra_ctl.json_boundary import (
+    JsonBoundaryError,
+    external_claude_team_json_source,
+    load_external_json,
+)
 
 
 def live_pane_ids() -> tuple[bool, set[str]]:
@@ -148,8 +153,12 @@ def _reconcile_config(cfg_path: Path, dry_run: bool, print_members: bool) -> int
     line per non-lead member so the lead knows whom to ``shutdown_request``.
     """
     try:
-        config = json.loads(cfg_path.read_text())
-    except (OSError, json.JSONDecodeError) as exc:
+        # 외부 입력: Claude Code가 소유하는 team roster 설정이다.
+        config = load_external_json(
+            external_claude_team_json_source(cfg_path),
+            artifact="Claude team configuration",
+        )
+    except JsonBoundaryError as exc:
         print(f"team-reconcile: cannot read team config at {cfg_path}: {exc}",
               file=sys.stderr)
         return 1

package/runtime/python/okstra_ctl/time_report.py

@@ -14,7 +14,10 @@ import json
 import sys
 from pathlib import Path
 
+from .fixed_text import line as _text_line
+
 from okstra_ctl.paths import resolve_under_root, task_timeline_file
+from okstra_ctl.json_boundary import load_owned_object
 from okstra_project import read_task_key
 from okstra_ctl.task_target import resolve_task_root
 
@@ -25,7 +28,7 @@ def time_rows_with_identity(run_root: Path) -> list[dict]:
 
     state_path = run_root / "state" / "team-state.json"
     try:
-        state = json.loads(state_path.read_text(encoding="utf-8"))
+        state = load_owned_object(state_path, artifact="team state")
     except (OSError, ValueError):
         return []
     return identity_rows_from_state(state if isinstance(state, dict) else {})
@@ -34,7 +37,7 @@ def time_rows_with_identity(run_root: Path) -> list[dict]:
 def load_runs(task_root: Path) -> tuple[list[dict], bool]:
     path = task_timeline_file(task_root)
     try:
-        data = json.loads(path.read_text(encoding="utf-8"))
+        data = load_owned_object(path, artifact="task timeline")
     except (OSError, ValueError):
         return [], True
     runs = data.get("runs", []) if isinstance(data, dict) else []
@@ -96,7 +99,7 @@ def _read_state(project_root: Path, rel: str) -> dict | None:
     if target is None:
         return None
     try:
-        state = json.loads(target.read_text(encoding="utf-8"))
+        state = load_owned_object(target, artifact="team state")
     except (OSError, ValueError):
         return None
     return state if isinstance(state, dict) else None
@@ -211,6 +214,48 @@ def aggregate_time(runs: list[dict], project_root: Path) -> dict:
     }
 
 
+def _worker_text(result: dict) -> str:
+    parts: list[str] = []
+    workers = result.get("perWorker")
+    if not isinstance(workers, dict):
+        return ""
+    for task_type, rows in workers.items():
+        for row in rows if isinstance(rows, list) else []:
+            if isinstance(row, dict):
+                parts.extend(("\n## Worker\n\n", _text_line("Task type", task_type), _text_line("Worker ID", row.get("workerId")), _text_line("Agents", ",".join(row.get("agents", [])) if isinstance(row.get("agents"), list) else None), _text_line("Runs", row.get("runs")), _text_line("Total ms", row.get("totalMs")), _text_line("Average ms", row.get("avgMs"))))
+    return "".join(parts)
+
+
+def _timeline_text(result: dict) -> str:
+    parts: list[str] = []
+    for row in result.get("perRunWallClock", []):
+        if isinstance(row, dict):
+            parts.extend(("\n## Run wall clock\n\n", _text_line("Run timestamp", row.get("runTimestamp")), _text_line("Task type", row.get("taskType")), _text_line("Wall clock ms", row.get("wallClockMs"))))
+    for timeline in result.get("phaseTimelines", []):
+        if not isinstance(timeline, dict):
+            continue
+        for phase in timeline.get("phases", []):
+            if isinstance(phase, dict):
+                parts.extend(("\n## Phase\n\n", _text_line("Run timestamp", timeline.get("runTimestamp")), _text_line("Task type", timeline.get("taskType")), _text_line("Phase", phase.get("phase")), _text_line("First at", phase.get("firstAt")), _text_line("Wall ms to next", phase.get("wallMsToNext"))))
+    return "".join(parts)
+
+
+def render_result_text(result: dict) -> str:
+    parts = ["# Okstra Time Input\n\n", _text_line("Task key", result.get("taskKey"))]
+    total = result.get("grandTotal") if isinstance(result.get("grandTotal"), dict) else {}
+    for key, label in (("runs", "Total runs"), ("leadMs", "Total lead ms"), ("workersMs", "Total workers ms"), ("cpuSumMs", "Total CPU sum ms")):
+        parts.append(_text_line(label, total.get(key)))
+    for row in result.get("byTaskType", []):
+        if not isinstance(row, dict):
+            continue
+        parts.extend(("\n## Task type\n\n", _text_line("Task type", row.get("taskType")), _text_line("Runs", row.get("runs")), _text_line("Lead ms", row.get("leadMs")), _text_line("Workers ms", row.get("workersMs")), _text_line("CPU sum ms", row.get("cpuSumMs"))))
+    parts.extend((_worker_text(result), _timeline_text(result)))
+    for row in result.get("unavailable", []):
+        if isinstance(row, dict):
+            parts.extend(("\n## Unavailable run\n\n", _text_line("Run timestamp", row.get("runTimestamp")), _text_line("Task type", row.get("taskType")), _text_line("Reason", row.get("reason"))))
+    return "".join(parts)
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(
         prog="okstra time-report",
@@ -219,13 +264,15 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument("--project-root", default="")
     parser.add_argument("--cwd", default=".")
     parser.add_argument("--json", action="store_true", help="emit JSON (always on)")
+    parser.add_argument("--text", action="store_true", help="emit fixed text fields")
     args = parser.parse_args(argv)
 
     task_root, project_root = resolve_task_root(args.target, args.project_root, args.cwd)
     runs, _ = load_runs(task_root)
     result = {"ok": True, "taskKey": read_task_key(task_root)}
     result.update(aggregate_time(runs, project_root))
-    print(json.dumps(result, ensure_ascii=False, indent=2))
+    output = render_result_text(result) if args.text else json.dumps(result, ensure_ascii=False, indent=2)
+    print(output, end="" if args.text else "\n")
     return 0
 
 

package/runtime/python/okstra_ctl/usage_identity.py

@@ -13,6 +13,7 @@ from .execution_identity import (
     stored_identity,
 )
 from .execution_manifest import read_execution_manifest
+from .json_boundary import load_owned_object
 
 
 def run_execution_manifest(run_root: Path) -> ExecutionManifest:
@@ -83,4 +84,4 @@ def _manifest_path(run_root: Path) -> Path:
 
 
 def _load_json(path: Path) -> dict[str, Any]:
-    return json.loads(path.read_text(encoding="utf-8"))
+    return load_owned_object(path, artifact="usage identity source")

package/runtime/python/okstra_ctl/usage_report.py

@@ -14,6 +14,8 @@ from okstra_ctl.time_report import (
     wall_clock_ms,
     load_runs,
 )
+from okstra_ctl.json_boundary import load_owned_object
+from okstra_ctl.fixed_text import line
 from okstra_project import ResolverError, list_project_tasks, resolve_project_root
 
 UTC = dt.timezone.utc
@@ -43,8 +45,8 @@ def _parse_timestamp(value: Any) -> dt.datetime | None:
 
 def _project_id(project_root: Path) -> str:
     try:
-        data = json.loads(
-            (project_root / ".okstra" / "project.json").read_text(encoding="utf-8")
+        data = load_owned_object(
+            project_root / ".okstra" / "project.json", artifact="project config"
         )
     except (OSError, ValueError):
         return ""
@@ -214,6 +216,9 @@ def build_usage_report(project_root: Path, days: int, now: dt.datetime) -> dict:
     rows = sorted(buckets.values(), key=lambda row: row["firstRunAt"])
     for row in rows:
         row["costUsd"] = round(_float_value(row["costUsd"]), 4)
+        row["collectionRate"] = (
+            row["collectedRuns"] / row["runs"] if row["runs"] else 0.0
+        )
     totals = {
         "runs": total_runs,
         "collectedRuns": collected_runs,
@@ -264,18 +269,67 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument("--project-root", default="")
     parser.add_argument("--cwd", default=".")
     parser.add_argument("--json", action="store_true", help="emit JSON (always on)")
+    parser.add_argument("--text", action="store_true", help="emit fixed text fields")
     args = parser.parse_args(argv)
     try:
         project_root = Path(
             resolve_project_root(explicit_root=args.project_root, cwd=args.cwd)
         ).resolve()
     except ResolverError as exc:
-        print(json.dumps({"ok": False, "stage": "resolve", "reason": str(exc)}))
+        payload = {"ok": False, "stage": "resolve", "reason": str(exc)}
+        print(render_usage_text(payload) if args.text else json.dumps(payload))
         return 2
     result = build_usage_report(project_root, args.days, utc_now())
-    print(json.dumps(result, ensure_ascii=False, indent=2))
+    print(
+        render_usage_text(result)
+        if args.text
+        else json.dumps(result, ensure_ascii=False, indent=2)
+    )
     return 0
 
 
+def render_usage_text(payload: dict) -> str:
+    """usage 모델 표면에 승인된 집계만 고정 순서로 투영한다."""
+    rows = ["Okstra usage\n"]
+    rows.append(line("Status", "ready" if payload.get("ok") else "error"))
+    rows.append(line("Project ID", payload.get("projectId")))
+    period = payload.get("range") if isinstance(payload.get("range"), dict) else {}
+    rows.append(line("Range days", period.get("days")))
+    runs = payload.get("runs") if isinstance(payload.get("runs"), dict) else {}
+    rows.append(line("Runs total", runs.get("total")))
+    rows.append(line("Runs collected", runs.get("collected")))
+    rows.append(line("Runs collection rate", runs.get("collectionRate")))
+    task_types = payload.get("byTaskType") if isinstance(payload.get("byTaskType"), list) else []
+    for index, item in enumerate(task_types, 1):
+        if not isinstance(item, dict):
+            continue
+        rows.append(line(f"Task type {index} name", item.get("taskType")))
+        rows.append(line(f"Task type {index} runs", item.get("runs")))
+        rows.append(line(f"Task type {index} collected runs", item.get("collectedRuns")))
+        rows.append(line(f"Task type {index} collection rate", item.get("collectionRate")))
+        rows.append(line(f"Task type {index} raw tokens", item.get("rawTokens")))
+        rows.append(line(f"Task type {index} billable tokens", item.get("billableTokens")))
+        rows.append(line(f"Task type {index} cost USD", item.get("costUsd")))
+        rows.append(line(f"Task type {index} CPU sum ms", item.get("cpuSumMs")))
+        rows.append(line(f"Task type {index} wall clock ms", item.get("wallClockMs")))
+    totals = payload.get("totals") if isinstance(payload.get("totals"), dict) else {}
+    for label, key in (("Raw tokens", "rawTokens"), ("Billable tokens", "billableTokens"),
+                       ("Cost USD", "costUsd"), ("CPU sum ms", "cpuSumMs"),
+                       ("Wall clock ms", "wallClockMs")):
+        rows.append(line(label, totals.get(key)))
+    for prefix, key in (("Unavailable", "unavailable"), ("Warning", "warnings")):
+        values = payload.get(key) if isinstance(payload.get(key), dict) else {}
+        for index, (name, count) in enumerate(sorted(values.items()), 1):
+            rows.append(line(f"{prefix} {index} reason", name))
+            rows.append(line(f"{prefix} {index} count", count))
+    models = payload.get("unmatchedModels") if isinstance(payload.get("unmatchedModels"), list) else []
+    for index, model in enumerate(models, 1):
+        rows.append(line(f"Unmatched model {index} name", model))
+    if not payload.get("ok"):
+        rows.append(line("Failure stage", payload.get("stage")))
+        rows.append(line("Failure reason", payload.get("reason")))
+    return "".join(rows)
+
+
 if __name__ == "__main__":
     raise SystemExit(main(sys.argv[1:]))