Checklist

# Implementation Checklist Verification

Verify implementation status against `.implementation-plan.md` files and update checkboxes to reflect actual code state.

## Silent Mode (`--silent`)

When invoked with `--silent`, execute autonomously without asking questions:

- **Do not ask for confirmation** before updating checklists
- **Process all discovered implementation plans** automatically
- **Make verification decisions** based on code analysis:
  - Mark items complete if matching code artifacts exist
  - Keep items unchecked if only stubs or placeholders exist
  - Use grep/search to find implementations by name patterns
- **Proceed through all targets** without user interaction
- **Document any ambiguous findings** in the output summary under a "Verification Notes" section

## Purpose

This command synchronizes implementation plan checklists with actual code. Use when:
- Code was written manually or by other tools
- Implementation plans are out of sync with reality
- You want to verify progress before continuing development
- After merging branches or pulling changes

## Prerequisites

- Implementation plans exist (run `/plan` first if missing)
- Component has `.implementation-plan.md` file

## Instructions

You are orchestrating the checklist verification pipeline. This command triggers the `planner-agent` for:
- Each component with an `.implementation-plan.md` file
- Infrastructure with `.specs/deployment/.implementation-plan.md`

---

## Phase 1: Discovery

Scan for implementation plans:

{container}/{component}/.implementation-plan.md .specs/deployment/.implementation-plan.md

---

## Phase 2: Verification (Parallel, Max 2 Per Batch)

Spawn `planner-agent` instances in parallel, with a **maximum of 2 concurrent agents** per batch. If more targets exist, process them in sequential batches.

### Agent Behavior

For each target, the agent must:

1. **Read the implementation plan** - Parse all action items with checkboxes
2. **Identify unchecked items** - Focus on items marked `[ ]` (not started)
3. **Research each item individually** - Search for actual implementation
4. **Update checkboxes** - Mark `[x]` for items that exist in code
5. **Update progress metrics** - Recalculate summary table

### Verification Rules

For each unchecked item, the agent must search for evidence:

| Item Type | How to Verify |
|-----------|---------------|
| Type/Interface | Search for `interface {Name}` or `type {Name}` or `class {Name}` in src/ |
| Class | Search for `class {Name}` in src/ |
| Method | Search for `def {name}` or `{name}(` within the class file |
| Property | Search for property definition in class file |
| Test | Search for `test_{name}` or `it('{name}'` in tests/ |
| Error handling | Search for try/except or error class usage |
| Azure Function | Search for `@app.route` or function trigger decorator |
| Bicep module | Search for `.bicep` file existence |
| Pipeline | Search for `.yml` workflow file |

### Update Criteria

Mark item as `[x]` completed if:
- The code artifact exists
- It matches the specification (name, signature, behavior)
- Basic functionality is implemented (doesn't need to be perfect)

Keep item as `[ ]` not started if:
- No matching code found
- Only stub/placeholder exists
- Implementation is fundamentally wrong

---

## Execution Flow

Phase 1: Discovery │ Find all .implementation-plan.md files │ Build list of targets ▼ Phase 2: Verification (BATCHED, max 2 per batch) │ Batch 1 (up to 2 agents): │ ├── container-a/component-1 → planner-agent → verify & update │ ├── container-a/component-2 → planner-agent → verify & update │ Wait for batch to complete │ ▼ │ Batch 2 (remaining agents, up to 2): │ ├── ... │ └── infrastructure → planner-agent → verify & update │ Wait for batch to complete ▼ Phase 3: Summary │ Aggregate progress across all plans │ Report changes made │ Show overall completion status

---

## How to Execute

When this command runs:

1. **Discover all implementation plans**:
   - Glob for `**/.implementation-plan.md`
   - Build complete list of targets

2. **Spawn planner-agent instances IN BATCHES** (max 2 concurrent per batch):
   - Split targets into batches of up to 2
   - For each batch: spawn agents in parallel (single message, multiple Task tool calls)
   - **CRITICAL**: Use `run_in_background: false` for ALL agents
   - Wait for all agents in current batch to complete before starting next batch
   - Continue until all targets are processed

3. **Aggregate results**:
   - Summarize changes made
   - Report overall progress
   - Identify any issues found

Use the Task tool with `subagent_type: planner-agent` and `run_in_background: false` for each target.

---

## Agent Prompt Template

### Component Verification Prompt

Verify implementation status for component: {container}/{component}

Your Task

1. Read the implementation plan: {container}/{component}/.implementation-plan.md

2. For EACH unchecked item (marked [ ]):

   • Search the codebase for the actual implementation
   • Verify it exists and matches the specification
   • Document what you found

3. Update the implementation plan:

   • Change [ ] to [x] for items that are implemented
   • Keep [ ] for items not yet implemented
   • Update the Summary metrics table

Verification Locations

Search for implementations in:

• Source code: {container}/{component}/src/
• Tests: {container}/{component}/tests/
• Adjacent files: {container}/{component}/*.ts or *.py

Search Strategy

For each item type:

• Types/Interfaces: Grep for interface {Name}, type {Name}, class {Name}, or Pydantic model
• Classes: Grep for class {Name}
• Methods: Read the class file and search for method definition
• Properties: Read the class file and search for property
• Tests: Grep for test function name in tests/
• Error handling: Look for try/except blocks or