@caddis/cli 0.4.11 → 0.4.12

package/bundles/antigravity-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "caddis",
-  "version": "1.3.99",
+  "version": "1.3.101",
   "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_spawn.py

@@ -546,14 +546,58 @@ def handshake_read(repo_root: Path, spawn_id: str) -> dict | None:
         return None
 
 
+MAX_REJECTS = 2
+
+
 def handshake_record(repo_root: Path, spawn_id: str, event: str,
-                     peer: str = "") -> tuple[dict | None, str]:
-    """Advance the handshake. Never rewinds: a verdict cannot un-answer the questions, and an
-    out-of-order event is a sign the operator has lost track of which round they are in — which
-    is exactly when a silent overwrite would hurt."""
+                     peer: str = "", verdict: str = "") -> tuple[dict | None, str]:
+    """Advance the handshake. One step forward, with exactly one named exception.
+
+    **REJECT sends it back to `awaiting-answers`, and that is the whole point of this function
+    having a rewind at all.** `spawn-session.md` defines REJECT as "an instruction to re-read named
+    sections and re-answer", and says "two REJECTs on one spawn means the HANDOVER is at fault —
+    regenerate it". Neither was possible until 2026-09-10: the states were strictly linear, so
+    after `verdict-sent` the only legal event was `ack`, and the handshake did not even record
+    WHICH verdict was sent. ACCEPT and REJECT were indistinguishable in the state file, so nothing
+    could count REJECTs and the two-strike rule was unenforceable prose.
+
+    Every other rewind is still refused. An out-of-order event is an operator who has lost track of
+    the round, which is exactly when a silent overwrite would hurt.
+    """
     state = handshake_read(repo_root, spawn_id)
     if state is None:
         return None, f"no handshake for {spawn_id} — run `handshake open --id {spawn_id}` first"
+
+    verdict = (verdict or "").strip().upper()
+    if event == "verdict" and verdict == "REJECT":
+        if state["state"] != "answered":
+            return state, (f"at `{state['state']}` — a REJECT only follows `answered`. "
+                           "There is nothing to reject yet.")
+        n = int(state.get("rejects", 0)) + 1
+        if n > MAX_REJECTS - 1:
+            state["rejects"] = n
+            # Recorded even though it is refused. The counter is the enforceable fact, but a
+            # history showing one REJECT beside a count of two is a state file that contradicts
+            # itself, and the next reader has to work out which half to believe.
+            state["history"].append({"event": "verdict", "verdict": "REJECT", "refused": True,
+                                     "at": int(time.time()),
+                                     **({"peer": peer} if peer else {})})
+            _handshake_path(repo_root, spawn_id).write_text(
+                json.dumps(state, indent=2) + chr(10), encoding="utf-8")
+            return state, (
+                f"REJECT #{n}. `spawn-session.md`: two REJECTs on one spawn means the HANDOVER is "
+                "at fault, not the successor. Regenerate it — do not coach the child through a "
+                "third round. Close this handshake and open a new one on a rewritten handover.")
+        state["rejects"] = n
+        state["state"] = "awaiting-answers"
+        state["history"].append({"event": "verdict", "verdict": "REJECT", "at": int(time.time()),
+                                 **({"peer": peer} if peer else {})})
+        if peer:
+            state["peer"] = peer
+        _handshake_path(repo_root, spawn_id).write_text(
+            json.dumps(state, indent=2) + chr(10), encoding="utf-8")
+        return state, ""
+
     target = _EVENT_STATE[event]
     here = HANDSHAKE_STATES.index(state["state"])
     there = HANDSHAKE_STATES.index(target)
