completion-check

# Completion Check: Verify Infrastructure Is Wired When building infrastructure, verify it's actually connected to the system before marking as complete. ## Pattern Infrastructure is not done when the code is written - it's done when it's wired into the system and actively used. Dead code (built but never called) is wasted effort. ## DO 1. **Trace the execution path** - Follow from user intent to actual code execution: ```bash # Example: Verify Task tool spawns correctly grep -r "claude -p" src/ grep -r "Task(" src/ ``` 2. **Check hooks are registered**, not just implemented: ```bash # Hook exists? ls -la .claude/hooks/my-hook.sh # Hook registered in settings? grep "my-hook" .claude/settings.json ``` 3. **Verify database connections** - Ensure infrastructure uses the right backend: ```bash # Check connection strings grep -r "postgresql://" src/ grep -r "sqlite:" src/ # Should NOT find if PostgreSQL expected ``` 4. **Test end-to-end** - Run the feature and verify infrastructure is invoked: ```bash # Add debug logging echo "DEBUG: DAG spawn invoked" >> /tmp/debug.log # Trigger feature uv run python -m my_feature # Verify infrastructure was called cat /tmp/debug.log ``` 5. **Search for orphaned implementations**: ```bash # Find functions defined but never called ast-grep --pattern 'async function $NAME() { $$$ }' | \ xargs -I {} grep -r "{}" src/ ``` ## DON'T - Mark infrastructure "complete" without testing execution path - Assume code is wired just because it exists - Build parallel systems (Task tool vs claude -p spawn) - Use wrong backends (SQLite when PostgreSQL is architected) - Skip end-to-end testing ("it compiles" ≠ "it runs") ## Completion Checklist Before declaring infrastructure complete: - [ ] Traced execution path from entry point to infrastructure - [ ] Verified hooks are registered in .claude/settings.json - [ ] Confirmed correct database/backend in use - [ ] Ran end-to-end test showing infrastructure invoked - [ ] Searched for dead code or parallel implementations - [ ] Checked configuration files match implementation ## Example: DAG Task Graph **Wrong approach:** ``` ✓ Built BeadsTaskGraph class ✓ Implemented DAG dependencies ✓ Added spawn logic ✗ Never wired - Task tool still runs instead ✗ Used SQLite instead of PostgreSQL ``` **Right approach:** ``` ✓ Built BeadsTaskGraph class ✓ Wired into Task tool execution path ✓ Verified claude -p spawn is called ✓ Confirmed PostgreSQL backend in use ✓ Tested: user calls Task() → DAG spawns → beads execute ✓ No parallel implementations found ``` ## Source Sessions - This session: Architecture gap discovery - DAG built but not wired, Task tool runs instead of spawn, SQLite used instead of PostgreSQL