@ai-dev-methodologies/rlp-desk 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ai-dev-methodologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,182 @@
+# RLP Desk
+
+> Fresh-context iterative loops for Claude Code — autonomous task completion with independent verification.
+
+RLP Desk brings [Geoffrey Huntley's Ralph Loop](https://ghuntley.com/ralph/) philosophy to Claude Code. Inspired by [OpenAI Codex's long-horizon tasks](https://developers.openai.com/blog/run-long-horizon-tasks-with-codex/) and [design-desk](https://github.com/derrickchoi-openai/design-desk), it orchestrates fresh-context workers and verifiers through Claude Code's `Agent()` tool.
+
+**Key insight**: Each iteration starts fresh. No accumulated context drift. The filesystem is the only memory.
+
+```
+[Your Session = LEADER]
+        │
+  Agent()├──▶ [Worker (fresh context)]
+        │     └── reads PRD + memory → implements → updates memory
+        │
+  Agent()└──▶ [Verifier (fresh context)]
+              └── reads done-claim → runs checks → writes verdict
+```
+
+## Quick Start
+
+### 1. Install
+
+```bash
+npm install -g @ai-dev-methodologies/rlp-desk
+```
+
+Or without npm:
+
+```bash
+curl -sSL https://raw.githubusercontent.com/ai-dev-methodologies/rlp-desk/main/install.sh | bash
+```
+
+### 2. Brainstorm
+
+In your project directory, start a Claude Code session:
+
+```
+/rlp-desk brainstorm "implement a Python calculator with tests"
+```
+
+This interactively defines the contract: slug, objective, user stories, verification commands, and iteration settings.
+
+### 3. Run
+
+```
+/rlp-desk run calculator
+```
+
+The leader loop runs autonomously — spawning workers, verifying results, and tracking progress until completion or a circuit breaker triggers.
+
+## Why?
+
+### The Context Problem
+
+LLM conversations accumulate context. Long sessions drift, hallucinate, and forget earlier decisions. The Ralph Loop solves this by treating **context as a disposable resource**:
+
+- Each worker gets a **fresh context** — no prior conversation, no accumulated confusion
+- **Filesystem = memory** — PRDs, campaign memory, and context files are the only state
+- **Independent verification** — a separate fresh-context verifier checks the worker's claims against real evidence
+
+### Lineage
+
+| Concept | Source |
+|---------|--------|
+| Fresh context per iteration | [Ralph Loop](https://ghuntley.com/ralph/) ([guide](https://www.aihero.dev/getting-started-with-ralph), [tips](https://www.aihero.dev/tips-for-ai-coding-with-ralph-wiggum)) |
+| Long-horizon autonomous tasks | [OpenAI Codex](https://developers.openai.com/blog/run-long-horizon-tasks-with-codex/) |
+| Desk-based orchestration | [design-desk](https://github.com/derrickchoi-openai/design-desk) |
+| Agent() subprocess model | Claude Code native |
+
+## How It Works
+
+### Three Roles
+
+| Role | Runs In | Responsibility |
+|------|---------|----------------|
+| **Leader** | Your current session | Orchestrates the loop, reads memory, selects models, writes sentinels |
+| **Worker** | Fresh `Agent()` context | Executes one bounded action per iteration, updates memory |
+| **Verifier** | Fresh `Agent()` context | Independently verifies worker claims with fresh evidence |
+
+### The Loop
+
+```
+for iteration in 1..max_iter:
+
+  1. Check sentinels (complete? blocked?)
+  2. Read campaign memory → get next iteration contract
+  3. Select model (haiku/sonnet/opus based on complexity)
+  4. Build worker prompt → dispatch via Agent()
+  5. Worker executes one bounded action, updates memory
+  6. If worker claims done → dispatch Verifier via Agent()
+  7. Verifier runs fresh checks → pass/fail/blocked
+  8. Update status, report to user, continue or stop
+```
+
+### Circuit Breakers
+
+| Condition | Action |
+|-----------|--------|
+| Context unchanged for 3 iterations | BLOCKED |
+| Same error repeated twice | Upgrade model, retry once, then BLOCKED |
+| Max iterations reached | TIMEOUT |
+
+### Model Routing
+
+| Scenario | Model |
+|----------|-------|
+| Simple, single-file changes | `haiku` |
+| Standard work (default) | `sonnet` |
+| Architecture changes, multi-file, prior failure | `opus` |
+| Standard verification | `sonnet` |
+| Security/critical logic verification | `opus` |
+
+## Commands
+
+```
+/rlp-desk brainstorm <description>     Plan before init (interactive)
+/rlp-desk init  <slug> [objective]     Create project scaffold
+/rlp-desk run   <slug> [--opts]        Run the loop (this session = leader)
+/rlp-desk status <slug>                Show loop status
+/rlp-desk logs  <slug> [N]             Show iteration logs
+/rlp-desk clean <slug>                 Reset for re-run
+```
+
+### Run Options
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--max-iter N` | 100 | Maximum iterations before timeout |
+| `--worker-model MODEL` | sonnet | Worker model (haiku/sonnet/opus) |
+| `--verifier-model MODEL` | sonnet | Verifier model (haiku/sonnet/opus) |
+
+## Project Structure
+
+After `init`, your project gets this scaffold:
+
+```
+your-project/
+└── .claude/ralph-desk/
+    ├── prompts/
+    │   ├── <slug>.worker.prompt.md
+    │   └── <slug>.verifier.prompt.md
+    ├── context/
+    │   └── <slug>-latest.md
+    ├── memos/
+    │   └── <slug>-memory.md
+    ├── plans/
+    │   ├── prd-<slug>.md
+    │   └── test-spec-<slug>.md
+    └── logs/<slug>/
+        └── status.json
+```
+
+## Example: Calculator
+
+See [`examples/calculator/`](examples/calculator/) for a complete example that implements a Python calculator module with tests using the RLP Desk loop.
+
+The example demonstrates:
+- A PRD with two user stories (calculator functions + pytest tests)
+- Test specification with verification commands
+- Worker and verifier prompts configured for the task
+
+To try it yourself:
+
+```
+mkdir my-calc && cd my-calc
+/rlp-desk brainstorm "Python calculator with add, subtract, multiply, divide + pytest tests"
+/rlp-desk run loop-test
+```
+
+## Documentation
+
+- [Architecture](docs/architecture.md) — Design philosophy and the Agent() approach
+- [Getting Started](docs/getting-started.md) — Step-by-step tutorial with the calculator example
+- [Protocol Reference](docs/protocol-reference.md) — Full protocol specification
+
+## Contributing
+
+See [CONTRIBUTING.md](.github/CONTRIBUTING.md).
+
+## License
+
+[MIT](LICENSE)

package/docs/architecture.md

@@ -0,0 +1,129 @@
+# Architecture
+
+## Design Philosophy
+
+RLP Desk is built on a single conviction: **context is a liability, not an asset**.
+
+In long-running LLM sessions, accumulated context causes drift, hallucination, and forgotten decisions. RLP Desk eliminates this by treating each iteration as a fresh start, with the filesystem as the sole source of truth.
+
+### Why Fresh Context Matters
+
+Traditional approaches:
+```
+Session start → Task 1 → Task 2 → ... → Task N
+                  ↑ context accumulates, quality degrades
+```
+
+RLP Desk approach:
+```
+Leader ──Agent()──▶ Worker 1 (fresh) ──▶ writes to filesystem
+       ──Agent()──▶ Worker 2 (fresh) ──▶ reads filesystem, continues
+       ──Agent()──▶ Worker 3 (fresh) ──▶ reads filesystem, continues
+```
+
+Each worker reads the same filesystem state that any human could inspect. No hidden context. No accumulated confusion.
+
+## The Agent() Approach
+
+Claude Code's `Agent()` tool spawns a subprocess — a completely new context window with no knowledge of the parent conversation. RLP Desk exploits this property:
+
+```python
+# Each call = new process = fresh context = no prior conversation
+Agent(
+    subagent_type="executor",   # Worker or Verifier
+    model="sonnet",             # Model selection per iteration
+    prompt=full_prompt_text,    # Everything the agent needs
+    mode="bypassPermissions"    # Autonomous execution
+)
+```
+
+The Agent returns synchronously. No polling, no signal files, no tmux. The Leader simply reads the filesystem after each Agent completes.
+
+### Why Agent() Over Other Approaches
+
+| Approach | Problem |
+|----------|---------|
+| Single long session | Context drift, token limits |
+| tmux + polling | Complex, brittle, race conditions |
+| Signal files + sleep loops | Fragile timing, wasted compute |
+| **Agent() subprocess** | **Clean, synchronous, guaranteed fresh context** |
+
+## Three-Role Architecture
+
+### Leader (Your Session)
+
+The Leader is the currently running Claude Code session. It:
+
+- Reads campaign memory to understand current state
+- Decides which model to use for the next iteration
+- Builds prompts by combining base prompts with iteration-specific context
+- Dispatches Workers and Verifiers via `Agent()`
+- Writes sentinel files (COMPLETE/BLOCKED) based on results
+- Tracks circuit breaker conditions
+
+The Leader **never writes code**. It orchestrates.
+
+### Worker (Fresh Context)
+
+Each Worker:
+
+- Receives a complete prompt with everything it needs (PRD, memory, context, task)
+- Executes exactly **one bounded action** (e.g., implement one user story)
+- Updates the filesystem:
+  - `context/<slug>-latest.md` — current frontier
+  - `memos/<slug>-memory.md` — campaign memory for the next worker
+  - `memos/<slug>-done-claim.json` — if claiming all work is complete
+- Exits
+
+The Worker has no memory of previous iterations. It relies entirely on what prior Workers wrote to the filesystem.
+
+### Verifier (Fresh Context)
+
+The Verifier exists because **Worker claims are not trustworthy**. A Worker may claim "all tests pass" without actually running them.
+
+Each Verifier:
+
+- Reads the PRD, test spec, and the Worker's done-claim
+- Runs verification commands **from scratch** (build, test, lint)
+- Checks each acceptance criterion against fresh evidence
+- Writes a verdict: pass, fail, or blocked
+- **Never modifies code**
+
+## Filesystem as Memory
+
+```
+.claude/ralph-desk/
+├── plans/          # Contracts (PRD, test spec) — written once, rarely modified
+├── prompts/        # Base prompts — templates for Worker/Verifier
+├── context/        # Current frontier — Worker updates each iteration
+├── memos/          # Runtime state — memory, claims, verdicts, sentinels
+└── logs/           # Audit trail — every prompt sent, every status change
+```
+
+### State Lifecycle
+
+```
+plans/prd-*.md          Written at init, stable reference
+plans/test-spec-*.md    Written at init, stable reference
+context/*-latest.md     Updated by Worker each iteration
+memos/*-memory.md       Rewritten by Worker each iteration
+memos/*-done-claim.json Created by Worker, cleaned by Leader
+memos/*-verify-verdict  Created by Verifier, cleaned by Leader
+memos/*-complete.md     Written once by Leader (terminal)
+memos/*-blocked.md      Written once by Leader (terminal)
+```
+
+## Model Routing Strategy
+
+Not every task needs the most powerful model. RLP Desk routes based on complexity:
+
+```
+Simple fix (typo, config)  →  haiku   (fast, cheap)
+Standard implementation    →  sonnet  (balanced)
+Architecture / debugging   →  opus    (thorough)
+```
+
+The Leader adapts dynamically:
+- Previous iteration failed → upgrade model
+- Simple repetitive task → downgrade model
+- User explicitly specified → respect the choice

package/docs/getting-started.md

@@ -0,0 +1,153 @@
+# Getting Started
+
+This guide walks you through your first RLP Desk loop using a simple Python calculator example.
+
+## Prerequisites
+
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code) installed and authenticated
+- A terminal with bash or zsh
+
+## Step 1: Install RLP Desk
+
+```bash
+npm install -g @ai-dev-methodologies/rlp-desk
+```
+
+Or without npm:
+
+```bash
+curl -sSL https://raw.githubusercontent.com/ai-dev-methodologies/rlp-desk/main/install.sh | bash
+```
+
+This installs three files:
+- `~/.claude/commands/rlp-desk.md` — the slash command
+- `~/.claude/ralph-desk/init_ralph_desk.zsh` — the scaffold generator
+- `~/.claude/ralph-desk/governance.md` — the protocol document
+
+## Step 2: Create a Project
+
+```bash
+mkdir calculator-demo && cd calculator-demo
+git init
+```
+
+## Step 3: Brainstorm
+
+Open Claude Code and run:
+
+```
+/rlp-desk brainstorm "Python calculator module with add, subtract, multiply, divide functions and pytest tests"
+```
+
+The brainstorm phase interactively determines:
+
+| Item | Example |
+|------|---------|
+| **Slug** | `loop-test` |
+| **Objective** | Implement calc.py + test_calc.py |
+| **User Stories** | US-001: calculator functions, US-002: pytest tests |
+| **Iteration Unit** | One user story per iteration |
+| **Verification** | `python3 -m pytest test_calc.py -v` |
+| **Models** | Worker: sonnet, Verifier: sonnet |
+| **Max Iterations** | 10 |
+
+On approval, brainstorm offers to run `init` automatically.
+
+## Step 4: Initialize (if not done in brainstorm)
+
+```
+/rlp-desk init loop-test "Python calculator with tests"
+```
+
+This creates the scaffold:
+
+```
+.claude/ralph-desk/
+├── prompts/
+│   ├── loop-test.worker.prompt.md
+│   └── loop-test.verifier.prompt.md
+├── context/
+│   └── loop-test-latest.md
+├── memos/
+│   └── loop-test-memory.md
+├── plans/
+│   ├── prd-loop-test.md
+│   └── test-spec-loop-test.md
+└── logs/loop-test/
+```
+
+## Step 5: Customize the PRD
+
+Edit `.claude/ralph-desk/plans/prd-loop-test.md` to define your user stories and acceptance criteria. See [`examples/calculator/`](../examples/calculator/.claude/ralph-desk/plans/prd-loop-test.md) for a complete example.
+
+Key sections:
+- **User Stories** with specific, testable acceptance criteria
+- **Technical Constraints** (e.g., "Python 3 + pytest only")
+- **Done When** conditions
+
+## Step 6: Define the Test Spec
+
+Edit `.claude/ralph-desk/plans/test-spec-loop-test.md` to specify verification commands:
+
+```markdown
+## Verification Commands
+### Test
+python3 -m pytest test_calc.py -v
+
+## Criteria → Verification Mapping
+| Criterion | Method | Command |
+|-----------|--------|---------|
+| calc.py exists | automated | test -f calc.py |
+| All tests pass | automated | python3 -m pytest test_calc.py -v |
+```
+
+## Step 7: Run the Loop
+
+```
+/rlp-desk run loop-test
+```
+
+What happens:
+
+1. **Iteration 1**: Worker reads the PRD, implements `calc.py` (US-001), updates memory
+2. **Iteration 2**: Worker reads memory, implements `test_calc.py` (US-002), writes done-claim
+3. **Iteration 3**: Verifier runs all checks, writes pass verdict
+4. Leader writes COMPLETE sentinel, reports success
+
+You'll see status updates after each iteration:
+
+```
+Iteration 1 | Worker (sonnet) | US-001 complete, continuing
+Iteration 2 | Worker (sonnet) | All stories done, requesting verification
+Iteration 3 | Verifier (sonnet) | PASS — all criteria met
+✓ COMPLETE
+```
+
+## Step 8: Check Status
+
+At any point during or after a run:
+
+```
+/rlp-desk status loop-test
+/rlp-desk logs loop-test        # latest iteration
+/rlp-desk logs loop-test 2      # specific iteration
+```
+
+## Step 9: Re-run (if needed)
+
+If you want to run the loop again:
+
+```
+/rlp-desk clean loop-test
+/rlp-desk run loop-test
+```
+
+`clean` removes runtime artifacts (sentinels, claims, verdicts) but preserves the PRD, test spec, and prompts.
+
+## Tips
+
+- **Start small**: One or two user stories for your first loop
+- **Be specific in acceptance criteria**: "function returns float" is testable; "function works well" is not
+- **Include verification commands**: The verifier needs concrete commands to run
+- **One story per iteration**: Each worker should do one bounded action
+- **Check logs when stuck**: `logs/<slug>/iter-NNN.worker-prompt.md` shows exactly what the worker received

package/docs/protocol-reference.md

@@ -0,0 +1,220 @@
+# Protocol Reference
+
+Complete specification of the RLP Desk leader loop protocol, signal contracts, circuit breakers, and model routing.
+
+## Leader Loop Protocol
+
+```
+for iteration in 1..max_iter:
+
+  ① Check sentinels
+     - <slug>-complete.md exists → stop (success)
+     - <slug>-blocked.md exists → stop (failure)
+
+  ② Read memory.md
+     - Parse "Stop Status" section → continue/verify/blocked
+     - Parse "Next Iteration Contract" → task for this iteration
+
+  ③ Select model
+     - Apply model routing rules (see below)
+     - Check circuit breaker conditions
+
+  ④ Build Worker prompt
+     - Read base prompt from prompts/<slug>.worker.prompt.md
+     - Append iteration number + contract from memory
+     - Write audit copy to logs/<slug>/iter-NNN.worker-prompt.md
+
+  ⑤ Execute Worker
+     Agent(subagent_type="executor", model=selected, prompt=prompt)
+     - Synchronous return — wait for completion
+     - Each Agent() = fresh context (new subprocess)
+
+  ⑥ Read memory.md again (Worker updated it)
+     - stop=continue → go to ⑧
+     - stop=verify   → go to ⑦
+     - stop=blocked  → write BLOCKED sentinel, stop
+
+  ⑦ Execute Verifier
+     - Build verifier prompt → write to logs/<slug>/iter-NNN.verifier-prompt.md
+     - Agent(subagent_type="executor", model=selected, prompt=prompt)
+     - Read verify-verdict.json:
+       • verdict=pass + recommended=complete → write COMPLETE sentinel, stop
+       • verdict=fail + recommended=continue → go to ⑧
+       • verdict=blocked → write BLOCKED sentinel, stop
+
+  ⑧ Update status.json, report to user, clean runtime files, next iteration
+```
+
+## Signal Contracts
+
+### Campaign Memory (`<slug>-memory.md`)
+
+Written by the Worker at the end of each iteration. Must contain:
+
+```markdown
+# <slug> - Campaign Memory
+
+## Stop Status
+continue | verify | blocked
+
+## Objective
+<original objective>
+
+## Current State
+Iteration N - <description>
+
+## Next Iteration Contract
+<specific task for the next worker>
+
+## Patterns Discovered
+## Learnings
+## Evidence Chain
+```
+
+The Leader reads **Stop Status** and **Next Iteration Contract** to decide what happens next.
+
+### Done Claim (`<slug>-done-claim.json`)
+
+Written by the Worker when claiming all work is complete:
+
+```json
+{
+  "iteration": 3,
+  "claimed_at_utc": "2025-01-15T10:30:00Z",
+  "summary": "All user stories implemented and tests passing",
+  "stories_completed": ["US-001", "US-002"],
+  "evidence": {
+    "test_output": "8 passed in 0.05s",
+    "files_created": ["calc.py", "test_calc.py"]
+  }
+}
+```
+
+### Verify Verdict (`<slug>-verify-verdict.json`)
+
+Written by the Verifier after independent verification:
+
+```json
+{
+  "verdict": "pass|fail|blocked",
+  "verified_at_utc": "2025-01-15T10:35:00Z",
+  "summary": "All criteria verified with fresh evidence",
+  "criteria_results": [
+    {
+      "criterion": "US-001 AC1: calc.py exists",
+      "met": true,
+      "evidence": "test -f calc.py → exit 0"
+    }
+  ],
+  "missing_evidence": [],
+  "issues": [],
+  "recommended_state_transition": "complete|continue|blocked",
+  "next_iteration_contract": "Fix failing test for divide by zero",
+  "evidence_paths": ["test_calc.py::test_divide_by_zero"]
+}
+```
+
+### Sentinels
+
+Leader-only files that terminate the loop:
+
+| File | Meaning | Written When |
+|------|---------|--------------|
+| `<slug>-complete.md` | Loop succeeded | Verifier passes all criteria |
+| `<slug>-blocked.md` | Loop cannot continue | Autonomous blocker or circuit breaker |
+
+**Only the Leader writes sentinels.** Workers and Verifiers never touch them.
+
+## Context File (`<slug>-latest.md`)
+
+Updated by the Worker each iteration to reflect the current frontier:
+
+```markdown
+# <slug> - Latest Context
+
+## Current Frontier
+### Completed
+- US-001: calculator functions implemented
+### In Progress
+- US-002: pytest tests
+### Next
+- Run verification
+
+## Key Decisions
+- Using ValueError for divide-by-zero (not ZeroDivisionError)
+
+## Known Issues
+## Files Changed This Iteration
+- calc.py (created)
+## Verification Status
+- python3 -m pytest → not yet run
+```
+
+## Circuit Breakers
+
+| Condition | Detection | Action |
+|-----------|-----------|--------|
+| Stale context | `context-latest.md` hash unchanged for 3 consecutive iterations | Write BLOCKED sentinel |
+| Repeated error | Worker produces the same error message 2 iterations in a row | Upgrade model, retry once; still failing → BLOCKED |
+| Timeout | Iteration count reaches `max_iter` | Write TIMEOUT status, report to user |
+
+### Stale Context Detection
+
+The Leader computes a hash (or diff) of `context-latest.md` before and after each Worker runs. If the content doesn't change for 3 consecutive iterations, the Worker is stuck and the loop is blocked.
+
+### Error Escalation
+
+```
+Error in iteration N (sonnet) → retry with opus in iteration N+1
+Same error in iteration N+1 (opus) → BLOCKED
+```
+
+## Model Routing
+
+### Selection Matrix
+
+| Scenario | Model | Rationale |
+|----------|-------|-----------|
+| Single file, clear change | `haiku` | Fast, sufficient |
+| Standard implementation | `sonnet` | Balanced (default) |
+| Multi-file, architecture | `opus` | Needs broad understanding |
+| Previous iteration failed | upgrade | Harder model may succeed |
+| Verification (standard) | `sonnet` | Sufficient for running checks |
+| Verification (security) | `opus` | Critical logic needs thoroughness |
+
+### Dynamic Adaptation
+
+The Leader reassesses the model every iteration:
+
+1. Read memory for previous iteration outcome
+2. If failed → upgrade one level (haiku → sonnet → opus)
+3. If simple/repetitive → consider downgrade
+4. User override via `--worker-model` / `--verifier-model` takes precedence
+
+## Status File (`status.json`)
+
+Updated by the Leader after each iteration:
+
+```json
+{
+  "slug": "loop-test",
+  "iteration": 2,
+  "max_iter": 100,
+  "phase": "worker|verifier|complete|blocked|timeout",
+  "worker_model": "sonnet",
+  "verifier_model": "sonnet",
+  "last_result": "continue|verify|pass|fail|blocked",
+  "updated_at_utc": "2025-01-15T10:30:00Z"
+}
+```
+
+## Slash Command Reference
+
+| Command | Arguments | Description |
+|---------|-----------|-------------|
+| `brainstorm` | `<description>` | Interactive planning before init |
+| `init` | `<slug> [objective]` | Create project scaffold |
+| `run` | `<slug> [--max-iter N] [--worker-model M] [--verifier-model M]` | Run the leader loop |
+| `status` | `<slug>` | Display current loop status |
+| `logs` | `<slug> [N]` | Show iteration logs |
+| `clean` | `<slug>` | Remove runtime artifacts for re-run |