okstra 0.186.6 → 0.187.0

package/runtime/validators/checks/runners-01.py

@@ -0,0 +1,108 @@
+"""runners-01 — 셸 시나리오에서 꺼낸 단언 블록.
+
+호출부: validators/lib/runners.sh:44
+규칙 R1 은 실행될 소스를 문자열/heredoc 이 아니라 실파일에 두게 한다.
+이 파일의 내용은 꺼내기 전과 같다 — 옮기기만 했다.
+"""
+from pathlib import Path
+import json
+import subprocess
+import sys
+
+project_root = Path(sys.argv[1])
+task_manifest_path = project_root / sys.argv[2]
+validator_script = Path(sys.argv[3])
+expected_status = sys.argv[4]
+expected_failure_substring = sys.argv[5]
+
+task_manifest = json.loads(task_manifest_path.read_text())
+timeline_path = project_root / task_manifest["historyTimelinePath"]
+timeline = json.loads(timeline_path.read_text())
+runs = timeline.get("runs", [])
+latest_run = None
+if isinstance(runs, list):
+    for item in reversed(runs):
+        if isinstance(item, dict):
+            latest_run = item
+            break
+
+if latest_run is None:
+    raise SystemExit("timeline does not contain a latest run entry")
+
+run_manifest_path = project_root / latest_run["runManifestPath"]
+run_manifest = json.loads(run_manifest_path.read_text())
+team_state_path = project_root / run_manifest["teamStatePath"]
+report_path = project_root / run_manifest["expectedReportRecordPath"]
+final_status_path = project_root / run_manifest["expectedStatusPath"]
+
+process = subprocess.run(
+    [
+        sys.executable,
+        str(validator_script),
+        "--team-state",
+        str(team_state_path),
+        "--report",
+        str(report_path),
+        "--run-manifest",
+        str(run_manifest_path),
+        "--task-manifest",
+        str(task_manifest_path),
+        "--final-status",
+        str(final_status_path),
+        # session-conformance 주입 시드 — prepare_run_validator_fixture 가
+        # 만든 합성 lead jsonl 디렉터리 (실제 ~/.claude/projects 미오염).
+        "--claude-projects-dir",
+        str(project_root / ".claude-projects-fixture"),
+    ],
+    capture_output=True,
+    text=True,
+)
+
+if not process.stdout.strip():
+    raise SystemExit("validator did not produce JSON output")
+
+payload = json.loads(process.stdout)
+actual_status = payload.get("validationStatus")
+if actual_status != expected_status:
+    extra = ""
+    if expected_status == "passed":
+        listed = payload.get("failures") or []
+        extra = "\n" + "\n".join(str(item) for item in listed)
+    raise SystemExit(
+        f"validator status mismatch: expected {expected_status}, got {actual_status}{extra}"
+    )
+
+if expected_status == "passed" and process.returncode != 0:
+    raise SystemExit(f"validator returned non-zero on success: {process.stderr}")
+if expected_status == "failed" and process.returncode == 0:
+    raise SystemExit("validator unexpectedly succeeded")
+
+if expected_failure_substring:
+    failures = payload.get("failures", [])
+    if not isinstance(failures, list) or not any(
+        expected_failure_substring in str(item) for item in failures
+    ):
+        raise SystemExit(
+            f"validator failure output did not include expected text: {expected_failure_substring}"
+        )
+
+if not final_status_path.is_file():
+    raise SystemExit(f"validator did not write final status file: {final_status_path}")
+
+final_status = final_status_path.read_text().strip()
+expected_final_status = "completed" if expected_status == "passed" else "contract-violated"
+if final_status != expected_final_status:
+    raise SystemExit(
+        f"final status file mismatch: expected {expected_final_status}, got {final_status}"
+    )
+
+updated_run_manifest = json.loads(run_manifest_path.read_text())
+updated_task_manifest = json.loads(task_manifest_path.read_text())
+updated_team_state = json.loads(team_state_path.read_text())
+
+if updated_run_manifest.get("validation", {}).get("status") != expected_status:
+    raise SystemExit("run manifest validation status was not updated correctly")
+if updated_task_manifest.get("contractValidation", {}).get("status") != expected_status:
+    raise SystemExit("task manifest validation status was not updated correctly")
+if updated_team_state.get("validator", {}).get("status") != expected_status:
+    raise SystemExit("team-state validator status was not updated correctly")

package/runtime/validators/checks/validate-assets-01.py

@@ -0,0 +1,60 @@
+"""validate-assets-01 — 셸 시나리오에서 꺼낸 단언 블록.
+
+호출부: validators/lib/validate-assets.sh:23
+규칙 R1 은 실행될 소스를 문자열/heredoc 이 아니라 실파일에 두게 한다.
+이 파일의 내용은 꺼내기 전과 같다 — 옮기기만 했다.
+"""
+from pathlib import Path
+import sys
+
+agents_source_root = Path(sys.argv[1])      # <repo>/agents
+skills_source_root = Path(sys.argv[2])      # <repo>/skills
+runtime_root = Path(sys.argv[3])            # <repo>/runtime
+validation_mode = sys.argv[4]
+errors = []
+
+
+def check(source_path: Path, target_path: Path) -> None:
+    if not target_path.is_file():
+        errors.append(f"missing build-output asset: {target_path}")
+        return
+    if validation_mode == "match" and target_path.read_bytes() != source_path.read_bytes():
+        errors.append(f"build-output asset does not match source: {target_path}")
+
+
+# 1. Worker agent files: agents/workers/*-worker.md -> runtime/agents/workers/*-worker.md
+#
+workers_source = agents_source_root / "workers"
+workers_target = runtime_root / "agents" / "workers"
+if not workers_source.is_dir():
+    errors.append(f"missing agents/workers source directory: {workers_source}")
+else:
+    for source_path in sorted(workers_source.glob("*.md")):
+        check(source_path, workers_target / source_path.name)
+
+# 2. Lead contract + internal lead resources: prompts/lead/* + prompts/coding-preflight/*
+#    -> runtime/prompts/*. These ship as runtime resources (okstra install copies
+#    runtime/prompts -> ~/.okstra/prompts), no longer as agent skills.
+prompts_source_root = agents_source_root.parent / "prompts"
+for sub in ("lead", "coding-preflight"):
+    sub_root = prompts_source_root / sub
+    if not sub_root.is_dir():
+        errors.append(f"missing prompts source directory: {sub_root}")
+        continue
+    for source_path in sorted(sub_root.rglob("*.md")):
+        relative = source_path.relative_to(prompts_source_root)
+        check(source_path, runtime_root / "prompts" / relative)
+
+# 3. Skill packages: skills/<name>/SKILL.md -> runtime/skills/<name>/SKILL.md
+if not skills_source_root.is_dir():
+    errors.append(f"missing skills source directory: {skills_source_root}")
+else:
+    for skill_dir in sorted(p for p in skills_source_root.iterdir() if p.is_dir()):
+        for source_path in sorted(skill_dir.rglob("*.md")):
+            relative = source_path.relative_to(skills_source_root)
+            check(source_path, runtime_root / "skills" / relative)
+
+if errors:
+    for error in errors:
+        print(error, file=sys.stderr)
+    sys.exit(1)

package/runtime/validators/checks/validate-prompt-metadata-01.py

