fabrizioduroni-autopilot

name	fabrizioduroni-autopilot
description	The self-feeding autonomous loop — one tick either discovers work (scout, auto-approved) when the queue is empty or drains one loop:ready issue to a PR. Sequential (no port collision), session-bound, code-only, never merges.
disable-model-invocation	true

fabrizioduroni-autopilot — the self-feeding loop tick

Composes the producer (fabrizioduroni-scout) and the consumer (fabrizioduroni-blog-sdlc --autonomous) into one sequential tick, so the loop feeds itself with no human curation step — only the PR-merge gate remains. This is the "never-stops" mode.

Difference from fabrizioduroni-loop: the curated drainer only builds issues you labelled loop:ready. Autopilot auto-approves its own findings (applies loop:ready itself), so you are no longer the valve on what gets built — only on what gets merged.

Know what you're turning on. Auto-approve removes the value filter: autopilot will build findings you might have skipped, producing PRs you then close (wasted tokens + noise). What still protects you: the scout's targeting, the implementer ⇄ code-reviewer maker/checker, CI, backpressure, and your merge click. If you want the valve back, run fabrizioduroni-loop (curated) instead. Two hard invariants carry over: it never merges, and it never prompts mid-run.

Driven by /loop, e.g. /loop 30m /fabrizioduroni-autopilot. Session-bound (runs only while the session is open; 24/7 is the future cloud swap). Run from the main working tree (the pipeline creates its own worktrees and cannot nest).

One tick — do EXACTLY ONE of: pause · drain · refill

Never run the scout and the pipeline in the same tick — both boot a production server on :3000, so a tick that did both would collide. Draining and refilling therefore alternate across ticks: drain until the queue is empty, then one refill tick, then drain again.

1. Preconditions

Be in the main working tree (not a worktree). gh auth status healthy. Otherwise report and stop.

2. Backpressure — pause if enough PRs already await you

gh issue list --label "loop:review" --state open --json number --jq 'length'

If ≥ 3, do nothing this tick — report "backpressure: N PRs awaiting review, pausing" and stop. (Draining and refilling both pause here — no point discovering more when you already have a review backlog.) It resumes as you merge.

3. Is there ready work?

gh issue list --label "loop:ready" --state open --json number,createdAt,labels

Drop any also carrying loop:working (a claim in flight).

• Some loop:ready issue exists → DRAIN (§4a). Do not scout this tick.
• None → REFILL (§4b). Do not drain this tick.

4a. Drain one issue

Read and follow .claude/skills/fabrizioduroni-blog-sdlc/SKILL.md → its § Autonomous mode (Phase 2) for the oldest loop:ready issue N — i.e. execute it exactly as if invoked with --autonomous --from-issue N (it can't be invoked via the Skill tool; read-and-follow is the mechanism). It claims the issue, runs the contract check, builds, and opens a PR (loop:review) or blocks it (loop:blocked). One issue per tick. Report the terminal state, then end the tick.

4b. Refill (auto-approved discovery)

Read and follow .claude/skills/fabrizioduroni-scout/SKILL.md with one deviation: file each issue WITH the loop:ready label (auto-approve), so the next tick drains it. Apply the scout's scanners, two-tier ranking, dedup against open issues, per-dimension cap, and global backpressure exactly as written — the only change is adding loop:ready at gh issue create (--label "<dimension>" --label "loop:ready"). Report what was filed, then end the tick. (The next tick will drain the oldest.)

5. Report

One short block: which branch was taken (pause / drain / refill), the outcome (PR URL, blocked reason, or issues filed), and current queue depth (loop:ready) + backpressure (loop:review).

Invariants

• One action per tick — pause, drain, or refill; never scout + pipeline together (port :3000).
• One issue built per drain tick. Sequential, no parallel drain.
• Never merges — PRs land for your merge; that is the sole remaining human gate.
• Auto-approves — applies loop:ready itself (the one behavioural difference from fabrizioduroni-loop).
• Code only. Deduped. Capped + backpressure-throttled — inherited from the scout and the orchestrator.