@caddis/cli 0.4.37 → 0.4.39

package/bundles/antigravity-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "caddis",
-  "version": "1.3.124",
+  "version": "1.3.126",
   "description": "caddis — agent-agnostic dev harness as an Antigravity (agy) plugin: TDD skills + commands, single-sourced with the Claude Code plugin."
 }

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

@@ -108,6 +108,18 @@ _LANES_RUN = r'python\s+"?\$\{CLAUDE_PLUGIN_ROOT\}/scripts/caddis_lanes\.py"?\s+
 
 # ── gate: lane-check ────────────────────────────────────────────────────────
 
+_QUOTED = re.compile(r"\"[^\"]*\"|'[^']*'")
+
+
+def _has_print_flag(cmd: str) -> bool:
+    """True when the command carries a real -p/--print flag.
+
+    The quoted prompt is blanked first: a prompt that merely contains the text " -p " must not
+    count, or an interactive child passes the gate (R3 cross-review, 2026-09-30).
+    """
+    return bool(re.search(r"(?:^|\s)(?:-p|--print)(?:\s|$)", _QUOTED.sub('""', cmd)))
+
+
 def gate_lane(plan: Path, phase: int) -> int:
     if not plan.is_file():
         return _degrade(f"no plan at {plan}")
@@ -157,12 +169,12 @@ def gate_lane(plan: Path, phase: int) -> int:
                 f"[caddis-gate] phase {phase}'s direct command names Phase {named.group(1)}: {cmd}\n"
                 "  The lane would run another phase's work. Refusing to run it.\n")
             return EXIT_MALFORMED
-        if cmd.startswith("agy") and not re.search(r"(?:^|\s)(?:-p|--print)(?:\s|$)", cmd):
+        if cmd.startswith("agy") and not _has_print_flag(cmd):
             sys.stderr.write(
                 f"[caddis-gate] phase {phase}'s direct agy command has no -p/--print: {cmd}\n"
                 "  The child would not run headless. Refusing to run it.\n")
             return EXIT_MALFORMED
