okstra 0.197.1 → 0.198.0

package/runtime/python/okstra_ctl/worker_audit_check.py

@@ -31,12 +31,16 @@ _CLI_EPILOG = r"""Usage:
     --seq <nnn> [--worker <id>]
 
   --run-dir    the run directory; worker-results/ and prompts/ hang off it
+  --seq        this run's seq; a bare number is zero-padded to three digits
   --worker     check only this worker (default: every worker in the run)
 
 Emits one JSON object — `{ok, inspected, inspectedFiles[], failures[],
 blocking[], advisory[], runImpact}` — and exits 2 when failures[] is
 non-empty, 0 otherwise. `failures` is `blocking` followed by `advisory`.
 
+A selector that matches no result file also exits 2, carrying `selectorError`
+instead of failures: nothing was checked, which is not a pass.
+
 Runs the Phase 7 audit-sidecar rules now, while the worker session is still
 alive: that every result file carries no `## 0. Reading Confirmation` heading,
 that its audit sidecar exists (blocking), and that every backticked `path:line`
@@ -49,6 +53,15 @@ row alone.
 """
 
 
+# 결과 파일명은 seq 를 3자리로 적고, 선택은 그 문자열과의 동등 비교다
+# (`worker_audit_ledger.worker_result_files`). `--seq 1` 은 `001` 과 같지 않아
+# 전건이 걸러지고, 검사 0건은 실패 0건이므로 통과로 읽혔다 — 2026-09-10
+# dev-10642-15 final-verification 001 실측.
+def _normalized_seq(value: str) -> str:
+    text = value.strip()
+    return text.zfill(3) if text.isdigit() else text
+
+
 def _parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         epilog=_CLI_EPILOG,
@@ -59,8 +72,9 @@ def _parser() -> argparse.ArgumentParser:
     parser.add_argument("--run-dir", type=Path, required=True,
                         help="runs/<task-type>/ for this run")
     parser.add_argument("--task-type", required=True)
-    parser.add_argument("--seq", required=True,
-                        help="this run's 3-digit seq")
+    parser.add_argument("--seq", required=True, type=_normalized_seq,
+                        help="this run's seq; a bare number is zero-padded to "
+                             "three digits")
     parser.add_argument("--worker", default=None,
                         help="check only this worker id, with or without the "
                              "`-worker` suffix (default: every worker)")
@@ -83,20 +97,28 @@ def main(argv: list[str] | None = None) -> int:
             args.run_dir, args.task_type, args.seq, args.worker
         )
     ]
-    print(json.dumps(
-        {
-            "ok": not failures,
-            "inspected": len(inspected),
-            "inspectedFiles": inspected,
-            "failures": failures,
-            "blocking": blocking,
-            "advisory": advisory,
-            "runImpact": RUN_IMPACT,
-        },
-        ensure_ascii=False,
-        indent=2,
-    ))
-    return 2 if failures else 0
+    # 검사한 파일이 없다는 것과 위반이 없다는 것은 다른 사실이고, `ok` 는 둘을
+    # 구분하지 못한다. 선택자가 아무것도 고르지 못했으면 판정 자체가 없었으므로
+    # 통과로 보고하지 않는다.
+    selector_error = "" if inspected else (
+        f"no worker-results file matched task-type={args.task_type} "
+        f"seq={args.seq}"
+        + (f" worker={args.worker}" if args.worker else "")
+        + f" under {args.run_dir}"
+    )
+    payload = {
+        "ok": bool(not failures and inspected),
+        "inspected": len(inspected),
+        "inspectedFiles": inspected,
+        "failures": failures,
+        "blocking": blocking,
+        "advisory": advisory,
+        "runImpact": RUN_IMPACT,
+    }
+    if selector_error:
+        payload["selectorError"] = selector_error
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+    return 2 if failures or selector_error else 0
 
 
 if __name__ == "__main__":

package/runtime/python/okstra_ctl/worker_liveness.py

@@ -32,10 +32,11 @@ import argparse
 import json
 import sys
 import time
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
+from typing import Any
 
 from .wrapper_status import log_path_for_prompt
 
@@ -353,7 +354,47 @@ _ARTIFACT_FIELD_BY_MODE = {
 }
 
 
+def _dispatch_worker_id(record: Mapping[str, Any]) -> str:
+    """이 디스패치 행이 말하는 워커 id.
+
+    execution-identity v2 행에는 `workerId` 가 실리지 않는다
+    (`dispatch_core._dispatch_record`). 그 경우 `assignmentRef` 의 마지막 마디가
+    워커 id 이므로 — `initial/codex-verifier`, `critic/acceptance` — 거기서 읽는다.
+    """
+    worker_id = record.get("workerId")
+    if isinstance(worker_id, str) and worker_id.strip():
+        return worker_id.strip()
+    assignment_ref = record.get("assignmentRef")
+    if isinstance(assignment_ref, str) and assignment_ref.strip():
+        return assignment_ref.strip().rsplit("/", 1)[-1]
+    return ""
+
+
+def _dispatch_fallback(state: Mapping[str, Any], worker_id: str) -> dict:
+    """같은 워커의 디스패치 행 중 마지막 것.
+
+    로스터 행에 없는 키를 여기서 보충한다. 재디스패치는 같은 워커의 행을 뒤에
+    덧붙이므로 마지막 행이 이번 시도다.
+    """
+    records = state.get("workerDispatches")
+    if not isinstance(records, list):
+        return {}
+    matches = [
+        row for row in records
+        if isinstance(row, Mapping) and _dispatch_worker_id(row) == worker_id
+    ]
+    return dict(matches[-1]) if matches else {}
+
+
 def _worker_row(team_state_path: Path, worker_id: str) -> dict:
