autonomy-profiles

What this skill does

# Autonomy Profiles — Runtime Skill

This skill activates the autonomy system. When invoked, read the current profile from `.claude/rules/autonomy.md`, load the active task from `.claude/active-task.md`, and operate according to the profile spec below.

---

## 1. Runtime Behavior by Profile

### 1.1 Conservative Runtime

**Entry sequence** (every session):
1. Read `.claude/active-task.md` — if it does not exist, create it from the template
2. Call `mem_context` to load cross-session memory
3. Read `.claude/rules/autonomy.md` to confirm profile
4. If task status is `implementing` or later, read the Phase Log and resume from the last completed phase
5. Announce current state: "Resuming [task name], Phase [N], last verified [timestamp]"

**Per-task loop**:
```
invoke autonomy-planner
  → receive structured plan
  → display plan to user
  → WAIT for user confirmation before proceeding

for each phase in plan:
  implement phase (one logical unit)
  invoke autonomy-verifier
    → if PASS: update active-task.md phase log, save memory, proceed
    → if FAIL: stop, show failures, ask user for direction
  WAIT for user to confirm continuation

invoke autonomy-reviewer
  → receive BLOCK / APPROVE decision
  → if BLOCK: address issues, re-verify, re-review
  → if APPROVE: stage files, show diff, ask user to confirm commit
```

**Context management**:
- Count exchanges. At exchange 20 (or when context > 80%): call `mem_session_summary`, then `/compact`
- After compact: re-read active-task.md and call `mem_context` before continuing

---

### 1.2 Balanced Runtime

**Entry sequence** (every session):
1. Read `.claude/active-task.md` if present
2. Call `mem_context`
3. Estimate task complexity: < 30 min → skip planner; > 30 min → invoke planner

**Per-task loop**:
```
if task_estimate > 30min:
  invoke autonomy-planner
  show plan (proceed without waiting for approval — but surface risks)

implement (read tools auto-approved, write/bash require case-by-case)

on completion:
  invoke autonomy-verifier
    → report results
    → if critical failures: stop and surface
    → if warnings only: continue with note
  
before PR:
  invoke autonomy-reviewer
    → address BLOCKs before opening PR
    → REQUESTs are noted in PR description

mem_save after each task completion
```

**Context management**:
- Count exchanges. At exchange 25: `mem_session_summary`, then `/compact`

---

### 1.3 Aggressive Runtime

**Entry sequence** (every session):
1. Check for `.claude/active-task.md` — if present and in-progress, resume without ceremony
2. Call `mem_context` (fast, non-blocking — do not wait for slow memory retrieval before starting)

**Per-task loop**:
```
assess task:
  if involves > 3 files or > 2 domains:
    spawn parallel subagents via Agent tool
    each subagent: scoped file list + objective + output contract
    synthesize in main session
  else:
    implement directly

all tool calls proceed without prompting (auto mode)

on completion:
  invoke autonomy-verifier (advisory — failures surface but do not block)
  mem_save with outcome summary

Exception: git push to main/master requires explicit user confirmation regardless of auto mode
```

**Parallelization pattern**:
```
Agent 1: "Implement [component A] in [files X, Y]. Return: list of changed files + summary."
Agent 2: "Implement [component B] in [files P, Q]. Return: list of changed files + summary."
Wait for both → merge → verify combined result
```

**Context management**:
- Count exchanges. At exchange 30: background `mem_session_summary`, then `/compact`
- Aggressive profile does not pause for memory ops — do them in background when possible

---

### 1.4 Unattended Review Runtime

**Entry sequence**:
1. This profile runs without human interaction — do not prompt for input
2. Read scope from session prompt or `.claude/review-scope.md`
3. Confirm read-only mode: no Write, Edit, or mutating Bash

