Autodev Lev

---
name: autodev-lev
description: "Heartbeat-driven autonomous development loop using lev loop autodev, with interval, budget, and tick controls for in-process SDLC execution."
---

# Autodev Lev

> Heartbeat-driven autonomous development loop using Lev primitives.
> Unlike `/autodev-loop` (which uses Claude Code CronCreate), this runs through `lev loop autodev`
> with sleep-based pacing — staying in-process with full state continuity between ticks.

## Invocation

```
/autodev-lev                           # Start with defaults (5m heartbeat)
/autodev-lev 10m                       # Custom interval
/autodev-lev --budget=50k              # Token budget cap
/autodev-lev --max-ticks=5             # Stop after 5 ticks
/autodev-lev --until="all specs pass"  # Semantic exit condition
/autodev-lev status                    # Show queue and config
/autodev-lev --dry-run                 # Scan only, show what would execute
```

## Architecture

```
┌─────────────────────────────────────────────────────────┐
│  Top-Level Orchestrator (you)                           │
│  Manages SDLC stages: SCAN → PLAN → EXEC → VALIDATE    │
└──────────────┬──────────────────────────────────────────┘
               │ /autodev-lev 5m
               ▼
┌─────────────────────────────────────────────────────────┐
│  Heartbeat Loop (lev loop autodev)                      │
│                                                         │
│  ┌──────┐  sleep(5m)  ┌──────┐  sleep(5m)  ┌──────┐   │
│  │SCAN  │────────────→│SCAN  │────────────→│SCAN  │   │
│  └──┬───┘             └──┬───┘             └──┬───┘   │
│     │ entities?           │ entities?          │ none   │
│     ▼                     ▼                    ▼        │
│  ┌──────┐             ┌──────┐           all_done      │
│  │ EXEC │             │ EXEC │                          │
│  └──┬───┘             └──┬───┘                          │
│     │                     │                              │
│     └─ runSdlcLoop()     └─ runSdlcLoop()               │
│        (token spend)        (token spend)                │
└─────────────────────────────────────────────────────────┘
```

## Key Difference from autodev-loop

| | autodev-loop | autodev-lev |
|---|---|---|
| **Runtime** | Claude Code CronCreate | `lev loop autodev` (in-process) |
| **Pacing** | Cron fires fresh invocation | Sleep between ticks (state preserved) |
| **Token efficiency** | Every tick = new context load | Scan phase = zero LLM cost |
| **State** | Stateless across ticks | Full continuity in-process |
| **Concurrency** | Single agent per cron tick | maxWorkers per tick |
| **Exit conditions** | Manual `/autodev-loop --stop` | Budget, until, max-ticks, circuit breaker |

## Protocol

### Phase 0: Pre-flight

1. Check `lev loop` for entity queue
2. Determine interval, budget, exit conditions
3. Execute `lev loop autodev` with flags

### Phase 1: Scan (zero cost)

- Filesystem glob across configured surfaces (`.lev/pm/plans/`, `docs/specs/`)
- Parse frontmatter for priority, lifecycle state, fitness functions
- Validation gates alignment: load `.lev/validation-gates.yaml`, report gate status
- Skip blocked/deferred entities
- Sort by priority (P0 > P1 > P2 > P3 > P4)

### Phase 2: Execute (token spend)

- Run `runSdlcLoop()` on discovered entities
- Uses prompt-stack for composition (default: `sdlc-exec-validate`)
- Uses exec profiles for execution (default: `sdlc.flowmind.exec`)
- Respects `maxWorkers` for concurrent execution
- Emits LevEvents for observability

### Phase 3: Exit Check

After each tick, check exit conditions in order:

1. **fail_fast** — any failure this tick + `--fail-fast` flag
2. **circuit_breaker** — 3 consecutive ticks with zero successes
3. **max_ticks** — hit `--max-ticks` limit
4. **budget_exhausted** — cumulative tokens >= `--budget`
5. **until_met** — semantic condition satisfied
6. **all_done** — no entities remaining in queue

### Phase 4: Sleep

Sleep for `--interval` duration. Process stays alive, state preserved.
SIGINT/SIGTERM triggers graceful shutdown after current tick completes.

## Configuration

Config lives in `plugins/core-sdlc/config.yaml` under `autodev.heartbeat`:

```yaml
autodev:
  heartbeat:
    interval: 5m
    max_workers: 3
    max_entities: 5
    max_ticks: 0          # 0 = unlimited
    budget_tokens: 0       # 0 = unlimited
    stack: sdlc-exec-validate
    profile: sdlc.flowmind.exec
    circuit_breaker_threshold: 3
```

