@caddis/cli 0.4.52 → 0.4.53

package/bundles/antigravity-plugin/scripts/caddis_workstreams.py

@@ -225,6 +225,43 @@ def _age(when: datetime, now: datetime) -> str:
     return f"{seconds // 86400}d"
 
 
+def _relays(directory: Path) -> list[tuple[str, dict, str]]:
+    out: list[tuple[str, dict, str]] = []
+    for path in sorted(directory.glob("*.md")) if directory.is_dir() else ():
+        if path.is_symlink():
+            continue
+        try:
+            name = _name(path.stem)
+            if not path.resolve().is_relative_to(directory.resolve()):
+                continue
+            content = path.read_bytes().decode("utf-8")
+            meta = parse(content)
+            if meta.get("type") != "relay" or meta.get("workstream") != name:
+                continue
+            generated = meta.get("generated")
+            datetime.fromisoformat(generated["at"].replace("Z", "+00:00"))
+            out.append((name, meta, content))
+        except (ValueError, KeyError, TypeError, AttributeError, OSError, UnicodeError):
+            continue
+    return out
+
+
+def _item_matches(item: str, next_text: str) -> bool:
+    needle = item.strip()
+    if not needle:
+        return False
+    lower_next = next_text.lower()
+    if needle.lower() in lower_next:
+        return True
+    m = re.fullmatch(r"(.+)#(\d+)", needle)
+    if m:
+        plan_slug = m.group(1).strip().lower()
+        phase_num = m.group(2)
+        if plan_slug and plan_slug in lower_next and re.search(rf"\bphase\s+{re.escape(phase_num)}\b", next_text, re.IGNORECASE):
+            return True
+    return False
+
+
 def render_index(root: Path, session_id: str | None, branch: str | None) -> str:
     """Write and return the bounded startup index from current local files."""
     artifact = _artifact(root)
@@ -240,25 +277,15 @@ def render_index(root: Path, session_id: str | None, branch: str | None) -> str:
         directory = artifact / "relay"
         if directory.exists() and not directory.resolve().is_relative_to(artifact.resolve()):
             raise ValueError("relay directory escapes artifact root")
-        for path in directory.glob("*.md") if directory.is_dir() else ():
-            if path.is_symlink():
-                continue
-            try:
-                name = _name(path.stem)
-                content, _ = read_relay(root, name)
-                meta = parse(content)
-                if meta.get("type") != "relay" or meta.get("workstream") != name:
-                    continue
-                generated = meta.get("generated")
-                at = datetime.fromisoformat(generated["at"].replace("Z", "+00:00"))
-                if at.tzinfo is None:
-                    at = at.replace(tzinfo=timezone.utc)
-                claimed_sessions.add(str(meta.get("session_id", "")))
-                label = _single_line(name, 80)
-                branch_label = _single_line(str(meta.get("branch", "?")), 50)
-                rows.append((at.timestamp(), f"- {label} ({branch_label}, {_age(at, now)}): {_next_step(content)}"))
-            except (ValueError, KeyError, TypeError, AttributeError, OSError, UnicodeError):
-                continue
+        for name, meta, content in _relays(directory):
+            generated = meta["generated"]
+            at = datetime.fromisoformat(generated["at"].replace("Z", "+00:00"))
+            if at.tzinfo is None:
+                at = at.replace(tzinfo=timezone.utc)
+            claimed_sessions.add(str(meta.get("session_id", "")))
+            label = _single_line(name, 80)
+            branch_label = _single_line(str(meta.get("branch", "?")), 50)
+            rows.append((at.timestamp(), f"- {label} ({branch_label}, {_age(at, now)}): {_next_step(content)}"))
         unnamed: list[tuple[datetime, str, str, str]] = []
         states = artifact / "session-state"
         if states.exists() and not states.resolve().is_relative_to(artifact.resolve()):
@@ -315,6 +342,36 @@ def render_index(root: Path, session_id: str | None, branch: str | None) -> str:
         return result
 
 
