okstra 0.186.4 → 0.186.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.186.4",
+  "version": "0.186.5",
   "description": "Host-aware multi-provider cross-verification orchestrator runtime and agent skills.",
   "license": "MIT",
   "author": "devonshin",

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.186.4",
-  "builtAt": "2026-08-24T05:51:42.489Z",
+  "package": "0.186.5",
+  "builtAt": "2026-08-24T06:52:38.243Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/python/okstra_ctl/report_assembly.py

@@ -131,10 +131,65 @@ def _clarifications(
         if not isinstance(row, Mapping):
             _fail("lead", path, f"activeClarifications[{index}]", "must be an object")
     activity_by_id = {row.get("activityId"): row for row in activities}
-    return [
+    rows = [
         _clarification_row(row, activity_by_id, path)
         for row in active
     ]
+    rows.extend(_carried_clarification_rows(ledger, {row.get("id") for row in rows}, path))
+    return rows
+
+
+def _carried_clarification_rows(
+    ledger: Mapping[str, Any], seen_ids: set[object], path: Path,
+) -> list[dict[str, Any]]:
+    """이월 결정은 active 질문이 아니다. 이번 런 활동 원장을 요구하지 않는다."""
+    carried = ledger.get("carriedDecisions")
+    if not isinstance(carried, list):
+        return []
+    rows: list[dict[str, Any]] = []
+    seen = set(seen_ids)
+    for index, entry in enumerate(carried):
+        if not isinstance(entry, Mapping):
+            _fail("lead", path, f"carriedDecisions[{index}]", "must be an object")
+        decision = entry.get("decision")
+        if not isinstance(decision, Mapping):
+            _fail(
+                "lead", path, f"carriedDecisions[{index}].decision",
+                "must be an object",
+            )
+        cid = decision.get("id")
+        if cid in seen:
+            continue
+        rows.append(_carried_clarification_row(decision))
+        seen.add(cid)
+    return rows
+
+
+def _carried_clarification_row(source: Mapping[str, Any]) -> dict[str, Any]:
+    row = {
+        key: source[key]
+        for key in (
+            "id", "ticketId", "kind", "statement", "expectedForm", "blocks",
+            "origin", "userConfirmation", "options",
+        )
+        if key in source
+    }
+    if "approval" in source:
+        row["approvalContext"] = source["approval"]
+    resolution = source.get("resolutionInput")
+    if not isinstance(resolution, Mapping):
+        row["status"] = "resolved"
+        return row
+    row.update(
+        status="resolved",
+        userInput=resolution.get("userText", ""),
+        resolution={
+            "disposition": resolution.get("disposition"),
+            "userText": resolution.get("userText"),
+            "checkRefs": list(resolution.get("checkRefs") or []),
+        },
+    )
+    return row
 
 
 def _project_relative(project_root: Path, path: Path) -> str:

package/runtime/validators/validate-run.py

@@ -3492,8 +3492,8 @@ def validate_final_report_data(
     errors = schema_validate(data, schema)
     for err in errors:
         failures.append(f"final-report data.json: {err}")
-    if errors:
-        return data
+    # 스키마 실패가 계약 스캔을 가리지 않는다. 빈 decisionRefs 가
+    # minItems 에서 막히면 종료상태 표 누락이 안 보였다.
 
     manifest = run_manifest or {}
     if data.get("executionIdentityVersion") == 2 or data.get("executionRoles"):
@@ -3595,8 +3595,11 @@ def validate_final_report_data(
             data, _project_root_from_report(report_path)
         ):
             print(f"validate-run: warning: {warning}", file=sys.stderr)
+        carried = _carried_decision_map(
+            manifest, project_root=project_root, report_path=report_path
+        )
         _validate_supersession_ledger(data, failures)
-        _validate_clarification_evidence_note(data, failures)
+        _validate_clarification_evidence_note(data, failures, carried=carried)
         _validate_approval_clarification_backtrace(data, failures)
         _validate_rerun_guidance(data, failures)
         _validate_approval_guidance(data, failures)
@@ -3606,7 +3609,11 @@ def validate_final_report_data(
             failures,
         )
         if not selected_direction_contract:
-            _validate_requirement_deviations(data, failures)
+            _validate_requirement_deviations(
+                data,
+                failures,
+                carried=carried,
+            )
             _validate_requirement_coverage_covered_by(data, failures)
         warnings = _validate_design_prep_contract(
             data,
@@ -5778,6 +5785,14 @@ def _validate_self_fix_rewrite_scope(data: dict, failures: list[str]) -> None:
                 )
 
 
+def _analyser_key(worker: str) -> str:
+    """`codex` 와 `codex-worker` 는 같은 분석기다."""
+    name = worker.strip()
+    if name.endswith("-worker"):
+        return name[: -len("-worker")]
+    return name
+
+
 def _validate_participating_analysers(data: dict, failures: list[str]) -> None:
     """The gate's own arithmetic base, checked against the votes it ran on.
 
@@ -5809,12 +5824,13 @@ def _validate_participating_analysers(data: dict, failures: list[str]) -> None:
         return
 
     observed = {
-        str(v.get("worker"))
+        _analyser_key(str(v.get("worker")))
         for item in (pbv.get("planItems") or [])
         if isinstance(item, dict)
         for v in (item.get("verdicts") or [])
         if isinstance(v, dict) and str(v.get("verdict") or "") != "verification-error"
     }
+    observed.discard("")
     if observed and voting != len(observed):
         failures.append(
             "final-report data.json: planBodyVerification.participatingAnalysers "
@@ -5917,7 +5933,9 @@ _EVIDENCE_NONE_RE = re.compile(r"^none\s*[—-]\s*\S")
 _EVIDENCE_PATH_LINE_RE = re.compile(r"\S+\.\w+:\d+")
 
 
-def _validate_clarification_evidence_note(data: dict, failures: list[str]) -> None:
+def _validate_clarification_evidence_note(
+    data: dict, failures: list[str], *, carried: dict | None = None,
+) -> None:
     """Every clarification row must show its codebase-first work.
 
     The profile requires any ambiguity answerable by `Read` / `Grep` to be
@@ -5930,10 +5948,13 @@ def _validate_clarification_evidence_note(data: dict, failures: list[str]) -> No
     """
     if (data.get("header") or {}).get("taskType") != "implementation-planning":
         return
+    carried_ids = set((carried or {}).keys())
     for row in data.get("clarificationItems") or []:
         if not isinstance(row, dict):
             continue
         row_id = str(row.get("id") or "<unknown>")
+        if row_id in carried_ids:
+            continue
         statement = str(row.get("statement") or "")
         match = _EVIDENCE_NOTE_RE.search(statement)
         if not match:
@@ -8628,14 +8649,83 @@ _DEVIATION_DECISION_REF_RE = re.compile(r"^(C-\d{3,}|D-\d{4,})$")
 _DEVIATION_BLOCKED_DISPOSITION_RE = re.compile(r"^blocked (C-\d{3,})$")
 
 
+def _carried_decision_map(
+    run_manifest: Mapping[str, Any] | None,
+    *,
+    project_root: Path | None,
+    report_path: Path,
+) -> dict[str, dict]:
+    """이전 런에서 carry 한 결정. active `clarificationItems` 에 다시 올리지 않는다."""
+    raw = (run_manifest or {}).get("approvalDecisionsPath")
+    if not isinstance(raw, str) or not raw.strip():
+        return {}
+    path = Path(raw.strip())
+    if not path.is_absolute():
+        root = project_root or _project_root_from_report(report_path)
+        path = root / path
+    if not path.is_file():
+        return {}
+    try:
+        ledger = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    if not isinstance(ledger, dict):
+        return {}
+    carried: dict[str, dict] = {}
+    for row in ledger.get("carriedDecisions") or []:
+        if not isinstance(row, dict):
+            continue
+        decision = row.get("decision")
+        if not isinstance(decision, dict):
+            continue
+        cid = decision.get("id")
+        if isinstance(cid, str) and cid:
+            carried[cid] = decision
+    return carried
+
+
+def _deviation_target(
+    ref: str,
+    clarifications: dict,
+    decisions: dict,
+    carried: dict,
+) -> dict | None:
+    if ref.startswith("C-"):
+        row = clarifications.get(ref) or carried.get(ref)
+        return row if isinstance(row, dict) else None
+    row = decisions.get(ref)
+    return row if isinstance(row, dict) else None
+
+
+def _deviation_is_user_confirmed(
+    ref: str, clarifications: dict, carried: dict,
+) -> bool:
+    row = clarifications.get(ref)
+    if (
+        isinstance(row, dict)
+        and row.get("status") in {"answered", "resolved"}
+        and str(row.get("userInput") or "").strip()
+    ):
+        return True
+    carried_row = carried.get(ref)
+    if not isinstance(carried_row, dict):
+        return False
+    resolution = carried_row.get("resolutionInput")
+    if isinstance(resolution, dict) and str(resolution.get("userText") or "").strip():
+        return True
+    return bool(str(carried_row.get("userConfirmation") or "").strip())
+
+
 def _resolved_deviation_refs(
     row_id: str,
     refs: object,
     clarifications: dict,
     decisions: dict,
     failures: list[str],
+    carried: dict | None = None,
 ) -> list[str]:
     valid_refs: list[str] = []
+    carried_rows = carried or {}
     for ref in refs if isinstance(refs, list) else []:
         if not isinstance(ref, str) or not _DEVIATION_DECISION_REF_RE.fullmatch(ref):
             failures.append(
@@ -8643,12 +8733,7 @@ def _resolved_deviation_refs(
                 f"unsupported decisionRef `{ref}`; expected C-NNN or D-NNNN."
             )
             continue
-        target = (
-            clarifications.get(ref)
-            if ref.startswith("C-")
-            else decisions.get(ref)
-        )
-        if target is None:
+        if _deviation_target(ref, clarifications, decisions, carried_rows) is None:
             failures.append(
                 f"final-report data.json: requirementCoverage `{row_id}` "
                 f"decisionRef `{ref}` does not exist in this report."
@@ -8664,12 +8749,13 @@ def _validate_deviation_disposition(
     refs: list[str],
     clarifications: dict,
     failures: list[str],
+    carried: dict | None = None,
 ) -> None:
+    carried_rows = carried or {}
     if disposition == "accepted":
         confirmed = any(
             ref.startswith("C-")
-            and clarifications[ref].get("status") in {"answered", "resolved"}
-            and bool(str(clarifications[ref].get("userInput") or "").strip())
+            and _deviation_is_user_confirmed(ref, clarifications, carried_rows)
             for ref in refs
         )
         if not confirmed:
@@ -8688,7 +8774,9 @@ def _validate_deviation_disposition(
     if blocked is None:
         return
     clarification_id = blocked.group(1)
-    clarification = clarifications.get(clarification_id)
+    clarification = clarifications.get(clarification_id) or carried_rows.get(
+        clarification_id
+    )
     if clarification is None:
         failures.append(
             f"final-report data.json: requirementCoverage `{row_id}` "
@@ -8706,7 +8794,9 @@ def _validate_deviation_disposition(
         )
 
 
-def _validate_requirement_deviations(data: dict, failures: list[str]) -> None:
+def _validate_requirement_deviations(
+    data: dict, failures: list[str], *, carried: dict | None = None,
+) -> None:
     """Require documented deviations to reference real decisions and approval."""
     planning = data.get("implementationPlanning")
     if not isinstance(planning, dict):
@@ -8721,15 +8811,26 @@ def _validate_requirement_deviations(data: dict, failures: list[str]) -> None:
         for row in (planning.get("decisionDrafts") or [])
         if isinstance(row, dict) and row.get("number")
     }
+    carried_rows = carried or {}
     for row in planning.get("requirementCoverage") or []:
         if not isinstance(row, dict) or row.get("status") != "documented-deviation":
             continue
         row_id = row.get("id") or "<row>"
         refs = _resolved_deviation_refs(
-            row_id, row.get("decisionRefs"), clarifications, decisions, failures
+            row_id,
+            row.get("decisionRefs"),
+            clarifications,
+            decisions,
+            failures,
+            carried_rows,
         )
         _validate_deviation_disposition(
-            row_id, row.get("approvalDisposition"), refs, clarifications, failures
+            row_id,
+            row.get("approvalDisposition"),
+            refs,
+            clarifications,
+            failures,
+            carried_rows,
         )
 
 
@@ -9518,15 +9619,35 @@ def _validate_convergence_rounds_match_manifest(
             )
 
 
-def _validate_convergence_states(run_dir, failures) -> None:
-    """Replay shared engine invariants for every public final state artifact."""
+def _validate_convergence_states(
+    run_dir, failures, run_manifest: dict | None = None, project_root: Path | None = None,
+) -> None:
+    """이번 런이 가리키는 수렴 상태만 본다. 디렉터리의 옛 seq 파일은 건너뛴다."""
     from pathlib import Path as _Path
 
-    state_dir = _Path(run_dir) / "state"
-    if not state_dir.is_dir():
-        return
-    for state_path in sorted(state_dir.glob("convergence-*.json")):
-        if state_path.name.startswith(_CONVERGENCE_INTERMEDIATE_PREFIXES):
+    declared = (run_manifest or {}).get("convergenceStatePath")
+    if isinstance(declared, str) and declared.strip():
+        path = _Path(declared.strip())
+        if not path.is_absolute():
+            if project_root is None:
+                return
+            path = project_root / path
+        paths = [path]
+    else:
+        state_dir = _Path(run_dir) / "state"
+        if not state_dir.is_dir():
+            return
+        paths = [
+            state_path
+            for state_path in sorted(state_dir.glob("convergence-*.json"))
+            if not state_path.name.startswith(_CONVERGENCE_INTERMEDIATE_PREFIXES)
+        ]
+    for state_path in paths:
+        if not state_path.is_file():
+            if isinstance(declared, str) and declared.strip():
+                failures.append(
+                    f"convergence state {state_path.name}: missing declared artifact"
+                )
             continue
         try:
             state = json.loads(state_path.read_text(encoding="utf-8"))
@@ -10355,7 +10476,9 @@ def main() -> int:
             run_dir = report_path.parent.parent
             _validate_requirements_discovery_fanout(run_dir, failures, brief_path)
     # Phase-agnostic: convergence runs in every finding-producing phase.
-    _validate_convergence_states(report_path.parent.parent, failures)
+    _validate_convergence_states(
+        report_path.parent.parent, failures, run_manifest, project_root
+    )
     _validate_convergence_rounds_match_manifest(
         report_path.parent.parent, run_manifest, failures
     )