Check If Done

Check if it is actually done

!"$CLAUDE_PLUGIN_ROOT/scripts/probe.sh" 2>/dev/null || "$HOME/.claude/skills/multi/scripts/probe.sh" 2>/dev/null || ./.claude/skills/multi/scripts/probe.sh

A model that just wrote code is the worst possible judge of whether that code works. It compares the task to its own summary of what it did, the two match, and it says done. Nothing was verified — the check was a memory of an intention.

So this skill does two things a normal review does not:

1. Someone who did not write it looks at it — Codex, OpenCode, and a sub-agent that has never seen this conversation.
2. Nothing is called done without an executed command behind it. Not "the tests should pass" — the command, its output, its exit code.

$SCRIPTS is whatever the probe printed as scripts-dir:.

If the line above reads Shell substitution failed instead of probe output, the session is in a git worktree whose shell gate refused the header; the plugin is fine. Run "$HOME/.claude/skills/multi/scripts/probe.sh" (or the same under $CLAUDE_PLUGIN_ROOT) yourself, as one plain command, and read scripts-dir: from that.

First: what was promised?

Everything here is a comparison, so you need both sides. In this order:

1. What the user named — a plan file, a spec, an issue, a PR description. Read it.
2. This session — what was asked for and what you said you did. Write it down as an explicit list before you go further; a promise you keep only in your head is one you will grade yourself on generously.
3. Nothing? Then say so and stop: "nothing to check against — point me at a plan or tell me what this was supposed to do." Do not substitute a code review. There is already a skill for that, and silently becoming it is how a completion check turns into theatre.

Then resolve the other side: what actually changed. git diff, the branch, the files you touched. Say both out loud in one line before launching anything:

Promised: <where it came from — plan.md, the issue, what we did this session>
Changed:  <concrete paths or range>

Launch the outside reviewers

They are free and slow to start, so they go first and run in the background while you do the real work below.

RUN="$($SCRIPTS/run-dir.sh --slug <two-to-four words: the project and the job, e.g. skills-fixing-multi>)"

# The reviewers run on a COPY of the work tree, never the live one. These are
# the same "read-only" reviewers that can wipe uncommitted work — a Bash
# sub-agent, or an opencode flipped to bash by a hostile repo config — so hand
# them a copy and let it take any destructive hit. The copy carries the change as
# review.diff (no git in it) and drops the repo's opencode config. Pass the same
# --diff you are checking; drop it if there is no diff to point at.
REPO="$(git -C "${REVIEW_DIR:-.}" rev-parse --show-toplevel)"
COPY="$($SCRIPTS/snapshot.sh --repo "$REPO" [--diff <spec>] --dest "$RUN/snapshot")"
# If the snapshot failed (empty $COPY), STOP — do not fall through to reviewing
# the live tree, which is the exact data-loss path this exists to close.
[ -n "$COPY" ] || { echo "snapshot failed — not reviewing the live tree"; exit 1; }
# Snapshot ONCE; later blocks read this path back, they do not re-snapshot.
echo "$COPY" > "$RUN/copy-path"

# Quoted heredoc on purpose: the promise below is pasted from a plan/issue/spec,
# and an unquoted heredoc would EXECUTE any $(...) or backticks in it while
# writing the file. The change-location line belongs here ONLY if you snapshotted
# with --diff; with no --diff there is no review.diff, so describe what changed in
# words instead.
cat > "$RUN/done-prompt.md" <<'EOF'
<the promise, as a concrete list of what was supposed to end up working>

<with --diff: "The change under review is in review.diff at the root of the code
you are in (statuses in review.manifest); new files are in the tree. No .git
here — do not run git." Without --diff: what changed, in words.>
EOF

$SCRIPTS/ask.sh --repo "$COPY" --question-file "$RUN/done-prompt.md" \
                --out-prefix "$RUN/done" --effort high > "$RUN/ask.log" 2>&1