+def parse_status(text: str) -> tuple[str, str]:
+    """Parse the terminal status line from a relay body."""
+    body = split_document(text)[1]
+    status_lines = [
+        line.strip()
+        for line in body.splitlines()
+        if line.strip().lower().startswith("status:")
+    ]
+    if len(status_lines) > 1:
+        raise ValueError("two or more status lines")
+
+    non_empty = [line.strip() for line in body.splitlines() if line.strip()]
+    if not non_empty:
+        raise ValueError("missing status line")
+
+    last = non_empty[-1]
+    if last == "STATUS: CONTINUE":
+        return "CONTINUE", ""
+    m = re.fullmatch(r"STATUS: OWNER-GATE ([A-Z]{2,4}-OG\d+)", last)
+    if m:
+        return "OWNER-GATE", m.group(1)
+    m = re.fullmatch(r"STATUS: BLOCKED (.+)", last)
+    if m and m.group(1).strip():
+        return "BLOCKED", m.group(1).strip()
+    m = re.fullmatch(r"STATUS: FAILED (.+)", last)
+    if m and m.group(1).strip():
+        return "FAILED", m.group(1).strip()
+    raise ValueError(f"invalid or missing status line: {last!r}")
+
+
 class MigrationReport(dict):
     """Report describing the outcome of a legacy migration."""
 
@@ -596,6 +653,20 @@ def main(argv: list[str] | None = None) -> int:
     write_p.add_argument("--expected-hash", help="hash from `hash`; 'none' when the relay must not exist yet")
     write_p.add_argument("--root", type=Path, default=Path("."))
 
+    status_p = sub.add_parser("status")
+    status_p.add_argument("name")
+    status_p.add_argument("--root", type=Path, default=Path("."))
+    status_p.add_argument("--json", action="store_true")
+
+    put_p = sub.add_parser("put")
+    put_p.add_argument("name")
+    put_p.add_argument("file", type=Path)
+    put_p.add_argument("--expected-hash")
+    put_p.add_argument("--require-status", action="store_true")
+    put_p.add_argument("--session-id")
+    put_p.add_argument("--branch")
+    put_p.add_argument("--root", type=Path, default=Path("."))
+
     render_p = sub.add_parser("render-index")
     render_p.add_argument("--session-id")
     render_p.add_argument("--branch")
@@ -604,6 +675,14 @@ def main(argv: list[str] | None = None) -> int:
     mig_p = sub.add_parser("migrate-legacy")
     mig_p.add_argument("--root", type=Path, default=Path("."))
 
+    list_p = sub.add_parser("list", help="list each relay's name, branch and next step")
+    list_p.add_argument("--root", type=Path, default=Path("."))
+
+    mentions_p = sub.add_parser("mentions", help="list other relays whose Next step mentions an item")
+    mentions_p.add_argument("--item", required=True)
+    mentions_p.add_argument("--except", dest="except_name")
+    mentions_p.add_argument("--root", type=Path, default=Path("."))
+
     args = parser.parse_args(argv)
     if args.command == "resolve":
         name = resolve_workstream(args.plan, args.branch, args.default_branch, args.suggest)
@@ -628,6 +707,64 @@ def main(argv: list[str] | None = None) -> int:
             return 1
         print(res.content_hash)
         return 0
+    elif args.command == "status":
+        try:
+            text, digest = read_relay(args.root, args.name)
+        except ValueError as exc:
+            sys.stderr.write(f"cannot read relay: {exc}\n")
+            return 1
+        if digest is None:
+            sys.stderr.write(f"relay {args.name!r} not found\n")
+            return 1
+        try:
+            kind, arg = parse_status(text)
+        except ValueError as exc:
+            sys.stderr.write(f"invalid relay status: {exc}\n")
+            return 1
+        if args.json:
+            print(json.dumps({"status": kind, "arg": arg}))
+        else:
+            if arg:
+                print(f"STATUS: {kind} {arg}")
+            else:
+                print(f"STATUS: {kind}")
+        return 0
+    elif args.command == "put":
+        try:
+            content = args.file.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError) as exc:
+            sys.stderr.write(f"cannot read file: {exc}\n")
+            return 1
+        if args.require_status:
+            try:
+                parse_status(content)
+            except ValueError as exc:
+                sys.stderr.write(f"relay rejected: {exc}\n")
+                return 1
+        if args.expected_hash is not None:
+            expected = None if args.expected_hash == "none" else args.expected_hash
+        else:
+            try:
+                _, expected = read_relay(args.root, args.name)
+            except ValueError as exc:
+                sys.stderr.write(f"cannot read existing relay: {exc}\n")
+                return 1
+        try:
+            res = write_relay(args.root, args.name, content, expected)
+        except ValueError as exc:
+            sys.stderr.write(f"invalid relay: {exc}\n")
+            return 1
+        if res.status != "written":
+            sys.stdout.write(res.diff + ("\n" if not res.diff.endswith("\n") else ""))
+            sys.stderr.write("relay not written: the stored relay changed since you read it (diff above)\n")
+            return 1
+        try:
+            render_index(args.root, args.session_id, args.branch)
+        except (OSError, ValueError) as exc:
+            # The relay is written; only the startup index is stale. Say so, but do not report a failed put.
+            sys.stderr.write(f"relay written, but the index was not rendered: {exc}\n")
+        print(res.content_hash)
+        return 0
     elif args.command == "render-index":
         render_index(args.root, args.session_id, args.branch)
         return 0
