sd0xdev/remind

Remind — Lightweight Model Correction

Detect what rules or steps the model forgot, auto-load the relevant rule files, and execute the correction immediately. Think of this as a "conscience check" that reads the actual rules rather than relying on memory.

⚠️ CRITICAL: Execute, Don't Report

/remind is an executor, not a reporter. After detecting a violation:

1. Output the findings table (for traceability)
2. Invoke the correction command via Skill tool in the same reply — e.g., Skill: /codex-review-doc
3. Do NOT stop after outputting findings

| Prohibited | Correct | |-----------|---------| | ❌ "要執行 /codex-review-doc 嗎？" | ✅ Output findings → immediately invoke /codex-review-doc | | ❌ Output table then stop | ✅ Output table → invoke correction Skill → report result | | ❌ "建議執行..." / "Next step: run..." | ✅ Execute the correction, don't suggest it | | ❌ Ask user for permission | ✅ Auto-loop rules mandate execution without permission |

Exception: Only stop without executing when findings are ### All Clear ✅ (nothing to fix).

Trigger

• Keywords: remind, forgot, check rules, what did I miss, you forgot to, re-read rules, drift, correction
• User suspects model skipped a required step or ignored a rule
• User explicitly says "你忘了做什麼" or similar

When NOT to Use

| Scenario | Alternative | |----------|------------| | Full code review | /codex-review-fast | | What to do next | /next-step | | Workflow progression | /feature-dev | | Adversarial debate | /codex-brainstorm |

Modes

| Mode | Trigger | Behavior | |------|---------|----------| | Smart detect | /remind (no args) | Read state + git → detect violations → auto-load relevant rules | | Specific rule | /remind auto-loop | Read rules/auto-loop.md → summarize + check violations | | Nuclear | /remind --all | Read CLAUDE.md + ALL rules → full compliance report |

Smart Detection Mode

When invoked without arguments, run detection heuristics then dynamically load the relevant rules for each finding.

Step 1: Read State + Git

# State file
STATE_FILE_EXISTS=$(test -f .claude_review_state.json && echo "true" || echo "false")
STATE=$(cat .claude_review_state.json 2>/dev/null || echo "{}")
HAS_CODE=$(echo "$STATE" | jq -r '.has_code_change // false')
HAS_DOC=$(echo "$STATE" | jq -r '.has_doc_change // false')
CODE_REVIEW=$(echo "$STATE" | jq -r '.code_review.passed // false')
DOC_REVIEW=$(echo "$STATE" | jq -r '.doc_review.passed // false')
PRECOMMIT=$(echo "$STATE" | jq -r '.precommit.passed // false')

# Git
BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null)
DIRTY=$(git status --porcelain 2>/dev/null)

Step 2: Detection → Rule Mapping

For each detected issue, Read the mapped rule file and extract the key section:

| # | Detection | Condition | Rule to Load | Section to Extract | |---|-----------|-----------|-------------|-------------------| | 1 | Code changed, no review | HAS_CODE=true + CODE_REVIEW=false | rules/auto-loop.md | "Prohibited Behaviors" + "Auto-Trigger" table | | 2 | Doc changed, no review | HAS_DOC=true + DOC_REVIEW=false | rules/auto-loop.md | ".md" row in Auto-Trigger table | | 3 | Review passed, no precommit | CODE_REVIEW=true + PRECOMMIT=false | rules/auto-loop.md | "precommit Pass" row | | 4 | State drift | State says changes but git clean | — | Suggest reset state file | | 5 | On main branch | BRANCH=main\|master | rules/git-workflow.md | Branch naming + protected branches | | 6 | Dirty worktree, no state | Git dirty + no state file | CLAUDE.md | "Required Checks" table |

Step 3: Output with Rule Context

For each finding, quote the relevant rule text inline so the model re-ingests the rule:

## Reminder

### Findings

| # | Priority | Rule | Issue | Correction |
|---|----------|------|-------|------------|
| 1 | P0 | auto-loop | Code changed but review not passed | `/codex-review-fast` |

