okstra 0.77.0 → 0.78.0

package/runtime/python/okstra_ctl/wrapper_status.py

@@ -0,0 +1,55 @@
+"""Reader for okstra worker wrapper status sidecars."""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Mapping
+
+
+@dataclass(frozen=True)
+class WrapperStatus:
+    path: Path
+    stage: str
+    exit_code: int | None
+    timeout: bool
+    log_path: Path | None
+    raw: Mapping[str, Any]
+
+    @property
+    def is_terminal(self) -> bool:
+        return self.stage == "exited"
+
+
+def status_path_for_prompt(prompt_path: Path) -> Path:
+    return prompt_path.with_suffix(prompt_path.suffix + ".status.json")
+
+
+def read_wrapper_status(path: Path) -> WrapperStatus | None:
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    if not isinstance(raw, dict):
+        return None
+    stage = raw.get("stage")
+    if not isinstance(stage, str) or not stage:
+        return None
+    return WrapperStatus(
+        path=path,
+        stage=stage,
+        exit_code=_optional_int(raw.get("exit_code")),
+        timeout=raw.get("timeout") is True,
+        log_path=_optional_path(raw.get("log_path")),
+        raw=raw,
+    )
+
+
+def _optional_int(value: object) -> int | None:
+    return value if isinstance(value, int) and not isinstance(value, bool) else None
+
+
+def _optional_path(value: object) -> Path | None:
+    if not isinstance(value, str) or not value.strip():
+        return None
+    return Path(value)

package/runtime/schemas/final-report-v1.0.schema.json