@@ -0,0 +1,261 @@
+"""validate-prompt-metadata-01 — 셸 시나리오에서 꺼낸 단언 블록.
+
+호출부: validators/lib/validate-prompt-metadata.sh:10
+규칙 R1 은 실행될 소스를 문자열/heredoc 이 아니라 실파일에 두게 한다.
+이 파일의 내용은 꺼내기 전과 같다 — 옮기기만 했다.
+"""
+from pathlib import Path
+import json
+import sys
+
+project_root = Path(sys.argv[1])
+task_manifest_path = project_root / sys.argv[2]
+errors = []
+
+
+def load_json(path: Path) -> dict:
+    return json.loads(path.read_text())
+
+
+def validate_prompt_contract(
+    prefix: str,
+    worker_ids: list[str],
+    prompt_dir: str,
+    prompt_map: object,
+    required_worker_roles: object,
+) -> None:
+    if not prompt_dir:
+        errors.append(f"{prefix} is missing worker prompt directory metadata")
+    if not isinstance(prompt_map, dict):
+        errors.append(f"{prefix} worker prompt map is missing or invalid")
+        prompt_map = {}
+    if not isinstance(required_worker_roles, list):
+        errors.append(f"{prefix} requiredWorkerRoles is missing or invalid")
+        required_worker_roles = []
+
+    expected_dir_prefix = prompt_dir.rstrip("/") + "/" if prompt_dir else ""
+    for worker_id in worker_ids:
+        if worker_id not in prompt_map:
+            errors.append(f"{prefix} worker prompt map is missing selected worker: {worker_id}")
+
+    for worker in required_worker_roles:
+        if not isinstance(worker, dict):
+            errors.append(f"{prefix} requiredWorkerRoles contains a non-object entry")
+            continue
+        worker_id = str(worker.get("workerId", "")).strip()
+        prompt_relative = str(worker.get("promptPath", "")).strip()
+        if not worker_id:
+            errors.append(f"{prefix} requiredWorkerRoles contains an entry without workerId")
+            continue
+        if not prompt_relative:
+            errors.append(
+                f"{prefix} required worker is missing promptPath: {worker_id}"
+            )
+            continue
+        if prompt_map.get(worker_id) != prompt_relative:
+            errors.append(
+                f"{prefix} worker prompt map does not match requiredWorkerRoles for {worker_id}"
+            )
+        if expected_dir_prefix and not prompt_relative.startswith(expected_dir_prefix):
+            errors.append(
+                f"{prefix} worker prompt path is outside the prompt directory: {prompt_relative}"
+            )
+
+
+if not task_manifest_path.is_file():
+    errors.append(f"task manifest is missing: {task_manifest_path}")
+else:
+    task_manifest = load_json(task_manifest_path)
+    selected_workers = task_manifest.get("recommendedWorkers", [])
+    if not isinstance(selected_workers, list):
+        errors.append("task manifest recommendedWorkers is missing or invalid")
+        selected_workers = []
+
+    task_prompt_dir = str(task_manifest.get("latestRunPromptsPath", "")).strip()
+    if not task_prompt_dir:
+        errors.append("task manifest is missing latestRunPromptsPath")
+
+    task_artifacts = task_manifest.get("artifacts", {})
+    if not isinstance(task_artifacts, dict):
+        errors.append("task manifest artifacts is missing or invalid")
+        task_artifacts = {}
+
+    validate_prompt_contract(
+        "task manifest",
+        selected_workers,
+        str(task_artifacts.get("workerPromptsDirectoryPath", "")).strip(),
+        task_artifacts.get("workerPromptPathByWorkerId"),
+        task_manifest.get("resultContract", {}).get("requiredWorkerRoles"),
+    )
+
+    if (
+        task_prompt_dir
+        and str(task_artifacts.get("workerPromptsDirectoryPath", "")).strip()
+        and task_prompt_dir
+        != str(task_artifacts.get("workerPromptsDirectoryPath", "")).strip()
+    ):
+        errors.append(
+            "task manifest latestRunPromptsPath does not match artifacts.workerPromptsDirectoryPath"
+        )
+
+    timeline_relative_path = str(
+        task_manifest.get("historyTimelinePath", "")
+    ).strip()
+    if not timeline_relative_path:
+        errors.append("task manifest is missing historyTimelinePath")
+    else:
+        timeline_path = project_root / timeline_relative_path
+        if not timeline_path.is_file():
+            errors.append(f"timeline file is missing: {timeline_path}")
+        else:
+            timeline = load_json(timeline_path)
+            runs = timeline.get("runs", [])
+            latest_run = None
+            if isinstance(runs, list):
+                for item in reversed(runs):
+                    if isinstance(item, dict):
+                        latest_run = item
+                        break
+            if latest_run is None:
+                errors.append("timeline does not contain a latest run entry")
+            else:
+                latest_run_prompt_dir = str(
+                    latest_run.get("workerPromptDirectoryPath", "")
+                ).strip()
+                if not latest_run_prompt_dir:
+                    errors.append(
+                        "latest timeline entry is missing workerPromptDirectoryPath"
+                    )
+                if task_prompt_dir and latest_run_prompt_dir and task_prompt_dir != latest_run_prompt_dir:
+                    errors.append(
+                        "timeline latest run prompt directory does not match task manifest latestRunPromptsPath"
+                    )
+                prompt_map = latest_run.get("workerPromptPathByWorkerId")
+                if not isinstance(prompt_map, dict):
+                    errors.append(
+                        "latest timeline entry is missing workerPromptPathByWorkerId"
+                    )
+                else:
+                    for worker_id in selected_workers:
+                        if worker_id not in prompt_map:
+                            errors.append(
+                                f"latest timeline entry is missing worker prompt path for {worker_id}"
+                            )
+
+                run_manifest_relative_path = str(
+                    latest_run.get("runManifestPath", "")
+                ).strip()
+                if not run_manifest_relative_path:
+                    errors.append(
+                        "latest timeline entry is missing runManifestPath"
+                    )
+                else:
+                    run_manifest_path = project_root / run_manifest_relative_path
+                    if not run_manifest_path.is_file():
+                        errors.append(f"latest run manifest is missing: {run_manifest_path}")
+                    else:
+                        run_manifest = load_json(run_manifest_path)
+                        run_prompt_dir = str(
+                            run_manifest.get("workerPromptsDirectoryPath", "")
+                        ).strip()
+                        if task_prompt_dir and run_prompt_dir and task_prompt_dir != run_prompt_dir:
+                            errors.append(
+                                "run manifest workerPromptsDirectoryPath does not match task manifest latestRunPromptsPath"
+                            )
+                        validate_prompt_contract(
+                            "run manifest",
+                            selected_workers,
+                            run_prompt_dir,
+                            run_manifest.get("workerPromptPathByWorkerId"),
+                            run_manifest.get("teamContract", {}).get("requiredWorkerRoles"),
+                        )
+
+                        team_state_relative_path = str(
+                            run_manifest.get("teamStatePath")
+                            or task_manifest.get("teamStatePath", "")
+                        ).strip()
+                        if not team_state_relative_path:
+                            errors.append(
+                                "team state relative path is missing from run/task manifest"
+                            )
+                        else:
+                            team_state_path = project_root / team_state_relative_path
+                            if not team_state_path.is_file():
+                                errors.append(f"team-state file is missing: {team_state_path}")
+                            else:
+                                team_state = load_json(team_state_path)
+                                team_artifacts = team_state.get("artifacts", {})
+                                if not isinstance(team_artifacts, dict):
+                                    errors.append(
+                                        "team-state artifacts is missing or invalid"
+                                    )
+                                    team_artifacts = {}
+                                team_prompt_dir = str(
+                                    team_artifacts.get(
+                                        "workerPromptsDirectoryPath", ""
+                                    )
+                                ).strip()
+                                if run_prompt_dir and team_prompt_dir and run_prompt_dir != team_prompt_dir:
+                                    errors.append(
+                                        "team-state worker prompt directory does not match run manifest"
+                                    )
+                                workers = team_state.get("workers", [])
+                                if not isinstance(workers, list):
+                                    errors.append("team-state workers is missing or invalid")
+                                else:
+                                    team_workers = {}
+                                    for worker in workers:
+                                        if not isinstance(worker, dict):
+                                            errors.append(
+                                                "team-state workers contains a non-object entry"
+                                            )
+                                            continue
+                                        worker_id = str(worker.get("workerId", "")).strip()
+                                        if not worker_id:
+                                            errors.append(
+                                                "team-state workers contains an entry without workerId"
+                                            )
+                                            continue
+                                        team_workers[worker_id] = worker
+
+                                    run_prompt_map = run_manifest.get(
+                                        "workerPromptPathByWorkerId", {}
+                                    )
+                                    if not isinstance(run_prompt_map, dict):
+                                        run_prompt_map = {}
+
+                                    for worker_id in selected_workers:
+                                        worker = team_workers.get(worker_id)
+                                        if worker is None:
+                                            errors.append(
+                                                f"team-state is missing selected worker entry: {worker_id}"
+                                            )
+                                            continue
+                                        prompt_relative = str(
+                                            worker.get("promptPath", "")
+                                        ).strip()
+                                        if not prompt_relative:
+                                            errors.append(
+                                                f"team-state worker is missing promptPath: {worker_id}"
+                                            )
+                                            continue
+                                        if run_prompt_map.get(worker_id) != prompt_relative:
+                                            errors.append(
+                                                f"team-state worker prompt path does not match run manifest for {worker_id}"
+                                            )
+                                        expected_dir_prefix = (
+                                            run_prompt_dir.rstrip("/") + "/"
+                                            if run_prompt_dir
+                                            else ""
+                                        )
+                                        if expected_dir_prefix and not prompt_relative.startswith(
+                                            expected_dir_prefix
+                                        ):
+                                            errors.append(
+                                                f"team-state worker prompt path is outside the run prompt directory: {prompt_relative}"
+                                            )
+
+if errors:
+    for error in errors:
+        print(error, file=sys.stderr)
+    sys.exit(1)

