@thierrynakoa/fire-flow 10.0.0

package/README.md

@@ -0,0 +1,398 @@
+# Dominion Flow
+
+**A comprehensive orchestration platform that empowers your Claude agent.**
+
+Dominion Flow gives Claude a complete, structured way to take your project from idea to finished code — with built-in quality checks, session memory, parallel execution, and a library of proven patterns. Think of it as a project management system that lives inside Claude Code.
+
+---
+
+## What Does It Do?
+
+When you start a new project, Claude normally has no memory between sessions, no standard process, and no way to verify its own work. Dominion Flow fixes all of that:
+
+- **Structured workflow** — A numbered pipeline (Plan → Execute → Verify → Handoff) so nothing gets skipped
+- **Session memory** — Claude picks up exactly where it left off, every time
+- **Parallel execution** — Multiple tasks run at the same time, safely, so work gets done faster
+- **Built-in quality gates** — A comprehensive checklist verifies every phase before moving on
+- **Skills library** — A growing collection of proven code patterns Claude can reuse instead of reinventing every time
+
+---
+
+## Who Is This For?
+
+This plugin is for anyone using Claude Code who wants:
+- Consistent, repeatable results on complex projects
+- Claude to remember what it was doing between sessions
+- Code that gets reviewed and verified, not just written
+
+**No prior experience with orchestration or AI agents required.**
+
+
+
+Introducing Dominion Flow: Elevate Your Claude Code Workflow
+
+Are you using Claude Code to build projects but feeling limited by session-hopping, lack of structure, or the need to constantly re-explain your requirements? Dominion Flow is a project management and orchestration plugin built to transform Claude from a simple assistant into a structured, persistent, and highly capable autonomous development agent.
+What is Dominion Flow?
+
+Dominion Flow acts as a professional-grade "operating system" inside your terminal. It introduces a formal, repeatable pipeline—Plan → Execute → Verify → Handoff—that ensures your project moves from an idea to working, verified code without skipping critical steps.
+Why Use It?
+
+    Persistent Memory: Through integrated vector database support (Qdrant), Dominion Flow allows Claude to remember your codebase, past decisions, and coding patterns across different sessions.
+
+    Structured Pipeline: Stop guessing where to start. The platform uses a clear, 39-command framework to guide you through every phase of development.
+
+    Quality & Verification: Built-in quality gates and automated testing (including Playwright E2E testing) ensure that code isn't just written—it's verified.
+
+    Autonomous Capabilities: Need to go hands-off? Features like /fire-autonomous allow Claude to plan, code, and verify entire project phases on its own.
+
+    Reusable Skills Library: Stop reinventing the wheel. Dominion Flow includes a library of proven, reusable patterns for authentication, APIs, payments, and more, which Claude can automatically learn and store as you build.
+
+Who Is It For?
+
+Whether you are a developer looking for a consistent, professional workflow or someone who wants to maximize the potential of Claude Code, Dominion Flow provides the structure and "long-term memory" required for complex, real-world projects.
+How to Get Started
+
+Dominion Flow is designed to be easily installed as a Claude Code plugin. Simply clone the repository and run the installation command:
+Bash
+
+git clone https://github.com/ThierryN/fire-flow.git
+claude install-plugin ./fire-flow
+
+For advanced users, the repository also supports optional "Power Features" like Docker-integrated memory (Qdrant) and local embeddings (Ollama) to make the agent even more powerful.
+
+
+
+---
+
+## Quick Install
+
+**Prerequisite:** You need [Claude Code](https://claude.ai/download) installed first. If you don't have it yet, download and install it, then come back here.
+
+Choose either Method A (recommended) or Method B:
+
+---
+
+### Method A — Git Clone (Recommended)
+
+1. Open your terminal and clone the repo:
+   ```bash
+   git clone https://github.com/ThierryN/fire-flow.git
+   ```
+
+2. Install the plugin from the cloned folder:
+   ```bash
+   claude install-plugin ./fire-flow
+   ```
+
+3. Restart Claude Code
+
+4. Type `/fire-0-orient` to check that everything is working
+
+---
+
+### Method B — Download ZIP (No Git Required)
+
+1. Go to [github.com/ThierryN/fire-flow](https://github.com/ThierryN/fire-flow)
+2. Click the green **"Code"** button → **"Download ZIP"**
+3. Extract the ZIP file to a folder you will keep (e.g., `Documents/fire-flow`)
+4. Open your terminal and install the plugin from that folder:
+
+   **Mac / Linux:**
+   ```bash
+   claude install-plugin ~/Documents/fire-flow
+   ```
+
+   **Windows:**
+   ```bash
+   claude install-plugin C:\Users\YourName\Documents\fire-flow
+   ```
+   *(Replace `YourName` with your actual Windows username)*
+
+5. Restart Claude Code
+
+6. Type `/fire-0-orient` to check that everything is working
+
+---
+
+## Optional but Recommended: Power Features
+
+The core workflow works out of the box. These extras unlock **persistent memory**, **codebase search**, and **Docker Hub access** — features that make Claude dramatically more capable on larger projects.
+
+---
+
+### Step 1 — Install Docker Desktop
+
+Docker Desktop is required to run Qdrant. Install it before anything else.
+
+**Windows (PC):**
+
+1. Go to [docker.com/products/docker-desktop](https://www.docker.com/products/docker-desktop/) and click **Download for Windows**
+2. Before running the installer, open **PowerShell as Administrator** and run:
+   ```powershell
+   wsl --update
+   wsl --set-default-version 2
+   ```
+3. Restart your computer
+4. Run the Docker installer and choose **"Use WSL 2 instead of Hyper-V"** when prompted
+5. After install, open Docker Desktop from your Start menu and wait for it to fully start (the whale icon in your taskbar stops animating)
+6. Verify it worked:
+   ```bash
+   docker --version
+   ```
+
+**Mac:**
+
+1. Go to [docker.com/products/docker-desktop](https://www.docker.com/products/docker-desktop/) and click **Download for Mac**
+   - Choose **Apple Chip** if you have an M1/M2/M3/M4 Mac, or **Intel Chip** for older Macs
+   - Not sure which? Click Apple menu → **About This Mac**
+2. Open the `.dmg` file and drag Docker to your Applications folder
+3. Open Docker from Applications and follow the prompts
+4. Wait for it to fully start (whale icon in menu bar stops animating)
+5. Verify it worked:
+   ```bash
+   docker --version
+   ```
+
+> Docker Desktop must be **open and running** whenever you use Qdrant or hub-mcp.
+
+---
+
+### Step 2 — Run Qdrant (Vector Database)
+
+Qdrant stores Claude's persistent memory across sessions — so Claude remembers your codebase, past decisions, and patterns from previous work.
+
+```bash
+docker pull qdrant/qdrant
+```
+
+```bash
+docker run -d \
+  -p 6333:6333 \
+  -p 6334:6334 \
+  -v qdrant_storage:/qdrant/storage \
+  --name qdrant \
+  qdrant/qdrant
+```
+
+| Port | What it is |
+|------|-----------|
+| **6333** | REST API — main port used by Claude |
+| **6334** | gRPC — high-speed operations |
+
+**Verify:** Open [http://localhost:6333/dashboard](http://localhost:6333/dashboard) in your browser. If you see the Qdrant dashboard, it is running.
+
+---
+
+### Step 3 — Connect Qdrant to Claude (MCP)
+
+This is what allows Claude to read and write to your `power_flow_memory` database.
+
+**Mac or WSL:**
+```bash
+claude mcp add qdrant -s user -- uvx mcp-server-qdrant \
+  --url http://localhost:6333 \
+  --collection-name power_flow_memory
+```
+
+**Windows (CMD or PowerShell):**
+```bash
+claude mcp add qdrant -s user -- cmd /c uvx mcp-server-qdrant \
+  --url http://localhost:6333 \
+  --collection-name power_flow_memory
+```
+
+---
+
+### Step 4 — Install Ollama (Local Embeddings)
+
+Ollama runs locally and generates the vectors that get stored in Qdrant.
+
+1. Download and install from [ollama.com](https://ollama.com)
+2. Pull the embedding model:
+   ```bash
+   ollama pull nomic-embed-text
+   ```
+
+---
+
+### Step 5 — Run Docker Hub MCP Server (hub-mcp)
+
+hub-mcp lets Claude search Docker Hub, browse images and tags, and pull images by just asking.
+
+```bash
+docker pull docker/hub-mcp
+```
+
+```bash
+docker run -d \
+  -p 8080:8080 \
+  --name hub-mcp \
+  docker/hub-mcp
+```
+
+Connect to Claude Code:
+
+```bash
+claude mcp add hub-docker -s user --transport sse http://localhost:8080/sse
+```
+
+> If port 8080 is already in use on your machine, change the left port number (e.g., `-p 9090:8080`) and update the URL to match (e.g., `http://localhost:9090/sse`).
+
+---
+
+### Verify Everything Is Connected
+
+Restart Claude Code, then type `/mcp`. You should see:
+
+| Server | What it does |
+|--------|-------------|
+| `qdrant` | Claude ↔ `power_flow_memory` database |
+| `hub-docker` | Claude ↔ Docker Hub image search |
+
+Then ask Claude to confirm the database connection:
+
+> *"Check if my Qdrant power_flow_memory collection is reachable and tell me how many points are stored."*
+
+Claude will query Qdrant directly and confirm it is live.
+
+---
+
+## Your First Project (5 Minutes)
+
+Start a new project with one command:
+
+```bash
+/fire-1-new
+```
+
+Claude will ask you a few simple questions about your project, then set everything up automatically. After that, the numbered commands walk you through each step:
+
+```
+/fire-1-new      → Start your project (asks you questions, creates the plan)
+/fire-2-plan 1   → Plan the first phase of work
+/fire-3-execute 1 → Build it (Claude does the coding)
+/fire-4-verify 1  → Check that everything actually works
+/fire-5-handoff   → Save your progress before closing
+/fire-6-resume    → Pick up where you left off next session
+```
+
+**Want Claude to handle everything automatically?**
+After `/fire-1-new`, just run:
+```bash
+/fire-autonomous
+```
+Claude will plan, build, and verify every phase without you having to type each command.
+
+---
+
+## How Does It Compare?
+
+![Feature Comparison](./docs/feature-comparison.png)
+
+## Key Features
+
+| Feature | What It Does |
+|---------|-------------|
+| 42 slash commands | Every task has a dedicated command — no guessing |
+| Skills library | Proven patterns for auth, payments, APIs, and more |
+| Breath-based parallelism | Independent tasks run at the same time |
+| 70-point verification | Every phase gets scored before moving on |
+| Session handoffs | Claude remembers everything between sessions |
+| Circuit breaker | Stops loops that are stuck or going in circles |
+| Auto skill extraction | Useful patterns discovered during work get saved automatically |
+| Playwright E2E testing | Automated browser testing built in |
+| Learncoding mode | Walk through any codebase step-by-step to learn it |
+| Security scanning | Detect prompt injection, OWASP vulnerabilities, credential leaks |
+
+---
+
+## All 39 Commands
+
+Commands are grouped into 7 tiers. You only need Tier 1 for most projects.
+
+| Tier | Purpose | Key Commands |
+|------|---------|-------------|
+| 1 — Core Workflow | The main pipeline | `/fire-1-new` through `/fire-6-resume` |
+| 2 — Autonomous | Full autopilot | `/fire-autonomous`, `/fire-loop` |
+| 3 — Debug & Discover | Investigate problems | `/fire-debug`, `/fire-map-codebase` |
+| 4 — Verification | Quality gates | `/fire-7-review`, `/fire-verify-uat` |
+| 5 — Skills | Manage the pattern library | `/fire-search`, `/fire-add-new-skill` |
+| 6 — Analytics & PM | Track progress | `/fire-dashboard`, `/fire-todos` |
+| 7 — Milestones | Long-term projects | `/fire-new-milestone`, `/fire-complete-milestone` |
+
+See [COMMAND-REFERENCE.md](./COMMAND-REFERENCE.md) for the complete list with descriptions.
+
+---
+
+## Finding More Skills
+
+The skills library is what makes Dominion Flow powerful. Skills are reusable patterns that Claude draws on during your project — for auth, payments, APIs, database design, testing, and much more.
+
+**Where to find skills:**
+
+- [aitmpl.com/skills](https://www.aitmpl.com/skills) — Curated skill collections, ready to install
+- [skillsmp.com](https://skillsmp.com/) — Community skill marketplace
+- GitHub — Search for `claude-code-skills` or `dominion-flow-skills` to find repos shared by the community
+
+**Installing skills from GitHub:**
+```bash
+claude plugin install <github-username>/<repo-name>
+```
+
+You can also create your own skills as you work. When Claude discovers a useful pattern, `/fire-add-new-skill` saves it to your library automatically.
+
+---
+
+## Documentation
+
+| File | What It Covers |
+|------|---------------|
+| [QUICK-START.md](./QUICK-START.md) | Step-by-step walkthrough of your first project |
+| [COMMAND-REFERENCE.md](./COMMAND-REFERENCE.md) | All 39 commands with descriptions |
+| [references/warrior-principles.md](./references/warrior-principles.md) | The WARRIOR operating principles — what they are and why they matter |
+| [DOMINION-FLOW-OVERVIEW.md](./DOMINION-FLOW-OVERVIEW.md) | Full system diagrams and architecture |
+| [ARCHITECTURE-DIAGRAM.md](./ARCHITECTURE-DIAGRAM.md) | Visual overview of how everything connects |
+| [TROUBLESHOOTING.md](./TROUBLESHOOTING.md) | Common problems and how to fix them |
+
+---
+
+## Community
+
+Have questions, want to share what you built, or just want to connect with others learning Claude Code?
+
+**Join the Facebook group:** [Claude Code Community](https://www.facebook.com/groups/1671431084311638)
+
+This is where students and followers ask questions, share projects, and stay up to date.
+
+---
+
+## Support This Project
+
+If you're following along and finding Dominion Flow useful, the best way to help is simple:
+
+- **Star this repo** — it helps others discover it
+- **Share it** — pass it along to anyone learning Claude Code or building AI-assisted projects
+
+This is a living project. Your support keeps it growing.
+
+---
+
+## Architecture Diagram
+
+![Dominion Flow Architecture](./docs/dominion-flow-architecture.png)
+
+View the full interactive version: **[Dominion Flow Architecture (HTML)](./docs/dominion-flow-architecture.html)** — Download and open in your browser to explore with interactive navigation.
+
+---
+
+## License
+
+MIT License — Copyright (c) 2026 ThierryN
+
+This software is free to use, copy, modify, and distribute. See [LICENSE](./LICENSE) for the full text.
+
+
+
+
+
+

package/TROUBLESHOOTING.md

@@ -0,0 +1,264 @@
+# Dominion Flow Troubleshooting Guide
+
+Common failure modes and their fixes.
+
+---
+
+## 1. Autonomous mode won't stop
+
+**Symptoms:**
+- `/fire-autonomous` or `/fire-loop` continues iterating past the point of usefulness
+- Agent ignores Sabbath Rest warnings and keeps working
+- Iteration count climbing with no meaningful progress
+
+**Likely Cause:**
+- `--max-iterations` set too high (default 50)
+- `--no-circuit-breaker` flag was passed, disabling the safety net
+- Completion promise text doesn't match actual output (e.g., "DONE" vs "Done")
+
+**Fix Steps:**
+1. Press `Ctrl+C` to interrupt the current iteration
+2. Run `/fire-loop-stop` to formally end the loop and save state
+3. Check `.planning/loops/fire-loop-*.md` for the loop state file
+4. Review the "Approaches Tried" section to see what was attempted
+
+**Prevention:**
+- Use `--max-iterations 20` for most tasks (30 max for complex work)
+- Never use `--no-circuit-breaker` unless you're monitoring closely
+- Write precise completion promises: `--completion-promise "ALL TESTS PASS"`
+- Use `--aggressive` for tighter stall/spin detection thresholds
+
+---
+
+## 2. Wrong files modified
+
+**Symptoms:**
+- Files in a different project were edited by a subagent
+- Changes landed in the wrong directory
+- Cross-project contamination (e.g., editing `my-other-project` instead of `my-project`)
+
+**Likely Cause:**
+- Working directory didn't match the project in CONSCIENCE.md
+- Subagent resolved a relative path to the wrong project
+- Multiple project directories open in the same session
+
+**Fix Steps:**
+1. Run `git diff` in the affected project to see what changed
+2. Run `git checkout -- .` to revert unwanted changes (or `git stash` to save them)
+3. Check CONSCIENCE.md -- does it reference the correct project path?
+4. Verify `pwd` matches the expected project root before re-running
+
+**Prevention:**
+- The Path Verification Gate (Step 3.5 in `/fire-3-execute`) catches this automatically
+- Always use absolute paths when working across multiple projects
+- Run `/fire-0-orient` at session start to confirm you're in the right place
+- When spawning subagents, the `<path_constraint>` block is injected automatically -- verify it matches
+
+---
+
+## 3. Memory features not working
+
+**Symptoms:**
+- Episodic memory injection (Step 7.1 in `/fire-loop`) returns no results
+- `/fire-reflect` can't search past reflections
+- "Connection refused" errors mentioning port 6335
+
+**Likely Cause:**
+- Qdrant is not running (native binary at `C:\path\to\qdrant\qdrant.exe`)
+- Qdrant is running but on the wrong port (6333 = Docker backup, 6335 = native primary)
+- Ollama embedding service is down (needed for `nomic-embed-text` 768d vectors)
+
+**Fix Steps:**
+1. Check Qdrant health: `curl http://localhost:6335/healthz`
+2. If down, start it: `C:\path\to\qdrant\qdrant.exe` (runs on port 6335)
+3. Check Ollama: `curl http://localhost:11434/api/tags`
+4. If Ollama is down: `ollama serve` in a separate terminal
+5. Verify the collection exists: `curl http://localhost:6335/collections/power_flow_memory`
+
+**Prevention:**
+- Dominion Flow degrades gracefully: if Qdrant is unreachable, it falls back to file-based search across `~/.claude/warrior-handoffs/` and `~/.claude/reflections/`
+- The file-based fallback is slower but functional -- memory retrieval is never silently skipped
+- Add Qdrant to your system startup if you use memory features regularly
+
+---
+
+## 4. Verification always fails
+
+**Symptoms:**
+- `/fire-4-verify` consistently returns REJECTED or CONDITIONAL
+- Score stuck below 49 even for seemingly complete work
+- E2E (Playwright) category drags the score down on non-UI projects
+
+**Likely Cause:**
+- The 70-point checklist includes 10 points for E2E/Playwright testing -- irrelevant for CLI, API-only, or library projects
+- Documentation category (10 points) penalizes when README/JSDoc isn't written yet
+- Validation thresholds: 63-70 = APPROVED, 56-62 = APPROVED*, 49-55 = CONDITIONAL, <42 = REJECTED
+
+**Fix Steps:**
+1. Check `.planning/phases/{N}-{name}/{N}-VERIFICATION.md` for the breakdown
+2. Identify which categories are scoring zero
+3. For non-UI projects: the E2E category should be redistributed to other categories by the verifier -- if it isn't, note this as a configuration issue
+4. Focus on the must-haves first: if all must-haves pass, CONDITIONAL is often acceptable for early phases
+
+**Prevention:**
+- Run `/fire-4-verify` with awareness of what the 7 categories are: Code Quality /10, Testing /10, Security /10, Performance /10, Documentation /10, Infrastructure /10, E2E /10
+- For API-only projects, tell the verifier in the plan: "No E2E -- redistribute points to Testing and Security"
+- Use `/fire-double-check` for a quick sanity check before the full 70-point verification
+
+---
+
+## 5. Plans executed in wrong order
+
+**Symptoms:**
+- Breath 2 tasks fail because Breath 1 outputs don't exist yet
+- Tasks with dependencies execute before their dependencies complete
+- File conflicts between parallel executors
+
+**Likely Cause:**
+- `breath:` frontmatter in BLUEPRINT.md files is incorrectly assigned
+- `depends_on:` field missing or wrong in the plan files
+- Execution mode selected PARALLEL when it should have been SEQUENTIAL (file overlap)
+
+**Fix Steps:**
+1. Open `.planning/phases/{N}-{name}/` and check each BLUEPRINT.md frontmatter
+2. Verify `breath:` numbers -- all tasks in Breath 1 should have no external dependencies
+3. Verify `depends_on:` lists reference only tasks in earlier breaths
+4. Re-run `/fire-2-plan {N}` to regenerate plans with correct breath assignment
+
+**Prevention:**
+- The planner agent validates breath assignments during `/fire-2-plan`
+- `/fire-3-execute` auto-detects file overlap and downgrades from PARALLEL to SEQUENTIAL
+- Review the execution manifest at Step 2 before proceeding
+
+---
+
+## 6. Context window filling up fast
+
+**Symptoms:**
+- Claude starts forgetting earlier instructions mid-session
+- Output quality degrades after 10-15 iterations
+- Sabbath Rest triggers repeatedly at low iteration counts
+
+**Likely Cause:**
+- Large files loaded into context (reading entire source files instead of relevant sections)
+- Skills library injecting too many skills per iteration (max should be 3)
+- No `.powerignore` file to exclude noise (node_modules, build artifacts, etc.)
+
+**Fix Steps:**
+1. Run `/compact` with a focus topic: `/compact Focus on phase 3 execution`
+2. Delegate research tasks to subagents instead of doing them in the main context
+3. Create a `.powerignore` file in the project root listing directories to exclude
+4. For `/fire-loop`: if iteration > 15, accept the Sabbath Rest and `/fire-loop-resume` in a fresh context
+
+**Prevention:**
+- Keep iteration output concise -- the recitation block is capped at 30 lines for a reason
+- Use `/fire-search` to find relevant skills BEFORE starting work (don't search mid-loop)
+- Read only the relevant sections of large files (use line offsets)
+- After 2 failed approaches, `/clear` and restart with the lessons learned
+
+---
+
+## 7. Agent spawns fail
+
+**Symptoms:**
+- "Agent definition not found" error when running `/fire-3-execute` or `/fire-7-review`
+- Subagent starts but immediately errors out
+- SWARM mode fails to create team members
+
+**Likely Cause:**
+- Agent definition file missing from `agents/` directory
+- Agent file has incorrect frontmatter (missing `name:` or `description:`)
+- Agent's `tools:` list references unavailable tools
+
+**Fix Steps:**
+1. Check that all agent files exist: `ls ~/.claude/plugins/dominion-flow/agents/`
+2. Expected files: `fire-executor.md`, `fire-planner.md`, `fire-researcher.md`, `fire-verifier.md`, `fire-reviewer.md`
+3. Verify each file has valid YAML frontmatter with `name:` and `description:`
+4. If a file is missing, run `/fire-update` to pull the latest plugin version
+
+**Prevention:**
+- Don't manually edit agent files unless you know the frontmatter schema
+- After updating the plugin, verify agents: `ls ~/.claude/plugins/dominion-flow/agents/`
+- SWARM mode requires the experimental teams flag: `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`
+
+---
+
+## 8. Skills not found
+
+**Symptoms:**
+- `/fire-search` returns no results for queries that should match
+- Planner agent says "no relevant skills found" during `/fire-2-plan`
+- Skills referenced in plans don't exist at the expected path
+
+**Likely Cause:**
+- Skills library path misconfigured or missing
+- Project-local skills out of sync with global library
+- Skill was deleted or moved to a different category
+
+**Fix Steps:**
+1. Check the skills library exists: `ls ~/.claude/plugins/dominion-flow/skills-library/`
+2. Run `/fire-skills-sync --pull` to pull latest skills from global to project
+3. Run `/fire-skills-sync --dry-run` to see what's out of sync
+4. If a specific skill is missing, search by keyword: `/fire-search "{topic}"`
+
+**Prevention:**
+- Run `/fire-skills-sync --pull` at the start of each major session
+- After contributing a new skill, verify it appears: `/fire-search "{skill name}"`
+- Keep skills in their correct category directory -- don't move them manually
+
+---
+
+## 9. Circuit breaker tripped
+
+**Symptoms:**
+- Loop stops with "CIRCUIT BREAK" banner
+- State shows SPINNING or STALLED or DEGRADED
+- Message: "Error seen N times. Previous approaches: {list}"
+
+**Likely Cause:**
+- **STALLED:** No file changes for 3+ iterations -- agent is reading/thinking but not acting
+- **SPINNING:** Same error hash repeated 4+ times -- agent retrying the same failed approach
+- **DEGRADED:** Output volume declining 50%+ from baseline -- context rot setting in
+
+**Fix Steps:**
+1. Read the loop state file: `.planning/loops/fire-loop-{ID}.md`
+2. Check the "Approaches Tried" section -- these are what NOT to repeat
+3. For STALLED: the fix is usually to try a fundamentally different approach
+4. For SPINNING: read the error carefully -- the repeated error hash tells you exactly what's failing
+5. For DEGRADED: accept the Sabbath Rest, `/clear`, then `/fire-loop-resume {ID}`
+
+**Prevention:**
+- Use `--aggressive` for tasks where you expect quick resolution (tighter thresholds)
+- Write clear completion criteria so the loop knows when it's done
+- Trust the circuit breaker -- forcing through a tripped breaker wastes iterations
+- After a trip, always read the loop file before resuming to understand what was tried
+
+---
+
+## 10. Handoff incomplete
+
+**Symptoms:**
+- `/fire-6-resume` can't find a handoff file or shows stale data
+- Handoff missing key sections (blockers, in-progress work, skills applied)
+- Next session agent doesn't have enough context to continue
+
+**Likely Cause:**
+- `/fire-5-handoff` wasn't run before ending the session
+- Handoff was created but CONSCIENCE.md was out of date at the time
+- Session ended abruptly (crash, Ctrl+C) before handoff could complete
+
+**Fix Steps:**
+1. Run `/fire-5-handoff` manually to create a fresh handoff from current state
+2. Check `.planning/` for any `POWER-HANDOFF-*.md` files -- there may be a partial one
+3. If CONSCIENCE.md is stale, update it manually with current phase status
+4. Verify the handoff follows WARRIOR 7-step format: What / Accomplished / Remaining / Resources / Issues / Observations / Recommendations
+
+**Prevention:**
+- Always run `/fire-5-handoff` before ending a session -- make it a habit
+- The `stop-verify.js` hook warns if tasks are incomplete when you exit
+- For long sessions, create intermediate handoffs every 2-3 hours
+- If using `/fire-loop`, the Sabbath Rest snapshot serves as an automatic partial handoff
+
+---
+
+*If your issue isn't listed here, check the references directory for detailed protocol documentation, or run `/fire-debug` to systematically investigate.*