okstra 0.208.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.
@@ -379,8 +431,8 @@ def plan_worker_height_resize(
     return None
 
 
-def shim_free_login_path() -> str:
-    """The user's login PATH with cmux's per-surface CLI shims removed.
+def shim_free_worker_path() -> str:
+    """The lead's inherited PATH with cmux's per-surface CLI shims removed.
 
     A cmux pane execs its command through `login … bash --noprofile --norc`, so
     none of the user's shell rc runs and PATH is cmux's own short list. What that
@@ -389,14 +441,23 @@ def shim_free_login_path() -> str:
     CLIs — and where a provider cmux does not know has no entry at all, which is
     a plain exit 127 inside the worker wrapper.
 
-    Restoring the login shell's PATH and dropping the shim entries gives the
-    wrapper what it would see in an ordinary terminal, which is what its own
-    `command -v <cli>` check expects. Nothing here is provider-specific, so
-    adding a provider does not touch this path.
+    The base is the PATH the lead process inherited, because the cli-wrapper
+    runtime (and every automatic retry, which always runs there) spawns with it.
+    A pane that resolved PATH from the login shell instead could pick another
+    install of the same CLI: on 2026-10-04 (fontsninja-v3-site dev-11118) the
+    login shell put Homebrew's codex 0.153.4 first, which rejects `gpt-6.1-sol`,
+    while the lead's PATH found nvm's 0.160.0, so every first attempt failed and
+    every retry passed. The login shell's PATH is the fallback when the inherited
+    one is empty after filtering.
     """
-    entries = _login_shell_path().split(os.pathsep)
+    path = _without_shims(os.environ.get("PATH", ""))
+    return path or _without_shims(_login_shell_path())
+
+
+def _without_shims(path_value: str) -> str:
     return os.pathsep.join(
-        entry for entry in entries if entry and SHIM_DIR_MARKER not in entry
+        entry for entry in path_value.split(os.pathsep)
+        if entry and SHIM_DIR_MARKER not in entry
     )
 
 
@@ -441,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.
 
@@ -453,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,
@@ -463,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)
@@ -471,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:
         # 호출이 반환되기 전에는 명부에 창 식별자가 없다. 여기서 정리하지
         # 않으면 대체 실행으로 전환된 뒤에도 회수할 수 없는 창이 남는다.
@@ -485,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:
     """실패한 분할이 리드에서 떼어 간 폭을 돌려준다.
 
@@ -508,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
 
@@ -552,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
@@ -573,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:
@@ -605,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
@@ -620,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]:
@@ -783,14 +847,18 @@ def _surface_from_split_echo(stdout: str) -> str:
 
 def _exec_worker(surface_uuid: str, *, cwd: Path, command: Sequence[str]) -> None:
     line = worker_command_line(
-        cwd=cwd, argv=command, path_value=shim_free_login_path()
+        cwd=cwd, argv=command, path_value=shim_free_worker_path()
     )
     started = run_cmux(["respawn-pane", "--surface", surface_uuid, "--command", line])
     if started.returncode != 0:
         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
@@ -817,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,
@@ -854,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.
 
@@ -866,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
@@ -887,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:
@@ -939,11 +1016,7 @@ def _pane_geometry(entry: dict[str, Any]) -> PaneGeometry:
 
 
 def _login_shell_path() -> str:
-    """PATH as the user's own login shell resolves it.
-
-    Falls back to the inherited PATH: a worker started with a shim-filtered
-    inherited PATH is still better than one started with cmux's bare list.
-    """
+    """PATH as the user's own login shell resolves it, or '' when it cannot run."""
     shell = os.environ.get("SHELL", "") or "/bin/sh"
     try:
         result = subprocess.run(
@@ -954,9 +1027,9 @@ def _login_shell_path() -> str:
             check=False,
         )
     except (OSError, subprocess.SubprocessError):
-        return os.environ.get("PATH", "")
+        return ""
     if result.returncode != 0 or not result.stdout.strip():
-        return os.environ.get("PATH", "")
+        return ""
     return result.stdout.strip()
 
 

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/coverage_census.py

@@ -242,8 +242,15 @@ def _split_verdict_section(text: str) -> tuple[list[str], str]:
     )
     if start is None:
         return [], text
+    level = len(lines[start]) - len(lines[start].lstrip("#"))
+    # Subheadings (`### EB-001`) group the verdict lines; only a heading at the
+    # section's own level or above closes it.
     end = next(
-        (index for index in range(start + 1, len(lines)) if _HEADING_RE.match(lines[index])),
+        (
+            index for index in range(start + 1, len(lines))
+            if _HEADING_RE.match(lines[index])
+            and len(lines[index]) - len(lines[index].lstrip("#")) <= level
+        ),
         len(lines),
     )
     return lines[start + 1:end], "\n".join(lines[:start] + lines[end:])

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: