okstra 0.195.1 → 0.195.3

package/runtime/python/okstra_ctl/convergence_critic_verify_prompt.py

@@ -0,0 +1,221 @@
+"""coverage-critic gap 검증 지시문을 gap 배치와 로스터에서 결정적으로 렌더한다.
+
+`prompts/lead/convergence.md` §"Gap verification" 은 critic 의 gap 마다 Phase 4
+분석자 한 명이 1라운드 adversarial 반박을 하라고 요구한다. 그런데 그 라운드는
+번호 라운드 원장 밖이라 `plan-round` 가 계획을 내지 않고, `reverify-prompt` 는
+계획 행만 렌더하며, 검증 audience 의 프롬프트는 렌더러 서명 없이는 materialize
+가 거절한다. 실측(2026-09-09 dev-10642 requirements-discovery 001): 리드가 세
+경로를 다 시도해 전부 거부됐고 gap 3건이 `gapsUnverified` 로 남았다.
+
+이 모듈이 그 지시문을 만든다. 입력은 리드가 `apply-critic-gaps` 에 줄 것과 같은
+coverage 배치(투표 전, `gaps[]` 만 채운 상태)와 Round 0 그룹(분석 로스터)이다.
+배정은 엔진과 같은 규칙(`critic_gap_assignees`, 로스터 순서 round-robin)이라
+`apply-critic-gaps` 의 커버리지 검사와 어긋나지 않는다. gap 마다 critic 결과
+파일의 `### [<gapId>]` 절과 critic 감사 사이드카를 실어, 검증자가 리드의 전사가
+아니라 critic 이 실제로 인용한 것을 판단하게 한다. 응답 형식은 번호 라운드와
+같은 adversarial 정본이다 — `apply-critic-gaps` 는 gap 표를 언제나
+adversarial 로 읽는다(`_parse_critic_gap` 의 `adversarial=True`).
+
+산출물은 프롬프트 materializer 의 `--instruction` 이 받는 본문이다. `## Instructions`
+로 시작하므로 `complete_reverify_instruction` 이 모델·task type·금지 목록을 그
+앞에 붙이고 출력 계약을 뒤에 덧붙인다.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+
+from .convergence_critic_prompt import analysis_roster
+from .convergence_engine import critic_gap_assignees
+from .convergence_provenance import worker_result_suffix
+from .convergence_reverify_prompt import (
+    ADVERSARIAL_MANDATE,
+    ADVERSARIAL_RESPONSE,
+)
+from .worker_artifact_paths import WorkerArtifactPathError, audit_sidecar_rel
+from .worker_prompt_policy import CRITIC_VERIFY_DISPATCH_KIND
+
+
+class CriticVerifyPromptError(ValueError):
+    """지시문을 결정적으로 만들 수 없다."""
+
+
+# 렌더된 지시문의 서명. `validate_reverify_prompt` 가 dispatch kind
+# `critic-verify` 에 이 줄을 요구한다 — 번호 라운드의 `reverify-prompt` 서명과
+# 같은 역할이고, 손으로 쓴 지시문은 materialize 에서 거절된다.
+RENDERED_BY_LINE = "**Rendered by:** okstra convergence critic-verify-prompt"
+
+
+@dataclass(frozen=True)
+class CriticGap:
+    """검증 큐의 gap 하나와, critic 결과 파일 안의 실물 인용 위치."""
+
+    gap_id: str
+    summary: str
+    category: str
+    ticket_ids: tuple[str, ...]
+    origin_evidence: str
+
+
+def _nonempty_string(value: Any) -> str:
+    return value if isinstance(value, str) and value.strip() else ""
+
+
+def _project_relative(project_root: Path, path: Path) -> str:
+    try:
+        return path.resolve().relative_to(project_root.resolve()).as_posix()
+    except ValueError as exc:
+        raise CriticVerifyPromptError(
+            f"critic result resolves outside the project root: {path}"
+        ) from exc
+
+
+def critic_result_paths(
+    groups: Mapping[str, Any],
+    *,
+    critic_provider: str,
+    project_root: Path,
+    run_dir: Path,
+) -> tuple[str, str]:
+    """critic 결과 파일과 그 감사 사이드카의 프로젝트 상대 경로.
+
+    critic 결과는 `<provider>-worker-critic-<task-type>-<workerResults seq>.md`
+    로 쓰인다(`-worker-` 토큰이 사이드카 이름을 결정한다 — convergence.md
+    §"Coverage critic pass"). 접미사는 분석자 결과와 같은 규칙으로 그룹의
+    `runManifestPath` 에서 읽는다. 파일이 없으면 critic 결과가 아직 수집되지
+    않은 것이라 거절한다 — gap 검증은 critic 결과 뒤에만 온다.
+    """
+    if not _nonempty_string(critic_provider):
+        raise CriticVerifyPromptError("run manifest has no critic assignment provider")
+    suffix = worker_result_suffix(Path(run_dir), groups)
+    if suffix is None:
+        raise CriticVerifyPromptError(
+            "cannot resolve the worker-result suffix from the grouping's runManifestPath"
+        )
+    result = Path(run_dir) / "worker-results" / f"{critic_provider}-worker-critic-{suffix}.md"
+    if not result.is_file():
+        raise CriticVerifyPromptError(
+            f"critic result is not collected yet: {result}; gap verification "
+            "follows the critic result"
+        )
+    result_rel = _project_relative(project_root, result)
+    try:
+        return result_rel, audit_sidecar_rel(result_rel)
+    except WorkerArtifactPathError as exc:
+        raise CriticVerifyPromptError(str(exc)) from exc
+
+
+def critic_verify_gaps(
+    batch: Mapping[str, Any],
+    groups: Mapping[str, Any],
+    worker_id: str,
+) -> list[CriticGap]:
+    """이 워커에게 배정된 gap 을 배치 순서대로.
+
+    배정은 `critic_gap_assignees` 와 같다: 선언된 중복을 뺀 gap *i* 가
+    `roster[i % len(roster)]` 에게 간다. 로스터는 Round 0 그룹의 분석 audience
+    워커 순서다 — `apply-critic-gaps` 가 `analyserRoster` 로 적는 것과 같은
+    순서다.
+    """
+    gaps_value = batch.get("gaps")
+    if not isinstance(gaps_value, list) or not gaps_value:
+        raise CriticVerifyPromptError("coverage batch has no gaps array")
+    roster = analysis_roster(groups)
+    # `<worker>-worker` 슬러그도 같은 워커다 — reverify 의 `plan_row_for_worker`
+    # 와 validate-run 의 `_plan_dispatch_finding_ids` 가 같은 규칙으로 맞춘다.
+    if worker_id not in roster and worker_id.removesuffix("-worker") in roster:
+        worker_id = worker_id.removesuffix("-worker")
+    if worker_id not in roster:
+        raise CriticVerifyPromptError(
+            f"`{worker_id}` is not an analysis worker of this run; roster: "
+            f"{', '.join(roster) or 'none'}"
+        )
+    verifiable = [
+        gap for gap in gaps_value
+        if isinstance(gap, Mapping) and not gap.get("duplicateOf")
+    ]
+    assignees = critic_gap_assignees(roster, verifiable)
+    assigned: list[CriticGap] = []
+    seen: set[str] = set()
+    for gap, assignee in zip(verifiable, assignees):
+        gap_id = _nonempty_string(gap.get("gapId"))
+        if not gap_id:
+            raise CriticVerifyPromptError("coverage batch gap has no gapId")
+        if gap_id in seen:
+            raise CriticVerifyPromptError(f"duplicate critic gapId: {gap_id}")
+        seen.add(gap_id)
+        if assignee != worker_id:
+            continue
+        ticket_ids = gap.get("ticketIds")
+        assigned.append(CriticGap(
+            gap_id=gap_id,
+            summary=_nonempty_string(gap.get("summary")),
+            category=_nonempty_string(gap.get("category")),
+            ticket_ids=tuple(
+                str(ticket) for ticket in ticket_ids
+            ) if isinstance(ticket_ids, list) else (),
+            origin_evidence=_nonempty_string(gap.get("originEvidence")),
+        ))
+    if not assigned:
+        raise CriticVerifyPromptError(
+            f"round-robin assigns no gap to `{worker_id}`; assignees in batch "
+            f"order: {', '.join(assignees) or 'none'}"
+        )
+    return assigned
+
+
+_EVIDENCE_ACCESS = """The `**Cited evidence**` line is the lead's summary of what the critic cited.
+The complete citation is the critic's own item: before judging, open the
+`**Origin item**` file at the named `### [<gap-id>]` section and read every path,
+line, command, and quote it cites. The `**Origin audit sidecar**` records the
+read-only commands the critic ran and their output; it counts as cited evidence
+and you may open it. A gap claims that something was NOT covered — to refute it,
+show where the coverage exists (an analyser result item, a file, a test); to
+let it survive, confirm the coverage is absent where the critic says it is."""
+
+
+def critic_verify_prompt_body(
+    *,
+    task_key: str,
+    critic_worker: str,
+    critic_result_path: str,
+    critic_audit_path: str,
+    gaps: Sequence[CriticGap],
+) -> str:
+    """critic gap 검증 지시문 본문. 같은 입력이면 같은 바이트를 낸다."""
+    if not _nonempty_string(task_key):
+        raise CriticVerifyPromptError("run manifest carries no taskKey")
+    if not gaps:
+        raise CriticVerifyPromptError("no gaps to verify")
+    rows = [
+        "## Instructions\n\n",
+        f"{RENDERED_BY_LINE}\n\n",
+        f"Perform ADVERSARIAL coverage-gap verification for {task_key} "
+        f"(dispatch kind `{CRITIC_VERIFY_DISPATCH_KIND}`, one round).\n\n",
+        ADVERSARIAL_MANDATE, "\n\n",
+        _EVIDENCE_ACCESS, "\n\n",
+        "## Findings to verify\n",
+    ]
+    for gap in gaps:
+        rows.append(f"\n### {gap.gap_id}: {gap.summary or '(no summary)'}\n")
+        rows.append(f"**Origin**: {critic_worker}\n")
+        rows.append(f"**Category**: {gap.category or '(none recorded)'}\n")
+        if gap.ticket_ids:
+            rows.append(f"**Tickets**: {', '.join(gap.ticket_ids)}\n")
+        rows.append(f"**Cited evidence**: {gap.origin_evidence or '(none recorded)'}\n")
+        rows.append(
+            f"**Origin item**: `{critic_result_path}` — section `### [{gap.gap_id}]`\n"
+        )
+        rows.append(f"**Origin audit sidecar**: `{critic_audit_path}`\n")
+    rows.append("\n## Response format\n\n")
+    rows.append(
+        "One block per gap, headed by the gap id at exactly three hashes. "
+        "Field labels are bold with the colon outside (`**Verdict**: …`); the "
+        "collector also reads `**Verdict:** …` and `- Verdict: …` as the same field.\n\n"
+    )
+    rows.append(ADVERSARIAL_RESPONSE.replace("<finding-id>", gaps[0].gap_id))
+    rows.append("\n")
+    if len(gaps) > 1:
+        rows.append(f"\n### {gaps[1].gap_id}\n**Verdict**: ...\n")
+    return "".join(rows)

package/runtime/python/okstra_ctl/convergence_engine.py

@@ -952,7 +952,7 @@ def _parse_critic_dispatches(
     return dispatches, completed
 
 
-def _critic_gap_assignees(
+def critic_gap_assignees(
     roster_order: list[str],
     gaps: list[Mapping[str, Any]],
 ) -> list[str]:
@@ -990,7 +990,7 @@ def _critic_gap_coverage_errors(
     계약 위반이 아니라 더 본 것이고, 그 사이 방치된 gap 은 표가 없어
     `unverifiedGaps` 로 스스로 드러난다.
     """
-    assignees = set(_critic_gap_assignees(roster_order, gaps))
+    assignees = set(critic_gap_assignees(roster_order, gaps))
     if dispatched == set(roster_order) or dispatched == assignees:
         return []
     missing = sorted(assignees - dispatched)

package/runtime/python/okstra_ctl/convergence_reverify_prompt.py

@@ -53,7 +53,7 @@ class ReverifyFinding:
     origin_audit_path: str
 
 
-_ADVERSARIAL_MANDATE = """Your job is to BREAK each finding below, not to confirm it. For EACH finding,
+ADVERSARIAL_MANDATE = """Your job is to BREAK each finding below, not to confirm it. For EACH finding,
 open the cited evidence directly and actively search for evidence that the claim
 is wrong, overstated, or unproven. Then respond with exactly one verdict:
 
@@ -95,7 +95,7 @@ commands that worker ran and their output; it counts as cited evidence and you m
 open it. Judge the claim against what the origin worker actually cited, never against
 the summary line alone."""
 
-_ADVERSARIAL_RESPONSE = """### <finding-id>
+ADVERSARIAL_RESPONSE = """### <finding-id>
 **Verdict**: REFUTED | SURVIVES | SURVIVES-WITH-CAVEAT | UNVERIFIABLE
 **Basis** (only if REFUTED): counter-evidence | burden-not-met
 **Explanation**: <2-3 sentences; for counter-evidence include the file:line you found>"""