package/runtime/validators/checks/validate-tasks-01.py

@@ -0,0 +1,46 @@
+"""validate-tasks-01 — 셸 시나리오에서 꺼낸 단언 블록.
+
+호출부: validators/lib/validate-tasks.sh:8
+규칙 R1 은 실행될 소스를 문자열/heredoc 이 아니라 실파일에 두게 한다.
+이 파일의 내용은 꺼내기 전과 같다 — 옮기기만 했다.
+"""
+from pathlib import Path
+import sys
+
+brief_path = Path(sys.argv[1])
+reference_path = Path(sys.argv[2])
+expected_task_key = sys.argv[3]
+brief_lines = brief_path.read_text().splitlines()
+section_map = {
+    "Configuration References and Expected Values": "config",
+    "Deployment Manifests and Expected Values": "deployment",
+}
+captured = {"config": [], "deployment": []}
+current_section = None
+
+for line in brief_lines:
+    if line.startswith("## "):
+        current_section = section_map.get(line[3:].strip())
+        continue
+    if current_section and line.strip():
+        captured[current_section].append(line)
+
+errors = []
+
+if not reference_path.is_file():
+    errors.append(f"reference expectations file is missing: {reference_path}")
+    reference_content = ""
+else:
+    reference_content = reference_path.read_text()
+
+for line in captured["config"] + captured["deployment"]:
+    if line not in reference_content:
+        errors.append(f"reference expectations file is missing brief line: {line}")
+
+if f"- Task Key: `{expected_task_key}`" not in reference_content:
+    errors.append("reference expectations file is missing the task key header")
+
+if errors:
+    for error in errors:
+        print(error, file=sys.stderr)
+    sys.exit(1)

