@opengsd/gsd-path 1.3.1 → 1.5.0

package/skills/gsd-path-ship/scripts/build_state.py

@@ -14,28 +14,41 @@ from datetime import datetime, timezone
 from pathlib import Path, PurePosixPath
 from typing import Dict, List, Mapping, Optional, Sequence, Tuple
 
-try:
-    from check_task_briefs import _frontmatter, _sections
-    from isolation import (
+if __package__:
+    from .check_task_briefs import _frontmatter, _sections
+    from .isolation import (
         VERIFY_LEDGER_PATH,
         IsolationError,
         recover as recover_isolation,
         verify_landed_task_files,
     )
-    from pipeline_git import task_commit_subject
-    from pipeline_state import PipelineStateError, load_state
-    import _common
-except ImportError:  # pragma: no cover - package imports used by tests
-    from scripts.check_task_briefs import _frontmatter, _sections
-    from scripts.isolation import (
-        VERIFY_LEDGER_PATH,
-        IsolationError,
-        recover as recover_isolation,
-        verify_landed_task_files,
-    )
-    from scripts.pipeline_git import task_commit_subject
-    from scripts.pipeline_state import PipelineStateError, load_state
-    from scripts import _common
+    from .pipeline_git import task_commit_subject
+    from .pipeline_state import PipelineStateError, load_state
+    from . import _common, check_handoffs
+else:
+    try:
+        from check_task_briefs import _frontmatter, _sections
+        from isolation import (
+            VERIFY_LEDGER_PATH,
+            IsolationError,
+            recover as recover_isolation,
+            verify_landed_task_files,
+        )
+        from pipeline_git import task_commit_subject
+        from pipeline_state import PipelineStateError, load_state
+        import _common
+        import check_handoffs
+    except ImportError:  # pragma: no cover - package imports used by tests
+        from scripts.check_task_briefs import _frontmatter, _sections
+        from scripts.isolation import (
+            VERIFY_LEDGER_PATH,
+            IsolationError,
+            recover as recover_isolation,
+            verify_landed_task_files,
+        )
+        from scripts.pipeline_git import task_commit_subject
+        from scripts.pipeline_state import PipelineStateError, load_state
+        from scripts import _common, check_handoffs
 
 
 DEFAULT_PROJECT_DIR = ".project"
@@ -45,6 +58,10 @@ FULL_SHA_RE = re.compile(r"^[0-9a-f]{40}$")
 # recover verdicts that count as landed, mapped to their evidence classification.
 LANDED_VERDICTS = {"recovered": "proven-landed", "attested": "attested"}
 WAVE_HEADING_RE = re.compile(r"(?m)^## Wave (?P<wave>\d+)\b.*$")
+REVIEW_VERDICT_RE = re.compile(
+    r"(?m)^Wave verdict:\s*(?P<verdict>pass|blocked)\s*(?:<!--.*?-->)?\s*$"
+)
+REVIEW_FINDINGS_HEADING = "Review findings"
 VERIFY_HEAVY_RE = re.compile(r"(?m)^Heavy:\s*(?P<value>yes|no)\s*(?:<!--.*-->)?\s*$")
 VALID_TASK_STATUSES = {"pending", "in-progress", "done", "failed", "blocked"}
 VERIFY_RESULTS = _common.VERIFY_RESULTS
@@ -75,6 +92,8 @@ class Task:
     task_branch: Optional[str]
     task_file: str
     verify_heavy: bool
+    repo: str = ""
+    review_findings: bool = False
 
 
 @dataclass(frozen=True)
@@ -227,6 +246,8 @@ def _parse_task(path: Path, relative_path: str, task_file: Optional[str] = None)
         task_branch=_nullable_string(fields, "task_branch", label),
         task_file=task_file or relative_path,
         verify_heavy=_verify_heavy(text, label),
+        repo=str(fields.get("repo") or ""),
+        review_findings=REVIEW_FINDINGS_HEADING in _sections(text),
     )
 
 
