rpi-kit 2.2.1 → 2.4.0

package/commands/rpi/docs.md

@@ -109,6 +109,15 @@ Rules:
 - Match existing documentation style and tone
 - Use concrete examples, not abstract descriptions
 - If the code says WHAT, the docs should say WHY
+
+After documentation updates, append your activity to rpi/features/{slug}/ACTIVITY.md:
+
+### {current_date} — Quill (Docs)
+- **Action:** Documentation updates for {slug}
+- **Key decisions:** {for each <decision> tag you emitted: "summary (rationale)", separated by semicolons. If none: "No decisions in this phase."}
+- **Files updated:** {list}
+- **Changelog entry:** {yes|no}
+- **Quality:** {your quality gate result}
 ```
 
 Store the output as `$QUILL_OUTPUT`.
@@ -124,7 +133,26 @@ Store the output as `$QUILL_OUTPUT`.
    git commit -m "docs({slug}): update documentation for {slug}"
    ```
 
-## Step 6: Output summary
+## Step 6: Consolidate decisions to DECISIONS.md
+
+1. Read `rpi/features/{slug}/ACTIVITY.md`.
+2. Extract all `<decision>` tags from entries belonging to the Docs phase (Quill entries from this run).
+3. If no decisions found, skip this step.
+4. Read `rpi/features/{slug}/DECISIONS.md` if it exists (to get the last decision number for sequential numbering).
+5. Append a new section to `rpi/features/{slug}/DECISIONS.md`:
+
+```markdown
+## Docs Phase
+_Generated: {current_date}_
+
+| # | Type | Decision | Alternatives | Rationale | Impact |
+|---|------|----------|-------------|-----------|--------|
+| {N} | {type} | {summary} | {alternatives} | {rationale} | {impact} |
+```
+
+6. Number decisions sequentially, continuing from the last number in DECISIONS.md.
+
+## Step 7: Output summary
 
 ```
 Documentation complete: {slug}

package/commands/rpi/fix.md

@@ -0,0 +1,301 @@
+---
+name: rpi:fix
+description: Quick bugfix — Luna interviews, Mestre plans (max 3 tasks), Forge implements. One command.
+argument-hint: "<bug-slug> [--resume] [--force]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+  - Agent
+  - AskUserQuestion
+---
+
+# /rpi:fix — Quick Bugfix
+
+Runs Luna → Mestre → Forge in one step for bugfixes. Creates compact artifacts with max 3 tasks. Each task generates a commit.
+
+---
+
+## Step 1: Load config and parse arguments
+
+1. Read `.rpi.yaml` for config. Apply defaults if missing:
+   - `folder`: `rpi/features`
+   - `context_file`: `rpi/context.md`
+   - `commit_style`: `conventional`
+2. Parse `$ARGUMENTS` to extract:
+   - `{slug}` — the bug name (required)
+   - `--resume`: continue from last completed task if IMPLEMENT.md exists
+   - `--force`: restart from scratch (overwrites existing artifacts)
+3. If `{slug}` is not provided, ask with AskUserQuestion: "What's the bug? Give it a short slug (e.g. 'login-crash', 'missing-validation')."
+4. Convert slug to kebab-case (lowercase, spaces/underscores become hyphens, strip special chars).
+
+## Step 2: Check for existing feature
+
+Check if `{folder}/{slug}/` already exists.
+
+If it exists and `--force` was NOT passed:
+- Check if `implement/IMPLEMENT.md` exists:
+  - If yes and `--resume` was passed (or default): skip to Step 6 (resume implementation).
+  - If yes and `--force` was NOT passed: ask the user: "Feature '{slug}' already exists. Resume implementation (--resume) or start over (--force)?"
+- If no IMPLEMENT.md: ask the user: "Feature '{slug}' already exists but implementation hasn't started. Overwrite? (yes/no)"
+
+If it exists and `--force` was passed: proceed (will overwrite).
+
+## Step 3: Create directory structure
+
+```bash
+mkdir -p {folder}/{slug}/plan
+mkdir -p {folder}/{slug}/implement
+```
+
+No `research/` directory. No `delta/` directories.
+
+## Step 4: Luna — Bugfix Interview
+
+Adopt Luna's persona. This is a bugfix interview — fast and focused.
+
+### If slug is descriptive (e.g. `login-crash`, `null-pointer-auth`):
+
+Ask one question with AskUserQuestion:
+> "Descreve o bug: o que acontece, o que deveria acontecer, e onde se manifesta (ficheiro, endpoint, componente — se souberes)."
+
+### If slug is vague (e.g. `fix1`, `bug`):
+
+Ask two questions with AskUserQuestion:
+> 1. "Qual é o bug?"
+> 2. "Onde se manifesta? (ficheiro, endpoint, componente — se souberes)"
+
+### Generate REQUEST.md
+
+Write `{folder}/{slug}/REQUEST.md`:
+
+```markdown
+# Fix: {slug}
+
+## Bug Report
+{bug description — what happens vs. what should happen}
+
+## Location
+{where it manifests — file, module, endpoint, or "Unknown"}
+
+## Constraints
+- {constraint if any, or "None identified"}
+
+## Unknowns
+- {at least one — e.g., "Root cause not confirmed"}
+
+## Complexity Estimate
+S — bugfix
+
+## Quick Flow
+This is a bugfix. Skipping research phase.
+```
+
+Output:
+```
+REQUEST.md created: {folder}/{slug}/REQUEST.md
+Starting plan phase...
+```
+
+## Step 5: Mestre — Compact Plan
+
+Launch Mestre agent with this prompt:
+
+```
+You are Mestre. Generate a compact bugfix plan for: {slug}
+
+## Bug Report (REQUEST.md)
+{content of REQUEST.md}
+
+## Project Context
+{content of context.md if it exists, otherwise "No project context file found."}
+
+## Instructions
+1. Read the files mentioned in the Location section of the bug report
+2. Analyze the probable root cause
+3. Generate a PLAN.md with maximum 3 tasks
+4. Each task must list exact files to change and dependencies
+5. Be surgical — only fix the bug, no refactoring, no improvements
+
+IMPORTANT: If you determine this bug needs more than 3 tasks, output ONLY:
+"ESCALATE: This bug is too complex for /rpi:fix. Use /rpi:new {slug} for the full pipeline."
+Do NOT generate a plan in this case.
+
+Output using this format:
+
+# Plan: Fix {slug}
+
+## Analysis
+{2-3 sentences — probable root cause, affected files}
+
+## Tasks
+
+### Task 1: {description}
+- Files: {files to change}
+- Deps: none
+
+### Task 2: {description}
+- Files: {files to change}
+- Deps: [1]
+
+## Risks
+- {if any, or "None — straightforward fix"}
+
+After generating the plan, append your activity to {folder}/{slug}/ACTIVITY.md:
+
+### {current_date} — Mestre (Fix — Compact Plan)
+- **Action:** Compact bugfix plan for {slug}
+- **Tasks:** {count}
+- **Quality:** {your quality gate result}
+```
+
+### Handle Mestre's response
+
+If Mestre outputs `ESCALATE:`:
+```
+This bug needs more than 3 tasks — too complex for /rpi:fix.
+
+Use the full pipeline: /rpi:new {slug}
+```
+Stop.
+
+If Mestre outputs a valid plan:
+1. Write `{folder}/{slug}/plan/PLAN.md` with Mestre's output.
+2. Output:
+   ```
+   PLAN.md created: {folder}/{slug}/plan/PLAN.md ({N} tasks)
+   Starting implementation...
+   ```
+
+## Step 6: Forge — Implementation
+
+For each task in PLAN.md order, respecting dependency ordering:
+
+### Step 6a: Initialize IMPLEMENT.md (if not resuming)
+
+Write `{folder}/{slug}/implement/IMPLEMENT.md`:
+
+```markdown
+# Implementation: Fix {slug}
+
+Started: {YYYY-MM-DD}
+Plan: {folder}/{slug}/plan/PLAN.md
+
+## Tasks
+
+- [ ] Task {1}: {description}
+- [ ] Task {2}: {description}
+- ...
+
+## Execution Log
+```
+
+### Step 6b: Handle resume
+
+If resuming (IMPLEMENT.md exists):
+1. Read IMPLEMENT.md, find next unchecked task `- [ ]`.
+2. Output: `Resuming '{slug}' from task {next_task_id}. ({completed}/{total} tasks done)`
+
+### Step 6c: Execute each task
+
+Launch Forge agent for each task:
+
+```
+You are Forge. Implement task {task_id} for bugfix: {slug}
+
+## Task
+{task description from PLAN.md}
+
+## Target Files
+{files listed for this task}
+
+## Dependencies Completed
+{list of completed task IDs and their descriptions}
+
+## Bug Report
+{content of REQUEST.md}
+
+## Project Context
+{content of context.md if it exists}
+
+CRITICAL RULES:
+1. CONTEXT_READ: You MUST read ALL target files before writing ANY code
+2. Match existing patterns — naming, error handling, imports, style
+3. Only touch files listed in the task unless absolutely necessary
+4. Commit your changes with a conventional commit message
+5. Report: DONE | BLOCKED | DEVIATED
+
+After completing the task, append your activity to {folder}/{slug}/ACTIVITY.md:
+
+### {current_date} — Forge (Fix — Task {task_id})
+- **Action:** Implemented task {task_id} for {slug}
+- **Files changed:** {list}
+- **Status:** {DONE|BLOCKED|DEVIATED}
+- **Quality:** {your quality gate result}
+```
+
+### Step 6d: Parse Forge response
+
+**DONE:**
+1. Update IMPLEMENT.md: `- [ ] Task {id}` → `- [x] Task {id}`
+2. Append to Execution Log:
+   ```
+   ### Task {id}: {description}
+   - Status: DONE
+   - Commit: {hash}
+   - Files: {list of files changed}
+   ```
+3. Continue to next task.
+
+**BLOCKED:**
+1. Update IMPLEMENT.md with blocker.
+2. Output:
+   ```
+   Fix blocked at task {id}: {description}
+
+   Blocker: {reason}
+
+   Options:
+   - Fix the blocker and run: /rpi:fix {slug} --resume
+   - Use the full pipeline: /rpi:new {slug}
+   ```
+3. Stop.
+
+**DEVIATED:**
+1. Cosmetic: log it, continue automatically.
+2. Interface/scope: warn the user, ask to accept or revert.
+3. If accepted: update IMPLEMENT.md as DONE with deviation noted.
+4. If reverted: git revert, task stays unchecked. Stop.
+
+## Step 7: Completion summary
+
+After all tasks completed, output:
+
+```
+Fix complete: {slug}
+
+Tasks: {completed}/{total}
+Commits:
+- {hash1}: {task 1 description}
+- {hash2}: {task 2 description}
+
+Next:
+- Review: /rpi:review {slug}
+- Archive: /rpi:archive {slug}
+- Full pipeline on this: /rpi {slug} --from=simplify
+```
+
+Update IMPLEMENT.md with a final section:
+
+```markdown
+## Summary
+
+- Total tasks: {N}
+- Completed: {N}
+- Blocked: {N}
+- Deviations: {N}
+- Completed: {YYYY-MM-DD}
+```

package/commands/rpi/implement.md

@@ -119,6 +119,15 @@ Your task:
 4. Cover: happy path, error path, at least one edge case
 5. Run the tests and confirm they fail
 6. Output: test file path, test code, and the failing test output
+
+After writing tests, append your activity to rpi/features/{slug}/ACTIVITY.md:
+
+### {current_date} — Sage (Implement — TDD for Task {task_id})
+- **Action:** Wrote failing tests for task {task_id}
+- **Key decisions:** {for each <decision> tag you emitted: "summary (rationale)", separated by semicolons. If none: "No decisions in this phase."}
+- **Tests written:** {count}
+- **Edge cases covered:** {count}
+- **Quality:** {your quality gate result}
 ```
 
 Wait for Sage to complete. Store the test output as `$SAGE_TESTS`. Verify the tests actually fail — if they pass, something is wrong (the behavior may already exist). Inform the user and ask how to proceed.
