@opengsd/gsd-path 1.3.1 → 1.5.0

package/skills/path/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,

package/skills/path/scripts/check_docs_audit.py

@@ -8,6 +8,10 @@ with testable claims where every claim row carries a valid type, a valid
 verdict, and real evidence, a `## Descriptive docs` list for claimless docs,
 the two sets disjoint and together equal to the frozen inventory, and a
 remediation queue with one classified row per non-verified claim.
+Queue numbers are unique, positive and strictly increasing, not necessarily
+contiguous. With `--prior-audit`, persisting rows keep their number and new
+rows use a number above every prior queue number and User rulings Queue #.
+Numbers stay bound to their original (doc, claim); never reuse a retired one.
 `## User rulings` is fixed-format durable memory. Pass the pre-rewrite audit
 with `--prior-audit FILE`; every prior row, including its Planned value, must
 remain an exact ordered prefix.
@@ -26,6 +30,10 @@ gate derives the inventory from tracked Markdown files, excluding `.git`,
 `*/skills/path` bundles,
 the audit itself, and — unless the
 audit declares `Alignment mode: yes` — everything else under `.project/`.
+
+`Repo root` names the primary repository. When the audit is gated inside a
+disposable sidecar, pass that sidecar as `--repo` and the primary as
+`--primary`; the header then stays valid after the sidecar is retired.
 """
 
 import argparse
@@ -92,6 +100,12 @@ def _table_rows(body: str, width: int, label: str) -> List[List[str]]:
     return rows
 
 
+def _remediation_queue_rows(body: str, label: str, required: bool = False) -> List[List[str]]:
+    if not required and "|" not in body:
+        return []
+    return _table_rows(body, 6, label)
+
+
 def _not_placeholder(value: str, label: str) -> None:
     normalized = value.strip().strip("`\"").strip()
     if (
@@ -243,12 +257,70 @@ def _check_carried(
             raise AuditError(f"{label}: doc or evidence changed since the prior audit: {', '.join(moved)}")
 
 
+def _queue_number(number: str, label: str) -> int:
+    if not re.fullmatch(r"[1-9][0-9]*", number):
+        raise AuditError(f"{label}: queue numbers must be positive integers")
+    return int(number)
+
+
+def _check_queue_number_history(
+    queue: Sequence[Sequence[str]],
+    prior_sections: Dict[str, str],
+) -> None:
+    if "Remediation queue" not in prior_sections:
+        raise AuditError("prior audit is missing section: ## Remediation queue")
+    if "User rulings" not in prior_sections:
+        raise AuditError("prior audit is missing section: ## User rulings")
+
+    prior_queue = _remediation_queue_rows(
+        prior_sections["Remediation queue"], "Prior remediation queue"
+    )
+    prior_items_by_number: Dict[int, tuple] = {}
+    prior_numbers_by_item: Dict[tuple, int] = {}
+    for number, doc, claim, *_ in prior_queue:
+        numeric_number = _queue_number(number, "Prior remediation queue")
+        identity = (doc, claim)
+        prior_items_by_number[numeric_number] = identity
+        prior_numbers_by_item[identity] = numeric_number
+
+    prior_rulings = _user_rulings(
+        prior_sections["User rulings"], "Prior user rulings"
+    )
+    prior_ruling_numbers = {int(row[0]) for row in prior_rulings}
+    prior_max = max(
+        [*prior_items_by_number, *prior_ruling_numbers],
+        default=0,
+    )
+
+    for number, doc, claim, *_ in queue:
+        numeric_number = _queue_number(number, "Remediation queue")
+        identity = (doc, claim)
+        prior_number = prior_numbers_by_item.get(identity)
+        if numeric_number in prior_ruling_numbers and prior_items_by_number.get(numeric_number) != identity:
+            raise AuditError(
+                f"Remediation queue #{number}: Queue # {number} is already retired by a prior "
+                "User rulings row for a different item; give new items a number above every "
+                "prior queue number and User rulings Queue #"
+            )
+        if prior_number is not None and numeric_number != prior_number:
+            raise AuditError(
+                f"Remediation queue #{number}: persisting item must keep its prior queue "
+                f"number #{prior_number}"
+            )
+        if prior_number is None and numeric_number <= prior_max:
+            raise AuditError(
+                f"Remediation queue #{number}: new items must use a number above every prior "
+                f"queue number and User rulings Queue # (maximum {prior_max})"
+            )
+
+
 def validate(
     repo: Path,
     audit_relative: str,
     inventory: Optional[Sequence[str]],
     prior_text: Optional[str] = None,
     changed: Optional[Sequence[str]] = None,
+    primary: Optional[Path] = None,
 ) -> Dict[str, object]:
     audit = repo / audit_relative
     if not audit.is_file() or audit.is_symlink():
@@ -263,8 +335,8 @@ def validate(
             raise AuditError(f"header must contain exactly one {key} line")
         header[key] = values[0]
     declared_root = Path(header["Repo root"])
-    if not declared_root.is_absolute() or declared_root.resolve() != repo.resolve():
-        raise AuditError("Repo root does not match --repo")
+    if not declared_root.is_absolute() or declared_root.resolve() != (primary or repo).resolve():
+        raise AuditError("Repo root does not match --primary (default --repo)")
     try:
         date.fromisoformat(header["Audited"])
     except ValueError as error:
@@ -349,7 +421,9 @@ def validate(
 
     queue_body = sections["Remediation queue"]
     non_verified = sum(tallies[verdict] for verdict in VERDICTS if verdict != "verified")
-    queue = _table_rows(queue_body, 6, "Remediation queue") if non_verified or "|" in queue_body else []
+    queue = _remediation_queue_rows(
+        queue_body, "Remediation queue", required=bool(non_verified)
+    )
     expected_queue = sorted(
         (doc, claim["claim"], claim["verdict"])
         for doc, claims in docs.items()
@@ -366,9 +440,13 @@ def validate(
         _not_placeholder(action, f"Remediation queue #{number}: action")
     if len(queue) != non_verified:
         raise AuditError(f"Remediation queue has {len(queue)} rows for {non_verified} non-verified claims")
-    numbers = [row[0] for row in queue]
-    if numbers != [str(number) for number in range(1, len(queue) + 1)]:
-        raise AuditError("Remediation queue numbers must be contiguous and ordered from 1")
+    numbers = [_queue_number(row[0], "Remediation queue") for row in queue]
+    if any(later <= earlier for earlier, later in zip(numbers, numbers[1:])):
+        raise AuditError(
+            "Remediation queue numbers must be unique and strictly increasing"
+        )
+    if prior_sections is not None:
+        _check_queue_number_history(queue, prior_sections)
     actual_queue = sorted((doc, claim, verdict) for _, doc, claim, verdict, _, _ in queue)
     if actual_queue != expected_queue:
         raise AuditError(
@@ -392,6 +470,11 @@ def parser() -> argparse.ArgumentParser:
     argument_parser.add_argument("--repo", type=Path, required=True)
     argument_parser.add_argument("--audit", default=DEFAULT_AUDIT, help="relative audit path (default: %(default)s)")
     argument_parser.add_argument("--inventory", help="file with one inventoried POSIX path per line, or - for stdin")
+    argument_parser.add_argument(
+        "--primary",
+        type=Path,
+        help="primary repository the Repo root header must name (default: --repo)",
+    )
     argument_parser.add_argument(
         "--prior-audit",
         type=Path,
@@ -454,7 +537,8 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
     changed = _path_lines(arguments.changed) if arguments.changed is not None else None
     try:
         result = validate(
-            arguments.repo.resolve(), arguments.audit, inventory, prior_text, changed
+            arguments.repo.resolve(), arguments.audit, inventory, prior_text, changed,
+            arguments.primary,
         )
     except AuditError as error:
         print(f"docs audit validation failed: {error}", file=sys.stderr)