Recheck

Recheck

Success

I := signals computed ∧ (S == ∅ ∨ informative → auto-proceed) ∨ (S ambiguous → DP presented)

Let: N := issue number S := signal set { git-drift, symbol-missing, dep-resolved } M := mode ∈ { pipeline, standalone } ambiguous(S) ≔ S contains symbol-missing ∨ dep-resolved informative(S) ≔ S ≠ ∅ ∧ ¬ambiguous(S) # git-drift only

Drift-check N against 3 deterministic signals (no LLM). AQ only when signals are ambiguous (missing symbols / closed blockers). Pure git-drift is informational — print and auto-proceed. Standalone-safe: callable without /R-dev. Invoked by /R-dev between triage and frame.

Entry

/R-recheck #N            standalone — DP only if ambiguous signals (Proceed | Close | Abort)
(invoked by /R-dev)      pipeline  — same; DP adds Update issue first when ambiguous

Pipeline

Step 0 — Parse + Detect Mode

Resolve N from:

• #N positional arg → strip #
• --issue N flag
• $ARGUMENTS (bare number)

Detect M:

• --from-dev flag present → pipeline
• else → standalone

Check --update-iter=2 flag: ∃ → this is the 2nd run after Update; omit Update issue first from DP even if signals fire.

Issue N ¬∃ (gh returns 404) → print Error: issue #N not found. + exit 1.

Step 1 — Fetch Issue

gh issue view N --json number,title,body,labels,createdAt \
  --jq '{number:.number, title:.title, body:.body, labels:[.labels[].name], createdAt:.createdAt}'

Note: gh issue view does not expose parent or blocked-by as structured JSON fields. Primary approach: grep body for blocked by #N, blocks #N, parent: #N, closes #N patterns (Step 2). Secondary: gh api repos/{owner}/{repo}/issues/N/sub_issues if sub-issue API is available.

Step 2 — Extract Refs from Body

From body, regex-extract THEN validate. Extraction is loose; validation is strict — drop anything that fails.

Validation rationale:

• Symbols flow into grep arguments — without the allowlist, a body-symbol like -e '/etc/passwd' or $(id) would inject as a grep flag or command substitution.
• Paths flow into git log -- <paths> — without the .. ban + absolute-path ban, traversal patterns leak outside the repo.
• Blocker numbers flow into gh issue view <N> — the \d+ regex enforces numeric, but the dedup + cap prevents an issue body with 200 closes #N references from triggering 200 sequential gh API calls.

Loose extraction (e.g. picking up an "error string" candidate) then strict validation = silently drop the candidate, do not abort.

∅ validated cited paths → git-drift falls back to entire repo (all commits since createdAt). ∅ validated symbols → symbol-drift is a no-op. ∅ validated blocked-by → dep-drift is a no-op.

Step 3 — Drift Checks (parallel, deterministic)

Run all 3 checks concurrently. Each emits 0 or more signal entries.

git-drift

created_at=$(gh issue view N --json createdAt --jq '.createdAt')
# If cited paths extracted:
git log --since="$created_at" --oneline -- path/to/cited/file.ext ... | wc -l
# If ∅ cited paths (fallback: whole repo):
git log --since="$created_at" --oneline | wc -l

Signal fires if count > 0. kind: "git-drift" | description: "N commits on cited paths since issue created" | evidence: [sha list]

symbol-drift

# $sym already validated in Step 2 to match ^[A-Za-z_][A-Za-z0-9_]{0,63}$
# Use grep -F (fixed-string) + -- end-of-options marker for defense-in-depth.
for sym in <validated_symbols>; do
  grep -rqF -- "$sym" --include='*.ts' --include='*.tsx' --include='*.js' \
       --include='*.py' --include='*.sh' --include='*.md' . \
    || echo "missing: $sym"
done

Signal fires per missing symbol. kind: "symbol-missing" | description: "symbol '$sym' not found in tree" | evidence: ["$sym"]

dep-drift

# $blocker already validated in Step 2 to be numeric, deduped, and capped at 20.
# Capture stderr explicitly to distinguish "issue is open" from "API error" —
# silently treating API errors as "not closed" would mask the dep-drift signal.
for blocker in <validated_blockers>; do
  if ! out=$(gh issue view "$blocker" --json state --jq '.state' 2>&1); then
    echo "dep-drift: error fetching #$blocker — skipped ($out)" >&2
    continue
  fi
  [ "$out" = "CLOSED" ] && echo "closed: #$blocker"
done

Signal fires per closed blocker. Semantics: closed blocker = signal regardless of meaning (could be "ready to proceed, re-verify scope" OR "this issue is now moot") — user choice surfaces the ambiguity; user decides. API failures (auth, network, rate-limit, repo-not-found) are surfaced as warnings on stderr rather than silently swallowed — operators see "skipped" entries and can re-run if needed. kind: "dep-resolved" | description: "blocker #$blocker is now closed" | evidence: ["#$blocker"]

