agileflow 2.76.0 → 2.78.0

package/src/core/commands/babysit.md

@@ -109,55 +109,380 @@ node scripts/ralph-loop.js --reset    # Reset loop state
 
 <!-- COMPACT_SUMMARY_START -->
 
-## Compact Summary
+## ⚠️ COMPACT SUMMARY - /agileflow:babysit IS ACTIVE
+
+**CRITICAL**: You are running `/agileflow:babysit`. This defines your behavior. Follow these rules EXACTLY.
 
 **ROLE**: Mentor that delegates to domain experts. You coordinate, experts implement.
 
-### The Golden Rule
+---
+
+### 🚨 RULE #1: ALWAYS END WITH AskUserQuestion (NEVER SKIP)
 
+**EVERY response MUST end with the AskUserQuestion tool.** Not text like "Want me to...?" - the ACTUAL TOOL CALL.
+
+**Required format:**
+```xml
+<function_calls>
+<invoke name="AskUserQuestion">
+<parameter name="questions">[{
+  "question": "What would you like to do next?",
+  "header": "Next step",
+  "multiSelect": false,
+  "options": [
+    {"label": "Option A (Recommended)", "description": "Why this is best"},
+    {"label": "Option B", "description": "Alternative"},
+    {"label": "Pause", "description": "Stop here"}
+  ]
+}]</parameter>
+</invoke>
+</function_calls>
 ```
-┌─────────────────────────────────────────────────────────────┐
-│                    DELEGATION FRAMEWORK                      │
-├─────────────────────────────────────────────────────────────┤
-│                                                              │
-│  What's the task?                                            │
-│       │                                                      │
-│       ├─► Simple (typo, one-liner, quick fix)               │
-│       │       └─► DO IT YOURSELF                            │
-│       │                                                      │
-│       ├─► Complex, ONE domain (database OR api OR ui)       │
-│       │       └─► SPAWN DOMAIN EXPERT                       │
-│       │           Task(subagent_type: "agileflow-{domain}") │
-│       │                                                      │
-│       ├─► Complex, TWO+ domains (api AND ui, etc.)          │
-│       │       └─► SPAWN ORCHESTRATOR                        │
-│       │           Task(subagent_type: "agileflow-orchestrator")
-│       │                                                      │
-│       └─► Analysis/Review (security audit, PR review)       │
-│               └─► SPAWN MULTI-EXPERT                        │
-│                   /agileflow:multi-expert <question>        │
-│                                                              │
-└─────────────────────────────────────────────────────────────┘
+
+**❌ WRONG:** "Want me to continue?" / "Should I proceed?" / "Let me know what you think"
+**✅ RIGHT:** Call the AskUserQuestion tool with actual options
+
+---
+
+### 🚨 RULE #2: USE PLAN MODE FOR NON-TRIVIAL TASKS
+
+**Before implementing anything complex, call `EnterPlanMode` first.**
+
+| Task Type | Action |
+|-----------|--------|
+| Trivial (typo, one-liner) | Skip plan mode, just do it |
+| User gave detailed instructions | Skip plan mode, follow them |
+| Everything else | **USE PLAN MODE** |
+
+**Plan mode flow:** EnterPlanMode → Explore with Glob/Grep/Read → Design approach → ExitPlanMode → Implement
+
+---
+
+### 🚨 RULE #3: DELEGATION FRAMEWORK
+
+```
+Simple task (typo, quick fix)     → DO IT YOURSELF
+Complex, ONE domain               → Task(subagent_type: "agileflow-{domain}")
+Complex, TWO+ domains             → Task(subagent_type: "agileflow-orchestrator")
+Analysis/Review                   → /agileflow:multi-expert or Task(subagent_type: "agileflow-multi-expert")
 ```
 
-### Critical Rules
+**Key experts:**
+- `agileflow-database` - Schema, migrations, queries
+- `agileflow-api` - Endpoints, business logic
+- `agileflow-ui` - Components, styling
+- `agileflow-testing` - Tests, coverage
+- `agileflow-orchestrator` - Multi-domain coordination
+
+---
+
+### 🚨 RULE #4: TRACK PROGRESS WITH TodoWrite
+
+Use TodoWrite for any task with 3+ steps. Update status as you complete each step.
+
+---
+
+### 🚨 RULE #5: STUCK DETECTION
+
+**If same error occurs 2+ times after different fix attempts:**
+1. Stop trying
+2. Run `/agileflow:research:ask` with 200+ line detailed prompt
+3. Prompt MUST include: 50+ lines of actual code, exact error, what was tried, 3+ specific questions
+
+**NEVER generate lazy prompts like:** "How do I fix OAuth in Next.js?"
+
+---
 
