okstra 0.179.2 → 0.180.0

package/runtime/schemas/report-narrative-v3.0.schema.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://okstra.dev/schemas/report-narrative-v3.0.json",
+  "title": "OKSTRA Report Writer Narrative Input (v3.0)",
+  "description": "Parsed report-writer Markdown. Only report-writer-owned judgments, plans, summaries, and user explanations are accepted.",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "humanSummary": {"type": "object"},
+    "verdictCard": {"type": "object"},
+    "rationale": {"type": "object"},
+    "summary": {"type": "array"},
+    "ticketCoverage": {"type": "object"},
+    "finalVerdict": {"type": "object"},
+    "requirementsDiscovery": {"type": "object"},
+    "improvementDiscovery": {"type": "object"},
+    "errorAnalysis": {"type": "object"},
+    "analysisCommon": {"type": "object"},
+    "projectAnalysis": {"type": "object"},
+    "featureAnalysis": {"type": "object"},
+    "changeImpactAnalysis": {"type": "object"},
+    "implementationOptionSelection": {"type": "object"},
+    "implementationPlanning": {"type": "object"},
+    "releaseHandoff": {"type": "object"},
+    "implementation": {"type": "object"},
+    "finalVerification": {"type": "object"},
+    "recommendedNextSteps": {"type": "array"},
+    "followUpTasks": {"type": "array"}
+  }
+}

package/runtime/templates/report-writer-prompt-preamble.md

@@ -1,37 +1,31 @@
 # Report Writer Prompt Preamble (canonical)
 
-This file is the audience-specific contract for `report-writer`. Read it end-to-end. Before work, also read the shared file named by `**Worker Error Contract Path:**`; error rules live only there.
+This file is the audience-specific contract for `report-writer`. Read it and the shared Worker Error Contract end-to-end.
 
-## Required reading
-
-Read every input enumerated by the Phase 6 dispatch end-to-end: task/analysis inputs, worker results, convergence state, the instruction-set-local `final-report-template.md`, and the task-type excerpt `final-report-schema.json`. Do not pull the full repository template or schema when the scoped instruction-set copies are provided.
+## Output ownership
 
-Write Reading Confirmation to `**Audit sidecar path:**`, not the rendered final report. Resolve `.okstra/**` paths against `**Project Root:**`.
+Write only the report narrative Markdown at `**Result Path:**`, the pointer record at `**Worker Result Path:**`, and the reading audit at `**Audit sidecar path:**`.
 
-Write `- PROGRESS: <stage> <ISO-8601-UTC>` there before reading and at least every five minutes while pending. The only valid report-writer stages are `started`, `required-reading-complete`, `synthesis-start`, `data-json-write-start`, `render-start`, and `write-result-start`.
+The report narrative Markdown contains the task judgment, plan, summaries, and user explanation. It must not write or patch `final-report-*.data.json`, the approval decision ledger, activity ledger, team state, convergence state, or design-preparation input.
 
-## Report authoring handoff
+The following fields belong to other owners and must not appear in the narrative: `designPreparation`, `designSurfaceCoverage`, `executionStatus`, `executionRoles`, `tokenUsage`, `crossVerification`, `approvalContext`, `clarificationItems`, `agentActivity`, and `planBodyVerification`.
 
