okstra 0.76.0 → 0.78.0

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,10 +47,25 @@ from okstra_ctl.md_table import (  # noqa: E402
 
 TERMINAL_STATUSES = {"completed", "timeout", "error", "not-run"}
 ATTEMPTED_STATUSES = {"completed", "timeout", "error"}
+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:
@@ -401,27 +416,39 @@ def validate_team_state(
         for w in workers
     )
     if any_dispatched:
-        team_create = team_state.get("teamCreate")
-        if _is_legal_concurrent_run_skip(team_create, concurrent_run_authorized):
-            pass
-        elif not isinstance(team_create, dict) or not team_create.get("attempted"):
-            failures.append(
-                "team-state.teamCreate.attempted must be true once any worker has "
-                "been dispatched (status in completed/timeout/error/in-progress). "
-                "Phase 3 (TeamCreate) was skipped — workers ran in-process without "
-                "the Teams split-pane surface. See agents/SKILL.md Phase 3. "
-                "(The no-team concurrent-run path is legal ONLY when the "
-                "run-manifest carries prepare-recorded `concurrentRun.detected: "
-                'true` AND team-state records `teamCreate: { attempted: false, '
-                'status: "skipped", reason: "concurrent-run" }`.)'
-            )
+        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 non-Team worker dispatch "
+                    f"(expected one of: {expected})"
+                )
         else:
-            tc_status = str(team_create.get("status", "")).strip()
-            if tc_status not in {"ok", "error"}:
+            team_create = team_state.get("teamCreate")
+            if _is_legal_concurrent_run_skip(team_create, concurrent_run_authorized):
+                pass
+            elif not isinstance(team_create, dict) or not team_create.get("attempted"):
                 failures.append(
-                    "team-state.teamCreate.status must be `ok` or `error` once "
-                    f"workers have been dispatched (found: `{tc_status}`)."
+                    "team-state.teamCreate.attempted must be true once any worker has "
+                    "been dispatched (status in completed/timeout/error/in-progress). "
+                    "Phase 3 (TeamCreate) was skipped — workers ran in-process without "
+                    "the Teams split-pane surface. See agents/SKILL.md Phase 3. "
+                    "(The no-team concurrent-run path is legal ONLY when the "
+                    "run-manifest carries prepare-recorded `concurrentRun.detected: "
+                    'true` AND team-state records `teamCreate: { attempted: false, '
+                    'status: "skipped", reason: "concurrent-run" }`.)'
                 )
+            else:
+                tc_status = str(team_create.get("status", "")).strip()
+                if tc_status not in {"ok", "error"}:
+                    failures.append(
+                        "team-state.teamCreate.status must be `ok` or `error` once "
+                        f"workers have been dispatched (found: `{tc_status}`)."
+                    )
 
     by_role: dict[str, dict] = {}
     for worker in workers:
