Remind — Lightweight Model Correction

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

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")

After Receiving Reminder Output

The reminder output isn't just informational — it's a correction directive. When /remind outputs findings:

1. Execute the correction commands immediately in the same reply — do not ask for permission or output a summary
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 it 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.

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