okstra 0.205.1 → 0.206.1

package/runtime/python/okstra_ctl/phases/catalog.py

@@ -0,0 +1,260 @@
+"""12개 작업 유형과 단계 디렉터리의 고정 대응.
+
+이 모듈을 import 해도 단계 실행 모듈은 적재되지 않는다. 경로는 문자열로만
+계산한다. 외부 설정에서 모듈 경로를 받아 실행하지 않는다.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from ..asset_roots import walk_to_asset_root
+
+
+class PhaseAssetError(ValueError):
+    """단계 자산을 요청한 실행 루트에서 해석할 수 없다."""
+
+
+class UnknownTaskType(PhaseAssetError):
+    """등록표에 없는 작업 유형이다."""
+
+
+@dataclass(frozen=True)
+class PhaseRecord:
+    """외부 작업 유형 하나와 그 코드 위치."""
+
+    task_type: str
+    package_name: str
+    migrated: bool
+    view_module: str
+    view_function: str
+
+
+def _view(package_name: str, function: str, *, phase_package: bool) -> tuple[str, str]:
+    if phase_package:
+        return f"okstra_ctl.phases.{package_name}.report", function
+    return f"okstra_ctl.report_html.view_models.{package_name}", function
+
+
+def _record(
+    task_type: str,
+    package_name: str,
+    migrated: bool,
+    view_function: str,
+) -> PhaseRecord:
+    module, function = _view(package_name, view_function, phase_package=migrated)
+    return PhaseRecord(task_type, package_name, migrated, module, function)
+
+
+# 이전되지 않은 단계는 기존 ``prompts/profiles`` 위치를 명시적으로 쓴다.
+# 이전된 단계는 okstra_ctl 패키지를 품은 루트에서 단계 디렉터리만 본다. 그
+# 루트의 단계 파일이 없어도 prompts/profiles 사본으로 넘어가지 않는다. 패키지를
+# 품지 않은 루트는 그 루트의 prompts/profiles 사본이 자료다 (``profile_markdown``).
+PHASES: tuple[PhaseRecord, ...] = (
+    _record("requirements-discovery", "requirements_discovery", True, "build_requirements_discovery_view"),
+    _record("improvement-discovery", "improvement_discovery", True, "build_improvement_discovery_view"),
+    _record("project-analysis", "project_analysis", True, "build_project_analysis_view"),
+    _record("feature-analysis", "feature_analysis", True, "build_feature_analysis_view"),
+    _record("change-impact-analysis", "change_impact_analysis", True, "build_change_impact_analysis_view"),
+    _record("error-analysis", "error_analysis", True, "build_error_analysis_view"),
+    _record("technical-verification", "technical_verification", True, "build_technical_verification_view"),
+    _record(
+        "implementation-option-selection",
+        "implementation_option_selection",
+        True,
+        "build_implementation_option_selection_view",
+    ),
+    _record("implementation-planning", "implementation_planning", True, "build_implementation_planning_view"),
+    _record("implementation", "implementation", True, "build_implementation_view"),
+    _record("final-verification", "final_verification", True, "build_final_verification_view"),
+    _record("release-handoff", "release_handoff", True, "build_release_handoff_view"),
+)
+
+_BY_TASK_TYPE = {row.task_type: row for row in PHASES}
+
+# 같은 자산 루트 안에서만 고른다. 다른 설치본으로 넘어가는 순서가 아니다.
+_PACKAGE_RELATIVES = (
+    ("scripts", "okstra_ctl"),
+    ("python", "okstra_ctl"),
+    ("lib", "python", "okstra_ctl"),
+)
+
+
+def phase_record(task_type: str) -> PhaseRecord:
+    try:
+        return _BY_TASK_TYPE[task_type]
+    except KeyError as exc:
+        raise UnknownTaskType(f"unknown task type: {task_type}") from exc
+
+
+def task_types() -> tuple[str, ...]:
+    return tuple(row.task_type for row in PHASES)
+
+
+def is_migrated(task_type: str) -> bool:
+    """단계 패키지로 옮겨진 작업 유형인지. 등록표에 없는 이름은 False."""
+    record = _BY_TASK_TYPE.get(task_type)
+    return record is not None and record.migrated
+
+
+def logical_profile_markdown(task_type: str) -> str:
+    """실행 자료에 기록되는 프로필 계약 경로. 물리 파일 이름과 다를 수 있다."""
+    phase_record(task_type)
+    return f"prompts/profiles/{task_type}.md"
+
+
+def package_root(asset_root: Path) -> Path | None:
+    """``asset_root`` 안의 okstra_ctl 패키지. 없으면 None, 둘 이상이면 오류."""
+    found = [
+        asset_root.joinpath(*parts)
+        for parts in _PACKAGE_RELATIVES
+        if (asset_root.joinpath(*parts) / "__init__.py").is_file()
+    ]
+    if not found:
+        return None
+    if len(found) > 1:
+        joined = ", ".join(str(path) for path in found)
+        raise PhaseAssetError(f"ambiguous okstra_ctl package under {asset_root}: {joined}")
+    return found[0]
+
+
+def profile_markdown(asset_root: Path, task_type: str) -> Path:
+    """요청한 실행 루트에서 프로필 Markdown 의 물리 경로."""
+    record = phase_record(task_type)
+    legacy = asset_root / "prompts" / "profiles" / f"{task_type}.md"
+    if not record.migrated:
+        return legacy
+    root = package_root(asset_root)
+    # 요청한 루트가 런타임 패키지를 품지 않으면 그 루트에 있는 프로필이 그 실행의
+    # 자료다. 패키지를 품은 루트에서 단계 파일이 없을 때는 아래 경로를 그대로
+    # 돌려, 같은 루트의 prompts/profiles 사본으로 넘어가지 않는다.
+    if root is None:
+        return legacy
+    return root / "phases" / record.package_name / "profile.md"
+
+
+def profile_contract(asset_root: Path, task_type: str) -> Path:
+    return profile_markdown(asset_root, task_type).with_suffix(".json")
+
+
+def view_builder_import(task_type: str) -> tuple[str, str]:
+    """표시 함수의 모듈과 이름. import 는 호출자가 선택 시점에 한다."""
+    record = phase_record(task_type)
+    return record.view_module, record.view_function
+
+
+def migrated_report_template(asset_root: Path, logical_name: str) -> Path | None:
+    """이전된 보고서 본문의 물리 경로.
+
+    이 논리 이름이 단계 소유가 아니면 None 이다. ``asset_root`` 가 okstra_ctl
+    패키지를 품지 않을 때도 None 이며, 호출자는 그 루트의 ``templates/reports``
+    사본을 읽는다 (``profile_markdown`` 과 같은 규칙).
+    """
+    for record in PHASES:
+        if not record.migrated:
+            continue
+        filename = _report_template_filename(record.task_type, logical_name)
+        if filename is None:
+            continue
+        root = package_root(asset_root)
+        if root is None:
+            return None
+        return root / "phases" / record.package_name / "report_assets" / filename
+    return None
+
+
+def resolve_include(profile_path: Path, target_name: str) -> Path:
+    """포함 대상을 찾는다.
+
+    이전되지 않은 프로필은 자기 부모 디렉터리 기준을 유지한다. 이전된
+    ``profile.md`` 는 그 파일을 품은 자산 루트의 논리 경로로 찾고, 다른
+    설치본의 ``OKSTRA_HOME`` 으로 넘어가지 않는다. 공유 조각과 같은 이름의
+    단계 전용 파일이 함께 있으면 어느 쪽인지 정할 수 없으므로 오류다.
+    """
+    name = target_name.strip()
+    if not name or name.startswith("/") or ".." in Path(name).parts:
+        raise PhaseAssetError(f"invalid profile include target: {target_name!r}")
+    if not _is_migrated_profile(profile_path):
+        return profile_path.parent / name
+    asset_root = _asset_root_containing(profile_path)
+    if name.startswith("prompts/"):
+        return asset_root / name
+    shared = asset_root / "prompts" / "profiles" / Path(name).name
+    local = profile_path.parent / name
+    if shared.is_file() and local.is_file():
+        raise PhaseAssetError(
+            f"profile include {name!r} exists both as a shared fragment ({shared}) "
+            f"and beside the phase profile ({local})"
+        )
+    if local.is_file():
+        return local
+    return shared
+
+
+def _is_migrated_profile(profile_path: Path) -> bool:
+    if profile_path.name != "profile.md" or profile_path.parent.parent.name != "phases":
+        return False
+    package_name = profile_path.parent.name
+    return any(row.migrated and row.package_name == package_name for row in PHASES)
+
+
+def _asset_root_containing(start: Path) -> Path:
+    root = walk_to_asset_root(("prompts", "profiles"), start=start, is_present=Path.is_dir)
+    if root is None:
+        raise PhaseAssetError(
+            f"could not locate prompts/profiles while resolving an include from {start}"
+        )
+    return root
+
+
+def _report_template_filename(task_type: str, logical_name: str) -> str | None:
+    if task_type == "requirements-discovery" and logical_name == "fan-out-unit.template.md":
+        return logical_name
+    if logical_name == f"{task_type}-input.template.md":
+        return logical_name
+    if logical_name == f"html/tasks/{task_type}.template.html":
+        return f"{task_type}.template.html"
+    if logical_name == f"md/tasks/{task_type}.template.md":
+        return f"{task_type}.template.md"
+    return None
+
+
+
+def host_rules(asset_root: Path, task_type: str) -> Path:
+    """선택된 단계의 호스트 지침을 같은 자산 루트에서 찾는다."""
+    record = phase_record(task_type)
+    root = package_root(asset_root) if record.migrated else None
+    if root is not None:
+        return root / "phases" / record.package_name / "host-rules.md"
+    return asset_root / "prompts" / "host-orchestration" / f"{task_type}.md"
+
+
+def profile_sidecar(asset_root: Path, logical_name: str) -> Path:
+    """동결 프로필에 남은 구현 보조 지침 경로도 현재 정본으로 해석한다."""
+    path = Path(logical_name)
+    if logical_name in {
+        "prompts/lead/plan-body-verification.md",
+        "scripts/okstra_ctl/phases/implementation_planning/instructions/plan-body-verification.md",
+    }:
+        root = package_root(asset_root)
+        if root is not None:
+            return root / "phases" / "implementation_planning" / "instructions" / path.name
+    if path.parent in {
+        Path("prompts/profiles"),
+        Path("scripts/okstra_ctl/phases/implementation/instructions"),
+    } and path.name in {
+        "_implementation-executor.md", "_implementation-verifier.md",
+        "_implementation-deliverable.md", "_implementation-diff-review.md",
+        "_implementation-self-check.md",
+    }:
+        root = package_root(asset_root)
+        if root is not None:
+            return root / "phases" / "implementation" / "instructions" / path.name
+    return asset_root / path
+
+
+def phase_boundary(asset_root: Path, task_type: str) -> Path | None:
+    """주어진 자산 루트 안에 있는 단계 경계 자원의 경로."""
+    record = phase_record(task_type)
+    root = package_root(asset_root)
+    return root / "phases" / record.package_name / "boundary.json" if root else None

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

@@ -0,0 +1,11 @@
+{
+  "allowed": "  - preserved behavior, impacted items, and dependency propagation\n  - test and operational impact\n  - constraints and open decisions passed to implementation-planning\n",
+  "forbidden": [
+    "source or configuration edits",
+    "tests, builds, migrations, or deployments",
+    "starting any other lifecycle phase inside this run",
+    "implementation alternatives",
+    "file change specifications",
+    "stepwise execution plans"
+  ]
+}

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

@@ -0,0 +1,39 @@
+"""Feature-baseline input steps for change impact analysis."""
+from __future__ import annotations
+
+from typing import Optional
+
+from okstra_ctl.wizard.ids import S_FEATURE_EVIDENCE, S_FEATURE_EVIDENCE_PICK
+from okstra_ctl.wizard.state import Prompt, WizardState
+from okstra_ctl.wizard.prompts import _p
+from okstra_ctl.wizard.steps_analysis import (
+    _accept_analysis_evidence,
+    _build_analysis_evidence_pick,
+    _submit_analysis_evidence_pick,
+)
+
+
+def _build_feature_evidence_pick(state: WizardState) -> Prompt:
+    return _build_analysis_evidence_pick(
+        state, step=S_FEATURE_EVIDENCE_PICK, relation="feature-baseline"
+    )
+
+
+def _submit_feature_evidence_pick(state: WizardState, value: str) -> Optional[str]:
+    return _submit_analysis_evidence_pick(
+        state, value, step=S_FEATURE_EVIDENCE_PICK,
+        field_name="feature_evidence_path",
+        pending_name="feature_evidence_pending_text",
+    )
+
+
+def _build_feature_evidence(state: WizardState) -> Prompt:
+    t = _p(state.workspace_root, S_FEATURE_EVIDENCE)
+    return Prompt(step=S_FEATURE_EVIDENCE, kind="text", label=t["label"],
+                  echo_template=t["echo_template"])
+
+
+def _submit_feature_evidence(state: WizardState, value: str) -> Optional[str]:
+    candidate = _accept_analysis_evidence(state, value, "feature_evidence_path")
+    state.feature_evidence_pending_text = False
+    return f"feature-evidence: {candidate.report_path}"

package/runtime/python/okstra_ctl/{report_html/view_models/change_impact_analysis.py → phases/change_impact_analysis/report.py}

@@ -1,9 +1,9 @@
 """Human-first change-impact-analysis view model."""
 from __future__ import annotations
 
-from ..common import analysis_review_ids, evidence_index
-from ..models import HumanReportView, VisualEdge, VisualNode
-from ..visualizations import flow_figure
+from okstra_ctl.report_html.common import analysis_review_ids, evidence_index
+from okstra_ctl.report_html.models import HumanReportView, VisualEdge, VisualNode
+from okstra_ctl.report_html.visualizations import flow_figure
 
 # Record fields this template anchors as `id-<row id>` (see
 # `HumanReportView.anchored_fields`); ids elsewhere land in the ledger.

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

@@ -0,0 +1,26 @@
+# Change impact analysis phase
+
+## Purpose and boundaries
+
+This phase maps a proposed change's preserved behavior, affected and unaffected boundaries, dependency propagation, tests and operational impact. It records planning constraints and open decisions without producing an execution plan. `profile.md` owns these analysis instructions and the adversarial convergence setting.
+
+`entry.py` owns the feature-baseline selection and text-entry handlers. The common wizard registry preserves the existing question order: feature evidence before project evidence. Shared analysis-input code retains evidence ownership, review status, freshness, relation and path checks. The CLI evidence arguments and run artifacts are unchanged.
+
+## Result and validation
+
+`validation.py` owns the current-code evidence collection names and the rule limiting `planningInputs` to constraints and unknowns. `validators/validate_analysis_report.py` remains the common assembly point for phase semantics, current-code evidence, frozen input snapshots, worker completion and review-resolution checks. Evidence path predicates remain in `analysis_scope.py`.
+
+`report.py` builds the impact graph and human view from `changeImpactAnalysis`. The input, Markdown and HTML templates live in `report_assets/`. Common schemas, analysis-review controls and report routing remain shared. The common lead routing policy chooses the next phase; the profile describes facts and constraints for that decision.
+
+## Guarantees
+
+| ID | Guarantee | Enforcement |
+|---|---|---|
+| CI-1 | Planning inputs contain constraints and unknowns only. | `scripts/okstra_ctl/phases/change_impact_analysis/validation.py::validate_change_impact_semantics` |
+| CI-2 | Impact items require current-code evidence within the included scope. | `validators/validate_analysis_report.py::_validate_all_current_code_evidence`, `scripts/okstra_ctl/phases/change_impact_analysis/tests/test_change_impact_analysis_validation.py::test_change_impact_item_requires_current_code_evidence` |
+| CI-3 | The wizard collects feature evidence before project evidence. | `tests/domain/wizard/test_analysis_inputs.py::test_change_impact_collects_feature_then_project_evidence` |
+| CI-4 | Common validation checks the frozen analysis source, target and evidence snapshot. | `validators/validate_analysis_report.py::validate_analysis_snapshot` |
+
+## Tests
+
+The phase tests retain the existing impact-evidence and forbidden-planning-field assertions through the common report validator. Shared wizard tests cover selecting, skipping, reusing and editing evidence. Shared schema, report-assembly and rendering tests cover the existing report contract and views.

package/runtime/python/okstra_ctl/phases/change_impact_analysis/validation.py

@@ -0,0 +1,23 @@
+"""Change impact content boundaries; analysis evidence stays shared."""
+from __future__ import annotations
+
+EVIDENCE_COLLECTIONS = (
+    "preservedBehaviors",
+    "impactItems",
+    "dependencyBlastRadius",
+    "testImpact",
+    "operationalImpact",
+)
+
+
+def validate_change_impact_semantics(data: dict, errors: list[str]) -> None:
+    analysis = data.get("changeImpactAnalysis") or {}
+    allowed = {"constraint", "unknown"}
+    for index, row in enumerate(analysis.get("planningInputs") or []):
+        if not isinstance(row, dict):
+            continue
+        for field in sorted(set(row) - allowed):
+            errors.append(
+                f"changeImpactAnalysis.planningInputs[{index}] forbids `{field}`; "
+                "planning inputs may contain constraints and unknowns only"
+            )

package/runtime/python/okstra_ctl/phases/error_analysis/__init__.py

@@ -0,0 +1 @@
+"""오류 분석 단계의 진단 규칙과 자원."""

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

@@ -0,0 +1,9 @@
+{
+  "allowed": "  - symptom and trigger evidence\n  - root-cause hypotheses with supporting citations\n  - reproduction gaps and missing observability\n  - validation paths to confirm or refute hypotheses\n  - one endStateCoverage row per brief end-state id (this phase authors no goal of its own)",
+  "forbidden": [
+    "source code edits, refactors, or fix attempts",
+    "implementation design or planning artifacts",
+    "executing builds, migrations, deployments, or any state-mutating command",
+    "starting `implementation-planning` or `implementation` inside this run (each must be a separate run, and `implementation` additionally requires an approved `implementation-planning` deliverable)"
+  ]
+}

package/runtime/{prompts/profiles/error-analysis.md → python/okstra_ctl/phases/error_analysis/profile.md}

@@ -25,10 +25,10 @@
   - **Falsifiable cause candidates:** every root-cause candidate must include supporting evidence, the strongest falsifying evidence checked, confidence, and the next diagnostic action that would disprove it. A candidate that cannot be falsified is too vague for this phase.
   - **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. If the cause is credible, recommend `implementation-option-selection` with the verified evidence; if the cause is still unclear, recommend another `error-analysis` run with the next diagnostic. The lead's Phase Routing settles the next phase.
+  - **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.
 - 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.
-  - A route to `implementation-option-selection` requires a credible leading cause referenced by `routing.leadingCauseId` and `begin-option-selection` as the direction. A route back to `error-analysis` requires the sharp next diagnostic and `continue-investigation` as the direction.
+  - Record the route selected by the lead through the common Phase Routing rules, its `routing.leadingCauseId`, and the matching direction.
   - Structure is enforced by `schemas/final-report-v2.0.schema.json` `$defs.ErrorAnalysis`. `validators/validate-run.py::_validate_error_analysis_consistency` enforces the cross-field values: the routing target, a `routing.leadingCauseId` that names an actual `EA-NNN` candidate, the `verdictCard.direction` / `finalVerdict.direction` pair matching that target, and exactly one `phase-continuation` row in `followUpTasks` pointing at it. The prose of `direction` and `nextStep` is not scanned for routing wording.
 - Primary focus areas:
   - symptom and trigger clarification

package/runtime/python/okstra_ctl/{report_html/view_models/error_analysis.py → phases/error_analysis/report.py}

@@ -1,17 +1,16 @@
 """Human-first error-analysis view model."""
+
 from __future__ import annotations
 
 import re
 
-from ..common import evidence_index
-from ..models import HumanReportView, VisualEdge, VisualNode
-from ..visualizations import cause_graph_figure
+from okstra_ctl.report_html.common import evidence_index
+from okstra_ctl.report_html.models import HumanReportView, VisualEdge, VisualNode
+from okstra_ctl.report_html.visualizations import cause_graph_figure
 
 # Record fields this template anchors as `id-<row id>` (see
 # `HumanReportView.anchored_fields`); ids elsewhere land in the ledger.
-ANCHORED_FIELDS = (
-    "errorAnalysis.causeCandidates",
-)
+ANCHORED_FIELDS = ("errorAnalysis.causeCandidates",)
 
 
 _LEAD_CLAUSE = re.compile(r"\s[—–-]\s|(?<=[.。!?])\s")
@@ -43,7 +42,7 @@ def _cause_node(row: dict, leading_cause_id: str) -> VisualNode:
         "candidate",
         "leading" if leading else row["confidence"],
         "",
-        note="Leading cause" if leading else f'Confidence {row["confidence"]}',
+        note="Leading cause" if leading else f"Confidence {row['confidence']}",
     )
 
 
@@ -79,7 +78,9 @@ def _cause_edges(rows: list[dict], symptom_id: str) -> tuple[VisualEdge, ...]:
 
 
 def _cause_figure(error: dict):
-    symptom = VisualNode("symptom", "Observed failure", "effect", "risk", "", note="Symptom")
+    symptom = VisualNode(
+        "symptom", "Observed failure", "effect", "risk", "", note="Symptom"
+    )
     rows = error.get("causeCandidates", [])
     leading_cause_id = (error.get("routing") or {}).get("leadingCauseId") or ""
     causes = tuple(_cause_node(row, leading_cause_id) for row in rows)

package/runtime/{templates/reports → python/okstra_ctl/phases/error_analysis/report_assets}/error-analysis-input.template.md

@@ -80,7 +80,7 @@ taskType: "{{FM_TASK_TYPE}}"
 
 > Analysers MUST NOT expand the hypothesis space or evidence collection into items listed here. If an analyser believes an excluded item is causally linked to the symptom, it is reported as a recommended follow-up analysis task in the final report — never silently merged into the current root-cause narrative. If this section is left empty, analysers treat any cause beyond what `Symptom Summary` and `Reproduction Context` describe as out of scope by default.
 
-**Enforced (delivery only):** `tests/contract/test_scope_boundary_delivery.py` pins that a filled section reaches every analysis worker through `okstra_ctl.analysis_packet` — drop it from `CANONICAL_BRIEF_SECTIONS` and every run's exclusions vanish silently. The exclusions themselves are prose and are **not** machine-checked: only the codebase-scan `out-of-scope` frontmatter is a path list, and `validators/validate_improvement_report.py` checks that one.
+**Enforced (delivery only):** `tests/contract/test_scope_boundary_delivery.py` pins that a filled section reaches every analysis worker through `okstra_ctl.analysis_packet` — drop it from `CANONICAL_BRIEF_SECTIONS` and every run's exclusions vanish silently. The exclusions themselves are prose and are **not** machine-checked: only the codebase-scan `out-of-scope` frontmatter is a path list, and `scripts/okstra_ctl/phases/improvement_discovery/validation.py` checks that one.
 
 ## Questions for Analysers
 

package/{docs/task-process/error-analysis.md → runtime/python/okstra_ctl/phases/error_analysis/spec.md}

@@ -1,5 +1,14 @@
 # error-analysis process
 
+## Guarantees
+
+| ID | Guarantee | Enforcement |
+|---|---|---|
+| EA-1 | A blocked reproduction names its blocking reason; other statuses carry an empty reason | `scripts/okstra_ctl/phases/error_analysis/validation.py::_validate_reproduction` |
+| EA-2 | Cause-chain links reference sibling candidates and reject self-links and cycles | `scripts/okstra_ctl/phases/error_analysis/tests/test_diagnosis.py::test_cause_chain_rejects_unresolvable_links` |
+| EA-3 | A selected destination agrees with the cause reference, verdict directions, and continuation row | `scripts/okstra_ctl/phases/error_analysis/validation.py::_validate_error_analysis_consistency` |
+| EA-4 | Common routing destinations match both supported report schemas | `scripts/okstra_ctl/phases/error_analysis/tests/test_diagnosis.py::test_error_routing_policy_matches_schema` |
+
 ## Index
 
 - [1. Purpose](#1-purpose)
@@ -55,7 +64,7 @@ sequenceDiagram
 
 For canonical briefs, preflight runs before worker resolution, worktree provisioning, or report creation. A brief whose `reporter-confirmations` status is `pending` stops at this point; legacy briefs keep the compatibility path.
 
-The final report records its next phase in `errorAnalysis.routing.nextTaskType`. A credible cause uses `implementation-option-selection`; continued investigation uses `error-analysis`. When report validation passes, Phase 7 projects `workflow.nextRecommendedPhase` from that one field (`scripts/okstra_ctl/next_phase.py::project`) — a `ready` pointer naming it. A report that leaves the field empty leaves the pointer `pending`; there is no static fallback that supplies a phase the report did not author.
+The final report records its next phase in `errorAnalysis.routing.nextTaskType`. The common Phase Routing guide selects the destination from the recorded cause evidence. When report validation passes, Phase 7 projects `workflow.nextRecommendedPhase` from that one field (`scripts/okstra_ctl/next_phase.py::project`) — a `ready` pointer naming it. A report that leaves the field empty leaves the pointer `pending`; there is no static fallback that supplies a phase the report did not author.
 
 ## 4. lead execution flow
 
@@ -90,14 +99,20 @@ The expected final-report content is:
 - practical next diagnostic steps
 - if there is blocking uncertainty, `## 1. Clarification Items`, usually `Blocks=next-phase`
 
-For `error-analysis`, the structured `errorAnalysis` object is the source of truth for the verbatim symptom, reproduction status, `EA-NNN` cause candidates and their counter-evidence, the next diagnostic, and routing. Its shape is enforced by the final-report schema; `validators/validate-run.py::_validate_error_analysis_consistency` enforces the cross-field values — the routing target, a `leadingCauseId` naming a real cause candidate, the two `direction` fields agreeing with that target, and the single matching `phase-continuation` follow-up row. A route to `implementation-option-selection` needs a credible referenced leading cause and `begin-option-selection`. A route back to `error-analysis` needs the sharp next diagnostic and `continue-investigation`.
+For `error-analysis`, the structured `errorAnalysis` object is the source of truth for the verbatim symptom, reproduction status, `EA-NNN` cause candidates and their counter-evidence, the next diagnostic, and routing. Its shape is enforced by the final-report schema; `validators/validate-run.py::_validate_error_analysis_consistency` enforces the cross-field values — the routing target, a `leadingCauseId` naming a real cause candidate, the two `direction` fields agreeing with that target, and the single matching `phase-continuation` follow-up row. The common Phase Routing guide owns the conditions for selecting the next phase.
 
 What is prohibited is source edit, refactor, fix attempt, implementation design artifact, and running build/migration/deploy. Deferring ambiguity that could be answered from code or logs to a user question is also a defect per the profile.
 
 ## 6. Code reviewed
 
-- [`prompts/profiles/error-analysis.md`](../../prompts/profiles/error-analysis.md)
-- [`templates/reports/error-analysis-input.template.md`](../../templates/reports/error-analysis-input.template.md)
-- [`scripts/okstra_ctl/workflow.py`](../../scripts/okstra_ctl/workflow.py)
-- [`scripts/okstra_ctl/wizard/`](../../scripts/okstra_ctl/wizard/)
-- [`prompts/lead/okstra-lead-contract.md`](../../prompts/lead/okstra-lead-contract.md)
+- [`prompts/profiles/error-analysis.md`](profile.md)
+- [`templates/reports/error-analysis-input.template.md`](report_assets/error-analysis-input.template.md)
+- [`scripts/okstra_ctl/workflow.py`](../../workflow.py)
+- [`scripts/okstra_ctl/wizard/`](../../wizard)
+- [`prompts/lead/okstra-lead-contract.md`](../../../../prompts/lead/okstra-lead-contract.md)
+
+## Phase ownership
+
+`profile.md` and `profile.json` own the diagnostic procedure and worker requirements. `validation.py` owns reproduction, cause-chain, and authored routing consistency checks. `report.py` and `report_assets/` own the diagnosis display and input template. The common lead guide `prompts/lead/phase-routing.md` owns destination selection; common evidence reading, clarification contracts, and lifecycle projection remain outside this phase. The shared 2.0 and 3.0 final-report schemas retain `$defs.ErrorAnalysis`.
+
+`tests/test_diagnosis.py` exercises diagnosis rules. The common contract suite retains workflow projection and final-report assembly tests. No additional entry or wizard module is needed: this phase uses the common brief preflight and worker-selection flow.