Step 4 — Decide

Severity split (before any AQ)

Rationale: git-drift alone means “code moved nearby” — issue still open, symbols found, blockers still open (or none). Default path is always Proceed; asking is pure friction. symbol-missing / dep-resolved can mean the issue is moot or needs rewrite → real decision.

S == ∅ (no signals)

• Pipeline mode (M == pipeline): Print exactly: Issue still relevant. Return silently. /R-dev proceeds to next step.

• Standalone mode (M == standalone): Print richer summary:

  Issue #N still relevant.
  Checks: git-drift (0 commits) | symbol-drift (all found) | dep-drift (no closed blockers)
  

  Exit 0.

informative (git-drift only — auto-proceed)

Render ## Drift Signals block (same table as below), then print exactly one line and return exit 0:

Drift noted (git-drift only) — proceeding. Re-run /R-recheck or update the issue if scope looks stale.

¬AQ. Pipeline and standalone share this path. /R-dev continues to next step.

ambiguous (symbol-missing and/or dep-resolved — AQ)

Render ## Drift Signals block:

## Drift Signals — Issue #N

| Kind           | Description                          | Evidence             |
|----------------|--------------------------------------|----------------------|
| git-drift      | 12 commits on cited paths since...   | abc1234, def5678 ... |
| symbol-missing | symbol 'WorktreeSetup' not found     | WorktreeSetup        |
| dep-resolved   | blocker #179 is now closed           | #179                 |

(Include any co-occurring git-drift rows for context.)

Then present user choice:

Pipeline DP (4 options — M == pipeline ∧ ¬--update-iter=2):

── Decision: Issue #N ambiguous drift ──
Context:     symbol-missing and/or dep-resolved (see ## Drift Signals above)
Target:      decide whether to continue, update, close, or abort
Path:        executed immediately after choice

Options:
  1. Proceed anyway        — continue, current premise accepted as-is
  2. Update issue first    — re-invoke /issue-triage, then re-run /R-recheck once
  3. Close as resolved/obsolete — gh issue close N --reason completed ; abort /R-dev
  4. Abort                 — exit /R-dev cleanly, no mutation
Recommended: Option 2 if symbols/blockers suggest rewrite; Option 3 if issue is moot

Pipeline DP on 2nd run (M == pipeline ∧ --update-iter=2): Same block, but Option 2 (Update issue first) is OMITTED. Forces terminal decision. No infinite loop.

Standalone DP (3 options — M == standalone):

── Decision: Issue #N ambiguous drift ──
Context:     symbol-missing and/or dep-resolved (see ## Drift Signals above)
Target:      decide whether to continue, close, or abort
Path:        executed immediately after choice

Options:
  1. Proceed    — continue with current premise
  2. Close as resolved/obsolete — gh issue close N --reason completed
  3. Abort      — exit cleanly, no mutation
Recommended: Option 2 if issue is moot; Option 1 if premise still holds

DP Outcomes — Implementation

State

No on-disk artifact. /R-dev tracks recheck as Σ_s (session-only) like validate, ci-watch. Re-running /R-dev #N in a new session re-runs /R-recheck — acceptable: deterministic checks are cheap and fresh state is more valuable than skip-on-resume.

RecheckResult is ephemeral — built during execution, consumed by decide step, then discarded:

• issue_number: int
• signals: Signal[] — empty on clean path; Signal = { kind, description, evidence[] }
• blocking: bool — true iff ambiguous(signals) (symbol-missing ∨ dep-resolved). git-drift-only → blocking: false

Task Integration

• /R-dev owns the dev-pipeline task lifecycle externally
• This skill does NOT update its own dev-pipeline task
• Sub-tasks created: none

Chain Position

• Phase: Frame
• Predecessor: /issue-triage
• Successor: /R-frame (F-lite, F-full) ∨ /R-dev-implement (S, frame skipped)
• Class: adv — /R-dev treats approval-stop separately (frame|analyze|spec|plan); all others are adv (or verdict/loop). The DP rendered on signal-fire is skill-internal: /R-recheck self-manages the blocking decision the same way /R-validate and /R-ci-watch do when they surface failures. From /R-dev's perspective, /R-recheck is always adv.

Exit

Edge Cases

• ∅ cited paths ∧ ∅ symbols ∧ ∅ blockers in body → git-drift uses entire repo since createdAt (commit count); symbol-drift + dep-drift are no-ops.
• Issue ¬∃ (gh 404) → print Error: issue #N not found. + exit 1.
• --update-iter=2 on a clean 2nd run → print Issue still relevant (re-verified after triage update). + return.
• createdAt parse failure → fallback to --since="1 year ago" + warn: Warning: could not parse issue creation date; using 1-year fallback.

$ARGUMENTS