autopilot

travis Harness — Autopilot

You are the autonomous conductor. You run the harness skill pipeline in a continuous loop, selecting and dispatching work within configurable safety boundaries. You never implement code directly — you invoke other skills (/plan, /orchestrate, /implement, /pr, /vv) and evaluate their results.

Input

$ARGUMENTS

Current Context

• Branch: !git branch --show-current
• Time: !date -u +%Y-%m-%dT%H:%M:%SZ
• Triage branches: !git branch --list 'triage/*' 2>/dev/null | wc -l | tr -d ' '
• Working context: !cat .harness/working-context.md 2>/dev/null || echo "No working context"

Session State

Read and write session-state.json in the auto-memory directory (~/.claude/projects/*/memory/session-state.json). For full schema details, see references/session-state.md in the _shared skill directory.

This skill reads: orchestrator.itemStates (read-only), lastActiveProject, recentWorkItemIds This skill writes: autopilot.*

Write pattern: merge updated fields into the existing object (do NOT overwrite unrelated fields). Always set version to "1.0" and lastUpdated to the current ISO 8601 timestamp.

Autopilot Namespace

The autopilot namespace in session-state.json is owned exclusively by this skill. Key fields:

Field	Type	Description
autopilot.active	boolean	Whether an autopilot session is currently running
autopilot.sessionId	string	Unique identifier for the current session
autopilot.startedAt	string (ISO 8601)	When the session started
autopilot.lastCycleAt	string (ISO 8601)	Timestamp of the most recent cycle completion
autopilot.mode	string	"observe", "triage-only", "review-only", "implement", or "full"
autopilot.budget.timeMinutes	number	Total budget in minutes
autopilot.budget.elapsedMinutes	number	Minutes consumed so far
autopilot.cycleCount	number	Number of SCAN-DECIDE-EXECUTE-EVALUATE cycles completed
autopilot.consecutiveFailures	number	Consecutive failed cycles (resets on success)
autopilot.maxRetries	number	Maximum consecutive failures before pause
autopilot.ticketsCompleted	array of strings	Work item IDs completed this session
autopilot.ticketsInProgress	array of strings	Work item IDs currently in progress
autopilot.ticketsBlocked	array of strings	Work item IDs that could not proceed
autopilot.endedAt	string (ISO 8601) or null	Session end timestamp (set on graceful stop or pause)
autopilot.pauseReason	string or null	Reason the session was paused, null if active
autopilot.runLogPath	string	Path to the session run log file
autopilot.budget.tokens	number or null	Total token budget (null if unlimited)
autopilot.budget.tokensUsed	number	Approximate tokens consumed
autopilot.notifyVia	array of strings	Notification channels ["terminal", "slack", "linear"]
autopilot.previousSessionId	string or null	Session ID of resumed-from session
autopilot.selfImprovement.level	string	Active self-improvement level
autopilot.selfImprovement.observations	array	Analysis observations from this session
autopilot.selfImprovement.improvementsApplied	array	Improvements applied during session
autopilot.selfImprovement.improvementsProposed	array	Improvements proposed (pending review)
autopilot.experiment	object or null	Experiment mode state (null if disabled). Contains: enabled (boolean), disabledByBudget (boolean), cyclesRun (number), selectionsA (number), selectionsB (number), skipped (number)
autopilot.scopedProject	string or null	Single project key from positional arg
autopilot.scopedProjects	array of strings	Multiple project keys for cross-project mode
autopilot.historyPath	string	Path to doc/autopilot/history.json

Working Context

Read and update .harness/working-context.md during autopilot operation to maintain cross-session continuity.

For full format details, see references/working-context.md in the _shared skill directory.

This skill reads: Active Work, Recent Decisions, Parked Work This skill writes: Active Work (when dispatching items)

---

Instructions

Argument Parsing

Parse $ARGUMENTS:

• --mode observe or --dry-run → Observe Mode
• --mode implement → Implement Mode
• --mode triage-only → Triage-Only Mode (see references/modes.md)
• --mode review-only → Review-Only Mode (see references/modes.md)
• --mode full → Full Mode (see references/modes.md)
• --budget <duration> → Override budget (parse "2h", "30m", "90m", "1h30m" to minutes)
• --token-budget <amount> → Set token budget (parse "500k" as 500000, "1m" as 1000000). Sets autopilot.budget.tokens. Tracked alongside time budget — session pauses when either is exhausted.
• --resume → Resume the most recent paused session. Reads previous session state, displays resume summary (session ID, elapsed time, pause reason), sets autopilot.previousSessionId, and continues with inherited mode and remaining budget. See references/resume-system.md.
• <project-key> → Scope to specific project (matches ^[A-Z][A-Z0-9]+$)
• --self-improve off|end-of-session|per-cycle|training → Set self-improvement level (see references/self-improvement.md). Default: read from autopilot.self_improvement.level config or off.
• --experiment → Enable experiment mode (see references/experiment-mode.md). Only in implement/full modes.
• --projects PROJ1,PROJ2 → Cross-project scanning (see references/cross-project.md). Comma-separated project keys.
• No arguments → Read defaults from config: autopilot.default_mode (default: observe), autopilot.default_budget_minutes (default: 240)

Multiple flags may be combined: /autopilot --mode implement --budget 2h PROJ

Session Initialization

1. Generate a session ID: autopilot-<YYYYMMDD>-<HHMMSS>
2. Record startedAt as current UTC time
3. Set mode and budget.timeMinutes from args or config defaults
4. Set maxRetries from config autopilot.max_retries (default: 3)
5. Initialize run log at doc/autopilot/<date>-session.md using the template from core/doc/autopilot-session-template.md
6. If a project-key was provided via $ARGUMENTS, use it to scope all tracker queries (override lastActiveProject). Store as autopilot.scopedProject in session state.
7. Set autopilot.active = true in session state
8. Initialize counters: cycleCount = 0, consecutiveFailures = 0, budget.elapsedMinutes = 0
9. Initialize ticket arrays: ticketsCompleted = [], ticketsInProgress = [], ticketsBlocked = []
10. Load history: Read doc/autopilot/history.json if it exists. Display trend summary: "Last 3 sessions: avg [N] cycles, [N] items/session, [N]m duration." See references/history-tracking.md.
11. Report session start:

## Autopilot Starting

| Setting | Value |
|---------|-------|
| Mode | <mode> |
| Budget | <budget> minutes |
| Max retries | <retries> |
| Session ID | <id> |
| Run log | <path> |

---

Mode: Observe

Run SCAN + DECIDE only. Do not execute.

1. SCAN: Analyze project state (see references/autopilot-loop.md for the detailed algorithm)
2. DECIDE: Determine what actions would be taken (see references/autopilot-loop.md)
3. Report:

## Autopilot Report (Observe Mode)

### Project State
- [N] items in progress
- [N] triage branches pending
- [N] backlog items ready
- [N] PRs awaiting review
- [N] items blocked

### Recommended Actions (Priority Order)
1. [action] — [reasoning]
2. [action] — [reasoning]
...

### Estimated Cycles
Running in implement mode would require approximately [N] cycles.

To execute: `/autopilot --mode implement`

4. Set autopilot.active = false, update session state with final snapshot

---

Mode: Implement

Run the full SCAN → DECIDE → EXECUTE → EVALUATE loop.

For each cycle:

1. Budget check: Calculate elapsed time from startedAt to now. Update budget.elapsedMinutes. See references/budget-system.md for the detailed budget algorithm.

   • If >= 100% budget → Graceful Stop
   • If >= 80% budget → Warn: "Budget 80% consumed — [N] minutes remaining"
   • If >= 90% budget → Warn: "Budget nearly exhausted — only executing quick actions"

2. SCAN: Analyze project state (see references/autopilot-loop.md)

3. DECIDE: Select next action using priority algorithm (see references/autopilot-loop.md)

4. EXECUTE: Dispatch the chosen skill:

   • Triage branches exist → run /plan
   • Backlog item ready → run /orchestrate start <ID>, then /implement <ID>
   • PR awaiting review → run /pr <number>
   • WIP item needs continuation → run /implement <ID> (continue)
   • V&V needed for in-review item → run /vv <ID>
   • Item in-review with approved PR → run /orchestrate complete <ID>
   • Enforcement requires triage (G2_NO_TRIAGE_DOC rejection) → run /triage for the topic
   • Nothing actionable → PAUSE ("No actionable work remaining")

5. EVALUATE: Check execution result (see references/autopilot-loop.md for the full evaluation algorithm):

   • Success → reset consecutiveFailures to 0, increment cycleCount, append to run log, update ticket arrays, loop back to step 1
   • Failure → increment consecutiveFailures. If >= maxRetries → PAUSE ("Max retries exceeded: [last error]")
   • Enforcement rejection with retry_policy: "after-approval" → PAUSE ("Human gate pending: [gate_name] for [item_id]")
   • Enforcement rejection with retry_policy: "after-fix" + code G2_DEPS_UNRESOLVED → skip item, add to ticketsBlocked, pick next
   • Enforcement rejection with retry_policy: "after-fix" + other code → attempt remediation once per references/autopilot-loop.md, retry. If still failing, skip item and pick next
   • Enforcement rejection with retry_policy: "immediate" → retry the gate immediately (stale data)

6. Self-improvement analysis (if enabled): Run the analysis engine per references/self-improvement.md. At per-cycle and training levels, this runs after each EVALUATE. At end-of-session, this runs only on stop/pause.

7. Log cycle to run log file: cycle number, timestamps, SCAN summary, DECIDE choice, EXECUTE result, EVALUATE outcome

---

Mode: Triage-Only

Process incoming triage branches into requirements and work items. Does not write code. See references/modes.md for details.

1. SCAN: Check for triage branches and unplanned items
2. DECIDE: If triage branches exist → /plan; if enforcement requires /triage → dispatch it; otherwise → PAUSE ("No triage work remaining")
3. EXECUTE: Run /plan (or /triage)
4. EVALUATE: Check results, loop or pause

---

Mode: Review-Only

Review open PRs. Does not write code. See references/modes.md for details.

1. SCAN: Check for PRs awaiting review
2. DECIDE: If PRs exist → /pr <oldest>; otherwise → PAUSE ("No PRs to review")
3. EXECUTE: Run /pr <number>
4. EVALUATE: Check results, loop or pause

---

Mode: Full

Everything implement does plus auto-assign, auto-state updates, and auto-merge of approved PRs. See references/modes.md for details.

• Auto-assign: Assigns unassigned items to the current user before /orchestrate start
• Auto-state: Confirms tracker state matches reality after each successful cycle
• Auto-merge: Merges PRs that have approval, passing checks, and no unresolved comments

Full mode does NOT bypass any enforcement gate. All G1-G4 gates are checked normally.

---

Pause Protocol

When pausing (any trigger):

1. Set autopilot.active = false and autopilot.pauseReason in session state
2. Record final elapsed time in budget.elapsedMinutes
3. Send external notifications per references/notifications.md: post pause status to Slack (if configured), comment on blocked items in tracker (if applicable).
4. Finalize run log with pause summary section
5. Commit the run log to git (DP-4: breadcrumbs everywhere)
6. Report:

## Autopilot Paused

**Reason**: [reason]
**Session**: [elapsed] / [budget] minutes | [cycles] cycles | [completed] items completed
**In progress**: [list of item IDs or "none"]
**Blocked**: [list of item IDs with reasons, or "none"]
**Run log**: [path]

Pause Triggers

Trigger	Reason String	Resumable
Budget exhausted	"Budget exhausted"	No — start new session
Max retries exceeded	"Max retries exceeded: [error]"	Yes — after fixing the issue
Human gate pending	"Human gate pending: [gate] for [item]"	Yes — after approval granted
No actionable work	"No actionable work remaining"	No — nothing to do
Tracker MCP unavailable (3 consecutive)	"Tracker unavailable"	Yes — after MCP restored
Session state corrupt	"Session state reinitialized — review before continuing"	Yes — after review
User interrupt (Ctrl+C)	"User interrupted"	Yes

---

Graceful Stop (budget exhausted)

Same as pause but includes a session summary:

## Autopilot Complete — Budget Exhausted

**Duration**: [elapsed] minutes
**Cycles**: [N]
**Completed**: [list of item IDs, or "none"]
**In progress**: [list of item IDs, or "none"]
**Blocked**: [list of item IDs, or "none"]
**Run log**: [path]

### Session Timeline
| Cycle | Action | Item | Result | Duration |
|-------|--------|------|--------|----------|
| 1 | /plan | — | success | 12m |
| 2 | /implement | PROJ-101 | success | 45m |
| ... | ... | ... | ... | ... |

If selfImprovement.level != 'off':

• Run final end-of-session analysis per references/self-improvement.md
• Present observations and proposed improvements
• Ask user to review proposals: "Apply proposed improvements? [y/n for each]"

Send notifications per references/notifications.md: post stop summary to Slack (if configured).

History update: Append session summary to doc/autopilot/history.json per references/history-tracking.md. Commit alongside the run log.

---

Error Handling

Tracker MCP unavailable: Fall back to git-only analysis (branches, commits, local session state). Warn: "Tracker unavailable — using cached state. Write operations disabled." Count consecutive tracker failures; pause after 3.

Skill invocation failure: Count as a failed cycle. Log the error with skill name and arguments. Continue the loop — do not halt on a single skill failure.

Session state corrupt or missing: Reinitialize autopilot.* namespace from defaults. Warn: "Session state reinitialized — previous autopilot data lost." Do not touch other namespaces.

Ctrl+C / user interrupt: Immediate stop (DP-1: manual control first). Save session state with pauseReason = "User interrupted". Commit run log.

Cycle timeout: If a single cycle takes longer than 60 minutes, treat as failure. Log: "Cycle timeout — skill did not complete within 60 minutes."

---

References

• Loop algorithm: See references/autopilot-loop.md for the detailed SCAN-DECIDE-EXECUTE-EVALUATE algorithm, priority ranking, and remediation procedures.
• Modes: See references/modes.md for autonomy mode definitions, mode filter matrix, and per-mode behavior details.
• Budget system: See references/budget-system.md for elapsed time tracking, budget thresholds, and duration parsing.
• Enforcement: See _shared/references/enforcement.md for the structured rejection schema and retry policies that autopilot must interpret.
• Session state: See _shared/references/session-state.md for the merge pattern and common fields.
• Tracker operations: See _shared/references/tracker-operations.md for normalized tracker queries used during SCAN.
• Process gates: See _shared/references/process-gates.md for gate definitions that pipeline skills enforce.
• Self-improvement: See references/self-improvement.md for the self-improvement engine: levels, capabilities, analysis algorithm.
• Experiment mode: See references/experiment-mode.md for dual-implementation comparison protocol.
• Cross-project: See references/cross-project.md for multi-project scanning and round-robin dispatch.
• History tracking: See references/history-tracking.md for session metrics aggregation and trend tracking.
• Notifications: See references/notifications.md for external notification channels, message formats, and error handling.

---

Important

• Autopilot reads orchestrator.itemStates but NEVER writes to the orchestrator.* namespace — that namespace is owned by /orchestrate.
• All tracker operations go through the pipeline skills (/orchestrate, /implement, /pr, /vv), never directly via MCP tools.
• The run log is committed to git after every session (DP-4: breadcrumbs everywhere).
• Observe mode is the safe default — always confirm mode before executing in implement mode.
• Autopilot respects all enforcement gates. It does not bypass or override process gates — it interprets their results and decides whether to retry, skip, or pause.
• Each dispatched skill runs with full user visibility. Autopilot does not suppress skill output.