auto

|

What it does

|Pre-scan

Workflow-agnostic pulsed loop engine with natural-language commands — runs the auto loop pattern (plan-loop, parallel fan-out, review-fix until only P3 issues remain) as a durable, observable state machine backed by a per-unit ledger. v0.4.0 lands bare-/auto smart entry (hypothesis envelope + one action line, no verdict-tree prose), multi-plan fanout (one worktree + one cmux workspace per plan, port-allocated and crash-safe), default seam-flip (proceeds past plan→work unless --review-plan), slimmed driver skill (theory moved to docs/contracts/driver-reference.md), and project-as-workspace (cmux workspace IS the project — left pane = agent-session tabs, right pane = operator territory; fanouts land as tabs in the project workspace automatically when one is present). Outcomes-gated emission via recipe iteration blocks (A2 Parallel Theories+Judge, A4 Adversarial Pair+Comparator), engine-bounded by max_attempts + active-wall-time. Operator kill-switch (CLAUDE_AUTO_DISABLE_ITERATION). v0.4.1 silences blocked-on-human loop spam (a re-fired Stop now allows silently) and adds a `/auto-resume pause` verb for walls only a human can clear, plus the auto-author-goal skill — turn a plan into a model-judgeable goal doc you bind by hand with `/goal <doc.md>`. v0.4.2 hardens that skill against never-met goal loops: criteria must be agent-completable, human-gated/manual-QA steps go out-of-scope, and a goal that is only a manual test is refused (it can't be a `/goal`). v0.6.0 lands conversation-driven smart entry: /auto runs straight from a live conversation - it reads the current session (plus a light ~2-day lookback), recommends the right next step (vague -> brainstorm, clear -> plan, reviewed plan -> build, bug -> debug), and runs it inside the review/verify/fix-until-only-P3 loop with an auto-authored goal, then auto-advances through later phases via a multi-phase spine. An advisor gate absorbs routine mid-run judgment calls (consult a stronger reviewer instead of stopping to ask); a destructive-action backstop blocks irreversible commands (force-push, rm -rf, release deletes) and pauses the run with a loud operator signal, distinguishing a backstop pause (keeps gating, no self-disarm) from an operator pause (allows the operator's own cleanup). The upstream-rebound backward edge ships as detect-and-escalate scaffolding only; the producer and full rebound subsystem are deferred to v0.7.0. Workflow-blind: drives Compound Engineering, native Claude, or any workflow through a thin adapter. v0.6.1 is a behavior-preserving internal cleanup (shared ledger-scan helpers, decomposed recipe validation, dead-code removal) with +13 regression tests. v0.6.2 unsticks the self-pacing loop: it ships the missing `/auto-tick` command the loop re-arms into (every re-arm previously hit "Unknown command" and the tick never fired), the plan-loop feedback CLI (`ledger.sh set-gaps-open` / `set-enumerated-units`, the surface the model uses to report results back through Bash), and a producer handshake so plan-done waits for the enumerate step instead of flipping to a work phase with zero units. v0.6.3 reshapes the work-only `w` recipe so a reviewed plan goes straight to work: `w` now starts its plan phase already-satisfied (plan_presatisfied) and enumerates the reviewed plan into work units instead of re-running the plan-loop on finished work, and bare /auto on a reviewed plan routes here. Adds a `/auto-resume advance` verb — declare the current phase satisfied and move on (plan → enumerate straight to work; seam → continue) — the general "the plan is done, stop re-deriving it" tool. v0.6.4 fixes the advisor-gate destructive-action backstop, which was DARK on every run since v0.6.0: it keyed on CLAUDE_CODE_CHILD_SESSION (assumed to mean "spawned sub-agent"), but the harness sets that in every Bash-tool subprocess — where auto's CLIs always run — so the guard fired unconditionally and recorded a null owner the backstop could never match (and /auto-resume continue/advance always refused to re-arm). Now it trusts CLAUDE_CODE_SESSION_ID directly (which equals the PreToolUse hook's stdin session_id). v0.6.5 fixes self-pacing + fanout, which never worked: a plugin slash command fired programmatically (a ScheduleWakeup/loop re-injection OR a `claude '/cmd'` startup-arg) only resolves in its namespaced `/<plugin>:<command>` form — the bare `/auto-tick`, `/auto`, `/auto-resume` were all "Unknown command" (empirically confirmed: `claude -p '/auto-status'` → Unknown, `/auto:auto-status` → runs). Namespaced every programmatic emission across the rearm/wakeup path AND the fanout/orphan-resume startup-args, with a regression guard. v0.6.6 addresses code-review follow-ups: an ownership-steal guard so a second session's `/auto-resume continue`/`advance` can't silently dark a LIVE run's destructive-action backstop by stealing ownership (legitimate paused/orphaned handoff still works), a structured error instead of a raw traceback if the driving-session write hits a torn ledger, and doc/test cleanups. 858 tests green. v0.6.7 documents the resume/tick stdout contract: every tick AND every /auto-resume re-arm writes exactly one JSON object to stdout (parse it whole — prose rides as fields or on stderr, never loose stdout lines), and the plan-enumerate-pending producer handshake is a tick instruction (stash units via set-enumerated-units → re-arm → the next tick flips plan→work), not ceremony to skip past. Adds a regression test asserting one-JSON-object stdout AND clean stderr on both resume success paths. Docs + test only, no logic change. v0.6.8 fixes two /auto drive-friction walls hit driving a real feature build: the destructive-action backstop is now PATH-SCOPED — benign `rm -rf` of an ephemeral temp dir ($TMPDIR / /tmp / /private/tmp / /var/folders) no longer false-pauses and latches the run, while staying fail-closed for repo/$HOME/root/glob/command-substitution/unset-$TMPDIR (exemption is conservative about shell expansion: it resolves $TMPDIR from the hook env rather than trusting the literal token); and `record-verdict` + `set-verdict-decision` are now `ledger.sh` CLI verbs so the work-loop is drivable without the Python API. 920 tests green. v0.7.0 absorbs looper's loop-DESIGN layer in-tree (MIT-vendored, no runtime dependency): typed-verification gates - each gate criterion is programmatic (a command that passes/fails), model_judge, advisor_judge (satisfied by the driving session consulting the in-house advisor tool - auto's cross-model judge, replacing looper's external council), or human - folded into the gate's advance/iterate/exit signal WITHOUT becoming a second exit judge (the deterministic blockers==0 && majors==0 predicate stays the single source of 'done'). New auto-design coaching skill turns intent into a sharp goal + typed verification + control rubrics and compiles to a validated recipe via auto-author-recipe/auto-author-goal (no hand-written JSON). Hardening made the criteria actually reach the runtime (preserved through ledger normalization). 923 tests green. v0.8.0 fixes /auto's deterministic entry-routing priors so they match real usage. A new plan-freshness ranker (git opinion wins - uncommitted or recent-commit is fresh, older is stale - with an mtime fallback where git is silent) and a verb classifier ({work|plan|both|ambiguous} over freeform args, article/possessive-aware so "execute the plan" reads as work but "plan a feature" reads as plan-creation, and 's contractions like "let's ship" aren't mistaken for possessives) let bare /auto route an imperative about EXISTING work straight to WORK instead of re-planning it (the 2026-06 field misroute that bit twice), route multi-plan fanout on the count of FRESH plans (all-stale no longer offers a fanout), and let a fresh in-session plan preempt stale on-disk plans - closing the dead CLAUDE_AUTO_CONVERSATION_SIGNAL gap (declared and checked but never set in production). Detection stays deterministic (code) and classification stays the model's job; the detector remains read-only, degrade-safe, exit-0, and nine-key-envelope on every path. 1045 tests green. v0.9.0 reshapes interactive /auto into an agent-first launch chooser: a loop-design agent (skills/auto-launch) recommends a fitting shape (a1/a2/a4/w) or composes a custom loop, proposes typed verification gates, and drives a deterministic skip/confirm/two-step ladder before dispatch - skipping the prompt only when both shape AND gates are obviously settled (a router cross-check gates the skip; skip is bounded to a1/w). Adds one-renderer contrast cards (topology-render --compare), a deterministic headless-vs-interactive seam that keeps self-driven runs out of AskUserQuestion by construction, and atomic run-scoped recipe teardown. Composes with the v0.8.0 entry-routing on the shared freeform/reviewed-plan surface. 1149 tests green. v0.10.0 is the thermo-nuclear codebase-health refactor: 6 latent-bug fixes, a duplication cluster canonicalized into shared _bootstrap/facade helpers, four oversized-file splits (auto-detect.sh -> .py + shim, ledger_core.py -> ledger_predicate.py, recipes.py -> recipe_validate.py, tick.py re-cut), and #6 - the dependency engine is now wired through so emitter-materialized work units carry validated depends_on edges the readiness engine enforces (dangling/self/cyclic/malformed edges degrade cleanly, never a silent stall). Behavior-preserving except the terminal-phase guard and the dep-engine wiring, both deliberate-fail tested. 1217 tests green. v0.11.0 makes /auto's plan routing goal-aware: the driver recovers the operative goal for the current invocation (typed /auto intent or a current-session /goal text; else a session inference) and weights the discovered plans against it via a documented relevance rubric, so an EXPLICIT goal suppresses the N-way worktree fanout and preselects the matching plan (confirm-gated, interactive runs only) instead of blindly fanning out over docs/plans/ clutter; an INFERRED goal only re-ranks and keeps the fanout offered, and no goal / no match falls through to the existing freshness behavior unchanged. The deterministic detector stays goal-blind and byte-unchanged; the routing decision and its guardrails live in a pure, truth-tested lib/goal-route.py that refuses to suppress the fanout unless the goal is explicit AND the run is interactive, so a self-driven run or an inferred goal can never bypass the always-ask confirm gate. Guarded by a routing truth-table test plus doc-contract wiring tests. v0.12.0 adds agent-tree supervision: a dispatch-time watchdog heartbeat closes the inverted carve-out where a hung-but-alive work agent hung a run forever (the stall watchdog now fires while work is in flight, not only when idle); an attempt-gated reap_unit makes the native-death path and the timeout watchdog converge on exactly one stall per attempt (the gate stops a late death event from a superseded attempt stalling a fresh retry); a reap/retry/escalate policy (retry once, escalate at attempt 2) with an assertable reap_pending marker for the otherwise model-side kill; and nested do_unit reap via the parent unit's stall. Two new skills: auto-watch renders a legible driver->unit->do_unit tree with per-node age-vs-threshold and attempt, overlaying live TaskList/Monitor status; auto-translate turns a designed loop or recipe into cap-bounded execution-tree waves (native subagent-tree is the only executable target; workflow-script is an inert routing label until the parked substrate RFC lands). do_unit prompts also self-terminate on no-progress as defense-in-depth. 1270 tests green. v0.13.0 rebalances /auto toward agent-native control: agent steering verbs (force-skip with a mandatory reason, add-unit, reshape-deps, init, register-session) let a driving agent reshape a live run through validated, rejectable CLI verbs instead of getting boxed in by the state machine; a self-describing `describe` verb emits the whole operating contract as one JSON object to kill the per-session orientation tax; and the loop's phase work descends into a sub-agent tree beneath a light boss session, with the fail-closed destructive backstop chained into the tree via a session-ownership set so the code-writing `fix` phase can't run rm -rf ungated. The boss can drive from one editable goal doc (native /goal is opaque and frozen); the done-floor stays the deterministic ledger predicate, so prose can't fake done. The ledger family is frozen as the correctness spine; the whole CLI collapsed into one verb registry that dispatch and `describe` share. 1336 tests green. v0.14.0 renames eight load-bearing concepts to consistent identifiers, keys, verbs, and flags (tick→pulse, orchestrator→dispatcher, ledger→run_record, adapter→backend, recipe→workflow, unit→step, emitter→producer, seam→handoff), gated by a vocabulary-audit that fails on any surviving old term; old names live on only as documented compat shims (module/path forwards scheduled for v0.15.0, plus a PERMANENT format read-shim so auto never rewrites a file you authored). On that base it finishes the agent-native charter: one whole-engine `describe` (plus a run-scoped `describe <run>` phase overlay) composes the operating contract so sub-agents orient without the skill corpus; the smart-entry detector stops reaching for the transcript it can't see (retired the CLAUDE_AUTO_CONVERSATION_SIGNAL backchannel) and emits richer deterministic facts (freshness-ranked plans + git state) for the driver, which owns the conversation-vs-stale-plan route; `dispatcher propose` surfaces the grammar-legal candidate advances so the driver steers what-next (the engine still validates the pick and keeps one-advance-per-pulse); and per-run steering verbs (set-retry-budget, set-stall-threshold) hand the driver policy constants that were hardcoded. A pacing-shell spike validates a context-flat boss loop via a bounded `dispatcher digest` (state counts, not growing lists), confirmed live with real driver sub-agents. The determinism bar is untouched: the atomic write + in-lock predicate recompute, the state grammar, the exit predicate/Stop-hook, and all detection reads stay mechanism. Also lands addressable step contents (one-shot runnable preset, Phase 1). 1558 tests green.