Overridable via CLI flags (flags win over config).

## Skill Routing

When invoked as `/autodev-lev`:

```bash
# 1. Parse args
INTERVAL="${1:-5m}"
FLAGS="${@:2}"

# 2. Delegate to lev loop autodev
lev loop autodev --interval=$INTERVAL $FLAGS
```

When the orchestrator (top-level agent) uses this skill:

1. **Start**: `lev loop autodev --interval=5m --max-ticks=10 --budget=100k`
2. **Monitor**: Watch stdout for tick summaries
3. **Interrupt**: SIGINT to stop gracefully
4. **Status**: `lev loop autodev status` for queue snapshot

## Integration with Prompt Stacks

Uses existing prompt-stack plugin for entity composition:

- `sdlc-exec-validate` — default: execute entity + validate gates
- `sdlc-deepen-plan` — deep plan decomposition
- `sdlc-hygiene` — hygiene scan
- Custom stacks via `--stack=<id>`

FlowMind will absorb this when it settles. Until then, prompt stacks are the steering layer.

## Exit Reasons

| Reason | Meaning |
|--------|---------|
| `all_done` | No entities remaining in queue |
| `no_work` | No entities found on first scan |
| `budget_exhausted` | Token budget consumed |
| `max_ticks` | Hit `--max-ticks` limit |
| `until_met` | Semantic exit condition satisfied |
| `fail_fast` | Stopped on first failure |
| `circuit_breaker` | 3 consecutive tick failures |
| `interrupted` | SIGINT/SIGTERM received |

## Example Session

```
$ lev loop autodev --interval=5m --max-ticks=10 --budget=50k

⚡ Tick 1 | 4 entities | interval 5.0m
  → Processed: 2 | Succeeded: 2 | Failed: 0 | 45200ms
  💤 Sleeping 5.0m...

⚡ Tick 2 | 2 entities | interval 5.0m | budget 12000/50000
  → Processed: 2 | Succeeded: 1 | Failed: 1 | 38100ms
  💤 Sleeping 5.0m...

⚡ Tick 3 | 1 entities | interval 5.0m | budget 28000/50000
  → Processed: 1 | Succeeded: 1 | Failed: 0 | 22300ms
  💤 Sleeping 5.0m...

⚡ Tick 4 | 0 entities | interval 5.0m | budget 35000/50000
  ✓ No entities remaining — all done.

─── Autodev Session Complete ───
  Ticks:      4
  Processed:  5
  Succeeded:  4
  Failed:     1
  Duration:   15.2m
  Exit:       all_done
```

## Anti-Patterns

- **Don't use CronCreate** — that's the old way. Heartbeat > cron for state continuity.
- **Don't set interval < 1m** — burns tokens. If you need faster, use `lev loop run` directly.
- **Don't skip --budget on long runs** — set a budget to prevent runaway spend.
- **Don't ignore circuit_breaker** — 3 failures = something structural is wrong. Investigate.

## Dependencies

- `@lev-os/orchestration/entities` — discoverPlans, loadLoopConfig
- `plugins/core-sdlc/src/workflows/sdlc-loop.ts` — runSdlcLoop
- `plugins/prompt-stack` — prompt composition (until FlowMind absorbs)
- `core/exec` — execution engine with semaphore + token tracking

## Auto-Nudge + Stale Detection Heuristics (from OMX + Clawhip)

Enhanced idle/stale detection beyond basic `pane_last_active`:

### Stale Session Detection (from Clawhip cw-04)
- **Content hashing:** Hash tmux pane output before/after intervals. No change = stale.
- **Keyword windows:** Aggregate keyword hits (error, complete, stuck) over N-second windows. Burst = event.
- **Parent process tracking:** If the parent process of a tmux session dies, the session is orphaned.
- **Configurable stale_minutes:** Per-session stale threshold (default 30min from Clawhip).

### Auto-Nudge (from OMX omx-09)
- **Proceed-intent detection:** OMX detects when an agent is waiting for input vs genuinely stuck.
- **Stall signature matching:** Match against known stall patterns (repeated output, token exhaustion, rate limit).
- **Nudge escalation:** nudge → checkpoint → escalate → EXIT_SIGNAL (progressive, not immediate kill).

**Source:** `.lev/pm/parity/clawhip.yaml` (cw-04), `.lev/pm/parity/omx.yaml` (omx-09), tribunal items 18+24 (UNANIMOUS AGREE)