okstra 0.206.0 → 0.206.1

package/runtime/python/okstra_ctl/option_comparison.py

@@ -1,168 +1,6 @@
-"""구현 방향 비교 자료 — 선택 리포트 기록 하나를 채팅용 사실 묶음으로 투영한다.
-
-사용자가 방향을 고르기 전에 비교 자료를 청하면 리드는 점수표·투표표·충족
-요약을 보여 준다. 그 숫자는 전부 `implementationOptionSelection` 기록에 있고
-`weightedScore` 는 발행 시점에 재계산 값과 대조된다
-(`implementation_options.py` `_validate_option_scores`). 리드가 JSON 을 손으로
-읽고 가중 점수를 다시 계산하던 자리를 이 명령이 대신한다. 서술(도입 문장,
-방향별 요지)은 리드가 `narrative` 와 각 방향의 근거 필드로 쓴다.
-
-읽기 전용이다. 어떤 파일도 쓰지 않는다.
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from collections.abc import Mapping, Sequence
-from pathlib import Path
-from typing import Any
-
-from okstra_ctl import next_phase
-from okstra_ctl.final_report_paths import final_report_data_path
-from okstra_ctl.json_boundary import JsonBoundaryError, load_owned_object
-
-
-class OptionComparisonError(ValueError):
-    """비교 자료를 만들 수 없는 기록."""
-
-
-def _rows(value: object) -> list[Mapping[str, Any]]:
-    if not isinstance(value, Sequence) or isinstance(value, (str, bytes)):
-        return []
-    return [row for row in value if isinstance(row, Mapping)]
-
-
-def _text(value: object) -> str:
-    return value.strip() if isinstance(value, str) else ""
-
-
-def _count(value: object) -> int:
-    return len(value) if isinstance(value, Sequence) and not isinstance(value, str) else 0
-
-
-def _option(
-    option: Mapping[str, Any], recommended_id: str
-) -> dict[str, Any]:
-    coverage = option.get("coverageSummary")
-    coverage = coverage if isinstance(coverage, Mapping) else {}
-    scores = _rows(option.get("criterionScores"))
-    return {
-        "id": _text(option.get("id")),
-        "name": _text(option.get("name")),
-        "recommended": _text(option.get("id")) == recommended_id,
-        "goal": _text(option.get("goal")),
-        "coreMechanism": _text(option.get("coreMechanism")),
-        # 발행 검증이 재계산 값과 같음을 보장한 기록값이다. 다시 계산하지 않는다.
-        "weightedScore": option.get("weightedScore"),
-        "scores": {_text(row.get("criterion")): row.get("score") for row in scores},
-        "scoreRationales": {
-            _text(row.get("criterion")): _text(row.get("rationale")) for row in scores
-        },
-        "coverage": {
-            "verdict": _text(coverage.get("coverageVerdict")),
-            "coveredCount": coverage.get("coveredCount"),
-            "totalCount": coverage.get("totalCount"),
-            "requirementIds": [
-                _text(row.get("requirementId"))
-                for row in _rows(option.get("requirementCoverage"))
-                if _text(row.get("requirementId"))
-            ],
-        },
-        "safetyBlockers": _count(option.get("safetyBlockers")),
-        "unresolvedFeasibilityFacts": _count(option.get("unresolvedFeasibilityFacts")),
-        "votes": {
-            _text(vote.get("worker")): {
-                "verdict": _text(vote.get("verdict")),
-                "rationale": _text(vote.get("rationale")),
-                "counterevidence": _text(vote.get("counterevidence")),
-            }
-            for vote in _rows(option.get("feasibilityVotes"))
-            if _text(vote.get("worker"))
-        },
-    }
-
-
-def build_comparison(report_data: Mapping[str, Any]) -> dict[str, Any]:
-    """선택 리포트 기록 → 비교 자료 사실 묶음."""
-    selection = report_data.get("implementationOptionSelection")
-    if not isinstance(selection, Mapping):
-        raise OptionComparisonError(
-            "report has no implementationOptionSelection block; "
-            "pass an implementation-option-selection report record"
-        )
-    recommended_id = _text(selection.get("recommendedOptionId"))
-    options = [
-        _option(row, recommended_id) for row in _rows(selection.get("rankedOptions"))
-    ]
-    if not options:
-        raise OptionComparisonError("report ranks no direction; there is nothing to compare")
-    # 투표 열 순서는 처음 등장한 순서다 — 방향마다 같은 분석자 집합이 투표한다.
-    workers: list[str] = []
-    for option in options:
-        for worker in option["votes"]:
-            if worker not in workers:
-                workers.append(worker)
-    narrative = selection.get("userNarrative")
-    narrative = narrative if isinstance(narrative, Mapping) else {}
-    return {
-        "mode": _text(selection.get("mode")),
-        "routing": _text(selection.get("routing")),
-        "recommendedOptionId": recommended_id,
-        "criteria": [
-            {"criterion": _text(row.get("criterion")), "weight": row.get("weight")}
-            for row in _rows(selection.get("evaluationCriteria"))
-        ],
-        "workers": workers,
-        "options": options,
-        "narrative": {
-            key: _text(block.get("text"))
-            for key, block in narrative.items()
-            if isinstance(block, Mapping) and _text(block.get("text"))
-        },
-        # "남은 절차" 문단의 근거. 다음 phase 포인터와 같은 문장이다.
-        "nextStep": next_phase.project(report_data)["rationale"],
-    }
-
-
-def _load(report: Path) -> Mapping[str, Any]:
-    data_path = final_report_data_path(report)
-    try:
-        data = load_owned_object(data_path, artifact="implementation option data")
-    except (OSError, JsonBoundaryError) as exc:
-        raise OptionComparisonError(f"cannot read report record {data_path}: {exc}") from exc
-    return data
-
-
-def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        prog="okstra option-comparison",
-        description=(
-            "Print the comparison facts of an implementation-option-selection "
-            "report as JSON: criteria and weights, per-direction scores and "
-            "recorded weighted score, requirement coverage, blocker counts, "
-            "per-worker feasibility votes, the report narrative, and the next step."
-        ),
-    )
-    parser.add_argument(
-        "--report",
-        required=True,
-        help="final-report-implementation-option-selection-<seq>.data.json (a .md sibling is accepted)",
-    )
-    return parser
-
-
-def main(argv: list[str] | None = None) -> int:
-    args = build_parser().parse_args(argv)
-    try:
-        payload = build_comparison(_load(Path(args.report)))
-    except OptionComparisonError as exc:
-        print(f"option-comparison: {exc}", file=sys.stderr)
-        return 2
-    json.dump(payload, sys.stdout, ensure_ascii=False, indent=2)
-    sys.stdout.write("\n")
-    return 0
+"""기존 명령 이름을 단계의 실행 진입점으로 연결한다."""
+from okstra_ctl.phases.implementation_option_selection.comparison import main
 
 
 if __name__ == "__main__":
-    sys.exit(main())
+    raise SystemExit(main())

package/runtime/python/okstra_ctl/option_votes.py

@@ -1,194 +1,6 @@
-"""전원 투표만 모자란 구현 후보와, 그 표를 받아야 할 분석자를 낸다.
-
-`implementation-option-selection` 의 1라운드는 설계자들이 병렬로 돌아 서로의
-후보를 보지 못한다. 그래서 자기가 낸 후보에만 실현 가능성 표를 남기고, 병합된
-집합에는 분석자마다 다른 구멍이 생긴다. 유효성 규칙은 전원 투표를 요구하므로
-(`implementation_options._validate_option_feasibility`) 그런 후보는 순위표에
-오르지 못하고, 남는 후보가 하나도 없으면 run 이 `routing: blocked` 로 끝난다 —
-실측(2026-09-10, dev-10629-4): 설계자 3명 로스터에서 IO-001·IO-002·IO-003 이
-각각 `feasible` 2표를 받고도 빠진 분석자가 하나씩 달라 전부 탈락했다.
-
-거절은 그 상태를 알려 줄 뿐 메우지 못한다. 이 명령이 앞으로 가는 길이다:
-표만 모자란 후보를 세고, 어느 분석자에게 어떤 후보를 부쳐야 하는지 말한다.
-재검증(reverify) 라운드는 주장을 반박하는 라운드이지 후보에 표를 남기는
-라운드가 아니므로, 그 구멍을 메우는 디스패치는 리드가 이 목록을 보고 연다.
-
-읽는 자리는 두 가지다. 조립 전이면 작성자 서사(`--narrative`), 이미 발행된
-run 이면 리포트 레코드(`--report`). 로스터는 task-manifest 의
-`recommendedWorkers` 에서 `report-writer` 를 뺀 것이고, 그것이 검증기가
-`participating analysers` 로 쓰는 값과 같은 정의다(`validators/validate-run.py`).
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from collections.abc import Mapping
-from pathlib import Path
-from typing import Any
-
-from okstra_ctl.final_report_schema import load_schema_version
-from okstra_ctl.implementation_options import VoteGap, vote_gaps
-from okstra_ctl.json_boundary import JsonBoundaryError, load_owned_object
-from okstra_ctl.report_contract import CURRENT_REPORT_SCHEMA_VERSION
-from okstra_ctl.report_narrative import parse_narrative_structure
-
-
-class OptionVotesError(ValueError):
-    """투표 구멍을 셀 입력이 없거나 읽히지 않는다."""
-
-
-def _record_from_report(path: Path) -> dict[str, Any]:
-    try:
-        return load_owned_object(path, artifact="final-report data.json")
-    except (JsonBoundaryError, OSError) as exc:
-        raise OptionVotesError(f"report record is unreadable: {exc}") from exc
-
-
-def _record_from_narrative(path: Path) -> dict[str, Any]:
-    """작성자 서사를 레코드 모양으로 읽는다.
-
-    값 결함은 무시한다 — 교정 원장이 고칠 자리이고, 표 구멍을 세는 데에는
-    후보 id 와 `feasibilityVotes` 만 있으면 된다. 여기서 서사 전체를 거절하면
-    아직 교정 중인 run 은 이 명령을 쓸 수 없다.
-    """
-    try:
-        markdown = path.read_text(encoding="utf-8")
-    except OSError as exc:
-        raise OptionVotesError(f"narrative is unreadable: {exc}") from exc
-    schema = load_schema_version(CURRENT_REPORT_SCHEMA_VERSION)
-    record, _defects = parse_narrative_structure(markdown, schema)
-    return record
-
-
-def participating_analysers(manifest_path: Path) -> tuple[str, ...]:
-    try:
-        manifest = load_owned_object(manifest_path, artifact="task-manifest")
-    except (JsonBoundaryError, OSError) as exc:
-        raise OptionVotesError(f"task manifest is unreadable: {exc}") from exc
-    roster = manifest.get("recommendedWorkers")
-    if not isinstance(roster, list):
-        raise OptionVotesError("task manifest has no recommendedWorkers roster")
-    return tuple(
-        str(worker) for worker in roster if str(worker) != "report-writer"
-    )
-
-
-def _selection(record: Mapping[str, Any]) -> Mapping[str, Any]:
-    selection = record.get("implementationOptionSelection")
-    if not isinstance(selection, Mapping):
-        raise OptionVotesError(
-            "the source has no implementationOptionSelection block — "
-            "this command reads an implementation-option-selection run"
-        )
-    return selection
-
-
-def _dispatch_lines(gaps: list[VoteGap]) -> list[str]:
-    """분석자별로 부칠 후보 목록. 디스패치 단위가 분석자이기 때문이다."""
-    by_analyser: dict[str, list[str]] = {}
-    for gap in gaps:
-        for analyser in gap.missing:
-            by_analyser.setdefault(analyser, []).append(gap.option_id)
-    return [
-        f"  {analyser}: {', '.join(options)}"
-        for analyser, options in sorted(by_analyser.items())
-    ]
-
-
-def _render(gaps: list[VoteGap]) -> str:
-    if not gaps:
-        return (
-            "No candidate is short of votes alone. A blocked run here is "
-            "blocked by something a vote cannot settle — safety blockers, "
-            "unresolved feasibility facts, or too few feasible verdicts."
-        )
-    lines = [
-        f"{len(gaps)} candidate(s) need only the missing feasibility votes:",
-        "",
-    ]
-    lines += [
-        f"  {gap.option_id}: {gap.feasible_votes} feasible so far, "
-        f"missing {', '.join(gap.missing)}"
-        for gap in gaps
-    ]
-    lines += ["", "Dispatch one vote-completion assignment per analyser:"]
-    lines += _dispatch_lines(gaps)
-    lines += [
-        "",
-        "Each assignment asks that analyser for its own feasibility verdict, "
-        "rationale, and counterevidence on the named candidate — nothing else. "
-        "It generates no candidate, so the run stays in `candidate-comparison` "
-        "mode; `preselected-validation` is a whole-run mode that would collapse "
-        "the comparison to one direction.",
-    ]
-    return "\n".join(lines)
-
-
-def _gaps(args: argparse.Namespace) -> int:
-    if bool(args.report) == bool(args.narrative):
-        raise OptionVotesError("pass exactly one of --report or --narrative")
-    record = (
-        _record_from_report(args.report)
-        if args.report
-        else _record_from_narrative(args.narrative)
-    )
-    gaps = vote_gaps(
-        _selection(record), participating_analysers(args.task_manifest)
-    )
-    if args.json:
-        print(json.dumps(
-            {
-                "gaps": [
-                    {
-                        "optionId": gap.option_id,
-                        "missing": list(gap.missing),
-                        "feasibleVotes": gap.feasible_votes,
-                    }
-                    for gap in gaps
-                ]
-            },
-            ensure_ascii=False,
-            indent=2,
-        ))
-    else:
-        print(_render(gaps))
-    return 0
-
-
-_CLI_DESCRIPTION = (
-    "Report the implementation candidates that only lack feasibility votes, "
-    "and which analyser owes each one."
-)
-
-
-def _parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        description=_CLI_DESCRIPTION, prog="okstra option-votes"
-    )
-    subparsers = parser.add_subparsers(dest="command", required=True)
-    gaps_parser = subparsers.add_parser("gaps")
-    gaps_parser.add_argument(
-        "--task-manifest", type=Path, required=True,
-        help="the task's task-manifest.json — its roster names the analysers")
-    gaps_parser.add_argument(
-        "--report", type=Path,
-        help="a published final-report `.data.json`")
-    gaps_parser.add_argument(
-        "--narrative", type=Path,
-        help="the report writer's narrative markdown, before assembly")
-    gaps_parser.add_argument("--json", action="store_true")
-    return parser
-
-
-def main(argv: list[str] | None = None) -> int:
-    args = _parser().parse_args(argv)
-    try:
-        return _gaps(args)
-    except OptionVotesError as exc:
-        print(f"okstra option-votes: {exc}", file=sys.stderr)
-        return 1
+"""기존 명령 이름을 단계의 실행 진입점으로 연결한다."""
+from okstra_ctl.phases.implementation_option_selection.votes import main
 
 
 if __name__ == "__main__":
-    raise SystemExit(main(sys.argv[1:]))
+    raise SystemExit(main())

package/runtime/python/okstra_ctl/paths.py

@@ -29,6 +29,8 @@ from okstra_project.dirs import (
 )
 from okstra_project.slug import slugify
 
+from .asset_roots import walk_to_asset_root as _walk_to_asset_root
+
 __all__ = [
     "OKSTRA_RELATIVE",
     "TASKS_RELATIVE",
@@ -103,11 +105,9 @@ def walk_to_asset_root(
     override. A caller that must stay inside the tree it started from (a phase
     profile resolving its includes) calls this directly.
     """
-    here = Path(start or __file__).resolve()
-    for parent in [here, *here.parents]:
-        if is_present(parent.joinpath(*relative)):
-            return parent
-    return None
+    return _walk_to_asset_root(
+        relative, start=Path(start or __file__), is_present=is_present,
+    )
 
 
 _STAGED_TASK_TYPES = ("implementation", "final-verification")
@@ -623,6 +623,8 @@ def compute_run_paths(
     incremental_decision = run_state / f"incremental-decision-{task_type_segment}-{seqs['state']}.json"
 
     run_errors_log = run_logs / f"errors-{task_type_segment}-{seqs['state']}.jsonl"
+    from .phases.catalog import profile_sidecar
+
     runtime_home = okstra_home()
 
     claude_worker_errors_sidecar = worker_results / f"claude-worker-errors{suffixes['worker_results']}.json"
@@ -680,7 +682,7 @@ def compute_run_paths(
             runtime_home / "prompts" / "lead" / "convergence.md"
         ),
         "OKSTRA_PLAN_BODY_VERIFICATION_PATH": str(
-            runtime_home / "prompts" / "lead" / "plan-body-verification.md"
+            profile_sidecar(runtime_home, "prompts/lead/plan-body-verification.md")
         ),
         "OKSTRA_REPORT_WRITER_PATH": str(
             runtime_home / "prompts" / "lead" / "report-writer.md"

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

@@ -8,7 +8,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from pathlib import Path
 
-from ..paths import walk_to_asset_root
+from ..asset_roots import walk_to_asset_root
 
 
 class PhaseAssetError(ValueError):
@@ -51,23 +51,23 @@ def _record(
 # 루트의 단계 파일이 없어도 prompts/profiles 사본으로 넘어가지 않는다. 패키지를
 # 품지 않은 루트는 그 루트의 prompts/profiles 사본이 자료다 (``profile_markdown``).
 PHASES: tuple[PhaseRecord, ...] = (
-    _record("requirements-discovery", "requirements_discovery", False, "build_requirements_discovery_view"),
-    _record("improvement-discovery", "improvement_discovery", False, "build_improvement_discovery_view"),
-    _record("project-analysis", "project_analysis", False, "build_project_analysis_view"),
-    _record("feature-analysis", "feature_analysis", False, "build_feature_analysis_view"),
-    _record("change-impact-analysis", "change_impact_analysis", False, "build_change_impact_analysis_view"),
-    _record("error-analysis", "error_analysis", False, "build_error_analysis_view"),
-    _record("technical-verification", "technical_verification", False, "build_technical_verification_view"),
+    _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",
-        False,
+        True,
         "build_implementation_option_selection_view",
     ),
-    _record("implementation-planning", "implementation_planning", False, "build_implementation_planning_view"),
-    _record("implementation", "implementation", False, "build_implementation_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", False, "build_release_handoff_view"),
+    _record("release-handoff", "release_handoff", True, "build_release_handoff_view"),
 )
 
 _BY_TASK_TYPE = {row.task_type: row for row in PHASES}
@@ -208,9 +208,53 @@ def _asset_root_containing(start: Path) -> Path:
 
 
 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