docs(skills): loop-ops — prescribe the right scheduling recipe per situation

The native mechanisms aren't interchangeable; loop-ops now selects, not just lists.
Adds a recipe selector to claude-code-loops.md keyed to the real trade-offs:

- Connector-driven, no local code (email/Asana/Slack) -> cloud routine: it keeps your
  claude.ai connectors and runs with the machine off; the fresh-clone limit doesn't bite.
- Touches local code -> Desktop scheduled task or a background daemon.
- Sustained / token-sensitive -> a deterministic daemon firing `claude -p` every ~270s
  (fresh context per tick + stays under the 5-min prompt-cache TTL so the prefix reads at
  ~0.1x) rather than /loop, which grows one session and chews tokens.
- Supervised light polling -> /loop.
- Long task, fixed verifiable criteria -> /goal (+ auto mode).
- Cadence x completion compose: a cadence driving `claude -p "/goal <condition>"`.

Plus the economics (why a daemon beats /loop at scale) and a minimal while-sleep daemon.
SKILL.md workflow now points at the selector with the one-line heuristics.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

skills/loop-ops/SKILL.md

@@ -277,12 +277,13 @@ python scripts/check-pricing-sync.py --offline   # exit 0 in sync, 10 drift, 3 a
 6. **Doctor it:** `bash scripts/loop-doctor.sh --live .loops/<n>/loop.config.yaml` — prove
    it will actually *run* (gate binary on PATH, budget fits a tick). Audit = well-formed;
    doctor = will-run.
-7. **Schedule** the L1 run, native-first (read-only — it just writes `STATE.md` + a
-   report): `/loop` while you watch, a **Desktop scheduled task** for unattended *local*
-   loops, or a `/schedule` cloud routine for cloud-only work (no local files — see
-   [references/claude-code-loops.md](references/claude-code-loops.md)). Use `loop-run.sh` +
-   cron/Task Scheduler only if you want non-Claude-Code control. Bound a "work-until-done"
-   tick with `/goal`.
+7. **Schedule** the L1 run — but pick the mechanism deliberately; the **recipe selector**
+   in [references/claude-code-loops.md](references/claude-code-loops.md) prescribes it per
+   situation, because they're not interchangeable: connector-driven (email/Asana, no local
+   code) → **cloud routine**; touches local code → **Desktop scheduled task**; sustained &
+   token-sensitive → a **cache-warm daemon** (`claude -p` every ~270 s), *not* `/loop`
+   (which grows a session and chews tokens); fixed-criteria long task → **`/goal`**; quick
+   supervised polling → `/loop`. (L1 is read-only — it just writes `STATE.md` + a report.)
 8. **Read the reports.** Only after the loop's judgment is proven do you graduate it to
    **L2** (worktree + guard + `fleet-ops` landing) and re-audit at the higher tier.
 

skills/loop-ops/references/claude-code-loops.md

@@ -53,6 +53,45 @@ spine. No cron, no Task Scheduler, no Actions.
 
 ---
 
+## Which mechanism? — the recipe selector
+
+These mechanisms are **not interchangeable** — each has a load-bearing trade-off. Pick by
+answering: does it need **local code**, is it **connector-driven**, is it **recurring** or
+**run-to-completion**, and **does token cost matter**?
+
+| Your situation | Prescribed recipe | The trade-off that decides it |
+|---|---|---|
+| **Connector work, no local code** — triage email, Asana, Slack, calendar, issues via your claude.ai connectors | **Cloud routine** (`/schedule`) | Runs unattended in the cloud and **keeps all your claude.ai connectors** — email/Asana/tools work with your machine *off*. The fresh-clone/no-local-files limit doesn't bite because the work isn't in your repo. (≥1-hour cadence.) |
+| **Touches local code / build / tools**, unattended | **Desktop scheduled task**, or a **background daemon** running `claude -p` | Both have local files and need no open session. The daemon adds fresh context per tick + deterministic, tunable cost (next row). |
+| **Sustained / heavy cadence where tokens matter** | a **deterministic daemon** (or cron) firing `claude -p` — **not** `/loop` | `/loop` runs in one *growing* session: context accumulates, tokens climb, quality drifts past ~150k. A daemon fires a **fresh** `claude -p` each tick — bounded cost, no drift — and is deterministic. **Wake it just under the 5-min prompt-cache TTL (~240–270 s)** so the static `run.md`+system prefix stays cache-warm and each tick reads it at ~0.1×. Fresh context *and* cache reads — the cheap sustained-loop recipe. |
+| **Supervised, light, you're watching** | **`/loop`** | Quickest to start, in-session — perfect for a short burst ("watch this deploy"). But it's **token-hungry if left running heavy**; graduate to a daemon for anything sustained. |
+| **Long task with a fixed, verifiable end state** — "migrate until tests pass", "split until each file < N lines", "drain the labeled backlog" | **`/goal`** (+ auto mode) | Runs turn-after-turn until a fast model confirms the criteria, then stops — a *completion gate*, not a cadence. Auto mode makes each turn unattended; bound with `or stop after N turns`. |
+
+**Cadence × completion compose.** A recurring loop whose every tick should run *to
+completion* = a cadence mechanism driving `claude -p "/goal <tick condition>"`. E.g. a
+Desktop task (or daemon) every morning running `/goal` over the issue backlog.
+
+### The economics (why the daemon beats `/loop` at scale)
+
+Cadence is the top cost lever, **caching is the next** ([state-spine.md](state-spine.md),
+[loop-cost](../scripts/loop-cost.py)). The two interact:
+
+- **`/loop`** keeps one session alive; its input grows every iteration (accumulating
+  transcript), so cost climbs and the cache helps less. Great for short supervised runs.
+- **A daemon/cron `claude -p`** starts fresh each tick (the Ralph property → flat per-tick
+  cost) and, fired **under the 5-min cache TTL**, keeps the static prefix warm (~0.1× reads).
+  `loop-cost --cadence 5m` will show this; a 6 h loop can't cache at all.
+
+A minimal local daemon (no scheduler infra) — wake under the cache window, fresh context each tick:
+
+```bash
+# fires loop-run.sh every ~4.5 min: fresh `claude -p`, prefix stays cache-warm
+while true; do .loops/<name>/loop-run.sh; sleep 270; done
+# or run it under process-compose / a systemd timer / nohup for boot persistence
+```
+
+---
+
 ## The external-scheduler shape (when you're not using a native mechanism)
 
 Native paths (Desktop task, cloud routine, `/loop`) run the tick prompt — or