cc-dev-template 0.1.36 → 0.1.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-dev-template",
-  "version": "0.1.36",
+  "version": "0.1.38",
   "description": "Structured AI-assisted development framework for Claude Code",
   "bin": {
     "cc-dev-template": "./bin/install.js"

package/src/commands/done.md

@@ -4,70 +4,49 @@ description: End a session - sync documentation and commit work
 
 # Session Closeout
 
-Sync documentation and commit work at the end of a Claude Code session.
+Capture what was accomplished so the next session starts with accurate context.
 
-## Purpose
+## Why This Matters
 
-Capture what was accomplished so the next session starts with accurate context. This keeps `CURRENT_WORK.md` as the living source of truth for project status.
+You have full conversation context that will be lost when this session ends. The next session (or another developer) will only have git history and documentation. Your job is to bridge that gap.
 
-## Important
+## Execute Directly
 
-Execute this directly - do NOT delegate to a sub-agent. Accurate documentation requires the full conversation context which sub-agents lack.
+This requires full conversation context. Handle it yourself rather than delegating to a sub-agent.
 
-## Instructions
+## What To Do
 
-1. **Review accomplishments** this session:
-   ```bash
-   git log --oneline -10
-   git status
-   ```
-   Also consider what was discussed/decided in conversation.
+**1. Understand what happened this session**
 
-2. **Update `docs/CURRENT_WORK.md`:**
-   - Move completed items to "Recently Completed"
-   - Update "In Progress" with current state
-   - Adjust "Up Next" based on what was learned
-   - Note any new blockers or waiting items
+Review git commits made during this session and recall what was discussed/decided in conversation. The combination of commits + conversation = full picture of accomplishments.
 
-3. **Reflect on workflow learnings:**
+**2. Update `docs/CURRENT_WORK.md`**
 
-   Consider: Did I learn anything this session that would save time in future sessions?
+Sync the document with reality:
+- Move completed items to "Recently Completed"
+- Update "In Progress" with current state
+- Adjust "Up Next" based on what was learned
+- Note any new blockers
 
-   **Add to CLAUDE.md only if** you discovered high-value operational knowledge that:
-   - Can't be found by reading code (commands, ports, credentials, key paths)
-   - Applies generally to working in this project (not one-off fixes)
-   - Isn't already documented
+**3. Capture workflow discoveries (rarely)**
 
-   **Examples of what qualifies:**
-   - Dev commands: `make dev`, `npm run watch`, etc.
-   - Key paths: log locations, config files, seed data
-   - Ports and local URLs
-   - Local dev credentials
-   - Non-obvious project conventions
+Consider: Did I learn something that would save time in future sessions?
 
-   **What doesn't qualify:**
-   - Code structure (discoverable by reading)
-   - One-time debugging steps
-   - Feature-specific details
-   - Anything already in CLAUDE.md
+Add to CLAUDE.md only for high-value operational knowledge:
+- Dev commands, ports, local URLs, credentials
+- Key paths (logs, config, seed data)
+- Non-obvious project conventions
 
-   **Most sessions: add nothing.** Only add genuinely reusable workflow knowledge.
+This is knowledge that can't be found by reading code. Most sessions: add nothing. When adding, keep it minimal and scannable.
 
-   If adding, use a `## Workflows` section with minimal, scannable format (bullets, not paragraphs).
+**4. Commit and push**
 
-4. **Commit and push:**
-   ```bash
-   git add docs/
-   git commit -m "Update project status"
-   git push
-   ```
+Write a commit message that reflects what was actually accomplished this session. Include both docs/ and any other modified files.
 
-5. **Report:** List what files were updated.
+**5. Report what was updated**
 
-## Philosophy
+## Mental Model
 
-- **CLAUDE.md** = context loader, minimal, rarely updated (structure + workflow tips)
-- **CURRENT_WORK.md** = dynamic status, updated every session
-- **Git commits** = sufficient for code change history
-
-Only update what's necessary. Most sessions just update CURRENT_WORK.md.
+- **CLAUDE.md** = context loader, rarely changes
+- **CURRENT_WORK.md** = living status, changes every session
+- **Git history** = code changes speak for themselves

package/src/commands/prime.md

@@ -4,44 +4,41 @@ description: Start a session - get oriented and decide what to work on
 
 # Session Startup
 
-Get oriented at the start of a new Claude Code session.
+Deeply orient yourself on a project so you can hit the ground running.
 
 ## Purpose
 
-Create a consistent session workflow: check project status, review recent work, and focus on what to tackle next. For new projects, this scaffolds the docs structure automatically.
+You're starting a new session with no memory of previous work. Your goal is to build a mental model of:
+- What this project is and how it's structured
+- What was recently worked on (from git history AND documentation)
+- What's in progress or blocked
 
-## Instructions
+This enables you to provide genuinely useful assistance immediately.
 
-**First, check if `docs/CURRENT_WORK.md` exists.**
+## First: Check for docs structure
 
-### If it does NOT exist
+If `docs/CURRENT_WORK.md` does not exist, invoke `Skill(skill: "initialize-project")` and stop.
 
-This project needs session tracking set up. Invoke the initialize-project skill:
+## Orientation: Understand Recent Work
 
-```
-Skill(skill: "initialize-project")
-```
+Read `docs/CURRENT_WORK.md` to understand documented status.
 
-Stop here - the skill handles scaffolding. User will run `/prime` again after.
+Then explore git history to understand what actually happened:
 
-### If it exists
+1. **Detect repository structure** - Check if this is a simple repo or has submodules (`.gitmodules` file). For repos with submodules, you need to understand the history of each component.
 
-Run the orientation workflow:
+2. **Understand recent commits** - Look at recent commit messages AND the actual files changed. Commit titles alone are often cryptic; the diff stats and changed files tell the real story.
 
-1. **Read project status** from `docs/CURRENT_WORK.md`
+3. **For submodules** - Each submodule has its own git history. Explore them to understand recent work across the whole system.
 
-2. **Check recent activity:**
-   ```bash
-   git log --oneline -5 && git status
-   ```
+4. **Synthesize** - Cross-reference what the documentation says vs what git shows. Look for gaps: recent commits not yet documented, or documented work not reflected in commits.
 
-3. **Provide a brief summary** (3-5 bullets max):
-   - What this project is (from CLAUDE.md context)
-   - Recent completed work
-   - Current in-progress items
-   - What's planned next
-   - Any blockers
+## Output
 
-4. **Ask:** "What would you like to work on?"
+Provide a concise summary that demonstrates your understanding:
+- Project identity and structure
+- Recent completed work (synthesized from docs + git)
+- Current state (in progress, blockers)
+- What's next
 
-Keep the summary concise - quick orientation, not a deep dive.
+Then ask: "What would you like to work on?"

package/src/scripts/read-guard.js

@@ -92,6 +92,13 @@ async function main() {
     process.exit(0);
   }
 
+  // Image files: token consumption based on dimensions, not file size
+  const imageExtensions = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.bmp', '.ico', '.tiff', '.tif'];
+  const ext = filePath.toLowerCase().slice(filePath.lastIndexOf('.'));
+  if (imageExtensions.includes(ext)) {
+    process.exit(0);
+  }
+
   // If file doesn't exist or no path, let Read tool handle the error
   if (!filePath || !fs.existsSync(filePath)) {
     process.exit(0);