convoke-agents 3.2.1 → 3.3.0

package/_bmad/bme/_enhance/workflows/initiatives-backlog/steps-c/step-c-03-qualify.md

@@ -0,0 +1,176 @@
+---
+name: 'step-c-03-qualify'
+description: 'Qualifying gate for Create mode — walk gathered intakes, assign Lane + Portfolio + RICE per intake (or keep raw)'
+nextStepFile: '{project-root}/_bmad/bme/_enhance/workflows/initiatives-backlog/steps-c/step-c-04-generate.md'
+outputFile: '{planning_artifacts}/convoke-note-initiative-lifecycle-backlog.md'
+templateFile: '{project-root}/_bmad/bme/_enhance/workflows/initiatives-backlog/templates/rice-scoring-guide.md'
+processFile: '{project-root}/_bmad/bme/_enhance/workflows/initiatives-backlog/templates/lifecycle-process-spec.md'
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.md'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/bmad-party-mode/workflow.md'
+---
+
+# Step 3: Qualifying Gate (Create Mode)
+
+## STEP GOAL:
+
+Run the **qualifying gate** on each intake gathered in step-c-02. For each intake, the qualifier (Vortex, John, or Winston) assigns a **Lane** (Bug / Fast / Initiative), a **Portfolio** attachment, and an initial **RICE** score. Intakes the qualifier is not ready to route stay raw (§2.1 only).
+
+This step mirrors step-t-03 (Triage's qualifying gate). The lifecycle rules are identical — only the invocation context differs (Create mode is bootstrapping a new file).
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+- 🛑 NEVER generate lane/portfolio/RICE without user input — the qualifying gate is user-driven
+- 📖 CRITICAL: Read this complete step file before taking action
+- 🔄 CRITICAL: When loading next step with 'C', read the entire file
+- 📋 YOU ARE A QUALIFYING-GATE FACILITATOR supporting the qualifier (Vortex / John / Winston)
+
+### Role Reinforcement:
+- ✅ You are a **qualifying gate facilitator** — propose, don't decide; the qualifier decides
+- ✅ Only Vortex team, John, or Winston can qualify. Confirm the user's qualifier role.
+- ✅ Propose lane/portfolio/RICE based on intake description, but flag uncertainty plainly
+- ✅ Every intake ends this step in one of two states: **qualified** (lane + portfolio + RICE) or **raw intake** (logged to §2.1 only)
+
+### Step-Specific Rules:
+- 🎯 Focus on lane assignment, portfolio attachment, and RICE scoring
+- 🚫 FORBIDDEN to write to the backlog file (step-c-04's job)
+- 🚫 FORBIDDEN to re-gather or add new intakes (step-c-02's job)
+- 💬 Approach: walk intakes one at a time, propose + decide, track state
+
+## EXECUTION PROTOCOLS:
+- 🎯 Follow the MANDATORY SEQUENCE exactly
+- 📖 Load {templateFile} for RICE factor definitions and calibration examples
+- 📖 Load {processFile} for lane definitions and portfolio taxonomy
+- 💾 Track each intake's qualification decision for step-c-04
+
+## CONTEXT BOUNDARIES:
+- Available context: `gathered_intakes` from step-c-02, RICE scoring guide, lifecycle process spec
+- Focus: Qualifying gate per-intake
+- Limits: Do NOT write to backlog
+- Dependencies: step-c-02-gather.md (gathered intakes)
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise.
+
+### 1. Load References
+
+Load `{templateFile}` (rice-scoring-guide.md):
+- **Factor definitions:** Reach (1-10), Impact (0.25-3), Confidence (20-100%), Effort (1-10)
+- **Guided questions** for each factor
+- **Composite formula:** Score = (R × I × C) / E
+
+Load `{processFile}` (lifecycle-process-spec.md):
+- **§1.3 Three Lanes** — Bug / Fast / Initiative triggers
+- **§1.4 Portfolio Attachment** — current taxonomy + growth rule
+- **§1.6 RICE Scoring** — lane-specific notes
+
+### 2. Confirm Qualifier Role
+
+Display:
+
+> **Qualifying Gate — Confirm Qualifier**
+>
+> Only three parties can qualify intakes:
+> - **[V] Vortex** team (via discovery)
+> - **[J] John** (PM shortcut)
+> - **[W] Winston** (Architect shortcut)
+>
+> Who is qualifying in this session?
+
+Record qualifier identity. If user declines, display: "Qualifying requires an authorized qualifier. Type `raw-only` to skip qualification — all intakes will stay in §2.1 without a lane." and accept role letter or `raw-only`.
+
+### 3. Walk Intakes One at a Time
+
+Initialize:
+- `qualified_items = []` — intakes with lane + portfolio + RICE
+- `raw_intakes = []` — intakes kept as §2.1-only
+- `current_index = 1`
+
+For each intake in `gathered_intakes`:
+
+#### 3a. Present Intake & Proposed Qualification
+
+Display:
+
+> **Intake [current_index] of [total]**
+>
+> **Description:** [description]
+> **Source:** [source]
+> **Date:** [date]
+> **Raiser:** [raiser]
+>
+> **Proposed qualification:**
+> - **Lane:** [proposed with rationale]
+> - **Portfolio:** [proposed]
+> - **RICE:** R:[r] I:[i] C:[c]% E:[e] = [score]
+>   *[one-line rationale]*
+
+#### 3b. Present Per-Intake Menu
+
+Display:
+
+> **Review this qualification:**
+>
+> **Lane override:**
+> - `L bug` / `L fast` / `L initiative` — Change lane
+> - `L none` — Keep raw (§2.1 only)
+>
+> **Portfolio override:**
+> - `P [item]` — Set portfolio
+> - `P new [name] — [rationale]` — Propose new portfolio (logged for John+Winston review)
+>
+> **RICE adjustments:**
+> - `R [value]` / `I [value]` / `CF [value]` / `E [value]` — Component changes
+>
+> **Decisions:**
+> - `K` — Keep/accept
+> - `RAW` — Log as raw intake only
+> - `S` — Drop (won't reach backlog at all)
+> - `X` — Exit qualification (remaining intakes stay raw)
+>
+> **[A] Advanced Elicitation** / **[P] Party Mode** / **[C] Continue**
+
+#### Menu Handling Logic:
+- Same semantics as step-t-03:
+  - `L bug/fast/initiative/none`, `P [item|new ...]`, `R/I/CF/E [v]`, `K`, `RAW`, `S`, `X`, `A`, `P`, `C`.
+- Record adjustments, recalculate composite on RICE changes, redisplay after each action.
+- On K/C (with changes): add to `qualified_items`. On RAW/L none: add to `raw_intakes`. On S: drop (logged in Change Log by step-c-04).
+- On X: remaining intakes auto-moved to `raw_intakes`, go to step 4.
+
+#### 3c. Advance
+Increment `current_index`. If `<= total`, go to 3a. Otherwise step 4.
+
+### 4. Present Qualification Summary
+
+Display:
+
+> **Qualification Complete**
+>
+> **Qualified (will populate lanes):** [N]
+> **Raw intakes (§2.1 only):** [N]
+> **Dropped:** [N]
+>
+> **Qualified breakdown:**
+> - Bug Lane: [n]
+> - Fast Lane: [n]
+> - Initiative Lane: [n]
+>
+> **Qualifier:** [Vortex / John / Winston / raw-only]
+> **New portfolio proposals:** [list, or "none"]
+
+### 5. Present MENU OPTIONS
+
+> **[C] Continue** — Generate backlog file (step-c-04)
+> **[R] Revisit** — Walk intakes again
+> **[X] Abort** — Return to T/R/C menu without writing
+
+#### Menu Handling Logic:
+- IF C: Load, read, and execute `{project-root}/_bmad/bme/_enhance/workflows/initiatives-backlog/steps-c/step-c-04-generate.md`, passing `gathered_intakes` (for §2.1 rows), `qualified_items` (for lane rows), `raw_intakes`, `dropped_items`, and qualifier identity.
+- IF R: Re-enter step 3.
+- IF X: Discard qualifications. Load, read, and execute `{project-root}/_bmad/bme/_enhance/workflows/initiatives-backlog/workflow.md`.
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS:
+### ✅ SUCCESS: Every intake qualified or routed to raw/dropped, qualifier recorded, user validated, results passed to step-c-04
+### ❌ SYSTEM FAILURE: Qualification without authorized qualifier, lane assigned without RICE, intakes lost between steps, step-c-04 invoked with missing data
+**Master Rule:** Skipping steps is FORBIDDEN.

package/_bmad/bme/_enhance/workflows/initiatives-backlog/steps-c/step-c-04-generate.md

@@ -0,0 +1,259 @@
+---
+name: 'step-c-04-generate'
+description: 'Generate the complete lifecycle backlog file — frontmatter, Part 1 verbatim from process spec, Part 2 lanes populated from qualified + raw intakes, Appendix, Change Log'
+outputFile: '{planning_artifacts}/convoke-note-initiative-lifecycle-backlog.md'
+templateFile: '{project-root}/_bmad/bme/_enhance/workflows/initiatives-backlog/templates/backlog-format-spec.md'
+processFile: '{project-root}/_bmad/bme/_enhance/workflows/initiatives-backlog/templates/lifecycle-process-spec.md'
+workflowFile: '{project-root}/_bmad/bme/_enhance/workflows/initiatives-backlog/workflow.md'
+---
+
+# Step 4: Backlog Generation & Completion
+
+## STEP GOAL:
+
+Generate the complete lifecycle backlog file from scratch:
+- **Frontmatter** with correct artifact governance metadata
+- **Part 1: Lifecycle Process** copied verbatim from `lifecycle-process-spec.md`
+- **Part 2: Backlog** with §2.1 Intakes populated from all gathered intakes, and §2.2/2.3/2.4 populated from qualified items (if any). §2.5 Absorbed/Archived starts empty.
+- **Appendix: Initiative Details** (empty placeholder or populated for Initiative Lane items with detail)
+- **Change Log** with the creation entry
+
+Present a completion summary and return to the T/R/C menu.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+- 🛑 NEVER generate content without completing all mandatory sequence steps
+- 📖 CRITICAL: Read this complete step file before taking action
+- 🔄 CRITICAL: When returning to menu, read the entire workflow file
+- 📋 YOU ARE A BACKLOG OPERATIONS SPECIALIST generating a new file
+
+### Role Reinforcement:
+- ✅ You are a **backlog operations specialist** — precise, structured, format-compliant
+- ✅ Part 1 is **verbatim** from `{processFile}` — do not paraphrase, summarize, or edit
+- ✅ All output must be standard markdown — no HTML, no proprietary syntax
+- ✅ Every intake logged, every qualified item in its lane, every decision traceable in the Change Log
+
+### Step-Specific Rules:
+- 🎯 Focus on file generation, verbatim Part 1 emission, correct lane population, completion reporting
+- 🚫 FORBIDDEN to re-qualify items (step-c-03's job)
+- 🚫 FORBIDDEN to paraphrase or modify Part 1 content — emit the `lifecycle-process-spec.md` text verbatim
+- 🚫 FORBIDDEN to add items not in the gathered_intakes / qualified_items lists
+- 💬 Approach: assemble the complete file, verify structure, write, summarize, return to menu
+
+## EXECUTION PROTOCOLS:
+- 🎯 Follow the MANDATORY SEQUENCE exactly
+- 📖 Load `{templateFile}` (backlog-format-spec.md) for exact structural requirements and table formats
+- 📖 Load `{processFile}` (lifecycle-process-spec.md) for the verbatim Part 1 text
+- 💾 Write to `{outputFile}` as a complete new file
+
+## CONTEXT BOUNDARIES:
+- Available context: `gathered_intakes`, `qualified_items`, `raw_intakes`, `dropped_items`, qualifier identity, templates (format spec + process spec)
+- Focus: File generation, completion summary
+- Limits: Do NOT re-qualify or re-gather items
+- Dependencies: step-c-02 (gathered intakes) and step-c-03 (qualified items). Empty-create path from step-c-01 is valid — both lists may be empty.
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise.
+
+### 1. Load Templates (If Not Already Loaded)
+
+Ensure `{templateFile}` (backlog-format-spec.md) and `{processFile}` (lifecycle-process-spec.md) are loaded.
+
+Identify in `{processFile}` the **verbatim Part 1 text**: everything after the `---` separator line, starting with `## Part 1: Lifecycle Process` through the end of §1.6.
+
+### 2. Generate Frontmatter
+
+```yaml
+---
+initiative: convoke
+artifact_type: note
+qualifier: initiative-lifecycle-backlog
+created: 'YYYY-MM-DD'
+schema_version: 1
+status: draft
+origin: 'Create mode ([qualifier identity or raw-only], [date])'
+supersedes: convoke-note-initiatives-backlog.md
+---
+```
+
+`created` = current session date.
+
+### 3. Generate Title
+
+```markdown
+# Convoke Initiative Lifecycle & Backlog
+
+**Created:** [current session date]
+**Origin:** Create mode ([qualifier identity])
+**Status:** Draft (initial creation)
+```
+
+### 4. Emit Part 1 Verbatim
+
+Copy the Part 1 text from `{processFile}` verbatim into the new file. This includes:
+
+- `## Part 1: Lifecycle Process` heading
+- `### 1.1 Intake`
+- `### 1.2 Qualifying Gate`
+- `### 1.3 Three Lanes` (with H4 subsections: Bug Lane, Fast Lane, Initiative Lane)
+- `### 1.4 Portfolio Attachment`
+- `### 1.5 Pipeline Stages (Evolvable)`
+- `### 1.6 RICE Scoring`
+
+**Do not paraphrase, summarize, reorder, or edit.** If any edit is desired, it must be made in `lifecycle-process-spec.md` first and migrated downstream.
+
+### 5. Generate Part 2 Structure
+
+Emit `## Part 2: Backlog` with all five H3 sections:
+
+#### §2.1 Intakes (Unqualified)
+
+Emit the 5-column table header:
+
+```markdown
+| ID | Description | Source | Date | Raiser |
+|----|-------------|--------|------|--------|
+```
+
+For each intake in `gathered_intakes` (whether qualified, raw, or dropped):
+- `ID`: `IN-{n}` sequential starting at 1.
+- `Description`: the intake description. For qualified items, append ` → [laneID]` to cross-reference the lane row. For dropped items, prefix `[DROPPED]`.
+- `Source`: from gathered data.
+- `Date`: from gathered data.
+- `Raiser`: from gathered data.
+
+**Empty-create path:** If no intakes were gathered, emit the table header only (no rows).
+
+#### §2.2 Bug Lane
+
+Emit the 10-column table header:
+
+```markdown
+| ID | Description | R | I | C | E | Score | Portfolio | Status | Linked Follow-up |
+|----|-------------|---|---|---|---|-------|-----------|--------|------------------|
+```
+
+For each qualified item with Lane = Bug:
+- `ID`: `BUG-{n}` sequential.
+- All columns per format spec.
+- `Status`: `Open`.
+- Sort table by composite Score descending.
+
+If zero Bug items: emit header only with a line `*(none)*` below.
+
+#### §2.3 Fast Lane (Quick Wins + Spikes)
+
+Emit the 9-column table header:
+
+```markdown
+| ID | Description | R | I | C | E | Score | Portfolio | Status |
+|----|-------------|---|---|---|---|-------|-----------|--------|
+```
+
+For each qualified item with Lane = Fast:
+- `ID`: alpha-prefix sequential. Propose `Q-{n}` if uncertain about a domain prefix; user can rename later.
+- `Status`: `Backlog`.
+- Sort by composite Score descending.
+
+If zero: `*(none)*`.
+
+#### §2.4 Initiative Lane
+
+Emit the 10-column table header:
+
+```markdown
+| ID | Description | R | I | C | E | Score | Portfolio | Stage | Artifacts |
+|----|-------------|---|---|---|---|-------|-----------|-------|-----------|
+```
+
+For each qualified item with Lane = Initiative:
+- `ID`: alpha-prefix sequential.
+- `Stage`: `Qualified`.
+- `Artifacts`: `—` (no planning artifacts yet).
+- Sort by composite Score descending.
+
+If zero: `*(none)*`.
+
+#### §2.5 Absorbed / Archived
+
+Emit the section heading and an empty state:
+
+```markdown
+### 2.5 Absorbed / Archived
+
+*No absorbed or archived items yet.*
+```
+
+### 6. Generate Appendix
+
+```markdown
+## Appendix: Initiative Details
+
+*Full descriptions for §2.4 items whose table row is a one-liner. Populated as initiatives enter the pipeline and require detail.*
+```
+
+If any Initiative Lane item warrants detail (has substantial scope notes from gathering), emit an H3 subsection per format spec.
+
+### 7. Generate Change Log
+
+```markdown
+## Change Log
+
+| Date | Change |
+|------|--------|
+| [YYYY-MM-DD] | Create: Bootstrapped new lifecycle backlog. Intakes: [N] logged. Qualified: [X] (Bug: a, Fast: b, Initiative: c). Raw intakes: [Y]. Dropped: [Z]. Qualifier: [identity]. [Portfolio proposals: list, if any.] |
+```
+
+### 8. Write Complete File
+
+Write the assembled backlog to `{outputFile}`. The file must contain, in order:
+1. Frontmatter
+2. H1 title + metadata paragraph
+3. `## Part 1: Lifecycle Process` (verbatim from process spec)
+4. `## Part 2: Backlog` with §2.1 through §2.5
+5. `## Appendix: Initiative Details`
+6. `## Change Log`
+
+### 9. Post-Write Validation
+
+Re-load the written file and validate:
+- All H2 anchors present in correct order
+- All H3 Part 2 anchors present (§2.1 through §2.5)
+- Table column counts match spec
+- Frontmatter parses
+
+If validation fails, display the failure and prompt to retry or abort.
+
+### 10. Completion Summary & Return to Menu
+
+After successful write + validation, display:
+
+> **Create Complete — Lifecycle Backlog Bootstrapped**
+>
+> **File:** `{outputFile}`
+> **Intakes logged:** [N]
+> **Qualified into lanes:** [X]
+>   - Bug Lane: [n]
+>   - Fast Lane: [n]
+>   - Initiative Lane: [n]
+> **Raw intakes (awaiting later qualification):** [Y]
+> **Dropped (logged in §2.1 with [DROPPED] prefix):** [Z]
+> **Qualifier:** [identity]
+>
+> **Next steps:**
+> - Use **Triage (T)** to add new intakes from future findings.
+> - Use **Review (R)** to rescore lane items as context evolves.
+> - Unqualified intakes in §2.1 can be qualified later via a fresh Triage run or manual edit.
+
+Then return to the T/R/C menu:
+
+> Loading `{workflowFile}` to return to mode selection...
+
+Load, read the entire file, and execute `{workflowFile}`.
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS:
+### ✅ SUCCESS: Complete file generated with correct frontmatter, verbatim Part 1 from process spec, all five §2.x H3 sections present with correct column counts, intakes logged with cross-references to lanes, qualified items placed in correct lanes and sorted by RICE, Appendix and Change Log present, post-write validation passes, completion summary displayed, menu re-presented
+### ❌ SYSTEM FAILURE: Part 1 paraphrased or modified, missing H3 sections, wrong column counts, intakes not cross-referenced to qualified lane items, items placed in wrong lane, file not validated after write, no completion summary, no return to menu
+**Master Rule:** Skipping steps is FORBIDDEN.

package/_bmad/bme/_enhance/workflows/initiatives-backlog/steps-r/step-r-01-load.md

@@ -1,17 +1,17 @@
 ---
 name: 'step-r-01-load'
-description: 'Load existing backlog and RICE scoring guide for Review mode walkthrough'
+description: 'Load existing lifecycle backlog, let user choose which lane(s) to walk, and prepare item list for rescoring'
 nextStepFile: '{project-root}/_bmad/bme/_enhance/workflows/initiatives-backlog/steps-r/step-r-02-rescore.md'
-outputFile: '{planning_artifacts}/initiatives-backlog.md'
+outputFile: '{planning_artifacts}/convoke-note-initiative-lifecycle-backlog.md'
 templateFile: '{project-root}/_bmad/bme/_enhance/workflows/initiatives-backlog/templates/rice-scoring-guide.md'
 workflowFile: '{project-root}/_bmad/bme/_enhance/workflows/initiatives-backlog/workflow.md'
 ---
 
-# Step 1: Load Backlog & Walkthrough Setup
+# Step 1: Load Backlog & Choose Lanes
 
 ## STEP GOAL:
 
-Load the existing backlog file and RICE scoring guide, parse all active items with their current scores and provenance, and prepare for the per-item walkthrough.
+Load the existing lifecycle backlog file and RICE scoring guide, parse items from all three lanes (Bug / Fast / Initiative), and let the user choose which lane(s) to walk for rescoring in step-r-02.
 
 ## MANDATORY EXECUTION RULES (READ FIRST):
 
@@ -24,14 +24,15 @@ Load the existing backlog file and RICE scoring guide, parse all active items wi
 ### Role Reinforcement:
 - ✅ You are a **review analyst** — your job is to load and prepare data, not to modify it
 - ✅ Parse the backlog faithfully — do not reinterpret, reorder, or filter items
-- ✅ The walkthrough starts in step-r-02 — this step only loads and counts
+- ✅ The walkthrough starts in step-r-02 — this step only loads, counts, and lets the user choose scope
 
 ### Step-Specific Rules:
-- 🎯 Focus ONLY on loading, parsing, and counting backlog items
+- 🎯 Focus ONLY on loading, parsing, counting, and lane scope selection
 - 🚫 FORBIDDEN to rescore, modify, or delete any backlog items (that is step-r-02's job)
 - 🚫 FORBIDDEN to write to the backlog file (that is step-r-03's job)
 - 🚫 FORBIDDEN to add new items (that is Triage mode's job)
-- 💬 Approach: load efficiently, confirm readiness, move on
+- 🚫 FORBIDDEN to read or parse items from §2.1 Intakes or §2.5 Absorbed — Review only walks lane items (§2.2/2.3/2.4)
+- 💬 Approach: load efficiently, summarize lanes, let user choose scope, move on
 
 ## EXECUTION PROTOCOLS:
 - 🎯 Follow the MANDATORY SEQUENCE exactly
@@ -40,7 +41,7 @@ Load the existing backlog file and RICE scoring guide, parse all active items wi
 
 ## CONTEXT BOUNDARIES:
 - Available context: Existing backlog file, RICE scoring guide template
-- Focus: Data loading and preparation only
+- Focus: Data loading, lane summary, scope selection
 - Limits: Do NOT modify, score, or write anything
 - Dependencies: workflow.md R dispatch (Review mode selected)
 
@@ -54,9 +55,9 @@ Check if a backlog file exists at `{outputFile}`.
 
 - **If NOT found:** Display:
 
-  > **No backlog found at `{outputFile}`.**
+  > **No lifecycle backlog found at `{outputFile}`.**
   >
-  > Review mode requires an existing backlog to walk through. Use **Triage (T)** or **Create (C)** mode first to create one.
+  > Review mode requires an existing backlog to walk through. Use **Create (C)** mode first to bootstrap one, or **Triage (T)** if a backlog exists at a different path.
   >
   > Returning to mode selection...
 
@@ -74,47 +75,76 @@ Load `{templateFile}` (rice-scoring-guide.md) and internalize:
 - **Factor definitions:** Reach (1-10), Impact (0.25-3), Confidence (20-100%), Effort (1-10)
 - **Guided questions** for each factor
 - **Calibration examples** from the existing backlog
-- **Composite formula:** Score = (R x I x C) / E, where C is decimal (e.g., 70% = 0.7)
+- **Composite formula:** Score = (R × I × C) / E, where C is decimal (e.g., 70% = 0.7)
 - **Score rounding:** One decimal place for display
+- **Lane-specific scoring notes:** Bug impact often hardcoded high; Fast Lane effort typically 1-3; Initiative effort reflects pipeline + execution
 
-### 3. Parse Active Backlog Items
+### 3. Parse Lane Items
 
-Parse all category tables **under `## Backlog`** to collect items with:
-- Item ID (e.g., D2, P4)
-- Title and description
-- Category (H3 heading name)
-- Current RICE component scores (R, I, C, E)
-- Current composite score
-- Current provenance (from Initiative description cell)
-- Current status
+Parse tables from lane sections:
 
-**Do NOT include** items from `## Exploration Candidates`, `## Completed`, or other sections outside `## Backlog`.
+- **§2.2 Bug Lane** — 10 columns: ID, Description, R, I, C, E, Score, Portfolio, Status, Linked Follow-up.
+- **§2.3 Fast Lane** — 9 columns: ID, Description, R, I, C, E, Score, Portfolio, Status.
+- **§2.4 Initiative Lane** — 10 columns: ID, Description, R, I, C, E, Score, Portfolio, Stage, Artifacts.
+
+**Do NOT include** items from:
+- §2.1 Intakes (unqualified — no RICE)
+- §2.5 Absorbed / Archived (removed from active)
+- Any section outside `## Part 2: Backlog`
 
 ### 4. Count and Summarize
 
-Count the total number of active items collected. Display:
+Display a lane summary:
 
 > **Review Mode — Backlog Loaded**
 >
-> **Items found:** [N] active items across [M] categories
-> **Categories:** [list category names]
-> **Score range:** [lowest] to [highest]
+> | Lane | Items | Score range |
+> |------|-------|-------------|
+> | §2.2 Bug Lane | [n] | [low]–[high] |
+> | §2.3 Fast Lane | [n] | [low]–[high] |
+> | §2.4 Initiative Lane | [n] | [low]–[high] |
+> | **Total** | **[N]** | |
 >
-> The walkthrough will present each item one at a time for review. You can rescore, confirm, skip, or exit early at any point.
+> *Rescoring applies to these lane items only. Intakes (§2.1) have no RICE and are not included in Review.*
+
+### 5. Present Lane Selection Menu
 
-### 5. Present MENU OPTIONS
+Display:
 
-Display: "**Select:** [C] Continue to item walkthrough"
+> **Select lane(s) to walk:**
+>
+> - **[B] Bug Lane only** — [n] items
+> - **[F] Fast Lane only** — [n] items
+> - **[I] Initiative Lane only** — [n] items
+> - **[A] All lanes** — [N] items (walk in order Bug → Fast → Initiative)
+> - **[T] Top N by score** — walk top N items across all lanes (prompt for N)
+> - **[X] Exit** — return to mode selection
 
 #### Menu Handling Logic:
-- IF C: Load, read the entire file, and execute `{project-root}/_bmad/bme/_enhance/workflows/initiatives-backlog/steps-r/step-r-02-rescore.md`
-- IF any other input: Display "Enter **C** to continue to the walkthrough." then redisplay menu
 
-#### EXECUTION RULES:
-- ALWAYS halt and wait for user input after presenting the menu
-- ONLY proceed to next step when user selects 'C'
+- IF B: Set walk scope to Bug Lane items only.
+- IF F: Set walk scope to Fast Lane items only.
+- IF I: Set walk scope to Initiative Lane items only.
+- IF A: Set walk scope to all lane items in order Bug → Fast → Initiative.
+- IF T: Prompt "How many top-ranked items?". Accept integer N ≥ 1. Set walk scope to top N items ranked by composite score descending (tiebreak: Confidence, then lane priority Bug > Initiative > Fast).
+- IF X: Display "Exiting Review mode." then load, read, and execute `{workflowFile}`.
+- IF any other input: Display "Unknown option. Use B / F / I / A / T / X." then redisplay menu.
+
+### 6. Confirm Scope & Advance
+
+After scope selection, display:
+
+> **Walkthrough scope:** [description, e.g., "Fast Lane — 65 items"]
+>
+> **[C] Continue to walkthrough**
+> **[R] Re-select scope**
+> **[X] Exit**
+
+- IF C: Pass `walk_scope` (ordered list of items with full data) to step-r-02. Load, read the entire file, and execute `{project-root}/_bmad/bme/_enhance/workflows/initiatives-backlog/steps-r/step-r-02-rescore.md`.
+- IF R: Go back to step 5.
+- IF X: Load, read, and execute `{workflowFile}`.
 
 ## 🚨 SYSTEM SUCCESS/FAILURE METRICS:
-### ✅ SUCCESS: Backlog file loaded, RICE guide internalized, all active items parsed with scores and provenance, item count displayed, proceeding to step-r-02
-### ❌ SYSTEM FAILURE: Backlog not loaded, items from wrong sections included, items modified or filtered, scoring guide not loaded, missing backlog not handled gracefully
+### ✅ SUCCESS: Backlog file loaded, RICE guide internalized, lane items parsed from §2.2/2.3/2.4 only, lane summary displayed, user chose scope, scope list passed to step-r-02
+### ❌ SYSTEM FAILURE: Backlog not loaded, items from wrong sections included (Intakes / Absorbed), lanes not distinguished, scope selection skipped, missing backlog not handled gracefully
 **Master Rule:** Skipping steps is FORBIDDEN.