/update-plan-status

Verify the completion status of a plan by checking associated issues, pull requests, and validating that the actual functionality has been implemented and tested.

Input Parsing

The user invoked: /update-plan-status {plan_file_path}

• The path should point to a plan file (typically in /plans directory)
• If no path is provided, list available plan files and ask user to specify

Your Task

1. Read the specified plan file
2. Find all issues created from this plan (both GitHub and local)
3. Check the status of each issue and its associated PR
4. Validate actual implementation by examining the codebase for expected functionality
5. Verify test coverage for implemented features
6. Generate a comprehensive status report
7. Update the plan file with completion status

Workflow

1. Plan File Analysis

• Read the plan file to understand expected outcomes
• Extract all tasks/requirements that should have been implemented
• Identify success criteria for each task

2. Issue Discovery

If GitHub is available:

• Search for issues referencing this plan file
• Use: gh issue list --search "in:body {plan_file_name}" --state all --json number,title,state,labels,closedAt
• For each issue, extract:
  • Issue number and title
  • Current state (open/closed)
  • Associated labels
  • Linked PR (if any)

If using local files:

• Search /issues/*.md for files with source_plan: {plan_file_path} in frontmatter
• Read each issue file to check:
  • Status field in frontmatter
  • Pull request reference
  • Completion timestamp

3. Pull Request Verification

For each issue with an associated PR:

If GitHub is available:

• Fetch PR details: gh pr view {pr_number} --json number,title,state,mergedAt,mergeable,reviews
• Check PR status:
  • Is it merged? ✓
  • Is it closed without merge? ⚠️
  • Is it still open? ⏳
  • Review status (approved/changes requested/pending)

If using local files:

• Check if the PR branch exists locally
• Verify if branch has been merged to main
• Use: git branch --merged main and git branch --no-merged main

4. Implementation Validation

This is the critical step that goes beyond just checking tickets.

For each task in the plan:

1. Identify what should exist based on the task description

   • New files that should be created
   • Functions/classes that should exist
   • Configuration changes
   • Dependencies that should be added

2. Search the codebase to verify implementation:

   • Use Grep to find relevant code
   • Use Glob to find expected new files
   • Read key files to verify functionality exists
   • Check for proper error handling and edge cases

3. Verify tests exist:

   • Search for test files related to the feature
   • Check test coverage for new functionality
   • Verify tests are actually testing the right things
   • Example: gh pr checks {pr_number} or check test files directly

4. Validate integration:

   • Check that new code integrates with existing systems
   • Verify no breaking changes were introduced
   • Check documentation has been updated

5. Status Categorization

Assign each task one of these statuses:

• ✅ Complete: Issue closed, PR merged, functionality exists and is tested
• ⚠️ Partially Complete: PR merged but missing tests or incomplete implementation
• 🚧 In Progress: Issue open or PR pending review
• ❌ Not Started: No issue created or issue exists but no work done
• ⛔ Blocked: Issue or PR blocked by dependencies or failing checks

6. Status Report Generation

Create a comprehensive report with:

# Plan Status Report: {plan_file_name}
Generated: {timestamp}

## Overall Status
- Total Tasks: {count}
- ✅ Complete: {count} ({percentage}%)
- ⚠️ Partially Complete: {count} ({percentage}%)
- 🚧 In Progress: {count} ({percentage}%)
- ❌ Not Started: {count} ({percentage}%)
- ⛔ Blocked: {count} ({percentage}%)

## Detailed Task Status

### ✅ Complete ({count})
1. **{task_title}**
   - Issue: #{number} (Closed)
   - PR: #{number} (Merged on {date})
   - Implementation: Verified at {file_path}:{line}
   - Tests: ✓ {test_count} tests found
   - Coverage: {percentage}% of new code

### ⚠️ Partially Complete ({count})
1. **{task_title}**
   - Issue: #{number} (Closed)
   - PR: #{number} (Merged on {date})
   - Implementation: Found at {file_path}:{line}
   - ⚠️ Issues: {missing_tests | incomplete_implementation | missing_docs}

### 🚧 In Progress ({count})
1. **{task_title}**
   - Issue: #{number} (Open)
   - PR: #{number} (Under review)
   - Review Status: {approved | changes_requested | pending}

### ❌ Not Started ({count})
1. **{task_title}**
   - No issue found
   - Action: Run `/tasks-from-plan {plan_file}` to create issues

### ⛔ Blocked ({count})
1. **{task_title}**
   - Issue: #{number} (Open)
   - Blocker: {reason}
   - Dependencies: {dependency_list}

## Recommendations

### High Priority Actions
- [ ] {action_item_1}
- [ ] {action_item_2}

### Quality Improvements Needed
- [ ] {quality_issue_1}
- [ ] {quality_issue_2}

### Next Steps
1. {next_step_1}
2. {next_step_2}

## Implementation Verification Details

### Missing Tests
- {feature_name}: Expected tests in {expected_location}, but not found

### Incomplete Implementations
- {feature_name}: PR #{number} merged but {specific_functionality} not found in codebase

### Documentation Gaps
- {feature_name}: No documentation found for {aspect}

7. Update Plan File

Add a status section to the plan file (at the end):

---

## Implementation Status
Last updated: {timestamp}

### Completion Summary
- Overall: {percentage}% complete
- Tasks Complete: {count}/{total}
- All PRs Merged: {yes/no}
- All Tests Passing: {yes/no}

### Detailed Status
{link_to_status_report}

### Outstanding Items
- {item_1}
- {item_2}

Advanced Verification Strategies

For Security Plans

• Verify security fixes are actually in place
• Check that vulnerable code patterns have been removed
• Ensure security tests exist and pass
• Validate that dependencies have been updated

For Performance Plans

• Check that performance metrics are being tracked
• Verify benchmarks exist and show improvement
• Look for profiling or performance test results

For Architecture Plans

• Verify new architecture patterns are followed
• Check that old patterns have been refactored
• Ensure architecture documentation is updated

For Testing Plans

• Verify test coverage has increased
• Check that test types (unit/integration/e2e) match requirements
• Ensure CI/CD runs new tests

Example Commands

# Find issues related to a plan (GitHub)
gh issue list --search "in:body security-review-2024" --state all --json number,title,state

# Check PR status
gh pr view 42 --json state,mergedAt,reviews,checks

# Find test files for a feature
grep -r "test.*userValidation" --include="*.test.ts" --include="*.spec.ts"

# Check if specific functionality exists
grep -r "function validateUserInput" src/

# Check test coverage (if coverage tool available)
npm run test:coverage | grep "userValidation"

Error Handling

• Plan file not found: Prompt for valid path or list available plans
• No issues found: Suggest running /tasks-from-plan first
• GitHub unavailable: Fall back to local issue file checking
• Cannot verify implementation: Report as "⚠️ Unable to verify" with explanation

Important Notes

• This command is read-only and doesn't modify issues or PRs
• It provides objective assessment based on evidence
• The actual implementation check is critical - don't just rely on issue/PR status
• If tests are missing, that's a partial completion, not full completion
• Document why something is marked incomplete in the report

Success Criteria

A task is only marked ✅ Complete when ALL of these are true:

1. Issue is closed (or marked complete in local file)
2. PR is merged (or changes are in main branch)
3. Expected functionality exists in the codebase
4. Tests exist for the new functionality
5. Tests are passing (verified in PR checks or local test runs)
6. Documentation is updated (if applicable to the task)

This rigorous verification ensures that "done" actually means "done and tested".