specweave 0.18.0 → 0.20.0

package/plugins/specweave/commands/specweave-progress.md

@@ -1,18 +1,38 @@
 ---
 name: specweave:progress
-description: Show current increment progress, task completion %, PM gate status, and next action
+description: Show progress for ALL active increments (up to 2), task completion %, PM gates, and next actions
 ---
 
 # Progress Tracking
 
-**Quick Status Check**: See exactly where you are in your current increment.
+**Quick Status Check**: See exactly where you are in ALL your active increments.
+
+**NEW**: Now shows **ALL active increments** (max 2) with full progress for each!
 
 Shows:
-- Active increment status
-- Task completion percentage
+- **ALL active increment statuses** (not just one!)
+- Task completion percentage (per increment)
 - PM gate preview (tasks, tests, docs)
 - Next action to take
 - Time tracking
+- WIP limit warnings (if >2 active)
+
+---
+
+## Quick Start
+
+```bash
+# Check progress for all active increments (recommended)
+specweave progress
+
+# Or use the full command name
+specweave status --verbose
+
+# Filter by increment type
+specweave progress --type feature
+```
+
+**Note**: `progress` is an alias for `status --verbose` with automatic verbose mode enabled.
 
 ---
 
@@ -151,13 +171,20 @@ Next Action:
 
 ## Implementation
 
-**How `/progress` works**:
+**How `/progress` works** (UPGRADED for multi-active support):
 
-### Step 1: Find Active Increment
+### Step 1: Find ALL Active Increments (FAST!)
 
-```bash
-# Check for in-progress increments
-find .specweave/increments -name "tasks.md" -exec grep -l "status: in-progress" {} \;
+```typescript
+// NEW: Use ActiveIncrementManager cache (10x faster!)
+import { MetadataManager } from './src/core/increment/metadata-manager.js';
+
+// Get ALL active increments (from cache, not scan!)
+const activeIncrements = MetadataManager.getActive();
+
+// Performance:
+// - OLD: Scan 31 metadata files (~50ms)
+// - NEW: Read 1 cache + 1-2 metadata files (~5ms) ✅
 ```
 
 ### Step 2: Parse Tasks and Calculate %
@@ -194,19 +221,27 @@ Overall: (6 + 3 + 1) / (16 + 4.5 + 1) = 10/21.5 = 46.5%
 # - Status: ✅ updated, ⏳ partial, ❌ outdated
 ```
 