-- Author the data.json at `**Result Path:**` and the audit file at `**Audit sidecar path:**`.
-- Follow the task-type schema excerpt and Phase 6 report-writer contract. Do not perform independent analysis, edit source code, or load implementation coding-preflight resources.
-- Do not invoke `okstra render-final-report`. The full reading copy is rendered on demand.
-- Preserve source item IDs, convergence classifications, round history, and unresolved dissent; do not recompute them from intuition.
-- Every `clarificationItems[]` row you leave `status: open` with `blocks: approval` carries `origin` and `userConfirmation`. `origin` is `worker-finding` only when an analyser or verifier reached it on its own evidence — when the lead's dispatch prompt told you to raise it, it is `lead-directed`, whatever the workers then agreed. `userConfirmation` is what the lead reports having done about it (`asked-and-answered` / `asked-awaiting` / `deferred-no-interactive-session`); if the dispatch does not say, write `asked-awaiting` and name the gap in your return message rather than guessing. An open approval blocker stops the whole task, so a row that misreports where it came from costs a re-run. **Enforced:** `validators/validate-run.py` `_validate_open_approval_blocker_provenance`.
+Do not pre-fill a future round, future gate, usage value, activity identifier, or resolution. Report assembly derives those values after their owner input exists.
 
-## Anchor headers
+## Required reading
 
-The generated prompt selects this file through `**Worker Preamble Path:**` and includes `**Worker Error Contract Path:**`, `**Audit sidecar path:**`, error paths, and read scope. It never includes `**Coding preflight pack:**`.
+Read every path listed under `## Inputs` end-to-end. Full context is available for synthesis, but read access does not transfer write ownership. Preserve supplied technical meaning and do not invent missing evidence.
 
-The adjacent v2 prompt metadata supplies `participantRef`, `roleExecutionRef`, `executionLabel`, `invocationRef`, and `attempt`. Copy those values into report and audit identity fields without deriving them from the provider or model. Legacy v1 `workerId` is a read-only compatibility projection and is not written into v2 artifacts.
+Write the audit sidecar before synthesis with one `- PROGRESS: <stage> <ISO-8601-UTC>` line and the required reading confirmation. Valid stages are `started`, `required-reading-complete`, `synthesis-start`, `narrative-write-start`, and `write-result-start`.
 
-## Return message to the lead
+## Narrative format
 
-Begin the inline return with the exact `**Model:** Report writer worker, <modelExecutionValue>` line from the prompt, followed by the artifact status. Never invent or abbreviate the model.
+Start with `# OKSTRA Report Narrative`. Encode fields as nested Markdown list entries using `- **Humanised Field Name**`; use `- Item N` for array entries and `> value` for scalar or multiline values. Follow the task-specific schema order and write the prose in English. JSON, YAML, JSON Pointer, and fenced JSON are not narrative syntax.
 
-## Writing style
+## Pointer record
 
-Use concise reader-facing prose. Prefer tables when several items share a shape; reserve bullets for short standalone statements.
+The pointer record names the project-relative narrative path and audit sidecar path. It does not contain the narrative, worker result corpus, or any machine-owned ledger.
 
-**Author the data.json in English, whatever `**Report Language:**` says.** That header is not an instruction to write in that language — it names the language the *human HTML* renders in, and you copy its value verbatim into `data.json.meta.reportLanguage`. The data.json is the English SSOT every later phase, validator and agent reads. When the value is not `en`, Phase 7 dispatches a separate translator worker that writes a sidecar the HTML renderer overlays; you never author that sidecar and never write a second language into the data.json.
+## Failure handling
 
-Authoring the data.json in the reader's language is rejected before anything derives from it: `okstra report-translate check-source` fails the run when Korean exceeds 20% of its prose, and the same gate runs again inside `validate-run`. The cost of getting this wrong is a full rewrite, so decide it once, up front.
+If a required narrative fact is missing or contradictory, record the report-writer error and stop. If report assembly later reports another owner, do not edit that owner's input; return the failure to the named owner.

package/runtime/templates/reports/html/macros/forms.html

@@ -63,6 +63,7 @@
   {% for row in items %}
   {% set is_closed = row.status in ['resolved', 'obsolete'] %}
   {% set approval_context = row.approvalContext | default(None) %}
+  {% set resolution = row.resolution | default(None) %}
   {% set options = row.options | default([]) %}
   <article class="clarification-item" id="id-{{ row.id }}" data-response-id="{{ row.id }}" data-kind="{{ row.kind }}" data-status="{{ row.status }}">
     <p class="eyebrow">{{ row.id }} · {{ row.kind }}</p>