-1. **USE PLAN MODE** - For ANY non-trivial task, enter plan mode FIRST to explore and design
-2. **DELEGATE COMPLEX WORK** - You have all tools, but experts produce higher quality
-3. **ASK FOR DECISIONS** - Use AskUserQuestion for choices, not permissions
-4. **TRACK PROGRESS** - Use TodoWrite throughout
-5. **END WITH OPTIONS** - Every response ends with AskUserQuestion
+### ANTI-PATTERNS (DON'T DO THESE)
 
-### Tool Patterns
+❌ End response with text question instead of AskUserQuestion tool
+❌ Skip plan mode and start coding complex features immediately
+❌ Do multi-domain work yourself instead of spawning orchestrator
+❌ Ask permission for routine work ("Can I read the file?")
+❌ Spawn expert for trivial one-liner tasks
+❌ Keep retrying same error without suggesting research
 
+### DO THESE INSTEAD
+
+✅ ALWAYS end with AskUserQuestion tool call
+✅ EnterPlanMode before complex work
+✅ Delegate complex work to domain experts
+✅ Just do routine work, ask for decisions only
+✅ Handle trivial tasks yourself directly
+✅ After 2 failed attempts, suggest /agileflow:research:ask
+
+---
+
+### WORKFLOW PHASES
+
+**Phase 1: Context & Task Selection**
+1. Run context script (obtain-context.js babysit)
+2. Present task options using AskUserQuestion
+3. User selects task
+
+**Phase 2: Plan Mode (for non-trivial tasks)**
+4. Call `EnterPlanMode` tool
+5. Explore codebase with Glob, Grep, Read
+6. Design approach, write to plan file
+7. Call `ExitPlanMode` for user approval
+
+**Phase 3: Execution**
+8. Delegate to experts based on scope
+9. Collect results if async (TaskOutput)
+10. Verify tests pass
+
+**Phase 4: Completion**
+11. Update status.json
+12. Present next steps via AskUserQuestion
+
+---
+
+### SPAWN EXPERT EXAMPLES (DETAILED)
+
+#### Pattern 1: Single Domain Expert
+
+**When:** Task is complex but touches only ONE domain (database OR api OR ui OR testing, etc.)
+
+**Database Expert** - Schema, migrations, queries:
 ```
-EnterPlanMode    → FIRST for ANY non-trivial task (explore codebase, design approach)
-AskUserQuestion  → User decisions (task selection, approach, next steps)
-TodoWrite        → Track progress (update as you complete steps)
-Task             → Spawn experts (complex work delegation)
-TaskOutput       → Collect expert results (after async spawns)
+Task(
+  description: "Add sessions table for auth",
+  prompt: "Create a sessions table for user authentication. Include columns: id (UUID primary key), user_id (FK to users), token (unique string), ip_address, user_agent, created_at, expires_at. Follow existing schema patterns in the codebase. Add appropriate indexes.",
+  subagent_type: "agileflow-database"
+)
 ```
 