-### Step 4: Determine Next Action
-
-```bash
-if [[ $in_progress_count -eq 0 ]]; then
-    echo "Run \`/inc\` to start new feature"
-elif [[ $in_progress_count -gt 1 ]]; then
-    echo "⚠️ Multiple increments active. Focus on completing one."
-    echo "Run \`/do $oldest_increment\`"
-elif [[ $next_task != "" ]]; then
-    echo "Run \`/do $increment_id\` to resume at $next_task"
-else
-    echo "All tasks complete! Run \`/done $increment_id\` to close."
-fi
+### Step 4: Display ALL Active Increments
+
+```typescript
+// NEW: Display progress for EACH active increment
+for (const increment of activeIncrements) {
+  console.log(`\n📊 ${increment.id}`);
+  console.log(`Status: ${increment.status}`);
+  console.log(`Task Progress: ${completed}/${total} (${percent}%)`);
+  console.log(`Next: /specweave:do ${increment.id}`);
+}
+
+// Show WIP limit info
+if (activeIncrements.length === 0) {
+  console.log('No active increments. Run /specweave:increment to start new work.');
+} else if (activeIncrements.length === 1) {
+  console.log('✅ 1 active increment (optimal focus)');
+} else if (activeIncrements.length === 2) {
+  console.log('✅ 2 active increments (at WIP limit, but OK)');
+} else if (activeIncrements.length > 2) {
+  console.log('⚠️ >2 active increments (exceeds WIP limit!)');
+}
 ```
 
 ---
@@ -238,11 +273,12 @@ Use `/specweave:progress` when you:
 
 ## Pro Tips
 
-1. **No increment ID needed** - `/specweave:progress` automatically finds active increment
-2. **Smart resume** - `/specweave:do` picks up where you left off (no task ID needed)
-3. **WIP limits** - Keep 1-2 increments active max for focus
-4. **Completion %** - P1 tasks weighted higher (they're critical path)
-5. **Time tracking** - Warns if tasks are stuck (>2 hours inactive)
+1. **Shows ALL active increments** - `/specweave:progress` displays up to 2 active increments with full progress
+2. **10x faster** - Uses cache instead of scanning 31 metadata files (5ms vs 50ms)
+3. **Smart resume** - `/specweave:do` picks up where you left off (no task ID needed)
+4. **WIP limits** - 2 active increments allowed (feature + hotfix/bug)
+5. **Completion %** - P1 tasks weighted higher (they're critical path)
+6. **Time tracking** - Warns if tasks are stuck (>2 hours inactive)
 
 ---
 
@@ -256,3 +292,116 @@ Use `/specweave:progress` when you:
 ---
 
 **💡 Remember**: `/progress` is your "where am I?" command. Use it anytime you need orientation!
+
+---
+
+## Executable Implementation
+
+```typescript
+import { Task } from '@claude/types';
+
+const task = new Task('progress-check', 'Show progress for all active increments');
+
+task.run(async () => {
+  const { MetadataManager } = await import('../../../dist/src/core/increment/metadata-manager.js');
+  const fs = await import('fs-extra');
+  const path = await import('path');
+
+  // Step 1: Get ALL active increments (FAST via cache!)
+  const activeIncrements = MetadataManager.getActive();
+
+  // Step 2: Check if specific increment requested
+  const requestedId = process.argv[2]?.replace(/^0+/, '').padStart(4, '0');
+  const increments = requestedId
+    ? activeIncrements.filter(inc => inc.id === requestedId)
+    : activeIncrements;
+
+  // Step 3: Display results
+  console.log('\n📊 Current Progress\n');
+
+  if (increments.length === 0) {
+    if (requestedId) {
+      console.log(`❌ Increment ${requestedId} is not active`);
+    } else {
+      console.log('No active increments found.\n');
+      console.log('Recent Increments:');
+      const allIncrements = MetadataManager.getAll()
+        .filter(m => m.status === 'completed' || m.status === 'closed')
+        .sort((a, b) => new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime())
+        .slice(0, 3);
+
+      allIncrements.forEach(inc => {
+        const age = Math.floor((Date.now() - new Date(inc.lastActivity).getTime()) / (1000 * 60 * 60 * 24));
+        console.log(`├─ ${inc.id} (${inc.status}) - ${age} day${age === 1 ? '' : 's'} ago`);
+      });
+
+      console.log('\nNext Action: Run /specweave:increment "feature description" to start new work');
+    }
+    return;
+  }
+
+  // Step 4: Show progress for each active increment
+  for (const increment of increments) {
+    console.log(`📦 Increment: ${increment.id}`);
+    console.log(`Status: ${increment.status}`);
+
+    const started = new Date(increment.created);
+    const lastActivity = new Date(increment.lastActivity);
+    const ageHours = Math.floor((Date.now() - started.getTime()) / (1000 * 60 * 60));
+    const lastActivityHours = Math.floor((Date.now() - lastActivity.getTime()) / (1000 * 60 * 60));
+
+    console.log(`Started: ${ageHours} hours ago`);
+    console.log(`Last Activity: ${lastActivityHours} hours ago`);
+
+    // Try to read tasks.md for progress
+    const incrementPath = path.default.join(process.cwd(), '.specweave/increments', increment.id);
+    const tasksPath = path.default.join(incrementPath, 'tasks.md');
+
+    if (await fs.default.pathExists(tasksPath)) {
+      const tasksContent = await fs.default.readFile(tasksPath, 'utf-8');
+
+      // Count tasks
+      const taskLines = tasksContent.split('\n').filter(line =>
+        line.match(/^#+\s+(T-?\d+|Task-?\d+):/i)
+      );
+      const completedTasks = tasksContent.split('\n').filter(line =>
+        line.includes('[✅]') || line.includes('[x]') || line.includes('[X]')
+      );
+
+      const total = taskLines.length;
+      const completed = completedTasks.length;
+      const percent = total > 0 ? Math.round((completed / total) * 100) : 0;
+
+      console.log(`\nTask Progress: ${completed}/${total} completed (${percent}%)`);
+
+      if (total > 0) {
+        console.log('\nTasks:');
+        taskLines.slice(0, 10).forEach(line => {
+          const isComplete = line.includes('[✅]') || line.includes('[x]') || line.includes('[X]');
+          const marker = isComplete ? '✅' : '⏳';
+          const taskName = line.replace(/^#+\s+/, '').replace(/\s*\[.*?\]\s*/, '').trim();
+          console.log(`  ${marker} ${taskName}`);
+        });
+
+        if (taskLines.length > 10) {
+          console.log(`  ... and ${taskLines.length - 10} more tasks`);
+        }
+      }
+    }
+
+    console.log(`\nNext Action: Run /specweave:do ${increment.id} to continue work\n`);
+  }
+
+  // Step 5: Show WIP limit warnings
+  if (activeIncrements.length > 2) {
+    console.log('⚠️ Warning: More than 2 active increments (exceeds WIP limit)');
+    console.log('💡 Recommendation: Focus on completing one increment before starting new work\n');
+  } else if (activeIncrements.length === 2) {
+    console.log('✅ 2 active increments (at WIP limit, but OK)\n');
+  } else if (activeIncrements.length === 1) {
+    console.log('✅ 1 active increment (optimal focus)\n');
+  }
+});
+
+export default task;
+```

package/plugins/specweave/commands/specweave-reopen.md

@@ -0,0 +1,391 @@
+---
+name: specweave-reopen
+description: |
+  Reopen completed increments, tasks, or user stories when issues are discovered.
+  Validates WIP limits, creates audit trail, and syncs to external tools.
+  Use when recently completed work has issues that need fixing.
+---
+
+# Reopen Increment, Task, or User Story
+
+Reopen completed work when issues are discovered after completion.
+
+## Quick Start
+
+```bash
+# Reopen entire increment
+/specweave:reopen 0031 --reason "GitHub sync failing"
+
+# Reopen specific task
+/specweave:reopen 0031 --task T-003 --reason "API integration broken"
+
+# Reopen user story (all related tasks)
+/specweave:reopen 0031 --user-story US-001 --reason "Acceptance criteria not met"
+```
+
+## Smart Detection First!
+
+**Before using this command manually**, try reporting your issue naturally:
+```
+"The GitHub sync isn't working"
+```
+
+The `smart-reopen-detector` skill will:
+1. 🔍 Scan recent work
+2. 🎯 Find related items
+3. 💡 Suggest the exact command to run
+
+## Usage
+
+### Reopen Entire Increment
+
+Reopens the increment and marks all tasks as active.
+
+```bash
+/specweave:reopen <increment-id> --reason "Why reopening"
+```
+
+**Example**:
+```bash
+/specweave:reopen 0031-external-tool-status-sync --reason "GitHub sync failing in production"
+```
+
+**What happens**:
+1. ✅ Changes status: COMPLETED → ACTIVE
+2. 📋 Reopens all completed tasks: [x] → [ ]
+3. ⚠️  Checks WIP limits (warns if exceeded)
+4. 📝 Creates audit trail in metadata.json
+5. 🔄 Syncs to external tools (GitHub/JIRA/ADO)
+6. 📊 Updates status line
+
+### Reopen Specific Task
+
+Reopens a single task without changing increment status.
+
+```bash
+/specweave:reopen <increment-id> --task <task-id> --reason "Why reopening"
+```
+
+**Example**:
+```bash
+/specweave:reopen 0031 --task T-003 --reason "GitHub API returning 500 errors"
+```
+
+**What happens**:
+1. ✅ Updates task status: [x] → [ ]
+2. 📝 Adds annotation: "Reopened: YYYY-MM-DD - reason"
+3. 🔄 Unchecks task checkbox in external issue (if synced)
+4. 📊 Updates status line progress
+
+### Reopen User Story
+
+Reopens a user story and all its related tasks.
+
+```bash
+/specweave:reopen <increment-id> --user-story <us-id> --reason "Why reopening"
+```
+
+**Example**:
+```bash
+/specweave:reopen 0031 --user-story US-001 --reason "Authentication not working as specified"
+```
+
+**What happens**:
+1. ✅ Finds all tasks with AC-US1-XX
+2. 📋 Reopens each task: [x] → [ ]
+3. 📄 Updates user story status in living docs
+4. 🔄 Syncs to external tools
+
+### Force Reopen (Bypass WIP Limits)
+
+Use `--force` to bypass WIP limit checks (use sparingly!).
+
+```bash
+/specweave:reopen <increment-id> --force --reason "Critical production issue"
+```
+
+**Example**:
+```bash
+/specweave:reopen 0031 --force --reason "Production down, need immediate fix"
+```
+
+**⚠️  Warning**: This can violate WIP limits. Use only for:
+- Critical production incidents
+- Hotfixes
+- When no other increment can be paused
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `<increment-id>` | Yes | Increment to reopen (e.g., `0031` or `0031-external-tool-status-sync`) |
+| `--reason <text>` | Yes | Why reopening (for audit trail) |
+| `--task <id>` | No | Reopen specific task (e.g., `T-003`) |
+| `--user-story <id>` | No | Reopen user story + related tasks (e.g., `US-001`) |
+| `--force` | No | Bypass WIP limit checks |
+
+## WIP Limit Validation
+
+The command automatically checks WIP limits before reopening increments.
+
+**Example (limit exceeded)**:
+```
+⚠️  WIP LIMIT WARNING:
+   Current active: 2 features
+   Limit: 2 features
+   Reopening 0031 will EXCEED the limit (3/2)!
+
+Options:
+1. Pause another feature: /specweave:pause 0030 --reason "Paused for critical fix"
+2. Complete another feature: /specweave:done 0029
+3. Force reopen: /specweave:reopen 0031 --force --reason "Production critical"
+
+Continue? (y/n)
+```
+
+**Unlimited types** (no WIP check):
+- `hotfix` - Critical production fixes
+- `bug` - Production bug investigations
+- `experiment` - POCs and spikes
+
+## Audit Trail
+
+Every reopen is tracked in the increment's metadata.json:
+
+```json
+{
+  "id": "0031-external-tool-status-sync",
+  "status": "active",
+  "reopened": {
+    "count": 1,
+    "history": [
+      {
+        "date": "2025-11-14T15:30:00Z",
+        "reason": "GitHub sync failing",
+        "previousStatus": "completed",
+        "by": "user"
+      }
+    ]
+  }
+}
+```
+
+Tasks are also annotated:
+
+```markdown
+### T-003: GitHub Content Sync
+
+**Status**: [ ] (Reopened: 2025-11-14 - GitHub sync failing)
+
+**Previous Completions**:
+- Completed: 2025-11-12T10:00:00Z
+- Reopened: 2025-11-14T15:30:00Z - GitHub sync failing
+```
+
+## External Tool Sync
+
+When you reopen an increment/task, it syncs to external tools:
+
+### GitHub
+- Reopens closed issue
+- Updates issue body: "⚠️  **Reopened**: [reason]"
+- Unchecks completed task checkboxes
+- Adds label: `reopened`
+
+### JIRA
+- Transitions issue: Done → In Progress
+- Adds comment: "Reopened: [reason]"
+- Updates resolution: None
+
+### Azure DevOps
+- Updates work item state: Closed → Active
+- Adds comment: "Reopened: [reason]"
+
+## Examples
+
+### Example 1: Production Bug
+```bash
+# Discover via smart detector
+"The payment processing is broken after deployment"
+
+# Suggested command (from smart detector)
+/specweave:reopen 0028-payment-integration --reason "Payment processing failing in prod"
+
+# Result
+✅ Increment 0028 reopened
+⚠️  WIP LIMIT: 3/2 active features (EXCEEDED)
+📋 Reopened 5 tasks
+🔄 Synced to GitHub issue #123
+💡 Continue work: /specweave:do 0028
+```
+
+### Example 2: Specific Task Fix
+```bash
+# Surgical reopen (just one task)
+/specweave:reopen 0031 --task T-003 --reason "GitHub API rate limiting not handled"
+
+# Result
+✅ Task T-003 reopened
+📊 Progress: 23/24 tasks (95%)
+💡 Fix and mark complete: [x] in tasks.md
+```
+
+### Example 3: User Story Not Met
+```bash
+# Reopen entire user story
+/specweave:reopen 0025 --user-story US-002 --reason "Security requirements not satisfied"
+
+# Result
+✅ User story US-002 reopened
+📋 Reopened 3 related tasks: T-004, T-005, T-006
+📄 Updated living docs: us-002-security-requirements.md
+🔄 Synced to JIRA story AUTH-123
+```
+
+## Status Line Integration
+
+After reopening, the status line shows:
+
+```
+📊 0031-external-tool-status-sync | ⚠️  REOPENED | 23/24 tasks (95%) | GitHub sync failing
+```
+
+The `⚠️  REOPENED` badge indicates the increment was previously completed.
+
+## Common Scenarios
+
+### Scenario 1: Tests Passing Locally, Failing in CI
+
+```bash
+# Reopen increment to investigate
+/specweave:reopen 0032 --reason "CI tests failing, passing locally"
+
+# Debug CI config
+# Fix issue
+# Mark complete again
+```
+
+### Scenario 2: Feature Works but Acceptance Criteria Not Met
+
+```bash
+# Reopen specific user story
+/specweave:reopen 0029 --user-story US-003 --reason "Missing error handling requirement"
+
+# Implement missing AC
+# Complete user story
+```
+
+### Scenario 3: Regression Found
+
+```bash
+# Reopen old increment (if within 7 days)
+/specweave:reopen 0027 --task T-012 --reason "Regression: login timeout increased"
+
+# Fix regression
+# Add regression test
+# Complete
+```
+
+## Integration with Workflow
+
+**Full workflow**:
+```bash
+# 1. Report issue (triggers smart detector)
+"The GitHub sync is broken"
+
+# 2. Smart detector suggests
+# /specweave:reopen 0031 --task T-003 --reason "GitHub sync broken"
+
+# 3. Execute reopen
+/specweave:reopen 0031 --task T-003 --reason "GitHub sync broken"
+
+# 4. Check status
+/specweave:status
+
+# 5. Fix the issue
+# Edit code...
+
+# 6. Mark complete
+# Update tasks.md: [ ] → [x]
+
+# 7. Close increment (if all tasks done)
+/specweave:done 0031
+```
+
+## Best Practices
+
+### ✅ Do
+- Always provide a clear `--reason`
+- Check WIP limits first (`/specweave:status`)
+- Use task-level reopen for surgical fixes
+- Use increment reopen for systemic issues
+- Add reopened annotation to tasks.md
+
+### ❌ Don't
+- Abuse `--force` (respect WIP limits)
+- Reopen old increments (>7 days) without investigation
+- Reopen without understanding the issue
+- Skip the reason (audit trail is critical)
+
+## Troubleshooting
+
+**Problem**: "Cannot reopen: increment status is active, not completed"
+
+**Solution**: Increment is already active, no need to reopen. Just continue work.
+
+---
+
+**Problem**: "WIP limit exceeded"
+
+**Solution**: Pause or complete another increment first:
+```bash
+/specweave:pause 0030 --reason "Paused for critical fix"
+/specweave:reopen 0031 --reason "Production issue"
+```
+
+---
+
+**Problem**: "Task T-003 not found in tasks.md"
+
+**Solution**: Check task ID spelling:
+```bash
+# List all tasks
+cat .specweave/increments/0031-external-tool-status-sync/tasks.md | grep "^##"
+```
+
+---
+
+**Problem**: "User story US-001 not found"
+
+**Solution**: Check spec.md for correct user story ID.
+
+## Related Commands
+
+- `/specweave:status` - Check WIP limits
+- `/specweave:progress` - See increment progress
+- `/specweave:do` - Continue work after reopening
+- `/specweave:pause` - Pause another increment to make room
+- `/specweave:done` - Close increment when fixed
+
+## Technical Details
+
+**Implementation**:
+- Core logic: `src/core/increment/increment-reopener.ts`
+- Smart detection: `src/core/increment/recent-work-scanner.ts`
+- Status transitions: Updated in `increment-metadata.ts`
+
+**Validation**:
+- ✅ Increment exists
+- ✅ Current status is COMPLETED
+- ✅ WIP limits (unless --force)
+- ✅ Task/User story exists
+
+**External Sync**:
+- GitHub: `plugins/specweave-github/hooks/post-task-completion.sh`
+- JIRA: `plugins/specweave-jira/hooks/post-task-completion.sh`
+- ADO: `plugins/specweave-ado/hooks/post-task-completion.sh`
+
+---
+
+**Related Skills**: `smart-reopen-detector`
+**Auto-activation**: Report issues like "not working", "broken", "failing"