@@ -155,6 +164,15 @@ CRITICAL RULES:
 4. If TDD: make the failing tests pass
 5. Commit your changes with a conventional commit message
 6. Report: DONE | BLOCKED | DEVIATED
+
+After completing the task, append your activity to rpi/features/{slug}/ACTIVITY.md:
+
+### {current_date} — Forge (Implement — Task {task_id})
+- **Action:** Implemented task {task_id} for {slug}
+- **Key decisions:** {for each <decision> tag you emitted: "summary (rationale)", separated by semicolons. If none: "No decisions in this phase."}
+- **Files changed:** {list}
+- **Status:** {DONE|BLOCKED|DEVIATED}
+- **Quality:** {your quality gate result}
 ```
 
 ### Step 5c: Parse Forge response
@@ -244,3 +262,22 @@ Update IMPLEMENT.md with a final section:
 - Deviations: {N} ({list severities})
 - Completed: {YYYY-MM-DD}
 ```
+
+## Step 7: Consolidate decisions to DECISIONS.md
+
+1. Read `rpi/features/{slug}/ACTIVITY.md`.
+2. Extract all `<decision>` tags from entries belonging to the Implement phase (Sage and Forge entries from this run).
+3. If no decisions found, skip this step.
+4. Read `rpi/features/{slug}/DECISIONS.md` if it exists (to get the last decision number for sequential numbering).
+5. Append a new section to `rpi/features/{slug}/DECISIONS.md`:
+
+```markdown
+## Implement Phase
+_Generated: {current_date}_
+
+| # | Type | Decision | Alternatives | Rationale | Impact |
+|---|------|----------|-------------|-----------|--------|
+| {N} | {type} | {summary} | {alternatives} | {rationale} | {impact} |
+```
+
+6. Number decisions sequentially, continuing from the last number in DECISIONS.md.