-    elif not re.search(r"(?:^|\s)(?:-p|--print)(?:\s|$)", cmd):
+    elif not _has_print_flag(cmd):
         sys.stderr.write(
             f"[caddis-gate] phase {phase}'s launch command has no -p/--print: {cmd}\n"
             "  Without it the child is not marked headless, reads the same Lane line, and spawns\n"
@@ -496,14 +508,37 @@ def gate_handover_check(doc: Path, repo_root: Path, max_chars: int | None = None
         return EXIT_BLOCKED
 
     missing: list[str] = []
-    for raw in sorted(set(_DOC_PATH.findall(text))):
-        # A backtick often wraps a whole command; the path is the token that looks like one.
-        cand = next((tok for tok in raw.split() if "/" in tok or tok.endswith(".md")), raw)
-        cand = cand.strip("(),;:'\"")
-        if cand.startswith(("http://", "https://", "~", "$")) or ".." in cand:
-            continue
-        if not (repo_root / cand).exists():
-            missing.append(cand)
+    try:
+        # One rule for both gates: `caddis_spawn.check_document` already treats a bare filename
+        # that matches no tracked file as a note (probably another repository's file), and one
+        # that matches tracked files as a block that names the full path. Two gates giving
+        # different answers to the same question is the defect this replaces.
+        here = str(Path(__file__).resolve().parent)
+        if here not in sys.path:
+            sys.path.insert(0, here)
+        import caddis_spawn
+        findings = caddis_spawn.check_document(text, repo_root)
+        missing = sorted(set(findings.missing_paths))
+        for name in findings.unresolved_names:
+            sys.stderr.write(
+                f"[caddis-gate] note: `{name}` is a bare filename that matches no tracked file here; "
+                "not checked\n")
+    except Exception as exc:
+        # Degrade to the plain existence rule, but say why: a bug inside the shared helper must
+        # not hide behind the fallback (an ImportError is the expected, quiet case).
+        if not isinstance(exc, ImportError):
+            sys.stderr.write(
+                f"[caddis-gate] note: shared path check failed ({type(exc).__name__}: {exc}); "
+                "using the plain existence rule\n")
+        missing = []
+        for raw in sorted(set(_DOC_PATH.findall(text))):
+            # A backtick often wraps a whole command; the path is the token that looks like one.
+            cand = next((tok for tok in raw.split() if "/" in tok or tok.endswith(".md")), raw)
+            cand = cand.strip("(),;:'\"")
+            if cand.startswith(("http://", "https://", "~", "$")) or ".." in cand:
+                continue
+            if not (repo_root / cand).exists():
+                missing.append(cand)
 
     stale: list[dict] = []
     try:

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

@@ -263,6 +263,8 @@ def stale_artifacts(root: Path) -> list[dict]:
             target = root / m
             if not target.is_file():
                 continue
+            if not _run(["git", "ls-files", "--", m], root):
+                continue  # untracked or git-ignored: rebuilt locally, so an old commit says nothing
             t_art = _run(["git", "log", "-1", "--format=%ct", "--", m], root)
             t_gen = _run(["git", "log", "-1", "--format=%ct", "--", f"scripts/{script.name}"], root)
             if not t_art or not t_gen:

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

@@ -992,7 +992,13 @@ def next_lane(
 
 
 def _ci_watch_block(output: str) -> dict[str, str] | None:
-    """Read the last complete watch report, ignoring an echoed prompt template."""
+    """Read the last complete watch report, ignoring an echoed prompt template.
+
+    The block must hold exactly RESULT, CHECKS, MERGE_STATE and FAILING, RESULT first. A reordered
+    or extended block returns None, and the caller then falls back to `gh` without saying why:
+    that is safe (the watch prompt pins the order) but invisible, so keep the prompt and this
+    reader in step.
+    """
     fields: dict[str, str] = {}
     reports: list[dict[str, str]] = []
     for line in output.splitlines():

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

@@ -259,6 +259,7 @@ def render_index(root: Path, session_id: str | None, branch: str | None) -> str:
                 rows.append((at.timestamp(), f"- {label} ({branch_label}, {_age(at, now)}): {_next_step(content)}"))
             except (ValueError, KeyError, TypeError, AttributeError, OSError, UnicodeError):
                 continue
+        unnamed: list[tuple[datetime, str, str, str]] = []
         states = artifact / "session-state"
         if states.exists() and not states.resolve().is_relative_to(artifact.resolve()):
             raise ValueError("session-state directory escapes artifact root")
@@ -277,9 +278,22 @@ def render_index(root: Path, session_id: str | None, branch: str | None) -> str:
                 asked = request.group(1).strip() if request else ""
                 note = _single_line(asked, 80) if asked and not asked.startswith("<") else "recent session"
                 branch_label = _single_line(state_branch.group(1), 40) if state_branch else "unknown branch"
-                rows.append((modified.timestamp(), f"- unnamed session {label} ({branch_label}, {_age(modified, now)}): {note}"))
+                if session_id and path.stem == session_id:
+                    rows.append((modified.timestamp(), f"- this session, no relay yet ({branch_label}): {note}"))
+                else:
+                    unnamed.append((modified, label, branch_label, note))
             except (OSError, UnicodeError):
                 continue
+        if unnamed:
+            # One line for every other session without a relay: a forked, peer or never-handed-off
+            # session is repeated text at every session start and buries the real workstreams.
+            unnamed.sort(key=lambda item: (-item[0].timestamp(), item[1]))
+            newest, label, _branch_label, note = unnamed[0]
+            count = len(unnamed)
+            noun = "session" if count == 1 else "sessions"
+            rows.append((newest.timestamp(),
+                         f"- {count} other {noun} without a relay (newest {label}, {_age(newest, now)}): "
+                         f"{note}; see .caddis/session-state/"))
         rows.sort(key=lambda item: (-item[0], item[1]))
         heading = _INDEX_MARKER + "# Workstream index\n"
         if session_id or branch:

package/bundles/manifest.json

@@ -1,7 +1,7 @@
 {
-  "poolVersion": "1.3.124",
+  "poolVersion": "1.3.126",
   "bundles": {
-    "antigravity-plugin": "1.3.124",
+    "antigravity-plugin": "1.3.126",
     "antigravity-plugin-extras": "1.3.40",
     "codex": "unknown"
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caddis/cli",
-  "version": "0.4.37",
+  "version": "0.4.39",
   "description": "Install, update and diagnose the caddis dev harness across every coding agent you use (Claude Code, agy/Antigravity, and more).",
   "keywords": [
     "caddis",