okstra 0.219.1 → 0.220.1

package/runtime/python/okstra_ctl/lead_progress.py

@@ -18,12 +18,14 @@ import argparse
 import json
 import sys
 from collections.abc import Mapping, Sequence
+from dataclasses import replace
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
 from okstra_ctl.json_boundary import JsonBoundaryError, load_owned_object
-from okstra_ctl.lead_events import LeadEvent, append_lead_event
+from okstra_ctl.lead_events import LeadEvent, append_lead_event, read_lead_events
+from okstra_ctl.phases import catalog
 
 
 class ProgressRecordError(ValueError):
@@ -64,6 +66,11 @@ _DEFAULT_DETAIL: Mapping[str, str] = {
     "phase-7-teardown": "shutting-down-workers",
 }
 
+# phase 하나에 문구가 둘인 체크포인트. 고정 표만으로는 두 번째 호출이 첫 문구를
+# 다시 내므로, 원장과 task type 을 보고 고른다.
+_INTAKE_COMPLETE_DETAIL = "complete"
+_LEAD_ONLY_SYNTHESIS_DETAIL = "authoring final report"
+
 
 def _utc_now() -> str:
     return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
@@ -165,6 +172,39 @@ def _parse_field(raw: str) -> tuple[str, str]:
     return name.strip(), field_value.strip()
 
 
+def _intake_already_started(events_path: Path, event: LeadEvent) -> bool:
+    return any(
+        prior.event_type == "progress"
+        and prior.details.get("phase") == "phase-1-intake"
+        and (prior.task_key, prior.task_type, prior.run_seq)
+        == (event.task_key, event.task_type, event.run_seq)
+        for prior in read_lead_events(events_path)
+    )
+
+
+def _task_type_dispatches_report_writer(task_type: str) -> bool:
+    if task_type not in catalog.task_types():
+        return True
+    package = catalog.phase_record(task_type).package_name
+    profile = _read_json_object(
+        Path(catalog.__file__).parent / package / "profile.json", "phase profile"
+    )
+    return any(
+        isinstance(row, Mapping) and row.get("roleId") == "report-writer"
+        for row in profile.get("roles") or []
+    )
+
+
+def _default_detail(phase: str, events_path: Path, event: LeadEvent) -> str | None:
+    if phase == "phase-1-intake" and _intake_already_started(events_path, event):
+        return _INTAKE_COMPLETE_DETAIL
+    if phase == "phase-6-synthesis" and not _task_type_dispatches_report_writer(
+        event.task_type
+    ):
+        return _LEAD_ONLY_SYNTHESIS_DETAIL
+    return _DEFAULT_DETAIL.get(phase)
+
+
 def render_progress_line(
     phase: str,
     fields: Sequence[tuple[str, str]] = (),
@@ -199,7 +239,9 @@ def record_progress(
         )
         ordered.append(("worker", role))
     ordered.extend(fields)
-    line = render_progress_line(phase, ordered, detail)
+    events_path = _resolve_project_path(
+        project_root, _require_string(manifest, "leadEventsPath")
+    )
     event = LeadEvent(
         event_type="progress",
         lead_runtime=_require_string(manifest, "leadRuntime"),
@@ -207,15 +249,15 @@ def record_progress(
         task_type=_require_string(manifest, "taskType"),
         run_seq=_manifest_run_seq(manifest),
         timestamp=timestamp or _utc_now(),
-        details={
-            "phase": phase,
-            "line": line,
-            **({name: field_value for name, field_value in ordered}),
-        },
-    )
-    events_path = _resolve_project_path(
-        project_root, _require_string(manifest, "leadEventsPath")
     )
+    if detail is None:
+        detail = _default_detail(phase, events_path, event)
+    line = render_progress_line(phase, ordered, detail)
+    event = replace(event, details={
+        "phase": phase,
+        "line": line,
+        **({name: field_value for name, field_value in ordered}),
+    })
     append_lead_event(events_path, event)
     return event, warning
 
@@ -306,7 +348,10 @@ def _parser() -> argparse.ArgumentParser:
         help="extra `NAME=VALUE` token, in the order given")
     append_parser.add_argument(
         "--detail",
-        help="verb phrase after the fields; contract wording is the default")
+        help="verb phrase after the fields; contract wording is the default "
+             "(a second phase-1-intake renders `complete`, and phase-6-synthesis "
+             "in a task type without a report writer renders "
+             "`authoring final report`)")
     return parser
 
 

package/runtime/python/okstra_ctl/manager_cli.py

@@ -332,6 +332,7 @@ def _parser() -> argparse.ArgumentParser:
     run.add_argument("--task-group", required=True)
     run.add_argument("--task-id", required=True)
     run.add_argument("--child-task-id", default=None)
+    run.add_argument("--allow-completed", action="store_true")
 
     split = task_sub.add_parser("split")
     split.add_argument("--manager-id", required=True)
@@ -466,6 +467,7 @@ def main(argv: list[str] | None = None) -> int:
                     args.task_id,
                     args.project_id,
                     child_task_id=args.child_task_id,
+                    allow_completed=args.allow_completed,
                 ),
                 args.json,
             )

package/runtime/python/okstra_ctl/manager_launch.py

@@ -20,7 +20,7 @@ from .manager_paths import (
     task_manifest_path,
 )
 from .manager_store import ManagerError, _now_iso, _read_json, _read_json_default, _write_json
-from .manager_sync import _resolve_task_root_read_only
+from .manager_sync import _snapshot_child, summary_bucket
 
 
 WORKER_DISPATCH_BACKEND = "subagent"
@@ -222,6 +222,25 @@ def _record_launch_prepared(
     )
 
 