+    """이 워커의 프로브 입력 — 로스터 행에 디스패치 행을 덧댄 것.
+
+    `livenessMode` 는 디스패치 행에만 실린다(`dispatch_core._dispatch_record`);
+    로스터 행은 그 키를 갖지 않는다. 로스터만 읽으면 cmux 백엔드의 모든 run 에서
+    프로브가 전면 거부되고, 리드는 계약이 금지한 자체 폴링으로 밀려난다.
+    보충은 로스터에 없거나 빈 키에만 적용한다 — `startedAt` 처럼 로스터가 정본인
+    값을 디스패치 행이 덮어쓰면 grace 앵커가 이번 시도에서 어긋난다.
+    """
     state = load_json_object(team_state_path, "team-state")
     workers = state.get("workers")
     if not isinstance(workers, list):
@@ -367,7 +408,12 @@ def _worker_row(team_state_path: Path, worker_id: str) -> dict:
     )
     if worker is None:
         raise DispatchError(f"team-state has no workerId={worker_id}: {team_state_path}")
-    return worker
+    merged = dict(worker)
+    for key, value in _dispatch_fallback(state, worker_id).items():
+        current = merged.get(key)
+        if key not in merged or (isinstance(current, str) and not current.strip()):
+            merged[key] = value
+    return merged
 
 
 def probe_target(team_state_value: str, worker_id: str) -> ProbeTarget:

package/runtime/python/okstra_ctl/workflow.py