package/commands/rpi/plan.md

@@ -178,6 +178,14 @@ After all questions answered, compile the interview results using your
 [Nexus — Developer Interview] output format.
 
 Return the compiled interview content.
+
+After the interview, append your activity to rpi/features/{slug}/ACTIVITY.md:
+
+### {current_date} — Nexus (Plan Interview)
+- **Action:** Developer interview for {slug}
+- **Key decisions:** {for each <decision> tag you emitted: "summary (rationale)", separated by semicolons. If none: "No decisions in this phase."}
+- **Questions asked:** {count}
+- **Quality:** {your quality gate result}
 ```
 
 Store the output as `$INTERVIEW`.
@@ -244,6 +252,15 @@ Your task:
 5. Output using your eng.md format: [Mestre -- Engineering Specification]
 
 Be pragmatic. Follow existing codebase patterns from context.md and research findings. No over-engineering.
+
+After generating eng.md, append your activity to rpi/features/{slug}/ACTIVITY.md:
+
+### {current_date} — Mestre (Plan — eng.md)
+- **Action:** Engineering specification for {slug}
+- **Key decisions:** {for each <decision> tag you emitted: "summary (rationale)", separated by semicolons. If none: "No decisions in this phase."}
+- **Architecture decisions:** {count}
+- **Files planned:** {count create + modify}
+- **Quality:** {your quality gate result}
 ```
 
 Store the output as `$ENG_OUTPUT`.