@@ -206,8 +206,8 @@ def reverify_prompt_body(
     if not findings:
         raise ReverifyPromptError("no findings to verify")
     mode = "ADVERSARIAL re-verification" if adversarial else "re-verification"
-    mandate = _ADVERSARIAL_MANDATE if adversarial else _COLLABORATIVE_MANDATE
-    response = _ADVERSARIAL_RESPONSE if adversarial else _COLLABORATIVE_RESPONSE
+    mandate = ADVERSARIAL_MANDATE if adversarial else _COLLABORATIVE_MANDATE
+    response = ADVERSARIAL_RESPONSE if adversarial else _COLLABORATIVE_RESPONSE
     rows = [
         "## Instructions\n\n",
         f"{RENDERED_BY_LINE}\n\n",

package/runtime/python/okstra_ctl/convergence_store.py

@@ -106,9 +106,16 @@ def reserve_dynamic_verifier(
     *,
     input_digest: str,
     invocation_ref: str | None = None,
+    dispatch_kind: str | None = None,
 ) -> tuple[RoleExecution, Invocation]:
     """Reserve one provider-neutral verifier identity for a logical round.
 
+    ``dispatch_kind`` 를 주지 않으면 번호 라운드(`reverify-r<N>`)다. critic gap
+    검증(`critic-verify`)은 같은 verifier 신원을 예약하되 kind 를 그대로 적는다 —
+    validate-run 이 team-state 의 dispatch kind 와 예약된 invocation 의
+    `dispatchKind` 를 대조하므로 예약이 `reverify-r1` 로 남으면 그 디스패치가
+    거부된다.
+
     예약은 정체성만 잡는다. 쓰기 계약은 디스패치가 attempt 를 열 때 한 번만
     계산해 그 attempt 행에 적는다 — 예약이 같은 값을 두 번째로 계산하던 동안,
     두 계산의 입력(worktree)이 갈리면 같은 invocationRef 가 `invocationRef
@@ -156,7 +163,7 @@ def reserve_dynamic_verifier(
             source_invocation_ref=None,
             recovery_ref=None,
             duty_id=duty_id,
-            dispatch_kind=f"reverify-r{round_number}",
+            dispatch_kind=dispatch_kind or f"reverify-r{round_number}",
             round=round_number,
             input_digest=input_digest,
         )

package/runtime/python/okstra_ctl/dispatch_state.py

@@ -61,6 +61,7 @@ from .worker_prompt_contract import (
     validate_prompt_model_header,
     validate_reverify_prompt,
 )
+from .worker_prompt_policy import is_verification_dispatch_kind
 from .worker_runner import LIVE, QUIET
 from .worker_request import verifier_extra_dirs
 from .worker_artifact_paths import audit_sidecar_rel
@@ -1880,13 +1881,13 @@ def validate_dispatch_prompts(
     if isinstance(manifest.get("agentContract"), Mapping):
         _validate_agent_invocations(manifest, jobs)
     initial_jobs = [
-        job for job in jobs if not job.dispatch_kind.startswith("reverify-r")
+        job for job in jobs if not is_verification_dispatch_kind(job.dispatch_kind)
     ]
     if initial_jobs:
         validate_initial_prompts(manifest, initial_jobs)
 
     reverify_jobs = [
-        job for job in jobs if job.dispatch_kind.startswith("reverify-r")
+        job for job in jobs if is_verification_dispatch_kind(job.dispatch_kind)
     ]
     if not reverify_jobs:
         return
@@ -1919,6 +1920,7 @@ def validate_dispatch_prompts(
                 task_type=task_type,
                 forbidden_actions=forbidden_actions,
                 expected_model=job.model_execution_value or None,
+                dispatch_kind=job.dispatch_kind,
             )
         )
     if errors:

package/runtime/python/okstra_ctl/final_report_schema.py

@@ -334,6 +334,65 @@ class _Validator:
         self.errors.append(f"{_format_path(path)}: {message}")
 
 
+def follow_up_task_rules(schema: Mapping[str, Any], task_type: str) -> tuple[str, ...]:
+    """이 task type 의 `followUpTasks` 에 스키마가 못 박은 행 규칙, 저작 문장으로.
+
+    `allOf` 의 if/then 가지 하나가 비종결 task type 에 phase-continuation 행
+    하나를 요구하고(`minItems`, `contains.origin.const`), `FollowUpRow` 의
+    가지가 그 행의 `autoSpawn` 을 `no` 로 고정한다. 작성자는 둘 다 읽지 못해
+    빈 배열을 냈고 조립이 `array length 0 < minItems 1` 로 거절했다(2026-09-09
+    실측, dev-10642 requirements-discovery: 이 계열로만 라운드 3회). 가지가
+    이 task type 에 없으면 빈 튜플이다 — 제약이 없다는 뜻이지 실패가 아니다.
+    """
+    def _task_matches(condition: Any) -> bool:
+        if not isinstance(condition, dict):
+            return False
+        header = (condition.get("properties") or {}).get("header") or {}
+        selector = (header.get("properties") or {}).get("taskType") or {}
+        allowed = selector.get("enum")
+        if allowed is None and "const" in selector:
+            allowed = [selector["const"]]
+        return isinstance(allowed, list) and task_type in allowed
+
+    rules: list[str] = []
+    for branch in schema.get("allOf") or []:
+        if not isinstance(branch, dict) or not _task_matches(branch.get("if")):
+            continue
+        follow_up = ((branch.get("then") or {}).get("properties") or {}).get("followUpTasks")
+        if not isinstance(follow_up, dict):
+            continue
+        min_items = follow_up.get("minItems")
+        origin = (
+            ((follow_up.get("contains") or {}).get("properties") or {}).get("origin") or {}
+        ).get("const")
+        if isinstance(min_items, int) and min_items > 0:
+            rules.append(
+                f"`Follow Up Tasks`: at least {min_items} `- Item N` row(s) for task "
+                f"type `{task_type}`; an empty list is refused."
+            )
+        if isinstance(origin, str) and origin:
+            rules.append(
+                f"`Follow Up Tasks`: one row must carry `Origin` `{origin}` — the "
+                "next phase of this task."
+            )
+            row_schema = (schema.get("$defs") or {}).get("FollowUpRow") or {}
+            for row_branch in row_schema.get("allOf") or []:
+                if not isinstance(row_branch, dict):
+                    continue
+                condition = ((row_branch.get("if") or {}).get("properties") or {}).get("origin") or {}
+                if condition.get("const") != origin:
+                    continue
+                pinned = ((row_branch.get("then") or {}).get("properties") or {})
+                for key, value in pinned.items():
+                    if isinstance(value, dict) and "const" in value:
+                        rules.append(
+                            f"`Follow Up Tasks`: the `{origin}` row's `{key}` "
+                            f"(schema key; write its Title Case label) is exactly "
+                            f"`{value['const']}`."
+                        )
+    return tuple(rules)
+
+
 def verdict_token_rule(schema: Mapping[str, Any], task_type: str) -> tuple[str, ...]:
     """이 task type 의 `finalVerdict.verdictToken` 에 스키마가 허용하는 값.
 

package/runtime/python/okstra_ctl/report_corrections.py

@@ -35,7 +35,7 @@ from .report_narrative import (
 CORRECTION_KINDS = ("replace", "remove", "rewrite")
 MECHANICAL_KINDS = frozenset({"replace", "remove"})
 # okstra 가 렌더하는 절. 지시문 본문에 있으면 두 절이 갈라지므로 거절한다.
-OKSTRA_OWNED_SECTIONS = ("## Corrections", "## Output")
+OKSTRA_OWNED_SECTIONS = ("## Corrections", "## Previous Attempt", "## Output")
 
 _SCHEMA_RELATIVE = ("schemas", "report-writer-corrections-v1.0.schema.json")
 _SEGMENT_RE = re.compile(r"^([A-Za-z][A-Za-z0-9]*)((?:\[\d+\])*)$")

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

@@ -191,6 +191,7 @@ def render_v2_html_view(
     response_js = (root / "report.js").read_text(encoding="utf-8")
     base_js = (root / "html/assets/base.js").read_text(encoding="utf-8")
     source_data = final_report_data_path(Path(run_meta.source_report)).as_posix()
+    user_responses_dir = user_responses_dir_for_report(data_path.resolve())
     context = {
         **view.context,
         "runMeta": run_meta,
@@ -215,6 +216,11 @@ def render_v2_html_view(
         # Every task type ends with the same run-cost section, so it is bound
         # here rather than in ten view models that would each rebuild it.
         "runUsage": run_usage(data),
+        # 바닥글이 "여기에 두면" 이라고 가리키는 디렉터리. 상대 경로
+        # `runs/<type>/user-responses/` 는 task 디렉터리 기준이라는 말이 없어
+        # 프로젝트 루트에서 찾으면 없고, implementation 은 stage 아래라 그 경로
+        # 자체가 틀렸다(실측 2026-09-09) — 보고서 파일에서 계산한 절대 경로를 찍는다.
+        "userResponseDir": user_responses_dir.as_posix(),
         "executionRoles": data.get("executionRoles") or [],
         "css": (root / "html/assets/base.css").read_text(encoding="utf-8"),
         "js": response_js + "\n" + base_js,
@@ -223,8 +229,8 @@ def render_v2_html_view(
     document = env.get_template(route.template_name).render(**context)
     document = inject_report_index(document, label=translate("base.contents"))
     output_path.write_text(document, encoding="utf-8")
-    if context["clarificationItems"] or context.get("directionSelection"):
-        # The footer tells the reader to drop the exported file here, so the
-        # directory has to exist before they go looking for it.
-        user_responses_dir_for_report(data_path).mkdir(parents=True, exist_ok=True)
+    # The footer tells the reader to drop the exported file here, so the
+    # directory has to exist before they go looking for it — on every report,
+    # not only those with clarification rows: the footer is rendered on all.
+    user_responses_dir.mkdir(parents=True, exist_ok=True)
     return output_path

package/runtime/python/okstra_ctl/report_narrative.py

@@ -40,7 +40,10 @@ NARRATIVE_GRAMMAR_INSTRUCTIONS: tuple[str, ...] = (
     "nest a child by indenting two more spaces), `- Item <N>` (one array entry, "
     "numbered 1..N without gaps), and `> value` (one scalar; repeat the line for a "
     "multi-line value; `> _none_` for null, an empty object, or an empty array). "
-    "Blank lines are ignored.",
+    "A `> value` line is indented exactly two spaces deeper than the `- **Label**` "
+    "or `- Item N` line it belongs to — a label at column 0 takes its value at "
+    "column 2, a label at column 2 takes it at column 4; a value at column 0 is "
+    "outside every field and the file is refused. Blank lines are ignored.",
     "Every other line is rejected — YAML frontmatter (`---` blocks), Markdown "
     "headings (`#`, `##`, `###`), pipe tables at column 0, code fences, bare "
     "paragraphs, JSON. Put such text inside a `> ` value instead. Report assembly "

package/runtime/python/okstra_ctl/report_projections.py

@@ -49,6 +49,24 @@ def _agent_label(row: Mapping[str, Any]) -> str:
     return _AGENT_LABELS.get(value.lower(), value)
 
 
+def _row_model(row: Mapping[str, Any], usage: Mapping[str, Any]) -> str:
+    """행이 이름한 모델, 없으면 사용량 수집기가 트랜스크립트에서 읽은 모델.
+
+    `/okstra-run` 으로 현재 세션에서 도는 리드는 prepare 시점에 모델을 모른다 —
+    매니페스트 `leadModel` 과 team-state `lead.model` 이 문자 그대로 `unknown`
+    이다. 수집기는 그 세션의 jsonl 에서 `claude-opus-5` 를 읽어 `leadUsage.model`
+    에 적어 두므로, 표는 그 값을 쓴다(실측 2026-09-09: 리드 행 모델 `unknown`).
+    """
+    named = row.get("model") or row.get("modelExecutionValue")
+    if isinstance(named, str) and named.strip() and named.strip() != "unknown":
+        return named.strip()
+    if usage.get("source") != "unavailable":
+        measured = usage.get("model")
+        if isinstance(measured, str) and measured.strip():
+            return measured.strip()
+    return "unknown"
+
+
 def _execution_row(
     row: Mapping[str, Any],
     *,
@@ -65,7 +83,7 @@ def _execution_row(
     result = {
         "agent": _agent_label(row),
         "role": role,
-        "model": _text(row.get("model") or row.get("modelExecutionValue"), "unknown"),
+        "model": _row_model(row, source),
         "status": status,
         "summary": _text(
             row.get("summary") or row.get("reason"),

package/runtime/python/okstra_ctl/report_synthesis_packet.py

@@ -26,7 +26,7 @@ from .report_narrative import writer_owned_data
 from .scope_provenance import brief_end_state_id_sequence
 
 from .exact_coverage import COVERAGE_VERDICT_PRECEDENCE
-from .final_report_schema import task_block_rules, verdict_token_rule
+from .final_report_schema import follow_up_task_rules, task_block_rules, verdict_token_rule
 from .report_contract import TASK_TYPE_DATA_PROPERTY
 from .report_markdown import humanise
 from .report_narrative import NarrativeContractError, allowed_top_level_fields
@@ -87,6 +87,10 @@ class ReportSynthesisPacket:
     # (2026-09-03 실측: implementation-option-selection 네 회차).
     block_key: str = ""
     block_rules: tuple[str, ...] = ()
+    # 비종결 task type 의 `followUpTasks` 행 규칙(최소 행 수, phase-continuation
+    # 행, 그 행의 autoSpawn). 스키마의 if/then 가지라 작성자에게 도달하지 않았고
+    # 빈 배열이 조립에서야 거절됐다(2026-09-09 실측, dev-10642).
+    follow_up_rules: tuple[str, ...] = ()
     # 작성자가 최상위에 쓸 수 있는 필드 전체(서사 스키마의 properties). 필수만
     # 적던 동안 리드가 어느 task type 에도 없는 절을 지시했고, 작성자는 조립이
     # 거절할 때까지 그 지시를 거를 근거가 없었다(2026-09-03 실측).
@@ -142,6 +146,7 @@ class ReportSynthesisPacket:
                 f"contain: {labels}. Report assembly refuses any other top-level "
                 "field, whichever instruction asked for it."
             )
+        lines.extend(self.follow_up_rules)
         if self.block_rules:
             lines.append(
                 f"Shape of the `{self.block_key}` block, one line per object, from "
@@ -736,8 +741,8 @@ def build_report_synthesis_packet(
                 for worker in roster
                 if _string(worker) and _string(worker) != "report-writer"
             )
-    required_top_level, verdict_tokens, block_rules = _schema_authoring_rules(
-        sources, task_type
+    required_top_level, verdict_tokens, block_rules, follow_up_rules = (
+        _schema_authoring_rules(sources, task_type)
     )
     return ReportSynthesisPacket(
         task_key=_string(manifest.get("taskKey")),
@@ -745,6 +750,7 @@ def build_report_synthesis_packet(
         result_path=_relative(project_root, narrative_path),
         required_top_level=required_top_level,
         verdict_tokens=verdict_tokens,
+        follow_up_rules=follow_up_rules,
         block_key=TASK_TYPE_DATA_PROPERTY.get(task_type, "") if block_rules else "",
         block_rules=block_rules,
         allowed_top_level=_allowed_top_level_labels(),
@@ -758,12 +764,13 @@ def build_report_synthesis_packet(
 
 def _schema_authoring_rules(
     sources: tuple[ReportSynthesisSource, ...], task_type: str,
-) -> tuple[tuple[str, ...], tuple[str, ...], tuple[str, ...]]:
-    """넘겨받은(동결된) 완성 리포트 스키마에서 작성자 몫의 규칙 세 가지를 뽑는다.
+) -> tuple[tuple[str, ...], tuple[str, ...], tuple[str, ...], tuple[str, ...]]:
+    """넘겨받은(동결된) 완성 리포트 스키마에서 작성자 몫의 규칙 네 가지를 뽑는다.
 
     최상위 `required` 가운데 작성자 소유 이름(서사 스키마의 properties)만
-    사람이 읽는 라벨로, 이 task type 의 `Verdict Token` 허용값, 그리고 이 task
-    type 의 데이터 블록 안쪽 모양(`task_block_rules`). 스키마 소스가 없거나
+    사람이 읽는 라벨로, 이 task type 의 `Verdict Token` 허용값, 이 task type 의
+    데이터 블록 안쪽 모양(`task_block_rules`), 그리고 `followUpTasks` 행 규칙
+    (`follow_up_task_rules`). 스키마 소스가 없거나
     JSON 이 아니면 빈 값이다 — 이 함수는 조립 검증을 대신하지 않고 도달하지
     못하던 규칙을 저작 계약에 옮길 뿐이다.
     """
@@ -789,7 +796,12 @@ def _schema_authoring_rules(
     )
     block_key = TASK_TYPE_DATA_PROPERTY.get(task_type, "")
     block_rules = task_block_rules(schema, block_key) if block_key else ()
-    return required_top_level, verdict_token_rule(schema, task_type), block_rules
+    return (
+        required_top_level,
+        verdict_token_rule(schema, task_type),
+        block_rules,
+        follow_up_task_rules(schema, task_type),
+    )
 
 
 def _allowed_top_level_labels() -> tuple[str, ...]:

package/runtime/python/okstra_ctl/wizard/engine.py

@@ -132,13 +132,23 @@ def next_prompt(state: WizardState) -> Prompt:
 
 
 def _native_picker_screen(state: WizardState, prompt: Prompt) -> Prompt:
+    """호스트 네이티브 선택기 한도에 맞춘 화면.
+
+    단일 선택이 한도를 넘으면 쪽으로 나눈다(`present_picker`). 체크박스(`multi`)는
+    나누지 않는다 — 네이티브 체크박스에 못 실으면 `CapabilityInteractionPort.plan`
+    이 `numbered-multi` 로 내려 전체 목록을 한 번에 보인다. 종전엔 체크박스도
+    한 줄씩 토글하는 쪽으로 내렸는데, claude-code 한도 4 에서 후보 12개는 쪽당
+    2개가 됐고, 쪽 사본이 추천 표시를 단 채 단일 선택이 돼 `Prompt` 의 추천
+    불변식(단일 선택은 추천 정확히 하나)에 걸려 화면이 열리지 않았다(실측
+    2026-09-09, verifier 전체 후보 화면).
+    """
     if "native_single_select" not in state.available_functions:
         return prompt
     if prompt.kind == "pick_group":
         if _interaction_plan(state, prompt).kind == "native-group":
             return prompt
         prompt = prompt.questions[0]
-    if _interaction_plan(state, prompt).kind == "native-multi":
+    if prompt.multi:
         return prompt
     limit = default_host_registry().resolve(state.host_runtime).interaction().native_option_limit
     return present_picker(state, prompt, limit=limit)
@@ -377,9 +387,8 @@ def submit(state: WizardState, value: str) -> dict[str, Any]:
     if prompt.kind == "pick_group":
         return _submit_group(state, prompt, value)
     if _is_role_selection_step(prompt.step):
-        # 화면은 호스트 한도에 맞춰 쪽으로 잘린 사본일 수 있다(`present_picker`).
-        # 답은 잘리지 않은 원본의 선택지로 검증한다 — 체크박스의 CSV 는 여러
-        # 쪽에 걸쳐 고른 값이다.
+        # 고정 단일 역할의 화면은 호스트 한도에 맞춰 쪽으로 잘린 사본일 수
+        # 있다(`present_picker`). 답은 잘리지 않은 원본의 선택지로 검증한다.
         original = next_role_prompt(state)
         if original is not None and original.step == prompt.step:
             prompt = original