@@ -88,7 +88,7 @@ PHASE_RULES: dict[str, dict[str, str]] = {
     "implementation-option-selection": {
         "allowed": (
             "  - candidate-comparison evidence for up to three options per worker\n"
-            "  - preselected-validation that re-evaluates the merged candidate set\n"
+            "  - preselected-validation of exactly ONE candidate: every analyser returns its own feasibility verdict on that one direction, `candidateAudit` stays empty, and no analyser generates an alternative. It is not a re-evaluation of the merged set — `okstra_ctl.implementation_options._validate_mode` rejects a preselected-validation report carrying more than one option or a non-empty audit\n"
             "  - a ranked display of at most three options with requirement mappings\n"
             "  - an audit record for every rejected candidate\n"
             "  - one endStateCoverage row per brief end-state id (this phase authors no goal of its own)"

package/runtime/skills/okstra-run/SKILL.md

@@ -191,6 +191,7 @@ Repeat until `next.kind == "done"` (or `"aborted"` — terminal cancel, see "How
 
 That is the entire interactive flow. The wizard handles:
 
+- project report language before task selection: when `.okstra/project.json` has no `reportLanguage` value, ask for a language tag and save the answer to that file. An existing value skips this question. Prompt rendering and progress estimation do not save a language,
 - new-vs-existing task split (remaining work — `workStatus != done` — top-3 newest recommendations + Enter directly), task-group / task-id slug validation (task-group offers the top-3 newest candidates combining recent task use + recent `.okstra/briefs/<group>/` creation activity + Enter directly; task-id offers the top-3 recent candidates from the same group + Enter directly),
 - task-type pick (3 options + Enter directly; Enter directly is validated against the full task-type whitelist in a follow-up `text` step). **For a brand-new task the brief is asked first** and the three options are entry phases only (`requirements-discovery` / `improvement-discovery` / `project-analysis` / `feature-analysis` / `change-impact-analysis` / `error-analysis`) — a new task-key has no approved plan, no implementation and no commits, so `implementation`, `final-verification` and `release-handoff` cannot be entered there; the recommended slot comes from the selected brief's `Recommended next phase:` line and falls back to `requirements-discovery` when the brief carries none. For an existing task-key what fills those three depends on `workflow.nextRecommendedPhase` — an object `{phase, status, rationale}`, not a phase-name string. `status: ready` gives the classic trio: its `phase` marked recommended, re-run the current phase, the lifecycle's next step. Any other status contributes nothing at all, since both the recommended slot and the next-step slot derive from that phase — re-run the current phase becomes the first option and the remaining slots fill unlabelled from recently used task-types and then the whitelist. Never recover a phase name from a non-`ready` pointer and propose it yourself: prepare deliberately lowers the pointer to `pending` while its run is unfinished, and the missing recommendation is that signal,
 - brief path — **for a new task it is asked right after task-group, before the task-type** (it is the only input that says what the task is, and the task-type recommendation reads it); for an existing task it is **asked only for entry task-types (requirements-discovery / error-analysis / improvement-discovery / project-analysis / feature-analysis / change-impact-analysis)** (same-group `.okstra/briefs/<task-group>/**/*.md` candidates first, sorted by the newer of file-created/modified time and latest task-catalog use; direct input last; `Keep / Change` for existing entry tasks). `project-analysis`, `feature-analysis`, and `change-impact-analysis` are brief entry task types. On an existing task a downstream lifecycle task-type auto carries in the manifest's brief, and when no registered brief exists a `brief_carry` 3-option prompt appears (recommend switching to entry / Enter directly / Abort). `release-handoff` has no brief step of its own — a new-task run answers the brief before the type is known, and the brief is dropped at render time, so prepare always generates the input document that cites the verification report,

package/runtime/validators/validate-run.py

@@ -115,6 +115,7 @@ from okstra_ctl.final_report_paths import (  # noqa: E402
 )
 from okstra_token_usage.report import _match_worker_index  # noqa: E402
 from okstra_ctl.implementation_options import (  # noqa: E402
+    validate_blocked_answer_channel,
     validate_implementation_option_selection,
 )
 from okstra_ctl.implementation_direction import (  # noqa: E402
@@ -149,6 +150,7 @@ from okstra_ctl.agent.invocation import (  # noqa: E402
     AgentInvocationError,
     agent_model_assignment_from_payload,
     invocation_execution_identity_from_manifest,
+    invocation_input_digest,
     verify_agent_invocation,
 )
 from okstra_ctl.execution_identity import ExecutionManifestError  # noqa: E402
@@ -253,6 +255,39 @@ def _result_link_attempt_status_failure(
     )
 
 
+def _dispatch_input_digest(
+    project_root: Path, row: Mapping[str, Any]
+) -> tuple[str | None, str]:
+    """이 디스패치의 예약 입력 해시, 예약이 계산한 것과 같은 방법으로.
+
+    `inputDigest` 와 `promptDigest` 는 서로 다른 대상이다. 전달 계약
+    `execution-identity-v1` 부터 예약은 **논리 작업**을 해시한다 — 시도별 전달값과
+    prompt history 경로를 뺀 본문(`agent_prompt_task_bytes`) — 반면 `promptDigest`
+    는 프롬프트 파일 전체 바이트다. 둘을 동등 비교하면 그 계약을 쓰는 run 은
+    통과할 수 있는 값이 하나도 없다(2026-09-08 f56ec08 이후 전부, 2026-09-10
+    dev-10642-15 final-verification 001 에서 7/7 디스패치가 이 규칙에 걸렸다).
+
+    그래서 재구현하지 않고 예약이 쓰는 함수를 그대로 부른다. 메타데이터 경로가
+    없는 구형 행만 `promptDigest` 로 돌아간다 — 그 계약에서는 두 값이 같다.
+    """
+    metadata_value = row.get("promptMetadataPath")
+    if not isinstance(metadata_value, str) or not metadata_value.strip():
+        return row.get("promptDigest"), ""
+    try:
+        metadata = json.loads(
+            _resolve_prompt_record_path(project_root, metadata_value)
+            .read_text(encoding="utf-8")
+        )
+    except (OSError, json.JSONDecodeError):
+        return None, "prompt metadata is missing or invalid"
+    if not isinstance(metadata, Mapping):
+        return None, "prompt metadata is not an object"
+    try:
+        return invocation_input_digest(metadata, project_root), ""
+    except (AgentInvocationError, KeyError, OSError, ValueError) as exc:
+        return None, f"input digest cannot be recomputed: {exc}"
+
+
 def _validate_agent_dispatch_contract(
     *,
     project_root: Path,
@@ -399,12 +434,16 @@ def _validate_agent_dispatch_contract(
                 )
                 continue
             invocation = canonical_invocations.get(row.get("invocationRef"))
+            input_digest, digest_error = _dispatch_input_digest(project_root, row)
+            if digest_error:
+                failures.append(f"agent dispatch {dispatch_id}: {digest_error}")
+                continue
             if not isinstance(invocation, Mapping) or any((
                 invocation.get("participantRef") != row.get("participantRef"),
                 invocation.get("roleExecutionRef") != row.get("roleExecutionRef"),
                 invocation.get("dutyId") != row.get("dutyId"),
                 invocation.get("dispatchKind") != dispatch_kind,
-                invocation.get("inputDigest") != row.get("promptDigest"),
+                invocation.get("inputDigest") != input_digest,
                 )):
                 failures.append(
                     f"agent dispatch {dispatch_id}: does not match canonical invocation"
@@ -3273,6 +3312,10 @@ def validate_final_report_data(
                 participating_analysers,
             )
         )
+        failures.extend(
+            f"implementation-option-selection: {error}"
+            for error in validate_blocked_answer_channel(data)
+        )
     elif task_type == "implementation":
         _validate_stage_carry_sidecar_exists(data, report_path, failures)
     _validate_lead_authored_report(data, report_path, failures)