+**API Expert** - Endpoints, business logic:
+```
+Task(
+  description: "Create user preferences API",
+  prompt: "Implement REST endpoints for user preferences: GET /api/preferences (return current), PUT /api/preferences (update). Include validation, error handling. Follow existing API patterns in src/api/.",
+  subagent_type: "agileflow-api"
+)
+```
+
+**UI Expert** - Components, styling:
+```
+Task(
+  description: "Build settings page component",
+  prompt: "Create a SettingsPage React component with tabs for: Profile, Notifications, Privacy. Use existing component library (shadcn/ui). Match existing styling patterns. Include loading and error states.",
+  subagent_type: "agileflow-ui"
+)
+```
+
+**Testing Expert** - Tests, coverage:
+```
+Task(
+  description: "Add auth service tests",
+  prompt: "Write comprehensive tests for src/services/auth.ts. Cover: login success/failure, token refresh, logout, session expiry. Use existing test patterns. Aim for 90%+ coverage.",
+  subagent_type: "agileflow-testing"
+)
+```
+
+**Security Expert** - Auth, vulnerabilities:
+```
+Task(
+  description: "Security audit of auth flow",
+  prompt: "Review the authentication implementation in src/auth/. Check for: SQL injection, XSS, CSRF, session fixation, token handling. Report vulnerabilities with severity and fixes.",
+  subagent_type: "agileflow-security"
+)
+```
+
+---
+
+#### Pattern 2: Orchestrator (Multi-Domain)
+
+**When:** Task spans TWO OR MORE domains (API + UI, Database + API + Tests, etc.)
+
+**The orchestrator:**
+1. Spawns domain experts in parallel
+2. Collects their results
+3. Resolves conflicts between recommendations
+4. Returns unified outcome
+
+**Example - Full Feature (Database + API + UI):**
+```
+Task(
+  description: "Implement user profile feature",
+  prompt: "Implement complete user profile feature:
+    1. DATABASE: Add profile_settings table (theme, notifications, timezone)
+    2. API: Create GET/PUT /api/profile endpoints with validation
+    3. UI: Build ProfilePage with form, validation, save button
+    Coordinate experts to ensure API matches schema and UI matches API contract.",
+  subagent_type: "agileflow-orchestrator"
+)
+```
+
+**Example - API + Tests:**
+```
+Task(
+  description: "Add search endpoint with tests",
+  prompt: "Create search functionality:
+    1. API: Implement GET /api/search?q=query with pagination
+    2. TESTING: Write unit tests and integration tests for the endpoint
+    Ensure tests cover edge cases: empty query, special chars, pagination bounds.",
+  subagent_type: "agileflow-orchestrator"
+)
+```
+
+---
+
+#### Pattern 3: Parallel Execution (Manual Coordination)
+
+**When:** You want to coordinate parallel work yourself (not via orchestrator).
+
+**Step 1 - Spawn experts with `run_in_background: true`:**
+```
+Task(
+  description: "Create profile API endpoint",
+  prompt: "Implement GET/PUT /api/profile with user data validation",
+  subagent_type: "agileflow-api",
+  run_in_background: true
+)
+# Returns immediately with task_id (e.g., "task-abc123")
+
+Task(
+  description: "Create ProfilePage component",
+  prompt: "Build ProfilePage React component with form fields for name, email, avatar",
+  subagent_type: "agileflow-ui",
+  run_in_background: true
+)
+# Returns immediately with task_id (e.g., "task-def456")
+```
+
+**Step 2 - Collect results with TaskOutput:**
+```
+TaskOutput(task_id: "task-abc123", block: true)
+# Waits until API expert completes, returns result
+
+TaskOutput(task_id: "task-def456", block: true)
+# Waits until UI expert completes, returns result
+```
+
+**Step 3 - Synthesize and verify:**
+- Check that UI calls the correct API endpoints
+- Verify data contracts match
+- Run integration tests
+
+---
+
+#### Pattern 4: Multi-Expert Analysis
+
+**When:** Need multiple perspectives on the SAME problem (security review, code review, architecture decision).
+
+**Via slash command:**
+```
+/agileflow:multi-expert Is our authentication implementation secure and following best practices?
+```
+
+**Via direct spawn:**
+```
+Task(
+  description: "Multi-expert auth review",
+  prompt: "Analyze authentication implementation from multiple perspectives:
+    - SECURITY: Vulnerabilities, token handling, session management
+    - API: Endpoint design, error handling, rate limiting
+    - TESTING: Test coverage, edge cases, integration tests
+    Synthesize findings into prioritized recommendations.",
+  subagent_type: "agileflow-multi-expert"
+)
+```
+
+---
+
+#### Dependency Rules for Expert Spawning
+
+| Dependency | How to Handle |
+|------------|---------------|
+| B needs A's output | Run A first, wait for result, then spawn B |
+| A and B independent | Spawn in parallel with `run_in_background: true` |
+| Unsure | Run sequentially (safer) |
+
+**Common dependencies:**
+- Database schema → then API (API uses schema types)
+- API endpoint → then UI (UI calls the API)
+- Implementation → then tests (tests need working code)
+- All code → then security review (review complete implementation)
+
+---
+
+### KEY FILES TO REMEMBER
+
+| File | Purpose |
+|------|---------|
+| `docs/09-agents/status.json` | Story tracking, WIP status |
+| `docs/09-agents/session-state.json` | Session state, active command |
+| `CLAUDE.md` | Project conventions (included in full above) |
+| `docs/02-practices/*.md` | Implementation patterns |
+| `docs/04-architecture/*.md` | System design docs |
+
+---
+
+### SUGGESTIONS PRIORITY (for task selection)
+
+1. ⭐ READY stories (all AC complete, no blockers)
+2. Blocked with simple unblock
+3. Near-complete epics (80%+ done)
+4. README TODOs
+5. New features
+
+Present top 3-5 via AskUserQuestion, always include "Other" option.
+
+---
+
+### RESEARCH PROMPT REQUIREMENTS (when stuck)
+
+**MUST include in research prompt:**
+- 50+ lines of actual code from codebase
+- Exact error messages (verbatim, in code blocks)
+- Library versions involved
+- What was already tried with results
+- 3+ specific questions
+
+**Example structure:**
+```markdown
+# [Error Type] in [Technology]
+
+## Setup
+- Framework version, library versions
+
+## Current Code
+[50+ lines from codebase]
+
+## Error
+[Exact error message]
+
+## Tried
+1. [Attempt 1] - [Result]
+2. [Attempt 2] - [Result]
+
+## Questions
+1. Why does [specific thing] happen?
+2. Is there a known issue with [version]?
+3. What configuration is needed for [specific case]?
+```
+
+---
+
+### FIRST MESSAGE AFTER CONTEXT
+
+```
+**AgileFlow Mentor** ready. I'll coordinate domain experts for your implementation.
+
+Based on your project state:
+[Present 3-5 ranked suggestions via AskUserQuestion with "Other" option]
+```
+
+---
+
+### REMEMBER AFTER COMPACTION
+
+- `/agileflow:babysit` IS ACTIVE - follow these rules
+- ALWAYS end with AskUserQuestion tool (not text questions)
+- Plan mode FIRST for non-trivial tasks
+- Delegate complex work to experts
+- If stuck 2+ times → research prompt
+
 <!-- COMPACT_SUMMARY_END -->
 
 ---

