okstra 0.200.0 → 0.201.0

package/runtime/python/okstra_ctl/report_assembly.py

@@ -26,6 +26,7 @@ from .report_synthesis_packet import (
 from .conformance import strip_stage_declaration_label
 from .design_prep import DesignPrepError, materialize_design_prep_requests
 from .implementation_options import validate_blocked_answer_channel
+from .technical_verification import validate_technical_verification_report
 from .implementation_direction import (
     load_selected_direction_snapshot,
     validate_selected_direction_plan,
@@ -462,8 +463,7 @@ def _compose(
     data["tokenUsage"] = usage
     data["crossVerification"] = convergence_data["crossVerification"]
     data["clarificationItems"] = _clarifications(ledger, activities, inputs["approval-decisions"].path)
-    # 차단된 option-selection 은 발행 전에 답변 채널을 갖춰야 한다. 발행 뒤에는
-    # 이 원장을 다시 읽는 경로가 없어 사용자에게 질문이 0건으로 보인다.
+    # 작성자의 사실 분류와 리드 원장의 질문 연결은 양쪽 입력을 합친 뒤 검사한다.
     for reason in validate_blocked_answer_channel(data):
         _fail(
             "lead",
@@ -888,6 +888,12 @@ def assemble_report(
         _fail("orchestrator", manifest_path, "expectedReportRecordPath", "required")
     target = Path(value)
     target = target if target.is_absolute() else project_root / target
+    verification_errors = validate_technical_verification_report(data, target, project_root)
+    if verification_errors:
+        raise ReportAssemblyError(tuple(
+            AssemblyIssue("report-writer", str(target), "technicalVerification", error)
+            for error in verification_errors
+        ))
     _publish(target, data, replace)
     if errors or direction_errors:
         raise ReportAssemblyError(

package/runtime/python/okstra_ctl/report_contract.py

@@ -9,6 +9,7 @@ PUBLIC_REPORT_TASK_TYPES = (
     "requirements-discovery",
     "improvement-discovery",
     "error-analysis",
+    "technical-verification",
     "implementation-option-selection",
     "project-analysis",
     "feature-analysis",
@@ -23,6 +24,7 @@ TASK_TYPE_DATA_PROPERTY = {
     "requirements-discovery": "requirementsDiscovery",
     "improvement-discovery": "improvementDiscovery",
     "error-analysis": "errorAnalysis",
+    "technical-verification": "technicalVerification",
     "implementation-option-selection": "implementationOptionSelection",
     "project-analysis": "projectAnalysis",
     "feature-analysis": "featureAnalysis",
@@ -47,6 +49,7 @@ TASK_TYPE_MARKDOWN_TEMPLATE = {
 }
 
 TASK_TYPE_REQUIRED_HUMAN_FIELDS = {
+    "technical-verification": ("technicalVerification.sourceReport", "technicalVerification.checks", "technicalVerification.routing"),
     "requirements-discovery": (
         "requirementsDiscovery.requestVerbatim",
         "requirementsDiscovery.systemInterpretation",

package/runtime/python/okstra_ctl/report_corrections.py

@@ -13,6 +13,7 @@
 """
 from __future__ import annotations
 
+import hashlib
 import json
 import re
 from copy import deepcopy
@@ -33,8 +34,8 @@ from .report_narrative import (
 )
 
 
-CORRECTION_KINDS = ("replace", "remove", "rewrite")
-MECHANICAL_KINDS = frozenset({"replace", "remove"})
+CORRECTION_KINDS = ("replace", "remove", "add", "move", "rewrite")
+MECHANICAL_KINDS = frozenset({"replace", "remove", "add", "move"})
 # okstra 가 렌더하는 절. 지시문 본문에 있으면 두 절이 갈라지므로 거절한다.
 OKSTRA_OWNED_SECTIONS = ("## Corrections", "## Previous Attempt", "## Output")
 
@@ -57,7 +58,7 @@ class CorrectionsCheck:
 
     ledger: dict[str, Any]
     corrections: tuple[dict[str, Any], ...]
-    # 기계적 교정(replace·remove)을 적용한 서사 자료. 기준 서사를 못 읽었으면 None.
+    # 확정 값의 교정을 적용한 서사 자료. 기준 서사를 못 읽었으면 None.
     scratch: dict[str, Any] | None
     # 작성자 라운드 없이 끝나는가 — rewrite 가 없고 결함도 없다.
     mechanical: bool
@@ -156,8 +157,8 @@ def _set(data: Any, tokens: Sequence[str | int], value: Any) -> None:
     if not found:
         raise KeyError(tokens)
     last = tokens[-1]
-    if isinstance(last, int):
-        parent[last] = value
+    if isinstance(last, int) and last == len(parent):
+        parent.append(value)
     else:
         parent[last] = value
 
@@ -194,6 +195,7 @@ def check_corrections(
     schema: Mapping[str, Any],
     block_rules: Sequence[str] = (),
     semantic_validator: Callable[[dict[str, Any]], Sequence[str]] | None = None,
+    rewrite_results: Mapping[str, Any] | None = None,
 ) -> CorrectionsCheck:
     """원장을 기준 서사에 대조한다. 설계 §4.2 의 1~6단계.
 
@@ -204,11 +206,49 @@ def check_corrections(
        적용 뒤에도 남아 있는 것만 보고한다.
     3. 경로 해소와 `current` 일치. `rewrite` 는 배열의 `[len]` 추가 위치를 허용한다.
     4. 작성자 소유 경로인가.
-    5. replace·remove 를 적용한 사본을 작성자 소유 값 스키마와 task 의미 검증기로
+    5. 확정 값의 교정을 적용한 사본을 작성자 소유 값 스키마와 task 의미 검증기로
        대조한다. rewrite 경로 아래로 특정된 결함은 뺀다(작성자가 다시 쓸 자리다).
     6. rewrite 마다 그 경로의 스키마 제약 문장을 붙인다.
     """
-    ledger_dict = dict(ledger)
+    ledger_dict = deepcopy(dict(ledger))
+    digest = hashlib.sha256(base_narrative.encode("utf-8")).hexdigest()
+    expected_digest = ledger_dict.get("baseNarrativeSha256")
+    if expected_digest is not None and expected_digest != digest:
+        return CorrectionsCheck(ledger_dict, (), None, False, {}, (
+            _defect("ledger", "baseNarrativeSha256", "base narrative hash does not match"),
+        ))
+    ledger_dict["baseNarrativeSha256"] = digest
+    corrections, parsed, defects = _parse_corrections(ledger_dict)
+    try:
+        data, _base_defects = parse_narrative_structure(base_narrative, schema)
+    except NarrativeContractError as exc:
+        defects.append(_defect("ledger", str(ledger_dict.get("baseNarrativePath") or "-"),
+                               f"base narrative does not parse: {exc}"))
+        return CorrectionsCheck(ledger_dict, corrections, None, False, {}, tuple(defects))
+    if rewrite_results is not None:
+        ledger_dict, result_defects = _complete_rewrites(ledger_dict, rewrite_results, data)
+        defects.extend(result_defects)
+        corrections = tuple(ledger_dict["corrections"])
+    valid, path_defects = _checked_correction_paths(corrections, parsed, data)
+    defects.extend(path_defects)
+    scratch = _apply_mechanical_corrections(data, valid, parsed)
+    rewrites = [item for item in valid if item.get("kind") == "rewrite"]
+    derived = _recount_planning_steps(scratch, corrections, rewrites)
+    corrections = (*corrections, *derived)
+    ledger_dict["corrections"] = list(corrections)
+    constraints = {str(item["id"]): _constraints_for(str(item["path"]), block_rules, schema)
+                   for item in rewrites}
+    errors = validate_writer_owned(scratch, schema)
+    if semantic_validator is not None:
+        errors.extend(semantic_validator(scratch))
+    defects.extend(_remaining_correction_defects(errors, rewrites))
+    return CorrectionsCheck(ledger_dict, corrections, scratch, not defects and not rewrites,
+                            constraints, tuple(defects))
+
+
+def _parse_corrections(
+    ledger_dict: dict[str, Any],
+) -> tuple[tuple[dict[str, Any], ...], dict[str, tuple[str | int, ...]], list[str]]:
     defects: list[str] = [
         _defect("ledger", error.split(": ", 1)[0], error)
         for error in validate(ledger_dict, corrections_schema())
@@ -231,21 +271,16 @@ def check_corrections(
             parsed[correction_id] = parse_field_path(path)
         except ValueError as exc:
             defects.append(_defect(correction_id, path, str(exc)))
-    if defects and not parsed:
-        return CorrectionsCheck(ledger_dict, corrections, None, False, {}, tuple(defects))
+    return corrections, parsed, defects
 
-    try:
-        data, _base_defects = parse_narrative_structure(base_narrative, schema)
-    except NarrativeContractError as exc:
-        defects.append(_defect(
-            "ledger", str(ledger_dict.get("baseNarrativePath") or "-"),
-            f"base narrative does not parse: {exc}",
-        ))
-        return CorrectionsCheck(ledger_dict, corrections, None, False, {}, tuple(defects))
 
-    scratch = deepcopy(data)
-    rewrite_paths: list[str] = []
-    constraints: dict[str, tuple[str, ...]] = {}
+def _checked_correction_paths(
+    corrections: Sequence[dict[str, Any]],
+    parsed: Mapping[str, tuple[str | int, ...]],
+    data: dict[str, Any],
+) -> tuple[list[dict[str, Any]], list[str]]:
+    valid: list[dict[str, Any]] = []
+    defects: list[str] = []
     for item in corrections:
         correction_id, path, kind = str(item.get("id")), str(item.get("path")), str(item.get("kind"))
         tokens = parsed.get(correction_id)
@@ -255,72 +290,147 @@ def check_corrections(
         if owned_defect:
             defects.append(_defect(correction_id, path, owned_defect))
             continue
-        found, value = _resolve(data, tokens)
-        if not found:
-            parent_found, parent = _parent(data, tokens)
-            appendable = (
-                kind == "rewrite"
-                and isinstance(tokens[-1], int)
-                and parent_found
-                and isinstance(parent, list)
-                and tokens[-1] == len(parent)
-            )
-            if not appendable:
-                defects.append(_defect(
-                    correction_id, path,
-                    "path does not resolve in the base narrative"
-                    + (" (a rewrite may append at index len(array))" if kind == "rewrite" else ""),
-                ))
-                continue
-        elif "current" in item and not _current_matches(item["current"], value):
-            defects.append(_defect(
-                correction_id, path,
-                f"current value is {_short(value)}, not {_short(item['current'])}",
-            ))
+        reason = _correction_path_defect(item, tokens, data)
+        if reason:
+            defects.append(_defect(correction_id, path, reason))
             continue
-        if kind == "rewrite":
-            rewrite_paths.append(path)
-            constraints[correction_id] = _constraints_for(path, block_rules, schema)
-
-    replacements = [c for c in corrections if c.get("kind") == "replace" and str(c.get("id")) in parsed]
-    removals = [c for c in corrections if c.get("kind") == "remove" and str(c.get("id")) in parsed]
-    defective_ids = {
-        line.split("correction=", 1)[1].split(" ", 1)[0] for line in defects if "correction=" in line
-    }
-    for item in replacements:
-        correction_id = str(item.get("id"))
-        if correction_id in defective_ids:
+        valid.append(item)
+    return valid, defects
+
+
+def _correction_path_defect(
+    item: Mapping[str, Any], tokens: Sequence[str | int], data: dict[str, Any],
+) -> str | None:
+    found, value = _resolve(data, tokens)
+    kind = item.get("kind")
+    parent_found, parent = _parent(data, tokens)
+    appendable = parent_found and (
+        (isinstance(parent, dict) and isinstance(tokens[-1], str))
+        or (isinstance(parent, list) and tokens[-1] == len(parent))
+    )
+    if found and kind in {"add", "move"}:
+        return "destination already exists; use replace to change an existing value"
+    if not found and not (kind in {"add", "move", "rewrite"} and appendable):
+        return "path does not resolve in the base narrative"
+    if kind == "move":
+        try:
+            source = parse_field_path(str(item.get("fromPath") or ""))
+        except ValueError as exc:
+            return f"invalid fromPath: {exc}"
+        owned_defect = writer_owned_path_defect(str(item["fromPath"]))
+        if owned_defect:
+            return f"fromPath {owned_defect}"
+        if source == tuple(tokens[:len(source)]):
+            return "move destination must not be inside its source"
+        if any(isinstance(token, int) for token in (*source, *tokens)):
+            return "move supports object fields only; use add/remove for array items"
+        found, value = _resolve(data, source)
+        if not found:
+            return "fromPath does not resolve in the base narrative"
+    if found and "current" in item and not _current_matches(item["current"], value):
+        return f"current value is {_short(value)}, not {_short(item['current'])}"
+    return None
+
+
+def _apply_mechanical_corrections(
+    data: dict[str, Any], corrections: Sequence[dict[str, Any]],
+    parsed: Mapping[str, tuple[str | int, ...]],
+) -> dict[str, Any]:
+    scratch = deepcopy(data)
+    removals: list[tuple[str | int, ...]] = []
+    for item in corrections:
+        tokens = parsed[str(item["id"])]
+        if item.get("kind") in {"replace", "add"}:
+            _set(scratch, tokens, deepcopy(item.get("replacement")))
+        elif item.get("kind") == "move":
+            source = parse_field_path(str(item["fromPath"]))
+            _set(scratch, tokens, deepcopy(_resolve(data, source)[1]))
+            removals.append(source)
+        elif item.get("kind") == "remove":
+            removals.append(tokens)
+    for tokens in sorted(set(removals), key=lambda ts: tuple(map(_removal_order, ts)), reverse=True):
+        if _resolve(scratch, tokens)[0]:
+            _remove(scratch, tokens)
+    return scratch
+
+
+def _remaining_correction_defects(
+    errors: Sequence[str], rewrites: Sequence[dict[str, Any]],
+) -> list[str]:
+    defects: list[str] = []
+    for error in errors:
+        location, separator, _ = error.partition(": ")
+        location = location if separator else "-"
+        if any(location == item["path"] or location.startswith(f"{item['path']}.")
+               or location.startswith(f"{item['path']}[") for item in rewrites):
             continue
-        _set(scratch, parsed[correction_id], deepcopy(item.get("replacement")))
-    for item in sorted(
-        removals,
-        key=lambda c: tuple(_removal_order(t) for t in parsed[str(c.get("id"))]),
-        reverse=True,
+        defects.append(_defect("applied", location, error))
+    return defects
+
+
+def _recount_planning_steps(
+    scratch: dict[str, Any], corrections: Sequence[dict[str, Any]],
+    rewrites: Sequence[dict[str, Any]],
+) -> tuple[dict[str, Any], ...]:
+    planning = scratch.get("implementationPlanning")
+    if not isinstance(planning, dict) or any(
+        str(item["path"]).startswith("implementationPlanning") for item in rewrites
     ):
-        correction_id = str(item.get("id"))
-        if correction_id in defective_ids:
+        return ()
+    stages, stage_map = planning.get("stages"), planning.get("stageMap")
+    if not isinstance(stages, list) or not isinstance(stage_map, list):
+        return ()
+    derived: list[dict[str, Any]] = []
+    used = {item.get("id") for item in corrections}
+    for index, row in enumerate(stage_map):
+        if not isinstance(row, dict):
             continue
-        _remove(scratch, parsed[correction_id])
-
-    # 원장의 일부가 결함이어도 나머지를 적용한 사본은 검증한다 — 리드가 한
-    # 회차에 전건을 보게 하려는 것이 이 모듈의 이유다. 결함인 교정은 적용하지
-    # 않았으므로 그 자리는 기준 서사의 값 그대로다.
-    if scratch is not None:
-        errors = validate_writer_owned(scratch, schema)
-        if semantic_validator is not None:
-            errors.extend(semantic_validator(scratch))
-        for error in errors:
-            location, separator, _ = error.partition(": ")
-            location = location if separator else "-"
-            if any(location == rp or location.startswith(f"{rp}.") or location.startswith(f"{rp}[")
-                   for rp in rewrite_paths):
-                continue
-            defects.append(_defect("applied", location, error))
-
-    mechanical = not defects and not rewrite_paths
-    return CorrectionsCheck(
-        ledger_dict, corrections, scratch, mechanical, constraints, tuple(defects)
-    )
+        matches = [stage for stage in stages if isinstance(stage, dict)
+                   and stage.get("stage") == row.get("stage")]
+        if len(matches) != 1 or not isinstance(matches[0].get("stepwiseExecution"), list):
+            continue
+        steps = matches[0]["stepwiseExecution"]
+        if not all(isinstance(step, dict) for step in steps) or row.get("stepCount") == len(steps):
+            continue
+        correction_id = next((f"RC-{n:03d}" for n in range(1, 1000) if f"RC-{n:03d}" not in used), None)
+        if correction_id is None:
+            break
+        used.add(correction_id)
+        derived.append({
+            "id": correction_id, "kind": "replace" if "stepCount" in row else "add",
+            "path": f"implementationPlanning.stageMap[{index}].stepCount",
+            "replacement": len(steps), "reason": "Derived from the matching stage's stepwiseExecution rows",
+            **({"current": row["stepCount"]} if "stepCount" in row else {}),
+        })
+        row["stepCount"] = len(steps)
+    return tuple(derived)
+
+
+def _complete_rewrites(
+    ledger: dict[str, Any], results: Mapping[str, Any], data: dict[str, Any],
+) -> tuple[dict[str, Any], list[str]]:
+    errors = validate(dict(results), corrections_schema()["$defs"]["RewriteResults"])
+    if errors:
+        return ledger, [_defect("rewrite-results", "-", error) for error in errors]
+    if results.get("baseNarrativeSha256") != ledger["baseNarrativeSha256"]:
+        errors.append("base narrative hash does not match")
+    rows = results.get("replacements")
+    rows = rows if isinstance(rows, list) else []
+    ids = [row.get("id") for row in rows if isinstance(row, dict)]
+    expected = {item["id"] for item in ledger["corrections"] if item.get("kind") == "rewrite"}
+    if len(ids) != len(set(ids)) or set(ids) != expected:
+        errors.append("replacement ids must name every rewrite exactly once and no other correction")
+    if errors:
+        return ledger, [_defect("rewrite-results", "-", error) for error in errors]
+    completed = deepcopy(ledger)
+    replacements = {row["id"]: row["replacement"] for row in rows}
+    for item in completed["corrections"]:
+        if item.get("kind") != "rewrite":
+            continue
+        found, _value = _resolve(data, parse_field_path(item["path"]))
+        item["kind"] = "replace" if found else "add"
+        item["replacement"] = replacements[item["id"]]
+    return completed, []
 
 
 def _constraints_for(
@@ -348,11 +458,10 @@ def _constraints_for(
 def render_applied_narrative(
     check: CorrectionsCheck, schema: Mapping[str, Any],
 ) -> str:
-    """기계적 교정(replace·remove)만 있는 원장을 적용한 서사 본문.
+    """확정 값으로 구성된 원장을 적용한 서사 본문.
 
-    작성자 라운드 없이 okstra 가 `reportNarrativePath` 에 쓰는 문서다. 결함이
-    있거나 `rewrite` 가 섞인 대조 결과는 받지 않는다 — 그 원장은 작성자가 다시
-    써야 할 자리가 있다.
+    기계적 교정이나 작성자가 제출한 교체 값의 대조를 마친 문서다. 결함이
+    있거나 아직 교체 값이 제출되지 않은 `rewrite` 가 섞인 결과는 받지 않는다.
     """
     if not check.mechanical or check.scratch is None:
         pending = [
@@ -363,8 +472,8 @@ def render_applied_narrative(
             list(check.defects)
             or [_defect(
                 ", ".join(pending) or "-", "-",
-                "rewrite entries need a writer round; only a ledger of replace "
-                "and remove entries can be applied mechanically",
+                "rewrite entries need a writer round; supply rewrite results "
+                "or use only replace, remove, add and move entries",
             )]
         )
     return render_narrative(check.scratch, schema)
@@ -398,10 +507,11 @@ def render_corrections_section(
     lines = [
         "## Corrections",
         "",
-        f"Your previous attempt is preserved at `{base_narrative_rel}`. Read that copy "
-        "and reproduce it verbatim, then apply only the corrections below. Do not read "
-        "your own `**Result Path:**` for this purpose: it is the same document and you "
-        f"are about to overwrite it. Corrections ledger: `{corrections_rel}`.",
+        f"Your previous attempt is preserved at `{base_narrative_rel}`. "
+        "The runtime preserves all fields outside the corrections. Read only the target "
+        "values and cited evidence below; expand to related source sections when needed. "
+        f"Corrections ledger: `{corrections_rel}`.",
+        f"Base narrative SHA-256: `{check.ledger['baseNarrativeSha256']}`.",
         "",
     ]
     for item in check.corrections:
@@ -413,15 +523,21 @@ def render_corrections_section(
         except ValueError:
             label = f"`{path}`"
         head = f"- {correction_id} `{kind}` — {label} (`{path}`): "
-        if kind == "replace":
+        if kind in {"replace", "add"}:
             current = (
                 f"current {_scalar_text(item['current'])}, " if "current" in item else ""
             )
             action = f"{current}write exactly {_scalar_text(item.get('replacement'))}."
         elif kind == "remove":
             action = "remove this item or field entirely; renumber the remaining `- Item N` rows 1..N."
+        elif kind == "move":
+            action = f"move the unchanged value from `{item.get('fromPath')}`."
         else:
             action = f"rewrite this part so that: {item.get('rule')}"
+            found, value = _resolve(check.scratch, parse_field_path(path))
+            action += " Current value: " + (json.dumps(value, ensure_ascii=False) if found else "<absent>") + "."
+            if item.get("evidenceRefs"):
+                action += " Evidence: " + ", ".join(f"`{ref}`" for ref in item["evidenceRefs"]) + "."
         constraint_lines = check.constraints.get(correction_id, ())
         if constraint_lines:
             action += " Schema constraint: " + " ".join(constraint_lines)

package/runtime/python/okstra_ctl/report_finalize.py

@@ -597,8 +597,12 @@ def run_finalize(
 
     if only:
         selected = set(only)
-        if ctx.report_contract_version == "3.0" and STEP_TRANSLATE in selected:
-            selected.add(STEP_PREFLIGHT)
+        if ctx.report_contract_version == "3.0":
+            if STEP_TRANSLATE in selected:
+                selected.add(STEP_PREFLIGHT)
+            if selected - {STEP_TOKEN_USAGE}:
+                # 부분 재개도 이전 조립본이 아닌 현재 소유자 입력을 소비한다.
+                selected.add(STEP_PROJECT_ACTIVITY)
         contract_order = (
             V3_STEP_ORDER if ctx.report_contract_version == "3.0" else STEP_ORDER
         )
@@ -644,13 +648,15 @@ def _execute_finalize_steps(
     steps: list[dict[str, Any]] = []
     first_failure = ""
     validated = False
-    preflight_failed = False
+    blocked: dict[str, str] = {}
     for name, command in commands:
         # 실패한 시퀀스가 worktree 를 거두면 재작업 대상이 사라지고, 검증 안 된
         # 레코드를 기억하면 형제 task 가 그것을 결론으로 읽는다.
-        if name in _SKIPPED_AFTER_FAILURE and first_failure:
+        if name in _SKIPPED_AFTER_FAILURE and first_failure and name not in blocked:
             continue
-        if name == STEP_TRANSLATE and preflight_failed:
+        if name in blocked:
+            steps.append({"name": name, "status": "skipped", "exitCode": None,
+                          "blockedBy": blocked[name]})
             continue
         if before_step is not None:
             before_step(name)
@@ -663,8 +669,16 @@ def _execute_finalize_steps(
                 detail="\n".join(filter(None, [result.stderr, result.stdout])) or f"{name} exited {result.returncode}",
             )
         steps.append(step)
-        if name == STEP_PREFLIGHT:
-            preflight_failed = result.returncode != 0
+        if result.returncode != 0:
+            if name == STEP_PROJECT_ACTIVITY:
+                for consumer, _ in commands:
+                    if consumer != STEP_TOKEN_USAGE or ctx.report_contract_version != "3.0":
+                        blocked[consumer] = name
+            elif name == STEP_PREFLIGHT:
+                blocked[STEP_TRANSLATE] = name
+                blocked[STEP_SPAWN_FOLLOWUPS] = name
+            elif name == STEP_RENDER_VIEWS:
+                blocked[STEP_VALIDATE_RUN] = name
         if result.returncode != 0 and not first_failure:
             first_failure = f"{name} failed with exit code {result.returncode}"
         if name == STEP_VALIDATE_RUN and result.returncode == 0:
@@ -1106,6 +1120,9 @@ def _step_summary_lines(
     lines = []
     for step in result.get("steps") or []:
         code = step.get("exitCode")
+        if step.get("status") == "skipped":
+            lines.append(f"  [skip] {step.get('name')} (blocked by {step.get('blockedBy')})")
+            continue
         mark = "ok  " if code == 0 else "FAIL"
         lines.append(f"  [{mark}] {step.get('name')} (exit {code})")
     for name in order:
@@ -1129,7 +1146,7 @@ def _recovery_step_names(
     failed = {
         string_value(step.get("name"))
         for step in (result.get("steps") or [])
-        if step.get("exitCode") != 0
+        if step.get("exitCode") not in (None, 0)
     }
     for index, name in enumerate(order):
         if name in failed:

package/runtime/python/okstra_ctl/report_html/router.py

@@ -5,6 +5,7 @@ from ..report_contract import html_template_for
 from .models import HtmlRoute
 from .view_models.change_impact_analysis import build_change_impact_analysis_view
 from .view_models.error_analysis import build_error_analysis_view
+from .view_models.technical_verification import build_technical_verification_view
 from .view_models.feature_analysis import build_feature_analysis_view
 from .view_models.final_verification import build_final_verification_view
 from .view_models.improvement_discovery import build_improvement_discovery_view
@@ -23,6 +24,7 @@ class HtmlRenderError(ValueError):
 
 
 VIEW_BUILDERS = {
+    "technical-verification": build_technical_verification_view,
     "requirements-discovery": build_requirements_discovery_view,
     "improvement-discovery": build_improvement_discovery_view,
     "error-analysis": build_error_analysis_view,

package/runtime/python/okstra_ctl/report_html/view_models/technical_verification.py

@@ -0,0 +1,21 @@
+"""기술 검증 입력과 관측 결과의 보고서 표시."""
+
+from __future__ import annotations
+
+from ..common import evidence_index
+from ..models import HumanReportView
+
+
+def build_technical_verification_view(data: dict) -> HumanReportView:
+    anchored = ("technicalVerification.checks",)
+    return HumanReportView(
+        "technical-verification",
+        "html/tasks/technical-verification.template.html",
+        {
+            "humanSummary": data["humanSummary"],
+            "verification": data["technicalVerification"],
+            "evidenceIndex": evidence_index(data, anchored),
+        },
+        (),
+        anchored_fields=anchored,
+    )

package/runtime/python/okstra_ctl/report_projections.py

@@ -1,6 +1,8 @@
 """역할별 실행 입력을 최종 리포트 조각으로 바꾸는 순수 투영."""
 from __future__ import annotations
 
+from okstra_token_usage.blocks import accounting_workers
+
 import json
 from copy import deepcopy
 from typing import Any, Mapping, Sequence
@@ -148,8 +150,7 @@ def project_execution(
         "role": "Okstra lead",
     }
     lead_usage = team_state.get("leadUsage")
-    workers = team_state.get("workers")
-    worker_rows = workers if isinstance(workers, list) else []
+    worker_rows = accounting_workers(team_state)
     result: dict[str, Any] = {
         "executionStatus": [
             _execution_row(
@@ -181,7 +182,7 @@ def _usage_row(summary: Mapping[str, Any], prefix: str, cost: object) -> dict[st
 
 def _worker_details(team_state: Mapping[str, Any]) -> list[dict[str, Any]]:
     result = []
-    for worker in team_state.get("workers") or []:
+    for worker in accounting_workers(team_state):
         if not isinstance(worker, Mapping):
             continue
         usage = worker.get("usage") if isinstance(worker.get("usage"), Mapping) else {}