okstra 0.186.7 → 0.187.0

package/runtime/python/okstra_ctl/report_finalize.py

@@ -42,11 +42,15 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Callable, Mapping, Sequence
 
-from .agent_activity import ActivityProjectionError, project_agent_activity
+from .agent.activity import ActivityProjectionError, project_agent_activity
 from .report_contract import apply_execution_roles
 from .report_assembly import ReportAssemblyError, assemble_report
 from .dispatch_state import DispatchError, link_agent_dispatch_result
-from .final_report_paths import final_report_data_path, final_report_markdown_path
+from .final_report_paths import (
+    final_report_data_path,
+    final_report_markdown_path,
+    sidecar_source_rel,
+)
 from .paths import task_dir, task_manifest_file
 from .release_gate import release_handoff_allowed
 from .json_boundary import JsonBoundaryError, load_owned_object, write_owned_object_atomic
@@ -57,6 +61,16 @@ from .stage_targets import (
 )
 from .session import observe_lead_session
 
+# 포인터 값 타입만 쓴다. `okstra_project.phase_pointer` 는 okstra 안의
+# 어떤 것도 import 하지 않는 leaf 라 순환이 없다 — 그 모듈 도크스트링.
+from okstra_project.phase_pointer import (
+    STATUS_BLOCKED,
+    STATUS_PENDING,
+    STATUS_READY,
+    STATUS_TERMINAL,
+    promote as promote_next_phase,
+)
+
 
 STEP_PROJECT_ACTIVITY = "project-activity"
 STEP_CHECK_SOURCE = "check-source"
@@ -120,13 +134,6 @@ def resolve_optional_path(project_root: Path, value: Any) -> Path | None:
     return resolve_project_path(project_root, value)
 
 
-def project_relative_path(project_root: Path, path: Path) -> str:
-    try:
-        return path.relative_to(project_root).as_posix()
-    except ValueError:
-        return str(path)
-
-
 def task_group(manifest: Mapping[str, Any]) -> str:
     value = string_value(manifest.get("taskGroup"))
     if value:
@@ -337,8 +344,11 @@ def build_commands(ctx: FinalizeContext) -> list[tuple[str, list[str]]]:
                 ctx.task_type,
                 "--seq",
                 ctx.seq,
+                # 사이드카가 되짚는 기준은 태스크 루트다. 프로젝트 루트
+                # 기준으로 넘기던 동안 HTML Export 가 만든 사이드카는
+                # 방향 선택 게이트를 통과할 수 없었다.
                 "--source-report",
