okstra 0.209.0 → 0.209.1

package/runtime/python/okstra_ctl/cmux.py

@@ -14,7 +14,7 @@ import socket
 import subprocess
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Collection, Sequence
+from typing import Any, Collection, Mapping, Sequence
 
 PING_OK = "PONG"
 
@@ -124,18 +124,63 @@ def cmux_available() -> bool:
         return False
     if not _ping_answers():
         return False
-    return bool(resolve_lead_workspace())
+    return bool(resolve_lead_workspace(None))
 
 
-def resolve_lead_workspace() -> str:
+@dataclass(frozen=True)
+class LeadLocation:
+    """prepare 가 본 리드의 cmux 위치. run manifest 에 기록된다."""
+
+    workspace_id: str
+    surface_id: str
+
+
+# run manifest 키. 리드 프로세스의 CMUX_* 는 리드를 띄운 터미널의 것이 아닐 수
+# 있다 — Claude Code 가 미리 띄워 둔 bg-spare 를 잡으면 그 프로세스가 만들어질
+# 때의 workspace 를 물려받는다(실측 2026-10-04). prepare 는 사용자가 실행한
+# 터미널에서 돌므로 그 시점 값을 기록하고, 이후 해석은 기록을 먼저 쓴다.
+LEAD_LOCATION_KEY = "cmuxLead"
+
+
+def lead_location_from_env() -> LeadLocation | None:
+    """이 프로세스의 cmux 위치. CMUX_* 두 값 중 하나라도 없으면 None."""
+    workspace = _lead_workspace_env()
+    surface = os.environ.get("CMUX_SURFACE_ID", "").strip()
+    if not workspace or not surface:
+        return None
+    return LeadLocation(workspace_id=workspace, surface_id=surface)
+
+
+def lead_location_payload(location: LeadLocation) -> dict[str, str]:
+    return {"workspaceId": location.workspace_id, "surfaceId": location.surface_id}
+
+
+def recorded_lead(manifest: Mapping[str, Any]) -> LeadLocation | None:
+    """prepare 가 기록한 리드 위치. 기록이 없는 run(이전 버전 manifest 포함)은 None."""
+    block = manifest.get(LEAD_LOCATION_KEY)
+    if not isinstance(block, Mapping):
+        return None
+    workspace = str(block.get("workspaceId") or "").strip()
+    surface = str(block.get("surfaceId") or "").strip()
+    if not workspace or not surface:
+        return None
+    return LeadLocation(workspace_id=workspace, surface_id=surface)
+
+
+def resolve_lead_workspace(recorded: LeadLocation | None) -> str:
     """The lead's workspace UUID, or "" when it cannot be resolved.
 
-    The UUID is read from the environment rather than from `identify`, whose
-    refs are positional and shift as surfaces open and close. `identify` is
-    consulted only to prove the environment is current: a process that inherits
-    a CMUX_* block keeps it verbatim, so those variables can outlive the surface
-    they name.
+    기록된 위치가 있으면 환경보다 우선하고, 그 surface 가 아직 열려 있을 때만
+    유효하다 — 닫힌 리드 옆에 워커를 열 이유가 없다.
+
+    Without one, the UUID is read from the environment rather than from
+    `identify`, whose refs are positional and shift as surfaces open and close.
+    `identify` is consulted only to prove the environment is current: a process
+    that inherits a CMUX_* block keeps it verbatim, so those variables can
+    outlive the surface they name.
     """
+    if recorded is not None:
+        return recorded.workspace_id if _recorded_surface_is_open(recorded) else ""
     workspace = _lead_workspace_env()
     if not workspace:
         return ""
@@ -148,6 +193,13 @@ def _lead_workspace_env() -> str:
     return os.environ.get("CMUX_WORKSPACE_ID", "").strip()
 
 
+def _recorded_surface_is_open(recorded: LeadLocation) -> bool:
+    try:
+        return recorded.surface_id in open_surface_ids(recorded.workspace_id)
+    except (RuntimeError, OSError, subprocess.SubprocessError):
+        return False
+
+
 @dataclass(frozen=True)
 class PaneGeometry:
     """One pane as `pane.list` reports it.
@@ -450,6 +502,7 @@ def spawn_worker_surface(
     command: Sequence[str],
     title: str,
     owned_surface_ids: Collection[str],
+    recorded: LeadLocation | None,
 ) -> str:
     """Start one worker beside the lead and return its surface UUID.
 