@@ -587,7 +614,12 @@ _TOKEN_USAGE_SENTINEL_VALUES = frozenset(
 _TOKEN_USAGE_ZERO_VALUES = frozenset({"0", "$0.00", "$0", "0.00"})
 
 
-def _scan_token_usage_summary(content: str, failures: list[str]) -> None:
+def _scan_token_usage_summary(
+    content: str,
+    failures: list[str],
+    *,
+    allow_unavailable_tokens: bool = False,
+) -> None:
     """Reject sentinel / zero values that workers typed into the Token
     Usage Summary table instead of leaving the `{{...}}` placeholders
     verbatim for Phase 7 substitution.
@@ -639,6 +671,8 @@ def _scan_token_usage_summary(content: str, failures: list[str]) -> None:
             for value in _TOKEN_USAGE_BACKTICK_CELL_RE.findall(raw_cell):
                 stripped = value.strip()
                 lowered = stripped.lower()
+                if allow_unavailable_tokens and stripped == "--":
+                    continue
                 if lowered in _TOKEN_USAGE_SENTINEL_VALUES:
                     failures.append(
                         "Token Usage Summary cell contains sentinel value "
@@ -883,7 +917,11 @@ def _validate_conformance(report_path: Path, failures: list[str],
 
 
 def validate_report(
-    report_path: Path, required_agent_status_entries: list[str], failures: list[str]
+    report_path: Path,
+    required_agent_status_entries: list[str],
+    failures: list[str],
+    *,
+    allow_unavailable_token_usage: bool = False,
 ) -> None:
     if not report_path.exists():
         failures.append(f"final report is missing: {report_path}")
@@ -905,7 +943,11 @@ def validate_report(
 
     # Catch the "workers typed `0` / `pending` instead of the placeholder"
     # failure mode that bypasses the placeholder check above.
-    _scan_token_usage_summary(content, failures)
+    _scan_token_usage_summary(
+        content,
+        failures,
+        allow_unavailable_tokens=allow_unavailable_token_usage,
+    )
 
     # Verdict Card is mandatory in every final-report (introduced with the
     # report-format readability pass). Missing card means the reader has no
@@ -1051,6 +1093,8 @@ def validate_worker_results_audit(
 
 
 def validate_team_state_usage(team_state: dict, failures: list[str]) -> None:
+    if _session_accounting(team_state) == "artifact-only":
+        return
     summary = team_state.get("usageSummary") or {}
     if not summary or not summary.get("collectedAt"):
         failures.append(
@@ -1810,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.
@@ -1909,6 +1984,8 @@ def _import_token_usage():
 
 
 def _needs_token_autofix(team_state: dict, report_path: Path) -> bool:
+    if _session_accounting(team_state) == "artifact-only":
+        return False
     summary = team_state.get("usageSummary") or {}
     if not summary or not summary.get("collectedAt"):
         return True
@@ -2187,7 +2264,12 @@ def main() -> int:
     _validate_fix_cycle(
         run_manifest, _load_final_report_data(report_path), failures
     )
-    validate_report(report_path, contract["required_agent_status_entries"], failures)
+    validate_report(
+        report_path,
+        contract["required_agent_status_entries"],
+        failures,
+        allow_unavailable_token_usage=_session_accounting(team_state) == "artifact-only",
+    )
     validate_team_state_usage(team_state, failures)
 
     validate_phase_boundary(task_type, report_path, failures)
@@ -2202,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 로만 인정.
@@ -190,6 +191,118 @@ def _collect_lead_evidence(
     return evidence, None
 
 
+def _resolve_lead_events_path(
+    team_state: dict, project_root: Path
+) -> tuple[Path | None, str | None]:
+    raw = team_state.get("leadEventsPath") or (
+        (team_state.get("artifacts") or {}).get("leadEventsPath")
+        if isinstance(team_state.get("artifacts"), dict)
+        else ""
+    )
+    if not raw:
+        return None, (
+            "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"artifact lead event log not found: {path} — artifact-only "
+            "conformance cannot be verified."
+        )
+    return path, None
+
+
+def _event_matches_run(event, team_state: dict, task_type: str, run_seq: str) -> bool:
+    task_key = str(team_state.get("taskKey", ""))
+    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
+    return event.task_type == task_type and event.run_seq == run_seq
+
+
+def _progress_line_from_event(event) -> tuple[str, str, str] | None:
+    details = event.details
+    phase = details.get("phase")
+    if not isinstance(phase, str) or not phase:
+        line_candidate = details.get("line")
+        if isinstance(line_candidate, str):
+            match = _PROGRESS_LINE_RE.search(line_candidate)
+            if match:
+                phase = match.group("phase")
+        if not isinstance(phase, str) or not phase:
+            return None
+    line = details.get("line")
+    if not isinstance(line, str) or not line:
+        message = details.get("message")
+        tail = f" {message}" if isinstance(message, str) and message else ""
+        line = f"PROGRESS: {phase}{tail}"
+    return (event.timestamp, phase, line)
+
+
+def _sidecar_read_from_event(event) -> tuple[str, str] | None:
+    details = event.details
+    if event.event_type != "sidecar-read" and details.get("kind") != "implementation-sidecar":
+        return None
+    basename = details.get("basename")
+    if not isinstance(basename, str) or not basename:
+        raw_path = details.get("path") or details.get("filePath")
+        basename = Path(str(raw_path or "")).name
+    if basename not in _SIDECAR_BASENAMES:
+        return None
+    return (basename, event.timestamp)
+
+
+def _collect_artifact_lead_evidence(
+    team_state: dict,
+    project_root: Path,
+    task_type: str,
+    suffix: str | None,
+) -> tuple[_LeadEvidence | None, str | None]:
+    if not suffix or "-" not in suffix:
+        return None, (
+            "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)
+    if error:
+        return None, error
+
+    try:
+        from okstra_ctl.lead_events import LeadEventParseError, read_lead_events
+    except ImportError as exc:
+        return None, f"okstra_ctl.lead_events import failed — {exc}"
+
+    try:
+        events = read_lead_events(events_path)
+    except LeadEventParseError as exc:
+        return None, f"artifact lead event log is malformed — {exc}"
+
+    run_seq = suffix.rsplit("-", 1)[1]
+    evidence = _LeadEvidence(scanned_files=[events_path])
+    for event in events:
+        if not _event_matches_run(event, team_state, task_type, run_seq):
+            continue
+        if event.event_type in ("progress", "progress-checkpoint"):
+            progress = _progress_line_from_event(event)
+            if progress is not None:
+                evidence.progress.append(progress)
+        elif event.event_type in ("artifact-read", "sidecar-read"):
+            read = _sidecar_read_from_event(event)
+            if read is not None:
+                basename, timestamp = read
+                evidence.sidecar_reads.setdefault(basename, []).append(timestamp)
+
+    evidence.progress.sort()
+    for ts_list in evidence.sidecar_reads.values():
+        ts_list.sort()
+    return evidence, None
+
+
 def _convergence_rounds_ran(run_dir: Path, suffix: str | None) -> bool:
     """이 run 의 convergence state artifact 가 실제 round 를 1회 이상 돌았는지.
     auto-disable(`totalRounds: 0`)·artifact 부재는 phase-5.5 라인을 요구하지 않는다."""
@@ -420,16 +533,25 @@ 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)
 
-    evidence, error = _collect_lead_evidence(
-        team_state, team_state_path, project_root, claude_projects_dir
-    )
+    lead_runtime = team_state.get("leadRuntime", "") or "claude-code"
+    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:
+        evidence, error = _collect_lead_evidence(
+            team_state, team_state_path, project_root, claude_projects_dir
+        )
     if error:
         result.errors.append(error)
         return result
-    suffix = run_artifact_suffix(team_state_path)
     _check_progress_checkpoints(evidence, team_state, run_dir, suffix, result.errors)
     if task_type == "implementation":
         _check_implementation_sidecar_reads(evidence, result.errors)