@@ -637,6 +774,28 @@ def main(argv: list[str] | None = None) -> int:
         for conflict in report.conflicts:
             print(f"  conflict: {conflict}")
         return 0 if report.status in ("clean", "migrated") else 1
+    elif args.command == "list":
+        artifact = _artifact(args.root)
+        directory = artifact / "relay"
+        if directory.exists() and not directory.resolve().is_relative_to(artifact.resolve()):
+            raise ValueError("relay directory escapes artifact root")
+        for name, meta, content in _relays(directory):
+            branch_label = _single_line(str(meta.get("branch", "?")), 50)
+            print(f"{name}\t{branch_label}\t{_next_step(content)}")
+        return 0
+    elif args.command == "mentions":
+        artifact = _artifact(args.root)
+        directory = artifact / "relay"
+        if directory.exists() and not directory.resolve().is_relative_to(artifact.resolve()):
+            raise ValueError("relay directory escapes artifact root")
+        skip = args.except_name.lower() if args.except_name else None
+        for name, _meta, content in _relays(directory):
+            if skip and name.lower() == skip:  # names compare case-insensitively
+                continue
+            match = _NEXT.search(content)
+            if match and _item_matches(args.item, match.group(1)):
+                print(name)
+        return 0
     parser.print_help()
     return 2
 

package/bundles/antigravity-plugin/scripts/caddis_worktree_close.py

@@ -0,0 +1,349 @@
+"""Close a lane's git worktree after its PR merged: compare content, then remove the worktree and its branches.
+
+Refuses (exit 1) when the PR is not merged, the worktree has commits the PR head does not contain, the merged files differ
+from the PR head, a named port still listens, the worktree is dirty, or the worktree holds a junction or symlink. The PR
+may be a combined release PR: the lane branch need not be the PR's head branch, only contained in its head. The remote
+branch is deleted only when its tip is contained in the PR head; a branch someone pushed to after the merge is kept,
+because deleting it would lose work that is not on main.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+import socket
+import stat
+import subprocess
+import sys
+from typing import Callable, Sequence
+
+try:
+    import caddis_exit
+except ModuleNotFoundError as exc:
+    if exc.name != "caddis_exit":
+        raise
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+    sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "claude-harness" / "scripts"))
+    import caddis_exit
+
+
+def _is_symlink_or_reparse(p: Path | str) -> bool:
+    """Return True if path is a symlink or Windows reparse point."""
+    try:
+        path_obj = Path(p)
+        if os.path.islink(path_obj):
+            return True
+        st = os.lstat(path_obj)
+        reparse_flag = getattr(stat, "FILE_ATTRIBUTE_REPARSE_POINT", None)
+        if reparse_flag is not None and hasattr(st, "st_file_attributes"):
+            if bool(st.st_file_attributes & reparse_flag):
+                return True
+    except OSError:
+        pass
+    return False
+
+
+def _same_path(p1: str | Path, p2: str | Path) -> bool:
+    """Compare two paths for equality accounting for Windows semantics."""
+    try:
+        if Path(p1).resolve() == Path(p2).resolve():
+            return True
+    except Exception:
+        pass
+    return os.path.normcase(os.path.abspath(str(p1))) == os.path.normcase(os.path.abspath(str(p2)))
+
+
+def close_worktree(
+    *,
+    repo: Path,
+    worktree: Path,
+    pr: int,
+    gh: Callable[[list[str]], str],
+    ports: Sequence[int] = (),
+    dry_run: bool = False,
+) -> int:
+    """Close a worktree after verifying PR merge and cleanliness."""
+    if _is_symlink_or_reparse(worktree):
+        # Checked on the path as given: resolve() would follow the junction and hide it.
+        print(f"refuse: worktree folder {worktree} is a junction or symlink; deleting through it destroys its target")
+        return caddis_exit.BLOCKED
+    repo = Path(repo).resolve()
+    worktree = Path(worktree).resolve()
+
+    # 1. Resolve worktree and find it in git -C repo worktree list --porcelain
+    proc = subprocess.run(
+        ["git", "-C", str(repo), "worktree", "list", "--porcelain"],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+    if proc.returncode != 0:
+        print(f"git worktree list failed: {proc.stderr.strip()}", file=sys.stderr)
+        return caddis_exit.ERROR
+
+    blocks: list[dict[str, str]] = []
+    current_block: dict[str, str] = {}
+    for line in proc.stdout.splitlines():
+        line = line.strip()
+        if not line:
+            if current_block:
+                blocks.append(current_block)
+                current_block = {}
+            continue
+        if line.startswith("worktree "):
+            if current_block:
+                blocks.append(current_block)
+                current_block = {}
+            current_block["worktree"] = line[len("worktree "):].strip()
+        elif line.startswith("HEAD "):
+            current_block["HEAD"] = line[len("HEAD "):].strip()
+        elif line.startswith("branch "):
+            current_block["branch"] = line[len("branch "):].strip()
+        elif line == "detached":
+            current_block["detached"] = "true"
+    if current_block:
+        blocks.append(current_block)
+
+    if not blocks:
+        print(f"No worktrees found for repo {repo}", file=sys.stderr)
+        return caddis_exit.ERROR
+
+    # First entry is the main checkout
+    if _same_path(blocks[0].get("worktree", ""), worktree):
+        print(f"refuse: {worktree} is the main checkout (first entry); will not remove", file=sys.stderr)
+        return caddis_exit.ERROR
+
+    target_block: dict[str, str] | None = None
+    for b in blocks[1:]:
+        if _same_path(b.get("worktree", ""), worktree):
+            target_block = b
+            break
+
+    if target_block is None:
+        print(f"refuse: {worktree} is not listed in worktrees of {repo}", file=sys.stderr)
+        return caddis_exit.ERROR
+
+    branch_ref = target_block.get("branch", "")
+    if branch_ref.startswith("refs/heads/"):
+        branch_name = branch_ref[len("refs/heads/"):]
+    elif branch_ref:
+        branch_name = branch_ref
+    else:
+        print(f"refuse: worktree {worktree} has no branch (detached)", file=sys.stderr)
+        return caddis_exit.ERROR
+
+    # 2. gh pr view
+    try:
+        raw_json = gh(["pr", "view", str(pr), "--json", "state,mergeCommit,headRefOid,headRefName"])
+        pr_data = json.loads(raw_json)
+    except Exception as exc:
+        detail = getattr(exc, "stderr", "") or ""
+        print(f"refuse: failed to view PR #{pr}: {exc} {detail}".rstrip())
+        return caddis_exit.BLOCKED
+
+    state = pr_data.get("state")
+    merge_commit = pr_data.get("mergeCommit")
+    merge_oid = merge_commit.get("oid") if isinstance(merge_commit, dict) else None
+    head_ref_oid = pr_data.get("headRefOid")
+
+    if state != "MERGED" or not merge_oid:
+        print(f"refuse: PR #{pr} is not merged")
+        return caddis_exit.BLOCKED
+
+    # 3. git fetch origin --prune; git fetch origin <headRefOid>; cat-file
+    subprocess.run(["git", "-C", str(repo), "fetch", "-q", "origin", "--prune"], capture_output=True, text=True, encoding="utf-8", errors="replace")
+    if head_ref_oid:
+        subprocess.run(["git", "-C", str(repo), "fetch", "-q", "origin", str(head_ref_oid)], capture_output=True, text=True, encoding="utf-8", errors="replace")
+
+    proc = subprocess.run(
+        ["git", "-C", str(repo), "cat-file", "-e", f"{head_ref_oid}^{{commit}}"],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+    if proc.returncode != 0:
+        print(f"refuse: PR head commit {head_ref_oid} not found in repo")
+        return caddis_exit.BLOCKED
+
+    # 4. Unpushed work
+    proc = subprocess.run(
+        ["git", "-C", str(worktree), "rev-parse", "HEAD"],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+    if proc.returncode != 0:
+        print(f"refuse: failed to get HEAD of worktree {worktree}")
+        return caddis_exit.BLOCKED
+
+    wt_head = proc.stdout.strip()
+    if wt_head != head_ref_oid:
+        proc_ancestor = subprocess.run(
+            ["git", "-C", str(repo), "merge-base", "--is-ancestor", wt_head, str(head_ref_oid)],
+            capture_output=True,
+            text=True,
+        )
+        if proc_ancestor.returncode != 0:
+            print("refuse: worktree has commits the PR does not")
+            return caddis_exit.BLOCKED
+
+    # 5. Content compare
+    proc = subprocess.run(
+        ["git", "-C", str(repo), "diff", "--name-only", f"{merge_oid}^", merge_oid],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+    if proc.returncode != 0:
+        print(f"git diff failed for {merge_oid}^ {merge_oid}: {proc.stderr.strip()}", file=sys.stderr)
+        return caddis_exit.ERROR
+
+    files = [line.strip() for line in proc.stdout.splitlines() if line.strip()]
+    files_compared = len(files)
+    if files:
+        proc_diff = subprocess.run(
+            ["git", "-C", str(repo), "diff", "--quiet", str(head_ref_oid), merge_oid, "--", *files],
+            capture_output=True,
+            text=True,
+        )
+        if proc_diff.returncode != 0:
+            print("refuse: PR head differs from the merged content; not deleted")
+            return caddis_exit.BLOCKED
+
+    # 6. Ports
+    for port in ports:
+        try:
+            with socket.create_connection(("127.0.0.1", int(port)), timeout=0.5):
+                print(f"refuse: a server still listens on {port}")
+                return caddis_exit.BLOCKED
+        except (OSError, socket.timeout):
+            pass
+
+    # 7. Dirty
+    proc = subprocess.run(
+        ["git", "-C", str(worktree), "status", "--porcelain", "--untracked-files=all"],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+    if proc.returncode != 0:
+        print(f"git status failed on worktree {worktree}: {proc.stderr.strip()}", file=sys.stderr)
+        return caddis_exit.ERROR
+
+    dirty = proc.stdout.strip()
+    if dirty:
+        print(f"refuse: worktree {worktree} is dirty:\n{dirty}")
+        return caddis_exit.BLOCKED
+
+    # 8. Junction or symlink guard
+    if _is_symlink_or_reparse(worktree):
+        print(f"refuse: worktree folder {worktree} is a junction or symlink; deleting through a junction destroys its target")
+        return caddis_exit.BLOCKED
+
+    if worktree.is_dir():
+        try:
+            for item in worktree.iterdir():
+                if _is_symlink_or_reparse(item):
+                    print(f"refuse: entry {item} inside worktree is a junction or symlink; deleting through a junction destroys its target")
+                    return caddis_exit.BLOCKED
+        except OSError as exc:
+            print(f"refuse: failed to inspect worktree {worktree}: {exc}")
+            return caddis_exit.BLOCKED
+
+    # 9. dry_run
+    if dry_run:
+        print(f"would remove {worktree}, branch {branch_name} (local and origin)")
+        return caddis_exit.CLEAN
+
+    # 10. Remove
+    cmd_wt_rm = ["git", "-C", str(repo), "worktree", "remove", "--force", str(worktree)]
+    proc = subprocess.run(cmd_wt_rm, capture_output=True, text=True, encoding="utf-8", errors="replace")
+    if proc.returncode != 0:
+        print(f"failed command: {' '.join(cmd_wt_rm)}\n{proc.stderr.strip() or proc.stdout.strip()}", file=sys.stderr)
+        return caddis_exit.ERROR
+
+    cmd_br_d = ["git", "-C", str(repo), "branch", "-D", branch_name]
+    proc = subprocess.run(cmd_br_d, capture_output=True, text=True, encoding="utf-8", errors="replace")
+    if proc.returncode != 0:
+        print(f"failed command: {' '.join(cmd_br_d)}\n{proc.stderr.strip() or proc.stdout.strip()}", file=sys.stderr)
+        return caddis_exit.ERROR
+
+    cmd_ls = ["git", "-C", str(repo), "ls-remote", "--exit-code", "--heads", "origin", branch_name]
+    proc_ls = subprocess.run(cmd_ls, capture_output=True, text=True, encoding="utf-8", errors="replace")
+    if proc_ls.returncode not in (0, 2):  # 2 = no such branch; anything else = origin could not be read
+        print(f"WARNING: could not read origin (ls-remote exit {proc_ls.returncode}); origin/{branch_name} not deleted")
+    remote_tip = proc_ls.stdout.split()[0] if proc_ls.returncode == 0 and proc_ls.stdout.split() else ""
+    contained = remote_tip == head_ref_oid or (remote_tip and subprocess.run(
+        ["git", "-C", str(repo), "merge-base", "--is-ancestor", remote_tip, str(head_ref_oid)],
+        capture_output=True, text=True, encoding="utf-8", errors="replace").returncode == 0)
+    if remote_tip and not contained:
+        # Someone pushed after the merge: that work is not in main. Keep the remote branch.
+        print(f"kept origin/{branch_name}: its tip {remote_tip[:12]} is not contained in the merged PR head {str(head_ref_oid)[:12]}")
+    elif remote_tip:
+        cmd_push_del = ["git", "-C", str(repo), "push", "-q", "origin", "--delete", branch_name]
+        proc = subprocess.run(cmd_push_del, capture_output=True, text=True, encoding="utf-8", errors="replace")
+        if proc.returncode != 0:
+            print(f"failed command: {' '.join(cmd_push_del)}\n{proc.stderr.strip() or proc.stdout.strip()}", file=sys.stderr)
+            return caddis_exit.ERROR
+
+    cmd_prune = ["git", "-C", str(repo), "worktree", "prune"]
+    proc = subprocess.run(cmd_prune, capture_output=True, text=True, encoding="utf-8", errors="replace")
+    if proc.returncode != 0:
+        print(f"failed command: {' '.join(cmd_prune)}\n{proc.stderr.strip() or proc.stdout.strip()}", file=sys.stderr)
+        return caddis_exit.ERROR
+
+    print(f"removed {worktree} ({branch_name}); merge {merge_oid}; files compared: {files_compared}")
+    return caddis_exit.CLEAN
+
+
+def main(argv: list[str] | None = None) -> int:
+    """CLI entry point for caddis_worktree_close."""
+    if argv is None:
+        argv = sys.argv[1:]
+
+    parser = argparse.ArgumentParser(description="Close a worktree after PR merge.")
+    parser.add_argument("--repo", required=True, type=Path, help="Path to main repository")
+    parser.add_argument("--worktree", required=True, type=Path, help="Path to worktree to close")
+    parser.add_argument("--pr", required=True, type=int, help="PR number")
+    parser.add_argument(
+        "--port",
+        dest="ports",
+        type=int,
+        nargs="+",
+        action="extend",
+        default=[],
+        help="Ports to check for listening servers",
+    )
+    parser.add_argument("--dry-run", action="store_true", default=False, help="Dry run mode")
+
+    args = parser.parse_args(argv)
+
+    def real_gh(gh_args: list[str]) -> str:
+        proc = subprocess.run(
+            ["gh", *gh_args],
+            cwd=str(args.repo),
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return proc.stdout
+
+    return close_worktree(
+        repo=args.repo,
+        worktree=args.worktree,
+        pr=args.pr,
+        gh=real_gh,
+        ports=tuple(args.ports),
+        dry_run=args.dry_run,
+    )
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/bundles/antigravity-plugin/scripts/check_doc_coverage.py

@@ -38,7 +38,6 @@ from __future__ import annotations
 import argparse
 import os
 import re
-import subprocess
 import sys
 from pathlib import Path
 
@@ -282,54 +281,6 @@ def _split_list_entries(nested: list[str]) -> list[str]:
     return entries
 
 
-HUB_REPORTS_DIR = ".caddis/advisory-hub-reports"
-
-
-def misfiled_hub_spawns(root: Path) -> list[str]:
-    """Files whose FRONTMATTER declares `type: hub-spawn` but which live outside the reports dir.
-
-    `/caddis:spawn-hub` states the correct path, justifies it, and is gated — but the gate only
-    runs INSIDE the command. An agent asked for a handover "basically like what we do with caddis
-    spawn-hub" hand-wrote one without invoking it, never read the instruction, and filed the
-    artefact in `.caddis/prompts/` because that is where the project's generic prompts live. The
-    mechanism was self-enforcing only for those already using it.
-
-    The knock-on is the sharp part: spawn-hub's own trap-rotation step reads the last spawn prompt
-    from the reports dir to pick a fresh trap. A prompt filed elsewhere is invisible, so rotation
-    silently runs against an empty set — the exact failure the artefact file was introduced to
-    prevent, returning through a different door.
-
-    Frontmatter only, never a prose match: this repo's own documentation says `type: hub-spawn` in
-    running text, and flagging that would make the check permanently red where it is authored.
-    """
-    out: list[str] = []
-    try:
-        # --others --exclude-standard is load-bearing: a hand-rolled spawn prompt is UNTRACKED at
-        # the exact moment it is misfiled, and a plain `git ls-files` lists only tracked files. The
-        # first version of this check used one, so it passed cleanly on a live misfiled artefact —
-        # a check that cannot fail, guarding the case it was written for.
-        listed = subprocess.run(
-            ["git", "ls-files", "--cached", "--others", "--exclude-standard", "*.md"],
-            cwd=str(root), capture_output=True, text=True, timeout=30)
-        files = [root / p for p in listed.stdout.splitlines() if p.strip()] \
-            if listed.returncode == 0 else []
-    except Exception:
-        files = []
-    if not files:  # no git, or an empty listing — fall back to the artefact tree
-        files = sorted((root / ".caddis").rglob("*.md")) if (root / ".caddis").is_dir() else []
-    for f in files:
-        rel = f.relative_to(root).as_posix() if f.is_absolute() else str(f)
-        if rel.startswith(HUB_REPORTS_DIR):
-            continue
-        try:
-            meta = _header_fields(f.read_text(encoding="utf-8", errors="ignore"))
-        except OSError:
-            continue
-        if str(meta.get("type", "")).strip().lower() == "hub-spawn":
-            out.append(rel)
-    return out
-
-
 def trust_signal_warnings(text: str) -> list[str]:
     """Well-formedness warnings for the OKF v0.2 trust signals present in ``text``. Pure.
 
