okstra 0.175.1 → 0.176.0

package/runtime/python/okstra_ctl/wizard.py

@@ -59,6 +59,7 @@ from okstra_ctl.registry.host_registry import default_host_registry
 from okstra_ctl.registry.provider_registry import default_provider_registry
 from okstra_ctl.model_defaults import ModelDefaultScopes, default_candidates
 from okstra_ctl.model_pool import ModelPool
+from okstra_ctl import next_phase
 from okstra_ctl.legacy_model_selection import serialize_host_session_context
 from okstra_ctl.role_requirements import (
     RoleProfile,
@@ -1131,11 +1132,13 @@ def _convert_v1_provider_selections(
     cross_requirement = _initial_cross_verification_requirement(profile)
     providers = _legacy_worker_providers(payload)
     if cross_requirement is not None:
-        selected_count = cross_requirement.count
-        if providers and cross_requirement.optional_count > 0:
-            maximum = cross_requirement.count + cross_requirement.optional_count
-            selected_count = min(maximum, max(cross_requirement.count, len(providers)))
-        if cross_requirement.optional_count > 0:
+        selected_count = cross_requirement.recommended_count
+        if providers and cross_requirement.min_count < cross_requirement.max_count:
+            selected_count = min(
+                cross_requirement.max_count,
+                max(cross_requirement.min_count, len(providers)),
+            )
+        if cross_requirement.min_count < cross_requirement.max_count:
             state.role_counts[cross_requirement.role] = selected_count
             count_id = f"role-count:{cross_requirement.role}"
             state.role_selection_order.append(count_id)
@@ -1204,7 +1207,7 @@ def _convert_v1_provider_selections(
     static_roles = {
         requirement.role
         for requirement in profile.roles
-        if not requirement.dynamic and requirement.count > 0
+        if not requirement.dynamic and requirement.min_count > 0
     }
     if state.host_entry_mode == "spawn-process":
         static_roles.add("leader")
@@ -1246,6 +1249,17 @@ def _wizard_state_from_json(payload: dict[str, Any]) -> WizardState:
     if version != 2:
         state.execution_identity_version = 2
         _convert_v1_provider_selections(state, payload)
+        # v1 은 리더 확인 칸이 없었다. 변환 재개 시 다시 묻지 않는다.
+        if (
+            state.host_entry_mode == "current-session"
+            and _LEADER_SESSION_STEP not in state.answered
+        ):
+            state.answered.append(_LEADER_SESSION_STEP)
+        if (
+            state.host_entry_mode == "current-session"
+            and _LEADER_SESSION_STEP not in state.role_selection_order
+        ):
+            state.role_selection_order.insert(0, _LEADER_SESSION_STEP)
     return state
 
 
@@ -1277,17 +1291,35 @@ def _role_count_prompt_id(role: str) -> str:
     return f"role-count:{role}"
 
 
+def _role_add_prompt_id(role: str) -> str:
+    return f"role-add:{role}"
+
+
 def _role_model_prompt_id(role: str, ordinal: int) -> str:
     return f"role-model:{role}:{ordinal}"
 
 
+_LEADER_SESSION_STEP = "leader-session"
+
+
+def _is_role_selection_step(step_id: str) -> bool:
+    return step_id == _LEADER_SESSION_STEP or step_id.startswith(
+        ("role-count:", "role-model:", "role-add:")
+    )
+
+
 def _selected_role_count(
     state: WizardState,
     requirement: RoleRequirement,
 ) -> int:
-    if requirement.optional_count == 0:
-        return requirement.count
-    return state.role_counts.get(requirement.role, requirement.count)
+    if requirement.min_count == requirement.max_count:
+        return requirement.min_count
+    if requirement.role in state.role_counts:
+        return state.role_counts[requirement.role]
+    # min=0 선택 역할(예: critic)은 사용자가 열기 전까지 기본 0
+    if requirement.min_count == 0:
+        return 0
+    return requirement.recommended_count
 
 
 def _selectable_static_requirements(
@@ -1296,7 +1328,7 @@ def _selectable_static_requirements(
 ) -> tuple[RoleRequirement, ...]:
     requirements: list[RoleRequirement] = []
     if state.host_entry_mode == "spawn-process":
-        requirements.append(RoleRequirement("leader", 1, "lead"))
+        requirements.append(RoleRequirement("leader", 1, 1, 1, "lead"))
     requirements.extend(
         requirement
         for requirement in profile.roles
@@ -1306,18 +1338,47 @@ def _selectable_static_requirements(
     return tuple(requirements)
 
 
+def _leader_session_prompt(state: WizardState) -> Prompt:
+    """current-session 리더 칸: 모델/effort 표시만 하고 role_models 에 쓰지 않는다."""
+    attestation = _host_session_context(state).current_model
+    model_ref = (
+        attestation.normalized_model_ref
+        or attestation.observed_model
+        or "current-session"
+    )
+    steps = _load_wizard_root(state.workspace_root)["steps"]
+    raw = steps.get("leader_session") or {}
+    effort_suffix = ""
+    if attestation.effort:
+        effort_template = raw.get("effort_suffix", " · effort {effort}")
+        effort_suffix = effort_template.format(effort=attestation.effort)
+    prompt = _p(
+        state.workspace_root,
+        "leader_session",
+        model_ref=model_ref,
+        effort_suffix=effort_suffix,
+    )
+    continue_label = prompt["options"].get("continue", "계속")
+    return Prompt(
+        step=_LEADER_SESSION_STEP,
+        kind="pick",
+        label=prompt["label"],
+        options=[_opt("continue", continue_label)],
+        echo_template=prompt["echo_template"],
+    )
+
+
 def _count_prompt(
     state: WizardState,
     requirement: RoleRequirement,
 ) -> Prompt:
-    maximum = requirement.count + requirement.optional_count
     prompt = _p(
         state.workspace_root,
         "role_count",
         role=requirement.role,
-        minimum=str(requirement.count),
-        maximum=str(maximum),
-        default=str(requirement.count),
+        minimum=str(requirement.min_count),
+        maximum=str(requirement.max_count),
+        default=str(requirement.recommended_count),
     )
     return Prompt(
         step=_role_count_prompt_id(requirement.role),
@@ -1330,17 +1391,52 @@ def _count_prompt(
                     count=count,
                     default_suffix=(
                         prompt["options"].get("default_suffix", "")
-                        if count == requirement.count
+                        if count == requirement.recommended_count
                         else ""
                     ),
                 ),
             )
-            for count in range(requirement.count, maximum + 1)
+            for count in range(requirement.min_count, requirement.max_count + 1)
         ],
         echo_template=prompt["echo_template"],
     )
 
 
+def _role_add_prompt(
+    state: WizardState,
+    requirement: RoleRequirement,
+) -> Prompt:
+    """min=0 선택 역할: 기본은 추가 안 함, 추가 시 1..max 수량을 이 스텝에서 고른다."""
+    prompt = _p(
+        state.workspace_root,
+        "role_add",
+        role=requirement.role,
+        maximum=str(requirement.max_count),
+    )
+    options = [
+        _opt(
+            "0",
+            prompt["options"]["skip"].format(
+                default_suffix=prompt["options"].get("default_suffix", ""),
+            ),
+        ),
+    ]
+    for count in range(1, requirement.max_count + 1):
+        options.append(
+            _opt(
+                str(count),
+                prompt["options"]["add"].format(count=count),
+            )
+        )
+    return Prompt(
+        step=_role_add_prompt_id(requirement.role),
+        kind="pick",
+        label=prompt["label"],
+        options=options,
+        echo_template=prompt["echo_template"],
+    )
+
+
 def _role_default_candidates(
     state: WizardState,
     role: str,
@@ -1628,30 +1724,19 @@ def _completed_role_models(
         candidates = _executable_role_models(state, profile, requirement, context)
         if not candidates or any(model not in candidates for model in selected):
             return None
-        providers = {
-            context.pool.resolve(model).provider_id
-            for model in selected[:requirement.count]
-        }
-        required = requirement.min_distinct_providers or 0
-        available_providers = {
-            context.pool.resolve(model).provider_id for model in candidates
-        }
-        required_slots = max(0, requirement.count - len(selected))
-        possible = len(providers | available_providers)
-        if min(possible, len(providers) + required_slots) < required:
+        # 같은 역할 패널의 model_ref 는 서로 달라야 한다.
+        if len(set(selected)) < len(selected):
+            return None
+        used = set(selected)
+        remaining = [model for model in candidates if model not in used]
+        if len(remaining) < count - len(selected):
             return None
         while len(selected) < count:
-            ordinal = len(selected) + 1
-            model_ref = candidates[0]
-            if ordinal <= requirement.count and len(providers) < required:
-                model_ref = next(
-                    model
-                    for model in candidates
-                    if context.pool.resolve(model).provider_id not in providers
-                )
+            model_ref = next(
+                model for model in candidates if model not in used
+            )
             selected.append(model_ref)
-            if ordinal <= requirement.count:
-                providers.add(context.pool.resolve(model_ref).provider_id)
+            used.add(model_ref)
     return {role: tuple(models) for role, models in completed.items()}
 
 
@@ -1701,18 +1786,45 @@ def next_role_prompt(state: WizardState) -> Prompt | None:
     if not _role_selection_enabled(state) or not _identity_ready(state):
         return None
     state.use_defaults = False
+    # current-session: 리더는 읽기 전용 확인 칸만 먼저 보여 준다.
+    if (
+        state.host_entry_mode == "current-session"
+        and _LEADER_SESSION_STEP not in state.answered
+        and _LEADER_SESSION_STEP not in state.role_selection_order
+    ):
+        return _leader_session_prompt(state)
     profile = _load_role_profile_for_state(state)
     for requirement in profile.roles:
-        if requirement.dynamic or requirement.optional_count == 0:
+        # 필수 수량: min < max 이고 min > 0 일 때만.
+        if (
+            requirement.dynamic
+            or requirement.min_count == requirement.max_count
+            or requirement.min_count == 0
+        ):
             continue
         if requirement.role not in state.role_counts:
             return _count_prompt(state, requirement)
         count = state.role_counts[requirement.role]
-        maximum = requirement.count + requirement.optional_count
-        if count < requirement.count or count > maximum:
+        if count < requirement.min_count or count > requirement.max_count:
             raise WizardError(
                 f"role {requirement.role!r} count must be in "
-                f"{requirement.count}..{maximum}: {count}"
+                f"{requirement.min_count}..{requirement.max_count}: {count}"
+            )
+    for requirement in profile.roles:
+        # 선택 역할(min=0, max>0): 기본은 추가 안 함. role-add 로만 연다.
+        if (
+            requirement.dynamic
+            or requirement.min_count != 0
+            or requirement.max_count == 0
+        ):
+            continue
+        if requirement.role not in state.role_counts:
+            return _role_add_prompt(state, requirement)
+        count = state.role_counts[requirement.role]
+        if count < 0 or count > requirement.max_count:
+            raise WizardError(
+                f"role {requirement.role!r} count must be in "
+                f"0..{requirement.max_count}: {count}"
             )
     requirements = _selectable_static_requirements(state, profile)
     try:
@@ -1781,6 +1893,11 @@ def _validate_submitted_role_model(
 
 
 def _submit_role_prompt(state: WizardState, prompt: Prompt, value: str) -> str:
+    if prompt.step == _LEADER_SESSION_STEP:
+        if value != "continue":
+            raise WizardError("leader session step accepts only 'continue'")
+        # role_models["leader"] 에 쓰지 않는다 — 현재 세션 모델을 그대로 쓴다.
+        return "leader-session: continue"
     if prompt.step.startswith("role-count:"):
         role = prompt.step.split(":", 1)[1]
         profile = _load_role_profile_for_state(state)
@@ -1788,21 +1905,57 @@ def _submit_role_prompt(state: WizardState, prompt: Prompt, value: str) -> str:
             (row for row in profile.roles if row.role == role),
             None,
         )
-        if requirement is None or requirement.dynamic or requirement.optional_count == 0:
+        if (
+            requirement is None
+            or requirement.dynamic
+            or requirement.min_count == requirement.max_count
+            or requirement.min_count == 0
+        ):
             raise WizardError(f"role {role!r} does not accept a count selection")
         try:
             count = int(value)
         except ValueError as exc:
             raise WizardError(f"role {role!r} count must be an integer") from exc
-        maximum = requirement.count + requirement.optional_count
-        if count < requirement.count or count > maximum:
+        if count < requirement.min_count or count > requirement.max_count:
             raise WizardError(
                 f"role {role!r} count must be in "
-                f"{requirement.count}..{maximum}: {count}"
+                f"{requirement.min_count}..{requirement.max_count}: {count}"
             )
         state.role_counts[role] = count
         state.role_models.pop(role, None)
         return f"role-count: {role}={count}"
+    if prompt.step.startswith("role-add:"):
+        role = prompt.step.split(":", 1)[1]
+        profile = _load_role_profile_for_state(state)
+        requirement = next(
+            (row for row in profile.roles if row.role == role),
+            None,
+        )
+        if (
+            requirement is None
+            or requirement.dynamic
+            or requirement.min_count != 0
+            or requirement.max_count == 0
+        ):
+            raise WizardError(f"role {role!r} does not accept an optional add")
+        allowed = {option.value for option in prompt.options}
+        if value not in allowed:
+            raise WizardError(
+                f"role {role!r} add selection must be one of "
+                f"{sorted(allowed, key=int)}: {value}"
+            )
+        try:
+            count = int(value)
+        except ValueError as exc:
+            raise WizardError(f"role {role!r} count must be an integer") from exc
+        if count < 0 or count > requirement.max_count:
+            raise WizardError(
+                f"role {role!r} count must be in "
+                f"0..{requirement.max_count}: {count}"
+            )
+        state.role_counts[role] = count
+        state.role_models.pop(role, None)
+        return f"role-add: {role}={count}"
     _, role, ordinal_raw = prompt.step.split(":", 2)
     ordinal = int(ordinal_raw)
     allowed = {option.value for option in prompt.options}
@@ -2136,6 +2289,30 @@ def _contract_outcome_suffix(entry: dict) -> str:
     return ""
 
 
+def _next_phase_cell(raw: Any) -> str:
+    """task picker 한 줄에 실을 다음 phase 표기.
+
+    `phase` 만 싣고 `status` 를 버리면 "아직 여기 있다" 가 "다음으로 갈 수 있다"
+    로 읽힌다. prepare 는 끝나지 않은 run 의 포인터를 `ready` → `pending` 으로
+    내리면서 `phase` 는 남겨두므로(`render._derive_next_recommended_phase`),
+    준비만 된 implementation 태스크의 포인터가
+    `{"phase": "final-verification", "status": "pending"}` 이다. status 를 안
+    보면 그 줄이 `next: final-verification` 으로 찍혀 착수 가능한 것처럼 읽힌다.
+
+    그래서 `ready` 가 아닌 status 는 괄호로 함께 싣는다. `okstra-inspect` 의
+    status 표는 같은 정보를 `*` 마커로 싣지만(`facets/status.md`), 그쪽은 표
+    아래 범례 한 줄을 붙일 수 있는 자리다. picker 옵션은 라벨 한 줄이 전부라
+    범례를 둘 데가 없으므로 status 이름을 그대로 적는다. phase 를 `--` 로
+    지우지 않는 이유는 그 이름이 "어디로 가는 태스크인가" 라는 정보를 여전히
+    나르기 때문이다 — 지우는 것은 착수 가능성만이 아니라 목적지까지 지운다.
+    """
+    pointer = next_phase.promote(raw)
+    cell = pointer["phase"] or "--"
+    if pointer["status"] == next_phase.STATUS_READY:
+        return cell
+    return f"{cell} ({pointer['status']})"
+
+
 def _build_task_pick(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "task_pick")
     project_root = Path(state.project_root)
@@ -2151,7 +2328,7 @@ def _build_task_pick(state: WizardState) -> Prompt:
         # catalog entries are flat (render_task_catalog_discovery) — there is
         # no nested "workflow" object here, unlike task-manifest.json.
         phase = entry.get("currentPhase") or ttype
-        nxt = entry.get("nextRecommendedPhase") or ""
+        nxt = _next_phase_cell(entry.get("nextRecommendedPhase"))
         suffix = latest_suffix if key == latest_key else ""
         label = f"{key}  ·  {phase}  ·  next: {nxt}{_contract_outcome_suffix(entry)}{suffix}"
         options.append(_opt(value=key, label=label))
@@ -2191,8 +2368,7 @@ def _submit_task_pick(state: WizardState, value: str) -> Optional[str]:
     # task_type seeded from manifest's nextRecommendedPhase as the recommended default
     root = find_task_root(Path(state.project_root), value)
     manifest = (read_task_manifest(root) or {}) if root else {}
-    workflow = manifest.get("workflow") or {}
-    state.task_type = workflow.get("nextRecommendedPhase") or ""
+    state.task_type = next_phase.autofill_task_type(manifest)
     return f"task: {value}"
 
 
@@ -2636,8 +2812,18 @@ def _build_task_type(state: WizardState) -> Prompt:
 
     workflow = _existing_task_workflow(state)
     revision_requested = _latest_revision_requested_analysis_type(state)
+    # 포인터에서 phase 를 꺼내는 것은 `status` 가 `ready` 일 때뿐이다. prepare 는
+    # 실행이 끝나지 않은 run 의 포인터를 일부러 `pending` 으로 내려두는데
+    # (`render._derive_next_recommended_phase`), 여기서 status 를 안 보고 `phase`
+    # 만 꺼내면 그 방어를 그대로 우회한다 — 기록된 사례가 `implementation` 이
+    # `prepared` 상태인데 `final-verification` 이 추천으로 뜬 것이다. 판정은
+    # 셸 진입점이 쓰는 것과 같은 함수(`next_phase.autofill_task_type`)로 한다.
+    #
+    # `ready` 가 아니면 추천은 비고, 아래 `currentPhase` 재실행 옵션이 남는다.
+    # 실패한 run 의 포인터가 `{"phase": "", "status": "blocked"}` 라는 점에서
+    # 그것이 맞는 제안이다 — 그 옵션은 포인터가 아니라 `currentPhase` 에서 온다.
     recommended = (revision_requested or state.task_type
-                   or workflow.get("nextRecommendedPhase") or "")
+                   or next_phase.autofill_task_type({"workflow": workflow}))
     if not recommended and not workflow:
         recommended = TASK_TYPE_VALUES[0]
     add(recommended, recommended_suffix)
@@ -5020,7 +5206,7 @@ def _reset_role_selection_from(state: WizardState, target_step: str) -> None:
     kept_counts = {
         step_id.split(":", 1)[1]
         for step_id in kept_ids
-        if step_id.startswith("role-count:")
+        if step_id.startswith(("role-count:", "role-add:"))
     }
     kept_models: dict[str, int] = {}
     for step_id in kept_ids:
@@ -5052,12 +5238,12 @@ def _clear_role_selection(state: WizardState) -> None:
     state.answered = [
         step_id
         for step_id in state.answered
-        if not step_id.startswith(("role-count:", "role-model:"))
+        if not _is_role_selection_step(step_id)
     ]
 
 
 def _submit_edit_target(state: WizardState, value: str) -> Optional[str]:
-    if value.startswith(("role-count:", "role-model:")):
+    if _is_role_selection_step(value):
         _reset_role_selection_from(state, value)
     elif any(s.id == value for s in STEPS):
         _reset_from(state, value)
@@ -5779,7 +5965,7 @@ def _sim_advance(state: WizardState, prompt: Prompt) -> None:
     """기본답으로 한 화면 전진한다. progress 를 재계산하는 submit()/
     _submit_group() 은 호출하지 않고 step.submit 만 직접 호출해 재귀를 막는다."""
     try:
-        if prompt.step.startswith(("role-count:", "role-model:")):
+        if _is_role_selection_step(prompt.step):
             _submit_role_prompt(state, prompt, _sim_answer(prompt))
             if prompt.step not in state.answered:
                 state.answered.append(prompt.step)
@@ -5966,7 +6152,7 @@ def submit(state: WizardState, value: str) -> dict[str, Any]:
     value = _normalize_interaction_answer(state, prompt, plan, value)
     if prompt.kind == "pick_group":
         return _submit_group(state, prompt, value)
-    if prompt.step.startswith(("role-count:", "role-model:")):
+    if _is_role_selection_step(prompt.step):
         echo = _submit_role_prompt(state, prompt, value or "")
         if prompt.step not in state.answered:
             state.answered.append(prompt.step)
@@ -6006,13 +6192,19 @@ def render_role_args(state: WizardState) -> list[str]:
         profile = _load_role_profile_for_state(state)
         requirements = _selectable_static_requirements(state, profile)
         for requirement in profile.roles:
-            if requirement.dynamic or requirement.optional_count == 0:
+            if (
+                requirement.dynamic
+                or requirement.min_count == requirement.max_count
+            ):
                 continue
             if requirement.role not in state.role_counts:
                 continue
+            count = state.role_counts[requirement.role]
+            if count <= 0:
+                continue
             role_argv.extend([
                 "--role-count",
-                f"{requirement.role}={state.role_counts[requirement.role]}",
+                f"{requirement.role}={count}",
             ])
         ordered_roles = [requirement.role for requirement in requirements]
     else:

package/runtime/python/okstra_ctl/worker_prompt_body.py

@@ -6,11 +6,27 @@ from typing import Any, Mapping, Sequence
 from .worker_prompt_policy import PromptPlan
 
 
-ANALYSIS_WORKER_LABELS = {
+_ANALYSIS_WORKER_LABELS = {
     "claude": "Claude worker",
     "codex": "Codex worker",
     "antigravity": "Antigravity worker",
 }
+
+
+def analysis_worker_label(worker_id: str) -> str:
+    """The role label this worker's prompt body is titled with.
+
+    The map above only supplies display capitalization for the three providers
+    that predate it; every other worker id (`grok`, `kimi`, a user-installed
+    adapter) takes the id itself. Both branches are identity deltas the equality
+    group must normalize away, so `worker_prompt_contract` erases exactly what
+    this function returns rather than restating the map — an enumeration that
+    covered only the map's keys let `# grok worker Dispatch` through and failed
+    every roster carrying grok or kimi before publication.
+    """
+    return _ANALYSIS_WORKER_LABELS.get(worker_id, f"{worker_id} worker")
+
+
 def analysis_prompt_body(
     manifest: Mapping[str, Any],
     active_context: Mapping[str, Any],
@@ -19,7 +35,7 @@ def analysis_prompt_body(
     plan: PromptPlan,
 ) -> list[str]:
     """Render the provider-neutral body for an initial analysis audience."""
-    label = ANALYSIS_WORKER_LABELS.get(worker_id, f"{worker_id} worker")
+    label = analysis_worker_label(worker_id)
     pane_role = {
         "implementation-executor": "executor",
         "implementation-verifier": "verifier",

package/runtime/python/okstra_ctl/worker_prompt_contract.py

@@ -5,8 +5,9 @@ import json
 import re
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Mapping, Sequence
+from typing import Any, Iterable, Mapping, Sequence
 
+from .worker_prompt_body import analysis_worker_label
 from .worker_prompt_policy import (
     ERRORS_PATH_HEADERS,
     IMPLEMENTATION_HEADERS,
@@ -88,10 +89,7 @@ _WORKER_SPECIFIC_PREFIXES = (
     "**Host runtime:**",
     "**Host model value:**",
 )
-_WORKER_LABEL_RE = re.compile(
-    r"\b(?:Claude|Codex|Antigravity) worker\b",
-    re.IGNORECASE,
-)
+_WORKER_LABEL_SUBSTITUTE = "<analysis-worker>"
 
 
 @dataclass(frozen=True)
@@ -156,8 +154,38 @@ def validate_final_verification_initial_prompt(text: str) -> list[str]:
     return errors
 
 
-def normalise_analysis_prompt(text: str) -> str:
-    """Remove only permitted worker identity, model, role, and path deltas."""
+def _worker_label_pattern(worker_ids: Iterable[str]) -> re.Pattern[str] | None:
+    """Match the role label the body renderer titled each compared worker with.
+
+    Built from `analysis_worker_label`, the same function that writes the label,
+    so a provider outside its display map (`grok`, `kimi`) is covered as it
+    comes. Restating the map here is what forked the roster: the enumeration
+    named only Claude / Codex / Antigravity, `# grok worker Dispatch` survived
+    normalization, and every run rostering grok or kimi failed the equality group
+    before publication with no prompt defect to fix.
+    """
+    labels = sorted(
+        {
+            analysis_worker_label(worker_id.strip())
+            for worker_id in worker_ids
+            if worker_id.strip()
+        },
+        key=lambda label: (-len(label), label),
+    )
+    if not labels:
+        return None
+    alternation = "|".join(re.escape(label) for label in labels)
+    return re.compile(rf"\b(?:{alternation})\b", re.IGNORECASE)
+
+
+def normalise_analysis_prompt(text: str, *, worker_ids: Iterable[str]) -> str:
+    """Remove only permitted worker identity, model, role, and path deltas.
+
+    ``worker_ids`` is every worker in the comparison group, not just this
+    prompt's own: a body that names a sibling worker must normalize to the same
+    bytes in all of them, or the mention itself reads as divergence.
+    """
+    label = _worker_label_pattern(worker_ids)
     normalized: list[str] = []
     for line in text.replace("\r\n", "\n").replace("\r", "\n").splitlines():
         stripped = line.strip()
@@ -167,7 +195,10 @@ def normalise_analysis_prompt(text: str) -> str:
         )
         if prefix:
             continue
-        normalized.append(_WORKER_LABEL_RE.sub("<analysis-worker>", line.rstrip()))
+        line = line.rstrip()
+        normalized.append(
+            line if label is None else label.sub(_WORKER_LABEL_SUBSTITUTE, line)
+        )
     return "\n".join(normalized).strip() + "\n"
 
 
@@ -176,7 +207,7 @@ def validate_analysis_prompt_set(prompts: Mapping[str, str]) -> list[str]:
     if len(prompts) < 2:
         return []
     normalized = {
-        worker_id: normalise_analysis_prompt(text)
+        worker_id: normalise_analysis_prompt(text, worker_ids=prompts.keys())
         for worker_id, text in sorted(prompts.items())
     }
     baseline_worker = next(iter(normalized))

package/runtime/python/okstra_ctl/worker_prompt_headers.py

@@ -54,6 +54,17 @@ EVIDENCE_CITATION_HEADER = (
     "ledger row and fails exactly like a file you never opened, however many "
     "times you cited the full path earlier."
 )
+# 파일 인용과 같이 첫 결론 명령 앞에 형식을 둔다. 분석 프리앰블에만 있으면
+# 구현 워커는 명령 행을 쓰지 못한다.
+EVIDENCE_COMMANDS_HEADER = (
+    "**Evidence commands:** Append one `- Evidence command: "
+    "{\"command\":\"<exact command>\",\"cwd\":\"<project-root>\","
+    "\"exitCode\":0,\"outputSummary\":\"<one-line result>\"}` row to the audit "
+    "sidecar for each command that produced or verified a conclusion. Do not "
+    "record exploratory `rg`, `ls`, or file-opening commands. Write the command "
+    "as you ran it. A value that must not be written down is yours to omit or "
+    "pass as a `$VAR` reference."
+)
 
 # `agy`'s write tool validates the target against the Gemini artifact store
 # whenever the model attaches ArtifactMetadata, and rejects every path outside
@@ -120,7 +131,11 @@ def worker_prompt_headers(
             f"**Coding preflight pack:** {_coding_preflight_pack_path(active_context)}"
         )
     if dispatch_kind == "initial" and plan.audience != "report-writer":
-        headers += [EVIDENCE_LEDGER_HEADER, EVIDENCE_CITATION_HEADER]
+        headers += [
+            EVIDENCE_LEDGER_HEADER,
+            EVIDENCE_CITATION_HEADER,
+            EVIDENCE_COMMANDS_HEADER,
+        ]
     headers.extend([
         f"**Errors log path:** {errors_log_path}",
         f"**Errors sidecar path:** {errors_sidecar_path}",