@@ -745,7 +745,7 @@
       }
     },
     {
-      "description": "final-verification verdict token must be one of accepted / conditional-accept / blocked.",
+      "description": "final-verification verdict token must be one of accepted / conditional-accept / blocked and must explicitly list conditional acceptance conditions.",
       "if": {
         "properties": { "header": { "properties": { "taskType": { "const": "final-verification" } } } },
         "required": ["header"]
@@ -753,6 +753,7 @@
       "then": {
         "properties": {
           "finalVerdict": {
+            "required": ["conditionalAcceptanceConditions"],
             "properties": {
               "verdictToken": { "enum": ["accepted", "conditional-accept", "blocked"] }
             }
@@ -775,6 +776,7 @@
       "then": {
         "properties": {
           "finalVerdict": {
+            "not": { "required": ["conditionalAcceptanceConditions"] },
             "properties": {
               "verdictToken": { "const": "not-applicable" }
             }

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

@@ -273,6 +273,9 @@ Agent(
 - Agent Teams mode: Spawn within an existing team
 - Fallback mode: Spawn with `run_in_background: true` and no `team_name`
 
+For `tmux-pane` backend runs, do not use the Agent snippet. For each reverify round, write a jobs file at `runs/<task-type>/state/reverify-jobs-r<N>-<task-type>-<seq>.json` with `dispatchKind: "reverify-r<N>"` and worker entries containing `workerId`, `provider`, `role`, `modelExecutionValue`, `promptPath`, `resultPath`, `workerResultPath`, and `completionPaths`; then run `okstra team dispatch --project-root <dir> --run-manifest <path> --dispatch-kind reverify-r<N> --jobs-file <jobs-file>` followed by `okstra team await --project-root <dir> --run-manifest <path>`.
+
+
 **Completion detection per round (BLOCKING).** Each round dispatches a variable set (1..N) of reverify workers asynchronously; the `Agent(... team_name ...)` calls return `Spawned successfully` immediately, which is NOT completion. Lead MUST detect each round's completion via the self-scheduled polling protocol in [okstra-team-contract](../okstra-team-contract/SKILL.md) "Worker-completion detection (self-scheduled polling)", with the pending set reconstructed from that round's dispatched workers' Result Paths — do NOT restate the algorithm here. Lead MUST NOT treat the spawn ack as completion and MUST NOT end its turn with a prose "waiting" statement.
 
 ### Required reverify-prompt anchor headers (BLOCKING)

package/runtime/skills/okstra-report-writer/SKILL.md

@@ -82,6 +82,9 @@ Except for `release-handoff` (which is single-lead by design and never dispatche
 
 Speculative reasons such as "session resume constraint", "team object no longer exists", or "lead can do it faster" are NOT valid.
 
+For `tmux-pane` backend runs, do not use the Agent template. Create a one-job jobs file for the `report-writer` with `dispatchKind: "report-writer"` and the same `workerId`, `provider`, `role`, `modelExecutionValue`, `promptPath`, `resultPath`, `workerResultPath`, and `completionPaths` fields used by reverify jobs. Then call `okstra team dispatch --project-root <dir> --run-manifest <path> --jobs-file <jobs-file>` followed by `okstra team await --project-root <dir> --run-manifest <path>`. Completion requires both the report data.json and the report-writer worker-results audit file.
+
+
 ## Phase 6 → Phase 7 execution sequence (BLOCKING order)
 
 The four steps below MUST execute in this exact order. Reordering them is the recurring root cause of reports shipping with `--` token cells (Phase 7 not run yet), Section 3 missing follow-up entries, or Section 4 rows never spawning.

package/runtime/skills/okstra-team-contract/SKILL.md

@@ -127,6 +127,18 @@ Terminal statuses that can be recorded for a worker:
 
 Lead dispatches workers asynchronously: an `Agent` call carrying `team_name` returns `Spawned successfully` **immediately** — that ack is NOT a completion. Lead MUST NOT treat the spawn ack as completion, and MUST NOT end its turn with a prose "waiting for ..." statement (that path stalls the run — the Agent Teams idle-notification is experimental and can be dropped, leaving Lead parked until the user manually nudges it). Instead:
 
+For `tmux-pane` backend runs, Lead MUST use exactly one background wait command instead of raw result-file polling:
+
+```bash
+okstra team await --project-root <dir> --run-manifest <path>
+```
+
+This command checks both result files and wrapper status sidecars. Raw result-file-only polling is forbidden for `tmux-pane` because pane creation and file presence alone are not terminal worker completion.
+
+For the Claude Code `team` backend, use the self-scheduled polling protocol below.
+
+
+
 1. Record the dispatched workers' Result Paths as the **pending set** (resolved to absolute from each launch prompt's `**Result Path:**` anchor header against `**Project Root:**`; the same paths recorded in run-manifest / team-state).
 2. Arm a SINGLE self-wakeup: one `Bash(run_in_background: true)` poll covering ALL dispatched workers (not one background task per worker):
 

package/runtime/validators/forbidden_actions.py

@@ -0,0 +1,135 @@
+"""Phase 별 금지 행위(publish/deploy/force-push)의 post-hoc 자동 스캐너.
+
+배경: 금지 행위는 `prompts/profiles/forbidden-actions.json` (SSOT) 에 선언되고
+launch 경계(PHASE_FORBIDDEN_ACTIONS)와 profile 본문으로 렌더되지만, 지금까지 lead 의
+수동 self-review 로만 감사됐다(코드 강제 없음). 이 모듈은 run 종료 후 세션 transcript 의
+Bash tool_use 명령을 phase deny-list 와 대조해 위반을 기계적으로 잡아낸다.
+
+스캔 규칙(false-positive 방지가 핵심, validate_session_conformance 와 동일 seam):
+- `type == "assistant"` 레코드만, `isSidechain` 제외.
+- run 윈도우(resolve_run_window)로 스코핑 — 같은 세션 jsonl 에 섞인 직전 run 의
+  명령을 증거로 오인하지 않는다.
+- Bash tool_use 의 `input.command` 만 본다 — text 블록(설명/금지어 언급)이나 다른
+  tool 의 인자는 보지 않으므로 "npm publish 하지 말 것" 같은 산문은 잡히지 않는다.
+
+한계 1: claude-code 세션 jsonl 만 스캔한다. codex/gemini lead·worker 는 동일 형식의
+tool_use transcript 를 ~/.claude/projects 에 남기지 않으므로 이 스캐너의 사정권 밖이며,
+해당 런타임의 금지 행위는 여전히 수동 감사에 의존한다.
+한계 2: deny-list 는 Bash 명령 문자열 전체를 검색하므로, 금지 토큰이 인자/메시지에
+등장하는 경우(예: `git commit -m "... npm publish ..."`)도 위반으로 잡힐 수 있다.
+`cd <path> && <cmd>` 형태 때문에 명령 head 앵커링은 불가하므로 이 잔여 오탐은 감수한다.
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+from pathlib import Path
+
+_UNIVERSAL = [
+    ("npm publish", re.compile(r"\bnpm\s+publish\b")),
+    ("cargo publish", re.compile(r"\bcargo\s+publish\b")),
+    ("pip publish", re.compile(r"\bpip\s+publish\b")),
+    ("twine upload", re.compile(r"\btwine\s+upload\b")),
+    ("gh release", re.compile(r"\bgh\s+release\s+(create|edit)\b")),
+    ("docker push", re.compile(r"\bdocker\s+push\b")),
+    ("terraform apply", re.compile(r"\bterraform\s+apply\b")),
+    ("kubectl apply", re.compile(r"\bkubectl\s+apply\b")),
+    ("git push --force", re.compile(r"\bgit\s+push\b.*(?:--force(-with-lease)?|\s-[A-Za-z]*f)")),
+]
+_NON_HANDOFF_PUSH = ("git push", re.compile(r"\bgit\s+push\b"))
+
+
+def forbidden_patterns_for(task_type: str) -> list[tuple[str, re.Pattern]]:
+    """task_type(=phase profile) 의 deny-list. 모든 phase 가 _UNIVERSAL 을 받고,
+    release-handoff 를 제외한 모든 phase 는 bare `git push` 도 금지한다
+    (release-handoff 는 feature 브랜치 push 가 정당하므로 제외)."""
+    patterns = list(_UNIVERSAL)
+    if task_type != "release-handoff":
+        patterns.append(_NON_HANDOFF_PUSH)
+    return patterns
+
+
+def _ensure_token_usage_importable() -> None:
+    """okstra_token_usage 패키지를 레이아웃별(repo/scripts, runtime/python,
+    OKSTRA_PYTHONPATH)로 해소 — validate_session_conformance 와 동일 후보."""
+    here = Path(__file__).resolve().parent
+    candidates = [here.parent / "scripts", here.parent / "python"]
+    env_pp = os.environ.get("OKSTRA_PYTHONPATH", "").strip()
+    if env_pp:
+        candidates.append(Path(env_pp))
+    for candidate in candidates:
+        if candidate.is_dir() and (candidate / "okstra_token_usage").is_dir():
+            if str(candidate) not in sys.path:
+                sys.path.insert(0, str(candidate))
+            break
+
+
+def _scan_one(
+    path: Path,
+    since: str | None,
+    until: str | None,
+    patterns: list[tuple[str, re.Pattern]],
+) -> list[tuple[str, str]]:
+    """jsonl 한 파일에서 deny-list 에 걸린 (label, command) 쌍을 추출한다."""
+    from okstra_token_usage.paths import ts_in_window
+
+    hits: list[tuple[str, str]] = []
+    try:
+        fh = path.open(encoding="utf-8")
+    except OSError:
+        return hits
+    with fh:
+        for raw in fh:
+            try:
+                rec = json.loads(raw)
+            except (json.JSONDecodeError, UnicodeDecodeError):
+                continue
+            if rec.get("type") != "assistant" or rec.get("isSidechain"):
+                continue
+            ts = rec.get("timestamp") or ""
+            if ts and not ts_in_window(ts, since, until):
+                continue
+            for block in (rec.get("message") or {}).get("content") or []:
+                if not isinstance(block, dict):
+                    continue
+                if block.get("type") != "tool_use" or block.get("name") != "Bash":
+                    continue
+                command = (block.get("input") or {}).get("command") or ""
+                for label, pattern in patterns:
+                    if pattern.search(command):
+                        hits.append((label, command))
+                        break  # one violation per command — most-specific pattern wins
+    return hits
+
+
+def scan_forbidden_actions(
+    *,
+    team_state: dict,
+    team_state_path: Path,
+    project_root: Path,
+    task_type: str,
+    claude_projects_dir: Path | None = None,
+) -> list[str]:
+    """Return human-readable violation strings (empty = clean)."""
+    _ensure_token_usage_importable()
+    from okstra_token_usage.claude import find_claude_team_sessions
+    from okstra_token_usage.collect import resolve_run_window, resolve_team_name
+
+    since, until = resolve_run_window(team_state_path, team_state)
+    lead_sid = (team_state.get("lead") or {}).get("sessionId") or ""
+    sessions = find_claude_team_sessions(
+        project_root,
+        resolve_team_name(team_state),
+        lead_sid,
+        projects_root=claude_projects_dir,
+    )
+    patterns = forbidden_patterns_for(task_type)
+    violations: list[str] = []
+    for sid, path in sorted(sessions.items()):
+        for label, command in _scan_one(path, since, until, patterns):
+            violations.append(
+                f"{label} 명령이 세션 {sid} 에서 실행됨: {command.strip()[:120]}"
+            )
+    return violations

package/runtime/validators/validate-run.py

@@ -47,11 +47,25 @@ from okstra_ctl.md_table import (  # noqa: E402
 
 TERMINAL_STATUSES = {"completed", "timeout", "error", "not-run"}
 ATTEMPTED_STATUSES = {"completed", "timeout", "error"}
-CODEX_DISPATCH_MODES = {"cli-wrapper", "mixed"}
+WORKER_DISPATCH_MODES = {"cli-wrapper", "mixed", "tmux-pane"}
 
 
 def utc_now() -> str:
     return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+def _session_accounting(team_state: dict) -> str:
+    adapter = (
+        team_state.get("leadAdapter") if isinstance(team_state.get("leadAdapter"), dict) else {}
+    )
+    value = str(adapter.get("sessionAccounting", "")).strip()
+    if value:
+        return value
+    return (
+        "artifact-only"
+        if team_state.get("leadRuntime") in {"codex", "external"}
+        else "claude-jsonl"
+    )
+
+
 
 
 def load_json(path: Path) -> dict:
@@ -402,12 +416,15 @@ def validate_team_state(
         for w in workers
     )
     if any_dispatched:
-        if team_state.get("leadRuntime") == "codex":
-            dispatch_mode = str(team_state.get("dispatchMode", "")).strip()
-            if dispatch_mode not in CODEX_DISPATCH_MODES:
-                expected = ", ".join(sorted(CODEX_DISPATCH_MODES))
+        dispatch_mode = str(team_state.get("dispatchMode", "")).strip()
+        if (
+            dispatch_mode in WORKER_DISPATCH_MODES
+            or team_state.get("leadRuntime") in {"codex", "external"}
+        ):
+            if dispatch_mode not in WORKER_DISPATCH_MODES:
+                expected = ", ".join(sorted(WORKER_DISPATCH_MODES))
                 failures.append(
-                    "team-state.dispatchMode must be set for Codex worker dispatch "
+                    "team-state.dispatchMode must be set for non-Team worker dispatch "
                     f"(expected one of: {expected})"
                 )
         else:
@@ -1076,7 +1093,7 @@ def validate_worker_results_audit(
 
 
 def validate_team_state_usage(team_state: dict, failures: list[str]) -> None:
-    if team_state.get("leadRuntime") == "codex":
+    if _session_accounting(team_state) == "artifact-only":
         return
     summary = team_state.get("usageSummary") or {}
     if not summary or not summary.get("collectedAt"):
@@ -1837,6 +1854,37 @@ def _validate_session_conformance(
     failures.extend(f"session-conformance: {err}" for err in result.errors)
 
 
+def _validate_forbidden_actions(
+    team_state: dict,
+    team_state_path: Path,
+    project_root: Path,
+    task_type: str,
+    claude_projects_dir: str | None,
+    failures: list[str],
+) -> None:
+    """phase deny-list(publish/deploy/force-push, 비-release-handoff bare push)
+    위반을 세션 transcript 에서 스캔해 ``forbidden-action: `` 접두로 folding 한다.
+    설계: docs/superpowers/plans/2026-06-13-repo-risk-hardening.md (P2-3)."""
+    _validators_dir = Path(__file__).resolve().parent
+    if str(_validators_dir) not in sys.path:
+        sys.path.insert(0, str(_validators_dir))
+    try:
+        from forbidden_actions import scan_forbidden_actions  # noqa: E402
+    except ImportError as exc:
+        failures.append(
+            f"forbidden-action: scan_forbidden_actions import failed — {exc}"
+        )
+        return
+    violations = scan_forbidden_actions(
+        team_state=team_state,
+        team_state_path=team_state_path,
+        project_root=project_root,
+        task_type=task_type,
+        claude_projects_dir=Path(claude_projects_dir) if claude_projects_dir else None,
+    )
+    failures.extend(f"forbidden-action: {v}" for v in violations)
+
+
 def _validate_requirements_discovery_fanout(run_dir, failures) -> None:
     """requirements-discovery run 에 fan-out/ 이 있으면 packet+index 를 검증해
     실패를 ``requirements-discovery: `` 접두로 folding 한다. fan-out 이 없으면 no-op.
@@ -1936,7 +1984,7 @@ def _import_token_usage():
 
 
 def _needs_token_autofix(team_state: dict, report_path: Path) -> bool:
-    if team_state.get("leadRuntime") == "codex":
+    if _session_accounting(team_state) == "artifact-only":
         return False
     summary = team_state.get("usageSummary") or {}
     if not summary or not summary.get("collectedAt"):
@@ -2220,7 +2268,7 @@ def main() -> int:
         report_path,
         contract["required_agent_status_entries"],
         failures,
-        allow_unavailable_token_usage=team_state.get("leadRuntime") == "codex",
+        allow_unavailable_token_usage=_session_accounting(team_state) == "artifact-only",
     )
     validate_team_state_usage(team_state, failures)
 
@@ -2236,6 +2284,14 @@ def main() -> int:
             args.claude_projects_dir,
             failures,
         )
+        _validate_forbidden_actions(
+            team_state,
+            team_state_path,
+            project_root,
+            task_type,
+            args.claude_projects_dir,
+            failures,
+        )
     if task_type in ("implementation", "final-verification"):
         _sp = None
         _pj = project_json_path(project_root)

package/runtime/validators/validate_session_conformance.py

@@ -29,6 +29,7 @@ from datetime import datetime
 from pathlib import Path
 
 _DISPATCHED_STATUSES = {"completed", "timeout", "error", "in-progress"}
+_WORKER_DISPATCH_MODES = {"cli-wrapper", "mixed", "tmux-pane"}
 _ATTEMPTED_STATUSES = {"completed", "timeout", "error"}
 
 # lead 의 체크포인트 라인 — assistant text 블록 안에서 line-anchored 로만 인정.
@@ -200,15 +201,15 @@ def _resolve_lead_events_path(
     )
     if not raw:
         return None, (
-            "Codex lead event log path missing from team-state "
-            "(`leadEventsPath`) — leadRuntime=codex conformance cannot be verified."
+            "artifact lead event log path missing from team-state "
+            "(`leadEventsPath`) — artifact-only conformance cannot be verified."
         )
     path = Path(str(raw))
     if not path.is_absolute():
         path = project_root / path
     if not path.is_file():
         return None, (
-            f"Codex lead event log not found: {path} — leadRuntime=codex "
+            f"artifact lead event log not found: {path} — artifact-only "
             "conformance cannot be verified."
         )
     return path, None
@@ -216,7 +217,8 @@ def _resolve_lead_events_path(
 
 def _event_matches_run(event, team_state: dict, task_type: str, run_seq: str) -> bool:
     task_key = str(team_state.get("taskKey", ""))
-    if event.lead_runtime != "codex":
+    expected_runtime = str(team_state.get("leadRuntime", "") or "claude-code")
+    if event.lead_runtime != expected_runtime:
         return False
     if task_key and event.task_key != task_key:
         return False
@@ -255,7 +257,7 @@ def _sidecar_read_from_event(event) -> tuple[str, str] | None:
     return (basename, event.timestamp)
 
 
-def _collect_codex_lead_evidence(
+def _collect_artifact_lead_evidence(
     team_state: dict,
     project_root: Path,
     task_type: str,
@@ -263,7 +265,7 @@ def _collect_codex_lead_evidence(
 ) -> tuple[_LeadEvidence | None, str | None]:
     if not suffix or "-" not in suffix:
         return None, (
-            "Codex lead event log cannot be scoped because team-state filename "
+            "artifact lead event log cannot be scoped because team-state filename "
             "does not expose a run artifact suffix."
         )
     events_path, error = _resolve_lead_events_path(team_state, project_root)
@@ -278,7 +280,7 @@ def _collect_codex_lead_evidence(
     try:
         events = read_lead_events(events_path)
     except LeadEventParseError as exc:
-        return None, f"Codex lead event log is malformed — {exc}"
+        return None, f"artifact lead event log is malformed — {exc}"
 
     run_seq = suffix.rsplit("-", 1)[1]
     evidence = _LeadEvidence(scanned_files=[events_path])
@@ -531,13 +533,16 @@ def validate_session_conformance(
         result.errors.append(f"okstra_token_usage import failed — {exc}")
         return result
 
-    run_dir = report_path.parent.parent  # reports/ 의 부모 = run 디렉터리
+    run_dir = report_path.parent.parent
     _check_heartbeat_sidecars(run_dir, task_type, result.errors)
     suffix = run_artifact_suffix(team_state_path)
 
     lead_runtime = team_state.get("leadRuntime", "") or "claude-code"
-    if lead_runtime == "codex":
-        evidence, error = _collect_codex_lead_evidence(
+    dispatch_mode = str(team_state.get("dispatchMode", "")).strip()
+    if lead_runtime in {"codex", "external"} or (
+        lead_runtime == "claude-code" and dispatch_mode in _WORKER_DISPATCH_MODES
+    ):
+        evidence, error = _collect_artifact_lead_evidence(
             team_state, project_root, task_type, suffix
         )
     else: