okstra 0.171.0 → 0.173.0

package/runtime/python/okstra_ctl/agent_activity.py

@@ -0,0 +1,306 @@
+"""Record lead activity and project it into final-report data."""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+import tempfile
+from collections.abc import Mapping, Sequence
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from okstra_ctl.lead_events import (
+    LeadEvent,
+    append_activity_event,
+    read_lead_events,
+)
+from okstra_ctl.worker_audit_ledger import (
+    EvidenceCommand,
+    parse_evidence_commands,
+    read_evidence_commands,
+)
+
+
+ACTIVITY_KINDS = frozenset({
+    "worker-dispatched",
+    "worker-completed",
+    "verification-round-completed",
+    "self-fix-applied",
+    "user-decision-required",
+    "user-decision-evaluated",
+})
+ACTIVITY_OUTCOMES = frozenset({
+    "pending",
+    "completed",
+    "failed",
+    "blocked",
+    "resolved",
+})
+ACTIVITY_FIELDS = (
+    "activityId",
+    "kind",
+    "agent",
+    "summary",
+    "planItemIds",
+    "resultPath",
+    "commands",
+    "evidenceRefs",
+    "outcome",
+)
+_ACTIVITY_ID_RE = re.compile(r"^A-(\d{3,})$")
+
+
+class ActivityProjectionError(ValueError):
+    """Raised when activity cannot be recorded or projected safely."""
+
+
+def _read_json_object(path: Path) -> dict[str, Any]:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise ActivityProjectionError(f"cannot read JSON object {path}: {exc}") from exc
+    if not isinstance(payload, dict):
+        raise ActivityProjectionError(f"JSON value must be an object: {path}")
+    return payload
+
+
+def _resolve_project_path(project_root: Path, value: str | Path) -> Path:
+    path = Path(value)
+    return path if path.is_absolute() else project_root / path
+
+
+def _require_string(payload: Mapping[str, Any], key: str) -> str:
+    value = payload.get(key)
+    if not isinstance(value, str) or not value.strip():
+        raise ActivityProjectionError(f"required string missing: {key}")
+    return value.strip()
+
+
+def _manifest_run_seq(manifest: Mapping[str, Any]) -> str:
+    sequences = manifest.get("runSequencesByCategory")
+    if not isinstance(sequences, Mapping):
+        raise ActivityProjectionError(
+            "run manifest has no runSequencesByCategory object"
+        )
+    return _require_string(sequences, "manifests")
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _activity_row(event: LeadEvent) -> dict[str, Any]:
+    details = dict(event.details)
+    missing = [key for key in ACTIVITY_FIELDS if key not in details]
+    if missing:
+        raise ActivityProjectionError(
+            "activity event is missing " + ", ".join(missing)
+        )
+    if details["kind"] not in ACTIVITY_KINDS:
+        raise ActivityProjectionError(
+            f"unsupported activity kind: {details['kind']}"
+        )
+    if details["outcome"] not in ACTIVITY_OUTCOMES:
+        raise ActivityProjectionError(
+            f"unsupported activity outcome: {details['outcome']}"
+        )
+    activity_id = details["activityId"]
+    if (
+        not isinstance(activity_id, str)
+        or _ACTIVITY_ID_RE.fullmatch(activity_id) is None
+    ):
+        raise ActivityProjectionError(f"invalid activityId: {activity_id}")
+    return {key: details[key] for key in ACTIVITY_FIELDS}
+
+
+def _validate_activity_order(rows: Sequence[Mapping[str, Any]]) -> None:
+    ids = [str(row["activityId"]) for row in rows]
+    if len(ids) != len(set(ids)):
+        raise ActivityProjectionError("activityId values must be unique")
+    numbers = [int(_ACTIVITY_ID_RE.fullmatch(value).group(1)) for value in ids]
+    if any(current <= previous for previous, current in zip(numbers, numbers[1:])):
+        raise ActivityProjectionError(
+            "activity events must be in strict activityId order"
+        )
+
+
+def _atomic_write_json(path: Path, payload: Mapping[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary_path: Path | None = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            encoding="utf-8",
+            dir=path.parent,
+            prefix=f".{path.name}.",
+            suffix=".tmp",
+            delete=False,
+        ) as handle:
+            temporary_path = Path(handle.name)
+            json.dump(payload, handle, ensure_ascii=False, indent=2)
+            handle.write("\n")
+        os.replace(temporary_path, path)
+    finally:
+        if temporary_path is not None and temporary_path.exists():
+            temporary_path.unlink()
+
+
+def record_activity(
+    project_root: Path,
+    run_manifest_path: Path,
+    details: Mapping[str, Any],
+    timestamp: str | None = None,
+) -> LeadEvent:
+    """Append one activity event using identity from its run manifest."""
+    manifest = _read_json_object(run_manifest_path)
+    if manifest.get("activityContractVersion") != 1:
+        raise ActivityProjectionError(
+            "run manifest does not declare activityContractVersion 1"
+        )
+    event = LeadEvent(
+        event_type="activity",
+        lead_runtime=_require_string(manifest, "leadRuntime"),
+        task_key=_require_string(manifest, "taskKey"),
+        task_type=_require_string(manifest, "taskType"),
+        run_seq=_manifest_run_seq(manifest),
+        timestamp=timestamp or _utc_now(),
+        details=dict(details),
+    )
+    events_path = _resolve_project_path(
+        project_root, _require_string(manifest, "leadEventsPath")
+    )
+    return append_activity_event(events_path, event)
+
+
+def project_agent_activity(
+    project_root: Path,
+    run_manifest_path: Path,
+    data_path: Path,
+) -> tuple[dict[str, Any], ...]:
+    """Replace only ``agentActivity`` with this run's canonical events."""
+    manifest = _read_json_object(run_manifest_path)
+    if manifest.get("activityContractVersion") != 1:
+        return ()
+    events_path = _resolve_project_path(
+        project_root, _require_string(manifest, "leadEventsPath")
+    )
+    run_seq = _manifest_run_seq(manifest)
+    task_key = _require_string(manifest, "taskKey")
+    task_type = _require_string(manifest, "taskType")
+    events = (
+        event
+        for event in read_lead_events(events_path)
+        if event.event_type == "activity"
+        and event.task_key == task_key
+        and event.task_type == task_type
+        and event.run_seq == run_seq
+    )
+    rows = tuple(_activity_row(event) for event in events)
+    _validate_activity_order(rows)
+    data = _read_json_object(data_path)
+    data["agentActivity"] = list(rows)
+    _atomic_write_json(data_path, data)
+    return rows
+
+
+def _parse_command_records(raw_records: Sequence[str]) -> tuple[EvidenceCommand, ...]:
+    content = "\n".join(
+        f"- Evidence command: {record}" for record in raw_records
+    )
+    commands, failures = parse_evidence_commands(content)
+    if failures:
+        raise ActivityProjectionError("; ".join(failures))
+    return commands
+
+
+def _activity_commands(args: argparse.Namespace) -> tuple[EvidenceCommand, ...]:
+    commands = list(_parse_command_records(args.command_record))
+    if args.audit_sidecar is not None:
+        audit_commands, failures = read_evidence_commands(args.audit_sidecar)
+        if failures:
+            raise ActivityProjectionError("; ".join(failures))
+        commands.extend(audit_commands)
+    return tuple(commands)
+
+
+def _conversation_activity_line(details: Mapping[str, Any]) -> str:
+    plan_items = ",".join(details["planItemIds"]) or "<none>"
+    result_path = str(details["resultPath"] or "<none>")
+    summary = json.dumps(details["summary"], ensure_ascii=False)
+    return (
+        f"ACTIVITY: id={details['activityId']} agent={details['agent']} "
+        f"summary={summary} items={plan_items} result={result_path} "
+        f"outcome={details['outcome']}"
+    )
+
+
+def _append(args: argparse.Namespace) -> int:
+    commands = _activity_commands(args)
+    details = {
+        "kind": args.kind,
+        "agent": args.agent,
+        "summary": args.summary,
+        "planItemIds": args.plan_item_id,
+        "resultPath": args.result_path,
+        "commands": [command.to_record() for command in commands],
+        "evidenceRefs": args.evidence_ref,
+        "outcome": args.outcome,
+    }
+    event = record_activity(args.project_root, args.run_manifest, details)
+    payload = dict(event.details)
+    payload["ok"] = True
+    payload["activityLine"] = _conversation_activity_line(payload)
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+    return 0
+
+
+def _project(args: argparse.Namespace) -> int:
+    rows = project_agent_activity(args.project_root, args.run_manifest, args.data)
+    print(json.dumps(
+        {"ok": True, "count": len(rows), "agentActivity": rows},
+        ensure_ascii=False,
+        indent=2,
+    ))
+    return 0
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="okstra agent-activity")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    append_parser = subparsers.add_parser("append")
+    append_parser.add_argument("--project-root", type=Path, required=True)
+    append_parser.add_argument("--run-manifest", type=Path, required=True)
+    append_parser.add_argument(
+        "--kind", choices=sorted(ACTIVITY_KINDS), required=True
+    )
+    append_parser.add_argument("--agent", required=True)
+    append_parser.add_argument("--summary", required=True)
+    append_parser.add_argument(
+        "--outcome", choices=sorted(ACTIVITY_OUTCOMES), required=True
+    )
+    append_parser.add_argument("--plan-item-id", action="append", default=[])
+    append_parser.add_argument("--evidence-ref", action="append", default=[])
+    append_parser.add_argument("--command-record", action="append", default=[])
+    append_parser.add_argument("--result-path", default="")
+    append_parser.add_argument("--audit-sidecar", type=Path)
+    project_parser = subparsers.add_parser("project")
+    project_parser.add_argument("--project-root", type=Path, required=True)
+    project_parser.add_argument("--run-manifest", type=Path, required=True)
+    project_parser.add_argument("--data", type=Path, required=True)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    try:
+        return _append(args) if args.command == "append" else _project(args)
+    except ActivityProjectionError as exc:
+        print(f"okstra agent-activity: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/runtime/python/okstra_ctl/agent_invocation.py

@@ -21,6 +21,7 @@ AgentAudience = Literal[
     "discovery-worker",
     "diagnosis-worker",
     "planning-worker",
+    "direction-selection-worker",
     "implementation-executor",
     "implementation-verifier",
     "acceptance-verifier",

package/runtime/python/okstra_ctl/analysis_packet.py

@@ -57,6 +57,12 @@ WORKER_PROFILE_SECTIONS_BY_TASK_TYPE = {
         "Brief consumption",
         "Worker diagnosis procedure",
     ),
+    "implementation-option-selection": (
+        "Brief consumption",
+        "Worker direction-selection procedure",
+        "Pre-selection context exploration",
+        "Option evaluation rules",
+    ),
     "implementation-planning": (
         "Brief consumption",
         "Worker planning procedure",

package/runtime/python/okstra_ctl/clarification_items.py

@@ -372,6 +372,13 @@ APPROVAL_BLOCKS = frozenset({"approval"})
 # user-response skill must list them — counting only `approval` made a report
 # whose open items were all `next-phase` look like it had none.
 USER_INPUT_BLOCKS = frozenset({"approval", "next-phase"})
+ANSWER_DISPOSITIONS = frozenset({
+    "answer",
+    "select",
+    "accept-risk",
+    "request-revision",
+    "reject",
+})
 
 
 @dataclass(frozen=True)
@@ -391,28 +398,39 @@ class ClarificationScan:
 def scan_approval_gate(report_path: Path) -> ClarificationScan:
     """Scan for unresolved ``Blocks=approval`` rows (``Status`` in
     ``{open, answered}``), refusing to guess whenever the schema drifted."""
-    return scan_clarification_blockers(report_path, APPROVAL_BLOCKS)
+    return scan_clarification_blockers(
+        report_path, APPROVAL_BLOCKS, honor_sidecar_answers=False
+    )
 
 
 def scan_open_user_input(report_path: Path) -> ClarificationScan:
     """Scan for every unresolved row that still owes the user an answer
     (``Blocks`` in ``{approval, next-phase}``)."""
-    return scan_clarification_blockers(report_path, USER_INPUT_BLOCKS)
+    return scan_clarification_blockers(
+        report_path, USER_INPUT_BLOCKS, honor_sidecar_answers=True
+    )
 
 
 def scan_clarification_blockers(
-    report_path: Path, blocking_values: frozenset[str]
+    report_path: Path,
+    blocking_values: frozenset[str],
+    *,
+    honor_sidecar_answers: bool,
 ) -> ClarificationScan:
     """Shared fail-closed clarification walk for both gates above — schema-v2
-    reads its rows from the data sibling, schema-v1 from the §1 table, and the
-    user's `user-responses/` sidecar outranks whatever the report says about
-    those rows."""
+    reads its rows from the data sibling and schema-v1 from the §1 table.
+    ``honor_sidecar_answers`` controls whether a user's sidecar hides answered
+    rows from this scan; approval deliberately passes ``False``."""
     v2_scan = _scan_v2_blockers(report_path, blocking_values)
     scan = (
         v2_scan if v2_scan is not None
         else scan_section_1_blockers(_read_report_text(report_path), blocking_values)
     )
-    return _resolve_blockers_answered_by_user(report_path, scan)
+    return (
+        _resolve_blockers_answered_by_user(report_path, scan)
+        if honor_sidecar_answers
+        else scan
+    )
 
 
 def _resolve_blockers_answered_by_user(
@@ -422,9 +440,8 @@ def _resolve_blockers_answered_by_user(
 
     답의 정본은 사용자의 `user-responses/` 사이드카다. 리포트의 `Status` 는 그
     run 이 스스로 적어둔 값이고, 답이 사이드카로만 들어오는 경로(HTML 뷰의
-    `Export user response`, `okstra user-response write`)에서는 갱신되지
-    않는다 — 게이트가 리포트만 보면 사용자가 답을 다 채운 뒤에도 같은 항목이
-    영원히 미해결로 남아 다음 phase 를 막는다.
+    `Export user response`, `okstra user-response write`)에서는 갱신되지 않는다.
+    사용자 입력 목록은 사이드카 답변이 있는 항목을 다시 묻지 않는다.
 
     fail-closed 는 그대로다: 행 자체를 못 읽은 스캔(`unreadable_reason`)은
     어떤 id 가 blocker 인지 모르는 상태이므로 사이드카로 덮지 않는다.
@@ -630,10 +647,10 @@ def sidecar_answers(source: Path) -> dict[str, str]:
     사용자가 답한 항목이 무엇인지 아는 단일 참조점 — carry-in 병합도, 승인
     게이트도, 스킬의 열린 항목 목록도 전부 이 한 곳을 본다.
 
-    `disposition` 이 `answer` 인 항목만 답으로 센다. `reframe` 은 "다음 run 에서
-    다시 물어달라" 이지 답이 아니므로(`skills/okstra-user-response/SKILL.md` 의
-    "A reframe is not an answer") 답 집합에서 빠져야 게이트가 그 항목을 계속
-    미해결로 잡는다.
+    `disposition` 이 `ANSWER_DISPOSITIONS` 에 속하는 항목만 답으로 센다.
+    `reframe` 은 "다음 run 에서 다시 물어달라" 이지 답이 아니므로
+    (`skills/okstra-user-response/SKILL.md` 의 "A reframe is not an answer")
+    답 집합에서 빠져야 사용자 입력 목록에 그 항목이 계속 남는다.
 
     같은 id 가 여러 사이드카에 나오면 이름순 마지막(최신 seq)이 이긴다 — 최신이
     reframe 이거나 값이 비면 앞선 답을 지운다. 그래야 답을 물렀을 때 그 항목이
@@ -646,7 +663,7 @@ def sidecar_answers(source: Path) -> dict[str, str]:
         for entry in parse_user_response_entries(
             sidecar.read_text(encoding="utf-8")
         ):
-            if entry.value and entry.disposition == "answer":
+            if entry.value and entry.disposition in ANSWER_DISPOSITIONS:
                 answers[entry.response_id] = entry.value
             else:
                 answers.pop(entry.response_id, None)
@@ -759,7 +776,7 @@ def _v2_section_1_body(entries: list) -> str:
     """schema-v2 `clarificationItems[]` 를 §1 표 본문으로.
 
     메타 셀은 렌더러가 쓰는 모양 그대로다 — `Status:` 는 따옴표 없이 써야
-    `_reconcile_user_input` 이 답을 병합하면서 상태를 resolved 로 넘길 수 있다."""
+    `_reconcile_user_input` 이 답을 병합하면서 상태를 answered 로 넘길 수 있다."""
     rows = [e for e in entries if isinstance(e, dict) and e.get("id")]
     if not rows:
         return f"\n{_SECTION_1_EMPTY_STATE}"
@@ -783,7 +800,7 @@ def _v2_section_1_body(entries: list) -> str:
 # The final-report renderer writes `Status: open` / `Status: answered` unquoted
 # in the stacked meta cell; only those two are unresolved. Resolve in place so
 # the meta cell's other fields (ID, Ticket, Kind, Blocks) are left untouched.
-_STATUS_RESOLVE_RE = re.compile(r"(Status:\s*)(?:open|answered)\b", re.IGNORECASE)
+_STATUS_ANSWER_RE = re.compile(r"(Status:\s*)(?:open|answered)\b", re.IGNORECASE)
 
 
 def _locate_user_input_column(lines: list[str]) -> tuple[int, int]:
@@ -799,7 +816,7 @@ def _locate_user_input_column(lines: list[str]) -> tuple[int, int]:
 
 def _reconcile_row(line: str, ui_col: int, answers: dict[str, str]) -> str:
     """답이 있고 open/answered 인 행이면 `User input` 칸을 그 답으로 채우고 Status 를
-    resolved 로 바꾼 줄을, 그 외에는 원본 줄을 그대로 돌려준다.
+    answered 로 바꾼 줄을, 그 외에는 원본 줄을 그대로 돌려준다.
 
     칸에 이미 값이 있어도 사용자의 사이드카 답이 이긴다. 그 칸을 채우는 것은
     run 자신(직전 렌더가 옮겨 적은 값)이고, 사용자가 나중에 답을 바꾸면 둘이
@@ -819,13 +836,13 @@ def _reconcile_row(line: str, ui_col: int, answers: dict[str, str]) -> str:
     if not 0 <= ui_col < len(raw):
         return line
     raw[ui_col] = answers[item.row_id]
-    raw[0] = _STATUS_RESOLVE_RE.sub(r"\1resolved", raw[0])
+    raw[0] = _STATUS_ANSWER_RE.sub(r"\1answered", raw[0])
     return "| " + " | ".join(to_cell_text(c) for c in raw) + " |"
 
 
 def _reconcile_user_input(section: str, answers: dict[str, str]) -> str:
     """§1 표에서 사이드카 답이 있는 미해결 행의 `User input` 칸을 답으로 채우고
-    Status 를 resolved 로 바꾼 §1 본문을 돌려준다.
+    Status 를 answered 로 바꾼 §1 본문을 돌려준다.
 
     답의 정본 위치를 §1 표 안으로 옮긴다 — 표만 읽는 승인 게이트·프롬프트
     빌더·검증 워커가 모두 답을 보게 하려는 것. 사이드카는 §1 표 밖 별도 섹션에만

package/runtime/python/okstra_ctl/exact_coverage.py

@@ -0,0 +1,128 @@
+"""Pure exact requirement coverage calculation."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from typing import Literal
+
+
+class ExactCoverageError(ValueError):
+    """Raised when coverage input cannot define a valid comparison."""
+
+
+@dataclass(frozen=True)
+class ExactCoverageResult:
+    coverage_percent: float
+    scope_precision_percent: float
+    covered_count: int
+    total_count: int
+    unmapped_commitments: tuple[str, ...]
+    contradicted_requirements: tuple[str, ...]
+    verdict: Literal["exact", "under", "over", "contradicted"]
+
+    def as_report_summary(self) -> dict[str, object]:
+        return {
+            "coveragePercent": self.coverage_percent,
+            "scopePrecisionPercent": self.scope_precision_percent,
+            "coveredCount": self.covered_count,
+            "totalCount": self.total_count,
+            "unmappedCommitments": list(self.unmapped_commitments),
+            "contradictedRequirements": list(self.contradicted_requirements),
+            "coverageVerdict": self.verdict,
+        }
+
+
+def calculate_exact_coverage(
+    original_requirement_ids: Sequence[str],
+    coverage_status_by_id: Mapping[str, str],
+    commitment_requirement_ids: Mapping[str, Sequence[str]],
+) -> ExactCoverageResult:
+    original_ids = tuple(original_requirement_ids)
+    if not original_ids:
+        raise ExactCoverageError("original requirement denominator is empty")
+    if len(set(original_ids)) != len(original_ids):
+        raise ExactCoverageError("original requirement ids contain duplicates")
+
+    original_id_set = set(original_ids)
+    if set(coverage_status_by_id) != original_id_set:
+        raise ExactCoverageError("coverage rows must match original requirement ids")
+    allowed_statuses = {"covered", "not-covered", "contradicted"}
+    if any(status not in allowed_statuses for status in coverage_status_by_id.values()):
+        raise ExactCoverageError("coverage status is invalid")
+    if not commitment_requirement_ids:
+        raise ExactCoverageError("implementation commitment denominator is empty")
+
+    unmapped = tuple(
+        commitment_id
+        for commitment_id, requirement_ids in commitment_requirement_ids.items()
+        if not requirement_ids
+        or any(requirement_id not in original_id_set for requirement_id in requirement_ids)
+    )
+    contradicted = tuple(
+        requirement_id
+        for requirement_id in original_ids
+        if coverage_status_by_id[requirement_id] == "contradicted"
+    )
+    covered_count = sum(
+        coverage_status_by_id[requirement_id] == "covered"
+        for requirement_id in original_ids
+    )
+    coverage_percent = round(covered_count / len(original_ids) * 100, 2)
+    traceable_count = len(commitment_requirement_ids) - len(unmapped)
+    scope_precision_percent = round(
+        traceable_count / len(commitment_requirement_ids) * 100,
+        2,
+    )
+    verdict: Literal["exact", "under", "over", "contradicted"]
+    if contradicted:
+        verdict = "contradicted"
+    elif covered_count != len(original_ids):
+        verdict = "under"
+    elif unmapped:
+        verdict = "over"
+    else:
+        verdict = "exact"
+
+    return ExactCoverageResult(
+        coverage_percent=coverage_percent,
+        scope_precision_percent=scope_precision_percent,
+        covered_count=covered_count,
+        total_count=len(original_ids),
+        unmapped_commitments=unmapped,
+        contradicted_requirements=contradicted,
+        verdict=verdict,
+    )
+
+
+def calculate_plan_exact_coverage(
+    original_requirement_ids: Sequence[str],
+    coverage_status_by_id: Mapping[str, str],
+    stage_requirement_ids: Mapping[int, Sequence[str]],
+    file_requirement_ids: Mapping[str, Sequence[str]],
+) -> tuple[ExactCoverageResult, tuple[int, ...], tuple[str, ...]]:
+    """Apply exact coverage to the executable stage and file-change scope."""
+    commitments = {
+        **{
+            f"stage:{stage}": requirement_ids
+            for stage, requirement_ids in stage_requirement_ids.items()
+        },
+        **{
+            f"file:{path}": requirement_ids
+            for path, requirement_ids in file_requirement_ids.items()
+        },
+    }
+    result = calculate_exact_coverage(
+        original_requirement_ids,
+        coverage_status_by_id,
+        commitments,
+    )
+    unmapped_stages = tuple(
+        stage for stage, requirement_ids in stage_requirement_ids.items()
+        if not requirement_ids
+    )
+    unmapped_files = tuple(
+        path for path, requirement_ids in file_requirement_ids.items()
+        if not requirement_ids
+    )
+    return result, unmapped_stages, unmapped_files

package/runtime/python/okstra_ctl/fix_cycles.py

@@ -27,7 +27,9 @@ _LOCK_FILENAME = ".fix-cycles.lock"
 # 완료(release-handoff) task 에 fix-cycle 로 재진입할 수 있는 entry phase 들.
 # prepare(run.py) 의 게이트와 wizard 의 감지 술어가 공유하는 SSOT.
 FIX_CYCLE_ENTRY_PHASES = (
-    "requirements-discovery", "error-analysis", "implementation-planning")
+    "requirements-discovery", "error-analysis", "implementation-option-selection",
+    "implementation-planning",
+)
 
 
 def fix_cycles_path(task_root: Path) -> Path: