@caddis/cli 0.4.56 → 0.4.58

package/bundles/antigravity-plugin/skills/using-git-worktrees/SKILL.md

@@ -5,213 +5,90 @@ description: "Use when starting feature work that needs isolation from the curre
 
 # Using Git Worktrees
 
-## Overview
+A worktree gives one branch its own folder. It shares the repository with the main checkout.
 
-Git worktrees create isolated workspaces sharing the same repository, allowing work on multiple branches simultaneously without switching.
+**Branch in place by default.** Run `git switch -c <branch>`. Never create a sibling repository folder.
+Use a worktree only when the checkout is not safe to move.
 
-**Core principle:** Systematic directory selection + safety verification = reliable isolation.
+**Announce at start:** "I am using the using-git-worktrees skill to set up an isolated workspace."
 
-**Announce at start:** "I'm using the using-git-worktrees skill to set up an isolated workspace."
+## When to use a worktree
 
-## Directory Selection Process
+Use a worktree when any of these is true:
 
-Follow this priority order:
+1. The repo `AGENTS.md` says `Shared checkout: yes` (a dev service serves from it) and your change touches
+   served code. A change to `.caddis/` or `docs/` only may use a branch.
+2. Another session or agent may be live in the checkout, or you cannot tell. Codex and agy cannot detect
+   peers. For them, "cannot tell" means not safe.
+3. `git status` shows changes you did not make. Never stash, commit, reset or carry them.
+4. Two or more agents edit at the same time. Each editing agent gets its own worktree. The orchestrator
+   creates and removes them. Read-only subagents share the checkout and never move HEAD.
 
-### 1. Check Existing Directories
+If none is true, stop here and use `git switch -c`.
 
-```bash
-# Check in priority order
-ls -d .worktrees 2>/dev/null     # Preferred (hidden)
-ls -d worktrees 2>/dev/null      # Alternative
-```
-
-**If found:** Use that directory. If both exist, `.worktrees` wins.
+## Create the worktree
 
-### 2. Check AGENTS.md (the canonical rules file; CLAUDE.md is an @import shim)
+1. Fetch: `git fetch origin`.
+2. Find the default branch (`main` in most repos): `git symbolic-ref --short refs/remotes/origin/HEAD`.
+   It prints `origin/main`. Use the part after `origin/` as `<default>`.
+3. Create the worktree from `origin/<default>`, never from the local HEAD, under `%TEMP%`:
 
-```bash
-grep -i "worktree.*director" AGENTS.md CLAUDE.md 2>/dev/null
+```powershell
+git worktree add -b <branch> "$env:TEMP\<repo>-<short-name>" origin/<default>
 ```
 
-**If preference specified:** Use it without asking.
-
-### 3. Ask User
-
-If no directory exists and no AGENTS.md preference:
-
-```
-No worktree directory found. Where should I create worktrees?
+   Do not create worktrees inside the repo (no `.worktrees/`).
+4. State the full path of the worktree. Work only there, and do not switch branches in it.
 
-1. .worktrees/ (project-local, hidden)
-2. ~/.config/superpowers/worktrees/<project-name>/ (global location)
+## Install dependencies fresh
 
