okstra 0.202.0 → 0.205.0

package/runtime/python/okstra_ctl/option_comparison.py

@@ -0,0 +1,168 @@
+"""구현 방향 비교 자료 — 선택 리포트 기록 하나를 채팅용 사실 묶음으로 투영한다.
+
+사용자가 방향을 고르기 전에 비교 자료를 청하면 리드는 점수표·투표표·충족
+요약을 보여 준다. 그 숫자는 전부 `implementationOptionSelection` 기록에 있고
+`weightedScore` 는 발행 시점에 재계산 값과 대조된다
+(`implementation_options.py` `_validate_option_scores`). 리드가 JSON 을 손으로
+읽고 가중 점수를 다시 계산하던 자리를 이 명령이 대신한다. 서술(도입 문장,
+방향별 요지)은 리드가 `narrative` 와 각 방향의 근거 필드로 쓴다.
+
+읽기 전용이다. 어떤 파일도 쓰지 않는다.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+from okstra_ctl import next_phase
+from okstra_ctl.final_report_paths import final_report_data_path
+from okstra_ctl.json_boundary import JsonBoundaryError, load_owned_object
+
+
+class OptionComparisonError(ValueError):
+    """비교 자료를 만들 수 없는 기록."""
+
+
+def _rows(value: object) -> list[Mapping[str, Any]]:
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes)):
+        return []
+    return [row for row in value if isinstance(row, Mapping)]
+
+
+def _text(value: object) -> str:
+    return value.strip() if isinstance(value, str) else ""
+
+
+def _count(value: object) -> int:
+    return len(value) if isinstance(value, Sequence) and not isinstance(value, str) else 0
+
+
+def _option(
+    option: Mapping[str, Any], recommended_id: str
+) -> dict[str, Any]:
+    coverage = option.get("coverageSummary")
+    coverage = coverage if isinstance(coverage, Mapping) else {}
+    scores = _rows(option.get("criterionScores"))
+    return {
+        "id": _text(option.get("id")),
+        "name": _text(option.get("name")),
+        "recommended": _text(option.get("id")) == recommended_id,
+        "goal": _text(option.get("goal")),
+        "coreMechanism": _text(option.get("coreMechanism")),
+        # 발행 검증이 재계산 값과 같음을 보장한 기록값이다. 다시 계산하지 않는다.
+        "weightedScore": option.get("weightedScore"),
+        "scores": {_text(row.get("criterion")): row.get("score") for row in scores},
+        "scoreRationales": {
+            _text(row.get("criterion")): _text(row.get("rationale")) for row in scores
+        },
+        "coverage": {
+            "verdict": _text(coverage.get("coverageVerdict")),
+            "coveredCount": coverage.get("coveredCount"),
+            "totalCount": coverage.get("totalCount"),
+            "requirementIds": [
+                _text(row.get("requirementId"))
+                for row in _rows(option.get("requirementCoverage"))
+                if _text(row.get("requirementId"))
+            ],
+        },
+        "safetyBlockers": _count(option.get("safetyBlockers")),
+        "unresolvedFeasibilityFacts": _count(option.get("unresolvedFeasibilityFacts")),
+        "votes": {
+            _text(vote.get("worker")): {
+                "verdict": _text(vote.get("verdict")),
+                "rationale": _text(vote.get("rationale")),
+                "counterevidence": _text(vote.get("counterevidence")),
+            }
+            for vote in _rows(option.get("feasibilityVotes"))
+            if _text(vote.get("worker"))
+        },
+    }
+
+
+def build_comparison(report_data: Mapping[str, Any]) -> dict[str, Any]:
+    """선택 리포트 기록 → 비교 자료 사실 묶음."""
+    selection = report_data.get("implementationOptionSelection")
+    if not isinstance(selection, Mapping):
+        raise OptionComparisonError(
+            "report has no implementationOptionSelection block; "
+            "pass an implementation-option-selection report record"
+        )
+    recommended_id = _text(selection.get("recommendedOptionId"))
+    options = [
+        _option(row, recommended_id) for row in _rows(selection.get("rankedOptions"))
+    ]
+    if not options:
+        raise OptionComparisonError("report ranks no direction; there is nothing to compare")
+    # 투표 열 순서는 처음 등장한 순서다 — 방향마다 같은 분석자 집합이 투표한다.
+    workers: list[str] = []
+    for option in options:
+        for worker in option["votes"]:
+            if worker not in workers:
+                workers.append(worker)
+    narrative = selection.get("userNarrative")
+    narrative = narrative if isinstance(narrative, Mapping) else {}
+    return {
+        "mode": _text(selection.get("mode")),
+        "routing": _text(selection.get("routing")),
+        "recommendedOptionId": recommended_id,
+        "criteria": [
+            {"criterion": _text(row.get("criterion")), "weight": row.get("weight")}
+            for row in _rows(selection.get("evaluationCriteria"))
+        ],
+        "workers": workers,
+        "options": options,
+        "narrative": {
+            key: _text(block.get("text"))
+            for key, block in narrative.items()
+            if isinstance(block, Mapping) and _text(block.get("text"))
+        },
+        # "남은 절차" 문단의 근거. 다음 phase 포인터와 같은 문장이다.
+        "nextStep": next_phase.project(report_data)["rationale"],
+    }
+
+
+def _load(report: Path) -> Mapping[str, Any]:
+    data_path = final_report_data_path(report)
+    try:
+        data = load_owned_object(data_path, artifact="implementation option data")
+    except (OSError, JsonBoundaryError) as exc:
+        raise OptionComparisonError(f"cannot read report record {data_path}: {exc}") from exc
+    return data
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="okstra option-comparison",
+        description=(
+            "Print the comparison facts of an implementation-option-selection "
+            "report as JSON: criteria and weights, per-direction scores and "
+            "recorded weighted score, requirement coverage, blocker counts, "
+            "per-worker feasibility votes, the report narrative, and the next step."
+        ),
+    )
+    parser.add_argument(
+        "--report",
+        required=True,
+        help="final-report-implementation-option-selection-<seq>.data.json (a .md sibling is accepted)",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        payload = build_comparison(_load(Path(args.report)))
+    except OptionComparisonError as exc:
+        print(f"option-comparison: {exc}", file=sys.stderr)
+        return 2
+    json.dump(payload, sys.stdout, ensure_ascii=False, indent=2)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/runtime/python/okstra_ctl/path_hints.py

@@ -64,6 +64,7 @@ def compact_active_run_context(
         "run": {
             "stage": ctx.get("RUN_STAGE", ""),
             "fixRunCarry": ctx.get("FIX_RUN_CONTEXT", ""),
+            "hostSessionContract": ctx.get("HOST_SESSION_CONTRACT_PATH", ""),
         },
         "agentContract": dict(_mapping(payload.get("agentContract"))),
         "inputs": _compact_active_inputs(payload),
@@ -118,8 +119,13 @@ def hydrate_active_run_context(payload: Mapping[str, Any]) -> dict[str, Any]:
                     "IMPLEMENTATION_WORKER_PREAMBLE_PATH", ""
                 ),
                 "report-writer": ctx.get("REPORT_WRITER_PREAMBLE_PATH", ""),
+                "translator": ctx.get("TRANSLATOR_PREAMBLE_PATH", ""),
             },
             "workerErrorContractPath": ctx.get("WORKER_ERROR_CONTRACT_PATH", ""),
+            "hostSessionContractPath": (
+                str(_mapping(payload.get("run")).get("hostSessionContract", ""))
+                or ctx.get("HOST_SESSION_CONTRACT_PATH", "")
+            ),
         },
         "executorWorktree": dict(_mapping(payload.get("executorWorktree"))),
         "verificationTarget": dict(_mapping(payload.get("verificationTarget"))),
@@ -509,6 +515,9 @@ def _runtime_fields(paths: Mapping[str, Any]) -> dict[str, str]:
         "REPORT_WRITER_PREAMBLE_PATH": str(
             runtime_home / "templates" / "report-writer-prompt-preamble.md"
         ),
+        "TRANSLATOR_PREAMBLE_PATH": str(
+            runtime_home / "templates" / "translator-prompt-preamble.md"
+        ),
         "WORKER_ERROR_CONTRACT_PATH": str(
             runtime_home / "templates" / "worker-error-contract.md"
         ),

package/runtime/python/okstra_ctl/paths.py

@@ -647,6 +647,9 @@ def compute_run_paths(
         "REPORT_WRITER_PREAMBLE_PATH": str(
             runtime_home / "templates" / "report-writer-prompt-preamble.md"
         ),
+        "TRANSLATOR_PREAMBLE_PATH": str(
+            runtime_home / "templates" / "translator-prompt-preamble.md"
+        ),
         "WORKER_ERROR_CONTRACT_PATH": str(
             runtime_home / "templates" / "worker-error-contract.md"
         ),

package/runtime/python/okstra_ctl/profile_show.py

@@ -19,6 +19,7 @@ import sys
 from pathlib import Path
 
 from .paths import find_asset_root
+from .role_requirements import RoleProfileError, load_role_profile
 from .run import PrepareError, _expand_profile_includes
 
 _PROFILES_REL = ("prompts", "profiles")
@@ -82,9 +83,49 @@ def sidecar_bodies(root: Path, profile_text: str) -> list[str]:
 def render(root: Path, task_type: str, *, resolved: bool) -> str:
     path = profile_path(root, task_type)
     if not resolved:
+        # 계약상 이 출력은 디스크의 파일 그대로다. 역할 구조는 이제 `.json` 에
+        # 있으므로 `--resolved` 가 렌더한다.
         return path.read_text(encoding="utf-8")
     expanded = _expand_profile_includes(path)
-    return expanded + "".join(sidecar_bodies(root, expanded))
+    body = expanded + "".join(sidecar_bodies(root, expanded))
+    return body + _role_requirements_section(path)
+
+
+def _role_requirements_section(profile_path: Path) -> str:
+    """Render the profile's role structure from its contract.
+
+    The structure moved out of the Markdown into the `.json` sibling, so a
+    reader of `okstra profile show` would otherwise no longer see which roles
+    the phase runs — which is most of what the command is read for.
+    """
+    try:
+        profile = load_role_profile(profile_path)
+    except RoleProfileError as exc:
+        return f"\n## Role requirements\n\nunavailable: {exc}\n"
+    if not profile.roles:
+        return "\n## Role requirements\n\nThis phase runs a single lead and no workers.\n"
+    lines = [
+        "",
+        "## Role requirements",
+        "",
+        "| Role | Duty | Count (min/recommended/max) | Activation |",
+        "|---|---|---|---|",
+    ]
+    for requirement in profile.roles:
+        if requirement.dynamic:
+            sources = ", ".join(f"`{role}`" for role in requirement.source_role_ids)
+            counts = f"one per activated {sources} slot"
+            activation = requirement.activation
+        else:
+            counts = (
+                f"{requirement.min_count} / {requirement.recommended_count} / "
+                f"{requirement.max_count}"
+            )
+            activation = "static"
+        lines.append(
+            f"| `{requirement.role}` | `{requirement.duty}` | {counts} | {activation} |"
+        )
+    return "\n".join(lines) + "\n"
 
 
 def _write_stdout(text: str) -> None:

package/runtime/python/okstra_ctl/registry/host_discovery.py

@@ -18,6 +18,8 @@ class HostManifest:
     native_provider_id: str
     required_executables: tuple[str, ...]
     relay_contract: Path
+    # 선언하지 않은 호스트는 None. 이 호스트 세션 안에서 도는 워커가 읽는 계약이다.
+    worker_session_contract: Path | None = None
 
 
 def discover_host_manifests(roots: Iterable[Path]) -> tuple[HostManifest, ...]:
@@ -54,7 +56,15 @@ def _read_manifest(manifest_path: Path) -> HostManifest:
     native_provider_id = _optional_id(raw, "nativeProviderId", manifest_path)
     required_executables = _string_tuple(raw, "requiredExecutables", manifest_path)
     relay_ref = _required_string(raw, "relayContract", manifest_path)
-    relay_contract = _resolve_relay_contract(manifest_path, relay_ref)
+    relay_contract = _resolve_adapter_file(manifest_path, relay_ref, "relay contract")
+    session_ref = raw.get("workerSessionContract")
+    if session_ref is not None and (not isinstance(session_ref, str) or not session_ref):
+        raise HostAdapterContractError(f"invalid host manifest: {manifest_path}")
+    worker_session_contract = (
+        _resolve_adapter_file(manifest_path, session_ref, "worker session contract")
+        if session_ref is not None
+        else None
+    )
     return HostManifest(
         path=manifest_path,
         host_id=host_id,
@@ -62,6 +72,7 @@ def _read_manifest(manifest_path: Path) -> HostManifest:
         native_provider_id=native_provider_id,
         required_executables=required_executables,
         relay_contract=relay_contract,
+        worker_session_contract=worker_session_contract,
     )
 
 
@@ -111,15 +122,12 @@ def _string_tuple(
     return tuple(value)
 
 
-def _resolve_relay_contract(manifest_path: Path, relay_ref: str) -> Path:
+def _resolve_adapter_file(manifest_path: Path, ref: str, label: str) -> Path:
+    """어댑터 디렉터리 안의 파일 하나를 해석한다. 밖을 가리키면 거절한다."""
     adapter_root = manifest_path.parent.resolve()
-    if Path(relay_ref).is_absolute():
-        raise HostAdapterContractError(
-            f"relay contract escapes adapter root: {relay_ref!r}"
-        )
-    relay_contract = (adapter_root / relay_ref).resolve()
-    if adapter_root not in relay_contract.parents or not relay_contract.is_file():
-        raise HostAdapterContractError(
-            f"relay contract escapes adapter root: {relay_ref!r}"
-        )
-    return relay_contract
+    if Path(ref).is_absolute():
+        raise HostAdapterContractError(f"{label} escapes adapter root: {ref!r}")
+    resolved = (adapter_root / ref).resolve()
+    if adapter_root not in resolved.parents or not resolved.is_file():
+        raise HostAdapterContractError(f"{label} escapes adapter root: {ref!r}")
+    return resolved

package/runtime/python/okstra_ctl/registry/host_registry.py

@@ -248,6 +248,15 @@ def _validated_descriptor(adapter: object, manifest: HostManifest) -> HostDescri
         raise HostAdapterContractError(
             f"relay contract mismatch for {manifest.host_id!r}"
         )
+    declared = (
+        Path(descriptor.worker_session_contract).resolve()
+        if descriptor.worker_session_contract
+        else None
+    )
+    if declared != manifest.worker_session_contract:
+        raise HostAdapterContractError(
+            f"worker session contract mismatch for {manifest.host_id!r}"
+        )
     return descriptor
 
 
@@ -286,6 +295,8 @@ def _copy_descriptor(raw: object, host_id: str) -> HostDescriptor:
             session_accounting=raw.session_accounting,
             has_claude_session=raw.has_claude_session,
             relay_contract=raw.relay_contract,
+            worker_session_contract=getattr(raw, "worker_session_contract", ""),
+            initial_prompt_delivery_mode=raw.initial_prompt_delivery_mode,
         )
     except (AttributeError, TypeError) as exc:
         raise HostAdapterContractError(

package/runtime/python/okstra_ctl/render.py

@@ -455,6 +455,10 @@ def _worker_assignments(ctx: dict) -> list[dict]:
             # 다른데 반환값만 봐서는 구별되지 않는다.
             print(f"render: WORKER_ASSIGNMENTS_JSON is not valid JSON, "
                   f"falling back to the worker catalog ({exc})", file=sys.stderr)
+    # 여기 도달하면 이 run 에는 해소된 배정이 없다 — 준비 경로는 언제나
+    # `WORKER_ASSIGNMENTS_JSON` 을 채운다(`run.py` `_model_tokens`). 남은 정보가
+    # 워커 id 뿐이라 역할을 복원할 수 없고, 아래 값은 분석 run 로스터의 모양을
+    # 가정한 것이다. 이 로스터로 implementation 프롬프트를 고를 수는 없다.
     catalog = _worker_catalog(ctx, include_assignments=False)
     return [
         {
@@ -690,9 +694,13 @@ def _active_runtime_resources(ctx: dict) -> dict:
             or str(runtime_home / "templates" / "implementation-worker-preamble.md"),
             "report-writer": ctx.get("REPORT_WRITER_PREAMBLE_PATH")
             or str(runtime_home / "templates" / "report-writer-prompt-preamble.md"),
+            "translator": ctx.get("TRANSLATOR_PREAMBLE_PATH")
+            or str(runtime_home / "templates" / "translator-prompt-preamble.md"),
         },
         "workerErrorContractPath": ctx.get("WORKER_ERROR_CONTRACT_PATH")
         or str(runtime_home / "templates" / "worker-error-contract.md"),
+        "hostSessionContractPath": ctx.get("HOST_SESSION_CONTRACT_PATH")
+        or _host_session_contract_path(ctx),
     }
 
 
@@ -2002,6 +2010,35 @@ def _initialize_report_ledgers(ctx: Mapping[str, Any], manifest: Mapping[str, An
     activity_path = Path(activity_value)
     if activity_value and not activity_path.is_file():
         _write_text(activity_path, "")
+    _initialize_lead_only_convergence(ctx, manifest)
+
+
+def _initialize_lead_only_convergence(
+    ctx: Mapping[str, Any], manifest: Mapping[str, Any],
+) -> None:
+    """워커를 띄우지 않는 phase 의 수렴 상태.
+
+    리포트 조립은 모든 리포트에 수렴 입력을 요구하는데(ADR-0020), 프로필이
+    "convergence 를 돌지 않는다" 고 선언한 phase 에는 그 파일을 만드는 주체가
+    없었다. 리드가 매 run 마다 seed → plan-round → finalize 를 손으로 돌려 빈
+    상태를 만들어 왔다(실측: dev-10860 release-handoff 001·002 둘 다). 나머지
+    입력과 같은 자리에서 같은 조건으로 만든다 — 없을 때만.
+    """
+    from .convergence_engine import lead_only_final_state
+    from .convergence_store import write_final_state_atomic
+
+    if _resolve_workers(dict(ctx)):
+        return
+    value = str(ctx.get("CONVERGENCE_STATE_PATH") or "")
+    path = Path(value)
+    if not value or path.exists():
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    write_final_state_atomic(
+        path,
+        lead_only_final_state(str(manifest.get("taskKey") or "")),
+        migration=None,
+    )
 
 
 _MODEL_ASSIGNMENT_KEYS = {
@@ -2019,6 +2056,9 @@ _V2_INVOCATION_IDENTITY_KEYS = {
 }
 _AGENT_CONTRACT_KEYS = {
     "schemaVersion",
+    # 이 run 이 동결한 계약의 형식. 없는 run 은 Markdown 직무를 동결했고, 그
+    # 형식의 리더는 제거됐다.
+    "contractFormatVersion",
     "dutyRootPath",
     "catalogDigest",
     "invocationReservationRootPath",
@@ -2610,9 +2650,15 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
     report_writer_preamble = ctx.get("REPORT_WRITER_PREAMBLE_PATH") or str(
         runtime_templates / "report-writer-prompt-preamble.md"
     )
+    translator_preamble = ctx.get("TRANSLATOR_PREAMBLE_PATH") or str(
+        runtime_templates / "translator-prompt-preamble.md"
+    )
     worker_error_contract = ctx.get("WORKER_ERROR_CONTRACT_PATH") or str(
         runtime_templates / "worker-error-contract.md"
     )
+    host_session_contract = ctx.get(
+        "HOST_SESSION_CONTRACT_PATH"
+    ) or _host_session_contract_path(ctx)
     okstra_runtime_resources_block = (
         "## Okstra Runtime Resources\n"
         "\n"
@@ -2629,8 +2675,14 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
         f"- Analysis worker preamble: `{analysis_preamble}`\n"
         f"- Implementation worker preamble: `{implementation_preamble}`\n"
         f"- Report writer preamble: `{report_writer_preamble}`\n"
+        f"- Translator preamble: `{translator_preamble}`\n"
+
         f"- Shared worker error contract: `{worker_error_contract}`"
     )
+    if host_session_contract:
+        okstra_runtime_resources_block += (
+            f"\n- Host worker session contract: `{host_session_contract}`"
+        )
 
     def fmt_assignment(role: str, model: str, execution: str) -> str:
         if execution and execution != model:
@@ -2814,6 +2866,23 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
     ctx["EXECUTION_STATUS_TABLE_ROWS"] = "\n".join(execution_status_table_lines)
 
 
+def _host_session_contract_path(ctx: Mapping[str, object]) -> str:
+    """이 run 의 호스트가 선언한 워커 세션 계약의 절대 경로. 없으면 빈 문자열.
+
+    호스트를 못 찾는 것은 여기서 실패할 일이 아니다 — 계약이 없는 호스트와
+    같게 다루고, 헤더를 빼면 그 워커는 세션 규칙 없이 돈다. 호스트 해석 실패
+    자체는 이 함수를 부르기 전에 이미 run 준비를 막는다.
+    """
+    host_id = str(ctx.get("HOST_RUNTIME", "") or _lead_runtime(ctx) or "").strip()
+    if not host_id:
+        return ""
+    try:
+        descriptor = default_host_registry().resolve(host_id).descriptor
+    except Exception:
+        return ""
+    return descriptor.worker_session_contract or ""
+
+
 def apply_lead_prompt_defaults(ctx: dict) -> None:
     """Apply default values for optional lead-prompt ctx fields.
 
@@ -2853,10 +2922,20 @@ def apply_lead_prompt_defaults(ctx: dict) -> None:
         "REPORT_WRITER_PREAMBLE_PATH",
         str(runtime_home / "templates" / "report-writer-prompt-preamble.md"),
     )
+    ctx.setdefault(
+        "TRANSLATOR_PREAMBLE_PATH",
+        str(runtime_home / "templates" / "translator-prompt-preamble.md"),
+    )
     ctx.setdefault(
         "WORKER_ERROR_CONTRACT_PATH",
         str(runtime_home / "templates" / "worker-error-contract.md"),
     )
+    # 호스트가 선언한 워커 세션 계약. 선언하지 않은 호스트는 빈 문자열이고,
+    # 그러면 헤더가 방출되지 않는다.
+    ctx.setdefault(
+        "HOST_SESSION_CONTRACT_PATH",
+        _host_session_contract_path(ctx),
+    )
     # Lead resource paths the launch template references directly. paths.py
     # seeds the production values; setdefault backfills callers that render the
     # template without the full path ctx.

package/runtime/python/okstra_ctl/report_contract.py

@@ -123,7 +123,7 @@ TASK_TYPE_REQUIRED_HUMAN_FIELDS = {
     "release-handoff": (
         "releaseHandoff.userSelections",
         "releaseHandoff.featureBranchState",
-        "releaseHandoff.pullRequestOutcome",
+        "releaseHandoff.pullRequestOutcomes",
         "releaseHandoff.mergeConflictProbe",
     ),
 }