@@ -284,6 +305,8 @@ def _load_tasks(
         raise BuildStateError("missing-input", f"task directory is missing or unsafe: {tasks_dir}")
     task_paths: Dict[str, Path] = {}
     for path in sorted(tasks_dir.iterdir()):
+        if _common.is_ignored_junk(path):
+            continue
         match = TASK_FILE_RE.fullmatch(path.name)
         if match is None or not path.is_file() or path.is_symlink():
             raise BuildStateError(
@@ -464,9 +487,41 @@ def _validate_ready_metadata(project: Project) -> None:
 
 
 def _overlap(left: Task, right: Task) -> List[str]:
+    if left.repo != right.repo:
+        return []
     return sorted(set(left.files) & set(right.files))
 
 
+def _blocked_wave_reviews(project: Project) -> Dict[int, int]:
+    """Return waves whose highest canonical review cycle has a blocked lens."""
+
+    review_dir = project.tasks_dir.parent / "review"
+    if review_dir.is_symlink() or not review_dir.is_dir():
+        return {}
+
+    latest: Dict[int, int] = {}
+    verdicts: Dict[Tuple[int, int], List[str]] = {}
+    for path in sorted(review_dir.iterdir()):
+        named = check_handoffs.WAVE_REVIEW_NAME.fullmatch(path.name)
+        if named is None or path.is_symlink() or not path.is_file():
+            continue
+        wave, cycle = int(named.group("wave")), int(named.group("cycle"))
+        latest[wave] = max(latest.get(wave, 0), cycle)
+        try:
+            text = path.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            continue
+        verdict = REVIEW_VERDICT_RE.search(text)
+        if verdict is not None:
+            verdicts.setdefault((wave, cycle), []).append(verdict.group("verdict"))
+
+    return {
+        wave: cycle
+        for wave, cycle in latest.items()
+        if "blocked" in verdicts.get((wave, cycle), [])
+    }
+
+
 def ready(repo: str, project_dir: str = DEFAULT_PROJECT_DIR, *,
           allow_done: bool = False) -> Dict[str, object]:
     """Return task readiness, optionally accepting build/done for completion checks."""
@@ -476,6 +531,39 @@ def ready(repo: str, project_dir: str = DEFAULT_PROJECT_DIR, *,
     by_id = {task.task_id: task for task in project.tasks}
     unfinished_waves = sorted({task.wave for task in project.tasks if task.status != "done"})
     current_wave = unfinished_waves[0] if unfinished_waves else None
+    blocked_reviews = _blocked_wave_reviews(project)
+    blocked_wave = min(
+        (
+            wave
+            for wave in blocked_reviews
+            if (current_wave is None or wave < current_wave)
+            and any(task.wave == wave for task in project.tasks)
+            and all(task.status == "done" for task in project.tasks if task.wave == wave)
+        ),
+        default=None,
+    )
+    repair_for_wave: Optional[int] = None
+    blocked_review: Optional[Dict[str, object]] = None
+    if blocked_wave is not None:
+        source_ids = {task.task_id for task in project.tasks if task.wave == blocked_wave}
+        repairs = [
+            task
+            for task in project.tasks
+            if task.status != "done"
+            and task.wave > blocked_wave
+            and task.review_findings
+            and source_ids.intersection(task.deps)
+        ]
+        if repairs:
+            repair_for_wave = blocked_wave
+            current_wave = min(task.wave for task in repairs)
+        else:
+            current_wave = blocked_wave
+            blocked_review = {
+                "wave": blocked_wave,
+                "cycle": blocked_reviews[blocked_wave],
+                "waiting_waves": unfinished_waves,
+            }
     active = [task for task in project.tasks if task.status == "in-progress"]
     if current_wave is not None and any(task.wave != current_wave for task in active):
         task = next(task for task in active if task.wave != current_wave)
@@ -518,7 +606,7 @@ def ready(repo: str, project_dir: str = DEFAULT_PROJECT_DIR, *,
                 )
 
     wave_active = any(task.wave == current_wave for task in active)
-    if current_wave is not None and not selectable and not wave_active:
+    if current_wave is not None and blocked_review is None and not selectable and not wave_active:
         stalled = [
             {
                 "id": task.task_id,
@@ -538,11 +626,17 @@ def ready(repo: str, project_dir: str = DEFAULT_PROJECT_DIR, *,
             {"wave": current_wave, "tasks": stalled},
         )
 
+    typed: Dict[str, object] = {}
+    if repair_for_wave is not None:
+        typed["repair_for_wave"] = repair_for_wave
+    if blocked_review is not None:
+        typed["blocked_review"] = blocked_review
     return {
         "command": "ready",
         "branch": project.branch,
         "head": project.head,
         "current_wave": current_wave,
+        **typed,
         "ready": [
             {
                 "id": task.task_id,
@@ -553,6 +647,7 @@ def ready(repo: str, project_dir: str = DEFAULT_PROJECT_DIR, *,
                 "files": list(task.files),
                 "task_file": task.task_file,
                 "verify_heavy": task.verify_heavy,
+                **({"repo": task.repo} if task.repo else {}),
             }
             for task in selectable
         ],
@@ -726,6 +821,22 @@ def _ledger_path(repo: Path) -> Path:
     return path
 
 
+def _member_checkout(repo: Path, member: Optional[str]) -> Path:
+    if member is None:
+        return repo
+    try:
+        import members
+    except ImportError:  # pragma: no cover - package import used by tests
+        from scripts import members
+    try:
+        listed = {item["name"]: Path(item["checkout"]) for item in members.read_members(repo)}
+    except members.MembersError as error:
+        raise BuildStateError("invalid-member", str(error)) from error
+    if member not in listed:
+        raise BuildStateError("invalid-member", f"{member} is not in MEMBERS.md")
+    return listed[member]
+
+
 def _ledger_key(repo: Path, command: str, commit: str) -> Tuple[str, str]:
     if not command.strip():
         raise BuildStateError("invalid-command", "--command must not be empty")
@@ -742,13 +853,20 @@ def _ledger_entries(path: Path) -> List[Dict[str, object]]:
 
 
 def verify_record(repo: str, command: str, commit: str, result: str,
-                  execution: Optional[Dict[str, object]] = None) -> Dict[str, object]:
-    """Append one verify run (command, commit, result, timestamp) to the ledger."""
+                  execution: Optional[Dict[str, object]] = None,
+                  member: Optional[str] = None) -> Dict[str, object]:
+    """Append one verify run (command, commit, result, timestamp) to the ledger.
+
+    A member run names its member and a commit in that member's repository.
+    """
 
     repository = _repo_root(repo)
     if result not in VERIFY_RESULTS:
         raise BuildStateError("invalid-result", "--result must be pass or fail")
-    normalized, commit = _ledger_key(repository, command, commit)
+    normalized, commit = _ledger_key(_member_checkout(repository, member), command, commit)
+    ignore_error = _common.project_ignore_error(repository)
+    if ignore_error:
+        raise BuildStateError("ignored-ledger", ignore_error)
     path = _ledger_path(repository)
     _ledger_entries(path)
     entry = {
@@ -757,6 +875,7 @@ def verify_record(repo: str, command: str, commit: str, result: str,
         "commit": commit,
         "result": result,
         "recorded_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+        **({"repo": member} if member else {}),
     }
     if execution is not None:
         if (not isinstance(execution.get("stdout"), str)
@@ -771,12 +890,12 @@ def verify_record(repo: str, command: str, commit: str, result: str,
     return {"command": "verify-record", "ledger": VERIFY_LEDGER_PATH, "entry": entry}
 
 
-def verify_lookup(repo: str, command: str, commit: str) -> Dict[str, object]:
+def verify_lookup(repo: str, command: str, commit: str, member: Optional[str] = None) -> Dict[str, object]:
     """Return the latest recorded run of this command at this commit, or a miss."""
 
     repository = _repo_root(repo)
-    normalized, commit = _ledger_key(repository, command, commit)
-    entry = _common.latest_verify_entry(_ledger_entries(_ledger_path(repository)), normalized, commit)
+    normalized, commit = _ledger_key(_member_checkout(repository, member), command, commit)
+    entry = _common.latest_verify_entry(_ledger_entries(_ledger_path(repository)), normalized, commit, member)
     return {
         "command": "verify-lookup",
         "ledger": VERIFY_LEDGER_PATH,