@@ -462,7 +515,7 @@ def spawn_worker_surface(
     user and may hold anything.
     """
     panes = list_panes(workspace)
-    lead = _lead_pane(panes)
+    lead = _lead_pane(panes, recorded)
     placement = plan_worker_placement(
         panes,
         lead_pane_id=lead.pane_id,
@@ -472,7 +525,7 @@ def spawn_worker_surface(
     try:
         surface_uuid = _create_surface(workspace, placement, target)
     except (RuntimeError, OSError, subprocess.SubprocessError):
-        _restore_lead_after_failed_spawn(workspace, owned_surface_ids)
+        _restore_lead_after_failed_spawn(workspace, owned_surface_ids, recorded)
         raise
     try:
         renamed = rename_surface(surface_uuid, title)
@@ -480,8 +533,8 @@ def spawn_worker_surface(
             raise RuntimeError(renamed.stderr.strip() or "cmux could not name the worker")
         _exec_worker(surface_uuid, cwd=cwd, command=command)
         owned = (*owned_surface_ids, surface_uuid)
-        _size_lead_pane(workspace, owned)
-        _equalize_worker_heights(workspace, owned)
+        _size_lead_pane(workspace, owned, recorded)
+        _equalize_worker_heights(workspace, owned, recorded)
     except (RuntimeError, OSError, subprocess.SubprocessError) as exc:
         # 호출이 반환되기 전에는 명부에 창 식별자가 없다. 여기서 정리하지
         # 않으면 대체 실행으로 전환된 뒤에도 회수할 수 없는 창이 남는다.
@@ -494,13 +547,15 @@ def spawn_worker_surface(
                 f"{exc}; cleanup failed for cmux surface {surface_uuid}: {cleanup_error}"
             ) from exc
         finally:
-            _restore_lead_after_failed_spawn(workspace, owned_surface_ids)
+            _restore_lead_after_failed_spawn(workspace, owned_surface_ids, recorded)
         raise
     return surface_uuid
 
 
 def _restore_lead_after_failed_spawn(
-    workspace: str, owned_surface_ids: Collection[str]
+    workspace: str,
+    owned_surface_ids: Collection[str],
+    recorded: LeadLocation | None,
 ) -> None:
     """실패한 분할이 리드에서 떼어 간 폭을 돌려준다.
 
@@ -517,7 +572,7 @@ def _restore_lead_after_failed_spawn(
     중이고, 원장에 남아야 할 문장은 그쪽이다.
     """
     try:
-        _size_lead_pane(workspace, owned_surface_ids)
+        _size_lead_pane(workspace, owned_surface_ids, recorded)
     except (RuntimeError, OSError, subprocess.SubprocessError):
         return
 
@@ -561,7 +616,7 @@ def close_surface(surface_uuid: str) -> None:
         return
 
 
-def restore_lead_width() -> None:
+def restore_lead_width(recorded: LeadLocation | None) -> None:
     """Put the lead back on its target width once its workers are reclaimed.
 
     Closing a pane hands its width to whichever neighbour cmux picks, and that
@@ -582,10 +637,10 @@ def restore_lead_width() -> None:
     failed to close counts as a stranger's and keeps its width, which is the
     safe way to be wrong here.
     """
-    workspace = resolve_lead_workspace()
+    workspace = resolve_lead_workspace(recorded)
     if not workspace:
         return
-    _size_lead_pane(workspace, ())
+    _size_lead_pane(workspace, (), recorded)
 
 
 def socket_reachability() -> str:
@@ -614,7 +669,7 @@ def socket_reachability() -> str:
         probe.close()
 
 
-def unreachable_reason() -> str:
+def unreachable_reason(recorded: LeadLocation | None) -> str:
     """Why cmux cannot be reached from here, or "" when it can.
 
     `environment` is the case a socket probe alone cannot see: a sandbox that
@@ -629,7 +684,7 @@ def unreachable_reason() -> str:
         return LOST_DENIED
     if reachability != SOCKET_OK:
         return LOST_GONE
-    return LOST_NOTHING if resolve_lead_workspace() else LOST_GONE
+    return LOST_NOTHING if resolve_lead_workspace(recorded) else LOST_GONE
 
 
 def unreachable_advice(reason: str) -> tuple[str, str]:
@@ -799,7 +854,11 @@ def _exec_worker(surface_uuid: str, *, cwd: Path, command: Sequence[str]) -> Non
         raise RuntimeError(started.stderr.strip() or "cmux could not start the worker")
 
 
-def _size_lead_pane(workspace: str, owned_surface_ids: Collection[str]) -> None:
+def _size_lead_pane(
+    workspace: str,
+    owned_surface_ids: Collection[str],
+    recorded: LeadLocation | None,
+) -> None:
     """Move the lead's border to its share of the workspace.
 
     This is the horizontal border okstra places. The first worker column
@@ -826,7 +885,7 @@ def _size_lead_pane(workspace: str, owned_surface_ids: Collection[str]) -> None:
         # rather than leave it where the user last saw it.
         return
     panes = _panes_from(payload)
-    lead = _lead_pane(panes)
+    lead = _lead_pane(panes, recorded)
     target = lead_target_width(
         panes,
         lead_pane_id=lead.pane_id,
@@ -863,7 +922,9 @@ def _size_lead_pane(workspace: str, owned_surface_ids: Collection[str]) -> None:
 
 
 def _equalize_worker_heights(
-    workspace: str, owned_surface_ids: Collection[str]
+    workspace: str,
+    owned_surface_ids: Collection[str],
+    recorded: LeadLocation | None,
 ) -> None:
     """Give every owned worker the same height in the first column.
 
@@ -875,7 +936,7 @@ def _equalize_worker_heights(
     """
     for _ in range(MAX_WORKER_HEIGHT_MOVES):
         panes = list_panes(workspace)
-        lead = _lead_pane(panes)
+        lead = _lead_pane(panes, recorded)
         workers = [
             pane
             for pane in panes
@@ -896,7 +957,14 @@ def _equalize_worker_heights(
         )
 
 
-def _lead_pane(panes: Sequence[PaneGeometry]) -> PaneGeometry:
+def _lead_pane(
+    panes: Sequence[PaneGeometry], recorded: LeadLocation | None
+) -> PaneGeometry:
+    if recorded is not None:
+        for pane in panes:
+            if recorded.surface_id in pane.surface_ids:
+                return pane
+        raise RuntimeError("cmux could not locate the lead's pane in its workspace")
     caller_pane_ref = identify_caller().get("pane_ref", "")
     for pane in panes:
         if caller_pane_ref and pane.ref == caller_pane_ref:

package/runtime/python/okstra_ctl/convergence.py

@@ -564,7 +564,9 @@ def _parser() -> argparse.ArgumentParser:
     return parser
 
 
-def _emit(operation: str, action: str, path: Path) -> None:
+def _emit(
+    operation: str, action: str, path: Path, extra: Mapping[str, Any] | None = None,
+) -> None:
     print(
         json.dumps(
             {
@@ -572,6 +574,7 @@ def _emit(operation: str, action: str, path: Path) -> None:
                 "operation": operation,
                 "action": action,
                 "path": str(path),
+                **(extra or {}),
             },
             ensure_ascii=False,
         )
@@ -1078,14 +1081,21 @@ def _seed(args: argparse.Namespace) -> tuple[str, Path]:
     return decision.action, args.work_state
 
 
-def _plan_round(args: argparse.Namespace) -> tuple[str, Path]:
+def _plan_round(
+    args: argparse.Namespace,
+) -> tuple[str, Path, dict[str, Any]]:
     state = load_owned_json_object(args.work_state)
     errors = validate_working_state(state)
     if errors:
         raise ConvergenceContractError("invalid working state: " + "; ".join(errors))
     plan = plan_next_round(state)
     write_json_atomic(args.plan, plan)
-    return str(plan["action"]), args.plan
+    # 리드의 `phase-5.5-convergence round=<N> queue=<count>` 줄이 이 두 값을 그대로
+    # 옮긴다. 리드가 계획 파일을 세면 `queueFindingIds` 와 혼동해 queue=0 을 적었다.
+    return str(plan["action"]), args.plan, {
+        "round": plan["round"],
+        "inputQueueSize": plan["inputQueueSize"],
+    }
 
 
 def _apply_round(args: argparse.Namespace) -> tuple[str, Path]:
@@ -1378,7 +1388,7 @@ def _group_from_fields(
         if not colon or not worker or not item_id:
             raise ConvergenceContractError("Sources must use worker:item-id entries")
         parsed = [(worker, item_id, scalar["evidence"])]
-    discovered, source_items = _group_source_provenance(parsed)
+    discovered, source_items = _group_source_provenance(finding_id, parsed)
     origin_worker, separator, origin_item = scalar.get("origin", "").partition(":")
     if not separator or discovered.get(origin_worker, {}).get("itemId") != origin_item:
         raise ConvergenceContractError("Origin must identify one Source item")
@@ -1398,11 +1408,20 @@ def _group_from_fields(
 
 
 def _group_source_provenance(
+    finding_id: str,
     parsed: list[tuple[str, str, str]],
 ) -> tuple[dict[str, dict[str, str]], list[dict[str, str]]]:
-    workers = [worker for worker, _item, _evidence in parsed]
-    if len(workers) != len(set(workers)):
-        raise ConvergenceContractError("duplicate Source worker in one finding")
+    items_by_worker: dict[str, list[str]] = {}
+    for worker, item, _evidence in parsed:
+        items_by_worker.setdefault(worker, []).append(item)
+    for worker, items in items_by_worker.items():
+        if len(items) > 1:
+            raise ConvergenceContractError(
+                f"duplicate Source worker in one finding: {finding_id} has "
+                f"{len(items)} Source lines for `{worker}` ({', '.join(items)}); "
+                "a group takes one Source line per worker, so split the extra "
+                "item(s) into their own group(s) instead of dropping them"
+            )
     discovered = {
         worker: {"itemId": item, "evidence": evidence}
         for worker, item, evidence in parsed
@@ -1754,7 +1773,7 @@ def _settled_critic_result(manifest: Mapping[str, Any]) -> str:
     return latest["resultPath"]
 
 
-def _execute(args: argparse.Namespace) -> tuple[str, Path]:
+def _execute(args: argparse.Namespace) -> tuple[Any, ...]:
     operations: dict[str, Any] = {
         "prepare-groups": _prepare_groups,
         "seed": _seed,
@@ -1797,7 +1816,7 @@ def main(argv: list[str] | None = None) -> int:
         if args.operation == "census-gapfill-prompt":
             print(_census_gapfill_prompt(args), end="")
             return 0
-        action, path = _execute(args)
+        action, path, *extra = _execute(args)
     except (ConvergenceContractError, VerdictBlockError, ReverifyPromptError,
             CriticVerifyPromptError, CensusError,
             json.JSONDecodeError, ValueError) as exc:
@@ -1809,7 +1828,7 @@ def main(argv: list[str] | None = None) -> int:
     if args.operation == "prepare-groups":
         print("Convergence groups\n" + line("Status", "ready") + line("Action", action), end="")
     else:
-        _emit(args.operation, action, path)
+        _emit(args.operation, action, path, *extra)
     return 0
 
 

package/runtime/python/okstra_ctl/dispatch_checkpoints.py

@@ -9,18 +9,30 @@ dispatch 를 정하고 결과를 확정하는 곳은 `team dispatch` / `team awa
 워커별 체크포인트는 `initial` dispatch 만 센다. reverify·critic·plan-verify 는
 리드가 따로 알리는 이후 라운드이고, 여기서 기록하면 activity-contract run 이
 존재하지 않는 `worker-dispatched` / `worker-completed` 행을 요구받게 된다.
+
+activity-contract v1 run 에서는 검증기가 워커별 `phase-4-dispatch` /
+`phase-5-collect` 마다 같은 워커의 `worker-dispatched` / `worker-completed`
+activity 를 요구한다. 체크포인트를 명령이 쓰면 리드는 "activity 먼저, PROGRESS
+다음" 순서를 지킬 수 없으므로 그 activity 도 여기서 쓴다. summary 는 고정 영어다.
 """
 from __future__ import annotations
 
+import sys
 from pathlib import Path
 from typing import Any, Mapping, Sequence
 
+from .agent.activity import (
+    ActivityProjectionError,
+    conversation_activity_line,
+    record_activity,
+)
 from .dispatch_state import (
     TERMINAL_WORKER_STATUSES,
     dispatch_worker_key,
     has_recorded_team_create,
     worker_dispatch_records,
 )
+from .json_boundary import JsonBoundaryError, load_owned_object
 from .lead_progress import record_checkpoint
 from .worker_prompt_body import REPORT_WRITER_WORKER_ID
 
@@ -44,6 +56,7 @@ def record_dispatch_checkpoints(
     """
     if not jobs:
         return []
+    records_activity = _declares_activity_contract(project_root, run_manifest, source)
     lines: list[str | None] = []
     if not has_recorded_team_create(team_state):
         lines.append(record_checkpoint(
@@ -56,6 +69,13 @@ def record_dispatch_checkpoints(
                 worker=job.worker_id,
                 fields=(("model", job.model_execution_value),),
             ))
+            if records_activity:
+                lines.append(_record_worker_activity(
+                    project_root, run_manifest, source=source,
+                    kind="worker-dispatched", agent=job.worker_id,
+                    summary=f"Dispatched {job.worker_id} as an initial worker",
+                    result_path=None, outcome="pending",
+                ))
     dispatches_writer = any(job.worker_id == REPORT_WRITER_WORKER_ID for job in jobs)
     writer_dispatched_before = bool(
         worker_dispatch_records(team_state, REPORT_WRITER_WORKER_ID)
@@ -104,18 +124,88 @@ def record_collect_checkpoints(
     통과했고, 결과가 dispatch 에 연결됐거나(`dispatch_core._finish_attempt`),
     attempt 가 `error` / `timeout` 으로 닫혔다.
     """
-    lines = []
+    lines: list[str | None] = []
+    records_activity: bool | None = None
     for key, record in after.items():
         previous = before.get(key)
         if previous is not None and _attempt(previous) == _attempt(record):
             continue
+        worker = dispatch_worker_key(record)
+        status = str(record.get("status"))
         lines.append(record_checkpoint(
             project_root, run_manifest, "phase-5-collect", source=source,
-            worker=dispatch_worker_key(record),
-            fields=(("status", str(record.get("status"))),),
+            worker=worker, fields=(("status", status),),
         ))
+        if records_activity is None:
+            records_activity = _declares_activity_contract(
+                project_root, run_manifest, source
+            )
+        if records_activity:
+            lines.append(_record_worker_activity(
+                project_root, run_manifest, source=source,
+                kind="worker-completed", agent=worker,
+                summary=f"Collected the {worker} result: status={status}",
+                result_path=_project_relative(project_root, record.get("resultPath")),
+                outcome="completed" if status == "completed" else "failed",
+            ))
     return [line for line in lines if line]
 
 
+def _declares_activity_contract(
+    project_root: Path, run_manifest: str | Path, source: str,
+) -> bool:
+    path = Path(run_manifest)
+    if not path.is_absolute():
+        path = project_root.resolve() / path
+    try:
+        manifest = load_owned_object(path, artifact="run manifest")
+    except JsonBoundaryError as exc:
+        print(f"{source}: could not read activity contract: {exc}", file=sys.stderr)
+        return False
+    return manifest.get("activityContractVersion") == 1
+
+
+def _project_relative(project_root: Path, value: Any) -> str | None:
+    if not isinstance(value, str) or not value:
+        return None
+    path = Path(value)
+    root = project_root.resolve()
+    return str(path.relative_to(root)) if path.is_relative_to(root) else value
+
+
+def _record_worker_activity(
+    project_root: Path,
+    run_manifest: str | Path,
+    *,
+    source: str,
+    kind: str,
+    agent: str,
+    summary: str,
+    result_path: str | None,
+    outcome: str,
+) -> str | None:
+    """실패 처리는 `record_checkpoint` 와 같다: stderr 에만 남기고, 누락은 검증기가 보고한다."""
+    root = project_root.resolve()
+    path = Path(run_manifest)
+    try:
+        event = record_activity(
+            root, path if path.is_absolute() else root / path,
+            {
+                "kind": kind,
+                "agent": agent,
+                "summary": summary,
+                "planItemIds": [],
+                "resultPath": result_path,
+                "commands": [],
+                "evidenceRefs": [],
+                "outcome": outcome,
+            },
+        )
+    except (ActivityProjectionError, OSError) as exc:
+        print(f"{source}: could not record `{kind}` for `{agent}`: {exc}", file=sys.stderr)
+        return None
+    return conversation_activity_line(event.details)
+
+
 def _attempt(record: Mapping[str, Any]) -> int:
     return int(record.get("attempt", 1))

package/runtime/python/okstra_ctl/dispatch_core.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 import json
 import re
 import subprocess
+import sys
 import time
 from dataclasses import dataclass, field, replace
 from datetime import datetime, timezone
@@ -1992,7 +1993,10 @@ def _ensure_runtime_chain(plan: DispatchPlan) -> DispatchPlan:
     if plan.runtime_chain:
         return plan
     from .adapters.runtime.assembly import runtime_chain as build_chain
-    return replace(plan, runtime_chain=build_chain(plan.default_backend))
+    return replace(
+        plan,
+        runtime_chain=build_chain(plan.default_backend, manifest=plan.manifest),
+    )
 
 
 def _spawn_request(
@@ -2040,6 +2044,7 @@ def _start_job(plan: DispatchPlan, job: WorkerJob) -> WorkerHandle:
         print(
             f"DEGRADED {job.role}: {degraded_from} -> {runtime.surface} "
             f"({runtime.fallback_reason or 'no reason reported'})",
+            file=sys.stderr,
             flush=True,
         )
     completed = None

package/runtime/python/okstra_ctl/initial_prompt_materialization.py

@@ -722,6 +722,7 @@ def _prompt_body(
         worker.model,
         plan,
         _optional_approved_plan_path(context) if plan.include_approved_plan else "",
+        _selected_direction_path(context) if plan.include_selected_direction else "",
     )
 
 
@@ -1543,6 +1544,21 @@ def _optional_approved_plan_path(context: _MaterializationContext) -> str:
         return ""
 
 
+def _selected_direction_path(context: _MaterializationContext) -> str:
+    """The instruction-set snapshot path when prepare wrote one, otherwise empty.
+
+    Only a plan opened from `--selected-direction` has the snapshot; a legacy
+    rerun has none and its prompt drops the line.
+    """
+    packet = instruction_path(context.manifest, context.active_context, "analysisPacketPath")
+    if not packet:
+        return ""
+    snapshot = Path(packet).parent / "selected-direction.json"
+    if not _resolve_input_path(context.project_root, snapshot).is_file():
+        return ""
+    return str(snapshot)
+
+
 def _required_stage_number(context: _MaterializationContext) -> str:
     value = _string_value(_active_run_field(context, "stage"))
     if not value:

package/runtime/python/okstra_ctl/phases/implementation_planning/authoring.py

@@ -718,6 +718,21 @@ _PREP_OWNERSHIP_NOTE = (
     "writer did not produce those fields.\n"
 )
 
+# 이 네 필드는 report assembly 가 선택 방향 스냅샷으로 덮어쓰고 검증기가 다른 값을
+# 거절한다(validation._direction_realization_errors). 계획자가 바꿀 수 없는 값에
+# planner-fixable DISAGREE 를 내면 self-fix 로 풀리지 않는 차단이 된다.
+_DIR_SNAPSHOT_OWNED_NOTE = (
+    "\nSnapshot-owned fields: `coreMechanism`, `architectureBoundaries`, "
+    "`planningInvariants`, and `userConstraints` above are verbatim copies of "
+    "the selected-direction snapshot. Report assembly overwrites them from "
+    "that snapshot and validation rejects any other value, so the planner "
+    "cannot change them. Judge whether the writer-owned realization fields "
+    "honour them. When a later user decision (an answered clarification) "
+    "departs from them, judge whether the writer-owned fields and the plan "
+    "narrative's `supersessionLedger` carry that decision; do not return a "
+    "planner-fixable DISAGREE that asks to edit these four fields.\n"
+)
+
 
 def _step_coordinate(payload: object, field: str) -> int | None:
     if not isinstance(payload, Mapping):
@@ -784,7 +799,9 @@ def _render_analyser_split(verdicts: object) -> str:
             continue
         kind = str(verdict.get("breakageKind") or "").strip()
         label = f"{token}({kind})" if kind else token
-        rows.append(f"- `{worker}`: `{label}`\n")
+        basis = _prior_vote(verdict).get("basis")
+        suffix = f" — `{scalar(basis)}`" if basis else ""
+        rows.append(f"- `{worker}`: `{label}`{suffix}\n")
     if not rows:
         return ""
     return "Analyser split:\n" + "".join(rows)
@@ -944,6 +961,25 @@ def _render_prior_round(entry: object) -> str:
     return "".join(rows)
 
 
+# 검증자의 읽기 범위(`**Read scope:**`)는 `## Inputs` 에 열거된 경로만 허용한다.
+# 이 절이 없으면 P-Req 의 originalRequirementId 를 패킷의 요구 문장으로 되짚을
+# 수 없어 범위를 지킨 검증자는 verification-error 를 낸다.
+_INPUT_FIELDS = (
+    ("Primary analysis packet", "analysisPacketPath"),
+    ("Plan narrative", "reportNarrativePath"),
+)
+
+
+def _render_inputs(run_manifest: Path) -> str:
+    payload = validated_run_authority(run_manifest).payload
+    rows = [
+        f"- {label}: `{payload[field].strip()}`\n"
+        for label, field in _INPUT_FIELDS
+        if isinstance(payload.get(field), str) and payload[field].strip()
+    ]
+    return "\n## Inputs\n\n" + "".join(rows) if rows else ""
+
+
 def _prompt(args: argparse.Namespace) -> str:
     envelope = _load_json_object(
         _prepared_items_path(args.run_manifest, require_regular=True)
@@ -963,7 +999,11 @@ def _prompt(args: argparse.Namespace) -> str:
         if isinstance(envelope.get("priorRounds"), Mapping)
         else {}
     )
-    rows = ["# Plan verification queue\n", line("Item count", len(items))]
+    rows = [
+        "# Plan verification queue\n",
+        line("Item count", len(items)),
+        _render_inputs(args.run_manifest),
+    ]
     for index, item in enumerate(items, 1):
         if not isinstance(item, Mapping):
             continue
@@ -982,6 +1022,8 @@ def _prompt(args: argparse.Namespace) -> str:
         rows.append(_render_prior_steps(item, all_items))
         if item_id.startswith("P-Prep-"):
             rows.append(_PREP_OWNERSHIP_NOTE)
+        if item_id == "P-Dir-1":
+            rows.append(_DIR_SNAPSHOT_OWNED_NOTE)
         split = _render_analyser_split(
             (envelope.get("tieSplits") or {}).get(item_id)
             if isinstance(envelope.get("tieSplits"), Mapping)
@@ -2270,6 +2312,10 @@ def _narrow_dispatch_queue(
             f"queue does not contain — pass the artifact this round dispatched, "
             f"not another round's"
         )
+    if getattr(args, "append", False) and _queue_holds_open_round_votes(
+        verification, assigned - narrowed, args.round_number
+    ):
+        return narrowed
     verification["dispatchQueue"] = [
         item_id
         for item_id in (queue if isinstance(queue, list) else sorted(assigned))
@@ -2278,6 +2324,28 @@ def _narrow_dispatch_queue(
     return narrowed
 
 
+def _queue_holds_open_round_votes(
+    verification: Mapping[str, Any],
+    outside: set[object],
+    round_number: int,
+) -> bool:
+    """critic 의 `--append` 가 아직 열린 분석자 라운드에 얹히는지.
+
+    그 라운드의 큐를 tie 부분집합으로 덮으면 이어지는 `complete-round` 가
+    분석자 표가 있는 나머지 항목을 배정 밖으로 보고 거절한다.
+    """
+    items = verification.get("planItems")
+    return any(
+        isinstance(item, Mapping)
+        and item.get("id") in outside
+        and any(
+            isinstance(vote, Mapping) and vote.get("round") == round_number
+            for vote in item.get("verdicts") or []
+        )
+        for item in (items if isinstance(items, list) else [])
+    )
+
+
 def _incoming_verdict_rows(
     args: argparse.Namespace,
     known: set[object],