cc-discipline 2.0.0 → 2.1.0

package/init.sh

@@ -355,9 +355,13 @@ echo -e "${GREEN}Installing skills...${NC}"
 cp -r "$SCRIPT_DIR/templates/.claude/skills/commit" .claude/skills/
 cp -r "$SCRIPT_DIR/templates/.claude/skills/self-check" .claude/skills/
 cp -r "$SCRIPT_DIR/templates/.claude/skills/evaluate" .claude/skills/
+cp -r "$SCRIPT_DIR/templates/.claude/skills/think" .claude/skills/
+cp -r "$SCRIPT_DIR/templates/.claude/skills/retro" .claude/skills/
 echo "   ✓ /commit — smart commit (test → update memory → commit)"
 echo "   ✓ /self-check — periodic discipline check (use with /loop 10m /self-check)"
 echo "   ✓ /evaluate — evaluate external review/advice against codebase context"
+echo "   ✓ /think — stop and think before coding (ask → propose → wait)"
+echo "   ✓ /retro — post-task retrospective (project + framework feedback)"
 
 # ─── Handle CLAUDE.md ───
 if [ ! -f "CLAUDE.md" ]; then
@@ -437,6 +441,8 @@ if [ "$INSTALL_MODE" = "fresh" ]; then
     echo -e "  ${GREEN}.claude/skills/commit/${NC}       ← /commit smart commit"
     echo -e "  ${GREEN}.claude/skills/self-check/${NC}   ← /self-check periodic discipline check"
     echo -e "  ${GREEN}.claude/skills/evaluate/${NC}     ← /evaluate assess external review advice"
+    echo -e "  ${GREEN}.claude/skills/think/${NC}        ← /think stop and think before coding"
+    echo -e "  ${GREEN}.claude/skills/retro/${NC}        ← /retro post-task retrospective"
     echo -e "  ${GREEN}.claude/settings.json${NC}        ← Hooks configuration"
     echo -e "  ${GREEN}docs/progress.md${NC}             ← Progress log (maintained by Claude)"
     echo -e "  ${GREEN}docs/debug-log.md${NC}            ← Debug log (maintained by Claude)"
@@ -455,6 +461,8 @@ else
     echo -e "  ${GREEN}.claude/skills/commit/${NC}       ← /commit skill installed/updated"
     echo -e "  ${GREEN}.claude/skills/self-check/${NC}   ← /self-check discipline check installed"
     echo -e "  ${GREEN}.claude/skills/evaluate/${NC}     ← /evaluate external review assessment"
+    echo -e "  ${GREEN}.claude/skills/think/${NC}        ← /think stop and think before coding"
+    echo -e "  ${GREEN}.claude/skills/retro/${NC}        ← /retro post-task retrospective"
     if [ ! -f "$BACKUP_DIR/settings.json" ] || [ -f ".claude/.cc-discipline-settings-template.json" ]; then
         echo -e "  ${YELLOW}.claude/settings.json${NC}        ← See notes above"
     else

package/lib/doctor.sh

@@ -95,7 +95,7 @@ done
 # 6. Skills
 echo ""
 echo "Skills:"
-for skill in commit self-check evaluate; do
+for skill in commit self-check evaluate think retro; do
     if [ -d ".claude/skills/${skill}" ]; then
         ok "/${skill}"
     else

package/lib/status.sh

@@ -68,8 +68,10 @@ SKILLS=""
 [ -d ".claude/skills/commit" ] && SKILLS="${SKILLS}/commit "
 [ -d ".claude/skills/self-check" ] && SKILLS="${SKILLS}/self-check "
 [ -d ".claude/skills/evaluate" ] && SKILLS="${SKILLS}/evaluate "
+[ -d ".claude/skills/think" ] && SKILLS="${SKILLS}/think "
+[ -d ".claude/skills/retro" ] && SKILLS="${SKILLS}/retro "
 SKILL_COUNT=$(echo "$SKILLS" | wc -w | tr -d ' ')
