okstra 0.186.7 → 0.187.0

package/runtime/python/okstra_ctl/convergence_store.py

@@ -1,6 +1,7 @@
 """Validated JSON loading and atomic persistence for convergence artifacts."""
 from __future__ import annotations
 
+import hashlib
 from pathlib import Path
 from typing import Any, Mapping
 
@@ -13,8 +14,6 @@ from .execution_manifest import (
 )
 from .final_report_schema import load_named_schema
 from .json_boundary import JsonBoundaryError, load_owned_object, write_owned_object_atomic
-from .worker_request import verifier_extra_dirs
-from .write_policy import build_invocation_write_contract
 
 
 DYNAMIC_VERIFIER_SOURCE_ROLES = frozenset({
@@ -107,19 +106,13 @@ def reserve_dynamic_verifier(
     *,
     input_digest: str,
     invocation_ref: str | None = None,
-    artifact_paths: tuple[Path, ...],
-    worktree: Path | None = None,
 ) -> tuple[RoleExecution, Invocation]:
     """Reserve one provider-neutral verifier identity for a logical round.
 
-    `worktree` 는 이 런의 워커가 실제로 서는 루트다. 디스패치가 정책을 다시
-    계산할 때 쓰는 값(`dispatch_core._canonical_write_contract` 이 job 의
-    worktree 를 넘긴다)과 같아야 한다. 여기서 None 으로 고정하면 예약된 정책의
-    `sourcePolicy.allowedRoot` 는 프로젝트 루트, 디스패치가 계산한 정책은 스테이지
-    워크트리가 되어 writePolicyDigest 가 갈리고, 같은 invocationRef 가
-    `invocationRef drift` 로 거부된다 — 워크트리를 쓰는 런(implementation stage)
-    에서만 나타나고 워크트리가 없는 런(implementation-planning)에서는 안 나타나
-    버전 문제로 보이기 쉽다.
+    예약은 정체성만 잡는다. 쓰기 계약은 디스패치가 attempt 를 열 때 한 번만
+    계산해 그 attempt 행에 적는다 — 예약이 같은 값을 두 번째로 계산하던 동안,
+    두 계산의 입력(worktree)이 갈리면 같은 invocationRef 가 `invocationRef
+    drift` 로 거부됐다.
     """
     if round_number < 1:
         raise ExecutionManifestError("dynamic verifier round must be positive")
@@ -156,20 +149,6 @@ def reserve_dynamic_verifier(
             raise ExecutionManifestError(
                 "dynamic verifier has no runner write capability"
             )
-        try:
-            policy, enforcement = build_invocation_write_contract(
-                role="verifier",
-                project_root=project_root,
-                worktree=worktree,
-                artifact_paths=artifact_paths,
-                maximum_precision=capability.max_boundary_precision,
-                auxiliary_roots=verifier_extra_dirs("verifier"),
-                validated_auxiliary_roots=verifier_extra_dirs("verifier"),
-            )
-        except (OSError, ValueError) as exc:
-            raise ExecutionManifestError(
-                f"dynamic verifier write policy is invalid: {exc}"
-            ) from exc
         return Invocation(
             invocation_ref=selected_ref,
             participant_ref=verifier.participant_ref,
@@ -180,9 +159,6 @@ def reserve_dynamic_verifier(
             dispatch_kind=f"reverify-r{round_number}",
             round=round_number,
             input_digest=input_digest,
-            write_policy=policy.to_payload(),
-            write_policy_digest=policy.digest,
-            write_enforcement=enforcement.to_payload(),
         )
 
     return reserve_derived_role_invocation(

package/runtime/python/okstra_ctl/design_prep.py

@@ -53,6 +53,9 @@ _PLANNING_DATA_RE = re.compile(
 )
 _REQUEST_STATUSES = {"provisional", "blocked"}
 _INPUT_DECISIONS = {"accept-draft", "modify-draft", "reject-draft", "defer"}
+_RECORDED_REQUEST_RE = re.compile(
+    r"^design-prep-requests/design-prep-request-(?P<token>[0-9]+)-(?P<item>.+)\.md$"
+)
 _INPUT_FILENAME_RE = re.compile(
     r"^design-prep-input-(?P<seq>\d+)-(?P<item>PREP-\d{3})-"
     r"r(?P<revision>\d{3,})-(?P<input_id>[0-9a-f-]{36})\.md$"
@@ -322,12 +325,34 @@ def _request_target(
         "design-prep-requests/"
         f"design-prep-request-{planning_seq}-{item_id}.md"
     )
-    if item.get("requestPath") != expected_relative:
+    request_dir = data_path.parent.parent / "design-prep-requests"
+    recorded = item.get("requestPath")
+    if recorded == expected_relative:
+        target = (data_path.parent.parent / expected_relative).resolve()
+    elif isinstance(recorded, str) and recorded.startswith("design-prep-requests/"):
+        target = (data_path.parent.parent / recorded).resolve()
+        match = _RECORDED_REQUEST_RE.fullmatch(recorded)
+        same_item = bool(match and match.group("item") == item_id)
+        stages = {
+            stage for stage in (item.get("stageRefs") or []) if isinstance(stage, int)
+        }
+        token_ok = bool(match) and int(match.group("token")) in stages
+        if target.is_file() and same_item:
+            pass
+        elif same_item and token_ok:
+            # 스냅샷은 stage 번호를 파일명에 쓴다. 파일이 아직 없어도 그 경로가
+            # 정본이다.
+            pass
+        else:
+            raise DesignPrepError(
+                f"item {item_id} must use canonical requestPath {expected_relative}"
+            )
+    else:
         raise DesignPrepError(
             f"item {item_id} must use canonical requestPath {expected_relative}"
         )
-    request_dir = data_path.parent.parent / "design-prep-requests"
-    target = (data_path.parent.parent / expected_relative).resolve()
+    # resolve 하지 않은 request_dir 과 비교한다. 디렉터리가 바깥을 가리키는
+    # 심링크면 target.parent 가 바깥이 되어 탈출을 잡는다.
     if target.parent != request_dir:
         raise DesignPrepError(f"requestPath escapes design-prep-requests: {target}")
     return target
@@ -358,13 +383,54 @@ def _render_request(
     return target, _complete_request(body, assessment, request_content).encode("utf-8")
 
 
-def _require_matching_request(target: Path, expected: bytes, conflict: str) -> None:
+# 요청의 내용이 아니라 "어느 리포트가 이 요청을 실었는가" 에 딸린 프론트매터 줄.
+# `request-content-fingerprint` 가 여기 드는 이유는 그 해시의 입력
+# (`_render_request_body_without_fingerprints`) 이 `source-report` 줄을 포함하기
+# 때문이다 — 리포트가 바뀌면 지문도 같이 흔들린다.
+_REPORT_BOUND_REQUEST_FIELDS = ("source-report:", "request-content-fingerprint:")
+
+
+def _request_identity(raw: bytes) -> bytes:
+    """발행 리포트에 딸린 줄을 뺀 요청 신원.
+
+    Stage Ledger 규칙은 `done` stage 의 본문을 다음 계획 run 으로 그대로
+    이월하도록 요구하고, 그러면 같은 PREP 항목이 매 run 마다 다시 탐지된다.
+    렌더된 요청은 `source-report` 한 줄만 달라지므로, 발행 리포트까지 신원에
+    넣으면 한 태스크의 **두 번째 계획 run 부터 조립이 항상 막힌다** — 요청
+    파일은 태스크 단위 디렉터리에 누적되고 이월은 선택이 아니기 때문이다.
+
+    내용의 동일성은 남는 것들이 그대로 덮는다: `assessment-fingerprint` 는
+    항목의 의미 필드만 해시하고(`assessment_fingerprint`), 본문 10개 절은 통째로
+    비교된다. 즉 요청이 실제로 달라지면 여기서 여전히 걸린다.
+    """
+    try:
+        text = raw.decode("utf-8")
+    except UnicodeError:
+        # 신원을 계산할 수 없는 파일이다. 원본 바이트로 비교하게 두어 다르다고
+        # 판정되게 한다 — 읽을 수 없는 파일을 같다고 볼 근거가 없다.
+        return raw
+    return "\n".join(
+        line
+        for line in text.splitlines()
+        if not line.startswith(_REPORT_BOUND_REQUEST_FIELDS)
+    ).encode("utf-8")
+
+
+def _request_conflicts(target: Path, expected: bytes, conflict: str) -> str | None:
+    """Return a one-line conflict description, or ``None`` when the file matches."""
     try:
         existing = target.read_bytes()
     except OSError as exc:
         raise DesignPrepError(f"cannot read existing request {target}: {exc}") from exc
-    if existing != expected:
-        raise DesignPrepError(f"refuses to overwrite {conflict}: {target}")
+    if _request_identity(existing) != _request_identity(expected):
+        return f"refuses to overwrite {conflict}: {target}"
+    return None
+
+
+def _require_matching_request(target: Path, expected: bytes, conflict: str) -> None:
+    reason = _request_conflicts(target, expected, conflict)
+    if reason is not None:
+        raise DesignPrepError(reason)
 
 
 def _write_request_no_clobber(target: Path, encoded: bytes) -> None:
@@ -397,16 +463,32 @@ def materialize_design_prep_requests(plan_data_path: Path) -> list[Path]:
     planning_seq = _planning_seq(data_path)
     report_language = _report_language(data)
     items = _design_preparation_items(data)
-    written: list[Path] = []
-    for item in items:
-        if item.get("status") not in _REQUEST_STATUSES:
-            continue
-        target, encoded = _render_request(
+    # 충돌은 한 항목씩 알리지 않는다. 요청 12개가 모두 옛 리포트의 파일과 부딪히면
+    # 첫 건에서 멈추는 구현은 사용자에게 12회 왕복을 시키고, 그때마다 이미 쓴
+    # 앞쪽 파일이 남아 상태가 절반만 진행된다. 전부 렌더해 전부 검사한 뒤 쓴다.
+    rendered = [
+        _render_request(
             data_path=data_path,
             planning_seq=planning_seq,
             report_language=report_language,
             item=item,
         )
+        for item in items
+        if item.get("status") in _REQUEST_STATUSES
+    ]
+    conflicts = [
+        reason
+        for target, encoded in rendered
+        if target.exists()
+        and (reason := _request_conflicts(target, encoded, "different request"))
+    ]
+    if conflicts:
+        raise DesignPrepError(
+            f"{len(conflicts)} design-prep request(s) conflict with existing files: "
+            + "; ".join(conflicts)
+        )
+    written: list[Path] = []
+    for target, encoded in rendered:
         _write_request_no_clobber(target, encoded)
         written.append(target)
     return written
@@ -1367,8 +1449,22 @@ def _discover_planning_reports(project_root: Path) -> list[Path]:
     return sorted(project_root.glob(pattern))
 
 
+_CLI_EPILOG = r"""Usage:
+  okstra design-prep list [--project-root <path>] [--report <path>]
+  okstra design-prep show --report <path> [--item PREP-001]
+  okstra design-prep write --report <path> --item PREP-001 \
+    --decision <accept-draft|modify-draft|reject-draft|defer> \
+    [--overrides <json-object>] [--notes <text>] --confirmed
+"""
+_CLI_DESCRIPTION = "Review AI-prepared implementation design inputs."
+
+
 def _build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog="design-prep")
+    parser = argparse.ArgumentParser(
+        description=_CLI_DESCRIPTION,
+        epilog=_CLI_EPILOG,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        prog="okstra design-prep")
     subparsers = parser.add_subparsers(dest="command", required=True)
     list_parser = subparsers.add_parser("list")
     list_parser.add_argument("--project-root", default="")

package/runtime/python/okstra_ctl/design_snapshot.py

@@ -114,8 +114,18 @@ def write_snapshot(narrative_path: Path, output_path: Path) -> dict[str, Any]:
     return snapshot
 
 
+_CLI_EPILOG = r"""Usage:
+  okstra design-snapshot --narrative <report-narrative.md> --output <design-preparation.json>
+"""
+_CLI_DESCRIPTION = "Write the detector-owned planning snapshot."
+
+
 def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(prog="okstra design-snapshot")
+    parser = argparse.ArgumentParser(
+        description=_CLI_DESCRIPTION,
+        epilog=_CLI_EPILOG,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        prog="okstra design-snapshot")
     parser.add_argument("--narrative", type=Path, required=True)
     parser.add_argument("--output", type=Path, required=True)
     args = parser.parse_args(argv)

package/runtime/python/okstra_ctl/design_surfaces.py

@@ -110,6 +110,34 @@ def _phrase_matches(text: str, phrase: str) -> bool:
     return re.search(rf"(?<![\w-]){re.escape(phrase)}(?![\w-])", text) is not None
 
 
+SELECTED_DIRECTION_CONTRACT = "selected-direction"
+
+
+def _planned_file_structure(planning: Mapping[str, Any]) -> list[Any]:
+    """설계 표면 탐지가 읽는 "이 계획이 건드리는 파일" 목록.
+
+    계획서에는 계약이 둘 있고 그 목록의 자리가 다르다. 선택 방향 계약은
+    `directionRealization.fileStructure`, 레거시 후보비교 계약은 추천 후보의
+    `optionCandidates[].fileStructure` 다.
+
+    분기가 이 함수 안이 아니라 호출부 한 곳(`plan_items._extract_prep_items`)에만
+    있던 동안, 같은 탐지기를 부르는 나머지 세 호출부(`design_snapshot`,
+    `report_projections`, `validate-run`)는 선택 방향 계획을 레거시 모양으로 읽고
+    "recommended option '' is missing or ambiguous" 로 실패했다. 계획은 멀쩡한데
+    최종 검증만 막혔다.
+    """
+    if planning.get("planningContract") == SELECTED_DIRECTION_CONTRACT:
+        realization = planning.get("directionRealization")
+        if not isinstance(realization, Mapping):
+            raise DesignSurfaceError(
+                "selected-direction plan has no directionRealization object"
+            )
+        rows = realization.get("fileStructure")
+        return list(rows) if isinstance(rows, list) else []
+    rows = _selected_candidate(planning).get("fileStructure")
+    return list(rows) if isinstance(rows, list) else []
+
+
 def _selected_candidate(planning: Mapping[str, Any]) -> Mapping[str, Any]:
     recommended = _normalise((planning.get("recommendedOption") or {}).get("name"))
     candidates = [
@@ -321,8 +349,7 @@ def detect_design_surfaces(
                     value=step.get(field),
                 ):
                     grouped.setdefault((stage_number, kind), []).append(evidence)
-    selected = _selected_candidate(planning)
-    for row in selected.get("fileStructure") or []:
+    for row in _planned_file_structure(planning):
         if not isinstance(row, Mapping):
             continue
         path = str(row.get("path") or "")

package/runtime/python/okstra_ctl/dispatch_core.py

@@ -27,6 +27,7 @@ from .dispatch_state import (
     load_json_object as _load_json_object,
     link_agent_dispatch_result as _link_agent_dispatch_result,
     missing_completion_paths as _missing_completion_paths,
+    _plan_verify_result_aliases,
     mutate_team_state as _mutate_team_state,
     require_string as _require_string,
     resolve_project_path as _resolve_project_path,
@@ -54,7 +55,7 @@ from .assignment_resolver import (
 from .application.open_worker import open_worker
 from .domain.host import HostSessionContext
 from .domain.provider import HostModelBinding, ServedModelAttestation
-from .domain.worker_exec import SERVED_MODEL_MISMATCH_EXIT_CODE
+from .domain.worker_exec import NO_RESULT_EXIT_CODE, SERVED_MODEL_MISMATCH_EXIT_CODE
 from .domain.worker_runtime import (
     SURFACE_CMUX_PANE,
     EnvironmentBlocked,
@@ -90,7 +91,7 @@ from .initial_prompt_materialization import (
     PromptDeliveryMode,
     materialize_initial_prompts,
 )
-from .agent_invocation import AgentInvocationError, materialize_retry_invocation
+from .agent.invocation import AgentInvocationError, materialize_retry_invocation
 from .path_hints import hydrate_active_run_context
 from .schema_excerpt import (
     bundle_excerpt_path,
@@ -102,6 +103,7 @@ from .worker_audit_ledger import (
     check_worker_results_audit,
     parse_worker_result_name,
 )
+from .worker_artifacts import worker_provider_id
 from .worker_prompt_body import REPORT_WRITER_WORKER_ID
 from .worker_prompt_headers import (
     WorkerPromptHeaderError,
@@ -121,6 +123,7 @@ from .write_policy import (
     WritePolicy,
     build_invocation_write_contract,
     planned_paths_from_run_manifest,
+    task_root_from_run_manifest,
     write_enforcement_from_payload,
     write_policy_from_payload,
 )
@@ -914,24 +917,32 @@ def _select_workers(
             options,
         )
     supported = set(options.supported_worker_wrappers)
+    state = team_state or {}
+
+    def _wrapper_supported(worker_id: str) -> bool:
+        return _worker_provider(state, worker_id, options) in supported
+
     selected = (
         list(requested_workers)
         if requested_workers
         else [
             worker
             for worker in recommended
-            if worker in supported and worker != REPORT_WRITER_WORKER_ID
+            if _wrapper_supported(worker) and worker != REPORT_WRITER_WORKER_ID
         ]
     )
     unknown = [worker for worker in selected if worker not in recommended]
     if unknown:
         raise DispatchError("requested worker(s) are not in this run roster: " + ", ".join(unknown))
-    unsupported = [worker for worker in selected if worker not in supported]
+    unsupported = [worker for worker in selected if not _wrapper_supported(worker)]
     if unsupported:
         allowed = ", ".join(sorted(supported))
         raise DispatchError(
             f"unsupported {options.unsupported_worker_label} worker(s): "
-            + ", ".join(unsupported)
+            + ", ".join(
+                f"{worker} (provider {_worker_provider(state, worker, options)})"
+                for worker in unsupported
+            )
             + f" (dispatcher supports: {allowed})"
         )
     return selected
@@ -1162,13 +1173,11 @@ def _is_cli_wrapper_assignment(
     options: _BuildOptions,
 ) -> bool:
     state = _worker_state(team_state, worker_id)
-    provider = _string_value(state.get("provider")) or _provider_for_worker(
-        worker_id,
-        options,
-    )
     return (
         _string_value(state.get("runner")) or BACKEND_CLI_WRAPPER
-    ) == BACKEND_CLI_WRAPPER and provider in options.supported_worker_wrappers
+    ) == BACKEND_CLI_WRAPPER and _worker_provider(
+        team_state, worker_id, options
+    ) in options.supported_worker_wrappers
 
 
 def _runner_for_worker(team_state: Mapping[str, Any], worker_id: str) -> str:
@@ -1203,6 +1212,7 @@ def _job_from_roster_worker(
         completion_paths=_completion_paths(
             fact.worker_id, result_path, manifest, project_root
         ),
+        result_aliases=_plan_verify_result_aliases(result_path, manifest),
         worktree_path=_worktree_path(manifest, active_context),
         role=fact.role,
         idle_timeout_seconds=options.idle_timeout_seconds,
@@ -1484,26 +1494,28 @@ def _persisted_write_contract(
     if not job.has_execution_identity:
         return None
     manifest = read_execution_manifest(plan.manifest_path)
-    invocation = next(
+    # 계약은 attempt 소유다 — 재시도는 attempt 마다 다른 프롬프트 파생 파일을
+    # 쓰므로, invocation 으로 찾으면 1회차의 허용 경로를 2회차에 물린다.
+    attempt = next(
         (
-            row for row in manifest.invocations
-            if row.invocation_ref == job.invocation_ref
+            row for row in manifest.attempts
+            if row.invocation_ref == job.invocation_ref and row.attempt == job.attempt
         ),
         None,
     )
-    if invocation is None:
-        raise DispatchError("worker invocation write policy was not persisted")
+    if attempt is None:
+        raise DispatchError("worker attempt write policy was not persisted")
     try:
         enforcement = write_enforcement_from_payload(
-            invocation.write_enforcement
+            attempt.write_enforcement
         )
         policy = replace(
-            write_policy_from_payload(invocation.write_policy),
+            write_policy_from_payload(attempt.write_policy),
             maximum_boundary_precision=enforcement.boundary_precision,
         )
     except (TypeError, ValueError) as exc:
         raise DispatchError(f"persisted worker write policy is invalid: {exc}") from exc
-    if policy.digest != invocation.write_policy_digest:
+    if policy.digest != attempt.write_policy_digest:
         raise DispatchError("persisted worker write policy digest changed")
     return policy, enforcement
 
@@ -1555,9 +1567,6 @@ def _record_execution_attempt(plan: DispatchPlan, job: WorkerJob) -> None:
             dispatch_kind=job.dispatch_kind,
             round=_dispatch_round(job.dispatch_kind),
             input_digest=job.prompt_digest,
-            write_policy=write_policy.to_payload(),
-            write_policy_digest=write_policy.digest,
-            write_enforcement=write_enforcement.to_payload(),
         ),
         Attempt(
             invocation_ref=job.invocation_ref,
@@ -1569,6 +1578,9 @@ def _record_execution_attempt(plan: DispatchPlan, job: WorkerJob) -> None:
             error_path=None,
             change_summary={},
             evidence_seal_ref=None,
+            write_policy=write_policy.to_payload(),
+            write_policy_digest=write_policy.digest,
+            write_enforcement=write_enforcement.to_payload(),
         ),
         task_key=task_key,
     )
@@ -1603,6 +1615,9 @@ def _canonical_write_contract(
             project_root=plan.project_root,
             worktree=worktree,
             artifact_paths=artifacts,
+            task_root=task_root_from_run_manifest(
+                plan.project_root, plan.manifest
+            ),
             maximum_precision=capability.max_boundary_precision,
             planned_paths=planned[0],
             planned_paths_declared=planned[1],
@@ -2573,6 +2588,7 @@ def _dispatch_record(
         "modelExecutionValue": job.model_execution_value,
         "wrapperPath": str(job.wrapper_path),
         "completionPaths": [str(path) for path in job.completion_paths],
+        "resultAliases": [str(path) for path in job.result_aliases],
         "worktreePath": job.worktree_path,
     }
     if job.invocation_id:
@@ -2713,12 +2729,14 @@ def _skip_reasons(
             if worker_id not in set(selected)
         }
     supported = set(options.supported_worker_wrappers)
+    state = team_state or {}
     return {
         worker_id: (
             "skipped by worker dispatch default: worker is not supported by this dispatcher"
         )
         for worker_id in recommended
-        if worker_id not in set(selected) and worker_id not in supported
+        if worker_id not in set(selected)
+        and _worker_provider(state, worker_id, options) not in supported
     }
 
 
@@ -2857,7 +2875,7 @@ def _retry_details(job: WorkerJob, attempt: int, outcome: WorkerOutcome) -> dict
 def _outcome_from_status(record: Mapping[str, Any], status) -> WorkerOutcome:
     return WorkerOutcome(
         returncode=status.exit_code if status.exit_code is not None else 1,
-        missing_completion_paths=tuple(path for path in _record_completion_paths(record) if not path.is_file()),
+        missing_completion_paths=_record_missing_completion_paths(record),
         pane_id=_string_value(record.get("paneId")),
         status_sidecar_path=status.path,
         timeout=status.timeout,
@@ -2925,8 +2943,43 @@ def _record_completion_paths(record: Mapping[str, Any]) -> list[Path]:
     return [Path(path) for path in _string_list(record.get("completionPaths"))]
 
 
+def _record_missing_completion_paths(record: Mapping[str, Any]) -> tuple[Path, ...]:
+    aliases = {Path(path) for path in _string_list(record.get("resultAliases"))}
+    result_path = Path(_string_value(record.get("resultPath")))
+    worker_result = Path(_string_value(record.get("workerResultPath")))
+    missing: list[Path] = []
+    for path in _record_completion_paths(record):
+        if path.is_file():
+            continue
+        if path in {result_path, worker_result} and any(alias.is_file() for alias in aliases):
+            continue
+        missing.append(path)
+    return tuple(missing)
+
+
 def _should_retry(outcome: WorkerOutcome, attempt: int) -> bool:
-    return outcome.returncode == 0 and bool(outcome.missing_completion_paths) and attempt < MAX_WORKER_ATTEMPTS
+    """결과가 없으면 재시도한다 — 기준은 종료 코드가 아니라 산출물이다.
+
+    종전에는 `returncode == 0` 을 요구했다. 그래서 시작하자마자 죽은 CLI 는
+    재시도를 **한 번도** 못 받았고, 150초를 태우고 0 으로 끝난 CLI 만 받았다.
+    비용 순서가 거꾸로였다.
+
+    실측(fontsninja-v3-site `dev-10341`, grok 워커 13회 디스패치): 세션 생성이
+    거부돼 1.6~4.7초 만에 코드 1 로 죽은 경우가 4회다. 그중
+    `requirements-discovery-002` 는 그것이 1차 시도였는데 재시도가 없어 분석자
+    한 명이 그대로 사라졌고, 바로 다음 디스패치(`-003`)는 222초를 정상 수행했다.
+    같은 명령을 지금 돌리면 동시 3회까지 전부 성공한다 — 조건은 분 단위로
+    풀리는 일시적인 것이고, 재시도 비용은 2초다.
+
+    산출물이 이미 나왔으면 종료 코드가 무엇이든 재시도하지 않는다. 일이 끝났기
+    때문이다. 타임아웃도 재시도하지 않는다 — 그것은 예산을 다 쓴 실패라
+    재시도가 같은 예산을 한 번 더 쓴다.
+    """
+    if outcome.timeout:
+        return False
+    if attempt >= MAX_WORKER_ATTEMPTS:
+        return False
+    return bool(outcome.missing_completion_paths)
 
 
 def _job_for_next_attempt(job: WorkerJob) -> WorkerJob:
@@ -2946,6 +2999,8 @@ def _job_for_next_attempt(job: WorkerJob) -> WorkerJob:
 def _failure_reason(outcome: WorkerOutcome) -> str:
     if outcome.timeout:
         return "worker wrapper timed out"
+    if outcome.returncode == NO_RESULT_EXIT_CODE:
+        return "CLI ended cleanly without emitting a result event"
     if outcome.returncode != 0:
         return f"wrapper exited with code {outcome.returncode}"
     if outcome.missing_completion_paths:
@@ -2982,6 +3037,28 @@ def _resolve_wrapper(provider: str, workspace_root: Path, options: _BuildOptions
     raise DispatchError(f"{script} not found (searched: {', '.join(str(c) for c in candidates)})")
 
 
+def _worker_provider(
+    team_state: Mapping[str, Any],
+    worker_id: str,
+    options: _BuildOptions | None = None,
+) -> str:
+    """이 슬롯이 실제로 실행할 provider.
+
+    로스터의 worker_id 는 provider 이름이 아니다. 한 provider 가 두 역할을 맡으면
+    `grok-implementer` · `grok-verifier` 처럼 역할 접미사가 붙기 때문이다. 지원 여부는
+    항상 이 해석을 거친 provider 로 판정한다 — id 를 provider 집합과 직접 비교하면
+    역할 접미사가 붙은 슬롯이 전부 미지원으로 떨어진다.
+    """
+    workers = team_state.get("workers")
+    recorded = ""
+    if isinstance(workers, list):
+        for worker in workers:
+            if isinstance(worker, Mapping) and worker.get("workerId") == worker_id:
+                recorded = _string_value(worker.get("provider"))
+                break
+    return recorded or _provider_for_worker(worker_id, options)
+
+
 def _provider_for_worker(
     worker_id: str,
     options: _BuildOptions | None = None,
@@ -2992,7 +3069,7 @@ def _provider_for_worker(
             return configured
     if worker_id == REPORT_WRITER_WORKER_ID:
         return "claude"
-    return worker_id
+    return worker_provider_id(worker_id)