A Claude Code harness that earns its autonomy.

Knows when to stop.

Three independent stop conditions watch the run. zero-progress trips when two consecutive rounds merge nothing. time trips at --time-limit — six hours by default. The stall watchdog trips when a child stops making progress at all: 30 minutes of inactivity, or a four-hour absolute ceiling that never resets. Any one of them ends the run cleanly — saves state, writes the report, exits — instead of churning until your wallet or your repo notices.

Climbs when stuck — stops calmly when it can't.

Failed gates don't loop blindly. A failure that's worth another go runs again with the previous attempt's learnings appended — each retry is a fresh process, so nothing carries over but the notes. A refusal or an infrastructure failure skips the retries entirely and pauses on the spot. When the attempts are spent, a separate brain agent triages: SKIP, DEFER, or PAUSE. There is deliberately no RETRY verdict — it would re-enter the caller that just gave up.

A DEFER writes deferred/<slug>-q001.md with what it tried and what it needs from you — then carries on with the rest of the queue. Four attempts, a judge, one calm exit.

Stays in its lane.

Each ticket runs in its own git worktree on its own branch. The agent can’t reach main, can’t touch packed-refs, can’t read other repos, and has its tool list pinned ahead of time. The fence is enforced by the OS sandbox, not by asking the agent nicely — it literally cannot do the things outside it.

Schedules around conflicts. Heals what slips through.

Conflicts are mostly prevented before they happen. /overnight reads each ticket's file list and groups tickets into rounds so no two tickets in the same round touch the same file — and dependencies wait for their predecessors to finish. When a conflict still slips through, the harness uses a graded heal: trivial conflicts (whitespace, imports, non-overlapping hunks) take a fast-path stamp; real conflicts get exactly one bounded repair attempt, then defer. No infinite repair loops, no surprise force-pushes.

Survives interruption.

Every state write lands atomically — tempfile plus os.replace(), so a reader sees the old bytes or the new bytes, never a torn mix. Close your laptop mid-run, lose power, kill the process — on restart, interrupt.py inspects each still-running ticket's worktree, logs an interrupted event with the evidence it found, and hands the ticket back to the queue as pending. No double-merges, no orphaned worktrees, no half-applied state.

Tells you everything it did.

Five append-only JSONL streams record the run at five different scopes: session events, per-task dispatch and merge outcomes, per-feature phase transitions, per-turn agent tool calls, and the worker↔orchestrator escalation channel. Each has exactly one writing module, so ownership can't drift. At dawn they're collated into a single morning-report.md — what merged, what was skipped and why, what's waiting for you. Every decision is auditable; nothing happens off the record.