okstra 0.207.1 → 0.209.0

package/runtime/python/okstra_ctl/domain/role.py

@@ -58,6 +58,7 @@ DUTY_ROLE_IDS = {
     "reverification-worker": "verifier",
     "code-reviewer": "verifier",
     "schedule-verifier": "verifier",
+    "business-flow-investigator": "analyser",
     "report-writer": "report-writer",
     "translator": "translator",
 }

package/runtime/python/okstra_ctl/group_context.py

@@ -39,7 +39,7 @@ from typing import Any, Mapping
 from okstra_project import list_project_tasks
 from okstra_project.phase_pointer import STATUS_TERMINAL
 
-from .brief_frontmatter import read_brief_frontmatter
+from .brief_frontmatter import brief_task_id, read_brief_frontmatter
 from .ids import slugify_task_segment
 from .paths import find_asset_root
 from .run_context import dir_flock
@@ -387,7 +387,7 @@ _QUEUE_LINE_RE = re.compile(r"^\d+\. \[(?P<status>[^\]]*)\] (?P<task>\S+)")
 
 @dataclass(frozen=True)
 class QueueRow:
-    task_id: str        # slugified brief-id — the task directory name
+    task_id: str        # slugified task-id (else brief-id) — the task directory name
     brief_id: str
     ticket_id: str
     brief: str          # project-relative brief path