package/runtime/python/okstra_ctl/report_html/view_models/release_handoff.py

@@ -18,16 +18,31 @@ def _safe_http_url(value: str) -> str:
     return value if parsed.scheme in {"http", "https"} and parsed.netloc else ""
 
 
+def _pr_summary(outcomes: list) -> str:
+    """PR 은 stage 당 하나라 결과도 여러 개다. 타임라인 한 칸에는 종류별 건수로
+    접어 넣는다 — 대표 하나를 고르면 나머지 stage 의 결과가 사라진다."""
+    if not outcomes:
+        return "no-action"
+    counts: dict[str, int] = {}
+    for row in outcomes:
+        kind = row.get("kind", "")
+        counts[kind] = counts.get(kind, 0) + 1
+    return ", ".join(f"{kind} {n}" for kind, n in sorted(counts.items()))
+
+
 def _timeline_nodes(handoff: dict) -> tuple[VisualNode, ...]:
     selection = handoff["userSelections"]["h1"]
     branch = handoff["featureBranchState"]["branchName"]
     conflict = handoff["mergeConflictProbe"]["kind"]
-    pr = handoff["pullRequestOutcome"]["kind"]
+    outcomes = handoff["pullRequestOutcomes"]
+    kinds = {row.get("kind", "") for row in outcomes}
+    status = kinds.pop() if len(kinds) == 1 else "mixed"
     return (
         VisualNode("selection", selection, "handoff", "completed", "User-selected handoff"),
         VisualNode("branch", branch, "handoff", "completed", "Feature branch state"),
         VisualNode("conflict", conflict, "handoff", conflict, "Merge conflict probe"),
-        VisualNode("pull-request", pr, "handoff", pr, "Pull request outcome"),
+        VisualNode("pull-request", _pr_summary(outcomes), "handoff", status,
+                   "Pull request outcome, one per stage"),
     )
 
 
@@ -41,7 +56,10 @@ def build_release_handoff_view(data: dict) -> HumanReportView:
         "handoff": handoff,
         "narrative": handoff["userNarrative"],
         "handoffFigure": figure,
-        "prUrl": _safe_http_url(handoff["pullRequestOutcome"].get("url", "")),
+        "prOutcomes": [
+            {**row, "url": _safe_http_url(row.get("url", ""))}
+            for row in handoff["pullRequestOutcomes"]
+        ],
         "evidenceIndex": evidence_index(data, ANCHORED_FIELDS),
     }
     return HumanReportView(