package/runtime/validators/checks/validate-tasks-02.py

@@ -0,0 +1,85 @@
+"""validate-tasks-02 — 셸 시나리오에서 꺼낸 단언 블록.
+
+호출부: validators/lib/validate-tasks.sh:22
+규칙 R1 은 실행될 소스를 문자열/heredoc 이 아니라 실파일에 두게 한다.
+이 파일의 내용은 꺼내기 전과 같다 — 옮기기만 했다.
+"""
+from pathlib import Path
+import json
+import sys
+
+project_root = Path(sys.argv[1])
+expected_task_key = sys.argv[2]
+task_manifest_relative_path = sys.argv[3]
+expected_reference_relative_path = sys.argv[4]
+expected_task_catalog_relative_path = sys.argv[5]
+errors = []
+
+task_manifest_path = project_root / task_manifest_relative_path
+if not task_manifest_path.is_file():
+    errors.append(f"task manifest is missing: {task_manifest_path}")
+else:
+    task_manifest = json.loads(task_manifest_path.read_text())
+
+    if task_manifest.get("taskKey") != expected_task_key:
+        errors.append("task manifest does not contain the expected task key")
+
+    if task_manifest.get("referenceExpectationsPath") != expected_reference_relative_path:
+        errors.append("task manifest does not expose referenceExpectationsPath")
+
+    if task_manifest.get("taskCatalogPath") != expected_task_catalog_relative_path:
+        errors.append("task manifest does not expose taskCatalogPath")
+
+    if (
+        task_manifest.get("artifacts", {}).get("referenceExpectationsPath")
+        != expected_reference_relative_path
+    ):
+        errors.append("task manifest artifacts do not expose referenceExpectationsPath")
+
+    timeline_relative_path = task_manifest.get("historyTimelinePath", "")
+    if not timeline_relative_path:
+        errors.append("task manifest is missing historyTimelinePath")
+    else:
+        timeline_path = project_root / timeline_relative_path
+        if not timeline_path.is_file():
+            errors.append(f"timeline file is missing: {timeline_path}")
+        else:
+            timeline = json.loads(timeline_path.read_text())
+            runs = timeline.get("runs", [])
+            latest_run = None
+            if isinstance(runs, list):
+                for item in reversed(runs):
+                    if isinstance(item, dict):
+                        latest_run = item
+                        break
+            if latest_run is None:
+                errors.append("timeline does not contain a latest run entry")
+            else:
+                run_manifest_relative_path = latest_run.get("runManifestPath", "")
+                if not run_manifest_relative_path:
+                    errors.append("latest timeline entry is missing runManifestPath")
+                else:
+                    run_manifest_path = project_root / run_manifest_relative_path
+                    if not run_manifest_path.is_file():
+                        errors.append(f"latest run manifest is missing: {run_manifest_path}")
+                    else:
+                        run_manifest = json.loads(run_manifest_path.read_text())
+                        if run_manifest.get("taskKey") != expected_task_key:
+                            errors.append("run manifest does not contain the expected task key")
+                        if (
+                            run_manifest.get("referenceExpectationsPath")
+                            != expected_reference_relative_path
+                        ):
+                            errors.append(
+                                "run manifest does not expose referenceExpectationsPath"
+                            )
+                        if (
+                            run_manifest.get("taskCatalogPath")
+                            != expected_task_catalog_relative_path
+                        ):
+                            errors.append("run manifest does not expose taskCatalogPath")
+
+if errors:
+    for error in errors:
+        print(error, file=sys.stderr)
+    sys.exit(1)