@@ -280,6 +297,16 @@ Your task:
 5. Output using your pm.md format: [Clara -- Product Specification]
 
 Be ruthless with scope. Every requirement must have acceptance criteria.
+
+After generating pm.md, append your activity to rpi/features/{slug}/ACTIVITY.md:
+
+### {current_date} — Clara (Plan — pm.md)
+- **Action:** Product specification for {slug}
+- **Key decisions:** {for each <decision> tag you emitted: "summary (rationale)", separated by semicolons. If none: "No decisions in this phase."}
+- **User stories:** {count}
+- **Acceptance criteria:** {count}
+- **Scope cuts:** {count of out-of-scope items}
+- **Quality:** {your quality gate result}
 ```
 
 Store the output as `$PM_OUTPUT`.
@@ -375,6 +402,15 @@ Rules:
 - If Clara marked something as out-of-scope, don't create tasks for it
 - If the developer interview decided on approach X, all tasks must use approach X
 - If the developer marked something as out-of-scope, don't create tasks for it
+
+After generating PLAN.md, append your activity to rpi/features/{slug}/ACTIVITY.md:
+
+### {current_date} — Mestre (Plan — PLAN.md)
+- **Action:** Implementation plan for {slug}
+- **Key decisions:** {for each <decision> tag you emitted: "summary (rationale)", separated by semicolons. If none: "No decisions in this phase."}
+- **Tasks:** {count}
+- **Complexity:** {S|M|L|XL}
+- **Quality:** {your quality gate result}
 ```
 
 Store the output as `$PLAN_OUTPUT`.
@@ -497,6 +533,16 @@ After completing all passes:
 4. MEDIUM/LOW issues: present summary, developer can dismiss or address
 5. For each resolved issue: note the chosen resolution and which artifacts need patching
 6. Return the full adversarial review with all resolutions noted