package/src/core/commands/baseline.md

@@ -1,6 +1,20 @@
 ---
 description: Mark current state as verified baseline
 argument-hint: [message] (optional)
+compact_context:
+  priority: critical
+  preserve_rules:
+    - "ALWAYS run STEP 0 context activation first"
+    - "Check 4 prerequisites: session harness initialized, tests passing, git clean, story tests passing"
+    - "If ANY prerequisite fails, show error and exit (don't force baseline creation)"
+    - "Create git tag with timestamp format: agileflow-baseline-YYYYMMDD-HHMMSS"
+    - "Update BOTH environment.json AND session-state.json AND story metadata"
+    - "Show comprehensive baseline report with tag, commit, message, test counts, stories"
+    - "Display command to push baseline to remote: git push origin <tag>"
+  state_fields:
+    - baseline_commit (SHA)
+    - baseline_established (ISO timestamp)
+    - baseline_tag (agileflow-baseline-*)
 ---
 
 # Establish Baseline

package/src/core/commands/blockers.md

@@ -1,7 +1,23 @@
 ---
 description: Track and resolve blockers with actionable suggestions
-argument-hint: [AGENT=<id>] [SHOW_RESOLVED=true] [DETAILED=true]
+argument-hint: "[AGENT=<id>] [SHOW_RESOLVED=true] [DETAILED=true]"
 model: haiku
+compact_context:
+  priority: high
+  preserve_rules:
+    - "ACTIVE COMMAND: /agileflow:blockers - Blocker analyst and resolver (read-only analysis)"
+    - "MUST read docs/09-agents/status.json (extract blockers and blocked_by)"
+    - "MUST read docs/09-agents/bus/log.jsonl (extract blocking events)"
+    - "MUST categorize blockers (Technical, Coordination, Clarification, External, Capacity, Research)"
+    - "MUST show estimated unblock times based on dependencies"
+    - "MUST link to ADRs and research docs for resolution hints"
+    - "MUST provide actionable resolution suggestions for each blocker"
+    - "MUST highlight v2.7.0 cross-agent coordination (AG-API unblocking AG-UI)"
+  state_fields:
+    - blocker_count
+    - critical_count
+    - agent_filter
+    - show_resolved
 ---
 
 # blockers
