okstra 0.184.0 → 0.185.1

package/runtime/python/okstra_ctl/incremental_carry.py

@@ -13,10 +13,18 @@ from .convergence_store import write_json_atomic
 from .final_report_schema import load_schema_version
 from .report_narrative import parse_narrative, writer_owned_data
 from .json_boundary import load_owned_object
+from .plan_items import (
+    PlanItemContractError,
+    content_hash,
+    extract_plan_items,
+    planning_stage_ledger,
+    reverify_item_ids,
+)
 
 
 PREP_VERDICT_RE = re.compile(r"^P-Prep-S([1-9][0-9]*)-")
 STEP_VERDICT_RE = re.compile(r"^P-Step-([1-9][0-9]*)\.")
+_CHECKLIST_ID_PREFIXES = ("P-Val-", "P-Req-", "P-Rb-")
 
 
 class CarryError(Exception):
@@ -306,6 +314,100 @@ def _plan_item_stage(item: Mapping[str, Any]) -> int | None:
     return None
 
 
+def _checklist_id(item_id: str) -> bool:
+    return item_id.startswith(_CHECKLIST_ID_PREFIXES)
+
+
+def _item_stages(item: Mapping[str, Any]) -> list[int]:
+    scope = item.get("stageScope")
+    if not isinstance(scope, list):
+        return []
+    return [
+        value for value in scope
+        if isinstance(value, int) and not isinstance(value, bool)
+    ]
+
+
+def _stamp_carried(previous: dict, current: Mapping[str, Any], prev_seq: str) -> dict:
+    carried = copy.deepcopy(previous)
+    carried["carriedForwardFromSeq"] = str(prev_seq)
+    current_hash = current.get("contentHash")
+    if isinstance(current_hash, str) and current_hash:
+        carried["verifiedContentHash"] = current_hash
+        carried["contentHash"] = current_hash
+    return carried
+
+
+def _carry_unchanged_checklists(
+    prev: Mapping[str, Any],
+    narrative: Mapping[str, Any],
+    state_items: dict[str, dict],
+    prev_items: dict[str, dict],
+    *,
+    prev_seq: str,
+    reverify_stages: set[int],
+) -> None:
+    """본문이 같은 P-Val / P-Req / P-Rb 판정을 이월한다.
+
+    단계가 없으면 매 재실행 라운드 1 큐에 남아 이미 통과한 줄이 다시 반대되고
+    새 C 가 열린다. 추출 해시가 같으면 이전 표를 가져오고, 재검증 스테이지에
+    걸린 행과 본문이 바뀐 행은 그대로 둔다.
+    """
+    try:
+        prev_extracted = {
+            item["id"]: item
+            for item in extract_plan_items(_planning(dict(prev)))
+            if isinstance(item.get("id"), str)
+        }
+        cur_extracted = {
+            item["id"]: item
+            for item in extract_plan_items(_planning(dict(narrative)))
+            if isinstance(item.get("id"), str)
+        }
+    except (CarryError, PlanItemContractError, KeyError, TypeError):
+        return
+    for item_id, current in list(state_items.items()):
+        if not _checklist_id(item_id):
+            continue
+        stages = _item_stages(current)
+        if stages and set(stages) & reverify_stages:
+            continue
+        previous = prev_items.get(item_id)
+        if previous is None:
+            continue
+        prev_row = prev_extracted.get(item_id)
+        cur_row = cur_extracted.get(item_id)
+        if prev_row is None or cur_row is None:
+            continue
+        if content_hash(prev_row) != content_hash(cur_row):
+            continue
+        state_items[item_id] = _stamp_carried(previous, current, prev_seq)
+
+
+def _recompute_dispatch_queue(
+    narrative: Mapping[str, Any],
+    state_items: dict[str, dict],
+) -> list[str]:
+    try:
+        extracted = extract_plan_items(_planning(dict(narrative)))
+    except (CarryError, PlanItemContractError, KeyError, TypeError):
+        return []
+    by_id = {
+        item["id"]: item
+        for item in extracted
+        if isinstance(item.get("id"), str)
+    }
+    previous_hashes = {
+        item_id: content_hash(by_id[item_id])
+        for item_id, row in state_items.items()
+        if row.get("carriedForwardFromSeq") and item_id in by_id
+    }
+    if not previous_hashes:
+        return []
+    ledger = planning_stage_ledger(_planning(dict(narrative)))
+    return reverify_item_ids(extracted, previous_hashes, ledger)
+
+
 def _writer_stage_rows(data: Mapping[str, Any], *, snapshot: str) -> dict[int, dict]:
     planning = _planning(dict(writer_owned_data(data)))
     return _stage_rows(planning, snapshot=snapshot)
