/loopify

name: loopify
description: When you want to set up an agent loop, cron-scheduled task, or recurring workflow that runs autonomously. Judgment layer on top of Claude Code's ScheduleWakeup, CronCreate, and /loop — or, on other hosts, cron/GitHub Actions plus a headless agent CLI. Picks dynamic pacing, fixed cron, or a one-shot loop; designs idempotent loop bodies; sets bail-out conditions so loops don't run forever. Examples — weekly review pulse, daily brief, hourly metric monitor, periodic vault compile, upstream-check for an adapted skill. Triggers on "/loopify," "set up a loop," "schedule this task," "run this daily," "run this weekly," "cron this," "make this recurring," "automate this on a schedule," "keep this running until X." Part of the -ify trifecta (skillify / toolify / loopify). NOT for authoring a new skill — that's skillify. NOT for adding a tool/integration — that's toolify.
metadata:
  version: 0.2.0

/loopify — Set up an agent loop

Wizard for going from *"this task should run periodically"* to a working loop with the right pacing, idempotency, and bail-out. Reference (Claude Code): `ScheduleWakeup` (dynamic pacing), `CronCreate` (fixed schedule), and the built-in `/loop` (dynamic self-paced re-entry). Other hosts: see "On hosts other than Claude Code" in Step 4.

Step 0 — Confirm what you're looping

Ask if not obvious from context: *"What task should this loop do each iteration?"*

Then get the essentials:

| Question | Why it matters | |---|---| | **How often?** | Determines cron vs dynamic vs one-shot | | **When to stop?** | Bail-out condition — loops must have one | | **What's the loop body doing?** | Determines idempotency requirements | | **Where does output go?** | File / notification / commit / nothing | | **What's the failure mode if it runs twice?** | Idempotency validation |

Step 1 — Pick the pattern

Three primary patterns. Route by the answer to "how often":

Pattern A — Cron (fixed schedule)

**Use when**: task runs at predictable intervals — daily at 8am, weekly on Fridays, hourly on the hour.

Tool: `CronCreate` — schedules a recurring task with a cron expression.

CronCreate({
  schedule: "0 8 * * *",           // daily at 8am local
  prompt: "<loop body prompt>",
  timezone: "America/Los_Angeles"
})

Common cron patterns:

• `0 8 * * *` — daily at 8am
• `0 9 * * 1` — Mondays at 9am
• `0 9 * * 5` — Fridays at 9am
• `0 */2 * * *` — every 2 hours
• `*/15 * * * *` — every 15 minutes

**Trade-offs:**

• ✅ Predictable, human-readable, easy to reason about
• ✅ Best for time-of-day-dependent tasks (morning brief, EOD summary)
• ❌ Runs at the scheduled time even if the last run isn't done — need idempotent body
• ❌ No self-pacing — over-schedules if the task duration varies wildly

Pattern B — Dynamic pacing (self-scheduled)

**Use when**: task should react to state, not the clock. Monitor-until-condition-met patterns. Waiting on an external event.

Tool: `ScheduleWakeup` — the current run schedules its own next wake-up.

ScheduleWakeup({
  delaySeconds: 270,               // stay in cache window (< 5min)
  reason: "checking build status; sleeping under 5min to stay cache-warm",
  prompt: "<same task, re-entered>"
})

**Critical delay rules** (from `ScheduleWakeup` docs — internalized in the wizard):

| Delay range | Use for | Cache impact | |---|---|---| | **60s–270s** | Active work — polling build, waiting for state that's about to change | Stays in 5-min prompt cache — fast + cheap | | **300s** ❌ | **DON'T USE THIS** | Worst of both worlds — pay cache miss without amortizing | | **300s–3600s** | Waiting on something that takes minutes to change | Pay cache miss but justified | | **1200s–1800s** (20–30 min) | Idle ticks with no specific signal | Default for autonomous loops |

Never pick 300s literally — either drop to 270 (cache stays warm) or commit to 1200+ (cache miss buys longer wait).

**Trade-offs:**

• ✅ Adaptive — sleeps longer when idle, shorter when active
• ✅ Cache-optimal when tuned right
• ❌ Requires the loop body to know when to schedule next (extra logic)
• ❌ Harder to reason about when it'll run

Pattern C — One-shot loop (until-condition)

**Use when**: task runs until a condition is met, then stops. No recurrence after that.

Tool: `/loop` (built-in) with an exit condition in the prompt itself.

/loop
Check if the deploy is healthy. If yes → stop. If no → wait 5 min and check again.
Max 10 iterations. If still failing after 10, alert and stop.

**Trade-offs:**

• ✅ Simplest for check-until-condition
• ✅ Bounded — always eventually terminates
• ❌ Not for indefinite recurrence — that's Pattern A or B

Step 2 — Design the loop body for idempotency

Idempotent = running the loop twice produces the same result as running it once. **Non-negotiable for cron and dynamic patterns** because they'll fire while the previous iteration is still running or partially complete.

Idempotency patterns:

• **Use "already done" markers**: e.g., commit a state file `<vault>/.loopify/<name>-last-run.txt` with the timestamp of last successful run. Loop body checks the timestamp before doing work.
• **Use dedupe keys**: if the loop writes to a DB or file, key by content-hash or timestamp so re-runs are no-ops.
• **Use transactions**: DB writes in the loop body should be atomic — either all commit or all roll back.
• **Query before mutate**: check current state before applying the change. If already applied, skip.

Show the user the loop body draft, highlighting the idempotency check. If none exists, add one.

Step 3 — Bail-out condition

Every loop needs one. Options:

| Bail-out | When to use | |---|---| | **Max iterations** (e.g., stop after 100 runs) | Cron loops — prevents runaway | | **State-based** (e.g., stop when metric X drops below Y) | Monitoring loops | | **Time-based** (e.g., stop after 24 hours) | Bounded monitoring | | **Error-based** (e.g., stop on 3 consecutive failures) | All loops — catches de