Run that last command as a background task (the Bash tool's run_in_background): a foreground Bash call is capped at ten minutes, and a killed ask.sh marks every backend KILLED.

When you come back for the answers, block on them instead of reading whatever is there: $SCRIPTS/wait.sh --prefix "$RUN/done" --max 540 prints one line per backend (ok, FAILED: <reason>, or still running with its elapsed time and timeout) and exits 1 while any is still running — call it again. An empty done-<backend>.txt beside a live done-<backend>.txt.running is a reviewer still writing, not a missing one.

No --backend: who answers is the default profile in the user's config.toml, the same as code-review and ask. Pass --backend only for a set the user asked for. reviewer-model: in the probe is a different knob (the Claude sub-agent model) and has nothing to do with ask.sh.

$RUN is this session's own directory. Shell variables do not survive between commands, so repeat RUN= and REPO= in later blocks. COPY is snapshotted once here; later blocks (the execution sub-agent, ask.sh) read it back with COPY="$(cat "$RUN/copy-path")" — never re-run snapshot.sh, or you rebuild the copy while a reviewer is reading it.

Append this to the prompt file, verbatim in spirit — it is what makes them answer the right question:

You are checking whether a task was actually finished, not whether the code is good. For each item promised: does the code really do it, end to end, or does it only look like it does? Name what is missing, what is half-done, and what was silently dropped. Read the actual code — do not trust any summary of it. Anchor every point to a file and line. If everything promised is really there, say so plainly.

Spawn the execution sub-agent at the same time, in the same message. Give it the promise, and what you know about the task — it is the only reviewer with access to intent, and without that context it will correctly refuse to guess. Point it at $COPY: read the code and $COPY/review.diff there. It has no Bash tool (it reads with Read/Grep/Glob), so it cannot run a command against the live tree — that is what keeps a stray git checkout off the user's uncommitted work, not the prompt. The verification that DOES run commands is yours, below, on the real tree.

Then run the checks yourself

The reviewers judge on a copy; you verify on the real tree. This step is yours, in the live checkout — running the actual tests, CLI and migrations is the point, and it is safe because it is you doing it deliberately, not a reviewer let loose. For every claim that something works, execute the thing that proves it and read the output.

• Tests exist → run them. Not the whole suite if it is slow: the ones covering what changed.
• It is a CLI → invoke it, with real arguments.
• It is an endpoint → call it.
• It is a migration → run it against a scratch database.
• It writes to a database or a file → look at what landed, not at the code that was supposed to land it.
• Nothing runnable exists → say that. "No way to verify this" is a finding, and often the most important one.

Rules that keep this honest:

• Fresh output only. A test run from earlier in the session proves nothing about the code as it stands now.
• Read the whole output, including the exit code. A suite that prints PASSED and exits non-zero did not pass.
• A check that cannot fail is not a check. If it passes with the feature ripped out, it never tested the feature.
• Tests changed, code untouched? A diff that only edits test files — new assertions, loosened expectations, a deleted case — while the code under test stands still is a red flag: the tests may have been bent to fit a bug instead of the code fixed to pass. Read what the assertions claim now, not that they are green.
• Never edit code to make a check pass while running this skill. That is the one move that turns a completion check into a lie.

Do not ask permission to run tests, builds or a CLI in read-only ways — that is the job. Do ask before anything that writes outside the working tree: real migrations, deploys, calls to third-party services with side effects.

Report

# ✅ Check-if-done — <what was promised> 
Checked by: Claude · execution · Codex · OpenCode <model> · OpenRouter <model> [· Gemini]
<one line per reviewer that failed or was missing — `Codex FAILED: <reason>` / `OpenCode FAILED: <reason>` / `OpenRouter FAILED: <reason>` from the one-line text in its `.dead` marker (`done-<backend>.txt.dead`); a backend you launched must appear here or in the list above, never vanish; point at `/multi:setup` to connect anything missing>

## Verdict
DONE: yes | partially | no — <one sentence>

## ❌ Not done (<n>)
1. **<promised item>** — `path/file.py:120`
   <what is missing> — evidence: <the command you ran and what it actually said>

## 🟡 Half done (<m>)
- **<promised item>** — <what works, what does not> — `path/file.py:88`

## 🔍 Unverifiable (<k>)
- **<promised item>** — no runnable check exists for this. <What would be needed.>

## ✅ Verified working (<j>)
- **<promised item>** — `pytest tests/test_auth.py` → 12 passed, exit 0

## Reviewers disagreed (<d>)
- <where Codex and the sub-agent split, and your call after looking>

Rules for the report:

• An item with no executed evidence never lands in "Verified working." It goes to Unverifiable, however obviously correct it looks. That distinction is the entire point of this skill.
• Quote what the command actually printed, not your reading of it.
• Anything promised must appear in exactly one section. A promise that shows up nowhere is the failure this skill exists to catch — go find it.
• If the outside reviewers found nothing and every check passed, say DONE: yes plainly. That is a real answer, not a wasted run.

Then stop. Offer to fix what is open — do not start fixing unprompted, and never in the same breath as the verdict.