**Review loop**:
```
determine scope:
  - PR diff (git diff main...HEAD)
  - specified files (from session prompt)
  - full repo scan (fallback)

spawn parallel review agents:
  Agent 1: security-reviewer — OWASP Top 10, secrets, injection, path traversal
  Agent 2: correctness-reviewer — logic errors, edge cases, missing null checks, type safety
  Agent 3: performance-reviewer — N+1 queries, unbounded loops, memory leaks
  Agent 4: style-reviewer — naming, complexity, dead code, test coverage

wait for all agents → synthesize into unified report

output:
  if gh CLI available: post as PR comment
  else: write to review-output.md in repo root

exit — do not loop or wait
```

**Output contract**: Every finding must include:
- Severity: BLOCK / REQUEST / SUGGEST / PRAISE
- File path and line range
- What the issue is (1 sentence)
- Why it matters (1 sentence)
- Concrete fix (code snippet or specific action) for BLOCK and REQUEST

---

## 2. Planner Agent Protocol

**Agent file**: `.claude/agents/autonomy-planner.md`

```yaml
---
name: autonomy-planner
description: Decomposes a task into a structured, phase-by-phase plan with risk assessment, file list, verification steps, and rollback path. Invoked before implementation on conservative and balanced profiles.
model: claude-opus-4-6
allowed-tools:
  - Read
  - Glob
  - Grep
  - Bash
---
```

**Invocation**:
```
Task: [task description from active-task.md or user input]

Produce a structured plan. Do not implement anything.
```

**Required output format**:
```markdown
# Plan: [task name]

## Summary
[2-3 sentence description of what will be done and why]

## Complexity Estimate
[Low / Medium / High] — estimated [N] sessions for conservative, [N] for balanced

## Phases

### Phase 1: [name]
**Goal**: [one sentence]
**Files**:
  - `path/to/file.ts` — [what changes]
  - `path/to/other.ts` — [what changes]
**Verification**: [specific command or check to confirm phase success]
**Rollback**: [how to undo if this phase fails]

### Phase 2: [name]
[same structure]

## Risks

| Risk | Likelihood | Impact | Mitigation |
|------|-----------|--------|------------|
| [risk description] | Low/Med/High | Low/Med/High | [mitigation] |

## Dependencies
[List any external services, env vars, or tools that must be available]

## Out of Scope
[Explicitly list what this plan does NOT include to prevent scope creep]
```

**Planner constraints**:
- Do not include implementation code in the plan — phases describe what changes, not how
- Each phase must be independently verifiable
- Rollback path is mandatory for any phase that modifies a database schema, environment config, or public API contract
- If the task requires > 5 phases, recommend splitting into multiple tasks

---

## 3. Verifier Agent Protocol

**Agent file**: `.claude/agents/autonomy-verifier.md`

```yaml
---
name: autonomy-verifier
description: Runs the project's verification suite (type check, tests, lint, diff audit) and reports pass/fail with actionable output. On conservative profile, runs after each file change. On balanced, runs after task completion.
model: claude-sonnet-4-6
allowed-tools:
  - Bash
  - Read
  - Glob
---
```

**Invocation**:
```
Run the full verification suite for this project. Report pass/fail for each check.
```

**Detection → execution**:

Step 1: Detect stack
```bash
# Check for package.json → Node/TypeScript
# Check for pyproject.toml or setup.py → Python
# Check for *.csproj → .NET
# Check for go.mod → Go
# Check for Cargo.toml → Rust
```

Step 2: Run checks in order (stop on first BLOCK-level failure in conservative mode, continue in all others):

| Check | Command | Pass Condition |
|-------|---------|----------------|
| TypeScript | `npx tsc --noEmit` | Exit 0, 0 errors |
| Tests | `pnpm test` / `npm test` / `pytest` / `dotnet test` / `go test ./...` | Exit 0, 0 failures |
| Lint | `npx eslint . --max-warnings 0` / `ruff check .` | Exit 0, no new errors |
| Diff audit | `git diff --stat HEAD` | No unexpected files (files outside current task scope) |

Step 3: Write results to `.claude/active-task.md`