okstra 0.76.0 → 0.78.0

package/runtime/python/okstra_ctl/team.py

@@ -0,0 +1,267 @@
+"""Neutral okstra team CLI for external tmux-pane worker dispatch."""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+
+from . import tmux
+from .dispatch_core import (
+    BACKEND_TMUX_PANE,
+    DispatchError,
+    DispatchPlan,
+    await_dispatches,
+    build_dispatch_plan,
+    dispatch_plan,
+)
+
+_SUPPORTED_WRAPPERS = {
+    "claude": "okstra-claude-exec.sh",
+    "codex": "okstra-codex-exec.sh",
+    "gemini": "okstra-gemini-exec.sh",
+    "report-writer": "okstra-claude-exec.sh",
+}
+_TERMINAL_STATUSES = {"completed", "timeout", "error", "not-run"}
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = _parser()
+    args = parser.parse_args(argv)
+    try:
+        if args.command == "dispatch":
+            return _dispatch(args)
+        if args.command == "await":
+            return _await(args)
+        if args.command == "teardown":
+            return _teardown(args)
+    except DispatchError as exc:
+        print(f"okstra team: {exc}", file=sys.stderr)
+        return 2
+    parser.print_help()
+    return 2
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="okstra team")
+    parser.add_argument("--workspace-root", required=True)
+    parser.add_argument("--okstra-bin", required=True)
+    sub = parser.add_subparsers(dest="command", required=True)
+    _add_dispatch_parser(sub)
+    _add_await_parser(sub)
+    _add_teardown_parser(sub)
+    return parser
+
+
+def _add_dispatch_parser(sub) -> None:
+    parser = sub.add_parser("dispatch", help="dispatch tmux-pane workers")
+    _add_run_args(parser)
+    parser.add_argument("--workers", default="")
+    parser.add_argument("--jobs-file", default="")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--idle-timeout-seconds", type=int, default=600)
+    parser.add_argument("--dispatch-kind", default="initial")
+
+
+def _add_await_parser(sub) -> None:
+    parser = sub.add_parser("await", help="wait for tmux-pane workers")
+    _add_run_args(parser)
+    parser.add_argument("--poll-interval-seconds", type=int, default=5)
+    parser.add_argument("--timeout-seconds", type=int, default=None)
+    parser.add_argument("--heartbeat-seconds", type=int, default=30)
+    parser.add_argument("--json", action="store_true")
+
+
+def _add_teardown_parser(sub) -> None:
+    parser = sub.add_parser("teardown", help="kill tmux-pane workers")
+    _add_run_args(parser)
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--json", action="store_true")
+
+
+def _add_run_args(parser) -> None:
+    parser.add_argument("--project-root", required=True)
+    parser.add_argument("--run-manifest", required=True)
+
+
+def _dispatch(args) -> int:
+    if args.jobs_file and args.workers:
+        raise DispatchError("--jobs-file and --workers cannot be combined")
+    manifest = _load_manifest(args.project_root, args.run_manifest)
+    _validate_external_manifest(manifest)
+    requested = _parse_workers(args.workers)
+    plan = build_dispatch_plan(
+        project_root=Path(args.project_root),
+        run_manifest_path=Path(args.run_manifest),
+        workspace_root=Path(args.workspace_root),
+        okstra_bin=Path(args.okstra_bin),
+        requested_workers=requested,
+        idle_timeout_seconds=args.idle_timeout_seconds,
+        enable_report_writer="report-writer" in requested,
+        required_lead_runtime="external",
+        default_backend=BACKEND_TMUX_PANE,
+        supported_worker_wrappers=_SUPPORTED_WRAPPERS,
+        unsupported_worker_label="external lead",
+        dispatch_kind=args.dispatch_kind,
+        jobs_file=Path(args.jobs_file) if args.jobs_file else None,
+    )
+    if args.dry_run:
+        _print_json(plan.to_payload(dry_run=True))
+        return 0
+    result = dispatch_plan(plan, wait=False)
+    _print_json(plan.to_payload(dry_run=False))
+    return result
+
+
+def _await(args) -> int:
+    manifest = _load_manifest(args.project_root, args.run_manifest)
+    _validate_external_manifest(manifest)
+    plan = _plan_for_existing(Path(args.project_root), Path(args.workspace_root), Path(args.run_manifest), manifest)
+    code = await_dispatches(
+        plan,
+        poll_interval_seconds=args.poll_interval_seconds,
+        timeout_seconds=args.timeout_seconds,
+        heartbeat_seconds=0 if args.json else args.heartbeat_seconds,
+    )
+    if args.json:
+        _print_json(_await_payload(plan, code == 0))
+    else:
+        print("ALL_WORKERS_DONE" if code == 0 else "POLL_TIMEOUT")
+    return code
+
+
+def _teardown(args) -> int:
+    manifest = _load_manifest(args.project_root, args.run_manifest)
+    _validate_external_manifest(manifest)
+    project_root = Path(args.project_root).resolve()
+    team_state_path = _resolve_project_path(project_root, _require_string(manifest, "teamStatePath"))
+    team_state = _load_json(team_state_path, "team-state")
+    run_dir = _resolve_project_path(project_root, _require_string(manifest, "runDirectoryPath"))
+    lead_pane = tmux.resolve_caller_pane()
+    panes = _teardown_panes(team_state, run_dir, lead_pane)
+    if args.dry_run:
+        _emit_teardown(args.json, panes)
+        return 0
+    for pane in panes:
+        tmux.kill_pane(pane["paneId"])
+    _mark_teardown_errors(team_state_path)
+    _emit_teardown(args.json, panes)
+    return 0
+
+
+def _plan_for_existing(
+    project_root: Path, workspace_root: Path, run_manifest_path: Path, manifest: Mapping[str, Any]
+) -> DispatchPlan:
+    root = project_root.resolve()
+    manifest_path = _resolve_project_path(root, str(run_manifest_path))
+    return DispatchPlan(
+        project_root=root,
+        workspace_root=workspace_root.resolve(),
+        manifest_path=manifest_path,
+        team_state_path=_resolve_project_path(root, _require_string(manifest, "teamStatePath")),
+        lead_events_path=_resolve_project_path(root, _require_string(manifest, "leadEventsPath")),
+        manifest=manifest,
+        jobs=(),
+        default_backend=BACKEND_TMUX_PANE,
+    )
+
+
+def _await_payload(plan: DispatchPlan, completed: bool) -> dict[str, Any]:
+    team_state = _load_json(plan.team_state_path, "team-state")
+    dispatches = [d for d in team_state.get("workerDispatches", []) if isinstance(d, dict)]
+    timed_out = [d for d in dispatches if d.get("status") == "timeout"]
+    return {
+        "completed": completed,
+        "timedOut": len(timed_out),
+        "workers": dispatches,
+        "teamStatePath": str(plan.team_state_path),
+    }
+
+
+def _teardown_panes(team_state: Mapping[str, Any], run_dir: Path, lead_pane: str) -> list[dict[str, str]]:
+    seen: set[str] = set()
+    panes: list[dict[str, str]] = []
+    for record in team_state.get("workerDispatches", []):
+        if isinstance(record, dict):
+            _append_pane(panes, seen, str(record.get("paneId", "")), "worker")
+    for pane in tmux.list_run_panes(run_dir, lead_pane=lead_pane):
+        _append_pane(panes, seen, pane.pane_id, pane.kind)
+    return panes
+
+
+def _append_pane(panes: list[dict[str, str]], seen: set[str], pane_id: str, kind: str) -> None:
+    if pane_id and pane_id not in seen:
+        panes.append({"paneId": pane_id, "kind": kind})
+        seen.add(pane_id)
+
+
+def _mark_teardown_errors(team_state_path: Path) -> None:
+    payload = _load_json(team_state_path, "team-state")
+    for record in payload.get("workerDispatches", []):
+        if isinstance(record, dict) and record.get("status") not in _TERMINAL_STATUSES:
+            record["status"] = "error"
+            record["reason"] = "teardown before terminal status"
+    _write_json(team_state_path, payload)
+
+
+def _emit_teardown(as_json: bool, panes: list[dict[str, str]]) -> None:
+    if as_json:
+        _print_json({"panes": panes})
+        return
+    for pane in panes:
+        print(f"{pane['paneId']}\t{pane['kind']}")
+
+
+def _validate_external_manifest(manifest: Mapping[str, Any]) -> None:
+    runtime = manifest.get("leadRuntime")
+    if runtime == "external":
+        return
+    if runtime == "codex":
+        raise DispatchError("use okstra codex-dispatch for leadRuntime=codex")
+    if runtime == "claude-code":
+        raise DispatchError("use Claude Code TeamCreate/Agent flow for leadRuntime=claude-code")
+    raise DispatchError(f"unsupported leadRuntime for okstra team: {runtime}")
+
+
+def _load_manifest(project_root: str, run_manifest: str) -> dict[str, Any]:
+    root = Path(project_root).resolve()
+    path = _resolve_project_path(root, run_manifest)
+    return _load_json(path, "run manifest")
+
+
+def _load_json(path: Path, label: str) -> dict[str, Any]:
+    if not path.is_file():
+        raise DispatchError(f"{label} not found: {path}")
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise DispatchError(f"{label} must be a JSON object: {path}")
+    return payload
+
+
+def _write_json(path: Path, payload: Mapping[str, Any]) -> None:
+    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+def _resolve_project_path(project_root: Path, value: str | Path) -> Path:
+    path = Path(value)
+    return path if path.is_absolute() else project_root / path
+
+
+def _require_string(payload: Mapping[str, Any], key: str) -> str:
+    value = payload.get(key)
+    if not isinstance(value, str) or not value.strip():
+        raise DispatchError(f"required string missing: {key}")
+    return value.strip()
+
+
+def _parse_workers(raw: str) -> list[str]:
+    return [item.strip() for item in raw.split(",") if item.strip()]
+
+
+def _print_json(payload: Mapping[str, Any]) -> None:
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/runtime/python/okstra_ctl/tmux.py