@@ -571,6 +615,7 @@ def handshake_record(repo_root: Path, spawn_id: str, event: str,
     if peer:
         state["peer"] = peer
     state["history"].append({"event": event, "at": int(time.time()),
+                             **({"verdict": verdict} if event == "verdict" and verdict else {}),
                              **({"peer": peer} if peer else {})})
     state["state"] = target
     _handshake_path(repo_root, spawn_id).write_text(
@@ -659,6 +704,12 @@ def main(argv: list[str] | None = None) -> int:
     h.add_argument("--id", required=True)
     h.add_argument("--repo-root", default=".")
     h.add_argument("--event", choices=sorted(_EVENT_STATE))
+    h.add_argument("--verdict", default="",
+                   choices=["", "ACCEPT", "ACCEPT-WITH-CORRECTION", "REJECT"],
+                   help="with `--event verdict`. REJECT returns the handshake to "
+                        "`awaiting-answers` so the child re-reads and re-answers, and counts the "
+                        "strike; the second REJECT refuses and tells you to regenerate the "
+                        "handover instead of coaching the child through a third round")
     h.add_argument("--transport", choices=["auto", "message", "paste"], default="auto")
     h.add_argument("--peer", default="",
                    help="the child's name as ListAgents shows it — take it from the `from-name` "
@@ -763,11 +814,14 @@ def main(argv: list[str] | None = None) -> int:
             if not a.event:
                 sys.stderr.write("[spawn] --event is required for `record`" + chr(10))
                 return EXIT_REFUSED
-            st, err = handshake_record(root, a.id, a.event, a.peer)
+            st, err = handshake_record(root, a.id, a.event, a.peer, a.verdict)
             if err:
                 sys.stderr.write("[spawn] " + err + chr(10))
                 return EXIT_REFUSED
-            print(f"[spawn] {a.id}: {st['state']}")
+            rejects = int((st or {}).get("rejects", 0))
+            tail = f"  (REJECT #{rejects} — re-read and re-answer)" if \
+                (a.verdict.upper() == "REJECT" and rejects) else ""
+            print(f"[spawn] {a.id}: {st['state']}{tail}")
             return EXIT_OK
         if a.action == "close" and not (st.get("peer") or "").strip() \
                 and st["state"] != HANDSHAKE_STATES[0]:

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

@@ -699,6 +699,16 @@ repo**: an access request, a decision from another team, a change only someone e
 table stops a sent message from going unchased. Comms are almost always sent to get an *action*, and
 an unanswered ask looks exactly like a forgotten one unless something is tracking it.
 
+**Read that rule the other way round: THIS TABLE IS WHERE YOU LOOK BEFORE YOU WRITE ONE.** Check it
+before drafting, not only after filing. A handover transfers a task, and for the whole overlap
+window two sessions can both believe an outbound note is theirs - on 2026-09-08 two of them wrote
+the same note five minutes apart, and both sat here marked ready to send. Two notes on one subject
+reaching one team reads as one team not talking to itself.
+
+**If you do find a duplicate, do not delete it.** Verify its unique contributions independently,
+fold them into the survivor, and archive the loser with a banner saying why. The second draft is a
+second reading - the one in that incident found a defect in the first.
+
 | Raised | Audience | Subject | Status | Blocks | File |
 |---|---|---|---|---|---|
 | _(none yet)_ | | | | | |

package/bundles/antigravity-plugin/skills/spawn-session/SKILL.md

@@ -360,6 +360,21 @@ The vocabulary matches `/caddis:validate-phase` on purpose: same discipline, dif
 **Two REJECTs on one spawn means the HANDOVER is at fault, not the successor. Regenerate it** rather
 than coaching the child through it.
 
+**Record the verdict — the machine enforces both of those rules only if you tell it which one:**
+
+```
+python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_spawn.py" handshake record --id <id> --event verdict --verdict REJECT
+```
+
+A REJECT returns the handshake to `awaiting-answers`, so `record --event answers` is legal again
+and the child re-answers. The **second** REJECT is refused: it tells you to regenerate the handover,
+and the only way forward is then ACCEPT or abandoning the handshake.
+
+Until 2026-09-10 `--verdict` did not exist. The states were strictly linear, so after `verdict-sent`
+the only legal event was `ack`, and nothing recorded WHICH verdict was sent — ACCEPT and REJECT were
+indistinguishable in the state file. So "re-read and re-answer" was impossible and "two REJECTs
+means regenerate" was unenforceable, because nothing counted them.
+
 ### When the fault is yours, fix the class
 
 If validation finds an error that came from your handover, **fix the source document in the same

package/bundles/antigravity-plugin/skills/ui-brief/SKILL.md

@@ -74,7 +74,12 @@ Every component must reflect the agreed colour story and font pairing — no fal
 
 **Motion discipline:**
 - Use animation as communication, not decoration
-- Always respect `prefers-reduced-motion` media query
+- Always respect `prefers-reduced-motion` media query — but treat it as a DEFAULT, not a verdict.
+  Windows Server ships with animations off with no user preference expressed, so a build that only
+  checks the media query once at load and never offers a way back can freeze a genuinely correct
+  animation for the whole session with no override (found in `.caddis/second-brain.html`: the OS
+  read is captured into a `var` at script start and never re-read). Read the OS default into a
+  visible toggle, and have the draw loop read the toggle's current state, not a captured constant.
 - One hero animation moment — not every element animating on load
 - 44px minimum touch targets on mobile
 

package/bundles/manifest.json

@@ -1,7 +1,7 @@
 {
-  "poolVersion": "1.3.99",
+  "poolVersion": "1.3.101",
   "bundles": {
-    "antigravity-plugin": "1.3.99",
+    "antigravity-plugin": "1.3.101",
     "antigravity-plugin-extras": "1.3.29",
     "codex": "unknown"
   }

package/package.json

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