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

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

Modes

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:

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

Graceful Degradation

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