package/runtime/validators/checks/validate-tasks-03.py

@@ -0,0 +1,61 @@
+"""validate-tasks-03 — 셸 시나리오에서 꺼낸 단언 블록.
+
+호출부: validators/lib/validate-tasks.sh:36
+규칙 R1 은 실행될 소스를 문자열/heredoc 이 아니라 실파일에 두게 한다.
+이 파일의 내용은 꺼내기 전과 같다 — 옮기기만 했다.
+"""
+from pathlib import Path
+import json
+import sys
+
+project_root = Path(sys.argv[1])
+discovery_path = Path(sys.argv[2])
+expected_task_key = sys.argv[3]
+expected_task_manifest_relative_path = sys.argv[4]
+expected_reference_relative_path = sys.argv[5]
+expected_task_catalog_relative_path = sys.argv[6]
+errors = []
+
+if not discovery_path.is_file():
+    errors.append(f"latest-task discovery file is missing: {discovery_path}")
+else:
+    discovery = json.loads(discovery_path.read_text())
+
+    if discovery.get("taskKey") != expected_task_key:
+        errors.append("latest-task discovery does not point to the expected task key")
+
+    if discovery.get("taskManifestPath") != expected_task_manifest_relative_path:
+        errors.append("latest-task discovery does not point to the expected task manifest")
+
+    if discovery.get("referenceExpectationsPath") != expected_reference_relative_path:
+        errors.append("latest-task discovery does not expose the expected reference expectations path")
+
+    if discovery.get("taskCatalogPath") != expected_task_catalog_relative_path:
+        errors.append("latest-task discovery does not expose taskCatalogPath")
+
+    latest_run_prompts_relative_path = discovery.get("latestRunPromptsPath", "")
+    if not latest_run_prompts_relative_path:
+        errors.append("latest-task discovery is missing latestRunPromptsPath")
+
+    latest_run_manifest_relative_path = discovery.get("latestRunManifestPath", "")
+    if not latest_run_manifest_relative_path:
+        errors.append("latest-task discovery is missing latestRunManifestPath")
+    else:
+        latest_run_manifest_path = project_root / latest_run_manifest_relative_path
+        if not latest_run_manifest_path.is_file():
+            errors.append(f"latest run manifest is missing: {latest_run_manifest_path}")
+        else:
+            run_manifest = json.loads(latest_run_manifest_path.read_text())
+            if (
+                latest_run_prompts_relative_path
+                and run_manifest.get("workerPromptsDirectoryPath")
+                != latest_run_prompts_relative_path
+            ):
+                errors.append(
+                    "latest-task discovery latestRunPromptsPath does not match the latest run manifest"
+                )
+
+if errors:
+    for error in errors:
+        print(error, file=sys.stderr)
+    sys.exit(1)