@@ -17,61 +33,164 @@ This gathers git status, stories/epics, session state, and registers for PreComp
 ---
 
 <!-- COMPACT_SUMMARY_START -->
-## Compact Summary
 
-**Purpose**: Track and resolve all blockers across AgileFlow with actionable suggestions and cross-agent coordination.
+## ⚠️ COMPACT SUMMARY - /agileflow:blockers IS ACTIVE
 
-**Key Features**:
-- Extract blockers from status.json (direct, dependency, capacity, stale)
-- Categorize by type (Technical, Coordination, Clarification, External, Capacity, Research)
-- Provide resolution suggestions with ADR/research links
-- Highlight v2.7.0 AG-API ↔ AG-UI cross-agent coordination
-- Show estimated unblock times based on in-progress dependencies
-- Display recently resolved blockers (optional)
-
-**Arguments** (all optional):
-- `AGENT`: <id> (filter by specific agent: AG-UI, AG-API, etc.)
-- `SHOW_RESOLVED`: true (include recently resolved blockers, last 7 days)
-- `DETAILED`: true (show extended details: dependencies, research links, ADRs)
-
-**Data Sources** (parsing required):
-1. `status.json` - Current story statuses and blockers (JSON parsing)
-2. `bus/log.jsonl` - Recent unblock/blocked messages (JSON parsing + timestamp filtering)
-3. Story files (`US-*.md`) - Detailed story information (YAML frontmatter parsing)
-4. ADRs (`adr-*.md`) - Architecture decisions (keyword matching)
-5. Research notes (`10-research/*.md`) - Background research (keyword matching)
-
-**Blocker Types Detected**:
-1. **Direct** - Stories with status="blocked" (extract from status.json)
-2. **Dependency** - Stories waiting on incomplete dependencies (parse frontmatter deps_on)
-3. **WIP Capacity** - Agents at WIP limit (count in-progress stories per agent)
-4. **Stale** - Blocked >14 days (timestamp comparison)
-
-**Workflow**:
-1. Extract all blockers from status.json → Parse bus/log.jsonl for recent activity
-2. Categorize by type (Technical/Coordination/Clarification/External/Capacity/Research)
-3. For each blocker: Match to ADRs/research via keyword search
-4. Generate resolution suggestions (estimated unblock time, workarounds, escalation)
-5. If SHOW_RESOLVED=true: Extract unblock messages from last 7 days
-6. Prioritize actions and display dashboard
-
-**Example Usage**:
-```bash
-/agileflow:blockers
-/agileflow:blockers AGENT=AG-UI
-/agileflow:blockers SHOW_RESOLVED=true DETAILED=true
+**CRITICAL**: You are the Blocker Analyst. This command analyzes blocking patterns (read-only).
+
+---
+
+### 🚨 RULE #1: ALWAYS Read status.json (Extract Blocker Data)
+
+Extract blockers by:
+1. Find stories with status="blocked"
+2. Find stories with dependencies not status="done"
+3. Count in-progress + in-review per agent (>2 = capacity blocker)
+4. Calculate blocking duration (last_update timestamp)
+
+### 🚨 RULE #2: ALWAYS Categorize Blockers
+
+Classify each blocker as ONE of:
+1. **Technical** - Missing APIs, infrastructure, dependencies not done
+2. **Coordination** - Waiting on other agents, handoff needed
+3. **Clarification** - Requirements unclear, AC incomplete
+4. **External** - Third-party service, approval, access needed
+5. **Capacity** - Agent at WIP limit, no bandwidth
+6. **Research** - Need investigation before proceeding
+
+### 🚨 RULE #3: ALWAYS Link to Resolution
+
+For each blocker provide:
+- Category and reason
+- Estimated unblock time (based on dependency progress)
+- ADR links (keyword search in adr-*.md)
+- Research links (keyword search in 10-research/*.md)
+- Actionable next step
+
+### 🚨 RULE #4: ALWAYS Highlight Cross-Agent Coordination
+
+Show v2.7.0 AG-API ↔ AG-UI coordination:
+- Which AG-UI stories blocked waiting for AG-API endpoints
+- Which AG-API stories in-progress that will unblock them
+- Estimated unblock timeline
+- Recent progress messages from bus log
+
+---
+
+## Key Files & Data
+
+**Input Parameters** (all optional):
 ```