@@ -1,27 +1,198 @@
-"""tmux 명령 빌더."""
+"""tmux command helpers for okstra-owned panes."""
 from __future__ import annotations
 
-from typing import Optional
+import os
+import shlex
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Sequence
+
+
+@dataclass(frozen=True)
+class TmuxPane:
+    pane_id: str
+    title: str
+    run_dir: str
+    kind: str
 
 
 def _shell_quote(s: str) -> str:
-    """POSIX shell 안전 인용. shlex.quote 가 모든 메타문자(&, ;, |, *, ?, …) 를 처리한다."""
-    import shlex as _shlex
-    return _shlex.quote(s)
+    """POSIX shell 안전 인용. shlex.quote 가 모든 메타문자를 처리한다."""
+    return shlex.quote(s)
+
+
+def _canonical_run_dir(run_dir: Path) -> str:
+    return str(run_dir.resolve())
 
 
 def build_tmux_command(*, session_name: str, cwd: str, run_seq: int,
                        argv: list, okstra_script: str,
                        extra_env: Optional[dict] = None) -> list:
-    """tmux new-session 명령을 list 형태로 반환.
-    extra_env 의 키는 inner 명령 앞에 KEY=VAL 형태로 prepend 된다 — tmux 세션은
-    호출 셸의 환경을 자동 상속하지 않으므로 OKSTRA_HOME 등은 명시 전달해야 한다.
-    """
+    """tmux new-session 명령을 list 형태로 반환."""
     env_prefix = f"OKSTRA_RUN_SEQ_OVERRIDE={run_seq}"
     if extra_env:
         for k, v in extra_env.items():
             env_prefix += f" {k}={_shell_quote(str(v))}"