+def _current_child_state(project_root: str, child: dict, target_task_key: str, *, allow_completed: bool) -> dict:
+    """대상 하위 task 를 마지막 sync 가 아니라 지금 프로젝트에서 다시 읽는다.
+
+    스냅샷은 sync 시점 값이라, 그 뒤 프로젝트에서 끝난 task 에 런치 패킷을 만들면 같은 일을 두 번 시킨다.
+    """
+    current = _snapshot_child(Path(project_root), {**child, "taskKey": target_task_key})
+    if current.get("error"):
+        raise ManagerError(f"{target_task_key}: cannot read child task state: {current['error']}")
+    if summary_bucket(current) == "done" and not allow_completed:
+        report = current.get("latestReportRecordPath") or ""
+        raise ManagerError(
+            f"{target_task_key}: already done in its project "
+            f"(last phase {current.get('lastCompletedPhase') or current.get('currentPhase') or 'unknown'}, "
+            f"report {Path(project_root) / report if report else 'none'}); nothing to launch. "
+            "Run `okstra manager task sync` to refresh the manager, or pass --allow-completed to prepare a launch anyway"
+        )
+    return current
+
+
 def build_launch_packet(
     home: Path,
     manager_id: str,
@@ -230,6 +249,7 @@ def build_launch_packet(
     project_id: str,
     *,
     child_task_id: str | None = None,
+    allow_completed: bool = False,
     now: str | None = None,
 ) -> dict:
     manifest = _read_json(task_manifest_path(home, manager_id, task_group, task_id))
@@ -244,6 +264,7 @@ def build_launch_packet(
     target_task_key = _target_task_key(project_id, task_group, child_task_id_value)
     _validate_child_task_key(child, target_task_key)
     project_root = _validated_project_root(project)
+    current = _current_child_state(project_root, child, target_task_key, allow_completed=allow_completed)
     created_at = now or _now_iso()
     brief_path = (Path(str(child["briefPath"])) if child.get("briefPath")
                   else _discussion_follow_up_brief(snapshot, target_task_key))
@@ -277,7 +298,7 @@ def build_launch_packet(
     # phase 를 채워야 하는데, 두 값이 다 주어지면 그 채우기를 건너뛴다(autofill_from_manifest).
     # 토론 후속 브리프는 권장 phase 를 따로 적지 않아도 requirements-discovery 에서 시작한다.
     recommended = child.get("recommendedPhase") or (DISCUSSION_FOLLOW_UP_PHASE if discussion_ref else "")
-    if recommended and _resolve_task_root_read_only(Path(project_root), target_task_key) is None:
+    if recommended and not current["exists"]:
         run_args.extend(["--task-type", str(recommended)])
     if brief_path is not None:
         run_args.extend(["--task-brief", str(brief_path)])

package/runtime/python/okstra_ctl/phases/implementation/instructions/_implementation-deliverable.md

@@ -13,11 +13,12 @@ are collected and convergence finished. Phase 1-5 do not need it.
 - **Plan link & approval evidence**: path to the approved `final-report.md`, the exact quoted approval marker, AND the executed stage number / title quoted from the Stage Map row. For a selected-direction plan, also quote `selectedDirectionRef.optionId`, `snapshotPath`, and the validated snapshot digest; for a legacy plan, quote the effective `implementation-option` or the Recommended Option fallback.
 - **Commit list**: each commit's SHA (or short SHA), message, and the plan step(s) / TDD cycle it satisfies. A lead minor fix commit is listed too, with `planStep` `Lead minor fix (<finding ids>)`.
 - **Lead minor fixes**: when the lead fixed verifier findings in this run, pass each `implementation.leadFixes[]` entry to the report writer as recorded (§"Lead minor fix"). Omit the field when there was none.
+- **Correction rounds**: when this run ran correction rounds, pass one `implementation.correctionRounds[]` entry per round to the report writer — `round`, `findingIds`, `baseCommit`, `commit`, each verifier's re-verification `verifierVerdicts`, and `result` (§"Correction round"). `verifierResults` then carries the last round's verdicts. Omit the field when there was none.
 - **Diff summary**: capture `git diff --stat <base>..<captured-head>` and `git diff --numstat <base>..<captured-head>` for the full implementation stage, including after a fix run. Supply both outputs to the report writer; put each file's added/deleted counts alone in `diffSummary.files[].lines` (`+150/-0`) and one sentence on what the change in that file does in `diffSummary.files[].summary` — the report renders `summary` as the file's "what it does" column and `lines` as a separate number column. Do not substitute a fix-run aggregate or carry forward older statistics. If the captured commits are unavailable, identify the missing reference in the evidence instead of inventing counts.
 - **Change narrative scope**: `userNarrative.changeExplanation` describes the same scope as `diffSummary` — the whole stage from its base, every file the table lists. On a fix run, state what the fix run itself changed (its commits and files) as a separate sentence; never present the fix-run delta as the stage's change.
 - **Out-of-plan edits block**: every file edited that was not in the approved plan's file list, with rationale (empty block is acceptable and preferred)
 - **Clarification answers carried in**: when `instruction-set/clarification-response.md` exists, it holds the user's answers to the approved plan's `## 1. Clarification Items` rows. The report MUST render the `## 0. Clarification Response Carried In From Previous Run` section (set `clarificationCarryIn.sourceFile` to that path) and, for every carried-over `## 1.` row whose answer appears there, record the answer in the `User input` cell and flip `Status` to `resolved`. A row left `open`/`answered` despite a matching user answer is a contract violation; an answer that materially changes scope beyond the approved plan is routed to a new `implementation-planning` run, not silently executed.
-- **Stage sidecar evidence**: set `stageSidecarEvidence.carryJson` to the path `runs/<impl-task-key>/carry/stage-<N>.json` followed by a one-line summary of its payload — stage number, step results by status, stage commit range, number of files changed. Do not paste the payload itself: the file on disk is the record (`_validate_stage_carry_sidecar_exists` checks that it exists), and a pasted one-line JSON is unreadable in the report. Quote the `consumers.jsonl` rows this run appended line-by-line in `consumerRows`.
+- **Stage sidecar evidence**: set `stageSidecarEvidence.carryJson` to the `carryPath` that `okstra stage-done` printed — the flat `runs/implementation/carry/stage-<N>.json`, never a path under the run's `stage-<N>/` directory — followed by a one-line summary of its payload — stage number, step results by status, stage commit range, number of files changed. Do not paste the payload itself: the file on disk is the record (`_validate_stage_carry_sidecar_exists` checks that it exists), and a pasted one-line JSON is unreadable in the report. Quote the `consumers.jsonl` rows this run appended line-by-line in `consumerRows`.
 - **Validation evidence**: actual command output (stdout/stderr) for every `pre / mid / post` validation command from the plan. Truncated output is acceptable but the command line and exit code MUST be exact. No paraphrasing of test results. Set `checkId` to the plan's `validationChecklist` id (`VC-007`) when the row runs a checklist command, and `advisory: true` on a row whose check is advisory (an external Tier 3 conformance entry, for example) so a non-zero exit there is not shown as a failure.
 - **TDD evidence (when applicable)**: for steps that should be TDD-ordered, show the failing-test output captured BEFORE the merged commit and the passing-test output after, citing the single `feat|fix` commit SHA (test and implementation share one commit).
 - **Verifier results**: a section per verifier present in the resolved roster (`Claude verifier`, `Codex verifier`, and `Antigravity verifier` when opted in) containing:
@@ -46,7 +47,7 @@ are collected and convergence finished. Phase 1-5 do not need it.
 
 When the synthesised verdict would be `FAIL` only because of verifier findings that are small and local, the lead fixes them itself in this run instead of ending it and opening a fix run. Decide after Phase 5.5 convergence, before building the report-writer dispatch prompt and before "Lead post-stage persistence" below. No worker dispatch is open then, so the edit falls inside no read-only worker's mutation audit window. Never edit while a verifier, convergence, or report-writer dispatch is running: its audit reports `readonly source changed` and discards that worker's result.
 
-**Eligibility.** Every rule holds for every blocking finding of the round, or the lead fixes none of them and the normal FAIL → fix-run path applies:
+**Eligibility.** Every rule holds for every blocking finding of the round, or the lead fixes none of them and §"Correction round" decides whether the executor fixes them in this run:
 
 1. The fix is a code change at, or next to, the location the verifier cited.
 2. The lead's total diff is at most 30 changed lines (added plus deleted, `git diff --numstat`).
@@ -65,10 +66,32 @@ A finding that needs no code change (convergence settled it as a verifier misrea
 
 **Record.** One `implementation.leadFixes[]` entry per fixed finding group: `findingIds`, `verifiers` (the `verifierResults[].verifier` names whose FAIL it answers — every `FAIL` row is named by a passing entry before the stage may settle), `summary` (one sentence on what changed), `commit` (full SHA), `files`, `changedLines`, `commands[]` (`command`, `exitCode`, `outputTail`), and `result`. Keep each verifier's `FAIL` row as written. Leave the fixed findings out of `humanSummary.blockers`, and state in `userNarrative.validationExplanation` that the lead fixed them in this run.
 
-**Persistence after a passing fix.** The executor's `### Stage Carry Evidence` was emitted before the fix and names the pre-fix head. Before writing the carry sidecar, set `stageCommitRange.head` to the post-fix HEAD (`git rev-parse HEAD` in the stage worktree), add the fixed files to `filesChanged`, and append one `notes` line naming the lead commit and the finding ids. `stepResults` stays as the executor wrote it: a lead fix is not a plan step. Append the `done` row after the fix commit, so its `head_commit` is the post-fix HEAD, and capture `diffSummary` against the same head.
+**Persistence after a passing fix.** The executor's `### Stage Carry Evidence` was emitted before the fix and names the pre-fix head. Before passing the carry to `okstra stage-done`, set `stageCommitRange.head` to the post-fix HEAD (`git rev-parse HEAD` in the stage worktree), add the fixed files to `filesChanged`, and append one `notes` line naming the lead commit and the finding ids. `stepResults` stays as the executor wrote it: a lead fix is not a plan step. Append the `done` row after the fix commit, so its `head_commit` is the post-fix HEAD, and capture `diffSummary` against the same head.
 
 **Enforced:** `validators/validate-run.py` `_validate_lead_fixes` (blocking) fails an entry recorded `pass` whose command exited non-zero or that has no command, an entry over 30 changed lines, and a settled stage holding a `result: fail` entry; it reports (advisory) a settled stage whose `FAIL` row no passing entry names in `verifiers` — advisory because validate-run runs after the `done` row is appended, so blocking would undo nothing. `_validate_lead_fix_carry_head` (advisory) reports a carry sidecar whose head is not a passing lead fix commit. Eligibility rules 1, 3, 4 and 5 and the match between findings and `findingIds` are instructions only: the report carries no structured finding id or planned-path list to compare against.
 
+## Correction round (decided after convergence, before the report-writer dispatch)
+
+When the synthesised verdict is `FAIL` and the lead minor fix does not apply, the executor fixes the confirmed findings in this run and the verifiers re-verify the fix, instead of ending the run and opening a fix run. At most **2** rounds per run.
+
+**Entry.** Every blocking finding of the round meets all of these, or the run ends `FAIL` as before:
+
+1. A verifier cited where it is (`path:line`) and what the correct result is.
+2. The fix stays inside this stage's `plannedPaths` or files the executor already changed.
+3. It needs no new plan step, dependency, schema, migration, or config of record — a finding that does is a plan change: end the run `FAIL` and route by `prompts/lead/phase-routing.md`.
+
+Changing a test's expected value is allowed here when the finding shows the oracle is wrong, because the verifiers re-verify the fix.
+
+**Procedure for round `<N>`.**
+
+1. Record the stage HEAD as `<base>` (`git rev-parse HEAD` in the stage worktree).
+2. Write the executor instruction with `okstra correction prompt --run-manifest <path> --round <N> --role executor --base <base> --finding <F-id> [--finding <F-id> ...]` into a file under the run's `state/`, then materialize it with `okstra agent-prompt materialize` — `--audience implementation-executor`, `--assignment-ref initial/<executor worker id>`, `--dispatch-kind correction-r<N>`, a new `--invocation-id` ending `-correction-r<N>-<executor worker id>`, and a result path `<executor worker id>-worker-correction-r<N>-implementation-<seq>.md`. Build a jobs file with `okstra agent-prompt jobs --dispatch-kind correction-r<N>`, dispatch it alone with `okstra team dispatch --jobs-file <path> --dispatch-kind correction-r<N>`, and settle it with `okstra team await`.
+3. Do the same for every verifier with `--role verifier`, `--audience implementation-verifier`, its own `initial/<verifier worker id>` assignment, and result `<verifier worker id>-worker-correction-r<N>-implementation-<seq>.md`; dispatch the verifiers in one batch without the executor.
+4. Converge the re-verification results the way the initial round was converged, restarting Phase 5.5 with `okstra convergence seed ... --restart-from-round0`.
+5. No re-verification verdict is `FAIL`: the round `result` is `pass` and the run continues to persistence with the post-fix head. Otherwise `result: fail`; start round `<N+1>` if the cap allows and the entry rules still hold, or end the run `FAIL`.
+
+**Enforced:** `scripts/okstra_ctl/dispatch_core.py` `_validate_correction_rounds` (via `correction_round.validate_correction_dispatch`) refuses a round past the cap, a verifier dispatch before that round's executor returned an `ok` result, a second executor fix in the same round, and round `<N+1>` before round `<N>` was re-verified. `validators/validate-run.py` `_validate_correction_rounds` (blocking) fails a report whose `correctionRounds` differ from the correction rounds the run dispatched, whose rounds are not 1, 2 in order, whose `result` contradicts its verdicts, or whose `verifierResults` are not the last round's verdicts. The entry rules are instructions only.
+
 ## Self-review pass before finalising the report (the Okstra lead runs this; do not delegate it)
 
 1. **Plan coverage** — for a selected-direction plan, every step in the approved `plan-ready` stage must point to a commit (or an explicit `Skipped: <reason>` entry), and the diff must preserve the selected snapshot's mechanism and invariants. For a legacy plan, every step in the effective implementation option (explicit frontmatter value or Recommended Option fallback) must point to a commit or an explicit skip. List gaps. A `RED:` step and its `GREEN:` step pointing to the same merged commit SHA is NOT a coverage gap — one SHA may be shared by both.
@@ -90,10 +113,10 @@ A finding that needs no code change (convergence settled it as a verifier misrea
 
 - Parse the executor's `### Stage Carry Evidence` JSON block. If absent or unparsable, end with status `contract-violated` and route to a follow-up `error-analysis`.
 - The `### Stage Carry Evidence` JSON may include `designPrepEvidence[]`. Emit a row only when this stage produced concrete evidence that refines an effective PREP item: `itemId`, the injected `assessmentFingerprint`, `resolution`, and non-empty `evidence[]` are required; `overrides` is optional and only records observed, non-authoritative refinements. Carry evidence never represents user approval. Downstream resolution accepts it only from transitive dependency stages with the matching fingerprint.
-- **A `FAIL` synthesised verdict withholds the two writes below.** A verifier `FAIL` that a passing lead minor fix answered does not make the verdict `FAIL` (§"Lead minor fix"); persist with the post-fix head it names. They are what marks the stage `done`, so performing them on a stage whose verifier found a blocking defect stacks the next stage on a confirmed regression. When the synthesised verdict is `FAIL`: write NO carry sidecar, and append a `status:"failed"` row in place of the `done` row — same `okstra_ctl.consumers.append_consumer` call, carrying `report_path` and the SHA of HEAD. That row is terminal *without* completion: dependent stages stay blocked because this stage is not done, while its worktree-registry occupancy is released so a fix run can re-enter the same stage number — `--stage <N>` reuses the preserved worktree and branch instead of provisioning a new one. State the reason in the report's `Stage sidecar evidence` section as `withheld`. **Enforced:** `validators/validate-run.py` `_validate_stage_carry_sidecar_exists` accepts a missing carry file only when that field is non-empty, so silently skipping the sidecar still fails the run.
+- **A `FAIL` synthesised verdict withholds the two writes below.** A verifier `FAIL` that a passing lead minor fix answered does not make the verdict `FAIL` (§"Lead minor fix"); persist with the post-fix head it names. They are what marks the stage `done`, so performing them on a stage whose verifier found a blocking defect stacks the next stage on a confirmed regression. When the synthesised verdict is `FAIL`: write NO carry sidecar, and append a `status:"failed"` row in place of the `done` row with `okstra stage-fail <impl-task-key> --stage <N> --head-commit <HEAD sha> --report <this run's final-report path> --reason "<blocking finding ids>"` (it calls `append_consumer`, so the consumers lock and the registry release apply; do not call python directly). That row is terminal *without* completion: dependent stages stay blocked because this stage is not done, while its worktree-registry occupancy is released so a fix run can re-enter the same stage number — `--stage <N>` reuses the preserved worktree and branch instead of provisioning a new one. State the reason in the report's `Stage sidecar evidence` section as `withheld`. **Enforced:** `validators/validate-run.py` `_validate_stage_carry_sidecar_exists` accepts a missing carry file only when that field is non-empty, so silently skipping the sidecar still fails the run.
 - **A run that ends with no verifier result still closes.** When the stage ends before any verifier returned a verdict — the executor stopped without a change and the user chose not to verify, or every dispatched verifier ended without a result — append the `failed` row as above, record each roster verifier `not-run` with its reason (`okstra worker-state transition --team-state <path> --worker <worker-id> --status not-run --reason <text>`; a worker the dispatch skipped already carries one), and write the convergence state with `okstra convergence skip --run-manifest <path> --reason <text>` before dispatching the report writer. Without that state the report-writer packet refuses with `convergence … required source is missing`. The command refuses while any analyser, verifier, or critic attempt returned a result or is still running; such a run converges normally. In the report, write each verifier's `verifierResults[]` row as `verdict: not-run`, and state the reason under `Stage sidecar evidence` as `withheld`.
-- On a non-`FAIL` verdict, for this run's single stage: write its JSON verbatim to `runs/<impl-task-key>/carry/stage-<N>.json` — after a passing lead minor fix, with the head, files, and note that §"Lead minor fix" adds. Refuse to overwrite an existing file (one stage = one sidecar; a fix run re-entering after a `failed` row writes the first one, because a withheld stage never wrote it). A stage reopened after a `done` row (see "Reopening a settled stage" below) still has the sidecar of the run that first settled it, naming a head the stage has since moved past: move it unchanged to `runs/<impl-task-key>/carry/superseded/stage-<N>-from-<that run's task-type>-<seq>.json` before writing the new one, and name both paths in `Stage sidecar evidence`. Do not rename it inside `carry/`: the readers glob `carry/stage-*.json` (`okstra_ctl.stage_map`, `okstra_ctl.consumers.backfill_done_from_carry`), so a renamed file there is read again as a live sidecar. A reopened stage whose run ends `FAIL` writes nothing and leaves the old file where it is.
-- On a non-`FAIL` verdict, for this run's single stage: append a `status:"done"` row to `runs/<plan-task-key>/consumers.jsonl` with `completed_at`, `carry_path`, `report_path` (this run's final-report path relative to the run root), and the SHA of HEAD. Append it with `okstra_ctl.consumers.append_consumer` (NOT a raw filesystem write) — that call honours the consumers lock AND releases this stage's worktree-registry occupancy, so later runs stop seeing a finished stage as a concurrent run. `report_path` lets `final-verification` cite each stage's originating report when assembling its Source Implementation Report list.
+- On a non-`FAIL` verdict, for this run's single stage: save the executor's `### Stage Carry Evidence` JSON (after a passing lead minor fix, with the head, files, and note that §"Lead minor fix" adds; after a correction round, the last round's executor block) to a file under this run's `state/`, then run `okstra stage-done <impl-task-key> --stage <N> --carry <that file> --report <this run's final-report path>`. It writes the sidecar to the flat `runs/implementation/carry/stage-<N>.json` (the readers glob `carry/stage-*.json`: `okstra_ctl.stage_map`, `okstra_ctl.consumers.backfill_done_from_carry`, and validate-run's `RunRef.carry`), refuses to replace another head's sidecar of a stage that was never settled, and for a stage reopened after a `done` row (see "Reopening a settled stage" below) moves the previous sidecar unchanged to `carry/superseded/stage-<N>-from-<task-type>-<seq>.json` first. Name the `carryPath` and any `supersededCarryPath` it prints in `Stage sidecar evidence`. A reopened stage whose run ends `FAIL` writes nothing and leaves the old file where it is.
+- The same `okstra stage-done` call appends the `status:"done"` row to `runs/<plan-task-key>/consumers.jsonl` with `completed_at`, `carry_path`, `report_path` (relative to the report's run directory) and the carry's head, through `append_consumer` — so the consumers lock applies and this stage's worktree-registry occupancy is released. Never call `append_consumer` from python. `report_path` lets `final-verification` cite each stage's originating report when assembling its Source Implementation Report list.
 - **Automatic stage worktree cleanup:** after the report passes finalization, `report-finalize` reclaims this completed stage's clean worktree. It compares the report's final commit with the completion ledger and branch tip, preserves active or unfinished stages and dirty or nested worktrees, and keeps the branch and registry base for dependency rebases and later re-entry. Never remove the directory by hand before finalization. A later implementation or final-verification entry restores it from the preserved branch. After finalization, use the main project root or absolute artifact paths: this run's stage cwd may no longer exist. Enforcement: `report_finalize._teardown_stage_worktrees`, `stage_targets.teardown_completed_stage_worktrees`, and the cleanup/restoration tests in `tests/worktree/test_stage_rebase.py`.
 - **Reopening a settled stage.** Appending a `status:"failed"` row after a `done` one withdraws that stage: `--stage N` accepts it again, its dependents stop resolving a base from the withdrawn head, and whole-task final-verification blocks until it is settled again. Write it with `okstra stage-reopen <task-key> --stage <N> --reason "<why>" [--evidence <report>]`, which records the reason and the report that found the defect, and re-run the stage rather than repairing the tree outside okstra — a stage reverted outside the ledger leaves the recorded `head_commit` and the carry sidecar naming a tree that no longer exists, and the next stage branches from it.
 - The verifier round, Phase 5.5 convergence, and this Phase 6 report run **once per run** over this stage's diff — NOT per step.

package/runtime/python/okstra_ctl/phases/implementation/instructions/_implementation-verifier.md

@@ -220,6 +220,8 @@ Re-running commands proves the diff *builds and passes*; it does NOT prove the d
 
 ### Fix-run incremental scope (applies when the profile carries a "Fix-Run Carry" block)
 
+A correction-round re-verification (`--dispatch-kind correction-r<N>`, a "Correction Round" block in the task instructions) takes the same scope: the block's findings and the correction diff it names, with every validation command re-run.
+
 A fix run re-verifies a stage whose previous run already passed a full static
 sweep and failed only on cited blocking findings. Re-sweeping the whole stage
 diff re-buys wall-clock without new information, so the static scope narrows —

package/runtime/python/okstra_ctl/phases/implementation/profile.md

@@ -1,9 +1,10 @@
 # Implementation Profile
 
 - Purpose: realise the approved `implementation-planning` deliverable as actual source changes, with cross-model verification, while keeping the run reversible
-- **Run-level fixed cost:** the verifier set, Phase 5.5 convergence, and the Phase 6 report-writer run exactly once per implementation run, over this run's single stage diff — never once per step.
+- **Run-level fixed cost:** the verifier set and Phase 5.5 convergence run once per implementation run over this run's single stage diff — never once per step — plus once per correction round; the Phase 6 report-writer runs exactly once.
 - **Fix run (profile carries a "Fix-Run Carry" block):** the executor's scope is the carried blocking findings plus the previous routing recommendation — it MUST NOT re-execute plan steps the previous run completed. Verifiers apply the "Fix-run incremental scope" section of `_implementation-verifier.md`. The full validation-command re-run is NOT reduced.
 - **Lead minor fix:** a verifier FAIL whose findings are small and local is fixed by the lead inside this run, after convergence and before the report-writer dispatch, under `_implementation-deliverable.md` "Lead minor fix"; a passing fix settles the stage without a fix run.
+- **Correction round:** a verifier FAIL whose findings are confirmed, located, and inside the stage's plan is fixed by the executor and re-verified inside this run, at most 2 rounds, under `_implementation-deliverable.md` "Correction round"; a finding that needs a plan change still ends the run `FAIL`.
 - **Executor binding (resolved at run-prep time, fixed for this run):**
   - Executor display name: `{{EXECUTOR_DISPLAY_NAME}}`
   - Executor worker ID: `{{EXECUTOR_WORKER_ID}}`

package/runtime/python/okstra_ctl/phases/implementation/report_assets/implementation.template.html

@@ -32,6 +32,12 @@
   {% for row in implementation.leadFixes %}<article class="summary-card tone-{{ 'neutral' if row.result == 'pass' else 'important' }}"><p class="eyebrow">{{ row.findingIds | join(', ') | inline_code }} · <span class="status status-{{ row.result }}">{{ t('tasks.implementation.lead-fix-result-' ~ row.result) }}</span></p><p>{{ row.summary | inline_code }}</p><table><tbody><tr><th>{{ t('tasks.implementation.commit') }}</th><td><code>{{ row.commit }}</code></td></tr><tr><th>{{ t('tasks.implementation.lead-fix-verifiers') }}</th><td>{{ row.verifiers | join(', ') | inline_code }}</td></tr><tr><th>{{ t('tasks.implementation.files') }}</th><td>{% for path in row.files %}<code>{{ path }}</code>{% if not loop.last %}, {% endif %}{% endfor %}</td></tr><tr><th>{{ t('tasks.implementation.lead-fix-changed-lines') }}</th><td class="figure">{{ row.changedLines }}</td></tr></tbody></table>{% for command in row.commands %}<details><summary><code title="{{ command.command }}">{{ command.command }}</code> · {{ t('tasks.implementation.exit-code') }} {{ command.exitCode }}</summary><pre>{{ command.outputTail }}</pre></details>{% endfor %}</article>{% endfor %}
 </section>{% endif %}
 
+{% if implementation.get("correctionRounds") %}<section data-report-section="correction-rounds" data-report-field="implementation.correctionRounds">
+  <h2>{{ t('tasks.implementation.correction-rounds') }}</h2>
+  <p>{{ t('tasks.implementation.correction-rounds-intro') }}</p>
+  {% for row in implementation.correctionRounds %}<article class="summary-card tone-{{ 'neutral' if row.result == 'pass' else 'important' }}"><p class="eyebrow">{{ t('tasks.implementation.correction-round') }} {{ row.round }} · {{ row.findingIds | join(', ') | inline_code }} · <span class="status status-{{ row.result }}">{{ t('tasks.implementation.correction-result-' ~ row.result) }}</span></p><table><tbody><tr><th>{{ t('tasks.implementation.correction-range') }}</th><td><code>{{ row.baseCommit }}</code>..<code>{{ row.commit }}</code></td></tr>{% for verdict in row.verifierVerdicts %}<tr><th>{{ verdict.verifier | inline_code }}</th><td><span class="status status-{{ verdict.verdict | lower }}">{{ verdict.verdict }}</span></td></tr>{% endfor %}</tbody></table></article>{% endfor %}
+</section>{% endif %}
+
 <section data-report-section="remaining-issues">
   <h2>{{ t('tasks.implementation.what-is-left') }}</h2>
   {{ render_narrative(narrative.remainingIssues, "implementation.userNarrative.remainingIssues") }}

package/runtime/python/okstra_ctl/phases/implementation/spec.md

@@ -148,7 +148,7 @@ flowchart TD
     Verdict --> Report[Final report preserves dissent]
 ```
 
-Only the executor may mutate project files, with one exception: after the verifier round and convergence, the lead may fix small, local verifier FAIL findings itself (at most 30 changed lines, no test-expectation, dependency, schema, migration or config-of-record change), re-run the checks that found them, and settle the stage when they pass, instead of opening a fix run (`instructions/_implementation-deliverable.md` "Lead minor fix"). The verifier independently re-runs the diff and validation command read-only in the same worktree. Even a verifier with the same provider as the executor runs again in a separate fresh CLI session. This is to prevent a structure where the same session approves a diff the same session wrote.
+Only the executor may mutate project files, with one exception: after the verifier round and convergence, the lead may fix small, local verifier FAIL findings itself (at most 30 changed lines, no test-expectation, dependency, schema, migration or config-of-record change), re-run the checks that found them, and settle the stage when they pass, instead of opening a fix run (`instructions/_implementation-deliverable.md` "Lead minor fix"). Findings outside those limits but inside the stage's plan go to a correction round: the executor fixes them under dispatch kind `correction-r<N>` and the verifiers re-verify the fix, at most 2 rounds per run, before the report is written once (`"Correction round"`). The verifier independently re-runs the diff and validation command read-only in the same worktree. Even a verifier with the same provider as the executor runs again in a separate fresh CLI session. This is to prevent a structure where the same session approves a diff the same session wrote.
 
 ## 5. stage and consumers
 
@@ -200,6 +200,7 @@ The final report requires at least the following.
 - TDD failing-then-passing evidence
 - per-verifier independent validation rerun result
 - lead minor fixes, when any: finding ids, commit, files, changed lines, and re-run checks (`implementation.leadFixes`)
+- correction rounds, when any: round, finding ids, fix commit range, each verifier's re-verification verdict, and result (`implementation.correctionRounds`)
 - `carry/stage-<N>.json` evidence sidecar and `consumers.jsonl` started/done row
 - rollback verification
 - `implementation.manualUserTest` finalized against the actual diff and whether it is executable

package/runtime/python/okstra_ctl/phases/implementation/validation.py

@@ -2,7 +2,10 @@
 from __future__ import annotations
 
 import re
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
+from typing import Any
+
+from ...correction_round import correction_round
 
 _PASSING_VERDICT_TOKENS = frozenset({"accepted", "conditional-accept"})
 _CHECKLIST_ID_RE = re.compile(r"\bVC-\d{3,}\b")
@@ -266,6 +269,64 @@ def _validate_lead_fixes(data: dict, failures: list[str]) -> None:
         )
 
 
+_CORRECTION_BLOCKING = "correction-round BLOCKING:"
+
+
+def _validate_correction_rounds(
+    data: dict, run_manifest: Mapping[str, Any], failures: list[str],
+) -> None:
+    """수정 라운드 기록을 실제 dispatch 와, 마지막 라운드 verdict 를 verifierResults 와 맞춘다.
+
+    `_implementation-deliverable.md` "Correction round": verifierResults 는 마지막 라운드의
+    verdict 이고 앞선 FAIL 은 correctionRounds 에만 남는다. 원장에 있는 라운드가 기록에서
+    빠지면 그 FAIL 이 보고서에서 사라진다.
+    """
+    implementation = data.get("implementation")
+    if not isinstance(implementation, dict):
+        return
+    rows = [row for row in implementation.get("correctionRounds") or [] if isinstance(row, dict)]
+    recorded = [row.get("round") for row in rows]
+    dispatched = sorted({
+        number for invocation in run_manifest.get("invocations") or []
+        if isinstance(invocation, Mapping)
+        and (number := correction_round(str(invocation.get("dispatchKind") or ""))) is not None
+    })
+    if sorted(recorded) != dispatched:
+        failures.append(
+            f"{_CORRECTION_BLOCKING} implementation.correctionRounds records rounds "
+            f"{sorted(recorded)} but the run dispatched correction rounds {dispatched}. "
+            "Record one entry per dispatched round, with its re-verification verdicts."
+        )
+    if recorded != list(range(1, len(recorded) + 1)):
+        failures.append(
+            f"{_CORRECTION_BLOCKING} implementation.correctionRounds rounds are {recorded}; "
+            "they run 1, 2 in order."
+        )
+    for row in rows:
+        verdicts = [v for v in row.get("verifierVerdicts") or [] if isinstance(v, dict)]
+        any_fail = any(v.get("verdict") == "FAIL" for v in verdicts)
+        if (row.get("result") == "pass") == any_fail:
+            failures.append(
+                f"{_CORRECTION_BLOCKING} implementation.correctionRounds round "
+                f"{row.get('round')} records `result: {row.get('result')}` but its "
+                f"re-verification verdicts are {[v.get('verdict') for v in verdicts]}; "
+                "`pass` means no verdict is FAIL."
+            )
+    if not rows:
+        return
+    last = {
+        str(v.get("verifier")): v.get("verdict")
+        for v in rows[-1].get("verifierVerdicts") or [] if isinstance(v, dict)
+    }
+    reported = {who: row.get("verdict") for who, row in _verifier_rows(data)}
+    if last != reported:
+        failures.append(
+            f"{_CORRECTION_BLOCKING} implementation.verifierResults verdicts {reported} differ "
+            f"from the last correction round's {last}. verifierResults carries the last "
+            "round's verdicts; earlier ones stay in correctionRounds."
+        )
+
+
 def _validate_verifier_fail_blocks_verdict(data: dict, failures: list[str]) -> None:
     """A verifier FAIL cannot be dropped during synthesis.
 

package/runtime/python/okstra_ctl/phases/release_handoff/boundary.json

@@ -1,7 +1,7 @@
 {
-  "allowed": "  - entering this phase only when the cited final-verification report's verdict is release-ready — `Verdict Token` exactly `accepted`, or exactly `conditional-accept` with every Conditional Acceptance Condition row declaring `blocksReleaseHandoff: false` (`okstra_ctl.release_gate.release_handoff_allowed`)\n  - asking the user (via `AskUserQuestion` / interactive prompt) which delivery action to take: `local checkout`, `push + PR`, or `skip` (end the run)\n  - asking the user to pick a PR base branch from `staging` | `preprod` | `prod` | `main` | `dev` | a user-supplied branch name\n  - drafting PR title and PR body **inline as the Okstra lead** (no drafter worker and no delegated dispatch); the lead reviews its own draft with the user before any mutating git / gh command runs\n  - read-only git inspection: `git status`, `git diff`, `git log`, `git rev-parse`\n  - pushing the current feature branch to its origin remote via `git push -u origin <current-branch>` (the feature branch only — NEVER the base branch)\n  - creating a pull request via `gh pr create --base <chosen-base> --head <current-branch>`; if a PR with the same head already exists, surface its URL and skip creation\n  - the lead writes the final report directly (no `Report writer worker` dispatch); the report still conforms to the standard final-report template",
+  "allowed": "  - entering this phase only when the cited final-verification report's verdict is release-ready — `Verdict Token` exactly `accepted`, or exactly `conditional-accept` with every Conditional Acceptance Condition row declaring `blocksReleaseHandoff: false` (`okstra_ctl.release_gate.release_handoff_allowed`)\n  - asking the user (via `AskUserQuestion` / interactive prompt) which delivery action to take: `local checkout`, `push + PR`, or `skip` (end the run)\n  - asking the user to pick a PR base branch from `staging` | `preprod` | `prod` | `main` | `dev` | a user-supplied branch name\n  - drafting PR title and PR body **inline as the Okstra lead** (no drafter worker and no delegated dispatch); the lead reviews its own draft with the user before any mutating git / gh command runs\n  - read-only git inspection: `git status`, `git diff`, `git log`, `git rev-parse`\n  - pushing the current feature branch to its origin remote via `git push -u origin <current-branch>` (the feature branch only — NEVER the base branch)\n  - creating a pull request via `gh pr create --base <chosen-base> --head <current-branch>`; if a PR with the same head already exists, surface its URL and skip creation\n  - the lead writes the report narrative at the run manifest's `reportNarrativePath` directly (no `Report writer worker` dispatch); `okstra report-finalize` assembles the final report from it",
   "forbidden": [
-    "entering this phase when the cited final-verification `Verdict Token` is `conditional-accept` or `blocked`, or when no final-verification report is cited",
+    "entering this phase when a cited final-verification verdict is not release-ready — `Verdict Token` `blocked` or any token other than `accepted` / `conditional-accept`, a `conditional-accept` with no Conditional Acceptance Condition row or with any row whose `blocksReleaseHandoff` is not `false` (`okstra_ctl.release_gate.release_handoff_allowed`) — or when no final-verification report is cited",
     "local commit commands of any kind (`git add`, `git commit`, `git restore --staged`, `git stash`), and any direct `git merge` / `git rebase` / `git rebase --onto` / `git cherry-pick` / `git commit --amend` run by the lead. Runtime exceptions are dependency-ordered rebases by `okstra_ctl.stage_rebase` (which invalidate verification and stop PR delivery), and merge commits on a dedicated multi-predecessor `merge-base` branch. Never merge a moving predecessor or origin branch into a downstream stage to update its base.",
     "any git push variant that rewrites remote history, regardless of intent or whether the user said \"force it\": `git push --force`, `git push --force-with-lease`, `git push -f`, `git push +<refspec>`, or any other history-rewriting invocation",
     "pushing directly to a release base branch — i.e. `git push origin <branch>` where `<branch>` is `main`, `master`, `prod`, `preprod`, `staging`, `dev`, or the branch the user chose as the release base in this run. The only permitted push targets are the branches `okstra handoff pr-plan` listed for this run (each stage `head_branch`, and any `merge-base` branch).",

package/runtime/python/okstra_ctl/phases/release_handoff/profile.md

@@ -4,12 +4,12 @@
   the `releaseBase` the user picked. The report is the only place a reader learns which stages
   shipped and in what order their PRs must be merged — the branch names do not say.
 - Purpose: take a release-ready single-stage final-verification verdict for each already-committed implementation stage and turn it into a delivered push and/or pull request, with explicit user selection at every delivery step. **One stage is one PR.** The PR head is that stage's stack branch (`<prefix>-<task-id>-s<N>`); nothing is squashed or collected into a bundle branch. Runtime dependency rebases happen before delivery and invalidate the prior verification.
-- **Execution model: single-lead, no worker dispatch.** This phase is a thin orchestrator over `git` / `gh`; it does NOT dispatch teammates, does NOT dispatch analysis or drafter sub-agents, and does NOT run convergence. The host-native Okstra lead performs every step inline (drafting PR text, asking the user, running git / gh, writing the final report) — see "Lead-only contract" below.
+- **Execution model: single-lead, no worker dispatch.** This phase is a thin orchestrator over `git` / `gh`; it does NOT dispatch teammates, does NOT dispatch analysis or drafter sub-agents, and does NOT run convergence. The host-native Okstra lead performs every step inline (drafting PR text, asking the user, running git / gh, writing the report narrative) — see "Lead-only contract" below.
 - Worker roster: none — `profile.json` declares no roles; the run is executed entirely by the Okstra lead.
 - Lead-only contract (replaces the shared team contract for this phase):
   - The host-native Okstra lead is the sole agent for this run. No worker dispatch, no teammates, no parallel sub-agents, no convergence loop. Do NOT run `okstra convergence` in any form: prepare already wrote this run's convergence state as "not run — fewer than two analysers", which is the record report assembly reads. **Enforced:** `okstra_ctl.render._initialize_lead_only_convergence` writes it when the run has no analysers, and leaves an existing state alone.
   - The lead drafts each stage's PR title and PR body **inline** by reading the run brief, that stage's cited final-verification report, `git log --oneline <stage base>..<stage head>`, and `git diff <stage base>..<stage head> --stat`. No drafter worker is dispatched.
-  - The lead authors the final-report file directly (no `Report writer worker` dispatch). The report still conforms to the standard `templates/reports/final-report-v2.template.md` structure, including the `## 5.6 Release Handoff Deliverables` section.
+  - The lead authors the report narrative directly (no `Report writer worker` dispatch) and never writes `final-report-*.data.json`. Write the narrative to the path the run manifest names in `reportNarrativePath`. It carries only the writer-owned fields (`humanSummary`, `summary`, `verdictCard`, `finalVerdict`, `rationale`, `recommendedNextSteps`, `followUpTasks`, and `releaseHandoff` with its `userNarrative`) in the narrative line grammar of `report_narrative.NARRATIVE_GRAMMAR_INSTRUCTIONS`: the first line is `# OKSTRA Report Narrative`, followed only by `- **Field Name**`, `- Item <N>` and `> value` lines, each value indented two spaces deeper than its label. `okstra report-finalize` assembles `data.json` from this narrative plus the approval, activity, team-state and convergence ledgers prepare already created. A missing or unparseable narrative fails the `project-activity` step with `owner=lead`. **Enforced:** `report_inputs._LEAD_AUTHORED_NARRATIVE_TASK_TYPES`, read by `report_assembly.assemble_report`.
   - The shared anti-escalation rule from the common contract still applies: do not start any other lifecycle phase from inside this run.
   - The shared "authority & permissions assumption" rule from the common contract still applies: assume the user holds every permission needed; do not block on hypothetical approvals.
 - Pre-handoff entry gate (mandatory — refuse to start if any item fails):

package/runtime/python/okstra_ctl/phases/release_handoff/spec.md

@@ -33,7 +33,7 @@ When a predecessor advances, `okstra_ctl.stage_rebase.synchronize_stage_stack` r
 
 Because the PRs are a stack, they must be merged in dependency order with a merge commit or a rebase-merge. A squash replaces the commits the next PR's base points at, so the stack breaks — every PR body states this, and the lead never merges.
 
-This phase has no worker dispatch. It does not use a provider or report-writer roster; the host-native Okstra lead performs git/gh inspection, user questions, the PR draft, and the final report inline.
+This phase has no worker dispatch. It does not use a provider or report-writer roster; the host-native Okstra lead performs git/gh inspection, user questions, the PR draft, and the report narrative inline; `okstra report-finalize` assembles the final report from that narrative.
 
 ## 2. okstra-run wizard flow
 

package/runtime/python/okstra_ctl/report_assembly.py

@@ -762,7 +762,7 @@ def _attach_machine_planning(
     _sync_human_summary_with_plan_body_gate(data, projection)
 
 
-def _schema_owner(error: str) -> str:
+def _schema_owner(error: str, narrative_owner: str) -> str:
     field = error.split(" ", 1)[0]
     owners = {
         "executionStatus": "team-state",
@@ -781,8 +781,8 @@ def _schema_owner(error: str) -> str:
     if "planBodyVerification" in error:
         return "convergence"
     if "selectedDirectionRef" in error:
-        return "report-writer"
-    return owners.get(field.split(".", 1)[0], "report-writer")
+        return narrative_owner
+    return owners.get(field.split(".", 1)[0], narrative_owner)
 
 
 def _publish(
@@ -864,7 +864,7 @@ def assemble_report(
     path_errors = planned_path_declaration_errors(data)
     if path_errors:
         raise ReportAssemblyError(tuple(
-            AssemblyIssue("report-writer", str(inputs["narrative"].path), error.split(":", 1)[0], error)
+            AssemblyIssue(inputs["narrative"].owner, str(inputs["narrative"].path), error.split(":", 1)[0], error)
             for error in path_errors
         ))
     direction_errors = selected_direction_plan_errors(
@@ -888,7 +888,7 @@ def assemble_report(
         raise ReportAssemblyError(
             tuple(
                 AssemblyIssue(
-                    _schema_owner(error),
+                    _schema_owner(error, inputs["narrative"].owner),
                     str(target),
                     error.split(" ", 1)[0],
                     error,

package/runtime/python/okstra_ctl/report_inputs.py

@@ -28,6 +28,10 @@ _INPUT_FIELDS = (
     ("convergence", "convergence", "convergenceStatePath"),
 )
 
+# 워커 없이 리드가 리포트까지 쓰는 phase. 서사의 저자가 리드이므로, 서사가
+# 없을 때 조립이 report-writer 를 지목하면 띄울 수 없는 워커를 찾게 된다.
+_LEAD_AUTHORED_NARRATIVE_TASK_TYPES = frozenset({"release-handoff"})
+
 _PLANNING_INPUT_FIELDS = (
     ("design-preparation", "design-surface-detector", "designPreparationPath"),
     ("plan-body-verification", "convergence", "planBodyVerificationPath"),
@@ -63,8 +67,13 @@ def report_input_paths(
         if manifest.get("taskType") == "implementation-planning"
         else ()
     )
+    lead_authored = manifest.get("taskType") in _LEAD_AUTHORED_NARRATIVE_TASK_TYPES
     rows = tuple(
-        ReportInputPath(key, owner, _project_path(project_root, manifest.get(field), field))
+        ReportInputPath(
+            key,
+            "lead" if lead_authored and key == "narrative" else owner,
+            _project_path(project_root, manifest.get(field), field),
+        )
         for key, owner, field in fields
     )
     if len({row.key for row in rows}) != len(rows):