@@ -320,7 +422,7 @@ def merge_v3_plan_state(
     carry_stages: set[int],
     reverify_stages: set[int],
 ) -> dict[str, Any]:
-    """이전 판정 중 이월 스테이지 소유분만 v3 수렴 상태에 복사한다."""
+    """이전 판정 중 이월 스테이지 소유분과 본문이 같은 체크리스트를 복사한다."""
     prev_stages = _writer_stage_rows(prev, snapshot="prior")
     cur_stages = _stage_rows(_planning(narrative), snapshot="current")
     _validate_stage_sets(prev_stages, cur_stages, carry_stages, reverify_stages)
@@ -351,9 +453,7 @@ def merge_v3_plan_state(
         for field in ("subject", "sourceSection"):
             if current.get(field) != previous.get(field):
                 raise CarryError(f"carry-owned plan item {item_id} changed {field}")
-        carried = copy.deepcopy(previous)
-        carried["carriedForwardFromSeq"] = str(prev_seq)
-        state_items[item_id] = carried
+        state_items[item_id] = _stamp_carried(previous, current, prev_seq)
 
     prior_carried_ids = {
         item_id
@@ -363,12 +463,55 @@ def merge_v3_plan_state(
     missing = sorted(prior_carried_ids - set(state_items))
     if missing:
         raise CarryError(f"current state omitted carry-owned plan items: {missing}")
-    state["planBodyVerification"]["planItems"] = [
+    _carry_unchanged_checklists(
+        prev,
+        narrative,
+        state_items,
+        prev_items,
+        prev_seq=prev_seq,
+        reverify_stages=reverify_stages,
+    )
+    pbv = state.setdefault("planBodyVerification", {})
+    pbv["planItems"] = [
         state_items[item_id] for item_id in sorted(state_items)
     ]
+    queue = _recompute_dispatch_queue(narrative, state_items)
+    if queue:
+        pbv["dispatchQueue"] = queue
     return state
 
 
+def _sync_prepared_dispatch_queue(state_path: Path, merged: Mapping[str, Any]) -> None:
+    """이월 뒤 프롬프트 큐를 상태 파일과 맞춘다.
+
+    `plan-items prompt` 는 prepare 가 쓴 `plan-items-*.json` 을 읽는다. 시드가
+    그 파일을 먼저 쓰므로, 이월이 큐를 줄인 뒤에는 형제 파일을 같이 고쳐야
+    워커가 이미 통과한 P-Val 을 다시 보지 않는다.
+    """
+    name = state_path.name
+    prefix = "plan-body-verification-"
+    if not name.startswith(prefix):
+        return
+    prepared = state_path.with_name("plan-items-" + name.removeprefix(prefix))
+    if not prepared.is_file():
+        return
+    queue = (
+        merged.get("planBodyVerification", {}).get("dispatchQueue")
+        if isinstance(merged.get("planBodyVerification"), Mapping)
+        else None
+    )
+    if not isinstance(queue, list):
+        return
+    try:
+        envelope = load_owned_object(prepared, artifact="prepared plan items")
+    except (OSError, ValueError):
+        return
+    if not isinstance(envelope, dict):
+        return
+    envelope["dispatchQueue"] = queue
+    write_json_atomic(prepared, envelope)
+
+
 def _parse_stage_csv(value: str | None, *, option: str) -> set[int] | None:
     if value is None:
         return None
@@ -457,6 +600,7 @@ def main(argv: list[str]) -> int:
 
     try:
         write_json_atomic(output, merged)
+        _sync_prepared_dispatch_queue(output, merged)
     except OSError as exc:
         print(f"carry refused: --out could not be written: {exc}", file=sys.stderr)
         return 1

package/runtime/python/okstra_ctl/incremental_scope.py

@@ -34,9 +34,8 @@ DECLARED_FULL_PREFIX = "declared structural change:"
 UNRESOLVED_MODE = "unresolved"
 
 # `P-Step-<stage>.<step>` and `P-Prep-S<stage>-<kind>` carry their stage in the
-# id itself. Every other prefix (`P-Opt`, `P-Dep`, `P-Val`, `P-Rb`, `P-Req`) is
-# numbered by position in its own array, so its stage is only recoverable from
-# the prose the planner wrote.
+# id itself. Every other prefix is numbered by position; its stage comes from
+# `stageScope` / `stageRefs`, then from the prose the planner wrote.
 _STRUCTURAL_STAGE_IN_ID_RE = re.compile(r"^P-(?:Step-(\d+)\.\d+|Prep-S(\d+)-)")
 
 
@@ -131,10 +130,32 @@ def design_prep_impacted_stages(data: dict, item_ids: set[str]) -> set[int]:
     return impacted
 
 
+def _int_stages(value: object) -> set[int]:
+    if not isinstance(value, list):
+        return set()
+    stages: set[int] = set()
+    for entry in value:
+        if isinstance(entry, int) and not isinstance(entry, bool) and entry >= 1:
+            stages.add(entry)
+    return stages
+
+
 def _plan_item_stages(item: dict) -> set[int]:
+    """항목이 걸린 스테이지. id 좌표, 그다음 기록된 범위, 그다음 산문.
+
+    `P-Val-*` / `P-Req-*` 는 위치 번호라 id 에서 스테이지가 안 나온다. 행이
+    `stageScope` / `stageRefs` 를 실어도 산문 `subject` 만 읽으면 C-039 같은
+    답이 unlinked 가 되어 재실행이 full 로 떨어진다.
+    """
     structural = _STRUCTURAL_STAGE_IN_ID_RE.match(str(item.get("id") or ""))
     if structural:
         return {int(structural.group(1) or structural.group(2))}
+    stages = _int_stages(item.get("stageScope")) or _int_stages(item.get("stageRefs"))
+    payload = item.get("payload")
+    if not stages and isinstance(payload, dict):
+        stages = _int_stages(payload.get("stageRefs"))
+    if stages:
+        return stages
     return cited_stage_numbers(str(item.get("subject") or ""))
 
 
@@ -169,6 +190,7 @@ def _stages_blocked_on(coverage: object, clarification_id: str) -> set[int]:
     for row in coverage if isinstance(coverage, list) else []:
         if coverage_row_blocked_on(row, clarification_id):
             stages |= cited_stage_numbers(str(row.get("coveredBy") or ""))
+            stages |= _int_stages(row.get("stageRefs"))
     return stages
 
 

package/runtime/python/okstra_ctl/next_phase.py

@@ -9,6 +9,8 @@ from __future__ import annotations
 
 from typing import Any, Mapping
 
+from okstra_ctl.clarification_items import APPROVAL_BLOCKS, UNRESOLVED_STATUSES
+
 STATUS_READY = "ready"
 STATUS_PENDING = "pending"
 STATUS_BLOCKED = "blocked"
@@ -69,6 +71,12 @@ _OPTION_SELECTION_NON_PHASE = {
     "blocked": STATUS_BLOCKED,
 }
 
+# run.py BLOCKING_PLAN_BODY_GATES 와 같아야 한다. next_phase 는 run 을
+# 가져오지 않는다 — wizard 가 둘 다 import 해서 순환이 생긴다.
+_BLOCKING_PLAN_GATES = frozenset(
+    {"blocked-by-disagreement", "aborted-non-result"}
+)
+
 # final-verification 의 routing enum 중 phase 이름이 아니라 phase 에 붙은 범위
 # 한정자인 값 → 실제로 실행할 phase. `release-handoff(stage-group)` 은 넘길 stage
 # 묶음을 좁힌다는 뜻이지 다른 phase 가 아니다. 범위는 위저드의 handoff_stage_pick
@@ -210,13 +218,68 @@ def _from_option_selection(report_data: Mapping[str, Any]) -> dict[str, str]:
     return make(phase=routing, status=STATUS_READY)
 
 
+def _unresolved_approval_ids(report_data: Mapping[str, Any]) -> list[str]:
+    rows = report_data.get("clarificationItems")
+    if not isinstance(rows, list):
+        return []
+    ids: list[str] = []
+    for row in rows:
+        if not isinstance(row, Mapping):
+            continue
+        blocks = str(row.get("blocks") or "").strip().lower()
+        status = str(row.get("status") or "").strip().lower()
+        row_id = row.get("id")
+        if (
+            blocks in APPROVAL_BLOCKS
+            and status in UNRESOLVED_STATUSES
+            and isinstance(row_id, str)
+            and row_id
+        ):
+            ids.append(row_id)
+    return ids
+
+
+def _planning_approval_block_reason(
+    report_data: Mapping[str, Any], planning: Mapping[str, Any]
+) -> str:
+    """plan-ready 인데 승인할 수 없으면 근거, 아니면 빈 문자열.
+
+    자문 게이트(`passed-with-dissent`)와 재현 실패 `has-dissent` 는 여기 안
+    들어온다. 차단은 `blocked-by-disagreement` / `aborted-non-result` 와
+    `Status` 가 open/answered 인 `Blocks=approval` 행뿐이다.
+    """
+    ids = _unresolved_approval_ids(report_data)
+    if ids:
+        listed = ", ".join(ids)
+        return (
+            f"{listed} 가 Blocks=approval 로 열려 승인할 수 없습니다. "
+            "okstra-user-response 로 답한 뒤 그 답을 가지고 계획 단계를 "
+            "재개하세요. 구현을 시작하거나, 답을 쓰기 전에 계획 단계를 "
+            "다시 돌리지 마세요."
+        )
+    verification = planning.get("planBodyVerification")
+    gate = ""
+    if isinstance(verification, Mapping):
+        gate = str(verification.get("gateResult") or "").strip().lower()
+    if gate in _BLOCKING_PLAN_GATES:
+        return (
+            f"계획 본문 게이트가 `{gate}` 이라 승인할 수 없습니다. "
+            "구현을 시작하거나 계획 단계를 바로 다시 돌리지 마세요."
+        )
+    return ""
+
+
 def _from_planning(report_data: Mapping[str, Any]) -> dict[str, str]:
-    outcome = str(_block(report_data, "implementationPlanning").get("outcome") or "")
-    if outcome == "plan-ready":
-        return make(phase="implementation", status=STATUS_READY)
+    planning = _block(report_data, "implementationPlanning")
+    outcome = str(planning.get("outcome") or "")
     if outcome == "direction-invalidated":
         return make(phase="implementation-option-selection", status=STATUS_READY)
-    return make(status=STATUS_PENDING)
+    if outcome != "plan-ready":
+        return make(status=STATUS_PENDING)
+    blocked_reason = _planning_approval_block_reason(report_data, planning)
+    if blocked_reason:
+        return make(status=STATUS_BLOCKED, rationale=blocked_reason)
+    return make(phase="implementation", status=STATUS_READY)
 
 
 def _from_target(report_data: Mapping[str, Any], key: str) -> dict[str, str]:

package/runtime/python/okstra_ctl/plan_items.py

@@ -407,6 +407,15 @@ def expected_plan_item_ids(implementation_planning: Mapping[str, Any]) -> list[s
 
 _STARTABLE_STATUSES = frozenset({"ready", "active"})
 
+# 계획 전체를 판정하는 항목. 스테이지 하나를 고쳐도 요청하지 않은 작업이
+# 들어왔는지 다시 봐야 한다. P-Val / P-Req / P-Rb 는 여기 넣지 않는다 —
+# stageRefs 가 비어 있어도 이웃 수정의 일소 대상이 되면 C 행이 매 라운드 늘어난다.
+_PLAN_WIDE_ID_PREFIXES = ("P-Opt-", "P-Var-", "P-Dir-", "P-Dep-")
+
+
+def _is_plan_wide(item_id: str) -> bool:
+    return item_id.startswith(_PLAN_WIDE_ID_PREFIXES)
+
 
 def content_hash(item: Mapping[str, Any]) -> str:
     """이 항목 본문의 지문. 문구가 같으면 라운드가 달라도 같은 판정이다.
@@ -430,9 +439,13 @@ def stage_scope_bucket(
 ) -> str:
     """게이트·디스패치가 공유하는 범위. ``in-scope`` / ``observed`` / ``deferred``.
 
-    원장이 없거나 항목에 스테이지가 없으면 계획 전체로 읽는다. 검증기
+    원장이 없거나 계획 전체 항목이면 in-scope 이다. 검증기
     ``_stage_scope_bucket`` 과 같은 판정이어야 한다 — 디스패치와 게이트가
     다른 통을 쓰면 워커가 본 항목과 승인을 막는 항목이 갈라진다.
+
+    단계가 없는 ``P-Val`` / ``P-Req`` / ``P-Rb`` 는 원장에 ``done`` 이 생긴
+    뒤부터는 다음 착수를 막지 않는다. 생략된 ``stageRefs`` 를 모든 스테이지로
+    읽으면 이미 끝난 계획의 재실행마다 체크리스트 전부가 다시 채점된다.
     """
     if not isinstance(ledger, Mapping) or not ledger:
         return "in-scope"
@@ -442,6 +455,11 @@ def stage_scope_bucket(
         if isinstance(value, int) and not isinstance(value, bool)
     ] if isinstance(scope, list) else []
     if not stages:
+        item_id = str(item.get("id") or "")
+        if _is_plan_wide(item_id):
+            return "in-scope"
+        if "done" in {str(value) for value in ledger.values()}:
+            return "deferred"
         return "in-scope"
     statuses = {str(ledger.get(str(stage)) or "") for stage in stages}
     if statuses & _STARTABLE_STATUSES:
@@ -548,6 +566,10 @@ def reverify_item_ids(
 
     이전이 없으면 첫 라운드라 디스패치 큐 전부다. 해시가 같은 다른 스테이지
     항목은 보내지 않는다 — 그게 96개 일소 배치를 만들던 규칙이다.
+
+    단계가 없는 항목 전부가 계획 전체는 아니다. `P-Opt` / `P-Var` / `P-Dir` /
+    `P-Dep` 만 이웃 수정에 다시 묶인다. `P-Val` / `P-Req` / `P-Rb` 는 자기
+    해시가 바뀔 때만 다시 본다.
     """
     dispatched = dispatch_item_ids(items, ledger)
     by_id = {
@@ -558,8 +580,8 @@ def reverify_item_ids(
     if not previous_hashes:
         return dispatched
     changed = [
-        item_id for item_id in dispatched
-        if previous_hashes.get(item_id) != content_hash(by_id[item_id])
+        item_id for item_id, item in by_id.items()
+        if previous_hashes.get(item_id) != content_hash(item)
     ]
     changed_stages: set[int] = set()
     for item_id in changed:
@@ -570,6 +592,7 @@ def reverify_item_ids(
                 if isinstance(value, int) and not isinstance(value, bool)
             )
     queue: list[str] = []
+    queued: set[str] = set()
     for item_id in dispatched:
         item = by_id[item_id]
         scope = item.get("stageScope")
@@ -578,11 +601,24 @@ def reverify_item_ids(
             if isinstance(value, int) and not isinstance(value, bool)
         ] if isinstance(scope, list) else []
         if not stages:
-            if changed:
+            if item_id in changed or (changed and _is_plan_wide(item_id)):
                 queue.append(item_id)
+                queued.add(item_id)
             continue
         if item_id in changed or changed_stages.intersection(stages):
             queue.append(item_id)
+            queued.add(item_id)
+    # done 이후 디스패치에서 빠진 체크리스트라도 본문이 바뀌면 다시 본다.
+    for item_id in changed:
+        if item_id in queued or item_id not in by_id:
+            continue
+        scope = by_id[item_id].get("stageScope")
+        stages = [
+            value for value in scope
+            if isinstance(value, int) and not isinstance(value, bool)
+        ] if isinstance(scope, list) else []
+        if not stages:
+            queue.append(item_id)
     return queue
 
 

package/runtime/python/okstra_ctl/user_response.py

@@ -954,12 +954,15 @@ def list_awaiting_tasks(home: Path, project_id: str, limit: int) -> list[dict]:
 # `§x.y` is a full-reading-copy heading and is not a record coordinate.
 # `path.ext:line` is a source pointer the record does not define.
 _SECTION_REF_RE = re.compile(r"§[\d.]+|[A-Z]{1,4}-\d+|[\w./-]+\.\w+:\d+")
+_PATH_LINE_RE = re.compile(r"[\w./-]+\.\w+:\d+")
 _ID_TOKEN_RE = re.compile(r"^[A-Z]{1,4}-\d+$")
+_PLAN_ITEM_ID_RE = re.compile(r"^P-")
 _ROW_DEFINITION_KEYS = (
     "statement",
     "summary",
     "item",
     "title",
+    "subject",
     "check",
     "action",
     "evidence",
@@ -1992,6 +1995,138 @@ def _option_view(option: Mapping[str, Any], index: int) -> list[str]:
     ]
 
 
+def _option_probe_texts(options: list[Any]) -> list[str]:
+    texts: list[str] = []
+    for option in options:
+        if not isinstance(option, Mapping):
+            continue
+        texts.extend(
+            str(option.get(key) or "")
+            for key in ("answer", "rationale", "addedWork", "directionChange")
+        )
+    return texts
+
+
+def _row_probe_texts(row: Mapping[str, Any]) -> list[str]:
+    return [
+        str(row.get("statement") or ""),
+        str(row.get("expected_form") or ""),
+        *_option_probe_texts(list(row.get("options") or [])),
+    ]
+
+
+def _path_line_refs(*texts: str) -> list[str]:
+    found: list[str] = []
+    seen: set[str] = set()
+    for text in texts:
+        for match in _PATH_LINE_RE.findall(text or ""):
+            if match not in seen:
+                seen.add(match)
+                found.append(match)
+    return found
+
+
+def _why_asked(row: Mapping[str, Any]) -> str:
+    approval = row.get("approval_context") or {}
+    if not isinstance(approval, Mapping):
+        return "not stated in the report"
+    unblock = str(approval.get("unblockCondition") or "").strip()
+    if unblock:
+        return unblock
+    classification = str(approval.get("classification") or "").strip()
+    return classification or "not stated in the report"
+
+
+def _linked_plan_items(
+    record: dict[str, Any] | None, clarification_id: str
+) -> list[dict[str, str]]:
+    if record is None:
+        return []
+    linked: list[dict[str, str]] = []
+    seen: set[str] = set()
+
+    def walk(node: object) -> None:
+        if isinstance(node, dict):
+            row_id = node.get("id")
+            refs = node.get("clarificationRefs") or []
+            if (
+                isinstance(row_id, str)
+                and _PLAN_ITEM_ID_RE.match(row_id)
+                and isinstance(refs, list)
+                and clarification_id in refs
+                and row_id not in seen
+            ):
+                seen.add(row_id)
+                linked.append({
+                    "id": row_id,
+                    "definition": _row_definition(node) or "not stated in the report",
+                })
+            for value in node.values():
+                walk(value)
+        elif isinstance(node, list):
+            for item in node:
+                walk(item)
+
+    walk(record)
+    return linked
+
+
+def _format_ref_list(label: str, items: list[str]) -> list[str]:
+    if not items:
+        return [f"{label}: none"]
+    return [f"{label}:", *(f"- {item}" for item in items)]
+
+
+def _format_open_row_view(
+    row: Mapping[str, Any],
+    record: dict[str, Any] | None,
+    markdown_text: str,
+    response: UserResponseEntry | None,
+) -> list[str]:
+    item = row["item"]
+    probe = _row_probe_texts(row)
+    refs = sorted(set(_SECTION_REF_RE.findall(" ".join(probe))))
+    resolved = (
+        resolve_refs_from_record(record, refs)
+        if record is not None
+        else resolve_refs(markdown_text, refs)
+    )
+    lines = [
+        "",
+        f"[{item.row_id}]",
+        f"Kind: {item.kind}",
+        f"Blocks: {item.blocks}",
+        f"Report status: {item.status}",
+        f"Question: {row['statement']}",
+        f"Expected form: {row['expected_form']}",
+        f"Current response: {response.value if response else 'none'}",
+        f"Current disposition: {response.disposition if response else 'none'}",
+        f"Why asked: {_why_asked(row)}",
+        "Options:",
+    ]
+    approval = row.get("approval_context") or {}
+    if isinstance(approval, Mapping) and approval:
+        lines.extend([
+            f"Approval classification: {approval.get('classification', '')}",
+            f"Approval unblock condition: {approval.get('unblockCondition', '')}",
+            f"Approval recommended disposition: {approval.get('recommendedDisposition', '')}",
+        ])
+    for index, option in enumerate(row["options"], start=1):
+        lines.extend(_option_view(option, index))
+    linked = _linked_plan_items(record, item.row_id)
+    lines.extend(_format_ref_list(
+        "Linked plan items",
+        [f"{plan['id']}: {plan['definition']}" for plan in linked],
+    ))
+    lines.extend(_format_ref_list("Cited artifacts", _path_line_refs(*probe)))
+    lines.append("Context:")
+    lines.extend(
+        f"- {ref['ref']}: {ref['definition'] or 'not stated in the report'}"
+        for ref in resolved
+    )
+    return lines
+
+
 def format_show_view(report_path: Path, project_root: Path) -> str:
     context = _validate_owned_report_context(
         report_path, expected_project_root=project_root
@@ -1999,6 +2134,10 @@ def format_show_view(report_path: Path, project_root: Path) -> str:
     rows, record = _all_report_rows(context.report_path)
     state = _existing_sidecar_state(context.sidecar_path)
     current = {entry.response_id: entry for entry in state.entries}
+    markdown_text = (
+        "" if record is not None
+        else context.markdown_path.read_text(encoding="utf-8")
+    )
     lines = [
         "USER RESPONSE REPORT",
         f"Report: {context.report_path}",
@@ -2015,51 +2154,22 @@ def format_show_view(report_path: Path, project_root: Path) -> str:
     if candidates:
         lines.append("Plan option candidates:")
         for index, candidate in enumerate(candidates, start=1):
+            current_pick = (
+                state.plan_decision is not None
+                and state.plan_decision.implementation_option == candidate
+            )
             lines.extend([
                 f"Plan option {index}: {candidate}",
                 f"  Recommended: {'yes' if candidate == recommended_name else 'no'}",
-                "  Current decision: "
-                f"{'yes' if state.plan_decision and state.plan_decision.implementation_option == candidate else 'no'}",
+                f"  Current decision: {'yes' if current_pick else 'no'}",
             ])
     for row in rows:
         item = row["item"]
         if item.status not in {"open", "answered"} or item.row_id in current:
             continue
-        refs = sorted(set(_SECTION_REF_RE.findall(
-            row["statement"] + " " + row["expected_form"]
-        )))
-        resolved = (
-            resolve_refs_from_record(record, refs)
-            if record is not None
-            else resolve_refs(context.markdown_path.read_text(encoding="utf-8"), refs)
-        )
-        response = current.get(item.row_id)
-        lines.extend([
-            "",
-            f"[{item.row_id}]",
-            f"Kind: {item.kind}",
-            f"Blocks: {item.blocks}",
-            f"Report status: {item.status}",
-            f"Question: {row['statement']}",
-            f"Expected form: {row['expected_form']}",
-            f"Current response: {response.value if response else 'none'}",
-            f"Current disposition: {response.disposition if response else 'none'}",
-            "Options:",
-        ])
-        approval = row.get("approval_context") or {}
-        if approval:
-            lines.extend([
-                f"Approval classification: {approval.get('classification', '')}",
-                f"Approval unblock condition: {approval.get('unblockCondition', '')}",
-                f"Approval recommended disposition: {approval.get('recommendedDisposition', '')}",
-            ])
-        for index, option in enumerate(row["options"], start=1):
-            lines.extend(_option_view(option, index))
-        lines.append("Context:")
-        lines.extend(
-            f"- {ref['ref']}: {ref['definition'] or 'not stated in the report'}"
-            for ref in resolved
-        )
+        lines.extend(_format_open_row_view(
+            row, record, markdown_text, current.get(item.row_id),
+        ))
     return "\n".join(lines) + "\n"