@@ -72,9 +73,10 @@
     <div class="approval-context" data-approval-classification="{{ approval_context.classification }}">
       <p class="eyebrow">{{ approval_context.classification }}</p>
       <p><strong>{{ t('tasks.implementation-planning.unblock-condition') }}</strong> {{ approval_context.unblockCondition | inline_code }}</p>
-      <p><strong>{{ t('tasks.implementation-planning.agent-evidence') }}</strong>
-        {% for activity_id in approval_context.activityIds %}<a href="#id-{{ activity_id }}">{{ activity_id }}</a>{% if not loop.last %}, {% endif %}{% endfor %}
-      </p>
+      {% set check_refs = resolution.checkRefs if resolution else approval_context.activityIds | default([]) %}
+      {% if check_refs %}<p><strong>{{ t('tasks.implementation-planning.agent-evidence') }}</strong>
+        {% for activity_id in check_refs %}<a href="#id-{{ activity_id }}">{{ activity_id }}</a>{% if not loop.last %}, {% endif %}{% endfor %}
+      </p>{% endif %}
     </div>
     {% endif %}
     {% if options %}
@@ -85,7 +87,7 @@
         {% if option.disposition | default(None) %}<p class="clarification-option-disposition"><code>{{ option.disposition }}</code></p>{% endif %}
         <p class="clarification-option-rationale">{{ option.rationale }}</p>
         <dl class="clarification-option-impact">
-          <dt>{{ t('macros.forms.scope-impact') }}</dt><dd>{{ option.scopeImpact | join(', ') }}</dd>
+          <dt>{{ t('macros.forms.scope-impact') }}</dt><dd>{% if option.reach | default(None) %}{{ option.reach }}{% if option.scopeEffects | default([]) %}, {{ option.scopeEffects | join(', ') }}{% endif %}{% else %}{{ option.scopeImpact | join(', ') }}{% endif %}</dd>
           <dt>{{ t('macros.forms.added-work') }}</dt><dd>{{ option.addedWork }}</dd>
           <dt>{{ t('macros.forms.direction-change') }}</dt><dd>{{ option.directionChange }}</dd>
         </dl>

package/runtime/validators/validate-run.py

@@ -2890,7 +2890,7 @@ def validate_report(
     report_data: Mapping[str, Any] | None = None,
     team_state: Mapping[str, Any] | None = None,
 ) -> None:
-    if (report_data or {}).get("schemaVersion") == "2.0":
+    if (report_data or {}).get("schemaVersion") in {"2.0", "3.0"}:
         _validate_v2_report(report_data or {}, failures, team_state=team_state)
         return
 
@@ -3848,9 +3848,58 @@ def _classify_plan_item_gate(item: dict) -> str:
     # made the gate stricter than a healthy roster would.
     if len(non_error) >= 2 and len(blocking_disagree) > len(agree):
         return "majority-disagree"
+    # A tie is not consensus, and until now it read as one. The majority test is
+    # strict, so an even panel splitting 1-AGREE / 1-DISAGREE on a blocking kind
+    # fell through to `has-dissent` and the gate passed — the dissent recorded
+    # and never acted on. An even panel is not only the two-analyser roster: one
+    # UNVERIFIABLE or one lost dispatch turns any roster even for that item.
+    # Send the split back for a round; if it survives a round that judged the
+    # rewritten text, nothing further is going to settle it and the user decides.
+    # `_validate_unresolved_tie_was_reverified` is what makes the first branch
+    # more than a label — `needs-reverify` folds into `passed-with-dissent`.
+    if len(non_error) >= 2 and len(blocking_disagree) == len(agree):
+        if _max_verdict_round(item) >= _TIE_SETTLED_ROUND:
+            return "majority-disagree"
+        return "needs-reverify"
     return "has-dissent"
 
 
+# 동수를 한 번 재검증한 뒤에도 갈리면 그때는 사용자가 판단한다. 초기 검증이
+# 라운드 1이고 자가수정 뒤의 표적 재검증이 라운드 2이므로, 라운드 2 이상의
+# 판정이 붙은 동수는 이미 한 번 돌아온 것이다.
+_TIE_SETTLED_ROUND = 2
+
+
+def _max_verdict_round(item: dict) -> int:
+    """이 항목의 판정이 붙은 가장 늦은 라운드. 스탬프가 없으면 1.
+
+    `apply-verdicts --round <N>` 이 각 행을 찍는다. 스탬프가 없는 행은 자가수정이
+    한 번도 없었던 run 에서만 나오고, 그때는 라운드가 하나뿐이다.
+    """
+    rounds = [
+        verdict["round"]
+        for verdict in (item.get("verdicts") or [])
+        if isinstance(verdict, dict)
+        and isinstance(verdict.get("round"), int)
+        and not isinstance(verdict.get("round"), bool)
+    ]
+    return max(rounds, default=1)
+
+
+def _is_unsettled_tie(item: dict) -> bool:
+    """아직 재검증되지 않은 동수 항목."""
+    return (
+        _classify_plan_item_gate(item) == "needs-reverify"
+        and _max_verdict_round(item) < _TIE_SETTLED_ROUND
+        and len([
+            verdict for verdict in (item.get("verdicts") or [])
+            if isinstance(verdict, dict)
+            and str(verdict.get("verdict") or "").strip().upper()
+            not in ("", "VERIFICATION-ERROR")
+        ]) >= 2
+    )
+
+
 def _disagree_breakage_kinds(item: dict) -> set[str]:
     return {
         str(v.get("breakageKind") or "").strip().lower()
@@ -4536,6 +4585,8 @@ def _validate_approval_dispositions(
     row: dict,
     context: dict,
     failures: list[str],
+    *,
+    schema_version: str = "2.0",
 ) -> None:
     row_id = str(row.get("id") or "<unknown>")
     classification = str(context.get("classification") or "")
@@ -4546,7 +4597,11 @@ def _validate_approval_dispositions(
         for index, option in enumerate(row.get("options") or [])
         if isinstance(option, dict)
     )
-    resolution = context.get("resolution")
+    resolution = (
+        row.get("resolution")
+        if schema_version == "3.0"
+        else context.get("resolution")
+    )
     if isinstance(resolution, dict):
         candidates.append(("resolution.disposition", resolution.get("disposition")))
     for field, disposition in candidates:
@@ -4562,11 +4617,17 @@ def _validate_resolved_approval(
     row: dict,
     context: dict,
     failures: list[str],
+    *,
+    schema_version: str = "2.0",
 ) -> None:
     if row.get("status") != "resolved":
         return
     row_id = str(row.get("id") or "<unknown>")
-    resolution = context.get("resolution")
+    resolution = (
+        row.get("resolution")
+        if schema_version == "3.0"
+        else context.get("resolution")
+    )
     if not isinstance(resolution, dict):
         failures.append(
             f"final-report data.json: resolved approval clarification `{row_id}` "
@@ -4882,6 +4943,9 @@ def _validate_approval_context(
 ) -> None:
     if not _is_activity_contract_v1_planning(run_manifest):
         return
+    if data.get("schemaVersion") == "3.0":
+        _validate_v3_approval_context(data, failures)
+        return
     ip = data.get("implementationPlanning") or {}
     pbv = ip.get("planBodyVerification") or {}
     plan_items_by_id = {
@@ -4991,6 +5055,81 @@ def _validate_approval_context(
             )
 
 
+def _v3_expected_plan_backlinks(
+    activities: Mapping[str, dict],
+) -> dict[str, set[str]]:
+    expected: dict[str, set[str]] = {}
+    for activity in activities.values():
+        refs = {str(value) for value in activity.get("clarificationRefs") or []}
+        for item_id in activity.get("planItemIds") or []:
+            expected.setdefault(str(item_id), set()).update(refs)
+    return expected
+
+
+def _validate_v3_plan_backlinks(
+    data: dict, activities: Mapping[str, dict], failures: list[str],
+) -> None:
+    expected = _v3_expected_plan_backlinks(activities)
+    planning = data.get("implementationPlanning") or {}
+    verification = planning.get("planBodyVerification") or {}
+    for item in verification.get("planItems") or []:
+        if not isinstance(item, dict):
+            continue
+        item_id = str(item.get("id") or "")
+        actual = {str(value) for value in item.get("clarificationRefs") or []}
+        if actual != expected.get(item_id, set()):
+            failures.append(
+                f"final-report data.json: plan item `{item_id}` clarificationRefs "
+                "do not match activity-ledger backlinks."
+            )
+
+
+def _validate_v3_resolution_links(
+    row: dict, activities: Mapping[str, dict], failures: list[str],
+) -> None:
+    resolution = row.get("resolution")
+    if not isinstance(resolution, dict):
+        return
+    row_id = str(row.get("id") or "<unknown>")
+    for activity_id in resolution.get("checkRefs") or []:
+        activity = activities.get(activity_id)
+        if activity is None:
+            failures.append(
+                f"final-report data.json: clarification `{row_id}` references "
+                f"unknown activity `{activity_id}`."
+            )
+        elif row_id not in (activity.get("clarificationRefs") or []):
+            failures.append(
+                f"final-report data.json: activity `{activity_id}` does not "
+                f"link back to clarification `{row_id}`."
+            )
+
+
+def _validate_v3_approval_context(data: dict, failures: list[str]) -> None:
+    """검증 가능한 원장 참조만으로 v3 승인 역추적을 다시 계산한다."""
+    activities = _approval_activities_by_id(data)
+    _validate_v3_plan_backlinks(data, activities, failures)
+    approved = (data.get("frontmatter") or {}).get("approved") is True
+    for row in data.get("clarificationItems") or []:
+        if not isinstance(row, dict) or row.get("blocks") != "approval":
+            continue
+        context = row.get("approvalContext")
+        if not isinstance(context, dict):
+            continue
+        _validate_approval_dispositions(
+            row, context, failures, schema_version="3.0"
+        )
+        _validate_resolved_approval(
+            row, context, failures, schema_version="3.0"
+        )
+        _validate_v3_resolution_links(row, activities, failures)
+        if approved and row.get("status") in {"open", "answered"}:
+            failures.append(
+                f"final-report data.json: approval is true while clarification "
+                f"`{row.get('id')}` remains `{row.get('status')}`."
+            )
+
+
 def _validate_activity_contract_plan_limits(
     data: dict,
     run_manifest: dict,
@@ -5435,7 +5574,7 @@ def _validate_clarification_evidence_note(data: dict, failures: list[str]) -> No
         )
 
 
-_CLARIFICATION_OPTION_SCHEMA_VERSION = "2.0"
+_CLARIFICATION_OPTION_SCHEMA_VERSIONS = frozenset({"2.0", "3.0"})
 # The four profiles that read `_clarification-recommendation.md`. Unlike the
 # evidence-note gate above — which is called from inside the
 # `implementation-planning` branch — this one is called phase-agnostically, so
@@ -5508,7 +5647,7 @@ def _validate_clarification_options(data: dict, failures: list[str]) -> None:
     demanding one would fail every v1 `decision` row for a structure the format
     has no place to hold.
     """
-    if data.get("schemaVersion") != _CLARIFICATION_OPTION_SCHEMA_VERSION:
+    if data.get("schemaVersion") not in _CLARIFICATION_OPTION_SCHEMA_VERSIONS:
         return
     task_type = (data.get("header") or {}).get("taskType")
     if task_type not in _CLARIFICATION_OPTION_TASK_TYPES:
@@ -5517,7 +5656,10 @@ def _validate_clarification_options(data: dict, failures: list[str]) -> None:
         if not isinstance(row, dict) or row.get("kind") != "decision":
             continue
         row_id = str(row.get("id") or "<unknown>")
-        _validate_option_set(row.get("options"), row_id, failures)
+        _validate_option_set(
+            row.get("options"), row_id, failures,
+            schema_version=str(data.get("schemaVersion") or ""),
+        )
         if _LEGACY_EXPECTED_FORM_RE.search(str(row.get("expectedForm") or "")):
             failures.append(
                 f"final-report data.json: clarification `{row_id}` still encodes "
@@ -5529,7 +5671,7 @@ def _validate_clarification_options(data: dict, failures: list[str]) -> None:
 
 
 def _validate_option_set(
-    options: object, row_id: str, failures: list[str]
+    options: object, row_id: str, failures: list[str], *, schema_version: str = "2.0"
 ) -> None:
     """Check one `decision` row's `options[]` for pickability and reach."""
     if not isinstance(options, list) or len(options) < 2:
@@ -5550,7 +5692,9 @@ def _validate_option_set(
     for index, option in enumerate(entries):
         tokens = option.get("scopeImpact")
         reach = (
-            [token for token in tokens if token in _REACH_TOKENS]
+            [str(option.get("reach"))]
+            if schema_version == "3.0" and option.get("reach") in _REACH_TOKENS
+            else [token for token in tokens if token in _REACH_TOKENS]
             if isinstance(tokens, list)
             else []
         )
@@ -6697,6 +6841,53 @@ def _validate_round_recorded_verdicts(data: dict, failures: list[str]) -> None:
     )
 
 
+def _validate_unresolved_tie_was_reverified(
+    data: dict,
+    failures: list[str],
+) -> None:
+    """A split panel is sent back once before the gate is declared.
+
+    The gate needs a strict majority to block, so a panel splitting evenly on a
+    blocking kind reaches neither consensus nor `majority-disagree`. That state
+    is classified `needs-reverify`, and `needs-reverify` folds into
+    `passed-with-dissent` — which is correct for the shape it was built for (a
+    peer that returned nothing) and wrong for this one: nothing failed here, two
+    verifiers read the same plan and disagreed, and passing on that records a
+    dissent nobody acted on.
+
+    So the round is not optional. Re-dispatch those items and record the votes
+    with `--round 2`; a split that survives becomes `majority-disagree` and the
+    user decides. This is satisfiable with the machinery the contract already
+    defines — it is the same targeted re-verification step 7 runs after a
+    self-fix, with the tied items added to that queue.
+    """
+    ip = data.get("implementationPlanning")
+    if not isinstance(ip, dict):
+        return
+    pbv = ip.get("planBodyVerification")
+    if not isinstance(pbv, dict):
+        return
+    unsettled = sorted({
+        str(item.get("id") or "").strip()
+        for item in pbv.get("planItems") or []
+        if isinstance(item, dict)
+        and not item.get("carriedForwardFromSeq")
+        and _is_unsettled_tie(item)
+    })
+    if not unsettled:
+        return
+    failures.append(
+        f"final-report data.json: plan item(s) {unsettled} carry an even split "
+        "on a blocking breakage kind and were never re-verified. A tie is not "
+        "consensus: the gate's majority test is strict, so this split neither "
+        "blocks nor resolves, and declaring the gate on it passes a dissent "
+        "nobody settled. Re-dispatch those items in a plan-body round and "
+        "record the votes with `okstra plan-items apply-verdicts --data "
+        "<data.json> --verdicts <verdicts.json> --round 2`. A split that "
+        "survives that round becomes `majority-disagree` and goes to the user."
+    )
+
+
 def _validate_verdict_rounds_outlive_self_fix(
     data: dict,
     failures: list[str],
@@ -7794,6 +7985,7 @@ def validate_plan_body_section(
     _validate_round_recorded_verdicts(data, failures)
     _validate_verdicts_match_current_subjects(data, failures)
     _validate_verdict_rounds_outlive_self_fix(data, failures)
+    _validate_unresolved_tie_was_reverified(data, failures)
     _validate_plan_item_extraction_completeness(data, failures)
     _validate_plan_item_subject_substance(data, failures)
     _validate_plan_body_clarification_matching(data, failures, accepted_item_ids)
@@ -9272,6 +9464,52 @@ def run_plan_body_section(report_path: Path) -> int:
     return 0 if not failures else 2
 
 
+def run_plan_body_inputs(narrative_path: Path, state_path: Path) -> int:
+    """게시 전 서사와 수렴 소유 상태에서 같은 계획 게이트를 채점한다."""
+    from okstra_ctl.report_narrative import parse_narrative
+    from okstra_ctl.final_report_schema import load_schema_version
+
+    try:
+        narrative = parse_narrative(
+            narrative_path.read_text(encoding="utf-8"),
+            load_schema_version("3.0"),
+        )
+        state = json.loads(state_path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, ValueError) as exc:
+        print(f"validate-run: plan-body inputs are invalid ({exc})", file=sys.stderr)
+        return 2
+    state_owner = state.get("owner") if isinstance(state, dict) else None
+    verification = state.get("planBodyVerification") if isinstance(state, dict) else None
+    planning = narrative.get("implementationPlanning")
+    if state_owner != "convergence" or not isinstance(verification, dict):
+        print("validate-run: plan-body state must be convergence-owned", file=sys.stderr)
+        return 2
+    if not isinstance(planning, dict):
+        print("validate-run: narrative has no implementationPlanning", file=sys.stderr)
+        return 2
+    data = {**narrative, "schemaVersion": "3.0"}
+    data["implementationPlanning"] = {**planning, "planBodyVerification": verification}
+    failures: list[str] = []
+    warnings = validate_plan_body_section(data, _report_path_for_state(state_path), failures)
+    payload = {
+        "ok": not failures,
+        "section": SECTION_PLAN_BODY,
+        "gate": plan_body_gate_summary(data),
+        "failures": failures,
+        "warnings": warnings,
+    }
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+    return 0 if not failures else 2
+
+
+def _report_path_for_state(state_path: Path) -> Path:
+    match = re.search(r"-(\d{3})\.json$", state_path.name)
+    seq = match.group(1) if match else "001"
+    return state_path.parent.parent / "reports" / (
+        f"final-report-implementation-planning-{seq}.data.json"
+    )
+
+
 def _data_schema_failures(data: dict) -> list[str]:
     """Schema errors in the round's data.json, as failures.
 
@@ -9315,9 +9553,11 @@ def main() -> int:
     )
     parser.add_argument(
         "--report",
-        required=True,
+        required=False,
         help="Project-relative or absolute path to the report record (.data.json). Schema-v1 reports still use the Markdown file.",
     )
+    parser.add_argument("--narrative", required=False)
+    parser.add_argument("--state", required=False)
     parser.add_argument(
         "--run-manifest",
         required=False,
@@ -9343,7 +9583,15 @@ def main() -> int:
     args = parser.parse_args()
 
     if args.section == SECTION_PLAN_BODY:
-        return run_plan_body_section(Path(args.report).resolve())
+        if args.narrative and args.state and not args.report:
+            return run_plan_body_inputs(
+                Path(args.narrative).resolve(), Path(args.state).resolve()
+            )
+        if args.report and not args.narrative and not args.state:
+            return run_plan_body_section(Path(args.report).resolve())
+        parser.error(
+            "--section plan-body requires either --report or both --narrative and --state"
+        )
 
     missing = [
         f"--{flag.replace('_', '-')}"