-                project_relative_path(ctx.project_root, markdown_path),
+                sidecar_source_rel(markdown_path),
             ],
         ),
         (
@@ -491,9 +501,47 @@ def run_finalize(
         steps.append(step_payload(name, command, result))
         if result.returncode != 0 and not first_failure:
             first_failure = f"{name} failed with exit code {result.returncode}"
-    if first_failure:
-        return {"ok": False, "reason": first_failure, "steps": steps}
-    return {"ok": True, "reason": "", "steps": steps}
+    pointer, pointer_error = _recorded_next_phase(ctx)
+    payload: dict[str, Any] = {
+        "ok": not first_failure,
+        "reason": first_failure,
+        "steps": steps,
+        "nextRecommendedPhase": pointer,
+    }
+    if pointer_error:
+        payload["nextRecommendedPhaseError"] = pointer_error
+    # closeout 이 실제로 건넬 명령. 표를 리드의 기억에 맡기지 않는다.
+    payload["nextCommand"] = closeout_command(payload)
+    return payload
+
+
+def _recorded_next_phase(ctx: FinalizeContext) -> tuple[dict[str, str], str]:
+    """`validate-run` 이 방금 태스크 매니페스트에 쓴 다음 phase 포인터.
+
+    리드의 closeout 표는 이 포인터의 `status` / `rationale` 로 분기하는데,
+    포인터는 리드가 쓰는 필드가 아니고(`prompts/lead/report-writer.md`
+    "Nobody writes this pointer by hand"), 이 시퀀스의 결과에도 실리지
+    않았다. 값 없이 표만 받은 리드에게 남는 행동은 상태를 늘어놓고 턴을
+    끝내는 것뿐이다.
+
+    여기서 다시 계산하지 않는다 — 투영은 `validate-run` 의
+    `update_workflow_metadata` 가 하고, 이 함수는 그것이 파일에 남긴 값을
+    읽어 옮기기만 한다. `--only` 로 `validate-run` 을 건너뛴 호출에서는
+    이전 run 이 남긴 값이 그대로 읽히므로, 이번 시퀀스가 그 단계를 돌았는지는
+    `steps` 로 판단한다.
+
+    읽기가 실패하면 값을 지어내지 않고 사유를 함께 돌려준다.
+    """
+    try:
+        manifest = load_owned_object(
+            ctx.task_manifest_path, artifact="task-manifest"
+        )
+    except (JsonBoundaryError, OSError) as exc:
+        return promote_next_phase(None), f"{ctx.task_manifest_path}: {exc}"
+    workflow = manifest.get("workflow")
+    if not isinstance(workflow, Mapping):
+        return promote_next_phase(None), ""
+    return promote_next_phase(workflow.get("nextRecommendedPhase")), ""
 
 
 def _run_finalize_step(
@@ -529,6 +577,7 @@ def _run_project_activity(
     try:
         if ctx.report_contract_version == "3.0":
             assembled = assemble_report(ctx.project_root, ctx.manifest_path)
+            _point_task_manifest_at_report(ctx)
             count = len(assembled.get("agentActivity") or [])
         else:
             rows = project_agent_activity(
@@ -556,6 +605,34 @@ def write_execution_roles(ctx: FinalizeContext) -> None:
     write_owned_object_atomic(ctx.data_path, updated, artifact="final report record")
 
 
+def _point_task_manifest_at_report(ctx: FinalizeContext) -> None:
+    """게시한 data.json 을 latestReport 로 올린다.
+
+    render-only prepare 는 기존 포인터를 보존한다. 조립이 새 리포트를 썼는데도
+    task-manifest 가 예전 seq 를 가리키면 검사가 통과해도 상태가 004 에 남는다.
+    """
+    path = ctx.task_manifest_path
+    if not path.is_file() or not ctx.data_path.is_file():
+        return
+    try:
+        payload = load_owned_object(path, artifact="task manifest")
+    except (OSError, JsonBoundaryError):
+        return
+    if not isinstance(payload, Mapping):
+        return
+    try:
+        relative = ctx.data_path.resolve().relative_to(
+            ctx.project_root.resolve()
+        ).as_posix()
+    except ValueError:
+        relative = str(ctx.data_path)
+    if payload.get("latestReportRecordPath") == relative:
+        return
+    updated = dict(payload)
+    updated["latestReportRecordPath"] = relative
+    write_owned_object_atomic(path, updated, artifact="task manifest")
+
+
 def _link_lead_result_for_validation(ctx: FinalizeContext) -> None:
     """Link the lead-authored synthesis artifact before Phase 7 validation."""
     manifest = _load_manifest(ctx.manifest_path)
@@ -566,8 +643,11 @@ def _link_lead_result_for_validation(ctx: FinalizeContext) -> None:
     lead_dispatches = [
         row for row in (team_state.get("agentDispatches") or [])
         if isinstance(row, Mapping)
-        and row.get("audience") == "lead"
-        and row.get("workerId") == "lead"
+        and (
+            row.get("audience") == "lead"
+            or row.get("workerId") == "lead"
+            or str(row.get("assignmentRef") or "") in {"lead", "lead/lead"}
+        )
     ]
     if len(lead_dispatches) != 1:
         return
@@ -621,8 +701,41 @@ def _context_from_args(args: argparse.Namespace) -> FinalizeContext:
     )
 
 
+_CLI_EPILOG = r"""Usage:
+  okstra report-finalize --project-root <dir> --run-manifest <path> \
+    --report <final-report-<task-type>-<seq>.md> [--team-state <path>]
+
+Runs the six Phase 7 steps in their contractual order against one final-report:
+
+  1. project-activity  project the run's activity events into the data.json
+  2. check-source      verify the data.json is the English SSOT
+  3. token-usage       substitute real token/cost numbers into the data.json
+  4. render-views      write the schema-v2 task-specific *.html sibling; v1
+                       keeps the legacy conditional interactive view
+  5. spawn-followups   turn section 4 rows into task stubs
+  6. validate-run      validate the finished run artifacts
+
+Every step is idempotent, so re-running after a fixed failure is safe. The
+sequence stops at the first non-zero exit and reports which step failed, except
+token-usage: its input is the lead session log, so a failure there does not
+take the html, follow-ups and validation after it down with it. Whenever a step
+exits non-zero the command prints the --only flags that resume the sequence
+from the earliest failing step — follow those rather than rerunning the failing
+step alone, which would leave the html rendered before the tokens landed.
+
+This is the same code path the Codex lead adapter runs automatically after its
+report-writer completes, so a Claude-led and a Codex-led run finalize
+identically.
+
+  --workspace-root is owned by this command.
+"""
+
+
 def _parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
+        prog="okstra report-finalize",
+        epilog=_CLI_EPILOG,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
         description="Run the Phase 7 report post-processing sequence.",
     )
     parser.add_argument("--project-root", required=True)
@@ -691,6 +804,80 @@ def _recovery_step_names(
     return []
 
 
+def closeout_command(result: Mapping[str, Any]) -> dict[str, str]:
+    """이 run 이 사용자에게 건네야 할 명령.
+
+    `prompts/launch.template.md` "User closeout (BLOCKING)" 의 표를 코드로
+    내린 것이다. 그 표는 문서에만 있었고, 표가 분기하는 포인터는 리드에게
+    도착하지도 않았다 — 규칙이 있고 집행이 없는 자리였다. 여기서 판정하면
+    리드가 표를 기억해 따라갈 필요가 없고, 리드가 침묵해도 명령은
+    `report-finalize` 출력에 남는다.
+
+    산문을 해석하지 않는다. `blocked` / `pending` 의 근거 문장은 이미 무엇을
+    실행할지 말하고 있으므로(`okstra_ctl.next_phase` 의 승인 차단 근거,
+    `validators/validate-run.py` 의 검증 실패 근거), 그 문장을 그대로 인용할
+    자리로 넘기고 명령 칸은 비운다. 근거에서 명령을 다시 뽑아내는 것은
+    기록된 값의 재구현이다.
+
+    돌려주는 것은 `command` 와 `note` 두 칸이다. `command` 가 비면 근거
+    문장이 그 자리를 대신한다.
+    """
+    failed_validate = any(
+        step.get("name") == STEP_VALIDATE_RUN and step.get("exitCode") != 0
+        for step in (result.get("steps") or [])
+        if isinstance(step, Mapping)
+    )
+    if failed_validate:
+        return {
+            "command": "/okstra-run",
+            "note": "validate-run failed — name the blocking cause in one line, "
+                    "then re-run this same phase",
+        }
+    pointer = result.get("nextRecommendedPhase")
+    if not isinstance(pointer, Mapping):
+        return {"command": "/okstra-inspect status", "note": "no pointer recorded"}
+    status = str(pointer.get("status") or "").strip()
+    phase = str(pointer.get("phase") or "").strip()
+    rationale = str(pointer.get("rationale") or "").strip()
+    if status == STATUS_READY and phase:
+        return {"command": f"/okstra-run → {phase}", "note": ""}
+    if status == STATUS_TERMINAL:
+        return {
+            "command": "",
+            "note": "the lifecycle ends here — say the task is finished, name any "
+                    "follow-up tasks this run registered, and do not send the user "
+                    "to /okstra-inspect",
+        }
+    if status in (STATUS_BLOCKED, STATUS_PENDING) and rationale:
+        return {
+            "command": "",
+            "note": "quote the rationale above and issue the command it names",
+        }
+    return {"command": "/okstra-inspect status", "note": ""}
+
+
+def _next_phase_summary_lines(result: Mapping[str, Any]) -> list[str]:
+    """다음 phase 포인터와 그것이 정하는 명령을 사람이 읽는 줄로."""
+    pointer = result.get("nextRecommendedPhase")
+    if not isinstance(pointer, Mapping):
+        return []
+    lines = [
+        f"next phase status: {pointer.get('status') or '-'}",
+        f"next phase: {pointer.get('phase') or '-'}",
+    ]
+    rationale = str(pointer.get("rationale") or "").strip()
+    if rationale:
+        lines.append(f"next phase rationale: {rationale}")
+    error = str(result.get("nextRecommendedPhaseError") or "").strip()
+    if error:
+        lines.append(f"next phase pointer unreadable: {error}")
+    closeout = closeout_command(result)
+    lines.append(f"next command: {closeout['command'] or '-'}")
+    if closeout["note"]:
+        lines.append(f"next command note: {closeout['note']}")
+    return lines
+
+
 def main(argv: Sequence[str] | None = None) -> int:
     args = _parser().parse_args(argv)
     try:
@@ -708,6 +895,10 @@ def main(argv: Sequence[str] | None = None) -> int:
     print("finalize steps:", file=sys.stderr)
     for line in _step_summary_lines(result, order):
         print(line, file=sys.stderr)
+    # closeout 이 분기하는 값. JSON 을 파싱하지 않고 훑는 리드에게도 보이도록
+    # 요약 줄로 한 번 더 낸다.
+    for line in _next_phase_summary_lines(result):
+        print(line, file=sys.stderr)
     if not result["ok"]:
         print(f"error: {result['reason']}", file=sys.stderr)
         recovery = _recovery_step_names(result, order)

package/runtime/python/okstra_ctl/report_html/common.py

@@ -68,8 +68,8 @@ def _own_section_ids(data: dict, omitted_fields: tuple[str, ...] = ()) -> set[st
 
     The ledger is the fallback home for a cited row, so it must not claim an id
     that has one — two elements with the same anchor send half the links to the
-    wrong place. `crossVerification.consensus` numbers its rows `C-001` in some
-    runs, exactly where a clarification lives.
+    wrong place. `crossVerification.consensus` numbers its rows `CV-001`, a
+    namespace of its own, so a `C-NNN` in the report has exactly one home.
 
     `omitted_fields` names task-block fields the HTML template does not render,
     so their ids do not count as anchored.

package/runtime/python/okstra_ctl/report_html/render.py

@@ -69,25 +69,21 @@ def _report_meta(data: dict, run_meta: HtmlRunMeta) -> dict[str, object]:
 
 
 def _localize(data: dict, data_path: Path) -> tuple[dict, str]:
-    """Apply the translation sidecar for this report's language, if there is one.
-
-    The data.json is the English SSOT and is never rewritten — the sidecar is
-    read here and overlaid onto an in-memory copy, so only this HTML document
-    speaks the reader's language. A pointer the sidecar left untranslated
-    renders in English; that keeps a half-finished translation readable, and
-    the counts are printed because a silently half-empty sidecar otherwise
-    ships looking finished.
+    """이 리포트 언어의 번역 사이드카를 메모리 복사본에 덮어쓴다.
+
+    data.json 은 영어 정본이고 고치지 않는다. 사람이 읽는 HTML 만 독자 언어다.
+    사이드카가 빠진 포인터는 영어로 남긴다. 사이드카 파일 자체가 없으면
+    크롬만 번역되고 본문은 영어로 나가므로 렌더를 거부한다.
     """
     lang = str((data.get("meta") or {}).get("reportLanguage") or "en")
     if lang == "en":
         return data, lang
     sidecar_file = translation_sidecar_path(data_path, lang)
     if not sidecar_file.is_file():
-        sys.stdout.write(
-            f"note: no {lang} translation sidecar at {sidecar_file.name}; "
-            "rendering the English source\n"
+        raise HtmlRenderError(
+            f"no {lang} translation sidecar at {sidecar_file.name}; "
+            "human HTML cannot fall back to the English source"
         )
-        return data, lang
     payload = load_owned_object(sidecar_file, artifact="translation sidecar")
     strings = payload.get("strings")
     if not isinstance(strings, dict):

package/runtime/python/okstra_ctl/report_language.py

@@ -1,8 +1,12 @@
-"""Report-language resolution for the report-writer prompt.
+"""Report-language resolution — the one place the precedence lives.
 
-Both dispatchers stamp `**Report Language:**` into the report-writer prompt, so
-the precedence (project config → global config → inferred from the task brief)
-lives here rather than in whichever dispatcher happened to need it first.
+Two surfaces need the answer and must agree: the `**Report Language:**` line
+both dispatchers stamp into the report-writer prompt, and `reportLanguage` in
+the run manifest, which report assembly copies into `meta.reportLanguage` and
+the HTML renderer reads. When only the prompt called this, a project could ask
+for `ko`, get a Korean-instructed writer, and still ship an English report.
+
+Precedence: project config → global config → inferred from the task brief.
 """
 from __future__ import annotations
 

package/runtime/python/okstra_ctl/report_narrative.py

@@ -38,8 +38,25 @@ class _Node:
         self.children: list[_Node] = []
 
 
+_NARRATIVE_SCHEMA_RELATIVE = ("schemas", "report-narrative-v3.0.schema.json")
+
+
 def _narrative_schema_path() -> Path:
-    return Path(__file__).resolve().parents[2] / "schemas" / "report-narrative-v3.0.schema.json"
+    """schemas 를 실제로 가진 루트에서 해소한다.
+
+    부모 개수를 세면 체크아웃에서만 맞는다 — 설치본은 패키지가
+    `~/.okstra/lib/python/` 이고 schemas 는 `~/.okstra/schemas/` 라 한 단계
+    어긋나서, 설치본으로 실행할 때 서사 파싱이 스키마 없음으로 죽었다.
+    """
+    from .paths import find_asset_root
+
+    root = find_asset_root(_NARRATIVE_SCHEMA_RELATIVE)
+    if root is None:
+        raise NarrativeContractError(
+            "could not locate report-narrative-v3.0.schema.json. Set OKSTRA_HOME "
+            "or run from a checkout that contains schemas/."
+        )
+    return root.joinpath(*_NARRATIVE_SCHEMA_RELATIVE)
 
 
 def _narrative_schema() -> dict[str, Any]:
@@ -50,6 +67,72 @@ def _allowed_top_level() -> frozenset[str]:
     return frozenset(_narrative_schema().get("properties", {}))
 
 
+# 완성 리포트 스키마가 작성자 소유 블록 안에서 required 로 거는 기계 소유 필드.
+# `writer_owned_data` 가 떼어내고 `_NESTED_FORBIDDEN` 이 저작을 막는 바로 그
+# 이름들이라, 값 제약을 그대로 쓰면 정상 서사가 전부 "필수 필드 없음" 으로
+# 깨진다. 앞의 둘은 `_NESTED_FORBIDDEN` 에서 파생시켜 두 목록이 갈라지지
+# 않게 한다.
+_MACHINE_OWNED_NESTED = frozenset(
+    {path.rsplit(".", 1)[-1] for path in _NESTED_FORBIDDEN} | {"designSurfaceCoverage"}
+)
+
+
+def _without_machine_owned_required(node: Any, *, negated: bool = False) -> Any:
+    """`required` 목록에서 기계 소유 필드 이름만 뺀 스키마 사본.
+
+    `not` 아래는 건드리지 않는다. 거기서 `required: [designPreparation]` 은
+    "이 필드가 있으면 안 된다" 는 뜻이고 서사에는 원래 없으니 이미 만족한다.
+    이름을 빼면 `not: {required: []}` 가 되는데, 빈 `required` 는 모든 객체가
+    만족하므로 그 `not` 은 항상 거짓이 된다 — 통과해야 할 분기를 통과 불가로
+    뒤집는다. 실제로 `direction-invalidated` 계획 분기가 그렇게 죽었다.
+    """
+    if isinstance(node, list):
+        return [_without_machine_owned_required(item, negated=negated) for item in node]
+    if not isinstance(node, dict):
+        return node
+    result: dict[str, Any] = {}
+    for key, value in node.items():
+        if key == "required" and isinstance(value, list) and not negated:
+            result[key] = [
+                name for name in value if name not in _MACHINE_OWNED_NESTED
+            ]
+        else:
+            result[key] = _without_machine_owned_required(
+                value, negated=negated or key == "not"
+            )
+    return result
+
+
+def _writer_owned_schema(schema: Mapping[str, Any]) -> dict[str, Any]:
+    """작성자가 쓴 서사에 걸 값 제약 — 완성 리포트 스키마에서 잘라 온다.
+
+    `report-narrative-v3.0.schema.json` 은 최상위 **이름** 허용목록이고 값은
+    전부 `{"type": "object"}` 스텁이다. 그 스텁으로만 검증하면 enum 밖 값과
+    빠진 필수 필드가 서사 단계를 통과하고, Phase 7 조립이 완성 리포트 스키마에
+    부딪힐 때에야 거절된다 — 작성기 워커가 이미 끝난 뒤라 되돌릴 방법이 없다.
+    실측(2026-08-26, stage 10 run 002): `verdictCard.direction` 에 enum 에 없는
+    `proceed` 가, `humanSummary` 에 필수 `whyItMatters` 가 빠진 채로 서사가
+    통과했고 `report-finalize` 의 `project-activity` 가 exit 1 로 떨어졌다.
+
+    그래서 이름 소유권은 서사 스키마에서, 값 제약은 넘겨받은 완성 리포트
+    스키마에서 가져온다. 두 벌을 만들지 않으므로 드리프트가 생기지 않는다.
+    서사는 부분 문서다 — 최상위 `required` 는 싣지 않는다. 이 run 의 task
+    블록만 있고 나머지 task-type 블록과 기계 소유 최상위 필드는 없기 때문이다.
+    """
+    allowed = _allowed_top_level()
+    properties = {
+        key: value
+        for key, value in schema.get("properties", {}).items()
+        if key in allowed
+    }
+    return {
+        "type": "object",
+        "additionalProperties": False,
+        "properties": _without_machine_owned_required(properties),
+        "$defs": _without_machine_owned_required(schema.get("$defs", {})),
+    }
+
+
 def writer_owned_data(data: Mapping[str, Any]) -> dict[str, Any]:
     """완성 리포트에서 보고서 작성자 소유 필드만 복사한다."""
     owned = {
@@ -331,7 +414,11 @@ def _parse_object(node: _Node, schema_node: Any, index: SchemaIndex, path: str)
 
 
 def parse_narrative(markdown: str, schema: Mapping[str, Any]) -> dict[str, Any]:
-    """Markdown을 작성자 소유 자료로 읽고 소유권 표면을 검증한다."""
+    """Markdown을 작성자 소유 자료로 읽고, 소유권 표면과 값 제약을 검증한다.
+
+    `schema` 는 완성 리포트 스키마다. 이름·타입 해석과 값 검증이 모두 그
+    한 벌에서 나온다(`_writer_owned_schema`).
+    """
     root = _parse_tree(markdown)
     index = SchemaIndex(schema)
     result = _parse_object(root, schema, index, "")
@@ -345,7 +432,7 @@ def parse_narrative(markdown: str, schema: Mapping[str, Any]) -> dict[str, Any]:
             f"owner=report-writer cannot author fields: {labels}; "
             f"writer-owned top-level fields: {owned}"
         )
-    errors = validate(result, _narrative_schema())
+    errors = validate(result, _writer_owned_schema(schema))
     if errors:
         raise NarrativeContractError("; ".join(errors))
     return result

package/runtime/python/okstra_ctl/report_projections.py

@@ -168,6 +168,9 @@ def _worker_details(team_state: Mapping[str, Any]) -> list[dict[str, Any]]:
         usage = worker.get("usage") if isinstance(worker.get("usage"), Mapping) else {}
         row = {"label": _text(worker.get("role") or worker.get("workerId"), "Worker")}
         _populate_usage(row, usage)
+        # 작업 시간은 executionStatus 칸이다. workerDetails 스키마는
+        # durationMs 를 허용하지 않아 조립이 additionalProperties 로 거절한다.
+        row.pop("durationMs", None)
         for key in ("totalTokens", "cacheReadTokens", "billableTokens", "costUsd", "cliTotalTokens", "cliCostUsd"):
             row.setdefault(key, None)
         result.append(row)
@@ -231,6 +234,9 @@ def project_design(
 def _round_history(state: Mapping[str, Any]) -> dict[str, Any]:
     if not (state.get("config") or {}).get("enabled", True):
         return {"disabled": True}
+    skip_reason = state.get("round2SkippedReason", "not-skipped")
+    if skip_reason == "auto-disabled":
+        skip_reason = "single-analyser-only"
     rows = []
     for row in state.get("roundHistory") or []:
         if not isinstance(row, Mapping):
@@ -243,7 +249,7 @@ def _round_history(state: Mapping[str, Any]) -> dict[str, Any]:
             "dispatches": json.dumps(row.get("dispatches") or [], ensure_ascii=False),
             "skippedWorkers": json.dumps(row.get("skippedWorkers") or [], ensure_ascii=False),
         })
-    return {"rounds": rows, "round2SkippedReason": state.get("round2SkippedReason", "not-skipped")}
+    return {"rounds": rows, "round2SkippedReason": skip_reason}
 
 
 def _source_items(finding: Mapping[str, Any]) -> list[str]:
@@ -265,7 +271,7 @@ def project_convergence(state: Mapping[str, Any]) -> dict[str, Any]:
         ticket_id = _text(ticket_ids[0] if ticket_ids else "unknown", "unknown")
         if finding.get("classification") in {"full-consensus", "partial-consensus"}:
             row = {
-                "id": f"C-{len(consensus) + 1:03d}",
+                "id": f"CV-{len(consensus) + 1:03d}",
                 "ticketId": ticket_id,
                 "statement": _text(finding.get("summary"), "Converged finding"),
                 "sourceItems": _source_items(finding),