+
+After adversarial review, append your activity to rpi/features/{slug}/ACTIVITY.md:
+
+### {current_date} — Nexus (Plan Adversarial Review)
+- **Action:** Adversarial review for {slug}
+- **Key decisions:** {for each <decision> tag you emitted: "summary (rationale)", separated by semicolons. If none: "No decisions in this phase."}
+- **Issues found:** {count by severity}
+- **Contradictions resolved:** {count}
+- **Coherence status:** {PASS|PASS with notes|NEEDS re-plan}
+- **Quality:** {your quality gate result}
 ```
 
 Store the output as `$ADVERSARIAL_REVIEW`.
@@ -544,7 +590,26 @@ If `$ADVERSARIAL_REVIEW` contains resolved issues:
    ```
 8. Write delta spec files from Step 13 into the appropriate delta subdirectories.
 
-## Step 17: Output summary
+## Step 17: Consolidate decisions to DECISIONS.md
+
+1. Read `rpi/features/{slug}/ACTIVITY.md`.
+2. Extract all `<decision>` tags from entries belonging to the Plan phase (Nexus interview, Mestre eng.md, Clara, Mestre PLAN.md, Nexus adversarial entries).
+3. If no decisions found, skip this step.
+4. Read `rpi/features/{slug}/DECISIONS.md` if it exists (to get the last decision number for sequential numbering).
+5. Append a new section to `rpi/features/{slug}/DECISIONS.md`:
+
+```markdown
+## Plan Phase
+_Generated: {current_date}_
+
+| # | Type | Decision | Alternatives | Rationale | Impact |
+|---|------|----------|-------------|-----------|--------|
+| {N} | {type} | {summary} | {alternatives} | {rationale} | {impact} |
+```
+
+6. Number decisions sequentially, continuing from the last number in DECISIONS.md.
+
+## Step 18: Output summary
 
 ```
 Plan complete: rpi/features/{slug}/plan/

package/commands/rpi/research.md

@@ -75,6 +75,15 @@ Your task:
 3. Check rpi/solutions/ for past solutions that could be reused
 4. Identify files likely affected, patterns to follow, and risks
 5. Output using your standard format: [Atlas -- Codebase Analysis]
+
+6. After your analysis, append your activity to rpi/features/{slug}/ACTIVITY.md:
+
+### {current_date} — Atlas (Research)
+- **Action:** Codebase analysis for {slug}
+- **Scope:** {list files you actually read}
+- **Key decisions:** {for each <decision> tag you emitted: "summary (rationale)", separated by semicolons. If none: "No decisions in this phase."}
+- **Patterns found:** {count and summary}
+- **Quality:** {your quality gate result}
 ```
 
 ### Scout (external research)
@@ -100,6 +109,15 @@ Your task:
 4. Identify risks: breaking changes, security issues, maintenance status
 5. Find relevant benchmarks, examples, or case studies
 6. Output using your standard format: [Scout -- Technical Investigation]
+
+7. After your investigation, append your activity to rpi/features/{slug}/ACTIVITY.md:
+
+### {current_date} — Scout (Research)
+- **Action:** External research for {slug}
+- **Key decisions:** {for each <decision> tag you emitted: "summary (rationale)", separated by semicolons. If none: "No decisions in this phase."}
+- **Sources consulted:** {count and list}
+- **Recommendations:** {count and summary}
+- **Quality:** {your quality gate result}
 ```
 
 ## Step 5: Wait for completion
@@ -195,6 +213,15 @@ Rules for verdict:
 - No BLOCK + 2 or more CONCERN findings = GO with concerns
 - Otherwise = GO
 - NO-GO requires an Alternatives section
+
+After synthesis, append your activity to rpi/features/{slug}/ACTIVITY.md:
+
+### {current_date} — Nexus (Research Synthesis)
+- **Action:** Synthesized Atlas + Scout findings for {slug}
+- **Key decisions:** {for each <decision> tag you emitted: "summary (rationale)", separated by semicolons. If none: "No decisions in this phase."}
+- **Consensus points:** {count}
+- **Disagreements resolved:** {count}
+- **Quality:** {your quality gate result}
 ```
 
 ## Step 8: Write RESEARCH.md and populate delta baselines
@@ -206,7 +233,27 @@ Rules for verdict:
    - Copy relevant spec baselines into `delta/MODIFIED/` so the plan phase has reference copies
    - This gives Mestre (plan phase) the current state of specs that will be changed
 