@@ -420,6 +420,7 @@ def group_briefs(project_root: Path, task_group: str) -> list[dict[str, Any]]:
         brief_id = frontmatter.get("brief-id") or path.stem
         match = _ORDINAL_RE.match(brief_id)
         briefs.append({
+            "task_id": slugify_task_segment(brief_task_id(frontmatter) or brief_id),
             "brief_id": brief_id,
             "ticket_id": frontmatter.get("ticket-id") or ticket_id_from_brief_id(brief_id),
             "ordinal": int(match.group("ordinal")) if match else None,
@@ -509,7 +510,7 @@ def group_queue(
     recorded = catalog_progress(project_root, task_group)
 
     def _status(brief: dict[str, Any]) -> tuple[str, str]:
-        task_id = slugify_task_segment(brief["brief_id"])
+        task_id = brief["task_id"]
         if task_id in recorded:
             return recorded[task_id]
         entry = by_task.get(task_id)
@@ -527,7 +528,7 @@ def group_queue(
             if status_by_ticket[ticket][0] != QUEUE_DONE
         ))
         rows.append(QueueRow(
-            slugify_task_segment(brief["brief_id"]), brief["brief_id"], brief["ticket_id"],
+            brief["task_id"], brief["brief_id"], brief["ticket_id"],
             brief["brief"], status, progress, open_waits,
             duplicates.get(brief["brief_id"], ()),
         ))

package/runtime/python/okstra_ctl/legacy_model_selection.py

@@ -58,7 +58,6 @@ def normalize_model_selection_inputs(
     profile: RoleProfile,
     role_counts_raw: Sequence[str],
     role_models_raw: Sequence[str],
-    workers: str,
     worker_model: str,
     critic: str,
     executor: str,
@@ -73,7 +72,6 @@ def normalize_model_selection_inputs(
     models = _parse_role_models(role_models_raw)
     legacy = _legacy_selection(
         profile=profile,
-        workers=workers,
         worker_model=worker_model,
         critic=critic,
         executor=executor,
@@ -141,7 +139,6 @@ def _split_role_value(raw: str, option: str) -> tuple[str, str]:
 def _legacy_selection(
     *,
     profile: RoleProfile,
-    workers: str,
     worker_model: str,
     critic: str,
     executor: str,
@@ -155,27 +152,12 @@ def _legacy_selection(
     constraints: dict[str, tuple[str, ...]] = {}
     values: dict[str, dict[str, str]] = {}
     sources: list[str] = []
-    needs_initial = bool(
-        workers.strip()
-        or worker_model.strip()
-        or any(model.strip() for model in provider_models.values())
-    )
-    initial = (
-        _initial_cross_verification_requirement(profile)
-        if needs_initial
-        else None
-    )
-    if workers.strip() and initial is not None:
-        providers = _legacy_worker_providers(workers)
-        _validate_legacy_workers(initial, providers)
-        counts[initial.role] = len(providers)
-        constraints[initial.role] = providers
-        report_writer = _requirement(profile, "report-writer")
-        if report_writer is not None:
-            counts["report-writer"] = report_writer.recommended_count
-        sources.append("--workers")
     worker_values = _parse_worker_models(worker_model, provider_models)
-    if worker_values and initial is not None:
+    if worker_values:
+        # A provider model flag fills one slot of the initial cross-verification
+        # role per named provider; the remaining slots take the model defaults.
+        initial = _initial_cross_verification_requirement(profile)
+        constraints[initial.role] = tuple(worker_values)
         values[initial.role] = worker_values
         sources.append("worker-model")
     _add_provider_selection(
@@ -201,30 +183,8 @@ def _initial_cross_verification_requirement(profile: RoleProfile) -> RoleRequire
         }:
             return requirement
     raise ModelSelectionInputError(
-        "profile has no initial cross-verification role for legacy --workers"
-    )
-
-
-def _legacy_worker_providers(workers: str) -> tuple[str, ...]:
-    tokens = tuple(
-        token.strip().lower() for token in workers.split(",") if token.strip()
+        "profile has no initial cross-verification role for a provider model flag"
     )
-    return tuple(token for token in tokens if token != "report-writer")
-
-
-def _validate_legacy_workers(
-    requirement: RoleRequirement,
-    providers: tuple[str, ...],
-) -> None:
-    # minDistinctProviders 제거. 모델 참조 중복 거부는 Task 2.
-    if (
-        len(providers) < requirement.min_count
-        or len(providers) > requirement.max_count
-    ):
-        raise ModelSelectionInputError(
-            f"legacy --workers selects {len(providers)} {requirement.role} instances; "
-            f"profile requires {requirement.min_count}..{requirement.max_count}"
-        )
 
 
 def _parse_worker_models(
@@ -346,7 +306,7 @@ def _legacy_matches_canonical(
     canonical_models: Mapping[str, tuple[str, ...]],
     legacy: CanonicalModelSelection,
 ) -> bool:
-    """레거시(--workers 등)가 변환 후 정본과 같은 값으로 수렴하는지 본다."""
+    """레거시(공급자 모델 플래그 등)가 변환 후 정본과 같은 값으로 수렴하는지 본다."""
     leg_count = legacy.role_counts.get(role)
     can_count = canonical_counts.get(role)
     if can_count is not None and leg_count is not None and can_count != leg_count:
@@ -456,10 +416,6 @@ def _validate_role_count(
         )
 
 
-def _requirement(profile: RoleProfile, role: str) -> RoleRequirement | None:
-    return next((row for row in profile.roles if row.role == role), None)
-
-
 def serialize_host_session_context(context: HostSessionContext) -> str:
     """Serialize host-owned session facts as stable canonical JSON."""
     current = context.current_model

package/runtime/python/okstra_ctl/manager_split.py

@@ -277,6 +277,7 @@ def _render_brief(
     assignment: dict,
     task_group: str,
     manager_task: str,
+    child_task_id: str,
     stem: str,
     created: str,
     key: str,
@@ -293,6 +294,7 @@ def _render_brief(
         "---",
         "type: brief",
         f"brief-id: {stem}",
+        f"task-id: {child_task_id}",
         "parent-id: self",
         f"ticket-id: {ticket}",
         f"source-type: {SOURCE_TYPE}",
@@ -429,7 +431,8 @@ def split_task(
         siblings = [(other["taskKey"], other["assignment"], other["briefPath"]) for other in items
                     if other["issue"] is item["issue"] and other is not item]
         item["text"] = _render_brief(source=source, issue=item["issue"], assignment=item["assignment"],
-                                     task_group=task_group, manager_task=manager_task, stem=item["stem"],
+                                     task_group=task_group, manager_task=manager_task,
+                                     child_task_id=item["childTaskId"], stem=item["stem"],
                                      created=when[:10], key=item["taskKey"], project_root=item["projectRoot"],
                                      siblings=siblings, graph=graph)
     errors = _validate_rendered(items, validator, group_segment)

package/runtime/python/okstra_ctl/model_io/lines.py

@@ -2,18 +2,14 @@
 
 이 층은 파일을 열지 않는다 — 이미 읽힌 매핑을 받아 문자열만 만든다. 그래서
 참조 해석과 독립이고, 서식을 고칠 때 경로 규칙을 다시 읽을 필요가 없다.
-`_provider_models` 만 예외적으로 거절하지만, 그것도 디스크가 아니라 받은
-매핑 안의 모순을 보는 것이다.
 """
 from __future__ import annotations
 
-from pathlib import Path
 from typing import Any, Mapping
 
 from okstra_project.phase_pointer import promote
 
 from ..fixed_text import line as _line, scalar as _value
-from ..json_boundary import JsonBoundaryError
 
 
 def _mapping(payload: Mapping[str, Any], key: str) -> Mapping[str, Any]:
@@ -87,7 +83,7 @@ def _critic_assignment_lines(run: Mapping[str, Any]) -> list[str]:
     """Opt-in critics live only in `invocationAssignments`, never in `workerAssignments`.
 
     The id is the assignment ref's last segment, the value team dispatch and
-    `optionalWorkerRoles[].workerId` use (`render._optional_worker_roles`).
+    `criticRoles[].workerId` use (`render._critic_role_rows`).
     """
     assignments = run.get("invocationAssignments")
     if not isinstance(assignments, Mapping):
@@ -173,22 +169,3 @@ def _history_overview_text(rows: list[dict[str, object]], limit: int) -> str:
 
 def _csv(value: object) -> str:
     return ",".join(str(item) for item in value) if isinstance(value, list) else ""
-
-
-def _provider_models(run: Mapping[str, Any]) -> dict[str, str]:
-    values: dict[str, set[str]] = {}
-    assignments = run.get("workerAssignments")
-    if isinstance(assignments, list):
-        for assignment in assignments:
-            if not isinstance(assignment, Mapping):
-                continue
-            provider = assignment.get("provider")
-            model = assignment.get("model")
-            if isinstance(provider, str) and isinstance(model, str) and model:
-                values.setdefault(provider, set()).add(model)
-    for provider, models in values.items():
-        if len(models) > 1:
-            raise JsonBoundaryError(
-                Path("workerAssignments"), "run manifest", f"conflicting models for provider {provider}"
-            )
-    return {provider: next(iter(models)) for provider, models in values.items()}

package/runtime/python/okstra_ctl/model_io/renderers.py

@@ -18,10 +18,11 @@ from ..convergence import (
 from ..error_zip import last_output_path
 from ..fixed_text import line as _line, scalar as _value
 from ..json_boundary import JsonBoundaryError, load_owned_object
-from ..paths import okstra_home
+from ..paths import find_asset_root, okstra_home
+from ..phases.catalog import PhaseAssetError, profile_markdown
 from ..recap import assemble_group_recap, assemble_recap
+from ..role_requirements import RoleProfileError, load_role_profile
 from ..timeline_runs import current_run_facts
-from ..worker_artifacts import worker_provider_id
 from .lines import (
     _assignment_line,
     _csv,
@@ -30,7 +31,6 @@ from .lines import (
     _next_phase_lines,
     _project_policy_lines,
     next_phase_pointer,
-    _provider_models,
     _status_overview_text,
     _worker_assignment_lines,
     _worker_prompt_lines,
@@ -465,46 +465,59 @@ def render_report_input(project_root: Path, task_ref: str) -> str:
     )
 
 
-def _worker_providers_csv(recommended: Any) -> str:
-    """로스터 슬롯 id 를 `--workers` 가 받는 provider id 로 접는다.
+def _role_selection_rows(run: Mapping[str, Any]) -> list[tuple[str, str]]:
+    """실행된 역할 칸을 `--role-model` 값(`<role>=<provider>/<model>`)으로 옮긴다.
 
-    `recommendedWorkers` 는 슬롯 id(`codex-verifier`)를 싣고 `--workers` 는
-    프로파일이 선언한 provider 허용목록만 받는다([`workers.py`](../workers.py)).
-    슬롯 id 를 그대로 넘기면 재실행이 `unknown workers` 로 죽으므로, 재실행 입력을
-    만드는 이 자리에서 어휘를 맞춘다. 슬롯 수는 `--role-count` 가 나른다.
+    critic 은 `workerAssignments` 가 아니라 `invocationAssignments` 의 `critic/*`
+    에만 있다(`render._critic_role_rows`).
     """
-    if not isinstance(recommended, list):
-        return ""
-    seen: list[str] = []
-    for item in recommended:
-        if not isinstance(item, str) or not item.strip():
+    rows: list[tuple[str, str]] = []
+    assignments = run.get("workerAssignments")
+    for assignment in assignments if isinstance(assignments, list) else ():
+        if not isinstance(assignment, Mapping):
             continue
-        provider = worker_provider_id(item.strip())
-        if provider not in seen:
-            seen.append(provider)
-    return ",".join(seen)
+        role, provider, model = (
+            assignment.get(key) for key in ("role", "provider", "model")
+        )
+        if all(isinstance(value, str) and value for value in (role, provider, model)):
+            rows.append((role, f"{provider}/{model}"))
+    invocations = run.get("invocationAssignments")
+    if isinstance(invocations, Mapping):
+        for ref, assignment in sorted(invocations.items()):
+            if not (isinstance(ref, str) and ref.startswith("critic/")):
+                continue
+            if not isinstance(assignment, Mapping):
+                continue
+            provider, model = assignment.get("provider"), assignment.get("model")
+            if isinstance(provider, str) and provider and isinstance(model, str) and model:
+                rows.append(("critic", f"{provider}/{model}"))
+    return rows
+
+
+def _adjustable_roles(run_manifest: Path, task_type: object) -> set[str]:
+    """`--role-count` 를 받는 역할 — 하한과 상한이 다른 정적 역할."""
+    root = find_asset_root(("prompts", "profiles"), is_present=Path.is_dir)
+    if root is None or not isinstance(task_type, str):
+        raise JsonBoundaryError(run_manifest, "run manifest", "phase profile is unavailable")
+    try:
+        profile = load_role_profile(profile_markdown(root, task_type))
+    except (PhaseAssetError, RoleProfileError, ValueError) as exc:
+        raise JsonBoundaryError(run_manifest, "run manifest", str(exc)) from exc
+    return {
+        requirement.role
+        for requirement in profile.roles
+        if not requirement.dynamic and requirement.min_count < requirement.max_count
+    }
 
 
 def render_rerun_input(run_manifest: Path) -> str:
     run_manifest = _owned_run_manifest_path(run_manifest)
     run = load_owned_object(run_manifest, artifact="run manifest")
-    models = _provider_models(run)
-    team = _mapping(run, "teamContract")
-    executor = _mapping(team, "executor")
-    executor_provider = executor.get("provider")
-    executor_model = executor.get("model")
-    if (
-        isinstance(executor_provider, str)
-        and isinstance(executor_model, str)
-        and executor_model
-        and models.get(executor_provider)
-        and models[executor_provider] != executor_model
-    ):
-        raise JsonBoundaryError(
-            run_manifest,
-            "run manifest",
-            f"executor model conflicts with provider {executor_provider}",
-        )
+    rows = _role_selection_rows(run)
+    adjustable = _adjustable_roles(run_manifest, run.get("taskType"))
+    counts: dict[str, int] = {}
+    for role, _model_ref in rows:
+        counts[role] = counts.get(role, 0) + 1
     return (
         "# Okstra Rerun Input\n\n"
         + _line("Project ID", run.get("projectId"))
@@ -512,13 +525,13 @@ def render_rerun_input(run_manifest: Path) -> str:
         + _line("Task ID", run.get("taskId"))
         + _line("Task type", run.get("taskType"))
         + _line("Task brief", run.get("taskBriefPath"))
-        + _line("Workers", _worker_providers_csv(run.get("recommendedWorkers")))
         + _line("Related tasks", _csv(run.get("relatedTasks")))
-        + _line("Claude model", models.get("claude"))
-        + _line("Codex model", models.get("codex"))
-        + _line("Antigravity model", models.get("antigravity"))
-        + _line("Executor provider", executor.get("provider"))
-        + _line("Executor model", executor.get("model"))
+        + "".join(
+            _line("Role count", f"{role}={count}")
+            for role, count in counts.items()
+            if role in adjustable
+        )
+        + "".join(_line("Role model", f"{role}={model_ref}") for role, model_ref in rows)
     )
 
 

package/runtime/python/okstra_ctl/phases/change_impact_analysis/profile.json

@@ -6,7 +6,7 @@
       "mode": "static",
       "roleId": "analyser",
       "dutyId": "analysis-worker",
-      "min": 2,
+      "min": 1,
       "recommended": 3,
       "max": 5
     },

package/runtime/python/okstra_ctl/phases/change_impact_analysis/profile.md

@@ -1,14 +1,6 @@
 # Change Impact Analysis Profile
 
 - Purpose: assess the read-only impact of a proposed change, including preserved behavior, affected dependencies, and constraints that a later planning phase must resolve
-- Required workers:
-  - claude
-  - codex
-  - report-writer
-- Optional workers (opt-in via `--workers`):
-  - antigravity
-  - grok — optional adversarial analyser/critic through the Grok CLI wrapper
-  - kimi — optional long-context analyser/critic through the Kimi CLI wrapper
 {{INCLUDE:_common-contract.md}}
 - Phase 1.5 questions:
   - What user intent and preserved behavior define the proposed change boundary?

package/runtime/python/okstra_ctl/phases/error_analysis/profile.json

@@ -6,7 +6,7 @@
       "mode": "static",
       "roleId": "analyser",
       "dutyId": "diagnosis-worker",
-      "min": 2,
+      "min": 1,
       "recommended": 3,
       "max": 5
     },

package/runtime/python/okstra_ctl/phases/error_analysis/profile.md

@@ -1,14 +1,6 @@
 # Error Analysis Profile
 
 - Purpose: analyse reported errors or incidents and identify likely causes, missing evidence, and validation paths
-- Required workers:
-  - claude
-  - codex
-  - report-writer
-- Optional workers (opt-in via `--workers`):
-  - antigravity — when added to the roster it joins the analyser set; omitted by default
-  - grok — optional adversarial analyser/critic through the Grok CLI wrapper
-  - kimi — optional long-context analyser/critic through the Kimi CLI wrapper
 {{INCLUDE:_common-contract.md}}
 - Brief consumption (phase-specific addendum — shared rules live in `_common-contract.md` under "Brief handoff contract"):
   - Apply the shared reporter-confirmation precondition exactly as written. In this phase, unresolved `intent-check:` / `conversion-block:` rows use `Blocks=next-phase`; any unconfirmed inference may be used as a labelled hypothesis only.
@@ -26,6 +18,12 @@
   - **Graph-aware scope:** a graph edge can explain ordering or duplication, but it is not proof of cause by itself. Cite code/log evidence before claiming an upstream related task caused the current symptom.
   - **Sharp next diagnostic:** end with the single highest-value diagnostic command, log capture, or file inspection that should happen next, plus the expected signal that would confirm or reject the leading cause.
   - **Fix-design boundary:** do not design the implementation fix beyond what is necessary to validate the cause. Record whether the cause is credible and the next diagnostic. The common Phase Routing settles the next phase.
+- Census aspects:
+  - requirement pass-observation: Which observation would show the symptom resolved for this requirement?
+  - task symptom-lock: Which single observable failure condition does the reported symptom translate to?
+  - task reproduction: Was the symptom reproduced, not reproduced, or blocked before reproduction, and on what evidence?
+  - task cause-falsification: For each cause candidate, which evidence that could falsify it was checked?
+  - task next-diagnostic: Which diagnostic should run next, and which signal would confirm or reject the leading cause?
 - Structured diagnosis and routing contract:
   - `errorAnalysis` is the source of truth for reproduction status, `EA-NNN` cause candidates, the sharp next diagnostic, and the next route.
   - Record the route selected by the lead through the common Phase Routing rules, its `routing.leadingCauseId`, and the matching direction.

package/runtime/python/okstra_ctl/phases/feature_analysis/profile.json

@@ -6,7 +6,7 @@
       "mode": "static",
       "roleId": "analyser",
       "dutyId": "analysis-worker",
-      "min": 2,
+      "min": 1,
       "recommended": 3,
       "max": 5
     },

package/runtime/python/okstra_ctl/phases/feature_analysis/profile.md

@@ -1,14 +1,6 @@
 # Feature Analysis Profile
 
 - Purpose: analyse a confirmed feature target's behavior, rules, state changes, external calls, and test coverage scope without designing or changing an implementation
-- Required workers:
-  - claude
-  - codex
-  - report-writer
-- Optional workers (opt-in via `--workers`):
-  - antigravity
-  - grok — optional adversarial analyser/critic through the Grok CLI wrapper
-  - kimi — optional long-context analyser/critic through the Kimi CLI wrapper
 {{INCLUDE:_common-contract.md}}
 - Phase 1.5 questions:
   - What confirmed target and user intent bound this analysis?

package/runtime/python/okstra_ctl/phases/final_verification/profile.json

@@ -6,7 +6,7 @@
       "mode": "static",
       "roleId": "verifier",
       "dutyId": "acceptance-verifier",
-      "min": 2,
+      "min": 1,
       "recommended": 2,
       "max": 5
     },

package/runtime/python/okstra_ctl/phases/final_verification/profile.md

@@ -1,14 +1,6 @@
 # Final Verification Profile
 
 - Purpose: judge the delivered implementation on three axes before final acceptance — does it cover every requirement (under-delivery), does it carry work no requirement asked for (over-delivery), and does it actually do what it claims (defects, and tests that verify nothing). Whether the run followed okstra's own procedure is not one of the axes: the runtime and `validators/validate-run.py` own that, and a finding about it is not an acceptance judgement
-- Required workers:
-  - claude
-  - codex
-  - report-writer
-- Optional workers (opt-in via `--workers`):
-  - antigravity — when added to the roster it joins the analyser set; omitted by default
-  - grok — optional read-only adversarial analyser/critic through the Grok CLI wrapper
-  - kimi — optional read-only long-context analyser/critic through the Kimi CLI wrapper
 {{INCLUDE:_common-contract.md}}
 - Primary focus areas (each maps to a deliverable section below):
   - Acceptance-gating — a failure here pushes the verdict toward `blocked` / `conditional-accept`:
@@ -56,6 +48,8 @@
   - **Design-preparation carry-in:** read only source implementation report `missingInformation` rows whose `source` starts with `design-prep:`. Recommend `ifStillOpen: block` as an acceptance blocker and `ifStillOpen: follow-up` as residual risk. This phase does not read planning PREP sidecars directly or mutate planning snapshots.
   - **Could-not-verify honesty:** use `not-configured`, `env-unavailable`, `rejected`, `gap`, or `blocked` as appropriate. Never convert unavailable evidence into an executed/pass claim.
   - **Source-mutation prohibition:** verification may write only assigned okstra run artifacts. Do not edit source, schema, deployment, lockfile, or configuration files; route detected defects to a later phase.
+- Census aspects:
+  - file added-surface: Does this changed file add behaviour, configuration, or surface no requirement asked for, and does what it adds work?
 - Required deliverable shape (final report, in addition to the standard sections):
   - **Source Implementation Report(s)** (**Enforced:** `phases/final_verification/validation.py` `validate_verification_target_match` (called by `validators/validate-run.py`) compares `verificationScope`, `worktreePath`, `implementationBaseRef`, `capturedHeadSha`, and the `stageReports` stage set against the digest-verified `instruction-set/verification-target.md`; a snapshot whose digest no longer checks out is ignored rather than trusted. `verificationScope` in particular gates both stage-group eligibility and release-handoff routing, so it is not the report's to restate): the `VERIFICATION_TARGET` snapshot verbatim — verification scope, worktree path, base/head refs, the list of stages under verification, and one row per stage citing its originating implementation final-report (`report_path` from `consumers.jsonl`; render `(report_path unrecorded)` when absent). Every analyser prompt carries the same compact target identity (`**Verification scope:** / **Worktree:** / **Verification base ref:** / **Verification head ref:** / **Verification target path:** / **Verification target digest:**`) and reads the sidecar on demand for the complete diff stat. A worker that cannot confirm its analysis ran against that worktree's delivered diff MUST record a `tool-failure`.
   - **Verdict vocabulary**: Section 7 (`Final Verdict`) MUST include a `Verdict Token` field whose value is exactly one of `accepted`, `conditional-accept`, or `blocked`. `conditional-accept` requires an explicit, exhaustive list of conditions; ambiguous verdicts ("looks good", "mostly ready") are not allowed. Each condition MUST be recorded as a row in the **Conditional Acceptance Conditions** deliverable (`id` `CA-NNN`, `condition`, `evidenceRequired`, `blocksReleaseHandoff`). `blocksReleaseHandoff` is a gate, not a note: `false` means this condition alone would not stop the release, and a `conditional-accept` whose conditions are all `false` may route to `release-handoff` (the conditions travel into the PR body as unresolved items). Declare `true` for anything that must be settled before release. The validator enforces verdict↔deliverable consistency: `accepted` ⇒ zero acceptance blockers, `blocked` ⇒ at least one, `conditional-accept` ⇒ at least one condition, and a `release-handoff` routing recommendation is allowed only when the verdict is release-ready by `okstra_ctl.release_gate.release_handoff_allowed`. **Any Acceptance Blocker therefore forces the verdict off `accepted` (to `conditional-accept` or `blocked`); the gates below cite this rule instead of restating the arithmetic.**

package/runtime/python/okstra_ctl/phases/implementation/boundary.json

@@ -7,7 +7,7 @@
     "production credentials, deploy commands, infra mutation (`terraform apply`, `kubectl apply` against non-local cluster, etc.)",
     "external API write calls (POST/PUT/PATCH/DELETE) to third-party services other than localhost test fixtures",
     "source edits or Bash mutations performed by any verifier role (`Antigravity verifier`, `Codex verifier`, `Claude verifier` are read-only — recommend, do not apply)",
-    "dispatching parallel sub-agents beyond the required worker roster",
+    "dispatching parallel sub-agents beyond the run's selected roster",
     "silent scope expansion: every file edited outside the approved plan list MUST appear in the `Out-of-plan edits` block with rationale",
     "leaving placeholders such as TBD / TODO / \"implement later\" / \"handle edge cases\" in newly-added lines of this run (check via `git diff <base>..HEAD | grep -E '^\\+[^+].*\\b(TBD|TODO|FIXME|XXX|implement later|handle edge cases|similar to|placeholder)\\b'`; pre-existing strings in untouched regions are out of scope)",
     "lead substituting its own verdict when every verifier present in the resolved roster returned a non-result terminal status (`timeout`/`error`/`not-run`); in that case the run MUST end as `blocked` with routing recommendation back to `error-analysis`, never with a lead-only verdict",

package/runtime/python/okstra_ctl/phases/implementation/profile.json

@@ -14,7 +14,7 @@
       "mode": "static",
       "roleId": "verifier",
       "dutyId": "implementation-verifier",
-      "min": 2,
+      "min": 1,
       "recommended": 2,
       "max": 3
     },

package/runtime/python/okstra_ctl/phases/implementation/profile.md

@@ -3,12 +3,6 @@
 - Purpose: realise the approved `implementation-planning` deliverable as actual source changes, with cross-model verification, while keeping the run reversible
 - **Run-level fixed cost:** the verifier set, Phase 5.5 convergence, and the Phase 6 report-writer run exactly once per implementation run, over this run's single stage diff — never once per step.
 - **Fix run (profile carries a "Fix-Run Carry" block):** the executor's scope is the carried blocking findings plus the previous routing recommendation — it MUST NOT re-execute plan steps the previous run completed. Verifiers apply the "Fix-run incremental scope" section of `_implementation-verifier.md`; the report writer applies "Fix-run incremental authoring" in `report-writer.md`. The full validation-command re-run is NOT reduced.
-- Required workers:
-  - claude
-  - codex
-  - report-writer
-- Optional workers (opt-in via `--workers`):
-  - antigravity — when added to the roster it joins the verifier set; when omitted only the default Claude+Codex verifiers participate. `--executor antigravity` requires `antigravity` in the roster: the direct CLI demands it explicitly in `--workers`, while the wizard adds it automatically when you pick antigravity as the executor.
 - **Executor binding (resolved at run-prep time, fixed for this run):**
   - Executor display name: `{{EXECUTOR_DISPLAY_NAME}}`
   - Executor worker ID: `{{EXECUTOR_WORKER_ID}}`

package/runtime/python/okstra_ctl/phases/implementation/report_assets/implementation-input.template.md

@@ -73,7 +73,7 @@ taskType: "{{FM_TASK_TYPE}}"
 
 - `git push`, publish, deploy, migration execution, third-party write APIs, production credentials
 - Edits or Bash mutations performed by any verifier role
-- Sub-agent dispatch beyond the required worker roster
+- Sub-agent dispatch beyond the run's selected roster
 - Silent scope expansion — every file touched outside the plan's list MUST be recorded in `Out-of-plan edits` (**Enforced (declared edits only):** `_validate_out_of_plan_edits_are_real`)
 
 ## Verifier Worker Inputs

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

@@ -9,7 +9,7 @@ from .validation import (
     MAX_RANKED_OPTIONS,
     MAX_RAW_CANDIDATES_PER_ANALYSER,
     MIN_CRITERION_VALUE,
-    MIN_FEASIBLE_VOTES,
+    required_feasible_votes,
 )
 from okstra_ctl.exact_coverage import COVERAGE_VERDICT_PRECEDENCE
 
@@ -51,8 +51,9 @@ def requirement_instructions(original_requirement_ids: Sequence[str], participat
         "otherwise).",
         "A ranked option is valid only when every participating analyser "
         "supplied one feasibility vote, at least "
-        f"{MIN_FEASIBLE_VOTES} votes are `feasible`, and both `safetyBlockers` "
-        "and `unresolvedFeasibilityFacts` are empty.",
+        f"{required_feasible_votes(participating_analysers)} of them are "
+        "`feasible`, and both `safetyBlockers` and `unresolvedFeasibilityFacts` "
+        "are empty.",
         ("Classify each `unresolvedFeasibilityFacts` entry with `resolutionKind`: "
         "`user-decision` requires nonempty `clarificationRefs` linking that fact "
         "to actual C-NNN records, including answered records; `technical-verification` "

package/runtime/python/okstra_ctl/phases/implementation_option_selection/entry.py

@@ -1,9 +1,7 @@
-"""방향 비교가 필요한 요구사항과 독립 분석자 수를 확인한다."""
+"""방향 비교가 필요한 요구사항을 확인한다."""
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Sequence
-
 from okstra_ctl.prepare_error import PrepareError
 from okstra_ctl.scope_provenance import brief_end_state_id_sequence
 
@@ -14,14 +12,3 @@ def validate_brief_requirements(brief_path: Path) -> None:
             "regenerate the brief with stable end-state IDs before starting "
             "implementation-option-selection"
         )
-
-
-def validate_analyser_roster(
-    workers: Sequence[str]
-) -> None:
-    """Require independent analysis from three workers before option selection."""
-    analyser_count = sum(worker != "report-writer" for worker in workers)
-    if analyser_count < 3:
-        raise PrepareError(
-            "implementation-option-selection requires at least 3 analyser workers"
-        )

package/runtime/python/okstra_ctl/phases/implementation_option_selection/profile.json

@@ -6,7 +6,7 @@
       "mode": "static",
       "roleId": "designer",
       "dutyId": "direction-selection-worker",
-      "min": 3,
+      "min": 1,
       "recommended": 3,
       "max": 5
     },

package/runtime/python/okstra_ctl/phases/implementation_option_selection/profile.md

@@ -1,14 +1,6 @@
 # Implementation Option Selection Profile
 
 - Purpose: compare feasible implementation directions before planning, preserving a read-only record of the evidence and trade-offs that selects the direction to plan
-- Required workers:
-  - claude
-  - codex
-  - antigravity
-  - report-writer
-- Optional workers (opt-in via `--workers`):
-  - grok
-  - kimi
 {{INCLUDE:_common-contract.md}}
 - Brief consumption:
   - Apply the shared reporter-confirmation precondition exactly as written. Unresolved `intent-check:` and `conversion-block:` rows use `Blocks=next-phase`.
@@ -18,6 +10,11 @@
   - In `candidate-comparison` mode only, submit at most three candidates. A candidate must be feasible from inspected evidence, not from an assumed future change.
   - In `preselected-validation` mode, receive one preselected direction from the lead and validate its evidence, counterevidence, criterion scores, and requirement mappings, and state the same feasibility verdict with its rationale and counterevidence. The worker must not generate new candidates.
   - Do not produce detailed file lists, stage maps, execution commands, or a plan approval request.
+- Census aspects:
+  - requirement mapping: Which candidate or preselected direction satisfies this requirement, and how?
+  - requirement support: Which inspected evidence supports that mapping?
+  - requirement counter-evidence: What is the strongest evidence against that mapping?
+  - task feasibility: Is each candidate feasible, not feasible, or uncertain on inspected evidence?
 - Pre-selection context exploration:
   - In `candidate-comparison` mode, inspect the code paths, interfaces, tests, and constraints needed to distinguish candidates before assigning scores.
   - In `preselected-validation` mode, inspect the code paths, interfaces, tests, and constraints needed to validate the one preselected direction.