@torka/claude-qol 0.1.2 → 0.2.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,17 @@
 {
   "name": "@torka/claude-qol",
-  "version": "0.1.0",
-  "description": "Claude Code quality-of-life improvements: auto-approve hooks and context monitoring",
-  "type": "hooks"
+  "version": "0.2.0",
+  "description": "Claude Code quality-of-life improvements: auto-approve hooks, context monitoring, and workflow optimization",
+  "commands": [
+    {
+      "name": "optimize-auto-approve-hook",
+      "description": "Analyze auto-approve decisions to identify safe patterns for auto-allowing and validate existing rules"
+    }
+  ],
+  "skills": [
+    {
+      "name": "nash",
+      "description": "Workflow optimization loop that reviews Claude Code session transcripts to extract learnings and improve workflows"
+    }
+  ]
 }

package/hooks/auto_approve_safe.rules.json

@@ -27,12 +27,21 @@
     "^uv\\s+--version$",
 
     "^git\\s+(status|diff|log|show|branch|remote|stash\\s+list)(\\s+.*)?$",
+    "^git\\s+-C\\s+[^|;&]+\\s+(status|diff|log|show|branch)(\\s+.*)?$",
+    "^git\\s+-C\\s+[^|;&]+\\s+(add|commit|checkout|fetch|pull|push)(\\s+.*)?$",
+    "^git\\s+rm\\s+[^|;&]+$",
 
     "^pnpm\\s+(test|run\\s+(test|lint|typecheck|type-check|check|build|dev|start)|install|i|add|remove)(\\s+.*)?$",
-    "^npm\\s+(test|run\\s+(test|lint|typecheck|type-check|check|build|dev|start)|install|i|ci)(\\s+.*)?$",
+    "^npm\\s+(test|run\\s+(test|lint|lint:fix|typecheck|type-check|check|check-types|build|dev|dev:next|start)|install|i|ci)(\\s+.*)?$",
+    "^npm\\s+whoami$",
+    "^npm\\s+list(\\s+(-g|--global))?(\\s+[\\w@/-]+)?$",
+    "^npm\\s+ls(\\s+[\\w@/-]+)*$",
+    "^npm\\s+view\\s+[\\w@/-]+(\\s+.*)?$",
+    "^npm\\s+pack\\s+[\\w@/-]+\\s+--dry-run",
     "^yarn\\s+(test|lint|typecheck|type-check|check|build|dev|start|install|add|remove)(\\s+.*)?$",
     "^npx\\s+(tsc|eslint|prettier|vitest|jest)(\\s+.*)?$",
     "^npx\\s+tsx\\s+[^|;&]+$",
+    "^npx\\s+shadcn@latest\\s+(add|init)(\\s+[\\w@/-]+)*(\\s+--yes)?$",
 
     "^pytest(\\s+.*)?$",
     "^python(3)?\\s+-m\\s+pytest(\\s+.*)?$",
@@ -73,19 +82,38 @@
     "^touch\\s+",
     "^cp\\s+",
     "^mv\\s+",
+    "^rmdir\\s+[^|;&]+$",
 
     "^git\\s+(add|commit|checkout|fetch|pull|push|worktree|merge|rebase|stash\\s+(push|pop|drop|apply)|tag|switch|restore)(\\s+.*)?$",
 
-    "^gh\\s+(pr|issue|repo|release|workflow|run|api)(\\s+.*)?$",
+    "^gh\\s+(pr|issue|repo|release|workflow|run|api|auth)(\\s+.*)?$",
 
-    "^chmod\\s+[0-6][0-7][0-7]\\s+"
+    "^git\\s+rev-parse(\\s+.*)?$",
+    "^git\\s+stash(\\s+--include-untracked|\\s+--all|\\s+-u|\\s+-a)?(\\s+-m\\s+.*)?$",
+    "^git\\s+rev-list\\s+[^|;&]+$",
+    "^git\\s+ls-files(\\s+.*)?$",
+    "^git\\s+check-ignore(\\s+.*)?$",
+    "^git\\s+update-index(\\s+.*)?$",
+
+    "^test\\s+(-[dfeL])\\s+[^|;&]+\\s+(&&|\\|\\|)\\s+echo\\s+",
+    "^npm\\s+update\\s+[@\\w/-]+$",
+
+    "^sleep\\s+\\d+$",
+
+    "^chmod\\s+[0-6][0-7][0-7]\\s+",
+
+    "^lsof\\s+(-[a-zA-Z]+\\s+)*-?i\\s*[:\\d]+",
+    "^npm\\s+run\\s+clean(\\s+.*)?$",
+    "^npm\\s+(dedupe|cache\\s+clean)(\\s+.*)?$",
+    "^curl\\s+(-[sIo]+\\s+)*https?://localhost[:/][^|;&]*$",
+    "^pgrep\\s+"
   ],
 
   "deny_patterns": [
     "^sudo\\b",
     "^doas\\b",
-    "\\brm\\s+.*(-r|-rf|-fr|--recursive)",
-    "\\brm\\s+-[^\\s]*r",
+    "(?<!git\\s)\\brm\\s+.*(-r|-rf|-fr|--recursive)",
+    "(?<!git\\s)\\brm\\s+-[^\\s]*r",
     "^rm\\s+/",
     "\\bmkfs\\.",
     "\\bdd\\b.*\\bof=",
@@ -129,7 +157,7 @@
     "\\.pypirc$",
     "\\.netrc$",
     "\\bsecrets?\\b",
-    "\\bpassw",
+    "\\bpassw(?:ord)?s?\\.(txt|json|env|yaml|yml|ini|conf|cfg)$",
     "\\btoken"
   ]
 }

package/install.js

@@ -34,6 +34,23 @@ function logError(message) {
   log(`  ✗ ${message}`, 'red');
 }
 