### Rule Context (auto-loaded)

> **auto-loop.md — Prohibited Behaviors**:
> - ❌ Declaring ≠ Executing: Saying "need to run X" without actually invoking the tool
> - ❌ Summary ≠ Completion: Outputting a summary then stopping
>
> **Required action**: Execute `/codex-review-fast` in this reply, do not stop.

### Corrections (copy-pasteable)
1. `/codex-review-fast`

When no findings: output ### All Clear ✅ with a brief status summary.

Specific Rule Mode (/remind <rule>)

When user provides a rule name:

1. Resolve: rules/<rule>.md → if not found, try rules/<rule>-project.md → if not found, list available via Glob("rules/*.md")
2. Read: Read the full rule file
3. Summarize: Extract core principles, prohibited behaviors, required actions
4. Check: Cross-reference with current state (state file + git)
5. Output: Rule summary + current violation status + correction commands

Nuclear Mode (/remind --all)

When the model keeps drifting despite specific reminders:

1. Read CLAUDE.md: Extract ## Required Checks table + ## Workflow section + ## Auto-Loop Rule section
2. Read all rules: Glob("rules/*.md") → Read each file
3. For each rule: Extract prohibited behaviors / core principles
4. Cross-reference: State file + git status against all rules
5. Output: Full compliance report with every rule's status

This is the "nuclear option" — high token cost but guarantees the model re-ingests all project rules. Use when repeated /remind calls haven't fixed the drift.

Arguments

| Flag | Default | Description | |------|---------|-------------| | <rule> | — | Specific rule name (e.g., auto-loop, git-workflow) | | --all | false | Load ALL rules + CLAUDE.md (nuclear mode) | | (no args) | — | Smart detection with context-aware rule loading |

Graceful Degradation

| Failure | Behavior | |---------|----------| | jq unavailable | Skip state file parsing, git-only checks | | State file missing | Git-only checks + suggest starting review loop | | Rule file not found | List available rules via Glob("rules/*.md") |

Execution Contract (reinforces top-level CRITICAL section)

The reminder output isn't just informational — it's a correction directive with mandatory execution:

1. Invoke the correction Skill immediately in the same reply — do not ask for permission, do not output a summary and stop
2. Re-read the quoted rule text — it was loaded from the actual rule file specifically because the model drifted from it
3. Do not dismiss findings with "I already did that" unless you can point to the specific tool invocation in this conversation
4. If findings say "run /codex-review-fast" — invoke Skill: /codex-review-fast now, not later

The whole point of /remind is that the model's memory of rules has drifted. The quoted rule text is the source of truth, not the model's recollection of what the rules say.

Correct flow:

/remind → detect doc-no-review → output findings table → invoke Skill(/codex-review-doc) → report result
/remind → detect code-no-review → output findings table → invoke Skill(/codex-review-fast) → report result
/remind → no findings → output "### All Clear ✅" → stop (no correction needed)

Examples

Input: /remind
Output: Smart detection finds code changed without review → loads auto-loop.md → quotes Prohibited Behaviors → outputs `/codex-review-fast`

Input: /remind auto-loop
Output: Reads rules/auto-loop.md → summarizes 8 prohibited behaviors + auto-trigger table → checks state file → reports current compliance

Input: /remind --all
Output: Reads CLAUDE.md + all rules/*.md → produces full compliance matrix → flags all violations with correction commands

Input: /remind git-workflow
Output: Reads rules/git-workflow.md → summarizes branch naming + forbidden operations → checks current branch → warns if on main

Verification Checklist

• [ ] Detection heuristics ran (state + git)
• [ ] Relevant rules dynamically loaded (Read tool)
• [ ] Rule text quoted inline for model re-ingestion
• [ ] Correction commands are copy-pasteable
• [ ] No git add / git commit / git push executed

References

• references/detection-rules.md — Detection → rule mapping table + extraction patterns