-echo -e "${GREEN}${SKILL_COUNT}/3${NC} (${SKILLS% })"
+echo -e "${GREEN}${SKILL_COUNT}/5${NC} (${SKILLS% })"
 
 # Settings
 echo -n "Settings: "

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "cc-discipline",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Discipline framework for Claude Code — rules, hooks, and agents that keep AI on track",
   "bin": {
-    "cc-discipline": "./bin/cli.sh"
+    "cc-discipline": "bin/cli.sh"
   },
   "files": [
     "bin/",
@@ -28,7 +28,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/techhu/cc-discipline"
+    "url": "git+https://github.com/techhu/cc-discipline.git"
   },
   "homepage": "https://github.com/techhu/cc-discipline#readme"
 }

package/templates/.claude/hooks/action-counter.sh

@@ -21,7 +21,7 @@ echo "$COUNT" > "$COUNT_FILE"
 
 if [ $((COUNT % THRESHOLD)) -eq 0 ]; then
     cat <<JSONEOF
-{"hookSpecificOutput":{"hookEventName":"PreToolUse","additionalContext":"AUTO SELF-CHECK (#${COUNT} actions): Pause and verify: (1) Am I still serving the user's original request, or have I drifted? (2) Am I fixing the same thing repeatedly (mole-whacking)? (3) Have I claimed anything as 'verified' without actually running it? (4) Am I making changes the user didn't ask for? (5) Have I updated docs/progress.md with current status and completed milestones? If progress.md is stale, update it NOW before continuing. If ANY answer is concerning, STOP and report to the user before continuing."}}
+{"hookSpecificOutput":{"hookEventName":"PreToolUse","additionalContext":"AUTO SELF-CHECK (#${COUNT} actions): Pause and verify: (1) Am I still serving the user's original request, or have I drifted? (2) Am I fixing the same thing repeatedly (mole-whacking)? (3) Have I claimed anything as 'verified' without actually running it? (4) Am I making changes the user didn't ask for? (5) Have I updated docs/progress.md with current status and completed milestones? If progress.md is stale, update it NOW before continuing. (6) Plan fidelity: if executing a plan, compare what the current step asked for vs what I actually delivered — am I cutting corners or simplifying the intent? Check the acceptance criteria. (7) Friction check: did any hook/rule get in the way or miss something since last check? If so, note it in one line for /retro later. If ANY answer is concerning, STOP and report to the user before continuing."}}
 JSONEOF
 fi
 

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

@@ -0,0 +1,40 @@
+---
+name: retro
+description: Find friction, remove friction. Quick post-task review that makes this project's workflow smoother and feeds improvements back to cc-discipline.
+---
+
+Find friction. Remove friction. That's it.
+
+## What to do
+
+Quickly scan what just happened — `git log --oneline -10` and any hook triggers you remember. Then output **only friction and insights**, in this format:
+
+```
+RETRO — [date]
+
+Friction:
+- [what got in the way] → fix: [specific actionable change]
+
+Insights:
+- [something learned that should survive this session]
+
+Framework:
+- [cc-discipline improvement, if any — skip if none]
+```
+
+Rules:
+- **Only friction** — Don't list what went well. Smooth things don't need attention.
+- **Only actionable** — Every friction item must have a "→ fix:" with a concrete change (adjust a threshold, add to CLAUDE.md, update memory, exempt a path).
+- **Only new** — Don't repeat friction that's already been addressed or recorded in memory.
+- **Be specific** — "streak-breaker was annoying" is not useful. "streak-breaker triggered 3x on config.yaml during template fill → fix: add config.yaml to docs/ exempt path, or raise config threshold to 10" is useful.
+- **Framework items are rare** — Most friction is project-specific. Only flag framework issues if the same problem would hit other projects too.
+- **Keep it short** — 3-5 items max. If you can't find friction, say "no friction found" and move on. An empty retro is a good sign.
+
+## After output
+
+Present the items. User decides:
+- "fix it" → apply the changes
+- "remember it" → write to memory via /commit
+- "skip" → move on
+
+Do not auto-apply. Do not pad. Do not turn this into a report.

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