@@ -917,13 +868,6 @@ def run(root: Path, check: bool) -> int:
         for issue in issues:
             warnings.append(f"{rel}: {issue}")
 
-    # 5. Misfiled Hub artefacts (warning only).
-    for rel in misfiled_hub_spawns(root):
-        warnings.append(
-            f"{rel} is a hub-spawn artefact outside {HUB_REPORTS_DIR} — /caddis:spawn-hub's "
-            "trap rotation reads only that directory, so a prompt filed elsewhere is invisible "
-            "to it and the next succession rotates against an empty set")
-
     for w in warnings:
         print(f"  warning: {w}")
 

package/bundles/antigravity-plugin/scripts/claudster_doctor.py

@@ -51,6 +51,7 @@ ENV_PREFIX = "CADDIS"
 
 # Known top-level document and working artifact folders under .caddis/
 KNOWN_CADDIS_DIRS: set[str] = {
+    "advisory-hub-reports",  # retired 2026-10 (caddis-next Phase 12): kept as history, never a warning
     "plans",
     "prd",
     "kb",
@@ -64,7 +65,6 @@ KNOWN_CADDIS_DIRS: set[str] = {
     "prompts",
     "relay",
     "session-state",
-    "advisory-hub-reports",
     "orchestrator",
     "spawn-session",
     "metrics",