-Which would you prefer?
-```
+Install inside the worktree. Use the project's own command (`npm ci`, `python -m venv .venv` then
+`.venv\Scripts\python -m pip install -r requirements.txt`, `cargo build`, `go mod download`). Call the
+venv's own `python`; a bare `pip` can install into the global Python.
 
-## Safety Verification
+Never link `node_modules` or a venv from another folder. Tools that follow the link then change the
+shared copy, and a careless delete can follow it too.
 
-### For Project-Local Directories (.worktrees or worktrees)
+## Verify a clean baseline
 
-**MUST verify directory is ignored before creating worktree:**
+Run the project tests. If they fail, report the failures and ask before you go on. Then report:
 
-```bash
-# Check if directory is ignored (respects local, global, and system gitignore)
-git check-ignore -q .worktrees 2>/dev/null || git check-ignore -q worktrees 2>/dev/null
 ```
-
-**If NOT ignored:**
-
-Per Jesse's rule "Fix broken things immediately":
-1. Add appropriate line to .gitignore
-2. Commit the change
-3. Proceed with worktree creation
-
-**Why critical:** Prevents accidentally committing worktree contents to repository.
-
-### For Global Directory (~/.config/superpowers/worktrees)
-
-No .gitignore verification needed - outside project entirely.
-
-## Creation Steps
-
-### 1. Detect Project Name
-
-```bash
-project=$(basename "$(git rev-parse --show-toplevel)")
-```
-
-### 2. Create Worktree
-
-```bash
-# Determine full path
-case $LOCATION in
-  .worktrees|worktrees)
-    path="$LOCATION/$BRANCH_NAME"
-    ;;
-  ~/.config/superpowers/worktrees/*)
-    path="~/.config/superpowers/worktrees/$project/$BRANCH_NAME"
-    ;;
-esac
-
-# Create worktree with new branch
-git worktree add "$path" -b "$BRANCH_NAME"
-cd "$path"
-```
-
-### 3. Run Project Setup
-
-Auto-detect and run appropriate setup:
-
-```bash
-# Node.js
-if [ -f package.json ]; then npm install; fi
-
-# Rust
-if [ -f Cargo.toml ]; then cargo build; fi
-
-# Python
-if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
-if [ -f pyproject.toml ]; then poetry install; fi
-
-# Go
-if [ -f go.mod ]; then go mod download; fi
-```
-
-### 4. Verify Clean Baseline
-
-Run tests to ensure worktree starts clean:
-
-```bash
-# Examples - use project-appropriate command
-npm test
-cargo test
-pytest
-go test ./...
-```
-
-**If tests fail:** Report failures, ask whether to proceed or investigate.
-
-**If tests pass:** Report ready.
-
-### 5. Report Location
-
-```
-Worktree ready at <full-path>
+Worktree ready at <full-path> (branch <branch>, from origin/<default>)
 Tests passing (<N> tests, 0 failures)
-Ready to implement <feature-name>
 ```
 
-## Quick Reference
+## Remove it when done
 
-| Situation | Action |
-|-----------|--------|
-| `.worktrees/` exists | Use it (verify ignored) |
-| `worktrees/` exists | Use it (verify ignored) |
-| Both exist | Use `.worktrees/` |
-| Neither exists | Check AGENTS.md → Ask user |
-| Directory not ignored | Add to .gitignore + commit |
-| Tests fail during baseline | Report failures + ask |
-| No package.json/Cargo.toml | Skip dependency install |
+A worktree you create is yours to remove. Do it when the PR merges or the work stops. Remove all three:
 
-## Common Mistakes
+1. The worktree.
+2. The local branch.
+3. The remote branch, but only when its work is merged, or the owner says it is abandoned. If the work
+   only paused, keep the remote branch: it can be the only copy.
 
-### Skipping ignore verification
+After a squash merge, compare trees (content), not ancestry, before you delete.
 
-- **Problem:** Worktree contents get tracked, pollute git status
-- **Fix:** Always use `git check-ignore` before creating project-local worktree
+Do not delete a worktree folder by hand or with `rm -rf`: on Windows it can follow a junction into
+another folder. Use the `safe-cleanup` skill, or `scripts/caddis_worktree_close.py` after a merged PR.
 
-### Assuming directory location
-
-- **Problem:** Creates inconsistency, violates project conventions
-- **Fix:** Follow priority: existing > AGENTS.md > ask
-
-### Proceeding with failing tests
-
-- **Problem:** Can't distinguish new bugs from pre-existing issues
-- **Fix:** Report failures, get explicit permission to proceed
-
-### Hardcoding setup commands
-
-- **Problem:** Breaks on projects using different tools
-- **Fix:** Auto-detect from project files (package.json, etc.)
-
-## Example Workflow
-
-```
-You: I'm using the using-git-worktrees skill to set up an isolated workspace.
-
-[Check .worktrees/ - exists]
-[Verify ignored - git check-ignore confirms .worktrees/ is ignored]
-[Create worktree: git worktree add .worktrees/auth -b feature/auth]
-[Run npm install]
-[Run npm test - 47 passing]
-
-Worktree ready at /Users/jesse/myproject/.worktrees/auth
-Tests passing (47 tests, 0 failures)
-Ready to implement auth feature
-```
+Check for leftovers with `git worktree list`.
 
-## Red Flags
+## Red flags
 
 **Never:**
-- Create worktree without verifying it's ignored (project-local)
-- Skip baseline test verification
-- Proceed with failing tests without asking
-- Assume directory location when ambiguous
-- Skip AGENTS.md check
-
-**Always:**
-- Follow directory priority: existing > AGENTS.md > ask
-- Verify directory is ignored for project-local
-- Auto-detect and run project setup
-- Verify clean test baseline
+- Create a worktree from the local HEAD or a stale branch.
+- Put a worktree in the repo folder or in a sibling of the repo.
+- Link `node_modules` or a venv into a worktree.
+- Leave a worktree, local branch or merged remote branch behind after the work ends.
+- Use a worktree when `git switch -c` is safe.
 
 ## Integration
 
 **Called by:**
-- **brainstorming** (Phase 4) - REQUIRED when design is approved and implementation follows
-- Any skill needing isolated workspace
+- **brainstorming** (Phase 4) - when the design is approved and implementation follows
+- Any skill that needs an isolated workspace
 
 **Pairs with:**
-- **finishing-a-development-branch** - REQUIRED for cleanup after work complete
-- **executing-plans** or **subagent-driven-development** - Work happens in this worktree
+- **finishing-a-development-branch** - cleanup after the work is complete
+- **executing-plans** or **subagent-driven-development** - the work happens in this worktree

package/bundles/antigravity-plugin/warm_start_agy.py

@@ -245,23 +245,32 @@ def _hook_note(feature, exc, root=None):
 
 
 
-def _injected_marker(root, conversation):
-    """Path of the per-conversation "relay already injected" marker, or None."""
-    try:
-        safe = "".join(c for c in str(conversation) if c.isalnum() or c in "-_")[:64]
-        if not safe:
-            return None
-        return os.path.join(str(root), ".caddis", ".relay-injected", safe)
-    except Exception:
-        return None
+def _safe_conversation(conversation):
+    return "".join(c for c in str(conversation) if c.isalnum() or c in "-_")[:64]
+
+
+def _injected_markers(root, conversation):
+    """Where the "relay already injected" marker for this conversation may be: (repo marker, temp marker).
+
+    The repo marker lives in `.caddis/.relay-injected/`. The temp marker lives in the user's temp
+    folder, keyed by the repo path, for a repo that has no `.caddis/` (the hook must not create one).
+    """
+    safe = _safe_conversation(conversation)
+    if not safe:
+        return None, None
+    import hashlib
+    import tempfile
+    repo_marker = os.path.join(str(root), ".caddis", ".relay-injected", safe)
+    key = hashlib.sha1(os.path.normcase(os.path.abspath(str(root))).encode("utf-8", "replace")).hexdigest()[:16]
+    temp_marker = os.path.join(tempfile.gettempdir(), "caddis-relay-injected", key + "-" + safe)
+    return repo_marker, temp_marker
 
 
 def _already_injected(root, conversation):
     """True when this conversation has had its relay injected before. Fail-open: on any
     error return False, because a duplicate relay is a smaller harm than none at all."""
     try:
-        marker = _injected_marker(root, conversation)
-        return bool(marker) and os.path.isfile(marker)
+        return any(m and os.path.isfile(m) for m in _injected_markers(root, conversation))
     except Exception:
         return False
 
@@ -269,13 +278,15 @@ def _already_injected(root, conversation):
 def _mark_injected(root, conversation):
     """Record that this conversation received its relay. Never raises.
 
-    A failure here means the next truncation may re-inject — the pre-2026-08-22 behaviour,
-    which is exactly the fail-open direction we want.
+    The marker goes in `.caddis/` when the repo already has it, else in the user's temp folder:
+    this hook never creates `.caddis/` in a repo that did not opt in. A failure here means the
+    next truncation may re-inject, which is the fail-open direction we want.
     """
     try:
-        marker = _injected_marker(root, conversation)
-        if not marker:
+        repo_marker, temp_marker = _injected_markers(root, conversation)
+        if not repo_marker:
             return
+        marker = repo_marker if os.path.isdir(os.path.join(str(root), ".caddis")) else temp_marker
         os.makedirs(os.path.dirname(marker), exist_ok=True)
         with open(marker, "w", encoding="utf-8") as fh:
             fh.write("")

package/bundles/antigravity-plugin-extras/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "caddis-extras",
-  "version": "1.3.44",
+  "version": "1.3.45",
   "description": "caddis-extras — the long-tail skills for the Antigravity (agy) caddis plugin; install alongside caddis for the full set."
 }

package/bundles/antigravity-plugin-extras/skills/agent-orchestration/SKILL.md

@@ -128,7 +128,7 @@ Spec Input
 2. Categorise every item by effort (H = hours, D = days) and value (high / medium / low)
 3. Items that are **≤ 1 hour AND high-value** become quick wins (H1, H2, H3…)
 4. Implement quick wins in a single session
-5. Run full test suite — all tests must pass
+5. Run the tests of the touched files in the foreground (each command under 10 minutes) — all must pass. CI runs the full suite
 6. Commit: `feat: H1–H3 quick wins — <summary>`
 
 **Decision Gate:**
@@ -266,10 +266,10 @@ Score each identified risk:
 2. Provide the phase prompt:
    ```
    Read .caddis/plans/<feature>.md and implement Phase N.
-   Run pytest after every file change. All tests must pass before commit.
+   Run the tests of the files you changed, in the foreground, each command under 10 minutes. They must pass before commit. CI runs the full suite.
    ```
 3. Implement Agent reads the plan, executes numbered steps
-4. After implementation: run full test suite
+4. After implementation: run the tests of the touched files in the foreground (each command under 10 minutes). CI runs the full suite
 5. If tests pass → commit: `feat(<scope>): phase N — <summary>`
 6. If tests fail → fix within the same session before committing
 
@@ -340,7 +340,7 @@ The plan document should contain **copy-paste prompts** for each phase. This rem
    - Acceptance criteria
 3. **Write fix-up plan** — Place in `.caddis/plans/<feature>-fixup.md`
 4. **Execute** — Implement Agent works through issues sequentially
-5. **Verify** — Run full test suite + visual inspection
+5. **Verify** — Run the tests of the touched files (foreground, each command under 10 minutes) + visual inspection. CI runs the full suite
 6. **Commit** — `fix(<scope>): post-track cross-component polish`
 
 **Example from practice:**
@@ -610,7 +610,7 @@ Every stage that produces code changes should result in a commit:
 A well-orchestrated session should produce:
 
 - [ ] **Traceability** — Every spec requirement maps to a plan step, which maps to a commit
-- [ ] **Green tests** — Full suite passing after every commit
+- [ ] **Green tests** — Touched-file tests pass before every commit; CI runs the full suite on every PR
 - [ ] **Clean plan** — Fidelity audit: 0 gaps
 - [ ] **Managed risks** — No showstoppers unresolved
 - [ ] **Minimal rework** — Debug pass finds cosmetic issues, not fundamental errors

package/bundles/antigravity-plugin-extras/skills/cross-review/SKILL.md

@@ -95,7 +95,7 @@ smaller chunks; don't just raise `--max-diff-chars` without knowing the endpoint
 
 ## Three rules: one attempt, one review
 1. **Think before you send.** Before a task goes to any coder, write its edge cases and check the facts it depends on (one query or one file read).
-2. **Run it before review.** The coder runs the same checks as CI (name the exact commands in the task). Then run the change once on real data.
+2. **Run it before review.** The coder runs only the tests of the files it touched, in the foreground, each command under 10 minutes (split into parts if needed). Name the exact commands in the task. Never start the full suite in the background and never wait on a monitor for it: CI runs the full suite on every PR. Then run the change once on real data.
 3. **Review by tier.** Run `python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_gate.py" review-tier --range <base>...HEAD` (add `--plan <plan> --phase <N>` inside a plan; no `TIER:` line means tier 2).
    Tier 0: gates only. Tier 1-small: your self-check only. Tier 1: one review by another vendor; stop at
    the first CLEAN. Tier 2: two reviewers of two other vendors, in one round. Fix blocking findings only;

package/bundles/codex/.codex/skills/devops/gh-cli/SKILL.md

@@ -73,7 +73,10 @@ gh pr diff 55
 gh pr checkout 55
 gh pr review 55 --approve --body "LGTM!"
 gh pr review 55 --request-changes --body "Please fix error handling"
-gh pr merge 55 --squash --delete-branch
+# merge only on ci-watch RESULT: pass, only its HEAD:, with no default-branch run in progress
+python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_lanes.py" ci-watch --pr 55
+gh run list --branch main --json status       # no in_progress or queued run (main = the default branch)
+gh pr merge 55 --squash --delete-branch --match-head-commit <watched head>
 
 # Manage
 gh pr ready 55             # Mark draft as ready
@@ -170,8 +173,9 @@ gh issue develop 42 --branch fix/issue-42
 git add src/auth/login.py tests/test_login.py   # named files only, never `git add .`
 git commit -m "fix: resolve login bug" -- src/auth/login.py tests/test_login.py && git push -u origin HEAD
 gh pr create --title "fix: resolve login bug" --body "Closes #42"
-gh pr checks --watch
-gh pr merge --squash --delete-branch
+python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_lanes.py" ci-watch --pr <n>   # RESULT: pass, HEAD: <watched head>
+gh run list --branch main --json status       # wait while a default-branch run is in progress
+gh pr merge <n> --squash --delete-branch --match-head-commit <watched head>
 ```
 
 ### Release Workflow
@@ -189,8 +193,8 @@ gh release upload v1.3.0 ./dist/*.tar.gz
 | Create repo       | `gh repo create name --public`                 |
 | Create issue      | `gh issue create --title "..." --labels bug`   |
 | Create PR         | `gh pr create --title "..." --reviewer user`   |
-| Merge PR          | `gh pr merge 55 --squash --delete-branch`      |
+| Merge PR          | `gh pr merge 55 --squash --delete-branch --match-head-commit <watched head>`, only after ci-watch `RESULT: pass` |
 | Create release    | `gh release create v1.0.0 --generate-notes`    |
-| Watch CI          | `gh run watch`                                 |
+| Watch CI          | `caddis_lanes.py ci-watch --pr 55` (fallback: `gh run watch`) |
 | Set secret        | `echo "val" \| gh secret set KEY`              |
 | API call          | `gh api /repos/o/r --jq '.description'`        |