@caddis/cli 0.4.52 → 0.4.54

package/bundles/antigravity-plugin/skills/feature-plan/SKILL.md

@@ -13,9 +13,8 @@ The plan file is the **durable spine of the harness** — it must let any future
 agent, on any tool) resume with zero re-discovery. Optimize for that.
 
 ## Headless mode
-When the invocation contains the marker **`HEADLESS RUN RULES`**, **or `CADDIS_HEADLESS` /
-`DOCKET_PLAN` / `DOCKET_BRANCH` is set in the environment** (the caddis OSS launchers export
-`CADDIS_HEADLESS` on claude's `-p`/`--print`; the docket runner sets the others) — a non-interactive
+When the invocation contains the marker **`HEADLESS RUN RULES`**, **or `CADDIS_HEADLESS` is set in
+the environment** (the caddis OSS launchers export it on claude's `-p`/`--print`) — a non-interactive
 caller spawned this session and no human is present, so the scope-check questions and any interview are
 **suspended and forbidden**. This mode exists for one-line ideas: the card may be a short title with **no
 description**, and there may be **no codebase, PROJECT-FACTS, or prior PRD** to read. That is expected —
@@ -39,13 +38,6 @@ Absolute rules in this mode (they override everything below):
   a bullet under `## Constraints & decisions` — never a question to the user.
 - **Honor the caller's output path and slug** (falling back to `.caddis/plans/<feature-slug>.md`);
   set `feature: <slug>` in the frontmatter to that slug.
-- **Also emit a visual companion** — a self-contained, scannable HTML page at `<artifact_dir>/<slug>.html`
-  presenting the plan visually (a goal card, phases as cards with their steps, an affected-files table,
-  and a risks/decisions section). **Use inline `<style>` ONLY** — the visual is rendered in a *sandboxed*
-  iframe with no script execution, so a `<script>`/CDN (e.g. the Tailwind browser CDN) would NOT run and
-  the page would appear unstyled. Keep it fully portable — no external `<script>`/`<link>`, no local
-  asset files, no `/`-rooted paths. This is the visual the human reviews in docket alongside the markdown.
-  Write it after the `.md`; the runner finds it by the matching `<slug>.html` name.
 - **Always write the plan file, then end with exactly one fenced `json` highlights block** — nothing
   after it:
   ```json
@@ -62,8 +54,14 @@ points), read it first. It's a free, token-zero project fingerprint that anchors
 exists instead of assumed. If the work fits comfortably in one session, say so and offer to just do it
 instead of planning. Only produce a plan for genuinely multi-phase work.
 
+**Check upstream first when the plan builds on Claude Code behaviour** (hooks, headless `claude -p`, permission
+modes, subagents, worktrees, plugins and skills, Remote Control, background sessions). Read
+`.caddis/kb/claude-code-upstream-watch.md` if the repo has it, and the latest Claude Code changelog for that area
+(Improvements, Bug fixes, In development). Do not plan a fix or a workaround for something Claude Code has already
+changed, fixed or announced; cite the release in **Constraints & decisions** instead.
+
 ### Evidence gate — do not write plan content while a BLOCKER is unresolved
-Absorbed from `golden-plan`, whose strongest idea this is, and the direct counter to the failure
+This is the direct counter to the failure
 mode that makes a plan dangerous: **you write the spec, so you cannot see its gaps.** A phase built
 on guessed field names or an imagined API is confidently wrong, passes every completeness check,
 and only fails at the exit gate — or worse, doesn't.
@@ -164,9 +162,11 @@ of that role and write its Lane line as follows:
 - `sonnet`: `claude — /model sonnet`
 - `claude`: `claude — this session`
 - `codex`: codex — `codex exec --ephemeral --sandbox workspace-write "HEADLESS RUN RULES. Read <plan path> and its Constraints. Implement Phase N only in the current checkout. Do not switch or create branches, commit, push, or edit files outside this phase. Run its exit gate and report the literal result."`
-- `agy`: agy — `agy --mode accept-edits --dangerously-skip-permissions --add-dir . --print-timeout 20m --output-format text -p "HEADLESS RUN RULES. Read <plan path> and its Constraints. Implement Phase N only in the current checkout. Do not switch or create branches, commit, push, or edit files outside this phase. Run its exit gate and report the literal result."`
+- `agy`: agy — `python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_spend.py" run --caller lane-pN -- agy --mode accept-edits --dangerously-skip-permissions --add-dir . --print-timeout 20m --output-format json -p "HEADLESS RUN RULES. Read <plan path> and its Constraints. Implement Phase N only in the current checkout. Do not switch or create branches, commit, push, or edit files outside this phase. Run its exit gate and report the literal result."`
 
-Replace `<plan path>` and `N` with this plan's path and phase number. If the routing command fails
+Replace `<plan path>` and `N` (also in `lane-pN`) with this plan's path and phase number. The agy line
+always starts with `caddis_spend.py run`: it books the call against the global EUR spend cap, and
+`caddis_gate.py lane-check` refuses a bare `agy` Lane line. If the routing command fails
 or exits 3, use `claude — this session` and state the reason in that phase.
 
 #### A phase may take a no-escalation lane only if its exit gate would fail on a spec error
@@ -186,14 +186,9 @@ internal repo path into stakeholder-facing copy, and set a `live` status flag th
 framework's own "Soon" badge). `tsc` clean, 632/632 tests green, cross-review CLEAN, exit gate
 satisfied. A headless run following it literally would have committed both, entirely green.
 
-In an Advisory-Hub plan, treat your lane as **provisional**: the Hub writes each `phase-NN.prompt.md`
-before the phase runs, and that is the first time anyone but the spec's author reads it. Let that
-read confirm or downgrade the lane. It costs nothing — the prompt is being written anyway.
-
 ### Group phases into MILESTONES — only when the plan is big enough
 **Add milestones when the plan has ~8+ phases OR spans multiple sessions.** Below that, phases and a
-Tracker are enough; a three-phase feature gains nothing from ceremony. (Same sizing instinct as the
-Advisory-Hub test, deliberately — one threshold to remember, not two.)
+Tracker are enough; a three-phase feature gains nothing from ceremony.
 
 A milestone is **a group of phases that ship together**. It answers "what lands when this is done?",
 which is the question a long plan otherwise leaves the executor guessing at.
@@ -211,9 +206,10 @@ resuming session can see at a glance which group it is in and what remains befor
 ### Flag high-risk phases (`risk:` — a marker, not a mechanism)
 Each phase may carry **`risk: normal|high`** (default `normal` — omit the line unless the phase is
 `high`), meaning only "this is a phase where a wrong answer is expensive" — security/authz, a
-correctness-critical algorithm, an ambiguous spec, or an irreversible change. It is **inert**: it
-selects no model, spawns no agents, and implies no fan-out — it exists so the executor can decide **at
-runtime** whether an extra cross-check is worth it. Do not emit orchestration, lane fan-out, or
+correctness-critical algorithm, an ambiguous spec, or an irreversible change. It selects no model and
+implies no fan-out. It has one effect: the roadmap/plan runner reviews a finished `risk: high` phase
+twice (`caddis_review.py --plan --phase --runs 2`), gives it one fix session on blocking
+findings, and stops `BLOCKED review` when findings remain. Roadmap mode reviews before it publishes the PR. Do not emit orchestration, lane fan-out, or
 `Workflow` scripts from this command; the runtime decision rules and the intent→model map live in one
 place, the `agent-orchestration` skill's *Multi-model fan-out* section.
 
@@ -275,7 +271,10 @@ yourself (relay + Tracker) before stopping — do not hand back "run `/caddis:ha
 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.
-3. **Review once.** Use whatever reviewer is available. Stop at the first CLEAN. After two blocking reviews, ask the owner.
+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;
+   park the rest. Re-review only the fix diff, and only when the fix changed logic. After 3 rounds, ask the owner.
 
 - One phase at a time: read this plan → run the phase on its **Lane** → RED→GREEN→VERIFY→CROSS-REVIEW→
   COMMIT → update the **Tracker** row. The Tracker is the resume signal for every future session.
@@ -293,6 +292,10 @@ Three rules: one attempt, one review.
      normally; the halt stops anything being **built on top of it** before a human has looked. Blast
      radius stays one reviewable, revertable commit. Halting *beforehand* buys nothing: the phase has
      to be executed either way, and a well-specced high-risk phase is as executable as any other.
+     One exception: when the session prompt says the runner reviews `risk: high` phases (the
+     runner's `plan-resume-prompt.md` says so), the runner's review gate replaces this halt: the
+     session ends `STATUS: CONTINUE`, and the runner reviews the phase twice before anything builds
+     on it. A headless marker (`CADDIS_HEADLESS=1`) alone does not lift the halt.
   4. **A failed or blocked phase** — tests red, exit gate unmet, or the plan turned out wrong. Stop;
      do not build on it.
 - **A lane change is NOT a halt.** `/caddis:implement` spawns the assigned lane itself and verifies
@@ -366,66 +369,15 @@ done:
 
 If any phase relies on the implementer *reasoning out* a gap, close the gap in the plan now.
 
-## Step 3b — Does this plan need an Advisory Hub? (ask once, here)
-
-The Advisory Hub is **opt-in per plan**, gated on a single file: `<plan-stem>-advisory-context.md`
-beside the plan. `/caddis:implement`, `/caddis:handoff` and `/caddis:validate-phase` all check for it;
-**no file → no behaviour change, ever.** But nothing has ever *asked* whether to create it, so the
-pattern only ever gets used by someone who already knows it exists. This step closes that gap.
-
-**Ask it here** — at the end of planning is the only moment the phase count, risk levels and session
-boundaries are all known.
-
-> **You MUST call `Skill(advisory-hub)` and read *"When it earns its keep"* before deciding.**
-> Do not decide from memory, and do not decide from any summary — including one in this file.
-> The test is stated in exactly one place on purpose: two copies of a rule drift on the first edit,
-> and the copy that used to live here had already drifted. It compressed the REQUIRED leg to the
-> phrase *"expensive-to-reverse"* and dropped the enumeration that defines it — which reads as
-> *"can I `git revert` this?"*, and under that reading a plan that publishes € figures to business
-> stakeholders scores "no stakes". That is the one leg that fires on reporting, analytics and
-> dashboard work, i.e. most of what this fleet builds. Load the skill.
-
-If the test passes, tell the user plainly what it costs and what it buys, and offer to scaffold the
-context doc from the `advisory-hub` skill's template. **Do not create it silently** — an opt-in
-pattern that switches itself on is no longer opt-in.
-
-**In headless mode, never offer and never create.** Headless forbids asking anything, so an "offer"
-is impossible there. Instead record the result as a line under `## Constraints & decisions` —
-*"Advisory Hub: test passed (N phases, <criteria>) — not scaffolded, headless run; create
-`<plan-stem>-advisory-context.md` to enable"* — so the decision reaches a human rather than being
-silently dropped or silently taken.
-
-If it does not pass, say nothing **to the user** — a three-phase feature should never hear about
-this. But **always record the determination in the plan, pass or fail**: one line under
-`## Constraints & decisions`, naming which REQUIRED trigger was or was not hit.
-
-> `Advisory Hub: not applicable — no REQUIRED trigger (not a migration / security change /
-> production data correctness / numbers published to stakeholders).`
-
-### If the test FAILS but this repo already runs a Hub for another plan
-
-Check for an existing `*-advisory-context.md` in `.caddis/plans/` belonging to a **different** plan.
-If one exists, add a second line under `## Constraints & decisions`:
-
-> `Hub conventions: this repo runs Advisory Hub for <other-plan>. This plan does NOT — if it borrows
-> the phase-NN.prompt.md / .report.md / CONTINUE GATE conventions, the lightweight rule applies: the
-> session that files a report must not write the next prompt without an independent re-check.`
-
-**Why this line exists.** A repo with one Hub plan has its artefacts sitting there as the most recent
-example of "how we structure a multi-session plan here", and the next plan copies them by analogy.
-It inherits the file names and none of the safety, because the safety was never in the names.
-Measured once already: an implementing session filed its own batch report and then wrote the next
-batch's prompt in the same session, with nobody having looked in between. Nothing was wrong that
-time — and nothing checked either.
-
-This is the cheapest possible place to catch it: when the second plan is created, before any
-artefact-mimicry has happened. See *"Failing this test correctly does not mean no discipline"* in the
-`advisory-hub` skill for the rule itself. Do not restate the rule here — one home, or the copies
-drift.
-
-Silent to the human, auditable in the artifact. "Say nothing" once meant *leave no trace anywhere*,
-and a wrong negative was then invisible — no line in the plan, no line in the chat, nothing for
-anyone to challenge. A rule whose failures leave no artifact cannot be reviewed.
+A `risk: high` phase gets two independent review runs: run by the roadmap/plan runner automatically (from caddis-next Phase 11), and by hand in an interactive `/caddis:implement` run (`caddis_review.py --plan <plan> --phase <n> --runs 2`, from Phase 10). Only a `blocking` finding fails that review (exit 1); `should-fix` and `nit` findings go on a follow-up list and do not stop the merge. A phase gets 3 completed review rounds (a run that did not complete uses none); the 4th ends with exit 5, "stop, the owner decides". The advisory hub is retired; do not plan a separate validation session.
+
+## Programme triggers
+
+Small work that does not meet a trigger skips its block.
+
+**Trigger: Always.** Add one open-work row for the plan in `.caddis/open-work.md`. Set its cells with `python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_rows.py" set --file <open-work.md> --id <row id> --col Status=todo`, never with a regex edit.
+
+**Trigger: The plan records a decision.** Record it with `/caddis:decide`.
 
 ## Step 4 — Report
 Output the plan path (`.caddis/plans/<feature-slug>.md`), the phase list (one line each, with each

package/bundles/antigravity-plugin/skills/fleet-close/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: fleet-close
+description: Close a fleet of sessions — every session writes its handoff and acks, then print one restart sheet for the owner
+---
+
+# /caddis:fleet-close — close every session, collect acks, print the restart sheet
+
+Use this when **several** sessions must stop together (a machine restart, a long break, a context
+reset for the whole fleet). For one session, run `/caddis:handoff` instead. This session is the
+**coordinator**: it asks every other session to write its own handoff, collects one ack from each,
+writes its own handoff last, and prints a restart sheet. The owner starts each new session from that
+sheet, and each new session runs `/caddis:fleet-open <role>`.
+
+Every fleet rule (names, ack format, order, checks) lives in
+`${CLAUDE_PLUGIN_ROOT}/scripts/caddis_fleet.py`; this command only calls it. Run the steps in order.
+
+**Safety rules for the whole command** (a wrong close loses another session's relay or tasks):
+- Never write, edit or move another session's relay, tasks file or watcher files. Each session writes
+  its own; you only collect acks.
+- Never stop, end or kill another session, and never tell one to exit. The owner closes terminals
+  after reading the sheet.
+- Never wait with a foreground `sleep`. Every wait is a background timer (`run_in_background`).
+- A session that does not ack is never guessed: its row says `no ack`, and the owner runs
+  `/caddis:handoff` in it by hand.
+
+The ack format (one line in a fenced block, then the session's full resume prompt):
+
+```
+FLEET-ACK name=<n> role=<r> machine=<m> folder=<abs> relay=<path> tasks=<path|none> mode=<new|keeps-running|restore-on:<machine>|nothing> owns-watchers=<yes|no> worktrees=<abs;abs|none>
+```
+
+## Step 1 — list the fleet
+
+Run `ListAgents`. Your own name is in its header line (`This session is <name>`): you are the
+coordinator. Candidates:
+- every local interactive or background session, and every Remote Control session that is not
+  `offline`: each gets the close message in Step 3;
+- every cloud session: it is listed as `keeps-running` and gets **no** message (it keeps running in
+  the cloud). In Step 4 you save its ack yourself:
+  `FLEET-ACK name=<n> role=<role-of n> machine=cloud folder=- relay=- tasks=none mode=keeps-running owns-watchers=no worktrees=none`,
+  then the prompt line `Cloud session: keeps running; nothing to restore.`;
+- `offline` rows and your own row are not candidates.
+
+For each candidate, and for yourself, get the role:
+`python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_fleet.py" role-of <name>`. **Two sessions with the same role**
+would get one start line and one new name, and one of them would be lost. So when roles repeat, keep the
+role for the first name (sorted), and give each other one a distinct role `<role>-b`, `<role>-c`, ...; tell
+that session its role in Step 3 (rule 5).
+
+Print the candidate list (name, kind, machine, role) before you send anything. If there are no candidates,
+say so, run `/caddis:handoff` for this session only, and **stop**.
+
+## Step 2 — make the fleet dir
+
+The fleet dir is `.caddis/relay/fleet/<MMDD>-<HH>/` in this repo, at the coordinator's local time:
+
+```
+python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_fleet.py" new-name fleet
+```
+
+prints `fleet-<MMDD>-<HH>`; the dir name is the `<MMDD>-<HH>` part. Create it. It is local and
+gitignored (it holds machine paths). Use the same dir for every later step, even if the hour changes.
+
+## Step 3 — send the close message
+
+Send each candidate (from Step 1) one `SendMessage`. The first line must be exactly:
+
+```
+FLEET CLOSE from <coordinator>: write your handoff and ack.
+```
+
+Then these close rules, in the message:
+1. Run `/caddis:handoff` for **your own** relay only. Never touch another session's files. Skip its
+   Step 7 (the `Push this note for another machine?` question): the restart sheet carries your prompt,
+   and a question nobody answers would stop you before you ack.
+2. In a shared checkout (its `AGENTS.md` says `Shared checkout: yes`, or `git status` shows changes you
+   did not make), skip the steps the handoff checklist skips there.
+3. If you run watchers: copy each watcher script to `.caddis/relay/<your name>-files/watchers/`, and fill
+   the relay's `## Watchers` section (per watcher: script path, exact start command, stop condition,
+   the action after the stop).
+4. Your resume prompt must load your tasks file, greet peers with `<role> is now <your new name>`, and,
+   in a shared checkout, say: "read code facts from origin/main; a worktree needs its own fresh
+   dependencies".
+5. Reply to `<coordinator>` with this block (one line, every field filled), then your full resume prompt:
+   ```
+   FLEET-ACK name=<n> role=<r> machine=<m> folder=<abs> relay=<path> tasks=<path|none> mode=<new|keeps-running|restore-on:<machine>|nothing> owns-watchers=<yes|no> worktrees=<abs;abs|none>
+   ```
+   Use `name=<your current name>` exactly as `ListAgents` shows it, and `role=<role>` as given in this
+   message (a role that repeats in the fleet gets `<role>-b`, ...). `mode=new` if your work continues
+   in a new session; `mode=nothing` if it needs no new session (for example a finished read-only review).
+6. Remote sessions (another machine): also put your open task rows inline after the prompt, as a table
+   with exactly this header line (other headers are not read):
+   ```
+   | Old # | Status | Subject |
+   |---|---|---|
+   ```
+   and say whether your machine restarts (`mode=restore-on:<machine>`) or not (`mode=keeps-running`).
+7. Do not exit or stop after the ack; the owner closes sessions.
+
+## Step 4 — collect acks (first wait: 10 minutes)
+
+Start a background timer, never a foreground wait:
+
+```
+sleep 600
+```
+
+with `run_in_background`. Each ack arrives as a cross-session message. For each one:
+1. Write the message text (from the `FLEET-ACK` line to the end) to a temp file in your scratchpad.
+2. Save it:
+   ```
+   python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_fleet.py" ack add --dir <fleet dir> --text-file <temp file>
+   ```
+3. Exit 0 → acked. An error names the missing or bad field: send that session **one** reply that
+   quotes the error and asks for a corrected ack. Do not fix the ack yourself.
+4. The ack's `name=` must be the name of the candidate that sent it, and its `role=` the role you gave
+   it. If not, send **one** reply asking for a corrected ack (a wrong name makes a phantom row and marks
+   the real session `no ack`). A second ack from the same session replaces the first (`ack add` saves by
+   name).
+
+Also save the cloud-session acks from Step 1 here, the same way.
+
+## Step 5 — remind once (second wait: 20 minutes)
+
+When the 10-minute timer ends, send each silent candidate **one** reminder:
+`FLEET CLOSE reminder from <coordinator>: your ack is still missing.` Start a 20-minute background
+timer (`sleep 1200`, `run_in_background`) and keep saving acks as in Step 4. When it ends (or every
+candidate has acked), stop waiting. Each session still silent is a `no ack` row (Step 7).
+
+**A late ack is never dropped.** Until Step 8 ends, keep saving every ack that arrives, as in Step 4, and
+remove that session from the `--no-ack` list before the next `write`.
+
+## Step 6 — your own handoff and ack
+
+Run `/caddis:handoff` for this session (the coordinator's own relay). Then write your own ack (the
+`FLEET-ACK` block with your fields and your resume prompt) to a temp file and save it with
+`ack add`, as in Step 4. The coordinator's ack is never skipped. Then record this session's presence
+(your session id is printed at session start as `[caddis] this session's id: <id>`; never guess one):
+
+```
+python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_fleet.py" whoami --session-id <id> --name <your name> --root .
+```
+
+## Step 7 — write and check the sheet
+
+```
+python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_fleet.py" write --dir <fleet dir> --coordinator <your name> --no-ack <name> [--no-ack <name> ...]
+python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_fleet.py" check --dir <fleet dir>
+```
+
+Pass `--no-ack <name>` once for each silent session from Step 5, **on every `write`**, and leave it out
+when every session acked (a placeholder would become a fake row) (the no-ack rows are not
+saved between runs). `write` saves `roster.md` and `restart-sheet.md` in the fleet dir.
+
+- `check` exit 0 → go to Step 8.
+- `check` exit 1 → send each named session **one** message that quotes its error and asks for a
+  corrected ack. Start one 5-minute background timer (`sleep 300`, `run_in_background`) and save the
+  corrected acks that arrive. Then run `write` (same `--no-ack` flags) and `check` once more. Errors that
+  remain go at the end of `restart-sheet.md` under a heading `## Needs the owner:`, one line each,
+  quoted exactly.
+- `write` or `check` exit 3 (no acks, or a file it cannot read) → do not print a sheet. Report the exact
+  error, list every ack file in `<fleet dir>/acks/`, and **stop**: the owner decides.
+
+## Step 8 — final reply
+
+Reply with the whole text of `restart-sheet.md`, then its absolute path, and nothing else. The
+restart closes this session too, so the sheet must be on screen and on disk.

package/bundles/antigravity-plugin/skills/fleet-open/SKILL.md

@@ -0,0 +1,110 @@
+---
+name: fleet-open
+description: Restore one role from the fleet restart sheet in a new session — name check, relay, tasks, peer greeting, watchers
+---
+
+# /caddis:fleet-open — restore a role from the restart sheet
+
+A fleet close (`/caddis:fleet-close`) wrote a restart sheet: one row per role, with the folder to
+start `claude` in, a start line that names the new session, and the role's resume prompt. You are the new session
+for one of those rows. This command restores that role in one go.
+
+The argument is the role: `$ARGUMENTS`. If it is empty, list the roles of the newest sheet (Step 1)
+and ask which one — do not guess.
+
+Every fleet rule lives in `${CLAUDE_PLUGIN_ROOT}/scripts/caddis_fleet.py`; this command only calls it.
+Run each step in order. A step that says "stop" ends the command: print why, and nothing else.
+
+## Step 1 — find the newest restart sheet that holds the role
+
+```
+ls -d .caddis/relay/fleet/*/restart-sheet.md
+```
+
+The folders are named `<MMDD>-<HH>` (the coordinator's local time). Go from the newest folder to the
+oldest and take the first `restart-sheet.md` with a section `### <n>. <role>`. Read the
+`roster.md` beside it too: its row for the role gives the relay, the tasks file, the folder and the
+mode.
+
+- No sheet holds the role → say `No restart sheet holds <role>.` and **stop**.
+- The sheet row says `no new session` (mode `keeps-running`, `nothing` or `no ack`) → say so, quote
+  the row's section, and **stop**. A `no ack` row needs `/caddis:handoff` run by hand in the old
+  session first.
+
+## Step 2 — check this session's name before loading anything
+
+Run `ListAgents`. Its header line says `This session is <name>`; that is your name. The sheet row's
+Start line already names the session: `claude --name <expected> "/caddis:fleet-open <role>"`, where
+`<expected>` is `new_name` of the role at the sheet's hour.
+
+- `<name>` equals `<expected>` → go on.
+- Otherwise it must at least be a name of this role:
+  ```
+  python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_fleet.py" role-of <name>
+  ```
+  prints `<role>` (the name is `<role>-<MMDD>-<HH>`) → go on, and note the name differs from the sheet.
+- Anything else → tell the owner to run `/rename <expected>` and then `/caddis:fleet-open <role>`
+  again, and **stop**. A session cannot rename itself, and a role loaded under the wrong name is a
+  role its peers never reach.
+
+Nothing is read into this session (no relay, no tasks, no watcher) until this step passes.
+
+## Step 3 — read the relay and run its resume prompt
+
+Read the role's relay (the roster's Relay column, `.caddis/relay/<old name>.md`), then follow the
+resume prompt in the sheet section — the fenced block under `### <n>. <role>`. It is the same prompt
+the old session wrote; do what it says, in order.
+
+Load the open tasks: every row of the tasks file (roster Tasks file column,
+`.caddis/relay/<old name>.tasks.md`, table `| Old # | Status | Subject |`) becomes one `TaskCreate`
+with the Subject as its subject. A row with Status `in_progress` then gets
+`TaskUpdate` to `in_progress`. A remote role's rows are inline on the sheet under
+`Tasks (inline, remote session):` — load those the same way. Tasks file `none` → 0 tasks.
+Count the tasks you created; Step 6 reports it.
+
+## Step 4 — greet the live local peers
+
+From the `ListAgents` output of Step 2 (run it again if more than a few minutes passed), take each
+live local session whose role is in the roster (`caddis_fleet.py role-of <their name>`), other than
+your own role. When a role has several names, address the newest:
+
+```
+python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_fleet.py" newest <their role> --names-file <file with one name per line>
+```
+
+Send each one message, exactly: `<role> is now <name>` (your role, your name). Skip offline sessions
+and cloud sessions. Keep the list of names you greeted for Step 6.
+
+## Step 5 — restart the watchers
+
+Read the relay's `## Watchers` section. For each entry:
+
+1. Print the entry as written (script path, start command, stop condition, after-action).
+2. Check the script path exists (handoff copied it to `.caddis/relay/<old name>-files/watchers/`)
+   and that the stop condition and the after-action are both in the relay. If either is missing,
+   do not start it: report it as `watcher not started: <reason>` in Step 6.
+3. Start it with its exact start command through Bash with `run_in_background`. Never a foreground
+   `sleep` or loop.
+
+No `## Watchers` section → 0 watchers.
+
+## Step 6 — record the name and report
+
+Record this session's presence (your session id is printed at session start as
+`[caddis] this session's id: <id>`; never guess one):
+
+```
+python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_fleet.py" whoami --session-id <id> --name <name> --root .
+```
+
+Then print one line, and any `watcher not started:` lines under it:
+
+```
+[FLEET-OPEN] <role> restored: <n> tasks, <k> watchers, peers greeted: <names>
+```
+
+## Rules
+
+- One role per session. To restore another role, start another session from the sheet.
+- Never `claude --resume` the old session: the sheet exists so every role starts fresh.
+- Never edit the restart sheet or the roster; they are the record of the close.

package/bundles/antigravity-plugin/skills/gh-cli/SKILL.md

@@ -167,7 +167,8 @@ gh alias set review 'pr list --search "review-requested:@me"'
 
 ```bash
 gh issue develop 42 --branch fix/issue-42
-git add . && git commit -m "fix: resolve login bug" && git push -u origin HEAD
+git add src/auth/login.py tests/test_login.py   # named files only, never `git add .`
+git commit -m "fix: resolve login bug" && 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