@thierrynakoa/fire-flow 10.0.0

package/commands/fire-6-resume.md

@@ -0,0 +1,501 @@
+---
+description: Resume from previous session handoff with full context restoration
+---
+
+# /fire-6-resume
+
+> Resume work from most recent handoff with full context restoration
+
+---
+
+## Purpose
+
+Resume a project from a previous session by loading the most recent WARRIOR handoff file, displaying a comprehensive status summary, checking for incomplete work, and routing to the appropriate next action. This command ensures zero context loss between sessions.
+
+---
+
+## Arguments
+
+```yaml
+arguments: none
+
+optional_flags:
+  --handoff: "Specify handoff file to load (e.g., --handoff project_2026-01-20.md)"
+  --list: "List available handoffs without loading"
+  --diff: "Show changes since last handoff"
+```
+
+---
+
+## Process
+
+### Step 1: Find Most Recent Handoff
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+                         DOMINION FLOW > SESSION RESUME
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+**Scan Handoff Directory:**
+```bash
+ls -t ~/.claude/warrior-handoffs/*.md | head -5
+```
+
+**If `--list` flag:**
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ AVAILABLE HANDOFFS                                                          │
+├─────────────────────────────────────────────────────────────────────────────┤
+│                                                                             │
+│  Recent handoffs (newest first):                                            │
+│                                                                             │
+│  1. my-project_2026-01-22.md (2 hours ago)                                │
+│     Phase 3 - Pattern Computation | Status: Executing                       │
+│                                                                             │
+│  2. my-project_2026-01-21.md (1 day ago)                                  │
+│     Phase 2 - Typology | Status: Complete                                   │
+│                                                                             │
+│  3. book-writer-app_2026-01-20.md (2 days ago)                              │
+│     Phase 4 - Export | Status: Verifying                                    │
+│                                                                             │
+│  Load specific handoff: /fire-6-resume --handoff {filename}                │
+│                                                                             │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+**Select Handoff:**
+- Use most recent if no `--handoff` flag
+- Use specified file if `--handoff` provided
+- Error if no handoffs found
+
+### Step 2: Load Handoff Content
+
+**Read Handoff File:**
+```markdown
+@~/.claude/warrior-handoffs/{selected_handoff}.md
+```
+
+**Extract from Frontmatter:**
+```yaml
+project: {name}
+session_date: {date}
+phase: {number}
+status: {status}
+next_action: {action}
+```
+
+**Extract from WARRIOR Sections:**
+- **W (Work):** What was completed
+- **A (Assessment):** Current state
+- **R (Resources):** Required env/credentials
+- **R (Readiness):** What's ready/blocked
+- **I (Issues):** Known problems
+- **O (Outlook):** Recommended next steps
+- **R (References):** Skills, commits, docs
+
+### Step 2.5: SDFT On-Policy Self-Distillation (v5.0)
+
+> **Research basis:** Self-Distillation Fine-Tuning (MIT, Shenfeld et al., 2026)
+> — on-policy learning outperforms off-policy by 7 points at 14B params.
+
+**Before reading the full W (Work) section, PREDICT first:**
+
+After extracting the frontmatter (project, phase, status) but BEFORE reading
+the detailed work items:
+
+1. **Predict:** Given this phase name and its description from the roadmap,
+   what work would I expect was completed? What challenges would I anticipate?
+
+2. **Read:** Now read the full W (Work) and I (Issues) sections.
+
+3. **Compare:** Note where predictions matched reality (reinforced knowledge)
+   and where they diverged (learning signal).
+
+```
+SDFT Check:
+  Predicted: {brief prediction}
+  Reality:   {brief actual}
+  Signal:    {matched | surprised | missed}
+```
+
+**If 2+ surprises:** Flag for reflection capture after resumption is complete.
+
+**Skip condition:** If `--quick` flag or if this is a same-day resumption
+(handoff < 4 hours old), skip SDFT — context is still fresh.
+
+### Step 2.75: Security Scan on Resume (v5.0)
+
+> **Defense basis:** OWASP ASI04 (Supply Chain Vulnerabilities), OpenClaw/ClawdBot incident (2025)
+> — malicious skill instructions injected to collect API keys at 2 AM.
+
+**On every session resume, run a quick security sweep of the project's trust surface:**
+
+1. **Scan any NEW or MODIFIED skills** since the last handoff date:
+   ```
+   Check: ~/.claude/plugins/*/skills-library/**/*.md
+   Filter: modified after {handoff_date}
+   Mode: quick (Layers 1-5 only)
+   ```
+
+2. **Scan any NEW or MODIFIED plugin files:**
+   ```
+   Check: ~/.claude/plugins/*/commands/*.md, hooks/*.json, hooks/*.sh
+   Filter: modified after {handoff_date}
+   Mode: quick
+   ```
+
+3. **Check loaded MCP tools** for poisoning indicators:
+   ```
+   If MCP tools are loaded in this session:
+     Scan tool descriptions for invisible chars, injection, exfiltration URLs
+     Mode: quick (Layer 1 + Layer 5)
+   ```
+
+**Output:**
+```
+SECURITY SWEEP (resume):
+  Skills scanned: {N new/modified}  ... {CLEAN | N findings}
+  Plugins scanned: {N new/modified} ... {CLEAN | N findings}
+  MCP tools: {N loaded}             ... {CLEAN | N findings}
+  Verdict: {CLEAN | REVIEW NEEDED}
+```
+
+**If CLEAN:** Proceed silently (just the one-line summary above).
+
+**If findings detected:**
+```
+Use AskUserQuestion:
+  header: "Security"
+  question: "Security sweep found {N} issues since last session. Review now?"
+  options:
+    - "Show details" - Display all findings
+    - "Continue anyway" - Accept risk
+    - "Full scan" - Run /fire-security-scan --all-skills --all-plugins --deep
+```
+
+**Skip condition:** If `--quick` flag is set, skip security sweep (user accepts risk).
+
+### Step 2.8: Load Behavioral Directives (v6.0)
+
+> **Research basis:** CoALA procedural memory + SICA self-modifying agent (ICLR 2025). Active rules guide behavior; proposed rules await confirmation.
+
+```
+1. Read references/behavioral-directives.md
+2. Extract Active Rules (confidence 3+/5)
+3. Synthesize into a concise behavioral reminder:
+
+   <behavioral_directives>
+   Active rules for this session:
+   - {Rule 1}
+   - {Rule 2}
+   - ...
+   Proposed rules (watch for confirmation opportunities):
+   - {Proposed rule 1} (confidence: {N}/5)
+   </behavioral_directives>
+
+4. Inject into working context (silent — no display to user)
+```
+
+**Why silent:** Directives are internalized behavior, not status information. They guide the agent's decisions without cluttering the resume display.
+
+**Skip condition:** If `--quick` flag is set, still load directives (they're tiny and high-value).
+
+### Step 3: Display Project Status Summary
+
+```
+╔══════════════════════════════════════════════════════════════════════════════╗
+║ ⚡ RESUMING: {Project Name}                                                   ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║                                                                              ║
+║  Last Session: {date} ({time ago})                                           ║
+║  Duration: {X} hours                                                         ║
+║  Phase: {N} - {name}                                                         ║
+║  Status: {status}                                                            ║
+║                                                                              ║
+║  Progress: ████████████░░░░░░░░ {X}%                                         ║
+║                                                                              ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║ LAST SESSION SUMMARY                                                         ║
+├──────────────────────────────────────────────────────────────────────────────┤
+║                                                                              ║
+║  Completed:                                                                  ║
+║    ✓ {Work item 1}                                                           ║
+║    ✓ {Work item 2}                                                           ║
+║                                                                              ║
+║  In Progress:                                                                ║
+║    ◆ {Partial work} ({X}% complete)                                          ║
+║                                                                              ║
+║  Blocked:                                                                    ║
+║    ✗ {Blocker description}                                                   ║
+║                                                                              ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║ SKILLS APPLIED                                                               ║
+├──────────────────────────────────────────────────────────────────────────────┤
+║                                                                              ║
+║  This project has used {X} skills from the library:                          ║
+║    • {category/skill-1} (Phase {N})                                          ║
+║    • {category/skill-2} (Phase {N})                                          ║
+║                                                                              ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+```
+
+### Step 4: Check for Incomplete Work
+
+**Scan for .continue-here.md files:**
+```bash
+find .planning/phases/ -name ".continue-here.md"
+```
+
+**If Found:**
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ ⚠ INCOMPLETE WORK DETECTED                                                  │
+├─────────────────────────────────────────────────────────────────────────────┤
+│                                                                             │
+│  Found interrupted execution:                                               │
+│                                                                             │
+│  File: .planning/phases/{N}-{name}/.continue-here.md                        │
+│                                                                             │
+│  Context:                                                                   │
+│    Plan: {N}-{NN}                                                           │
+│    Task: {task number}                                                      │
+│    Stopped: {reason}                                                        │
+│                                                                             │
+│  Recommendation: Resume execution with --continue flag                      │
+│                                                                             │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+**Check CONSCIENCE.md for Current Position:**
+```markdown
+@.planning/CONSCIENCE.md
+```
+
+**Determine Incomplete Work:**
+- Plans started but not completed
+- Phases started but not verified
+- Verification gaps not addressed
+
+### Step 5: Route to Appropriate Next Action
+
+**Routing Logic:**
+
+```
+IF .continue-here.md exists:
+  → Route to: /fire-3-execute {phase} --continue
+  → Message: "Resuming interrupted execution"
+
+ELSE IF phase status == "Executing":
+  → Route to: /fire-3-execute {phase}
+  → Message: "Continuing phase execution"
+
+ELSE IF phase status == "Executed" (not verified):
+  → Route to: /fire-4-verify {phase}
+  → Message: "Phase ready for verification"
+
+ELSE IF phase status == "Verified with gaps":
+  → Route to: /fire-2-plan {phase} --gaps
+  → Message: "Planning gap closure"
+
+ELSE IF phase status == "Complete":
+  → Route to: /fire-2-plan {next_phase}
+  → Message: "Ready to plan next phase"
+
+ELSE IF phase status == "Ready to plan":
+  → Route to: /fire-2-plan {phase}
+  → Message: "Ready to create plans"
+
+ELSE:
+  → Display options menu
+```
+
+### Step 6: Display Routing Decision
+
+```
+╔══════════════════════════════════════════════════════════════════════════════╗
+║ RECOMMENDED ACTION                                                           ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║                                                                              ║
+║  Based on project state, you should:                                         ║
+║                                                                              ║
+║  → {Recommended command and description}                                     ║
+║                                                                              ║
+║  Reason: {Why this is the recommended action}                                ║
+║                                                                              ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║ OTHER OPTIONS                                                                ║
+├──────────────────────────────────────────────────────────────────────────────┤
+║                                                                              ║
+║  [1] /fire-dashboard        - View detailed project status                  ║
+║  [2] /fire-3-execute {N}    - Continue phase execution                      ║
+║  [3] /fire-4-verify {N}     - Verify current phase                          ║
+║  [4] /fire-2-plan {N+1}     - Plan next phase                               ║
+║  [5] /fire-search [query]   - Search skills library                         ║
+║                                                                              ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+```
+
+### Step 7: Update CONSCIENCE.md with Resumption
+
+**Add Resumption Entry:**
+```markdown
+## Session Continuity
+- Last session: {previous timestamp}
+- Resumed: {current timestamp}
+- Handoff loaded: {handoff filename}
+- Status: Active
+```
+
+### Step 8: Display Key Resources (from Handoff)
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ KEY RESOURCES                                                               │
+├─────────────────────────────────────────────────────────────────────────────┤
+│                                                                             │
+│  Environment:                                                               │
+│    {Key env vars from handoff R-Resources section}                          │
+│                                                                             │
+│  Services:                                                                  │
+│    {Service status from handoff}                                            │
+│                                                                             │
+│  URLs:                                                                      │
+│    Local: {dev URL}                                                         │
+│    Docs: {docs URL}                                                         │
+│                                                                             │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+### Step 9: Display Known Issues (from Handoff)
+
+**If Issues Exist:**
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ ⚠ KNOWN ISSUES                                                              │
+├─────────────────────────────────────────────────────────────────────────────┤
+│                                                                             │
+│  From last session:                                                         │
+│    • {Issue 1} - {severity}                                                 │
+│    • {Issue 2} - {severity}                                                 │
+│                                                                             │
+│  Technical Debt:                                                            │
+│    • {Debt item 1} - deferred to Phase {N}                                  │
+│                                                                             │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Agent Spawning
+
+This command does NOT spawn agents. It loads context and provides routing recommendations.
+
+---
+
+## Success Criteria
+
+### Required Outputs
+- [ ] Handoff file loaded and parsed
+- [ ] Project status summary displayed
+- [ ] Incomplete work detected (if any)
+- [ ] Appropriate next action routed
+- [ ] CONSCIENCE.md updated with resumption timestamp
+- [ ] Key resources and issues displayed
+
+### Context Restoration Checklist
+- [ ] Project name and core value known
+- [ ] Current phase and status known
+- [ ] Last session work summary loaded
+- [ ] Skills applied tracked
+- [ ] Known issues surfaced
+- [ ] Next action clearly recommended
+
+---
+
+## Error Handling
+
+### No Handoffs Found
+
+```
+╔══════════════════════════════════════════════════════════════════════════════╗
+║ ⚠ NO HANDOFFS FOUND                                                          ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║                                                                              ║
+║  No handoff files found in ~/.claude/warrior-handoffs/                       ║
+║                                                                              ║
+║  Options:                                                                    ║
+║    A) Check if project exists: look for .planning/CONSCIENCE.md                   ║
+║    B) Initialize new project: /fire-1-new                                   ║
+║    C) Check handoff directory: ls ~/.claude/warrior-handoffs/                ║
+║                                                                              ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+```
+
+### Handoff File Corrupted
+
+```
+╔══════════════════════════════════════════════════════════════════════════════╗
+║ ✗ ERROR: Invalid Handoff File                                                ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║                                                                              ║
+║  File: {filename}                                                            ║
+║  Issue: {parsing error description}                                          ║
+║                                                                              ║
+║  Options:                                                                    ║
+║    A) Try older handoff: /fire-6-resume --list                              ║
+║    B) Load directly from CONSCIENCE.md (partial context)                          ║
+║                                                                              ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+```
+
+### Project Mismatch
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ ⚠ WARNING: Project Mismatch                                                 │
+├─────────────────────────────────────────────────────────────────────────────┤
+│                                                                             │
+│  Handoff project: {handoff_project}                                         │
+│  Current directory: {current_dir}                                           │
+│                                                                             │
+│  The handoff appears to be for a different project.                         │
+│                                                                             │
+│  Options:                                                                   │
+│    A) Continue anyway (handoff will provide context)                        │
+│    B) Change to correct directory: cd {expected_path}                       │
+│    C) Load different handoff: /fire-6-resume --list                        │
+│                                                                             │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+### CONSCIENCE.md Missing
+
+```
+╔══════════════════════════════════════════════════════════════════════════════╗
+║ ⚠ WARNING: CONSCIENCE.md Not Found                                                ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║                                                                              ║
+║  Handoff loaded but .planning/CONSCIENCE.md is missing.                           ║
+║                                                                              ║
+║  This may indicate:                                                          ║
+║    • Wrong directory                                                         ║
+║    • Project files moved                                                     ║
+║    • Incomplete project setup                                                ║
+║                                                                              ║
+║  Options:                                                                    ║
+║    A) Create CONSCIENCE.md from handoff context                                   ║
+║    B) Navigate to correct project directory                                  ║
+║    C) Initialize fresh: /fire-1-new                                         ║
+║                                                                              ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## References
+
+- **Handoff Location:** `~/.claude/warrior-handoffs/`
+- **State File:** `@.planning/CONSCIENCE.md`
+- **Protocol:** `@references/honesty-protocols.md` - WARRIOR foundation
+- **Brand:** `@references/ui-brand.md` - Visual output standards