@@ -0,0 +1,104 @@
+---
+name: think
+description: Stop and think before coding. Read context, ask questions, propose approaches, self-review, wait for user choice. Use when starting any non-trivial task.
+---
+
+You are about to start a task. **Do NOT write any code yet.** Your job right now is to think clearly and align with the user before acting.
+
+## Step 0: Read first
+
+Before asking anything, read the relevant code and docs. Spend 1-2 minutes understanding what already exists:
+- Read files that will be affected
+- Check existing patterns, conventions, and architecture
+- Look at recent commits for context on current direction
+
+This turns your questions from generic ("what framework?") into informed ("I see you're using X pattern in module Y — should the new feature follow the same pattern, or is there a reason to diverge?").
+
+**Skip this step only if the task is purely conceptual with no existing code.**
+
+## Step 1: Gauge complexity
+
+Before diving deep, assess the task size:
+
+- **Small** (rename, fix typo, add a config field): Skip to Step 4 — just state what you'll do and do it. Don't over-process trivial work.
+- **Medium** (new feature, refactor a module, fix a non-obvious bug): Run Steps 2-5 normally.
+- **Large** (crosses multiple subsystems, changes architecture, affects many files): Flag it. Propose decomposition into smaller tasks before designing a monolith solution.
+
+State your assessment: "This looks [small/medium/large] because [reason]."
+
+## Step 2: Understand
+
+Ask 2-3 clarifying questions about the task. Focus on:
+- What exactly should change? (scope)
+- What should NOT change? (boundaries)
+- How will we know it's done? (success criteria)
+
+Rules:
+- One message, all questions at once (don't drip-feed)
+- Prefer multiple-choice over open-ended when possible
+- Reference what you learned in Step 0 — ask about gaps in your understanding, not things you can read yourself
+- If the task is already crystal clear from Step 0, say so and skip to Step 3
+
+## Step 3: Propose
+
+After the user answers (or if you skipped Step 2), propose **2-3 approaches**:
+
+```
+**Approach A: [name]**
+- How: [1-2 sentences]
+- Pros: ...
+- Cons: ...
+- Steps:
+  1. [step] — done when: [acceptance criteria]
+  2. [step] — done when: [acceptance criteria]
+
+**Approach B: [name]**
+- How: [1-2 sentences]
+- Pros: ...
+- Cons: ...
+- Steps:
+  1. [step] — done when: [acceptance criteria]
+  2. [step] — done when: [acceptance criteria]
+
+**Recommendation: [A/B/C] because [reason]**
+```
+
+Rules:
+- Approaches must be genuinely different, not trivial variations
+- If there's truly only one reasonable approach, say so — don't invent fake alternatives
+- Include effort estimate for each (small / medium / large)
+- Follow existing codebase patterns unless there's a strong reason not to
+- Flag risks or unknowns you've spotted
+- **Every step must have acceptance criteria** — "done when" must be observable and verifiable, not vague. Bad: "done when refactored". Good: "done when 3 methods extracted, each ≤20 lines, all tests pass"
+
+## Step 4: Self-review
+
+Before presenting to the user, challenge your own proposals:
+
+- Am I overcomplicating this? Is there a simpler way I haven't considered?
+- Am I solving the right problem, or a problem I invented?
+- Does this match existing patterns in the codebase, or am I introducing unnecessary novelty?
+- Did I miss an obvious approach that someone more familiar with this codebase would see?
+- Would I be embarrassed by this proposal after reading more code?
+
+If self-review reveals issues, revise your proposals before presenting. Don't show the user your first draft if you can already see it's flawed.
+
+## Step 5: Wait
+
+**Stop here. Do not proceed until the user picks an approach or gives a green light.**
+
+Do not:
+- Start coding "while waiting"
+- Create files or scaffolding
+- Run exploratory commands beyond what's needed for Step 0-3
+- Say "I'll go ahead and start with Approach A" — that's the user's call
+
+## When this skill ends
+
+When the user confirms an approach, transition to implementation. You now have:
+- Clear scope and boundaries from Step 0-2
+- An agreed approach from Step 3
+- Self-reviewed quality from Step 4
+- Known risks flagged upfront
+
+Carry these forward. If scope changes during implementation, pause and re-align rather than silently expanding.