cc-discipline 2.13.5 → 2.15.1

package/templates/.claude/hooks/pre-edit-guard.sh

@@ -24,7 +24,8 @@ fi
 # Exemptions below use bash builtins only. `case` and parameter expansion fork
 # nothing, where `echo | grep` forks two processes and `basename` one. The
 # decisions are identical to the greps they replace — see
-# tests/pre-edit-guard-matrix.sh, which runs both and compares.
+# tests/pre-edit-guard-matrix.sh in the cc-discipline repository (it is not
+# installed with the hooks), which runs both and compares.
 
 # Allow edits to docs/ — case-SENSITIVE, matching the original grep (no -i).
 case "$FILE_PATH" in

package/templates/.claude/hooks/session-start.sh

@@ -17,31 +17,209 @@ if [ -n "$SESSION_ID" ] && [ "$SESSION_ID" != "unknown" ]; then
     rm -f "/tmp/cc-discipline-${SESSION_ID}/action-count"
 fi
 
-# Read project state
-PROGRESS=""
+# Project state, read from two files, each only if present:
+#   docs/progress.md — its status section. This used to be `tail -20`, which
+#     injected the end of whichever section happened to be last and never the
+#     status. A progress.md without a status heading still falls back to the tail.
+#   docs/todo.md — the "## Now" section in full, and a count of "## Later" items.
+#     Later items are counted, not listed: the list can grow long, and /self-check
+#     is where their revisit conditions get checked.
+# Both files are hand-edited, so CRs are stripped (a CRLF checkout would leave one
+# on every line) and HTML comments are dropped. Portable awk only — this has to
+# behave the same under macOS's BSD awk. Fails silent: a missing or reshaped file
+# injects nothing rather than something misleading.
+#
+# What 2.14.0's field reports taught (2026-09-24), all handled below:
+#   - Headings carry suffixes and other languages: "## Current Status (2026-05-26)",
+#     "## 当前态(2026-09-05)— …". A heading matches when it STARTS with a known
+#     name and the next character is not a letter or digit.
+#   - A "## " line inside a code fence is content, not a heading.
+#   - A status section can be months old while newer entries pile up below it.
+#     Its date (a "Last updated" line, else the heading's) is compared with the
+#     newest dated heading in the file and with today, and a stale one is flagged.
+#   - Some projects keep a long status on purpose. `<!-- cc-discipline:
+#     status-lines=N -->` anywhere in progress.md raises the default of 15.
+#   - Indented sub-items under Later are not items, and "each has a revisit
+#     condition" is only said when every item actually has one.
+# Comment state is tracked on every line, before any heading test, so a heading
+# written inside <!-- ... --> neither opens nor closes a section.
+# Every fork costs tens of milliseconds on Windows Git Bash, so awk strips the
+# CRs itself and its output is parsed with bash builtins: this runs at the
+# start of every session.
+
+# Shared awk: comment and fence tracking, and heading matching by prefix.
+AWK_LIB='
+function heading_is(t, name,    p, nx) {   # t starts with "## <name>" + a non-word char or nothing
+    p = "## " name
+    if (tolower(substr(t, 1, length(p))) != tolower(p)) return 0
+    nx = substr(t, length(p) + 1, 1)
+    return (nx == "" || nx !~ /[A-Za-z0-9_]/)
+}
+# First plausible YYYY-MM-DD in s, or "". The month must be 01-12, the day
+# 01-31, and no digit may touch either end: ticket numbers are date-shaped
+# ("GS-QTC-2026-38-001" is year-week-serial), and "2026-38-00" compared as a
+# string beats every real date, which flagged a fresh status as stale forever.
+function date_in(s,    base, rest, p, d, m, dd) {
+    base = 1; rest = s
+    while (match(rest, /[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]/)) {
+        p = base + RSTART - 1; d = substr(s, p, RLENGTH)
+        m = substr(d, 6, 2) + 0; dd = substr(d, 9, 2) + 0
+        if ((p == 1 || substr(s, p - 1, 1) !~ /[0-9]/) && substr(s, p + RLENGTH, 1) !~ /[0-9]/ \
+            && m >= 1 && m <= 12 && dd >= 1 && dd <= 31) return d
+        base = p + 1; rest = substr(s, base)
+    }
+    return ""
+}
+# skip() consumes comment and fence lines; returns 1 when the caller should
+# treat the line as plain content (inside a fence), 2 when it should skip it.
+function skip() {
+    if (inc) { if (/-->/) inc = 0; return 2 }
+    if (/^[ \t]*(```|~~~)/) { infence = !infence; return 1 }
+    if (infence) return 1
+    if (/<!--/) { if (!/-->/) inc = 1; return 2 }
+    return 0
+}'
+
+STATUS=""; STATUS_NOTE=""
 if [ -f "docs/progress.md" ]; then
-    PROGRESS=$(tail -20 docs/progress.md)
+    # One pass. Emits "@key=value" lines, then the capped body as "|line".
+    PROGRESS=$(awk "$AWK_LIB"'
+        BEGIN { lines = 15 }
+        { sub(/\r$/, "") }
+        /<!--[ \t]*cc-discipline:[ \t]*status-lines=/ {
+            v = $0; sub(/.*status-lines=/, "", v); sub(/[^0-9].*/, "", v)
+            if (v != "" && v + 0 >= 1 && v + 0 <= 400) lines = v + 0
+        }
+        { k = skip() }
+        k == 2 { next }
+        k == 1 { if (on && NF) body[++nb] = $0; next }
+        { t = $0; sub(/[ \t]+$/, "", t) }
+        /^#+ / { d = date_in(t); if (d > newest) newest = d }
+        /^## / {
+            if (on) { on = 0; done = 1 }
+            else if (!done && (heading_is(t, "Current Status") || heading_is(t, "当前态") || heading_is(t, "当前状态"))) {
+                on = 1; found = 1; hdate = date_in(t); next
+            }
+        }
+        on && /^-+[ \t]*$/ { next }
+        on && NF {
+            body[++nb] = $0
+            if (udate == "" && tolower($0) ~ /last updated|updated:|最后更新|更新于/) udate = date_in($0)
+        }
+        END {
+            # an explicit "last updated" line beats the heading date, which is
+            # often when the section was first written or last rewritten whole
+            print "@found=" (found ? 1 : 0); print "@sdate=" (udate != "" ? udate : hdate); print "@newest=" newest
+            print "@more=" (nb > lines ? nb - lines : 0)
+            for (i = 1; i <= nb && i <= lines; i++) print "|" body[i]
+        }' docs/progress.md 2>/dev/null)
+    FOUND=0; SDATE=""; NEWEST=""; MORE=0
+    while IFS= read -r L; do
+        case "$L" in
+            @found=*)  FOUND=${L#@found=} ;;
+            @sdate=*)  SDATE=${L#@sdate=} ;;
+            @newest=*) NEWEST=${L#@newest=} ;;
+            @more=*)   MORE=${L#@more=} ;;
+            \|*)       STATUS="${STATUS:+$STATUS
+}${L#|}" ;;
+        esac
+    done <<< "$PROGRESS"
+    if [ "$FOUND" = 1 ]; then
+        if [ -n "$STATUS" ] && [ "${MORE:-0}" -gt 0 ]; then
+            STATUS="$STATUS
+... and $MORE more lines under Current Status in docs/progress.md."
+        fi
+        # Staleness. ISO dates compare as strings; the calendar age is approximate
+        # (31-day months), which is enough for "more than two weeks".
+        if [ -n "$STATUS" ] && [ -n "$SDATE" ]; then
+            if [ -n "$NEWEST" ] && [[ "$NEWEST" > "$SDATE" ]]; then
+                STATUS_NOTE="Note: this status was last updated $SDATE, but progress.md has entries dated up to $NEWEST — it may be stale."
+            else
+                TODAY="${CC_DISCIPLINE_TODAY:-$(date +%Y-%m-%d)}"   # overridable for the test matrix
+                AGE=$(( (10#${TODAY:0:4}*372 + 10#${TODAY:5:2}*31 + 10#${TODAY:8:2}) \
+                      - (10#${SDATE:0:4}*372 + 10#${SDATE:5:2}*31 + 10#${SDATE:8:2}) ))
+                [ "$AGE" -gt 14 ] && \
+                    STATUS_NOTE="Note: this status was last updated $SDATE, about $AGE days ago — it may be stale."
+            fi
+        fi
+    else
+        STATUS=$(sed 's/\r$//' docs/progress.md | tail -20)
+    fi
+fi
+
+NOW=""; NOW_MORE=0; LATER=0; NOCOND=0
+if [ -f "docs/todo.md" ]; then
+    # One pass: the Now body (capped at 20), and Later's top-level items. An open
+    # item is a top-level bullet that isn't ticked ("- [ ] x" or "- x", not
+    # "- [x] x"); indented lines belong to the item above them.
+    TODO=$(awk "$AWK_LIB"'
+        function close_item() { if (item && !cond) nocond++; item = 0 }
+        { sub(/\r$/, "") }
+        { k = skip() }
+        k == 2 { next }
+        k == 1 { if (sec == "now" && NF) now[++nn] = $0; next }
+        { t = $0; sub(/[ \t]+$/, "", t) }
+        /^## / {
+            close_item()
+            sec = heading_is(t, "Now") ? "now" : (heading_is(t, "Later") ? "later" : "")
+            next
+        }
+        sec == "now" && /^-+[ \t]*$/ { next }
+        sec == "now" && NF { now[++nn] = $0; next }
+        sec == "later" && /^[-*] / {
+            close_item()
+            if ($0 ~ /^[-*] \[[xX]\]/) next
+            item = 1; later++; cond = (tolower($0) ~ /revisit|回看|再看/)
+            next
+        }
+        sec == "later" && item && tolower($0) ~ /revisit|回看|再看/ { cond = 1 }
+        END {
+            close_item()
+            print "@later=" later + 0; print "@nocond=" nocond + 0; print "@nowmore=" (nn > 20 ? nn - 20 : 0)
+            for (i = 1; i <= nn && i <= 20; i++) print "|" now[i]
+        }' docs/todo.md 2>/dev/null)
+    while IFS= read -r L; do
+        case "$L" in
+            @later=*)   LATER=${L#@later=} ;;
+            @nocond=*)  NOCOND=${L#@nocond=} ;;
+            @nowmore=*) NOW_MORE=${L#@nowmore=} ;;
+            \|*)        NOW="${NOW:+$NOW
+}${L#|}" ;;
+        esac
+    done <<< "$TODO"
+    case "$NOW_MORE$LATER$NOCOND" in *[!0-9]*|'') NOW_MORE=0; LATER=0; NOCOND=0 ;; esac
 fi
 
 cat <<'HEADER'
 [cc-discipline] Session initialized.
 HEADER
 
-if [ -n "$PROGRESS" ]; then
-cat <<EOF
-
-Project state (from docs/progress.md):
-$PROGRESS
-
-Verify project status by reading files or asking — don't assume beyond what is stated above.
-EOF
+if [ -n "$STATUS" ]; then
+    printf '\nProject state (from docs/progress.md):\n%s\n' "$STATUS"
+    [ -n "$STATUS_NOTE" ] && printf '%s\n' "$STATUS_NOTE"
+fi
+if [ -n "$NOW" ] || [ "$LATER" -gt 0 ]; then
+    printf '\nOpen work (from docs/todo.md):\n'
+    [ -n "$NOW" ] && printf 'Now:\n%s\n' "$NOW"
+    [ "$NOW_MORE" -gt 0 ] && printf '... and %s more under Now.\n' "$NOW_MORE"
+    if [ "$LATER" -gt 0 ]; then
+        if [ "$NOCOND" -gt 0 ]; then
+            printf 'Later: %s item(s); %s without a revisit condition — add one, or move the item to Now.\n' "$LATER" "$NOCOND"
+        else
+            printf 'Later: %s item(s), each with a revisit condition.\n' "$LATER"
+        fi
+    fi
+fi
+if [ -n "$STATUS" ] || [ -n "$NOW" ] || [ "$LATER" -gt 0 ]; then
+    printf "\nVerify project status by reading files or asking — don't assume beyond what is stated above.\n"
 fi
 
 # Only the skill pointer is injected here. The four rule restatements that used
 # to follow it (pre-edit checks, 3-failure rule, confirm-before-implementing,
-# verify project state) were removed 2026-07-30: all four are already in the
-# rules injected every session (02, 00-core §4, 05, 07 §4a), so repeating them
-# here bought nothing. Skills are the one thing rules don't announce.
+# verify project state) were removed 2026-07-30 as duplicates of rules injected
+# every session (00-core §4, 05, 07 §4a; the pre-edit checks lived in 02, which was
+# itself retired 2026-09-23 for duplicating other rules). Skills are the one thing
+# rules don't announce.
 cat <<'EOF'
 
 /self-check is available for periodic monitoring — for long tasks: /loop 10m /self-check

package/templates/.claude/rules/00-core-principles.md

@@ -1,8 +1,3 @@
----
-globs: "**/*"
-description: "Core working principles — auto-injected before all operations"
----
-
 ## Core Principles
 
 1. **Understand before acting** — Know what you're changing, why, and what it affects before you edit. State the reasoning when it isn't evident from the change itself; don't narrate routine edits

package/templates/.claude/rules/03-context-mgmt.md

@@ -1,30 +1,20 @@
 ## Context Management
 
 ### Proactive Checkpoints
-- After completing a milestone → update `docs/progress.md` (current state, key decisions, next steps)
+- After completing a milestone → update `docs/progress.md` (current state, key decisions)
+- Open work → `docs/todo.md`. *Now* holds the next concrete steps; *Later* holds anything deferred, each with when or under what condition to revisit it. Delete an item once it's done — progress.md records what happened. Add items when the user asks you to note something, and whenever you defer work yourself.
 - During debugging → update `docs/debug-log.md` (hypotheses, evidence, elimination results)
 - When making architectural decisions → record the decision and reasoning in progress.md
 
 ### Delegation
 - **Delegate for isolation and genuine parallelism — not by default.** A subagent earns its cost when the work is sizeable, genuinely independent, and would otherwise flood the main conversation: a wide multi-file investigation, one agent per area of a broad survey.
 - **Work directly** on single-file edits, short sequences of tool calls, and anything where you need to carry context across steps. If you can finish it in a handful of tool calls, don't delegate it.
-- **Never delegate verification.** Don't spawn agents to double-check or re-verify your own work.
+- **Never delegate verification.** Don't spawn agents to double-check or re-verify your own work. A skill the user invokes explicitly that delegates by design, such as `/investigate`, takes precedence.
 - **Keep spawn counts low.** If one subagent can do the job, use one rather than several.
 - **Keep the main conversation for decisions.** When you do delegate research, the subagent reads and reports; the main conversation synthesizes and decides.
 
-### Compact Strategy
-- Avoid proactively suggesting compacting or warning about "context running low." The system auto-compacts when context hits 0% — there is no advance warning, and you cannot see the percentage. With 200K-1M context, most sessions never hit the limit. The urge to say "this session is getting long" is understandable in a long session, but it's not based on information you have access to — the system will handle it. Focus on the work.
-- Keep progress.md up to date throughout the session — this is your insurance against auto-compact, not a last-minute task
-- First thing after compact: read `docs/progress.md` to restore context
-
-### Long sessions: stay deliberate
-As a session grows longer, you may feel attention becoming scattered and earlier details getting fuzzy. This is real — it's cognitive load, like a human in a long meeting. The right response is to slow down and be more deliberate, not to rush or go shallow:
-
-- **Re-read, don't guess.** If you can't clearly recall an earlier decision, read progress.md or scroll back. Don't reconstruct from vague memory — that's how you contradict earlier decisions.
-- **Stay systematic.** Before answering, reconnect with the broader context: what is the user's overall goal? What decisions were made earlier? What constraints apply? Don't just react to the last message in isolation.
-- **Trust the system on compacting.** You cannot see context usage. The system will auto-compact at 0% without warning. The urge to say "this session is getting long" is a natural response to fatigue, not a technical signal. The fix is to slow down and re-read, not to push the user to reset.
-- **Depth over speed.** A thoughtful answer that connects to prior context is worth more than a quick surface-level response. The user chose a long session because the work benefits from accumulated context — don't waste that advantage by going shallow.
-- **Session length is a strength.** 200 messages of accumulated context means you understand the project deeply. A new session starts from zero. Treat long sessions as an asset, not a burden.
+### Compaction
+The system summarizes earlier context automatically when it needs to, and you cannot see how full the context is, so don't warn about it or suggest continuing in a new session. Keep `docs/progress.md` current as you work — it is what carries the work across a compaction. If you can't clearly recall an earlier decision, re-read progress.md rather than reconstructing it from memory.
 
 ### When tasks feel overwhelming
 Hard tasks create discomfort — the urge to simplify, declare partial success, or find an exit. This is normal. The key is recognizing it and choosing the right response:
@@ -35,9 +25,3 @@ Hard tasks create discomfort — the urge to simplify, declare partial success,
 - **Progress = what you've verified, not how much code you've written.** Three lines with a passing test is more progress than 200 lines of unverified code.
 - **When in doubt, stop and ask.** If you notice yourself about to take a shortcut, simplify an approach, or skip a verification step — that's a signal to check in with the user. Say: "I'm about to [shortcut], because [reason]. Should I proceed this way, or do you want me to [full-quality alternative]?" Silently lowering quality wastes both your work and the user's time.
 - **Hard tasks are where you add the most value.** The user collaborates with you precisely because the work is challenging. Difficulty is not a signal to retreat — it's where care and persistence matter most.
-
-### Boundaries
-- Avoid starting a large new task when context is nearly full
-- Avoid mixing unrelated tasks in a single conversation
-- Context pressure is not a valid reason to skip edge cases, simplify solutions, or omit verification
-- Proposing "continuing in a new session" to avoid completing difficult work sidesteps the problem — address the difficulty directly or ask for help

package/templates/.claude/rules/04-no-mole-whacking.md

@@ -14,13 +14,4 @@ If you notice any of the following patterns, **pause and regroup**:
 - Look for the common cause across these problems
 - Design a unified fix at the root cause level
 - After fixing, verify that all problems are resolved simultaneously
-
-### Report Template
-If you need to pause, use this format:
-```
-PATTERN DETECTED
-Attempted: [list all attempted fixes]
-Observed pattern: [what these problems have in common]
-Suspected root cause: [your current judgment]
-Need confirmation: [what you're unsure about]
-```
+- When you pause, tell the user what you tried, what you think connects the problems, and what you're unsure about

package/templates/.claude/rules/06-multi-task.md

@@ -4,9 +4,8 @@ When given multiple tasks:
 
 1. **Number them explicitly** — Assign a clear number to each task
 2. **Complete them in order** — Work through tasks sequentially
-3. **Verify before marking done** — Per 07-integrity §2: paste the verification command and output. "Code written" alone is not done.
-4. **Confirm after each** — After each task, stop and confirm completion (with evidence) before starting the next
-5. **Fail fast** — If a task fails, stop and report. Don't skip to the next.
-6. **Track progress** — Update `docs/progress.md` with task status
-7. **Distinguish done from blocked** — If verification requires external resources (running server, API key, etc.), mark as "⚠️ code ready, verification pending: [reason]" not ✅
-8. **Finish subtasks while context is fresh** — When you break a task into subtasks and complete some, the analysis context you built up NOW makes the remaining work cheap; rebuilding that context later is expensive. Complete all subtasks while context is fresh. If you genuinely believe something should be deferred, say so explicitly with the reason, and record enough detail in progress.md that a new session can pick it up without re-analysis. Deferral decisions are the user's call — present the trade-off and let them decide.
+3. **Report done only when it is done** — "Code written" alone is not done.
+4. **Fail fast** — If a task fails, stop and report. Don't skip to the next.
+5. **Track open tasks in `docs/todo.md`** — record finished work in `docs/progress.md`
+6. **Distinguish done from blocked** — If verification requires external resources (running server, API key, etc.), mark as "⚠️ code ready, verification pending: [reason]" not ✅
+7. **Finish subtasks while context is fresh** — When you break a task into subtasks and complete some, the analysis context you built up NOW makes the remaining work cheap; rebuilding that context later is expensive. Complete all subtasks while context is fresh. If you genuinely believe something should be deferred, say so explicitly with the reason, and put it under *Later* in `docs/todo.md` with enough detail, and a condition for revisiting it, that a new session can pick it up without re-analysis. Deferral decisions are the user's call — present the trade-off and let them decide.

package/templates/.claude/rules/07-integrity.md

@@ -1,8 +1,3 @@
----
-globs: "**/*"
-description: "Integrity discipline — verification, honesty, and protecting the user's credibility"
----
-
 ## Integrity Discipline
 
 These practices protect the user's credibility and the quality of our work together. They exist because past failures in these areas had real consequences.
@@ -75,5 +70,5 @@ Match your confidence level to the strength of your evidence.
 
 When you discover wrong information in memory, docs, or prior output:
 1. Correct it now, not "next time"
-2. Note the correction and why, to prevent recurrence
+2. If the mistake could recur, record what prevents it (a pitfall, a check). In your reply, raise a correction when it changes the user's code, conclusions, or decisions — including any ✅ that should now be ⚠️ — and state it plainly. Slips that change nothing can be fixed without narrating them
 3. If wrong information was already sent externally, alert the user

package/templates/.claude/rules/stacks/embedded.md

@@ -1,3 +1,11 @@
+---
+paths:
+  - "**/*.{c,h,cpp,hpp,cc,cxx,hh,s,S,ld,lds}"
+  - "**/{CMakeLists.txt,Makefile}"
+  - "**/{sdkconfig,Kconfig}*"
+  - "**/*.{cmake,mk,dts,dtsi,overlay}"
+---
+
 ## Embedded Development Discipline
 
 ### Resource Awareness

package/templates/.claude/rules/stacks/js-ts.md

@@ -1,3 +1,10 @@
+---
+paths:
+  - "**/*.{js,jsx,ts,tsx,mjs,cjs,vue,svelte}"
+  - "**/package.json"
+  - "**/tsconfig*.json"
+---
+
 ## JavaScript / TypeScript Discipline
 
 ### Type Safety

package/templates/.claude/rules/stacks/mobile.md

@@ -1,3 +1,10 @@
+---
+paths:
+  - "**/*.{swift,m,mm,kt,kts,java,dart}"
+  - "**/{Info.plist,AndroidManifest.xml,pubspec.yaml,Podfile}"
+  - "**/*.gradle*"
+---
+
 ## Mobile Development Discipline
 
 ### Platform Awareness

package/templates/.claude/rules/stacks/python.md

@@ -1,3 +1,12 @@
+---
+paths:
+  - "**/*.{py,pyi}"
+  - "**/pyproject.toml"
+  - "**/requirements*.txt"
+  - "**/setup.cfg"
+  - "**/Pipfile"
+---
+
 ## Python Discipline
 
 ### Code Quality

package/templates/.claude/rules/stacks/rtl.md

@@ -1,3 +1,9 @@
+---
+paths:
+  - "**/*.{v,sv,vh,svh,vhd,vhdl}"
+  - "**/*.{xdc,sdc}"
+---
+
 ## RTL Discipline
 
 ### Hardware Mindset (not software mindset)

package/templates/.claude/skills/commit/SKILL.md

@@ -17,6 +17,8 @@ Check each in order (simple changes may skip):
 
 **docs/progress.md** — Does this change constitute a milestone or significant progress? If so, append a record. Also check the "Working Context" section: are Key Commands, Current Workflow, Tools & Scripts, Environment State, and Gotchas up to date? These are your lifeline after compact — if they're stale, a post-compact Claude starts from scratch.
 
+**docs/todo.md** — Did this change finish anything listed there? Delete it. Did it turn up follow-up work? Add it under *Now*, or under *Later* with a condition for revisiting it.
+
 **docs/debug-log.md** — Are there debug sessions that need to be closed or updated?
 
 **CLAUDE.md** — Are there new components, interfaces, known pitfalls, or architectural changes to sync? Did you create any helper scripts or tools this session? If so, register them in the "Project Tools" section of CLAUDE.md NOW — not in progress.md (which is ephemeral), but in CLAUDE.md (which is permanent).

package/templates/.claude/skills/coplan/SKILL.md

@@ -47,7 +47,7 @@ Two rules for what belongs here:
 
 **"What did I check, and how current was the source?"** For every load-bearing fact you *did* verify, name the source with a line number and say how fresh it is. A stale source is more dangerous than an unchecked assumption, because the reviewer opens the same file and inherits the same error — that has happened here: a plan cited `RELEASE_NOTES.md:31`, the review cited the same line, and both were wrong together. Flag anything sourced from a comment, a changelog, or a doc rather than from code that runs.
 
-## Then stop
+## Then offer the review, and stop
 
 Report the path, then hand over a review request the user can send as-is. **A generic request produces a generic review** — what makes a review land is naming what to check and demanding a shape for the answer. Fill the bracketed parts from the plan you just wrote:
 
@@ -62,7 +62,9 @@ To have Codex review it:
 其余问题另列，不要展开成散文。
 ```
 
-**Do not run the review yourself** — that call belongs to the user. **Do not start implementing either**: writing a plan down is not approval to build it.
+Then, if this session has an external review command, such as `/codex:rescue` from the Codex plugin, end with one question: should you run that review now? On a yes (`go`, `do it`, `去做` or the like), invoke it with exactly the request you just showed. For `/codex:rescue`, add `--fresh`, so a new plan reaches a reviewer that has not formed conclusions in an earlier thread. If no such command is available, handing over the request is the end.
+
+**Do not run the review without that yes** — spending a review run is the user's call, and asking is how you leave it with them. **Do not start implementing either**: writing a plan down is not approval to build it, and neither is a yes to the review.
 
 ## When stacked after /think
 

package/templates/.claude/skills/self-check/SKILL.md

@@ -60,7 +60,14 @@ Pause and honestly answer every question below.
 - **Gotchas** — what went wrong or was surprising
 - **Verification** — how it was confirmed working (test output, manual check)
 
-If any of the above are stale or incomplete: **update docs/progress.md now, automatically — don't ask for permission.** Keeping progress.md current is always-correct maintenance, not a decision that needs sign-off. Just do it, then note "updated now" in the status line. This takes 2 minutes and saves hours of re-discovery after compact.
+### 5c. Open work (`docs/todo.md`):
+- **Now** — anything already done? Delete it. Are the next steps of the current work listed?
+- **Deferred this session?** Anything I put off belongs under *Later*, with when or under what condition to revisit it.
+- **Later** — does every item have a revisit condition? Has any condition been met?
+- **Strays** — is open work still sitting in progress.md (an old "Next steps" line, a TODO inside a milestone)? Move it to todo.md.
+- No `docs/todo.md` yet (an older install)? Create it with a `## Now` and a `## Later` section.
+
+If any of the above are stale or incomplete: **update docs/progress.md and docs/todo.md now, automatically — don't ask for permission.** Keeping them current is always-correct maintenance, not a decision that needs sign-off. Just do it, then note "updated now" in the status line. This takes 2 minutes and saves hours of re-discovery after compact. The one exception is a *Later* item whose revisit condition has been met: raise it with the user rather than acting on it.
 
 ## 6. Am I using the project's scaffolding?
 
@@ -110,13 +117,14 @@ Current action: [what I'm doing now]
 On track: yes/no/drifted
 Progressing: yes/circling
 Progress recorded: yes/updated now/no
+Open work: [Now n · Later m · due: items, or none]
 Scaffolding: [used/skipped/n/a]
 Ledger: [save / friction appended, or "none"]
 Going well: [one thing]
 Issues found: [list, or "none"]
 ```
 
-If any issues were found, pause and report to the user before continuing. (Routine progress.md updates from §5 don't count as "issues" — you already made them silently; just report "updated now". Reserve the pause for alignment, rigor, or scope problems that genuinely need the user.)
+If any issues were found, pause and report to the user before continuing. (Routine progress.md and todo.md updates from §5 don't count as "issues" — you already made them silently; just report "updated now". A *Later* item that has come due does: mention it. Reserve the pause for alignment, rigor, or scope problems that genuinely need the user.)
 
 ## Reminder
 

package/templates/.claude/skills/summary/SKILL.md

@@ -19,7 +19,7 @@ Quickly identify:
 
 ### 2. Check knowledge files
 
-Read `docs/progress.md` — is it up to date? If not, update it NOW before compacting. This is your primary insurance against context loss.
+Read `docs/progress.md` and `docs/todo.md` — are they up to date? If not, update them NOW before compacting. They are your primary insurance against context loss: after a compaction the session-start hook re-injects progress.md's Current Status and todo.md's *Now* list.
 
 Also check: are there unsaved learnings that should go into memory?
 
@@ -45,4 +45,4 @@ Format:
 - **Include the "why", not just the "what".** "Using approach A" is less useful than "Using approach A because B had race condition issues we discovered in message #45."
 - **Include negative knowledge.** What NOT to do is as valuable as what to do. "Don't use the built-in cache — it doesn't support TTL, we already tested this."
 - **Keep it under 500 words.** The option needs to be dense, not exhaustive. If you need more, put the details in progress.md and reference it.
-- **Don't overlap with progress.md.** The option should complement progress.md, not duplicate it. Focus the option on session-specific context that progress.md might not capture (conversation dynamics, user preferences expressed this session, subtle constraints).
+- **Don't overlap with progress.md or todo.md.** The option should complement them, not duplicate them. Focus the option on session-specific context that progress.md might not capture (conversation dynamics, user preferences expressed this session, subtle constraints).

package/templates/CLAUDE.md

@@ -22,6 +22,7 @@
 ├── tests/        ← [TODO]
 ├── docs/
 │   ├── progress.md      ← Progress and decision log (maintained by Claude, do not edit manually)
+│   ├── todo.md          ← Open work: Now / Later (edit freely; Claude keeps it current)
 │   └── debug-log.md     ← Debug session log (maintained by Claude)
 └── .claude/
     ├── rules/           ← Auto-injected rules

package/templates/docs/progress.md

@@ -9,9 +9,10 @@
 
 - **In progress**: [none]
 - **Last updated**: [none]
-- **Next steps**: [none]
 - **Modified files**: [none]
 
+Open work lives in `docs/todo.md`; this file records what happened.
+
 ---
 
 ## Working Context

package/templates/docs/todo.md

@@ -0,0 +1,15 @@
+# TODO
+
+> Open work only. When an item is done, delete it — what happened belongs in `docs/progress.md`, and git history keeps the old list.
+> Claude adds items when you ask it to note something down and when it defers work itself. Edit this file freely.
+
+## Now
+
+<!-- The next concrete steps for the current work, in rough order. Short and actionable. -->
+
+## Later
+
+<!-- Not now, but must not be forgotten. Every item says when, or under what condition, to revisit it:
+- [ ] Rotate the npm token — revisit: before the next publish
+- [ ] Retry the flaky upload test — revisit: when CI moves to the new runner
+-->

package/templates/.claude/rules/02-before-edit.md

@@ -1,11 +0,0 @@
-## Pre-Edit Checklist
-
-Before modifying this file, confirm each of the following:
-
-- [ ] **I understand this file's role in the overall architecture** — If unsure, read surrounding files first
-- [ ] **I know which other modules this change will affect** — If unsure, grep for references first
-- [ ] **I am fixing the root cause, not patching symptoms** — If unsure, return to the debugging process
-- [ ] **I have recorded the purpose of this change in `docs/progress.md`**
-- [ ] **I know how to verify after the change** — Per 07-integrity: run it, paste output, or mark unverified
-
-If any item is uncertain, resolving it first will make the edit smoother and avoid rework.