completion-check

What the source does

• FilesystemNone observedNo reads or writes in the source
• NetworkNone observedNo outbound calls in the source
• ShellNone observedNo commands run in the source
• DependenciesPinnedNothing floats
• SecretsNone foundNo keys in source

Five audit layers

Gates applied: no behavioural pass.

.claude/scripts/mcp

Audit 0.4.1 · source sha 79ffdab59d4c · 31 Oct 2026Report an issue or request a re-scan

• Publisherparcadei GitHub userOwner of the repository this skill is read from
• Source folderparcadei/continuous-claude-v3/.claude/skills/completion-checkThe exact folder we audited
• LicenceMITAs the repository states it
• Commit pinned for this verdict79ffdab59d4cA new audit runs when the source changes
• Repository statusNot archivedLast push 278 days ago
• Sandboxed runNot runSkills are read, not executed; layer L4 is skipped

Its description: Completion Check: Verify Infrastructure Is Wired

---
name: completion-check
description: "Completion Check: Verify Infrastructure Is Wired"
user-invocable: false
---

# 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

Excerpt, first 2,931 characters of SKILL.md, verbatim from the audited commit. It is text from someone else’s repository, quoted so you can judge it before your agent reads it.

uv run python -m my_feature

git clone https://github.com/parcadei/continuous-claude-v3
git -C continuous-claude-v3 checkout 79ffdab59d4c

Works in

1. 2026-10-31
   ✓SAFE B 89 / 100

   first audit · source 79ffdab59d4c

Questions about completion-check

• github.com/parcadei/continuous-claude-v3/tree/main/.claude/skill — the audited source at commit 79ffdab59d4c and every finding aboveObserved · 31 Oct 2026

Spotted something wrong? Report a correction · Methodology