okstra 0.187.0 → 0.188.0

package/runtime/python/okstra_ctl/report_narrative.py

@@ -67,6 +67,11 @@ def _allowed_top_level() -> frozenset[str]:
     return frozenset(_narrative_schema().get("properties", {}))
 
 
+def allowed_top_level_fields() -> frozenset[str]:
+    """작성자가 최상위에 쓸 수 있는 필드 이름(서사 스키마의 properties)."""
+    return _allowed_top_level()
+
+
 # 완성 리포트 스키마가 작성자 소유 블록 안에서 required 로 거는 기계 소유 필드.
 # `writer_owned_data` 가 떼어내고 `_NESTED_FORBIDDEN` 이 저작을 막는 바로 그
 # 이름들이라, 값 제약을 그대로 쓰면 정상 서사가 전부 "필수 필드 없음" 으로
@@ -273,7 +278,7 @@ def _parse_tree(markdown: str) -> _Node:
             _append_node(stack, field, item, level, number)
         elif value:
             level = _line_level(value.group("indent"), number)
-            _append_value(stack, value.group("value"), level, number)
+            _append_value(stack, value.group("value"), level, number, lines)
         else:
             raise NarrativeContractError(
                 f"line {number}: unsupported Markdown syntax `{line.strip()}` — "
@@ -299,9 +304,45 @@ def _append_node(stack: list[_Node], field: Any, item: Any, level: int, number:
     stack.append(node)
 
 
-def _append_value(stack: list[_Node], value: str, level: int, number: int) -> None:
+def _misplaced_value_lines(lines: list[str]) -> int:
+    """자기 라벨보다 두 칸 더 들여쓰지 않은 `> value` 줄의 수.
+
+    파서는 첫 결함에서 멈추므로 규모를 말하지 못한다 — 129줄이 전부 0열에
+    붙은 서술문이 `line 5` 한 건으로 보고됐다(2026-09-02 실측). 여기서는
+    직전 라벨(`- **…**` / `- Item N`)의 들여쓰기와 견줘 세기만 한다; 판정은
+    여전히 파서의 것이다.
+    """
+    misplaced = 0
+    label_indent = None
+    for line in lines[1:]:
+        if not line.strip():
+            continue
+        match = _FIELD_RE.match(line) or _ITEM_RE.match(line)
+        if match:
+            label_indent = len(match.group("indent"))
+            continue
+        value = _VALUE_RE.match(line)
+        if value and label_indent is not None:
+            if len(value.group("indent")) != label_indent + 2:
+                misplaced += 1
+    return misplaced
+
+
+def _append_value(
+    stack: list[_Node], value: str, level: int, number: int, lines: list[str] | None = None,
+) -> None:
     if stack[-1].level != level - 1:
-        raise NarrativeContractError(f"line {number}: value is outside its field")
+        count = _misplaced_value_lines(lines) if lines is not None else 0
+        scale = (
+            f"; {count} value line(s) in this file share the defect"
+            if count > 1
+            else ""
+        )
+        raise NarrativeContractError(
+            f"line {number}: value is outside its field — a `> value` line is "
+            "indented exactly two spaces deeper than the `- **Label**` or "
+            f"`- Item N` line it belongs to{scale}"
+        )
     if stack[-1].children:
         raise NarrativeContractError(f"line {number}: field mixes values and children")
     stack[-1].values.append(value)
@@ -317,7 +358,37 @@ def _allowed_labels(node: Any, index: SchemaIndex, path: str) -> list[str]:
     return sorted(humanise(key) for key in keys)
 
 
-def _field_key(label: str, node: Any, index: SchemaIndex, path: str) -> str:
+class _Defects:
+    """값 단계에서 모은 결함. 첫 건에서 멈추지 않고 문서 전체를 읽는다.
+
+    파서가 첫 강제 변환 실패에서 예외를 내던 동안, 같은 종류의 결함이 여러
+    자리에 있어도 한 자리만 보고돼 작성자가 같은 문서를 회차마다 한 자리씩
+    고쳤다(2026-09-03 실측, dev-10626 implementation-option-selection: 소수
+    `coveragePercent` 가 랭킹 옵션 둘에 있는데 `rankedOptions[1]` 한 건만).
+    스키마 검증(`validate`)은 이미 전건을 모으므로 값 단계도 그렇게 한다.
+    """
+
+    def __init__(self) -> None:
+        self.messages: list[str] = []
+        self.paths: list[str] = []
+
+    def add(self, path: str, message: str) -> None:
+        self.paths.append(path)
+        self.messages.append(message)
+
+    def covers(self, error: str) -> bool:
+        """스키마 검증이 같은 자리(또는 그 아래)에 낸 오류인가 — 값 단계가 이미
+        보고한 자리를 두 번 말하지 않는다."""
+        location = error.split(": ", 1)[0]
+        return any(
+            location == path or location.startswith(f"{path}.") or location.startswith(f"{path}[")
+            for path in self.paths
+        )
+
+
+def _field_key(
+    label: str, node: Any, index: SchemaIndex, path: str, defects: _Defects,
+) -> str | None:
     candidates: dict[str, list[str]] = {}
     for key in index.key_order(node):
         candidates.setdefault(label_key(humanise(key)), []).append(key)
@@ -330,20 +401,26 @@ def _field_key(label: str, node: Any, index: SchemaIndex, path: str) -> str:
     if not matches:
         allowed = _allowed_labels(node, index, path)
         listing = ", ".join(f"`{item}`" for item in allowed) or "(none)"
-        raise NarrativeContractError(
+        defects.add(
+            display_path,
             f"owner=report-writer field `{display_path}` is not an allowed unique "
-            f"field; allowed at this position: {listing}"
+            f"field; allowed at this position: {listing}",
         )
+        return None
     if len(matches) > 1:
         collisions = ", ".join(f"`{key}`" for key in matches)
-        raise NarrativeContractError(
+        defects.add(
+            display_path,
             f"owner=report-writer field `{display_path}` is not an allowed unique "
-            f"field; the label matches more than one schema key: {collisions}"
+            f"field; the label matches more than one schema key: {collisions}",
         )
+        return None
     return matches[0]
 
 
-def _parse_scalar(values: list[str], node: Any, index: SchemaIndex, path: str) -> Any:
+def _parse_scalar(
+    values: list[str], node: Any, index: SchemaIndex, path: str, defects: _Defects,
+) -> Any:
     types = _node_types(node, index)
     text = "\n".join(values)
     if text == EMPTY_MARKER and "null" in types:
@@ -353,17 +430,21 @@ def _parse_scalar(values: list[str], node: Any, index: SchemaIndex, path: str) -
     if "integer" in types:
         try:
             return int(text)
-        except ValueError as exc:
-            raise NarrativeContractError(f"{path}: expected integer") from exc
+        except ValueError:
+            defects.add(path, f"{path}: expected integer")
+            return text
     if "number" in types:
         try:
             return float(text)
-        except ValueError as exc:
-            raise NarrativeContractError(f"{path}: expected number") from exc
+        except ValueError:
+            defects.add(path, f"{path}: expected number")
+            return text
     return text
 
 
-def _parse_value(node: _Node, schema_node: Any, index: SchemaIndex, path: str) -> Any:
+def _parse_value(
+    node: _Node, schema_node: Any, index: SchemaIndex, path: str, defects: _Defects,
+) -> Any:
     types = _node_types(schema_node, index)
     if node.values:
         if node.values == [EMPTY_MARKER] and "null" in types:
@@ -372,43 +453,54 @@ def _parse_value(node: _Node, schema_node: Any, index: SchemaIndex, path: str) -
             return {}
         if node.values == [EMPTY_MARKER] and "array" in types:
             return []
-        return _parse_scalar(node.values, schema_node, index, path)
+        return _parse_scalar(node.values, schema_node, index, path, defects)
     if "array" in types or all(child.kind == "item" for child in node.children):
-        return _parse_array(node, schema_node, index, path)
-    return _parse_object(node, schema_node, index, path)
+        return _parse_array(node, schema_node, index, path, defects)
+    return _parse_object(node, schema_node, index, path, defects)
 
 
-def _parse_array(node: _Node, schema_node: Any, index: SchemaIndex, path: str) -> list[Any]:
+def _parse_array(
+    node: _Node, schema_node: Any, index: SchemaIndex, path: str, defects: _Defects,
+) -> list[Any]:
     if any(child.kind != "item" for child in node.children):
-        raise NarrativeContractError(f"{path}: array requires Item rows")
+        defects.add(path, f"{path}: array requires Item rows")
+        return []
     positions = [int(child.label) for child in node.children]
     if positions != list(range(1, len(positions) + 1)):
-        raise NarrativeContractError(f"{path}: Item numbers must be 1..N")
+        defects.add(path, f"{path}: Item numbers must be 1..N")
+        return []
     item_schema = index.item(schema_node)
     return [
-        _parse_value(child, item_schema, index, f"{path}[{position - 1}]")
+        _parse_value(child, item_schema, index, f"{path}[{position - 1}]", defects)
         for position, child in zip(positions, node.children, strict=True)
     ]
 
 
-def _parse_object(node: _Node, schema_node: Any, index: SchemaIndex, path: str) -> dict[str, Any]:
+def _parse_object(
+    node: _Node, schema_node: Any, index: SchemaIndex, path: str, defects: _Defects,
+) -> dict[str, Any]:
     result: dict[str, Any] = {}
     for child in node.children:
         if child.kind != "field":
-            raise NarrativeContractError(f"{path}: object requires named fields")
-        key = _field_key(child.label, schema_node, index, path)
+            defects.add(path, f"{path}: object requires named fields")
+            return result
+        key = _field_key(child.label, schema_node, index, path, defects)
+        if key is None:
+            continue
         child_path = f"{path}.{key}" if path else key
         if child_path in _NESTED_FORBIDDEN:
-            raise NarrativeContractError(
-                f"owner=report-writer cannot author `{path}.{child.label}`"
+            defects.add(
+                child_path, f"owner=report-writer cannot author `{path}.{child.label}`"
             )
+            continue
         if key in result:
-            raise NarrativeContractError(f"duplicate field: {child_path}")
+            defects.add(child_path, f"duplicate field: {child_path}")
+            continue
         child_schema = index.child(schema_node, key)
         if not _node_types(child_schema, index):
             child_schema = index.schema_for_key(key)
         result[key] = _parse_value(
-            child, child_schema, index, child_path
+            child, child_schema, index, child_path, defects
         )
     return result
 
@@ -417,11 +509,14 @@ def parse_narrative(markdown: str, schema: Mapping[str, Any]) -> dict[str, Any]:
     """Markdown을 작성자 소유 자료로 읽고, 소유권 표면과 값 제약을 검증한다.
 
     `schema` 는 완성 리포트 스키마다. 이름·타입 해석과 값 검증이 모두 그
-    한 벌에서 나온다(`_writer_owned_schema`).
+    한 벌에서 나온다(`_writer_owned_schema`). 값 단계의 결함(강제 변환·모양·
+    허용되지 않는 필드)과 스키마 검증의 결함을 한 예외에 모두 싣는다 — 값
+    단계가 보고한 자리는 스키마 검증에서 다시 말하지 않는다.
     """
     root = _parse_tree(markdown)
     index = SchemaIndex(schema)
-    result = _parse_object(root, schema, index, "")
+    defects = _Defects()
+    result = _parse_object(root, schema, index, "", defects)
     unknown = sorted(set(result) - _allowed_top_level())
     if unknown:
         labels = [humanise(key) for key in unknown]
@@ -432,7 +527,11 @@ 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, _writer_owned_schema(schema))
-    if errors:
-        raise NarrativeContractError("; ".join(errors))
+    errors = [
+        error
+        for error in validate(result, _writer_owned_schema(schema))
+        if not defects.covers(error)
+    ]
+    if defects.messages or errors:
+        raise NarrativeContractError("; ".join(defects.messages + errors))
     return result

package/runtime/python/okstra_ctl/report_synthesis_packet.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import copy
 import hashlib
+import json
 import os
 import re
 import tempfile
@@ -16,6 +17,7 @@ from .implementation_options import (
     EVALUATION_CRITERIA,
     MAX_CRITERION_VALUE,
     MAX_RANKED_OPTIONS,
+    MAX_RAW_CANDIDATES_PER_ANALYSER,
     MIN_CRITERION_VALUE,
     MIN_FEASIBLE_VOTES,
     NO_VALID_OPTIONS_ROUTING,
@@ -23,6 +25,12 @@ from .implementation_options import (
 from .report_narrative import writer_owned_data
 from .scope_provenance import brief_end_state_id_sequence
 
+from .exact_coverage import COVERAGE_VERDICT_PRECEDENCE
+from .final_report_schema import task_block_rules, verdict_token_rule
+from .report_contract import TASK_TYPE_DATA_PROPERTY
+from .report_markdown import humanise
+from .report_narrative import NarrativeContractError, allowed_top_level_fields
+
 
 @dataclass(frozen=True)
 class ReportSynthesisPacketIssue:
@@ -67,6 +75,21 @@ class ReportSynthesisPacket:
     participating_analysers: tuple[str, ...] = ()
     # 증분 판정. 저작 계약이 이번 run 의 stage 번호를 말할 수 있는 유일한 출처다.
     incremental_decision: dict[str, Any] | None = None
+    # 넘겨받은 완성 리포트 스키마에서 뽑은 값. 작성자는 스키마 가지를 읽지 않으므로
+    # 여기 적어 줘야 도달한다(2026-09-02 실측: `Human Summary` 절 누락, `Verdict
+    # Token` 에 `analysis-complete` — 둘 다 HTML 렌더에서야 거절됐다).
+    required_top_level: tuple[str, ...] = ()
+    verdict_tokens: tuple[str, ...] = ()
+    # 이 task type 의 데이터 블록과, 스키마가 그 블록 안쪽에 못 박은 모양(객체당
+    # 한 줄). 최상위 필드까지만 싣던 동안 리드는 하위 구조의 필수 필드·식별자
+    # 패턴을 스키마 JSON 에서 손으로 뽑았고, 놓친 만큼 리포트를 다시 썼다
+    # (2026-09-03 실측: implementation-option-selection 네 회차).
+    block_key: str = ""
+    block_rules: tuple[str, ...] = ()
+    # 작성자가 최상위에 쓸 수 있는 필드 전체(서사 스키마의 properties). 필수만
+    # 적던 동안 리드가 어느 task type 에도 없는 절을 지시했고, 작성자는 조립이
+    # 거절할 때까지 그 지시를 거를 근거가 없었다(2026-09-03 실측).
+    allowed_top_level: tuple[str, ...] = ()
 
     def _carry_instructions(self) -> list[str]:
         """이번 run 의 이월 지시. 증분이 아니면 빈 목록.
@@ -90,6 +113,45 @@ class ReportSynthesisPacket:
             f"rejects a carried stage that changed or is missing.",
         ]
 
+    def _schema_instructions(self) -> list[str]:
+        """스키마가 이 task type 에 못 박은 값을 저작 계약 문장으로 옮긴다."""
+        lines: list[str] = []
+        if self.required_top_level:
+            labels = ", ".join(f"`{label}`" for label in self.required_top_level)
+            lines.append(
+                f"Required top-level fields for this task type: {labels}. "
+                "Report assembly refuses a narrative that omits any of them."
+            )
+        if len(self.verdict_tokens) == 1:
+            lines.append(
+                f"`Final Verdict` -> `Verdict Token`: write exactly "
+                f"`{self.verdict_tokens[0]}`; the schema pins it for task type "
+                f"`{self.task_type}` and refuses every other value."
+            )
+        elif self.verdict_tokens:
+            allowed = ", ".join(f"`{token}`" for token in self.verdict_tokens)
+            lines.append(
+                f"`Final Verdict` -> `Verdict Token`: one of {allowed} for task type "
+                f"`{self.task_type}`."
+            )
+        if self.allowed_top_level:
+            labels = ", ".join(f"`{label}`" for label in self.allowed_top_level)
+            lines.append(
+                f"Writer-owned top-level fields, the complete set a narrative may "
+                f"contain: {labels}. Report assembly refuses any other top-level "
+                "field, whichever instruction asked for it."
+            )
+        if self.block_rules:
+            lines.append(
+                f"Shape of the `{self.block_key}` block, one line per object, from "
+                "the frozen schema. Paths are schema keys: write each key as its "
+                "Title Case label (`rankedOptions` -> `Ranked Options`), and `[]` "
+                "marks the items of an `- Item N` list. Report assembly refuses a "
+                "narrative that breaks any line."
+            )
+            lines.extend(self.block_rules)
+        return lines
+
     def _carry_validation_rules(self) -> list[str]:
         return ["carried-stages-unchanged"] if self.incremental_decision else []
 
@@ -114,6 +176,24 @@ class ReportSynthesisPacket:
             "`criterionScores` row per evaluation criterion. Weights and scores "
             f"are integers from {MIN_CRITERION_VALUE} through {MAX_CRITERION_VALUE}; "
             "`weightedScore` is the recalculated weighted mean.",
+            "`proposedBy` names exactly one participating analyser id, never a "
+            "list. Counting `rankedOptions` and `candidateAudit` together, each "
+            f"analyser may propose at most {MAX_RAW_CANDIDATES_PER_ANALYSER} raw "
+            "candidates and the run may hold at most "
+            f"{MAX_RAW_CANDIDATES_PER_ANALYSER} times the analyser count.",
+            "`coverageSummary` is recalculated from the row's `requirementCoverage` "
+            "statuses and `scopeCommitments`, and every field must equal the "
+            "recalculation: `totalCount` = number of original requirement ids; "
+            "`coveredCount` = rows with status `covered`; `coveragePercent` = "
+            "round(coveredCount / totalCount * 100, 2); `unmappedCommitments` = "
+            "commitment ids whose `requirementIds` is empty or names an id outside "
+            "the original set; `scopePrecisionPercent` = round((commitments - "
+            "unmapped) / commitments * 100, 2); `contradictedRequirements` = "
+            "original ids with status `contradicted`, in original order; "
+            "`coverageVerdict` = the first that applies of "
+            + ", ".join(f"`{verdict}`" for verdict in COVERAGE_VERDICT_PRECEDENCE)
+            + " (any contradicted; coveredCount below totalCount; any unmapped; "
+            "otherwise).",
             "A ranked option is valid only when every participating analyser "
             "supplied one feasibility vote, at least "
             f"{MIN_FEASIBLE_VOTES} votes are `feasible`, and both `safetyBlockers` "
@@ -170,6 +250,7 @@ class ReportSynthesisPacket:
                     "Do not invent a value when a source is missing or contradictory.",
                     "Write only the narrative, pointer, and audit artifacts named by the dispatch.",
                     *_INTERNAL_IDENTIFIER_INSTRUCTION,
+                    *self._schema_instructions(),
                     *self._task_instructions(),
                     *self._carry_instructions(),
                 ],
@@ -208,6 +289,7 @@ class ReportSynthesisPacket:
         # 작성자가 실제로 읽는 것은 마크다운이다. JSON 정본에만 실으면 지시가
         # 도달하지 않는다.
         lines.extend(f"- {text}" for text in _INTERNAL_IDENTIFIER_INSTRUCTION)
+        lines.extend(f"- {text}" for text in self._schema_instructions())
         lines.extend(f"- {text}" for text in self._task_instructions())
         lines.extend(f"- {text}" for text in self._carry_instructions())
         lines.extend(_accounting_markdown(self.accounting_snapshot))
@@ -646,10 +728,18 @@ def build_report_synthesis_packet(
                 for worker in roster
                 if _string(worker) and _string(worker) != "report-writer"
             )
+    required_top_level, verdict_tokens, block_rules = _schema_authoring_rules(
+        sources, task_type
+    )
     return ReportSynthesisPacket(
         task_key=_string(manifest.get("taskKey")),
         task_type=task_type,
         result_path=_relative(project_root, narrative_path),
+        required_top_level=required_top_level,
+        verdict_tokens=verdict_tokens,
+        block_key=TASK_TYPE_DATA_PROPERTY.get(task_type, "") if block_rules else "",
+        block_rules=block_rules,
+        allowed_top_level=_allowed_top_level_labels(),
         sources=sources,
         accounting_snapshot=_accounting_snapshot(team_state),
         original_requirement_ids=original_requirement_ids,
@@ -658,6 +748,51 @@ def build_report_synthesis_packet(
     )
 
 
+def _schema_authoring_rules(
+    sources: tuple[ReportSynthesisSource, ...], task_type: str,
+) -> tuple[tuple[str, ...], tuple[str, ...], tuple[str, ...]]:
+    """넘겨받은(동결된) 완성 리포트 스키마에서 작성자 몫의 규칙 세 가지를 뽑는다.
+
+    최상위 `required` 가운데 작성자 소유 이름(서사 스키마의 properties)만
+    사람이 읽는 라벨로, 이 task type 의 `Verdict Token` 허용값, 그리고 이 task
+    type 의 데이터 블록 안쪽 모양(`task_block_rules`). 스키마 소스가 없거나
+    JSON 이 아니면 빈 값이다 — 이 함수는 조립 검증을 대신하지 않고 도달하지
+    못하던 규칙을 저작 계약에 옮길 뿐이다.
+    """
+    schema_text = next(
+        (source.content for source in sources if source.label == "Final report schema"),
+        "",
+    )
+    try:
+        schema = json.loads(schema_text) if schema_text else {}
+    except ValueError:
+        schema = {}
+    if not isinstance(schema, dict):
+        schema = {}
+    try:
+        allowed = allowed_top_level_fields()
+    except (NarrativeContractError, JsonBoundaryError):
+        allowed = frozenset()
+    required = schema.get("required")
+    required_top_level = tuple(
+        humanise(key)
+        for key in (required if isinstance(required, list) else [])
+        if isinstance(key, str) and key in allowed
+    )
+    block_key = TASK_TYPE_DATA_PROPERTY.get(task_type, "")
+    block_rules = task_block_rules(schema, block_key) if block_key else ()
+    return required_top_level, verdict_token_rule(schema, task_type), block_rules
+
+
+def _allowed_top_level_labels() -> tuple[str, ...]:
+    """작성자 소유 최상위 필드 전체 — 서사 스키마 부재는 빈 값(조립이 판정한다)."""
+    try:
+        allowed = allowed_top_level_fields()
+    except (NarrativeContractError, JsonBoundaryError):
+        return ()
+    return tuple(humanise(key) for key in sorted(allowed))
+
+
 def report_synthesis_packet_paths(narrative_path: Path) -> tuple[Path, Path]:
     name = narrative_path.name
     prefix = "report-writer-narrative-"

package/runtime/python/okstra_ctl/report_view_artifacts.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 
 from pathlib import Path
 
+from .json_boundary import JsonBoundaryError, load_owned_object
+
 
 def html_view_path(report_path: Path) -> Path:
     """Return the HTML sibling for a final-report Markdown or data path."""
@@ -18,5 +20,43 @@ def user_responses_dir_for_report(report_path: Path) -> Path:
 
 
 def team_state_path_for_report(report_path: Path, task_type: str, seq: str) -> Path:
-    """Return the team-state sibling that records the run's usage windows."""
-    return report_path.parent.parent / "state" / f"team-state-{task_type}-{seq}.json"
+    """The team-state of the run that produced this report.
+
+    The report's sequence is not the run's: categories are numbered on their
+    own (`paths.compute_run_paths`), so two prepared-and-abandoned runs leave
+    the report slot free while consuming state slots, and the run that finally
+    writes `final-report-…-002` keeps its usage in `team-state-…-004`. Naming
+    the state after the report's seq read the earlier run's usage — a header
+    elapsed of 389h taken from a run that shared nothing but the number
+    (observed 2026-09-02, dev-10626 error-analysis). The run manifest names
+    both files (`expectedReportRecordPath`, `teamStatePath`), so the latest
+    manifest naming this report decides; the seq-derived sibling is the
+    fallback for a run directory without such a manifest.
+    """
+    run_dir = report_path.parent.parent
+    recorded = _team_state_from_manifests(run_dir, report_path.name)
+    if recorded is not None:
+        return recorded
+    return run_dir / "state" / f"team-state-{task_type}-{seq}.json"
+
+
+def _team_state_from_manifests(run_dir: Path, report_name: str) -> Path | None:
+    # 최신 manifest 부터 본다 — 같은 보고서 자리를 이름한 run 이 여럿이면(앞선
+    # run 이 준비만 하고 끝난 경우) 마지막 run 이 그 보고서를 쓴 run 이다.
+    # `Path.glob` 는 디렉터리가 없어도 빈 결과를 낸다.
+    for manifest_path in sorted(
+        (run_dir / "manifests").glob("run-manifest-*.json"), reverse=True
+    ):
+        try:
+            manifest = load_owned_object(manifest_path, artifact="run manifest")
+        except (OSError, JsonBoundaryError):
+            # 깨진 manifest 는 이 보고서를 이름할 수 없다 — 다음 후보를 본다.
+            continue
+        expected = manifest.get("expectedReportRecordPath")
+        team_state = manifest.get("teamStatePath")
+        if not isinstance(expected, str) or not isinstance(team_state, str):
+            continue
+        if Path(expected).name != report_name or not team_state:
+            continue
+        return run_dir / "state" / Path(team_state).name
+    return None

package/runtime/python/okstra_ctl/verdict_blocks.py

@@ -106,10 +106,33 @@ def parse_finding_votes(text: str, *, adversarial: bool) -> dict[str, FindingVot
     an unfamiliar token silently read as a different verdict.
     """
     vocabulary = ADVERSARIAL_VERDICTS if adversarial else COLLABORATIVE_VERDICTS
-    return {
-        finding_id: _finding_vote(finding_id, fields, vocabulary)
-        for finding_id, fields in _scan_blocks(text).items()
-    }
+    return _collect_blocks(
+        _scan_blocks(text),
+        lambda item_id, fields: _finding_vote(item_id, fields, vocabulary),
+    )
+
+
+def _collect_blocks(blocks: dict[str, dict[str, str]], parse) -> dict:
+    """모든 블록을 읽고 결함을 한 번에 보고한다.
+
+    첫 결함에서 멈추면 15건 중 13건이 같은 결함인 응답도 한 건씩만 드러나,
+    교정 디스패치를 그 수만큼 반복하게 된다(2026-09-02 실측). 한 응답의 결함은
+    서로 독립이므로 전부 모아 하나의 오류로 낸다.
+    """
+    parsed: dict = {}
+    errors: list[str] = []
+    for item_id, fields in blocks.items():
+        try:
+            parsed[item_id] = parse(item_id, fields)
+        except VerdictBlockError as exc:
+            errors.append(str(exc))
+    if errors:
+        if len(errors) == 1:
+            raise VerdictBlockError(errors[0])
+        raise VerdictBlockError(
+            f"{len(errors)} of {len(blocks)} blocks are malformed: " + "; ".join(errors)
+        )
+    return parsed
 
 
 def _finding_vote(
@@ -155,10 +178,7 @@ class VerdictBlock:
 
 def parse_verdict_blocks(text: str) -> dict[str, VerdictBlock]:
     """Every `### <item-id>` plan-body verdict block in *text*, keyed by item id."""
-    return {
-        item_id: _block(item_id, fields)
-        for item_id, fields in _scan_blocks(text).items()
-    }
+    return _collect_blocks(_scan_blocks(text), _block)
 
 
 def _verdict_token(item_id: str, raw: str) -> tuple[str, str]: