Planning & Specification Workflows

Implement a whole DAG plan autonomously — one approved pass, one clean rollback point per task, never building on a broken base. It requires an approved plan (specced upstream) and a clean git baseline, takes a SINGLE human approval of the plan, then walks the DAG layer by layer: for each task it implements on an isolated worktree branch test-first (RED → GREEN), integrates the slice onto the working branch, reviews the integrated change, runs a bounded fix loop until the task passes, and commits it individually — so any point is a clean rollback. It follows the dependency graph strictly (a task builds only once its deps integrate), checkpoints every task so it resumes exactly where it stopped, and STOPS-and-asks on unfixable failures, ambiguity, or irreversible steps rather than pushing through. This is the BUILD phase. Composes fan-out-work (per layer), converge-loop (per-task fix), adversarial-verify (per-task review), checkpoint-resume, and budget-guard.

Close every autonomous run with a learning pass so the machine never repeats a mistake it already paid for: harvest the run's STRUCTURED artifacts (checkpoint register, blocked-task reasons, guard blocks, fix-loop counts, degradations), verify each candidate lesson adversarially, dedupe against what is already known, then WRITE each learning to the Claude Code memory that LOADS AUTOMATICALLY next session — a convention or plan-shape rule into CLAUDE.md, an area-specific lesson into a path-scoped .claude/rules file, an environment quirk into auto memory. Machine defects are surfaced to the user, never self-patched. Because those are native context files Claude Code already loads, the next run picks the lessons up with no extra step. Use as the closing phase of every run, or standalone.

Generate and refresh the project's CONTEXT ARCHITECTURE — a disclosure-tiered map so the agent starts every session knowing the repo without paying for what it doesn't need. Platform-aware by explicit contract (claude|codex|dual): for Claude a lean root CLAUDE.md (loads always), path-scoped .claude/rules/.md (load only when touching matching files), nested CLAUDE.md throughout the tree (loaded on demand — zero cost until then); for Codex the root + nested AGENTS.md tree instead — never inventing a memory location the platform lacks, never touching private agent memory. Deep references are LINKED, never imported. Every claim is VERIFIED against the real repo before it ships (commands actually run; paths actually exist) — the map cannot lie. Use to initialize project context, refresh it after meaningful changes, or as the pipeline's final phase so the map reflects what just shipped.

Make code measurably faster without breaking it: metric + reproducible baseline FIRST, profile to the real hotspots, then per hotspot apply a change and re-benchmark — kept ONLY if the win is real beyond variance AND correctness holds; otherwise reverted. Stops at the target or diminishing returns. Never accepts an unmeasured "should be faster".

Take verified work to shippable — autonomously, with fail-closed gates and a human sign-off on anything irreversible. It runs the pre-launch gate (final validate green, review clean, security/observability/ rollback checks), and a gate that DIDN'T actually run is treated as a blocker, never as clean. Then it prepares the release: atomic commits, a changelog/release notes grounded in the actual changes, version bump, docs for user-visible/API changes — and opens the PR (or stages the rollout: feature flag + rollback path + monitoring). The deploy itself is gated on explicit human approval. It fails closed and never fabricates a green gate to ship. This is the SHIP phase. Composes adversarial-verify (confirm the "ready" claim), checkpoint-resume, and budget-guard.

Reduce a change's complexity WITHOUT changing behavior, provably: find duplication/dead code/over-abstraction in the diff, apply the smallest clarifying edit, then prove behavior preserved (tests green + adversarial semantic check) or REVERT — looping until dry. Respects Chesterton's Fence: never removes code whose purpose isn't established. Use when code works but reads worse than it should.

Turn a raw feature request into a grounded, TESTABLE spec — autonomously. It recons the real repo and domain to ground every claim, drafts a spec (objectives, user-visible behavior, acceptance criteria, explicit non-goals, constraints, interfaces, risks), then runs a completeness-critic loop that adversarially hunts for gaps, ambiguity, and untestable criteria and fixes them until the spec is stable. Every acceptance criterion it emits is measurable (you could write a test for it); every requirement is grounded in the repo or flagged as an assumption — no invented requirements, no phantom paths. It writes .ulpi/spec/ .md and is the DEFINE phase that feeds auto-plan. Composes fan-out-work (recon), adversarial-verify (the critic), converge-loop (until-stable), and checkpoint-resume.

Run the whole engineering lifecycle end-to-end from one request — spec → plan → build → simplify → test → review → performance → ship — as a single autonomous pass with ONE human approval (the plan) and hard-gated escalation for anything irreversible. It chains the auto- phase skills, carries a durable pipeline checkpoint so a stop/crash resumes at the exact phase and task it left off, watches the signal between phases (a phase that misses its gate is recorded blocked and surfaces in the register — fail closed, no false-green downstream), and returns a verified findings register at the end. It does NOT loop on its own: after one pass it reports what shipped and what's open, and the user decides on any fix round. This is the top-level "maximise autonomous agents" entry point. Composes every auto- phase plus checkpoint-resume, budget-guard, watch-and-act, and adversarial-verify.

The discipline that keeps an autonomous run from becoming a runaway: before any unattended loop or workflow, declare the five stop conditions — done-condition, hard cap, token/time budget, no-progress rule, escalation triggers — then hold the run to them and stop the instant one fires. Fails closed: a capped run reports an honest partial, never fabricated success. Load at the start of ANY unattended run.

Run a bounded, self-correcting loop that drives code toward a target state and STOPS honestly — until-green (validate → diagnose → minimal fix → re-run) or until-dry (find → act → re-find until N dry rounds). Every loop declares a termination set (done-condition, max iterations, budget, no-progress stop) and compiles onto native /goal + /loop. Use for any "repeat until a measurable condition holds" work instead of hand-rolling a keep-going loop.

Cover a large work-list in parallel without losing correctness or honesty — scout the items inline, then run each through its stages concurrently (map, optionally reduce) via the Workflow tool, with concurrency caps, per-item isolation where items mutate files, and an explicit account of anything dropped. Use when the task is "do the same thing to N independent things" — audit every module, migrate every call site, write tests for every gap, review every changed file — and N is big enough that serial is wasteful. It keeps the coordinator in control of the decision to continue while the per-item work runs in agents; it never silently truncates (a top-N/sampling cap is logged), and it aggregates results faithfully (a failed item becomes a reported null, not a hidden success). Composes with converge-loop (per-item loops) and adversarial-verify (gate each item's result).

Stand up a recurring scheduled agent for standing work (triage, monitoring, audits, digests): a self-contained IDEMPOTENT brief (each run wakes memory-less and must dedup prior work), a cadence matched to how often work actually arrives, a per-run BOUND, escalation rules, and a teardown condition. For durable unattended work that runs while you're offline, use claude.ai Routines (the /schedule skill / RemoteTrigger); an in-session CronCreate is the lighter, session-scoped alternative. Use for scheduled repeat work — not one-off waits (watch-and-act).

Wait on an EXTERNAL signal the harness can't notify you about — CI, a deploy, a queue, an endpoint — polling on a cache-aware cadence (≤270s active, ≥1200s idle, never ~300s), bounded by a deadline, acting on the transition. Prefers a NATIVE wait/monitor capability when present; when polling must cross a turn it persists a durable, atomic, resumable watch state (scripts/watch-state.mjs) so the ORIGINAL bound survives a fresh process and a missing wake capability degrades to a resumable PENDING report instead of blocking. Never polls harness-tracked background work (that re-invokes you automatically). Use to bridge a run to something happening elsewhere.