/objective-loop

name: objective-loop
description: "Loop /do cycles until done-criteria verify or budget stops."
user-invocable: false
allowed-tools:
  - Read
  - Write
  - Edit
  - Bash
  - Glob
  - Grep
  - Skill
  - Task
routing:
  not_for: "one-off tasks that finish in a single dispatch, the harness '/loop 5m /cmd' command, installing system cron jobs (headless-cron-creator), implementing retry/backoff code inside a program (condition-based-waiting), single-condition waits (Monitor tool)"
  triggers:
    - "keep working until"
    - "keep going until"
    - "iterate until done"
    - "loop on this until"
    - "until the tests pass"
    - "until CI is green"
    - "until all PRs are merged"
    - "drive this to done"
    - "objective with done criteria"
    - "work this until verified"
    - "reschedule yourself until"
  complexity: Complex
  category: meta
  pairs_with:
    - verification-before-completion
    - condition-based-waiting
    - feature-lifecycle

Objective Loop

The toolkit's iterate-until-verified-done loop. A user states an objective with verifiable done-criteria; each iteration routes one /do cycle, verifies the criteria by executing them, and reschedules itself via `ScheduleWakeup` until verified-done or budget-stop. This skill is a planner/verifier wrapped around the /do router — it executes no work inline. Objectives over tasks: describe what done looks like and how to verify it; the loop finds the path.

Phase 1: SPEC

Gather the objective spec from the request. Interview only for missing fields.

| Field | Required | Default | |---|---|---| | Objective statement | yes | — | | DONE-CRITERIA | yes | — | | Iteration budget | no | 5 | | Token-budget note | no | `orchestration.token_budget` from `.claude/settings.json` (500000 when absent) | | NOT-DONE-YET guardrails | no | empty |

**DONE-CRITERIA are verifiable checks.** Each criterion has a `type`: `command` (default, preferred) or `rubric`.

• `command` — a deterministic command with an expected exit code/output: `pytest -q` exits 0; `gh pr view N --json state -q .state` prints `MERGED`; `validate-doc-counts.py` reports zero drifts. A criterion the model reasons about is not a criterion; each needs a command plus an expected observable.
• `rubric` — allowed only where no mechanical check exists, per the PHILOSOPHY.md verification ranking (exit code > fresh-context grader > self-critique). Store the rubric verbatim in the state file at SPEC time: pass conditions plus the evidence the grader must cite. Frozen once the loop starts — changes require the user, same as a guardrail.

**NOT-DONE-YET guardrails** name what may never be done to satisfy a criterion (e.g. "never weaken a gate to make it pass"). They bind every iteration: inject them verbatim into each /do dispatch.

Gate: spec complete. Proceed to Phase 2.

Phase 2: STATE

Write `.objective/<slug>/state.md` from the template in `references/state-file.md`: objective, criteria table, guardrails, per-iteration log, next planned step.

• Wakeups resume FROM THE STATE FILE, never from conversation memory — the wakeup prompt carries only a pointer.
• `.objective/` mirrors `.feature/`'s ephemerality but stays separate: `.feature/` is feature-lifecycle's phase machine, managed only by `feature-state.py`, and its presence reroutes /do into feature phases. Objectives are arbitrary goals.
• State is session working memory — keep `.objective/` unstaged; stage repo files by name only.

Gate: state file written. Proceed to Phase 3.

Phase 3: ITERATE — one /do cycle

Plan the smallest next step toward the unmet criteria, then route it through the /do phases: classify → route → dispatch agents → evaluate. The loop dispatches work exclusively through /do — catching yourself editing or analyzing inline means stop and route. Multi-part objectives may dispatch parallel agents per /do's rules.

**Learning capture is automatic.** Every iteration dispatches through /do, so routing rows and outcomes record via the /do learning hooks. Add no manual capture.

Gate: dispatch evaluated, iteration log updated in the state file. Proceed to Phase 4.

Phase 4: VERIFY (execution, not reasoning)

Run every done-criterion check. A worker's "criterion passes" claim never substitutes for the re-run.

• `command` — run the command; paste the exit code and the decisive output line into the iteration log.
• `rubric` — dispatch a fresh-context sub-agent that did NOT produce the work. Input is the artifact plus the rubric, nothing else — no iteration history. It returns PASS/FAIL plus cited evidence (file:line or output excerpt), pasted into the iteration log exactly like an exit code.

Then:

• All criteria pass → write the final report (per-criterion evidence), STOP. The loop ends by not calling `ScheduleWakeup`.
• Any criterion unmet → Phase 5.

**Criteria-gaming guard (hard rule).** A criterion may never be satisfied by weakening a hook, gate, test, or safety control — and a rubric is never weakened to pass. When the only visible path to "pass" weakens a control or the rubric text, stop the loop and report the conflict to the user.

Phase 5: RESCHEDULE or STOP

| State | Action | |---|---| | All criteria pass | Final report; stop — no wakeup call | | Unmet + iterations remain | Update state file (log, next planned step); call `ScheduleWakeup {delaySeconds, reason, prompt}` with `prompt` = "Read `.objective/<slug>/state.md`, then resume the objective-loop skill from that state file." | | Budget exhausted | Honest NOT-DONE report: per-criterion status with last evidence, remaining gaps, suggested next step; stop — no wakeup call |

**Delay table (prompt-cache aware; `ScheduleWakeup` clamps 60–3600s):**

| Wait type | Delay | Cache economics | |---|---|---| | Active polling (CI run, PR merge expected soon) | 270s or less | Keeps the Anthropic prompt cache warm (5-min TTL) | | Idle / long agent work | 1200s+ | Pays one cache miss; right for long gaps | | ~300s band | skip it | Worst case —