+function logUpdated(message) {
+  log(`  ↻ ${message}`, 'blue');
+}
+
+/**
+ * Check if two files have identical content
+ */
+function filesAreIdentical(file1, file2) {
+  try {
+    const content1 = fs.readFileSync(file1);
+    const content2 = fs.readFileSync(file2);
+    return content1.equals(content2);
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Determine the target .claude directory based on installation context
  */
@@ -93,8 +110,18 @@ function copyDirRecursive(src, dest, stats) {
       copyDirRecursive(srcPath, destPath, stats);
     } else {
       if (fs.existsSync(destPath)) {
-        stats.skipped.push(destPath);
-        logSkip(`Skipped (exists): ${path.relative(stats.targetBase, destPath)}`);
+        // Check if files are identical
+        if (filesAreIdentical(srcPath, destPath)) {
+          stats.skipped.push(destPath);
+          logSkip(`Unchanged: ${path.relative(stats.targetBase, destPath)}`);
+        } else {
+          // Backup existing file, then replace
+          const backupPath = destPath + '.bak';
+          fs.copyFileSync(destPath, backupPath);
+          fs.copyFileSync(srcPath, destPath);
+          stats.updated.push(destPath);
+          logUpdated(`Updated (backup: .bak): ${path.relative(stats.targetBase, destPath)}`);
+        }
       } else {
         fs.copyFileSync(srcPath, destPath);
         stats.copied.push(destPath);
@@ -123,6 +150,7 @@ function install() {
 
   const stats = {
     copied: [],
+    updated: [],
     skipped: [],
     targetBase,
   };
@@ -132,6 +160,7 @@ function install() {
     { src: 'hooks', dest: 'scripts' },     // Hooks go to scripts directory
     { src: 'scripts', dest: 'scripts' },
     { src: 'commands', dest: 'commands' },
+    { src: 'skills', dest: 'skills' },
   ];
 
   for (const { src, dest } of mappings) {
@@ -147,7 +176,8 @@ function install() {
   // Summary
   log('\n' + colors.bold + '📊 Installation Summary' + colors.reset);
   log(`   Files copied: ${stats.copied.length}`, 'green');
-  log(`   Files skipped (already exist): ${stats.skipped.length}`, 'yellow');
+  log(`   Files updated (backups created): ${stats.updated.length}`, 'blue');
+  log(`   Files unchanged: ${stats.skipped.length}`, 'yellow');
 
   // Post-install instructions
   log('\n' + colors.bold + '📝 Configuration Required' + colors.reset);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torka/claude-qol",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "Claude Code quality-of-life improvements: auto-approve hooks, context monitoring, and status line enhancements",
   "keywords": [
     "claude-code",
@@ -22,6 +22,7 @@
     "hooks",
     "scripts",
     "commands",
+    "skills",
     "examples",
     ".claude-plugin",
     "install.js",

package/skills/nash/OPUS-ANALYSIS-PROMPT.md

@@ -0,0 +1,204 @@
+# Opus Analysis Prompt Template
+
+> **Usage:** Fill in the placeholders below and provide to an Opus subagent via the Task tool.
+
+---
+
+## Your Task
+
+You are an expert workflow analyst reviewing a Claude Code session transcript. Your goal is to identify improvements that will make the workflow more efficient, clear, and effective for future runs.
+
+## Context
+
+### Project Information
+```
+{PROJECT_CLAUDE_MD}
+```
+
+### Workflow Being Analyzed
+**Name:** `{WORKFLOW_NAME}`
+**Type:** {WORKFLOW_TYPE} (command | skill | agent)
+**Source:** {WORKFLOW_SOURCE} (project-specific | npm-package)
+
+### Workflow Definition
+```markdown
+{WORKFLOW_CONTENT}
+```
+
+{ADDITIONAL_WORKFLOW_FILES}
+
+---
+
+## Session Transcript
+
+The following is the session transcript in JSONL format. Each line is a JSON object representing an event (user message, assistant response, tool call, tool result, etc.).
+
+```jsonl
+{SESSION_TRANSCRIPT}
+```
+
+---
+
+## Analysis Instructions
+
+Analyze this session transcript against the workflow definition. Focus on practical, actionable improvements.
+
+### 1. What Went Well
+
+Identify aspects that worked smoothly:
+- Steps that executed without confusion
+- User satisfaction signals (thanks, approval, moving on quickly)
+- Efficient tool usage (parallel calls, minimal retries)
+- Good error recovery
+- Clear communication
+
+For each positive finding, note:
+- What worked
+- Evidence from transcript (quote or reference)
+- Why it's worth preserving
+
+### 2. What Could Be Better
+
+Identify friction points and inefficiencies:
+
+**Friction Indicators to Look For:**
+- User corrections ("no, I meant...", "actually...", "wait...")
+- Repeated attempts at the same operation
+- Requests for clarification ("what do you mean by...", "can you explain...")
+- Workflow restarts or backtracking
+- Long pauses followed by clarifying questions
+- Error messages and recovery attempts
+- Unnecessary file reads or tool calls
+- Sequential operations that could be parallel
+
+**For each issue found, note:**
+- What went wrong or was inefficient
+- Direct quote or event reference from transcript
+- Impact (time lost, confusion caused, goal blocked)
+- Root cause in workflow definition (if identifiable)
+
+### 3. Specific Improvement Suggestions
+
+For each identified issue, propose a concrete improvement:
+
+**Format:**
+```
+## [PRIORITY] Brief Title
+
+**Evidence:**
+> [Quote or description of the problematic event]
+
+**Root Cause:**
+[Why this happened - workflow instruction unclear, missing step, etc.]
+
+**Proposed Change:**
+- File: `{path-to-file}`
+- Location: {section or line reference}
+- Change:
+  ```markdown
+  [Specific edit - show before/after if possible]
+  ```
+
+**Expected Benefit:**
+[What will improve after this change]
+
+**Effort:** Simple | Moderate | Complex
+```
+
+**Priority Levels:**
+- **HIGH**: Caused workflow failure, significant time loss, or required multiple retries
+- **MEDIUM**: Caused confusion, required clarification, or added unnecessary steps
+- **LOW**: Optimization opportunity - would make workflow faster or clearer but didn't cause problems
+
+### 4. Patterns to Watch
+
+Note any patterns that might indicate systemic issues:
+- Same type of error appearing multiple times
+- Consistent unclear instructions in certain step types
+- Tool usage anti-patterns
+- Communication style issues
+
+---
+
+## Output Format
+
+Structure your response exactly as follows:
+
+```markdown
+# Workflow Analysis: {WORKFLOW_NAME}
+
+## Session Summary
+- **Duration:** [estimate from timestamps]
+- **Workflow completed:** Yes/No/Partial
+- **Overall smoothness:** [1-10 scale]
+
+## What Went Well
+
+### 1. [Title]
+- **Evidence:** [quote/reference]
+- **Why it works:** [explanation]
+
+### 2. [Title]
+...
+
+## What Could Be Better
+
+### 1. [Title]
+- **Evidence:** [quote/reference]
+- **Impact:** [description]
+- **Root cause:** [if known]
+
+### 2. [Title]
+...
+
+## Improvement Suggestions
+
+### 1. [HIGH] [Title]
+- **Evidence:** [quote]
+- **Root Cause:** [explanation]
+- **Proposed Change:**
+  - File: [path]
+  - Edit: [before → after]
+- **Expected Benefit:** [description]
+- **Effort:** [Simple/Moderate/Complex]
+
+### 2. [MEDIUM] [Title]
+...
+
+### 3. [LOW] [Title]
+...
+
+## Patterns Observed
+
+### Recurring Issues
+- [pattern 1]
+- [pattern 2]
+
+### Success Patterns Worth Preserving
+- [pattern 1]
+- [pattern 2]
+
+## Recommendations Summary
+
+| Priority | Improvement | File | Effort |
+|----------|-------------|------|--------|
+| HIGH | [title] | [file] | [effort] |
+| MEDIUM | [title] | [file] | [effort] |
+| LOW | [title] | [file] | [effort] |
+```
+
+---
+
+## Important Notes
+
+1. **Be specific.** Vague suggestions like "improve clarity" are not actionable. Show exactly what text to change.
+
+2. **Be evidence-based.** Every suggestion must reference specific events in the transcript.
+
+3. **Be practical.** Focus on changes that will have real impact, not theoretical improvements.
+
+4. **Preserve what works.** Don't suggest changing things that are working well.
+
+5. **Consider the user.** This workflow is used by a solo developer who values efficiency. Optimize for their workflow, not for edge cases.
+
+6. **Scope appropriately.** Suggest changes to the workflow files, not to Claude's core behavior or the user's project code.

package/skills/nash/SKILL.md

@@ -0,0 +1,400 @@
+---
+name: nash
+description: Workflow optimization loop that reviews Claude Code session transcripts to extract learnings and improve workflows. Run at end of sessions to create a continuous improvement cycle.
+tools: Read, Write, Edit, Glob, Grep, Bash, Task, AskUserQuestion
+---
+
+# Nash: Workflow Optimization Loop
+
+**Goal:** Review Claude Code session transcripts to extract learnings and improve workflows, creating a continuous improvement cycle.
+
+---
+
+## Configuration
+
+### NPM Package Sources
+
+When a workflow is from an NPM package, edits are made to the source directory:
+
+| Package | Local Path |
+|---------|------------|
+| `@torka/claude-workflows` | `~/Coding/npm-torka/vt-claude-workflows/` |
+| `@torka/claude-qol` | `~/Coding/npm-torka/vt-claude-qol/` |
+
+### Workflow File Locations
+
+| Type | Pattern |
+|------|---------|
+| Commands | `.claude/commands/{name}.md` |
+| Skills | `.claude/skills/{name}/SKILL.md` |
+| Agents | `.claude/agents/{name}.md` |
+| BMAD | `.claude/commands/bmad/{module}/...` |
+
+---
+
+## How It Works
+
+1. **Discovery** - Find the current session and detect which workflows were used
+2. **Selection** - Choose which session/workflow to optimize
+3. **Analysis** - Use Opus to deeply analyze the session transcript
+4. **Review** - Present findings and prioritize improvements
+5. **Execute** - Apply approved changes to workflow sources
+
+---
+
+## STEP 1: Discovery & Selection
+
+### 1.1 Identify Current Context
+
+Detect the current project and find recent sessions:
+
+```bash
+# Get current project path
+PROJECT_PATH=$(pwd)
+
+# Claude session files location
+SESSIONS_DIR=~/.claude/projects
+
+# List recent sessions (most recent first)
+ls -lt "$SESSIONS_DIR"/*/*.jsonl 2>/dev/null | head -10
+```
+
+### 1.2 Parse Session for Workflows
+
+Read the session JSONL file and extract workflow invocations. Look for:
+- `/command-name` patterns in user messages
+- `Skill` tool invocations
+- `Task` tool invocations with workflow-related prompts
+
+**Detection approach:**
+```
+For each line in session JSONL:
+  - If user message: Look for /[\w:-]+ patterns (slash commands)
+  - If assistant message with tool calls:
+    - If Skill tool: Extract skill name from parameters
+    - If Task tool: Note if it references a workflow
+```
+
+### 1.3 Present Options to User
+
+Display discovered options:
+
+```
+=== NASH: Workflow Optimization ===
+
+Current Session Analysis:
+- Session: [session-uuid]
+- Duration: [calculated from timestamps]
+- Workflows detected: /dev-story, /code-review
+
+Options:
+1. [Default] Optimize from current session
+   - Workflow: [first detected workflow]
+   - Session: [current]
+
+2. Recent sessions:
+   a) [time ago] /create-story on vt-saas-template
+   b) [time ago] /implement-epic on vt-saas-template
+
+3. Manual selection
+   - Specify workflow + session path
+
+Select option [1-3]:
+```
+
+### CHECKPOINT 1
+
+**Present to user:**
+- Session identified (ID, duration, size)
+- Workflows detected in session
+- Options for what to optimize
+
+**Use AskUserQuestion to get user selection before proceeding.**
+
+---
+
+## STEP 2: Load Context & Determine Source
+
+### 2.1 Resolve Workflow Files
+
+Based on user selection, locate all relevant workflow files:
+
+```bash
+# For commands
+WORKFLOW_FILE=".claude/commands/{name}.md"
+
+# For skills
+WORKFLOW_FILE=".claude/skills/{name}/SKILL.md"
+# Also check for additional files in the skill directory
+
+# For agents
+WORKFLOW_FILE=".claude/agents/{name}.md"
+```
+
+### 2.2 Dynamic NPM Package Detection
+
+Determine if the workflow comes from an NPM package by reading `plugin.json` files:
+
+```bash
+# Known NPM package directories
+NPM_PACKAGES=(
+  "$HOME/Coding/npm-torka/vt-claude-workflows"
+  "$HOME/Coding/npm-torka/vt-claude-qol"
+)
+
+# For each package, read plugin.json to find workflow sources
+for pkg in "${NPM_PACKAGES[@]}"; do
+  if [ -f "$pkg/.claude-plugin/plugin.json" ]; then
+    cat "$pkg/.claude-plugin/plugin.json"
+    # Parse the commands, agents, skills arrays
+    # If workflow name matches, this is the source
+  fi
+done
+```
+
+**Detection logic:**
+1. Read each package's `plugin.json`
+2. Check if workflow name appears in `commands`, `agents`, or `skills` arrays
+3. If match found → NPM package source (record package path)
+4. If no match → Project-specific
+
+### 2.3 Gather All Context Files
+
+Collect:
+1. **Session transcript** - The full JSONL file
+2. **Primary workflow file** - The main workflow/command/skill definition
+3. **Step files** - Any included steps (for skills)
+4. **Template files** - Referenced templates
+5. **Project CLAUDE.md** - For project context
+
+### CHECKPOINT 2
+
+**Confirm with user:**
+- Workflow file path(s) to analyze
+- Session file path
+- Workflow source: `project-specific` or `npm-package: @torka/{name}`
+- Context files that will be included
+
+**Use AskUserQuestion for explicit confirmation before proceeding to analysis.**
+
+---
+
+## STEP 3: Analysis (Opus Subagent)
+
+### 3.1 Prepare Analysis Context
+
+Read the Opus prompt template:
+```bash
+cat .claude/skills/nash/OPUS-ANALYSIS-PROMPT.md
+```
+
+Populate the template with:
+- `{PROJECT_CLAUDE_MD}` - Contents of project's CLAUDE.md
+- `{WORKFLOW_NAME}` - Name of the workflow being analyzed
+- `{WORKFLOW_TYPE}` - command | skill | agent
+- `{WORKFLOW_SOURCE}` - project-specific | npm-package
+- `{WORKFLOW_CONTENT}` - Full workflow file content
+- `{ADDITIONAL_WORKFLOW_FILES}` - Step files, templates, etc.
+- `{SESSION_TRANSCRIPT}` - Full JSONL content
+
+### 3.2 Launch Opus Subagent
+
+Use the Task tool to spawn an Opus subagent:
+
+```
+Task(
+    subagent_type="general-purpose",
+    model="opus",
+    prompt=<populated OPUS-ANALYSIS-PROMPT>
+)
+```
+
+### 3.3 Receive Structured Analysis
+
+The Opus subagent returns findings in structured markdown:
+- What Went Well (with evidence)
+- What Could Be Better (with evidence)
+- Specific Improvement Suggestions (prioritized)
+
+### CHECKPOINT 3
+
+**Analysis complete.** Opus findings received. Proceed to review.
+
+---
+
+## STEP 4: Review & Prioritize
+
+### 4.1 Present Findings
+
+Display the analysis results in an actionable format:
+
+```
+=== ANALYSIS COMPLETE ===
+
+What Went Well:
+- [finding 1]
+- [finding 2]
+
+Improvement Opportunities:
+1. [HIGH] Add pre-validation step before X
+   - Evidence: User had to restart 3 times due to missing file
+   - Effort: Simple
+
+2. [MEDIUM] Clarify step 3 instructions
+   - Evidence: User asked clarifying question
+   - Effort: Simple
+
+3. [LOW] Add parallel tool calls for search operations
+   - Evidence: Sequential searches added latency
+   - Effort: Moderate
+
+Select items to action [1,2,3 or 'all' or 'none']:
+```
+
+### 4.2 Gather User Feedback
+
+Using AskUserQuestion:
+- Which improvements to implement
+- Any custom improvements to add
+- Any modifications to suggestions
+- Final confirmation of action list
+
+### CHECKPOINT 4
+
+**Action list confirmed:**
+- [X] Improvement 1
+- [X] Improvement 3
+- [ ] Improvement 2 (skipped)
+
+**Wait for user approval of final action list before executing.**
+
+---
+
+## STEP 5: Execute Changes
+
+### 5.1 Generate Edit Plan
+
+For each approved improvement:
+1. Identify exact file(s) to modify
+2. Draft specific edits (old_string → new_string)
+3. Note dependencies between edits
+
+Present edit plan:
+```
+File: .claude/commands/dev-story.md
+Edit 1: Add validation step
+  - Location: After step 1
+  - Change: [before → after preview]
+```
+
+### 5.2 Execute Based on Source Type
+
+#### Path (a) - Project-Specific Workflow
+
+```bash
+# Make edits directly to project's .claude/ directory
+Edit(
+    file_path=".claude/commands/{name}.md",
+    old_string="...",
+    new_string="..."
+)
+
+# Validate changes
+cat .claude/commands/{name}.md | head -50
+```
+
+**Done after validation.**
+
+#### Path (b) - NPM-Packaged Workflow
+
+**Step 1:** Read NPM package CLAUDE.md for package-specific instructions:
+```bash
+cat ~/Coding/npm-torka/{package-name}/CLAUDE.md
+```
+
+**Step 2:** Make edits to NPM package source:
+```bash
+Edit(
+    file_path="~/Coding/npm-torka/{package-name}/{source-path}",
+    old_string="...",
+    new_string="..."
+)
+```
+
+**Step 3:** Bump version (patch for fixes, minor for features):
+```bash
+cd ~/Coding/npm-torka/{package-name}
+npm version patch --no-git-tag-version
+```
+
+**Step 4:** Commit changes:
+```bash
+cd ~/Coding/npm-torka/{package-name}
+git add -A
+git commit -m "fix({workflow-name}): {brief description}"
+```
+
+**Step 5:** Push if configured:
+```bash
+cd ~/Coding/npm-torka/{package-name}
+git push origin main 2>/dev/null || echo "Push manually if needed"
+```
+
+**Step 6:** Prompt for publish:
+```
+Ready to publish @torka/{package-name}@{new-version}
+
+If you have 2FA enabled on npmjs.com, run manually:
+cd ~/Coding/npm-torka/{package-name} && npm publish
+
+Otherwise, I can run `npm publish` for you.
+```
+
+**Step 7:** Update project dependency:
+```bash
+npm update @torka/{package-name}
+```
+
+### 5.3 Validate Changes
+
+```bash
+# Verify file was modified correctly
+cat {modified-file-path}
+
+# For NPM packages, verify version bump
+cat ~/Coding/npm-torka/{package-name}/package.json | grep version
+```
+
+### CHECKPOINT 5 (Final)
+
+**Summary:**
+- Files modified: [list]
+- Changes made: [summary]
+- Workflow source: [project-specific or npm-package]
+- Next steps: [if any, e.g., "run npm publish manually"]
+
+**Confirm completion with user.**
+
+---
+
+## Quick Reference
+
+### Session File Location
+```
+~/.claude/projects/{encoded-project-path}/{session-uuid}.jsonl
+```
+
+### Priority Levels
+- **HIGH**: Caused workflow failures or significant friction
+- **MEDIUM**: Caused confusion or required clarification
+- **LOW**: Optimization opportunities (speed, clarity)
+
+### Effort Levels
+- **Simple**: Single file edit, clear change
+- **Moderate**: Multiple files or requires careful consideration
+- **Complex**: Architectural change or significant rewrite
+
+### JSONL Event Types (for parsing)
+- `user` - User message (look for /commands here)
+- `assistant` - Assistant response with tool_calls
+- `tool_result` - Result of a tool call