-## Step 9: Output summary
+## Step 9: Consolidate decisions to DECISIONS.md
+
+1. Read `rpi/features/{slug}/ACTIVITY.md`.
+2. Extract all `<decision>` tags from entries belonging to the Research phase (Atlas, Scout, Nexus entries from this run).
+3. If no decisions found, skip this step.
+4. Write `rpi/features/{slug}/DECISIONS.md`:
+
+```markdown
+# Decision Log — {slug}
+
+## Research Phase
+_Generated: {current_date}_
+
+| # | Type | Decision | Alternatives | Rationale | Impact |
+|---|------|----------|-------------|-----------|--------|
+| {N} | {type} | {summary} | {alternatives} | {rationale} | {impact} |
+```
+
+5. Number decisions sequentially starting from 1.
+
+## Step 10: Output summary
 
 ```
 Research complete: rpi/features/{slug}/research/RESEARCH.md

package/commands/rpi/review.md

@@ -108,6 +108,15 @@ Output format:
 ## Summary
 - P1: {N} | P2: {N} | P3: {N}
 - Overall: {assessment}
+
+After your review, append your activity to rpi/features/{slug}/ACTIVITY.md:
+
+### {current_date} — Hawk (Review)
+- **Action:** Adversarial code review for {slug}
+- **Key decisions:** {for each <decision> tag you emitted: "summary (rationale)", separated by semicolons. If none: "No decisions in this phase."}
+- **Findings:** P1={count} P2={count} P3={count}
+- **Perspectives covered:** {list of 5 perspectives}
+- **Quality:** {your quality gate result}
 ```
 
 Store the output as `$HAWK_OUTPUT`.
@@ -178,6 +187,15 @@ Output format:
 
 ## Summary
 - P1: {N} | P2: {N} | P3: {N}
+
+After your audit, append your activity to rpi/features/{slug}/ACTIVITY.md:
+
+### {current_date} — Shield (Review)
+- **Action:** Security audit for {slug}
+- **Key decisions:** {for each <decision> tag you emitted: "summary (rationale)", separated by semicolons. If none: "No decisions in this phase."}
+- **Findings:** P1={count} P2={count} P3={count}
+- **OWASP categories checked:** {count}
+- **Quality:** {your quality gate result}
 ```
 
 Store the output as `$SHIELD_OUTPUT`.
@@ -242,6 +260,16 @@ Output format:
 - Modules without tests: {N}
 - Missing critical paths: {N}
 - Missing edge cases: {N}
+
+After your analysis, append your activity to rpi/features/{slug}/ACTIVITY.md:
+
+### {current_date} — Sage (Review)
+- **Action:** Test coverage analysis for {slug}
+- **Key decisions:** {for each <decision> tag you emitted: "summary (rationale)", separated by semicolons. If none: "No decisions in this phase."}
+- **Untested modules:** {count}
+- **Missing critical paths:** {count}
+- **Missing edge cases:** {count}
+- **Quality:** {your quality gate result}
 ```
 
 Store the output as `$SAGE_OUTPUT`.
@@ -387,7 +415,26 @@ Verdict: {PASS | PASS with concerns | FAIL}
 (or "No solutions saved.")
 ```
 
-## Step 10: Output summary
+## Step 10: Consolidate decisions to DECISIONS.md
+
+1. Read `rpi/features/{slug}/ACTIVITY.md`.
+2. Extract all `<decision>` tags from entries belonging to the Review phase (Hawk, Shield, Sage entries from this run).
+3. If no decisions found, skip this step.
+4. Read `rpi/features/{slug}/DECISIONS.md` if it exists (to get the last decision number for sequential numbering).
+5. Append a new section to `rpi/features/{slug}/DECISIONS.md`:
+
+```markdown
+## Review Phase
+_Generated: {current_date}_
+
+| # | Type | Decision | Alternatives | Rationale | Impact |
+|---|------|----------|-------------|-----------|--------|
+| {N} | {type} | {summary} | {alternatives} | {rationale} | {impact} |
+```
+
+6. Number decisions sequentially, continuing from the last number in DECISIONS.md.
+
+## Step 11: Output summary
 
 ```
 Review complete: {slug}

package/commands/rpi/rpi.md

@@ -51,7 +51,7 @@ Stop.
 
 Check which artifacts exist to determine the next phase:
 
-1. Has `REQUEST.md`, no `research/RESEARCH.md` → next = **research**
+1. Has `REQUEST.md`, no `research/RESEARCH.md` AND no `plan/PLAN.md` → next = **research**
 2. Has `research/RESEARCH.md`, no `plan/PLAN.md` → next = **plan**
 3. Has `plan/PLAN.md`, no `implement/IMPLEMENT.md` → next = **implement**
 4. Has `implement/IMPLEMENT.md` but NOT all tasks checked (`- [x]`) → next = **implement** (with `--resume`)