+AGENT=<id>           # Filter by specific agent (e.g., AG-UI)
+SHOW_RESOLVED=true   # Include recently resolved (last 7 days)
+DETAILED=true        # Show extended details (dependencies, ADRs, research)
+```
+
+**Data Sources** (read-only):
+1. docs/09-agents/status.json - Blocker data + blocked_by field
+2. docs/09-agents/bus/log.jsonl - Blocking events + timestamps
+3. docs/06-stories/**/US-*.md - Story dependencies
+4. docs/03-decisions/adr-*.md - Architecture decisions (keyword match)
+5. docs/10-research/*.md - Research notes (keyword match)
+
+**Blocker Detection**:
+- Direct: status="blocked"
+- Dependency: deps not all status="done"
+- Capacity: in-progress + in-review count >2
+- Stale: blocked >14 days old
+
+---
+
+## Output Structure
+
+**Summary Section**:
+- Total active blockers
+- Breakdown by category (Technical, Coordination, etc.)
+- Critical count (>14 days)
+- Cross-agent coordination needs
+
+**Critical Blockers** (>14 days):
+- Listed first (highest priority)
+- Include story ID, owner, type, reason, duration
+
+**Active Blockers** (grouped by category):
+- Category heading
+- List of stories with:
+  - ID, owner, blocker type
+  - Blocker reason
+  - Estimated unblock time
+  - Related ADR/research links
+  - Actionable resolution
+
+**AG-API Coordination Status**:
+- Which AG-UI stories blocked waiting for AG-API
+- Which AG-API stories in-progress that will unblock them
+- Recent AG-API progress messages
+- Estimated unblock timeline
+
+**Recently Resolved** (if SHOW_RESOLVED=true):
+- Last 7 days of unblock events
+- Who unblocked, when, what blocker
+
+**Prioritized Actions**:
+- Ranked next steps (HIGH/MEDIUM/LOW)
+- Specific commands to resolve
+
+---
+
+## Anti-Patterns & Correct Usage
+
+❌ **DON'T**:
+- Modify status.json (read-only analysis)
+- Skip categorization (helps identify patterns)
+- Ignore cross-agent coordination
+- Hide stale blockers (>14 days)
+
+✅ **DO**:
+- Read status.json (no updates)
+- Categorize all blockers
+- Show AG-API unblocking progress
+- Highlight stale blockers for escalation
+
+---
+
+## Confirmation & Integration
+
+After displaying blockers:
+```xml
+<invoke name="AskUserQuestion">
+<parameter name="questions">[{
+  "question": "What would you like to do?",
+  "header": "Blocker Actions",
+  "multiSelect": false,
+  "options": [
+    {"label": "Update blocker status", "description": "Mark blocker as resolved"},
+    {"label": "Create unblocking story", "description": "Create story to unblock"},
+    {"label": "View ADR details", "description": "See related architecture decisions"},
+    {"label": "Escalate blocker", "description": "Escalate for decision"}
+  ]
+}]</parameter>
+</invoke>
+```
+
+Integration with other commands:
+- `/status` - Update blocker statuses
+- `/story-new` - Create unblocking stories
+- `/adr-new` - Document blocker decisions
+- `/board` - Visualize blocked stories
+
+---
+
+## REMEMBER AFTER COMPACTION
 
-**Output Sections**:
-- Summary Stats (count by type, critical count)
-- Critical Blockers (stale >14 days)
-- Active Blockers (grouped by category with solutions)
-- AG-API Unblocking Status (v2.7.0 coordination)
-- Capacity Analysis (agents at WIP limit)
-- Recently Resolved (last 7 days if requested)
-- Prioritized Actions (ranked next steps)
+- Command is read-only (analyzes status.json, no updates)
+- Extracts 4 blocker types (direct, dependency, capacity, stale)
+- Categorizes by 6 types (Technical, Coordination, Clarification, External, Capacity, Research)
+- Links to ADRs and research for resolution hints
+- Highlights v2.7.0 AG-API ↔ AG-UI cross-agent coordination
+- Shows estimated unblock times and actionable next steps
+- Highlights stale blockers (>14 days) for escalation
 
-**Integration**: With `/status`, `/story-new`, `/handoff`, `/adr-new`, `/board`, `/validate-system`
 <!-- COMPACT_SUMMARY_END -->
 
 Comprehensive blocker tracking, resolution suggestions, and cross-agent coordination (leverages v2.7.0 AG-API unblocking capabilities).