-    # 스크립트 경로에 공백/메타문자가 있어도 안전하도록 동일 방식으로 인용.
     inner = (f"{env_prefix} {_shell_quote(okstra_script)} "
              + " ".join(_shell_quote(a) for a in argv))
     return ["tmux", "new-session", "-d", "-s", session_name, "-c", cwd, inner]
+
+
+def tmux_available() -> bool:
+    if shutil.which("tmux") is None:
+        return False
+    try:
+        result = run_tmux(["display-message", "-p", "#{version}"], timeout=3)
+    except (OSError, subprocess.SubprocessError):
+        return False
+    return result.returncode == 0
+
+
+def run_tmux(
+    args: Sequence[str], *, timeout: int = 10
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["tmux", *args],
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+        check=False,
+    )
+
+
+def resolve_caller_pane(start_pid: int | None = None) -> str:
+    try:
+        panes = run_tmux(["list-panes", "-a", "-F", "#{pane_pid} #{pane_id}"])
+    except (OSError, subprocess.SubprocessError):
+        return ""
+    if panes.returncode != 0 or not panes.stdout.strip():
+        return ""
+    pane_by_pid = _pane_ids_by_pid(panes.stdout)
+    pid = str(start_pid or os.getpid())
+    for _ in range(16):
+        if not pid or pid == "0":
+            return ""
+        if pid in pane_by_pid:
+            return pane_by_pid[pid]
+        pid = _parent_pid(pid)
+    return ""
+
+
+def _pane_ids_by_pid(output: str) -> dict[str, str]:
+    result: dict[str, str] = {}
+    for line in output.splitlines():
+        parts = line.split(maxsplit=1)
+        if len(parts) == 2:
+            result[parts[0]] = parts[1]
+    return result
+
+
+def _parent_pid(pid: str) -> str:
+    try:
+        result = subprocess.run(
+            ["ps", "-o", "ppid=", "-p", pid],
+            capture_output=True,
+            text=True,
+            timeout=3,
+            check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return ""
+    if result.returncode != 0:
+        return ""
+    return result.stdout.strip()
+
+
+def split_worker_pane(
+    *,
+    target_pane: str,
+    cwd: Path,
+    command: Sequence[str],
+    title: str,
+    run_dir: Path,
+) -> str:
+    result = run_tmux(
+        [
+            "split-window",
+            "-h",
+            "-P",
+            "-F",
+            "#{pane_id}",
+            "-c",
+            str(cwd),
+            "-t",
+            target_pane,
+            shlex.join(command),
+        ]
+    )
+    if result.returncode != 0:
+        raise RuntimeError(result.stderr.strip() or "tmux split-window failed")
+    pane_id = result.stdout.strip()
+    set_pane_title(pane_id, title)
+    tag_pane(pane_id, run_dir)
+    return pane_id
+
+
+def set_pane_title(pane_id: str, title: str) -> None:
+    result = run_tmux(["select-pane", "-t", pane_id, "-T", title])
+    if result.returncode != 0:
+        raise RuntimeError(result.stderr.strip() or "tmux select-pane failed")
+
+
+def tag_pane(
+    pane_id: str, run_dir: Path, *, option: str = "@okstra_worker_run"
+) -> None:
+    result = run_tmux(
+        ["set-option", "-p", "-t", pane_id, option, _canonical_run_dir(run_dir)]
+    )
+    if result.returncode != 0:
+        raise RuntimeError(result.stderr.strip() or "tmux set-option failed")
+
+
+def capture_pane(pane_id: str, *, last_lines: int = 200) -> str:
+    result = run_tmux(
+        ["capture-pane", "-p", "-t", pane_id, "-S", f"-{last_lines}"]
+    )
+    if result.returncode != 0:
+        return ""
+    return result.stdout
+
+
+def list_run_panes(run_dir: Path, *, lead_pane: str = "") -> list[TmuxPane]:
+    canonical = _canonical_run_dir(run_dir)
+    try:
+        result = run_tmux(
+            [
+                "list-panes",
+                "-a",
+                "-F",
+                "#{pane_id}\t#{pane_title}\t#{@okstra_worker_run}\t#{@okstra_trace_run}",
+            ]
+        )
+    except (OSError, subprocess.SubprocessError):
+        return []
+    if result.returncode != 0:
+        return []
+    return _parse_run_panes(result.stdout, canonical, lead_pane)
+
+
+def _parse_run_panes(output: str, canonical: str, lead_pane: str) -> list[TmuxPane]:
+    panes: list[TmuxPane] = []
+    for line in output.splitlines():
+        pane_id, title, worker_run, trace_run = (line.split("\t") + [""] * 4)[:4]
+        if not pane_id or pane_id == lead_pane:
+            continue
+        if worker_run == canonical:
+            panes.append(TmuxPane(pane_id, title, worker_run, "worker"))
+        elif trace_run == canonical:
+            panes.append(TmuxPane(pane_id, title, trace_run, "trace"))
+    return panes
+
+
+def kill_pane(pane_id: str) -> None:
+    try:
+        run_tmux(["kill-pane", "-t", pane_id])
+    except (OSError, subprocess.SubprocessError):
+        return

package/runtime/python/okstra_ctl/workflow.py

@@ -4,11 +4,14 @@ bash `compute_workflow_render_context` + `default_next_phase_for_task_type` 의
 python 구현. (task-type, current task/run status, render-only flag) 만 받아서
 WORKFLOW_* 필드 dict 를 돌려준다.
 
-또한 task-type 별 PHASE_ALLOWED_OUTPUTS / PHASE_FORBIDDEN_ACTIONS 본문 매핑을
-모듈 상수로 보유.
+task-type 별 PHASE_ALLOWED_OUTPUTS 본문 매핑은 모듈 상수(`PHASE_RULES`)로 보유하고,
+PHASE_FORBIDDEN_ACTIONS 는 `prompts/profiles/forbidden-actions.json` SSOT 에서 로드한다.
 """
 from __future__ import annotations
 
+import json
+from pathlib import Path
+
 PHASE_SEQUENCE = [
     "requirements-discovery",
     "error-analysis",
@@ -31,8 +34,9 @@ DEFAULT_NEXT_PHASE = {
     "release-handoff": "done-or-follow-up",
 }
 
-# Phase 별 allowed outputs / forbidden actions. bash heredoc 원문 그대로 옮긴 값.
-# 들여쓰기와 백틱은 prompt template 에 그대로 박혀 lead 가 읽는다.
+# Phase 별 allowed outputs. bash heredoc 원문 그대로 옮긴 값 — 들여쓰기와 백틱은
+# prompt template 에 그대로 박혀 lead 가 읽는다. forbidden actions 는 이 dict 가
+# 아니라 prompts/profiles/forbidden-actions.json (load_phase_forbidden) 이 SSOT.
 PHASE_RULES: dict[str, dict[str, str]] = {
     "requirements-discovery": {
         "allowed": (
@@ -41,12 +45,6 @@ PHASE_RULES: dict[str, dict[str, str]] = {
             "  - missing-input list and clarification requests\n"
             "  - approval / confirmation checkpoints recorded for the next phase"
         ),
-        "forbidden": (
-            "  - source code edits of any kind\n"
-            "  - implementation planning or detailed design beyond what is required to choose the next phase\n"
-            "  - executing builds, migrations, deployments, or any state-mutating command\n"
-            "  - starting `error-analysis`, `implementation-planning`, or `implementation` inside this run (each must be a separate run, and `implementation` additionally requires an approved `implementation-planning` deliverable)"
-        ),
     },
     "improvement-discovery": {
         "allowed": (
@@ -56,15 +54,6 @@ PHASE_RULES: dict[str, dict[str, str]] = {
             "  - Phase 1.5 reflect-back grilling log at `runs/improvement-discovery/<seq>/state/phase-1.5-grilling.md`\n"
             "  - Phase 5.5 consensus classification (full / partial / contested / worker-unique)"
         ),
-        "forbidden": (
-            "  - source code edits of any kind\n"
-            "  - implementation planning, root-cause analysis, builds, migrations, or deployments\n"
-            "  - starting `implementation-planning`, `implementation`, `error-analysis`, or any other lifecycle phase inside this run\n"
-            "  - generating candidates outside the lens whitelist (Lens enum violation rejects the report)\n"
-            "  - exceeding the candidate cap (absolute cap 12)\n"
-            "  - free external data fetch beyond the brief's Source Material or Phase 1.5 resolved scope\n"
-            "  - interpreting user phrases like `다음 단계 진행해` as authorisation to enter another phase"
-        ),
     },
     "error-analysis": {
         "allowed": (
@@ -73,12 +62,6 @@ PHASE_RULES: dict[str, dict[str, str]] = {
             "  - reproduction gaps and missing observability\n"
             "  - validation paths to confirm or refute hypotheses"
         ),
-        "forbidden": (
-            "  - source code edits, refactors, or fix attempts\n"
-            "  - implementation design or planning artifacts\n"
-            "  - executing builds, migrations, deployments, or any state-mutating command\n"
-            "  - starting `implementation-planning` or `implementation` inside this run (each must be a separate run, and `implementation` additionally requires an approved `implementation-planning` deliverable)"
-        ),
     },
     "implementation-planning": {
         "allowed": (
@@ -91,15 +74,6 @@ PHASE_RULES: dict[str, dict[str, str]] = {
             "  - YAML frontmatter line `approved: false` awaiting human flip to `true`\n"
             "  - self-review confirmation (spec coverage, placeholder scan, internal consistency, ambiguity, scope)"
         ),
-        "forbidden": (
-            "  - source code edits of any kind (Edit/Write on project source files is forbidden)\n"
-            "  - file writes outside the run`s artifact directories (`reports/`, `prompts/`, `state/`, `manifests/`, `worker-results/`, `status/`, `sessions/`); in particular, do not write to `docs/superpowers/specs/` or `docs/superpowers/plans/`\n"
-            "  - executing builds, migrations, deployments, or any state-mutating command\n"
-            '  - starting `implementation` inside this run (must be a separate run authorised by an approved deliverable from this phase), even if the user says "다음 단계 진행해"\n'
-            "  - dispatching parallel sub-agents beyond the required worker roster (okstra owns worker fan-out)\n"
-            '  - leaving placeholders such as TBD / TODO / "handle edge cases" / "similar to Option N" in the report\n'
-            "  - delegating the self-review pass to a generic subagent — `Claude lead` must run it"
-        ),
     },
     "implementation": {
         "allowed": (
@@ -113,21 +87,6 @@ PHASE_RULES: dict[str, dict[str, str]] = {
             "  - rollback verification (revert SHA reachable, feature flag toggle works, migration down step valid; dry-run preferred)\n"
             "  - routing recommendation for `final-verification` (ready / needs new error-analysis or planning loop)"
         ),
-        "forbidden": (
-            "  - any Edit/Write or state-mutating Bash before the pre-implementation gate passes (gate requires --approved-plan pointing to a final-report.md whose frontmatter has `approved: true`)\n"
-            "  - `git push` of any kind, `npm publish` / `cargo publish` / `pip publish`, `gh release`, `docker push`\n"
-            "  - real database migrations, schema changes against shared environments, or writes to non-local datastores\n"
-            "  - production credentials, deploy commands, infra mutation (`terraform apply`, `kubectl apply` against non-local cluster, etc.)\n"
-            "  - external API write calls (POST/PUT/PATCH/DELETE) to third-party services other than localhost test fixtures\n"
-            "  - source edits or Bash mutations performed by any verifier role (`Gemini verifier`, `Codex verifier`, `Claude verifier` are read-only — recommend, do not apply)\n"
-            "  - dispatching parallel sub-agents beyond the required worker roster\n"
-            "  - silent scope expansion: every file edited outside the approved plan list MUST appear in the `Out-of-plan edits` block with rationale\n"
-            '  - leaving placeholders such as TBD / TODO / "implement later" / "handle edge cases" in newly-added lines of this run (check via `git diff <base>..HEAD | grep -E \'^\\+[^+].*\\b(TBD|TODO|FIXME|XXX|implement later|handle edge cases|similar to|placeholder)\\b\'`; pre-existing strings in untouched regions are out of scope)\n'
-            "  - lead substituting its own verdict when every required verifier (`Gemini verifier`, `Codex verifier`, `Claude verifier`) returned a non-result terminal status (`timeout`/`error`/`not-run`); in that case the run MUST end as `blocked` with routing recommendation back to `error-analysis`, never with a lead-only verdict\n"
-            "  - claiming rollback verification on a schema migration, config-format change, or any persisted-state mutation without a recorded dry-run of the rollback step and its captured exit code\n"
-            '  - declaring overall task acceptance — that is `final-verification` ownership; this phase reports only "ready for final-verification" or "needs new planning loop"\n'
-            "  - delegating the self-review pass to a generic subagent — `Claude lead` must run it"
-        ),
     },
     "final-verification": {
         "allowed": (
@@ -135,11 +94,6 @@ PHASE_RULES: dict[str, dict[str, str]] = {
             "  - residual risk and regression notes\n"
             "  - recommended follow-up routing (`error-analysis` / `implementation-planning` / `release-handoff`) for any defects detected"
         ),
-        "forbidden": (
-            "  - source code edits, follow-up bug fixes, or scope expansion\n"
-            "  - state-mutating commands; only read-only execution of pre-existing test or validation commands is permitted\n"
-            "  - starting any follow-up phase inside this run; record findings and end the run"
-        ),
     },
     "release-handoff": {
         "allowed": (
@@ -152,30 +106,32 @@ PHASE_RULES: dict[str, dict[str, str]] = {
             "  - creating a pull request via `gh pr create --base <chosen-base> --head <current-branch>`; if a PR with the same head already exists, surface its URL and skip creation\n"
             "  - the lead writes the final report directly (no `Report writer worker` dispatch); the report still conforms to the standard final-report template"
         ),
-        "forbidden": (
-            "  - entering this phase when the cited final-verification `Verdict Token` is `conditional-accept` or `blocked`, or when no final-verification report is cited\n"
-            "  - any source-code edit, refactor, or scope expansion beyond what is strictly needed to author PR descriptions (the changes themselves are inherited from prior `implementation` runs)\n"
-            "  - local commit commands (`git add`, `git commit`, `git stash`, `git restore --staged`); commits are produced by `implementation`, not release-handoff\n"
-            "  - `git push --force`, `git push --force-with-lease`, or any rewriting of remote history\n"
-            "  - pushing directly to a base branch (`main`, `master`, `prod`, `preprod`, `staging`, `dev`, or any branch the user named as the PR base)\n"
-            "  - bypassing git hooks (`--no-verify`, `-n`), bypassing GPG signing, or otherwise disabling repo-configured safeguards\n"
-            "  - release-publishing commands: `gh release`, `npm publish`, `cargo publish`, `pip publish`, `docker push`, `terraform apply`, `kubectl apply` against non-local clusters\n"
-            "  - executing any command the user did NOT select (e.g. if the user picked `local only`, opening a PR is forbidden; if the user picked `skip`, the run ends without git commands)\n"
-            "  - `TeamCreate`, `Agent(...)` worker dispatch, parallel sub-agent fan-out, or any team-mode orchestration — this phase runs single-lead\n"
-            "  - silently retrying a failed git/gh command with weaker flags (e.g. retrying `git push` with `--force` after a non-fast-forward rejection)"
-        ),
     },
 }
 
 PHASE_RULES_UNKNOWN = {
     "allowed": "  - outputs defined by the active task type",
-    "forbidden": (
-        "  - any action that belongs to a different lifecycle phase\n"
-        "  - source code edits or state-mutating commands unless this task type explicitly authorises them"
-    ),
 }
 
 
+def render_forbidden(items: list[str]) -> str:
+    """Render a forbidden-action list to the `  - item` bullet block injected
+    into the launch prompt boundary and the profile body."""
+    return "\n".join(f"  - {item}" for item in items)
+
+
+def load_phase_forbidden(workspace_root: Path) -> dict[str, str]:
+    """Load the forbidden-actions SSOT and render each phase to its bullet block.
+
+    `workspace_root` is the resolved okstra asset root (repo or runtime); the
+    JSON lives beside the profile `.md` files at
+    `prompts/profiles/forbidden-actions.json`.
+    """
+    path = Path(workspace_root) / "prompts" / "profiles" / "forbidden-actions.json"
+    data = json.loads(path.read_text(encoding="utf-8"))
+    return {phase: render_forbidden(items) for phase, items in data.items()}
+
+
 def default_next_phase_for(task_type: str) -> str:
     return DEFAULT_NEXT_PHASE.get(task_type, "unknown")
 
@@ -186,6 +142,7 @@ def compute_workflow_state(
     current_run_status: str,
     current_task_status: str,
     render_only: bool,
+    forbidden_by_phase: dict[str, str],
     work_category: str = "",
 ) -> dict:
     """WORKFLOW_* + PHASE_* 값을 dict 로 돌려준다."""
@@ -231,5 +188,7 @@ def compute_workflow_state(
         "WORKFLOW_ROUTING_STATUS": routing_status,
         "WORKFLOW_LAST_SAFE_CHECKPOINT_LABEL": checkpoint_label,
         "PHASE_ALLOWED_OUTPUTS": rules["allowed"],
-        "PHASE_FORBIDDEN_ACTIONS": rules["forbidden"],
+        "PHASE_FORBIDDEN_ACTIONS": forbidden_by_phase.get(
+            task_type, forbidden_by_phase["unknown"]
+        ),
     }