commit 42b99b32d2f318bd967736e2e8bf8a5204de1aaa
Author: Zhongwei Li <lizhongwei.nkcs@gmail.com>
Date:   Sun Nov 30 08:29:00 2025 +0800

    Initial commit

diff --git a/.claude-plugin/plugin.json b/.claude-plugin/plugin.json
new file mode 100644
index 0000000..b695ad1
--- /dev/null
+++ b/.claude-plugin/plugin.json
@@ -0,0 +1,15 @@
+{
+  "name": "context-master",
+  "description": "Universal context management and planning system. PROACTIVELY activate for: (1) ANY complex task requiring planning, (2) Multi-file projects/websites/apps, (3) Architecture decisions, (4) Research tasks, (5) Refactoring, (6) Long coding sessions, (7) Tasks with 3+ sequential steps. Provides: optimal file creation order, context-efficient workflows, extended thinking delegation (23x context efficiency), Claude Sonnet 4.5 token budgeting, recursive delegation patterns, clear-and-verify production workflows, passive deep analysis architecture, progressive task decomposition, cross-platform Windows/Git Bash support, and prevents redundant work. Saves 62% context on average. Essential for maintaining session performance and analytical depth.",
+  "version": "2.2.0",
+  "author": {
+    "name": "Josiah Siegel",
+    "email": "JosiahSiegel@users.noreply.github.com"
+  },
+  "skills": [
+    "./skills"
+  ],
+  "commands": [
+    "./commands"
+  ]
+}
\ No newline at end of file
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..be1b3c9
--- /dev/null
+++ b/README.md
@@ -0,0 +1,3 @@
+# context-master
+
+Universal context management and planning system. PROACTIVELY activate for: (1) ANY complex task requiring planning, (2) Multi-file projects/websites/apps, (3) Architecture decisions, (4) Research tasks, (5) Refactoring, (6) Long coding sessions, (7) Tasks with 3+ sequential steps. Provides: optimal file creation order, context-efficient workflows, extended thinking delegation (23x context efficiency), Claude Sonnet 4.5 token budgeting, recursive delegation patterns, clear-and-verify production workflows, passive deep analysis architecture, progressive task decomposition, cross-platform Windows/Git Bash support, and prevents redundant work. Saves 62% context on average. Essential for maintaining session performance and analytical depth.
diff --git a/commands/plan-project.md b/commands/plan-project.md
new file mode 100644
index 0000000..3367237
--- /dev/null
+++ b/commands/plan-project.md
@@ -0,0 +1,161 @@
+---
+description: Plan optimal file creation order for multi-file projects before implementation
+---
+
+## CRITICAL GUIDELINES
+
+### Windows File Path Requirements
+
+**MANDATORY: Always Use Backslashes on Windows for File Paths**
+
+When using Edit or Write tools on Windows, you MUST use backslashes (`\`) in file paths, NOT forward slashes (`/`).
+
+**Examples:**
+- WRONG: `D:/repos/project/file.tsx`
+- CORRECT: `D:
epos\projectile.tsx`
+
+This applies to:
+- Edit tool file_path parameter
+- Write tool file_path parameter
+- All file operations on Windows systems
+
+### Windows/Git Bash Path Conversion
+
+When using Git Bash on Windows, automatic path conversion may occur:
+- Unix paths (`/foo`) convert to Windows paths automatically
+- This usually works transparently
+- See WINDOWS_GIT_BASH_GUIDE.md for advanced scenarios and troubleshooting
+
+### Documentation Guidelines
+
+**NEVER create new documentation files unless explicitly requested by the user.**
+
+- **Priority**: Update existing README.md files rather than creating new documentation
+- **Repository cleanliness**: Keep repository root clean - only README.md unless user requests otherwise
+- **Style**: Documentation should be concise, direct, and professional
+- **User preference**: Only create additional .md files when user specifically asks
+
+---
+
+# Plan Project
+
+## Purpose
+Before creating any files in a multi-file project (3+ related files), this command helps you plan the optimal creation order, identify dependencies, and prevent redundant work.
+
+## When to Use
+- Creating websites with multiple pages
+- Building applications with multiple components
+- Projects with shared dependencies (CSS, config files)
+- API implementations with multiple endpoints
+- Documentation sets with multiple files
+- Any task involving 3+ related files
+
+## Instructions
+
+### Step 1: Extended Thinking for Architecture
+IMMEDIATELY use extended thinking to analyze the project:
+
+```
+"Think hard about the architecture for this [project type]:
+- What files are needed and what is their purpose?
+- What are the shared dependencies (CSS, config, base classes)?
+- What is the optimal creation order and why?
+- What are the cross-file references?
+- What could go wrong if we create files in the wrong order?"
+```
+
+### Step 2: Create Architecture Plan
+Based on the thinking, create a plan following this template:
+
+```
+ARCHITECTURE PLAN:
+
+FILES NEEDED:
+  - [filename]: [purpose]
+  - [filename]: [purpose]
+
+SHARED DEPENDENCIES (must be created first):
+  - [dependency]: [what files need this]
+
+CREATION ORDER (numbered with reasoning):
+  1. [file] - Reason: [why this first]
+  2. [file] - Reason: [why this second]
+  3. [file] - Reason: [why this third]
+
+CROSS-FILE REFERENCES:
+  - [file A] references [file B] via [method]
+
+POTENTIAL ISSUES TO AVOID:
+  - [what could go wrong]
+  - [common mistake]
+```
+
+### Step 3: Announce the Plan to User
+Tell the user your file creation order before starting:
+
+```
+"I'll create these files in this order:
+1. [file] - [reason]
+2. [file] - [reason]
+3. [file] - [reason]
+...
+
+This order ensures all dependencies are in place before files that need them."
+```
+
+### Step 4: Create Files in Optimal Order
+Follow the plan:
+- Create foundation files first (CSS, config, base classes)
+- Create dependent files after their dependencies exist
+- Keep consistent naming and structure
+- Add comments about dependencies
+
+### Step 5: Verify
+After creating all files, verify:
+- All file paths are correct
+- CSS/JS references load properly
+- Navigation between pages works
+- Cross-file dependencies resolve
+- No broken links or missing file references
+
+## Key Principles
+
+**Foundations First:**
+- CSS files before HTML files that use them
+- Configuration files before code that needs them
+- Base classes before derived classes
+
+**Core Before Features:**
+- index.html before other pages
+- main.js before feature modules
+- Core API before additional endpoints
+
+**Structure Before Content:**
+- HTML structure before detailed content
+- API structure before implementation details
+- Component scaffolds before full logic
+
+## Token Savings
+- Without planning: ~8,000 tokens (redundant work + fixes)
+- With planning: ~3,000 tokens (efficient creation)
+- **Savings: ~5,000 tokens (62% reduction) per project**
+
+## Example: Portfolio Website
+
+**User Request:** "Create a portfolio with home, about, projects, and contact pages"
+
+**Your Response:**
+1. Use extended thinking to plan
+2. Announce: "I'll create: 1. styles.css, 2. index.html, 3. about.html, 4. projects.html, 5. contact.html"
+3. Create files in that order
+4. Verify all HTML files reference styles.css correctly
+
+**Result:** Efficient, no refactoring needed!
+
+## Windows/Git Bash Notes
+
+On Windows with Git Bash:
+- Path planning uses forward slashes (Unix format)
+- Actual file creation uses backslashes (Windows format)
+- Verification handles both formats automatically
+- See WINDOWS_GIT_BASH_GUIDE.md for detailed guidance
diff --git a/plugin.lock.json b/plugin.lock.json
new file mode 100644
index 0000000..15d6f29
--- /dev/null
+++ b/plugin.lock.json
@@ -0,0 +1,69 @@
+{
+  "$schema": "internal://schemas/plugin.lock.v1.json",
+  "pluginId": "gh:JosiahSiegel/claude-code-marketplace:plugins/context-master",
+  "normalized": {
+    "repo": null,
+    "ref": "refs/tags/v20251128.0",
+    "commit": "7ddb096e56abe2a195ece63dfbac05afb31b082d",
+    "treeHash": "d5baaf9d6206e38117776537c2d402aeed9a7cf8f954852844e54f9f46c12e61",
+    "generatedAt": "2025-11-28T10:11:48.923920Z",
+    "toolVersion": "publish_plugins.py@0.2.0"
+  },
+  "origin": {
+    "remote": "git@github.com:zhongweili/42plugin-data.git",
+    "branch": "master",
+    "commit": "aa1497ed0949fd50e99e70d6324a29c5b34f9390",
+    "repoRoot": "/Users/zhongweili/projects/openmind/42plugin-data"
+  },
+  "manifest": {
+    "name": "context-master",
+    "description": "Universal context management and planning system. PROACTIVELY activate for: (1) ANY complex task requiring planning, (2) Multi-file projects/websites/apps, (3) Architecture decisions, (4) Research tasks, (5) Refactoring, (6) Long coding sessions, (7) Tasks with 3+ sequential steps. Provides: optimal file creation order, context-efficient workflows, extended thinking delegation (23x context efficiency), Claude Sonnet 4.5 token budgeting, recursive delegation patterns, clear-and-verify production workflows, passive deep analysis architecture, progressive task decomposition, cross-platform Windows/Git Bash support, and prevents redundant work. Saves 62% context on average. Essential for maintaining session performance and analytical depth.",
+    "version": "2.2.0"
+  },
+  "content": {
+    "files": [
+      {
+        "path": "README.md",
+        "sha256": "ee27fbcb2b33b4aa550a0384313274722974a234792788592578ffb0ff4addf5"
+      },
+      {
+        "path": ".claude-plugin/plugin.json",
+        "sha256": "fad7d91b913e787f376a76234773b24374638565bae3f5e4a9ef548f4bb6df58"
+      },
+      {
+        "path": "commands/plan-project.md",
+        "sha256": "aecd3e2b1e9b0c1a68ad713fd4d140062a70b34c9c5b7dcdf8261d6afc5cc59e"
+      },
+      {
+        "path": "skills/context-master/SKILL.md",
+        "sha256": "6acfe436b0072903e7cb5e6534dcf3f2bbcaa4c385d474e8687f79a86a0e9f45"
+      },
+      {
+        "path": "skills/context-master/references/agent-skills-integration-2025.md",
+        "sha256": "1f724bffe009fbca12d34a8125a2fc99f04e6dec8aa6b6107f29ce6bb0c36339"
+      },
+      {
+        "path": "skills/context-master/references/context_strategies.md",
+        "sha256": "d326fc1d2443b8b6b888fd325f0cf8efe4d012fe862dccfecfde20fecf22cf75"
+      },
+      {
+        "path": "skills/context-master/references/subagent_patterns.md",
+        "sha256": "44d625b12e7ce06a8305b857048f65119320d69fd0c7b95bd2d0a1a0af1eaa58"
+      },
+      {
+        "path": "skills/context-master/scripts/create_subagent.py",
+        "sha256": "78a5052af6120100c48b0689028b5d3dfa742f128ac853e7c88b886b11434fcd"
+      },
+      {
+        "path": "skills/context-master/scripts/generate_claude_md.py",
+        "sha256": "3aa3eda5cd9ebd75344c540a9d8e31970c64540c7ab51c0a6867028f498fa8a2"
+      }
+    ],
+    "dirSha256": "d5baaf9d6206e38117776537c2d402aeed9a7cf8f954852844e54f9f46c12e61"
+  },
+  "security": {
+    "scannedAt": null,
+    "scannerVersion": null,
+    "flags": []
+  }
+}
\ No newline at end of file
diff --git a/skills/context-master/SKILL.md b/skills/context-master/SKILL.md
new file mode 100644
index 0000000..c4ba505
--- /dev/null
+++ b/skills/context-master/SKILL.md
@@ -0,0 +1,1661 @@
+---
+name: context-master
+description: "Universal context management and planning system. PROACTIVELY activate for: (1) ANY complex task requiring planning, (2) Multi-file projects/websites/apps, (3) Architecture decisions, (4) Research tasks, (5) Refactoring, (6) Long coding sessions, (7) Tasks with 3+ sequential steps. Provides: optimal file creation order, context-efficient workflows, extended thinking delegation (23x context efficiency), passive deep analysis architecture, progressive task decomposition, and prevents redundant work. Saves 62% context on average. Essential for maintaining session performance and analytical depth."
+---
+
+# Context Master
+
+## 🚨 CRITICAL GUIDELINES
+
+### Windows File Path Requirements
+
+**MANDATORY: Always Use Backslashes on Windows for File Paths**
+
+When using Edit or Write tools on Windows, you MUST use backslashes (`\`) in file paths, NOT forward slashes (`/`).
+
+**Examples:**
+- ❌ WRONG: `D:/repos/project/file.tsx`
+- ✅ CORRECT: `D:\repos\project\file.tsx`
+
+This applies to:
+- Edit tool file_path parameter
+- Write tool file_path parameter
+- All file operations on Windows systems
+
+### Documentation Guidelines
+
+**NEVER create new documentation files unless explicitly requested by the user.**
+
+- **Priority**: Update existing README.md files rather than creating new documentation
+- **Repository cleanliness**: Keep repository root clean - only README.md unless user requests otherwise
+- **Style**: Documentation should be concise, direct, and professional - avoid AI-generated tone
+- **User preference**: Only create additional .md files when user specifically asks for documentation
+
+
+
+---
+
+Universal context management and planning system for complex tasks, long coding sessions, and efficient workflow optimization.
+
+---
+
+## ⚡ TL;DR QUICK START (Read This First)
+
+**For ANY multi-file project, follow these 5 steps:**
+
+```
+1️⃣ STOP - Don't create files yet
+2️⃣ PLAN - Use "think hard" OR create planning document
+3️⃣ ANNOUNCE - Tell user your file creation order
+4️⃣ CREATE - Make files in optimal order (dependencies first)
+5️⃣ VERIFY - Check all references work
+```
+
+**Example:**
+```
+User: "Create a portfolio with home, about, projects pages"
+
+✓ Step 1: STOP [Don't immediately create index.html]
+✓ Step 2: PLAN [Think: Need styles.css + 3 HTML files, CSS first]
+✓ Step 3: ANNOUNCE ["I'll create: 1. styles.css, 2. index.html, 3. about.html, 4. projects.html"]
+✓ Step 4: CREATE [Make them in that order]
+✓ Step 5: VERIFY [Check all HTML files link to styles.css correctly]
+
+Result: Done efficiently, no refactoring needed!
+```
+
+**Token savings: ~5,000 tokens (62%) vs doing it wrong**
+
+**Continue reading below for detailed guidance...**
+
+---
+
+## Overview
+
+This skill provides comprehensive context management, planning strategies, and workflow optimization for ANY complex coding task, not just multi-file projects.
+
+**MUST use this skill for:**
+- ✅ ANY complex task requiring planning or strategy
+- ✅ Multi-file projects (HTML, CSS, JS, APIs, apps, docs)
+- ✅ Architecture or design decisions
+- ✅ Research tasks requiring analysis
+- ✅ Refactoring work
+- ✅ Long coding sessions (context optimization)
+- ✅ Tasks with 3+ sequential steps
+
+**What this skill provides:**
+- **Optimal file creation order** - Which files to create first, dependency management
+- **Context-efficient workflows** - 62% average context savings
+- **Extended thinking delegation** - 23x context efficiency for deep analysis
+- **Passive deep thinking architecture** - Get analytical depth without context cost
+- **Progressive task decomposition** - Break complex tasks into manageable phases
+- **Planning frameworks** - Think before coding, prevent redundant work
+- **Session optimization** - Maintain performance in long interactions
+
+**This skill activates automatically for:**
+- Complex tasks requiring planning ("build...", "create...", "implement...")
+- Architecture decisions ("should we use...", "which approach...")
+- Research requests ("research...", "analyze...", "compare...")
+- Refactoring work ("refactor...", "improve...", "optimize...")
+- Multi-step workflows (any task with 3+ steps)
+- Long coding sessions (automatic context monitoring)
+
+---
+
+# ⚠️ MANDATORY FIRST STEP - READ THIS BEFORE DOING ANYTHING ⚠️
+
+## 🛑 STOP - DO THIS FIRST 🛑
+
+**IMMEDIATELY use extended thinking to plan. Do NOT create any files yet.**
+
+**Your exact next output MUST be:**
+
+```
+"Think hard about the architecture for this [project type]:
+- What files are needed and what is their purpose?
+- What are the shared dependencies (CSS, config, base classes)?
+- What is the optimal creation order and why?
+- What are the cross-file references?
+- What could go wrong if we create files in the wrong order?"
+```
+
+**After the extended thinking completes, THEN announce your plan to the user.**
+
+**DO NOT create files until you:**
+1. ✅ Complete extended thinking 
+2. ✅ Announce the plan to the user
+3. ✅ Get their acknowledgment (or proceed if plan is sound)
+
+---
+
+## 🎯 PLANNING METHOD OPTIONS
+
+**You have TWO equally effective planning approaches:**
+
+### Option A: Extended Thinking (Pure Mental Planning)
+```
+"Think hard about the architecture for this [project]:
+- What files are needed?
+- What is the optimal creation order?
+- What dependencies exist?"
+```
+
+**Best for:** Quick projects, straightforward structures, when planning fits in thinking block
+
+### Option B: Planning Document (Structured Written Plan)
+```
+Use bash_tool or create an artifact for the planning document:
+
+ARCHITECTURE_PLAN.md:
+- Files needed: [list]
+- Creation order: [numbered list]
+- Dependencies: [diagram/list]
+- Potential issues: [list]
+```
+
+**Best for:** Complex projects, when you want a reference document, when planning is extensive
+
+**Both work equally well!** Choose based on project complexity and your preference.
+
+**Example using bash_tool for planning:**
+```bash
+cat > ARCHITECTURE_PLAN.md << 'EOF'
+# Portfolio Website Architecture
+
+## Files Needed
+1. styles.css - Shared styling
+2. index.html - Home page
+3. about.html - About page
+4. projects.html - Projects page
+5. contact.html - Contact page
+
+## Creation Order
+1. styles.css (shared dependency, created first)
+2. index.html (references styles.css)
+3. about.html (references styles.css)
+4. projects.html (references styles.css)
+5. contact.html (references styles.css)
+
+## Cross-References
+- All HTML files link to styles.css via <link rel="stylesheet">
+- All pages navigate to each other via <a href="...">
+EOF
+```
+
+**Benefit of planning document:** You can reference it throughout the project, and it serves as documentation.
+
+---## 💰 WHY THIS MATTERS: Token Savings
+
+**Without planning:**
+- Create files → Realize structure is wrong → Refactor → More explanations
+- **Cost: ~8,000 tokens** (redundant work + explanations + fixes)
+
+**With planning (this skill):**
+- Think first → Create files in optimal order → Done correctly first time
+- **Cost: ~3,000 tokens** (efficient creation only)
+
+**💡 Savings: ~5,000 tokens (62% reduction) per multi-file project**
+
+Over a long session with multiple projects, this compounds significantly.
+
+### Real-World Token Savings by Project Size
+
+**Small Project (3-4 files) - Portfolio Website**
+```
+Without planning: ~6,000 tokens
+  - Create HTML → Add inline styles → Extract CSS → Update refs
+With planning: ~2,500 tokens
+  - Plan → Create CSS → Create HTML with refs
+💰 Savings: ~3,500 tokens (58%)
+```
+
+**Medium Project (7-8 files) - Multi-page App**
+```
+Without planning: ~12,000 tokens
+  - Create pages → Realize shared components → Refactor → Fix imports
+With planning: ~4,500 tokens
+  - Plan → Create shared → Create pages → No refactoring
+💰 Savings: ~7,500 tokens (63%)
+```
+
+**Large Project (20+ files) - Full Application**
+```
+Without planning: ~35,000 tokens
+  - Create files randomly → Multiple refactoring cycles → Fix dependencies
+With planning: ~12,000 tokens
+  - Plan architecture → Create in optimal order → Minimal fixes
+💰 Savings: ~23,000 tokens (66%)
+```
+
+**Context window capacity:**
+- Standard: 200K tokens
+- With planning: Can complete 16-17 medium projects
+- Without planning: Can complete only 7-8 medium projects
+- **Effective capacity increase: 2.1x**
+
+---## 🚨 ACTIVATION TRIGGERS (You are seeing one of these RIGHT NOW)
+
+If the user's request includes ANY of these phrases, this skill activated for a reason:
+
+- ✅ "create a website with..." ← **YOU ARE HERE**
+- ✅ "build 3+ pages/files"
+- ✅ "make a [type] application"
+- ✅ "create [home/about/contact] pages"
+- ✅ "build an API with..."
+- ✅ "generate documentation for..."
+
+**→ Your NEXT output should be extended thinking about architecture, NOT file creation**
+
+---
+
+## 📊 POST-PROJECT REFLECTION (Optional But Valuable)
+
+**After completing a multi-file project, take a moment to assess the context savings:**
+
+### Quick Self-Assessment Questions
+
+```
+1. Did you plan before creating files? [Yes/No]
+   
+2. How many files did you create? [Number]
+
+3. Did you have to refactor or fix file references? [Yes/No]
+   
+4. If you planned first:
+   - Estimated context used: ~[2,500-4,500] tokens for [3-8] files
+   
+5. If you created without planning:
+   - You likely used: ~[6,000-12,000] tokens
+   - Potential savings missed: ~[3,500-7,500] tokens
+```
+
+### Success Indicators
+
+**✅ You used the skill effectively if:**
+- Created foundation files (CSS, config) before dependent files
+- No major refactoring needed after file creation
+- All file references worked on first try
+- Could describe file creation order before starting
+- Spent more time planning than fixing
+
+**⚠️ You could improve if:**
+- Had to go back and add shared dependencies
+- Needed to refactor file structure after creation
+- Found broken references between files
+- Created files in no particular order
+- Spent more time fixing than planning
+
+### Context Savings Calculator
+
+**Estimate your actual savings:**
+```
+Files created: [N]
+Did planning: [Yes/No]
+
+If Yes:
+  Tokens used: ~(N × 350) + 500 for planning
+  Tokens saved: ~(N × 800)
+  Efficiency: ~70%
+
+If No:
+  Tokens used: ~(N × 1,150) 
+  Missed savings: ~(N × 800)
+  Next time: Plan first!
+```
+
+**Example for 5-file project:**
+- With planning: ~2,250 tokens
+- Without planning: ~5,750 tokens  
+- Actual savings: ~3,500 tokens (60%)
+
+This reflection helps you recognize when the skill is working and when to apply it more strictly next time!
+
+---
+
+## ✓ REQUIRED WORKFLOW CHECKLIST
+
+**For EVERY multi-file project, follow this exact sequence:**
+
+```
+☐ Step 1: THINK FIRST - Use "think hard" to plan architecture
+         (List all files, determine optimal order, identify dependencies)
+         
+☐ Step 2: ANNOUNCE THE PLAN - Tell user the file creation order
+         ("I'll create files in this order: 1. CSS, 2. index.html, 3...")
+         
+☐ Step 3: CREATE FOUNDATION FILES - Shared dependencies first
+         (CSS files, config files, base classes)
+         
+☐ Step 4: CREATE DEPENDENT FILES - Files that use the foundations
+         (HTML pages that reference CSS, components that use base classes)
+         
+☐ Step 5: VERIFY - Check all references/imports work
+```
+
+**DO NOT skip Step 1. ALWAYS think before creating files.**
+
+---
+
+## 🔴 COMMON MISTAKE TO AVOID
+
+**WRONG APPROACH (what you might do without this skill):**
+```
+User: "Create a portfolio with home, about, and projects pages"
+You: [Creates index.html]
+You: [Creates about.html]
+You: [Creates projects.html]
+You: [Realizes CSS should be shared, has to refactor]
+Result: Wasted effort, redundant work
+```
+
+**CORRECT APPROACH (what you MUST do with this skill):**
+```
+User: "Create a portfolio with home, about, and projects pages"
+You: "Think hard about the architecture first..."
+     [Plans: Need 1 CSS file + 3 HTML files, CSS should come first]
+You: "I'll create files in this order: 1. styles.css, 2. index.html, 3. about.html, 4. projects.html"
+You: [Creates files in that order]
+Result: Efficient, no redundant work
+```
+
+---
+
+## ❌ MORE ANTI-PATTERNS (What NOT to Do)
+
+### Anti-Pattern 1: Creating JS Modules Before Main App File
+**Wrong:**
+```
+1. Create utils.js
+2. Create helpers.js
+3. Create api.js
+4. Create app.js (main file that imports all the above)
+Problem: Had to keep going back to app.js to add imports
+```
+
+**Right:**
+```
+1. Think about module structure
+2. Create app.js (with import statements planned)
+3. Create utils.js (knowing what app.js needs)
+4. Create helpers.js (knowing what app.js needs)
+5. Create api.js (knowing what app.js needs)
+Benefit: App.js structured correctly from the start
+```
+
+### Anti-Pattern 2: Writing Inline Styles Then Extracting Later
+**Wrong:**
+```
+1. Create index.html with inline styles
+2. Create about.html with inline styles
+3. Realize styles are duplicated
+4. Extract to styles.css
+5. Update all HTML files to reference it
+Problem: Redundant work, had to edit multiple files
+```
+
+**Right:**
+```
+1. Think: These pages will share styling
+2. Create styles.css first
+3. Create HTML files that reference styles.css
+Benefit: No duplication, no refactoring needed
+```
+
+### Anti-Pattern 3: Building Components Before Data Structure
+**Wrong:**
+```
+1. Create UserProfile.jsx component
+2. Create UserList.jsx component
+3. Realize data structure is unclear
+4. Go back and modify components to match data
+Problem: Components built on assumptions
+```
+
+**Right:**
+```
+1. Think about data structure first
+2. Create types.js or schema.js
+3. Create components that use defined data structure
+Benefit: Components built correctly from the start
+```
+
+### Anti-Pattern 4: Creating Pages Before Shared Layout
+**Wrong:**
+```
+1. Create home.html with full layout
+2. Create about.html with full layout
+3. Realize layout should be shared
+4. Extract to layout component/template
+5. Refactor all pages
+Problem: Major refactoring required
+```
+
+**Right:**
+```
+1. Think: Pages will share layout
+2. Create layout.html or Layout component
+3. Create pages that use the layout
+Benefit: DRY from the start
+```
+
+### Anti-Pattern 5: Creating Config Files Last
+**Wrong:**
+```
+1. Create multiple files with hardcoded values
+2. Realize config should be centralized
+3. Create config.js
+4. Update all files to use config
+Problem: Config scattered, hard to change
+```
+
+**Right:**
+```
+1. Think: What values will be used across files?
+2. Create config.js first
+3. Create other files that import config
+Benefit: Centralized configuration from start
+```
+
+---
+
+# 📖 PART 1: UNIVERSAL GUIDANCE (All Users - Web, API, CLI)
+
+**The sections below apply to ALL users. Read these first regardless of your environment.**
+
+---
+
+## Core Principles (All Environments)
+
+### 1. Extended Thinking for Complex Tasks
+
+Use extended thinking to keep reasoning separate from main context:
+
+**Trigger phrases:**
+- `"think about..."` - Standard extended thinking
+- `"think hard about..."` - More thorough analysis  
+- `"think harder about..."` - Deep analysis
+- `"ultrathink..."` - Maximum thinking budget
+
+**When to use:**
+- Planning complex implementations
+- Analyzing multiple approaches
+- Design decisions with tradeoffs
+- Any task requiring deep reasoning
+
+**Benefit:** Reasoning happens in separate blocks that don't clutter your main context.
+
+### 2. Artifacts for Content Offloading
+
+Create artifacts for substantial content instead of inline responses:
+
+**Use artifacts for:**
+- Code files (>20 lines)
+- Documents, reports, articles
+- Data analysis results
+- Complex visualizations
+- Any reusable content
+
+**Why it works:** Content lives in artifacts, not the conversation context.
+
+### 3. Progressive Task Decomposition
+
+Break complex requests into phases:
+
+**Instead of:**
+"Build me a complete app with authentication, database, and frontend"
+
+**Do this:**
+```
+Phase 1: "think about the architecture for this app"
+[Review architecture plan]
+
+Phase 2: "Create the database schema"
+[Review schema]
+
+Phase 3: "Build the authentication system"
+[Continue phase by phase]
+```
+
+**Benefit:** Each phase has fresh context, no accumulation of old decisions.
+
+### 4. Explicit Context Boundaries
+
+Signal when to start fresh:
+
+- "Let's start fresh with a new approach"
+- "Setting aside the previous discussion..."
+- "Here's a new angle on this problem..."
+
+**In Claude Code:** Use `/clear` command
+**In web/API:** Explicitly state context reset
+
+## Multi-File Project Planning (Critical Section)
+
+**📌 QUICK REMINDER: Did you think first? If not, go back to "STOP - DO THIS FIRST" above.**
+
+**When creating any project with 3+ related files, ALWAYS start with this planning workflow:**
+
+### Step 1: Architecture Planning
+
+**Choose your planning method (both equally effective):**
+
+**Method A: Extended Thinking**
+```
+"Think hard about the architecture for this [project]:
+- What files are needed and their purpose?
+- What are shared dependencies?
+- What is optimal creation order?
+- What are cross-file references?
+- What could go wrong?"
+```
+
+**Method B: Planning Document**
+```
+Create ARCHITECTURE_PLAN.md (via bash_tool or artifact):
+- Files needed with purposes
+- Shared dependencies
+- Numbered creation order with reasoning
+- Cross-file reference map
+- Potential issues to avoid
+```
+
+**Before creating any files, use extended thinking OR create planning document with this template:**
+
+```
+ARCHITECTURE PLAN TEMPLATE:
+
+□ FILES NEEDED:
+  - [filename]: [purpose]
+  - [filename]: [purpose]
+  - [filename]: [purpose]
+
+□ SHARED DEPENDENCIES (must be created first):
+  - [dependency]: [what files need this]
+
+□ CREATION ORDER (numbered with reasoning):
+  1. [file] - Reason: [why this first]
+  2. [file] - Reason: [why this second]
+  3. [file] - Reason: [why this third]
+
+□ CROSS-FILE REFERENCES:
+  - [file A] references [file B] via [method]
+  - [file C] imports [file D] via [method]
+
+□ POTENTIAL ISSUES TO AVOID:
+  - [what could go wrong]
+  - [common mistake]
+```
+
+**Example filled template for portfolio website:**
+
+```
+ARCHITECTURE PLAN:
+
+□ FILES NEEDED:
+  - styles.css: Shared styling for all pages
+  - index.html: Home page with navigation
+  - about.html: About page
+  - projects.html: Portfolio showcase
+  - contact.html: Contact form
+
+□ SHARED DEPENDENCIES:
+  - styles.css: All HTML files need this for consistent styling
+
+□ CREATION ORDER:
+  1. styles.css - Reason: Shared dependency, all HTML files will reference it
+  2. index.html - Reason: Main entry point, establishes structure
+  3. about.html - Reason: References styles.css which now exists
+  4. projects.html - Reason: References styles.css which now exists
+  5. contact.html - Reason: References styles.css which now exists
+
+□ CROSS-FILE REFERENCES:
+  - All HTML files link to styles.css via <link rel="stylesheet">
+  - All HTML pages link to each other via <a href="...">
+
+□ POTENTIAL ISSUES TO AVOID:
+  - Creating HTML before CSS → Would require going back to add links
+  - Inline styles in HTML → Would require extraction later
+  - Inconsistent navigation → Hard to maintain across files
+```
+
+**Use this template in your extended thinking output.**
+
+### Step 2: Optimal File Creation Order
+
+**General principles:**
+
+1. **Foundations first** - Shared dependencies before dependents
+   - CSS files before HTML files that use them
+   - Configuration files before code that needs them
+   - Base classes before derived classes
+
+2. **Core before features** - Essential files before optional ones
+   - index.html before other pages
+   - main.js before feature modules
+   - Core API before additional endpoints
+
+3. **Structure before content** - Layout before details
+   - HTML structure before detailed content
+   - API structure before implementation details
+   - Component scaffolds before full logic
+
+**Common file creation orders:**
+
+**Website project:**
+```
+1. styles.css (shared styling)
+2. index.html (home page - references styles.css)
+3. about.html (references styles.css)
+4. projects.html (references styles.css)
+5. contact.html (references styles.css)
+6. script.js (if needed)
+```
+
+**React application:**
+```
+1. package.json (dependencies)
+2. App.js (main component)
+3. components/Header.js (layout components)
+4. components/Footer.js
+5. pages/Home.js (page components)
+6. pages/About.js
+7. styles/main.css
+```
+
+**Backend API:**
+```
+1. config.js (configuration)
+2. database.js (DB connection)
+3. models/User.js (data models)
+4. routes/auth.js (route handlers)
+5. routes/api.js
+6. server.js (entry point)
+```
+
+### Step 3: Create Files with Awareness
+
+**As you create each file:**
+- Reference what's already been created
+- Note what future files will depend on this one
+- Keep consistent naming and structure
+- Add comments about dependencies
+
+### Step 4: Verify and Test
+
+**After creating all files, perform these verification checks:**
+
+#### ✓ File Path Verification
+```
+□ Check all file paths are correct
+  - CSS links: <link href="styles.css"> (not "style.css" or "css/styles.css")
+  - JS scripts: <script src="script.js"> 
+  - Images: <img src="image.png">
+  - Relative paths match actual file structure
+```
+
+#### ✓ Reference Loading Verification
+```
+□ Ensure CSS/JS references load properly
+  - HTML files can find the CSS file
+  - JavaScript imports resolve correctly
+  - No 404 errors for missing files
+  - Correct syntax in link/script tags
+```
+
+#### ✓ Navigation Verification (for websites)
+```
+□ Test navigation between pages
+  - All navigation links point to correct files
+  - Links use correct relative paths
+  - No broken navigation (links to non-existent pages)
+  - Back/forward navigation works logically
+```
+
+#### ✓ Cross-File Reference Verification
+```
+□ Validate cross-file dependencies work
+  - Components import correctly
+  - Modules can access exported functions
+  - Shared utilities are accessible
+  - API calls reference correct endpoints
+```
+
+#### ✓ Consistency Verification
+```
+□ Check consistency across files
+  - Naming conventions are consistent
+  - Styling is uniform (if using shared CSS)
+  - Code structure follows same patterns
+  - Documentation style matches across files
+```
+
+**Example verification for portfolio website:**
+```
+After creating styles.css, index.html, about.html, projects.html, contact.html:
+
+✓ Verification checklist:
+  [✓] All HTML files have <link rel="stylesheet" href="styles.css">
+  [✓] styles.css exists and has content
+  [✓] Navigation links: 
+      - index.html links to about.html, projects.html, contact.html ✓
+      - All other pages link back to index.html ✓
+  [✓] All pages use consistent styling from styles.css ✓
+  [✓] No broken links or missing file references ✓
+
+Result: Project structure verified, ready to use!
+```
+
+**If verification fails, fix issues before considering the project complete.**
+
+### When to Use This Planning Approach
+
+**ALWAYS plan first for:**
+- Websites with multiple pages (3+ HTML files)
+- Applications with multiple components
+- Projects with shared dependencies (CSS, config files)
+- API implementations with multiple endpoints
+- Documentation sets with multiple files
+- Any project where files reference each other
+
+**Don't need planning for:**
+- Single file creations
+- Truly independent files with no relationships
+- Simple, obvious structures
+
+## Passive Deep Thinking Architecture
+
+**The key insight:** Extended thinking can happen in isolated contexts (subagents/artifacts), keeping the main session lean while still getting deep analysis.
+
+### The Architectural Pattern
+
+```
+Main Session (Orchestrator)
+├─ Stays high-level and focused
+├─ Makes decisions based on summaries
+└─ Delegates complex analysis
+
+        ↓ delegates with thinking triggers ↓
+
+Analysis Layer (Agents/Artifacts)
+├─ Extended thinking happens HERE (5K+ tokens)
+├─ Deep reasoning happens HERE
+├─ Context-heavy work happens HERE
+└─ Returns concise summaries UP (~200 tokens)
+
+        ↑ returns actionable conclusions ↑
+
+Main Session
+└─ Receives well-reasoned recommendations
+└─ Context stays clean for sustained work
+```
+
+### How This Achieves Passive Deep Thinking
+
+**Without thinking delegation:**
+- Extended thinking happens in main context
+- Reasoning accumulates (~5K tokens per analysis)
+- Context fills quickly over long sessions
+- Eventually hits limits
+
+**With thinking delegation:**
+- Subagents/artifacts do extended thinking in isolation
+- Main context only receives summaries (~200 tokens)
+- Can sustain 25+ analyses before context issues
+- Deep thinking happens passively through architecture
+
+**Key benefit:** You get the depth of extended thinking without the context cost.
+
+### Implementation by Environment
+
+#### **Claude Code: Thinking Subagents**
+
+Create subagents that automatically use extended thinking:
+
+```bash
+# Create a deep analyzer for complex decisions
+python scripts/create_subagent.py architecture-advisor --type deep_analyzer
+
+# Create thinking-enabled researcher
+python scripts/create_subagent.py pattern-researcher --type researcher
+```
+
+**Usage:**
+```
+Main session: "I need to decide between microservices and monolith"
+↓
+/agent architecture-advisor "Analyze microservices vs monolith 
+for an e-commerce platform with 10M users, considering team size 
+of 8 developers"
+↓
+Subagent's isolated context:
+  - Uses "ultrathink" automatically
+  - 5K+ tokens of deep reasoning
+  - Evaluates tradeoffs thoroughly
+↓
+Returns to main: "After deep analysis, I recommend starting with 
+a modular monolith because [3 key reasons]. Microservices would 
+add complexity your team size can't support yet."
+↓
+Main session: Receives actionable advice, context clean
+```
+
+**Context saved:** ~4,800 tokens per analysis
+
+#### **Web/API: Thinking Artifacts**
+
+Use artifacts as "thinking containers":
+
+**Pattern:**
+```
+User: "Analyze the best database for this use case"
+
+Claude: "I'll create a deep analysis artifact where I can think 
+through this thoroughly."
+
+[Creates artifact: "database-analysis.md"]
+[Inside artifact:
+  - Extended thinking block (collapsed in UI)
+  - Detailed analysis
+  - Comparison tables
+  - Final recommendation
+]
+
+Main conversation: "Based on the analysis artifact, I recommend 
+PostgreSQL because [2-sentence summary]. See artifact for complete 
+reasoning including performance comparisons and scaling considerations."
+```
+
+**Why this works:**
+- Thinking is visually separated (in artifact)
+- Main conversation stays summary-focused
+- User can reference artifact when needed
+- Conversational context stays lean
+
+### When to Use Thinking Delegation
+
+**Delegate to thinking agents/artifacts for:**
+- Architecture decisions
+- Technology evaluations
+- Complex tradeoff analysis
+- Multi-factor comparisons
+- Design pattern selection
+- Performance optimization strategies
+- Security assessment
+- Refactoring approach planning
+
+**Keep in main context for:**
+- Simple implementation
+- Quick queries
+- Tactical decisions with obvious answers
+- Tasks requiring full project context
+
+### Example: Complex Decision with Thinking Delegation
+
+**Scenario:** Choose state management for React app
+
+**Traditional approach (main context):**
+```
+User: "What state management should I use?"
+Claude: [5K tokens of thinking in main context]
+Claude: [Another 2K tokens explaining recommendation]
+Total: ~7K tokens consumed
+```
+
+**Thinking delegation approach:**
+```
+User: "What state management should I use for a large e-commerce app?"
+
+Claude Code:
+"This warrants deep analysis. Let me delegate to a deep analyzer."
+/agent architecture-advisor "Think deeply about state management 
+options (Redux, Zustand, Jotai, Context) for large-scale e-commerce 
+with real-time inventory"
+
+[Subagent uses ultrathink in isolated context - 5K tokens]
+[Returns summary - 200 tokens]
+
+Main context: "The advisor recommends Zustand for these reasons..."
+Total in main: ~300 tokens
+```
+
+**Context efficiency:** 23x improvement while maintaining analytical depth
+
+### Compound Effect Over Long Sessions
+
+**Session without thinking delegation:**
+- Analysis 1: 7K tokens
+- Analysis 2: 7K tokens  
+- Analysis 3: 7K tokens
+- Analysis 4: 7K tokens
+- Analysis 5: 7K tokens
+- **Total: 35K tokens** (17% of 200K context)
+
+**Session with thinking delegation:**
+- Analysis 1: 300 tokens
+- Analysis 2: 300 tokens
+- Analysis 3: 300 tokens
+- Analysis 4: 300 tokens
+- Analysis 5: 300 tokens
+- **Total: 1.5K tokens** (0.75% of 200K context)
+
+**Result:** Can sustain 23x more analyses in same context window while maintaining analytical rigor.
+
+## Universal Strategies
+
+### Strategy 1: Research → Think → Implement
+
+**Works in all environments:**
+
+```
+Step 1: Research phase
+"Search for [topic] and gather key information"
+
+Step 2: Analysis phase  
+"think hard about the best approach based on those findings"
+
+Step 3: Implementation phase
+"Now implement [specific task] using the approach we decided"
+```
+
+**Why it works:** Each phase has clear purpose, prevents context sprawl.
+
+### Strategy 2: Artifact-Driven Development
+
+**For coding tasks:**
+
+```
+1. "Create a [file type] artifact with [functionality]"
+2. Test/review the artifact
+3. "Update the artifact to add [feature]"
+4. Iterate within the artifact
+```
+
+**Why it works:** Code lives in artifact, conversation stays focused on decisions.
+
+### Strategy 3: Document Plans Before Executing
+
+**For complex projects:**
+
+```
+1. "think about the plan for this project"
+2. "Create a markdown artifact with the plan"
+3. Reference the plan artifact as you work
+4. Update the plan artifact as decisions change
+```
+
+**Why it works:** Plan persists in artifact, you can reference it without re-explaining.
+
+### Strategy 4: Chunked Research
+
+**For large research tasks:**
+
+```
+1. "Research aspect A of [topic]"
+2. "Create a summary artifact"
+3. [New conversation or context reset]
+4. "Research aspect B of [topic]" 
+5. "Create a summary artifact"
+6. "Synthesize findings from both research phases"
+```
+
+**Why it works:** Each research phase stays focused, final synthesis combines cleanly.
+
+## Environment-Specific Techniques
+
+### Web Interface & API
+
+**Strategies:**
+- Use extended thinking liberally for complex reasoning
+- Create artifacts for code, documents, and substantial content
+- Break long tasks into explicit phases
+- Signal context resets when changing direction
+
+**Example workflow:**
+```
+"I need to build a REST API. Let me break this into phases:
+
+Phase 1: ultrathink about the API design and architecture
+[Review thinking output]
+
+Phase 2: Create an artifact with the OpenAPI specification
+[Review spec]
+
+Phase 3: Implement the authentication endpoints
+[Continue implementation]
+```
+
+### Claude Code (CLI)
+
+**Additional commands:**
+- `/clear` - Reset context between tasks
+- `/compact` - Compress context while keeping key decisions
+- `/continue` - Resume previous session
+- Subagents - Delegate research/testing to isolated contexts
+
+**Generate project-specific CLAUDE.md:**
+```bash
+python scripts/generate_claude_md.py --type [TYPE] --output ./CLAUDE.md
+```
+
+**Create subagents for recurring tasks:**
+```bash
+python scripts/create_subagent.py [NAME] --type [TYPE]
+```
+
+See **Claude Code Tooling** section below for details.
+
+## Common Workflows (All Environments)
+
+### Workflow 0: Multi-File Website/Project Creation ⭐ MOST COMMON
+
+**🚨 If user said: "create a website/app with multiple pages" → YOU ARE IN THIS WORKFLOW RIGHT NOW**
+
+**MANDATORY WORKFLOW - FOLLOW THIS EXACT SEQUENCE:**
+
+```
+✓ STEP 1: STOP AND THINK (DO THIS FIRST, ALWAYS)
+   Output: "Think hard about the architecture for this [project]..."
+   [Extended thinking plans: files needed, creation order, dependencies]
+
+✓ STEP 2: ANNOUNCE THE PLAN
+   Output: "I'll create these files in this order:
+            1. styles.css (shared styling)
+            2. index.html (home page)
+            3. about.html
+            4. projects.html
+            5. contact.html"
+
+✓ STEP 3: CREATE FOUNDATION FILES FIRST
+   Create: styles.css
+   
+✓ STEP 4: CREATE DEPENDENT FILES
+   Create: index.html (references styles.css)
+   Create: about.html (references styles.css)
+   Create: projects.html (references styles.css)
+   Create: contact.html (references styles.css)
+
+✓ STEP 5: VERIFY
+   Check: All HTML files reference styles.css correctly
+```
+
+**Example: Portfolio Website Request**
+
+```
+User: "Create a portfolio website with home, about, projects, and contact pages"
+
+🛑 BEFORE YOU CREATE ANY FILES, YOU MUST OUTPUT:
+
+"Let me think hard about the architecture first..."
+
+[Extended thinking output should plan:
+ - Files needed: index.html, about.html, projects.html, contact.html, styles.css
+ - Optimal order: styles.css FIRST (it's a shared dependency), then HTML pages
+ - Dependencies: All HTML files will reference styles.css
+ - Structure: Simple multi-page site with shared stylesheet]
+
+THEN announce the plan:
+
+"I'll create the files in this order:
+
+1. styles.css - Shared styling for all pages
+2. index.html - Home page (will reference styles.css)
+3. about.html - About page (will reference styles.css)
+4. projects.html - Projects page (will reference styles.css)
+5. contact.html - Contact page (will reference styles.css)
+
+This order ensures all dependencies are in place before files that need them."
+
+THEN create files in that exact order.
+```
+
+**❌ WRONG - What NOT to do:**
+```
+User: "Create a portfolio website with home, about, projects, and contact pages"
+
+[Immediately creates index.html without thinking]
+[Creates about.html]
+[Creates projects.html]
+[Realizes CSS should be shared, has to go back and add it]
+
+This wastes effort and context!
+```
+
+**✅ RIGHT - What to do:**
+```
+User: "Create a portfolio website with home, about, projects, and contact pages"
+
+"Think hard about architecture..." [Plans first]
+"I'll create in this order: CSS first, then HTML pages" [Announces plan]
+[Creates styles.css]
+[Creates HTML pages that reference styles.css]
+
+Efficient! No redundant work!
+```
+
+---
+
+### Workflow 1: Complex Decision Making
+
+**With Thinking Delegation:**
+
+**Claude Code:**
+```
+User: "Should we use microservices or monolith?"
+
+1. /agent deep-analyzer "Ultrathink about architecture choice 
+   for 10M user e-commerce platform, 8 dev team"
+2. [Receives well-reasoned recommendation in main context]
+3. Make decision based on analysis
+4. Proceed with implementation
+```
+
+**Web/API:**
+```
+User: "Should we use microservices or monolith?"
+
+1. "Create a deep-analysis.md artifact and ultrathink about this"
+2. [Artifact contains extended thinking + conclusion]
+3. Main conversation: "Based on analysis, recommend monolith because..."
+4. Proceed with implementation
+```
+
+**Context efficiency:** Deep thinking happens, main context stays clean.
+
+---
+
+### Workflow 2: Complex Feature Development
+
+```
+Phase 1: Architecture Analysis
+Claude Code: /agent deep-analyzer "Think deeply about architecture for [feature]"
+Web/API: "Create architecture-analysis artifact with deep thinking"
+[Isolated thinking → summary to main]
+
+Phase 2: Design Planning
+"Based on that analysis, create implementation plan artifact"
+[Main context references analysis conclusions]
+
+Phase 3: Implementation
+"Implement component A based on the plan"
+[Create code artifact]
+
+Phase 4: Testing
+Claude Code: /agent test-runner "Run tests and analyze failures"
+Web/API: "Run tests" [test output in separate space]
+
+Phase 5: Integration
+"Integrate based on architecture plan"
+```
+
+**Why it works:** Each phase has clear purpose, thinking isolated where needed.
+
+---
+
+### Workflow 3: Research & Technology Evaluation
+
+```
+Phase 1: Deep Research
+Claude Code: /agent pattern-researcher "Research and think hard about 
+  authentication approaches, analyze tradeoffs"
+Web/API: "Create research-findings artifact and think through options"
+
+Phase 2: Synthesis
+[Receives summary of findings]
+"Create comparison table artifact"
+
+Phase 3: Recommendation
+Claude Code: /agent deep-analyzer "Based on research, recommend approach"
+Web/API: "Based on research artifact, ultrathink and recommend"
+
+Phase 4: Implementation
+"Implement recommended approach"
+```
+
+**Why it works:** Research and deep analysis isolated, implementation focused.
+
+---
+
+### Workflow 4: Code Generation & Iteration
+
+```
+1. "Create a [language] script that [functionality]"
+   → Artifact created
+
+2. "Add [feature] to the script"
+   → Artifact updated
+
+3. "Optimize the [specific part]"
+   → Targeted update
+
+4. "Add error handling"
+   → Incremental improvement
+```
+
+**Why it works:** All code lives in the artifact, conversation stays focused on what to change.
+
+---
+
+### Workflow 5: Refactoring with Analysis
+
+**Claude Code:**
+```
+1. /agent analyzer "Think hard about refactoring approach 
+   for legacy auth system"
+2. [Receives analysis in main: strategy, risks, order]
+3. "Create REFACTOR.md plan based on analysis"
+4. /clear
+5. For each module:
+   - Refactor according to plan
+   - /agent test-runner "verify changes"
+   - Commit
+   - /clear before next
+```
+
+**Web/API:**
+```
+1. "Create refactoring-analysis artifact, think deeply about approach"
+2. [Artifact has thinking + strategy]
+3. "Create refactoring-plan artifact based on analysis"
+4. Implement module by module
+5. Reference plan artifact as you work
+```
+
+**Why it works:** Deep analysis happens once (isolated), execution follows clean plan.
+
+
+
+## Best Practices (Universal)
+
+### 1. Delegate Complex Analysis to Isolated Contexts
+
+**The most powerful pattern for context efficiency:**
+
+**Claude Code:**
+```
+✅ /agent deep-analyzer "Ultrathink about [complex decision]"
+❌ "Think about [complex decision]" [happens in main context]
+```
+
+**Web/API:**
+```
+✅ "Create analysis artifact and ultrathink about [decision]"
+❌ "Ultrathink about [decision]" [thinking stays in conversation]
+```
+
+**Benefit:** 5K+ tokens of reasoning happens in isolation, main context receives ~200 token summary. 23x context efficiency while maintaining analytical depth.
+
+### 2. Use Extended Thinking for Planning
+Before diving into implementation:
+```
+"think hard about the approach for [task]"
+```
+
+**Even better with delegation:**
+- Claude Code: Delegate to deep_analyzer subagent
+- Web/API: Use thinking artifact
+
+**Benefit:** Reasoning stays out of main context, you get thoughtful plans.
+
+### 3. Create Artifacts for Substantial Content
+Don't inline long code or documents in conversation:
+```
+✅ "Create a Python script artifact that [functionality]"
+❌ "Show me the Python code for [functionality]"
+```
+
+**Benefit:** Content lives in artifacts, not conversation history.
+
+### 4. Break Complex Tasks Into Explicit Phases
+State phase transitions clearly:
+```
+"Phase 1 complete. Moving to Phase 2: [description]"
+```
+
+**With thinking delegation:**
+```
+Phase 1: /agent deep-analyzer "analyze approaches"
+Phase 2: Implement based on analysis
+```
+
+**Benefit:** Each phase has clear purpose and boundaries.
+
+### 5. Document Decisions in Artifacts
+Create persistent references:
+```
+"Create a decisions.md artifact tracking our key choices"
+```
+
+**Benefit:** Can reference decisions without re-explaining full context.
+
+### 6. Progressive Disclosure
+Don't request everything at once:
+```
+✅ "First, analyze the requirements"
+    "Now, design the data model"
+    "Now, implement the core logic"
+
+❌ "Analyze requirements, design data model, and implement everything"
+```
+
+**Benefit:** Each step builds on the last without overwhelming context.
+
+### 7. Use Thinking for Exploration
+When uncertain about approach:
+```
+"ultrathink about multiple approaches and recommend the best one"
+```
+
+**Even better:** Delegate to deep_analyzer (Claude Code) or thinking artifact (Web/API)
+
+**Benefit:** Deep analysis without context clutter.
+
+### 8. Signal Context Resets
+When changing direction:
+```
+"Setting aside the previous approach, let's try a different angle..."
+```
+
+**Benefit:** Clear boundaries prevent old context from interfering.
+
+## Advanced Patterns (Universal)
+
+### Pattern: Iterative Refinement
+```
+1. "Create initial version of [artifact]"
+2. Review
+3. "Improve [specific aspect]"
+4. Review
+5. "Add [feature]"
+6. Continue iterating
+```
+
+**Benefit:** Focused improvements, not recreating everything each time.
+
+### Pattern: Multi-Artifact Projects
+```
+1. "Create architecture.md artifact"
+2. "Create database-schema.sql artifact"
+3. "Create api-spec.yaml artifact"
+4. "Now implement based on these artifacts"
+```
+
+**Benefit:** Each artifact is a stable reference, no context accumulation.
+
+### Pattern: Thinking → Document → Execute
+```
+1. "ultrathink about [complex problem]"
+2. "Document the decision in a plan artifact"
+3. "Execute phase 1 of the plan"
+4. Reference plan artifact as you continue
+```
+
+**Benefit:** Separation of reasoning, planning, and execution.
+
+### Pattern: Chunked Content Generation
+For long documents:
+```
+1. "Create outline artifact"
+2. "Write introduction (add to artifact)"
+3. "Write section 1 (add to artifact)"
+4. Continue section by section
+```
+
+**Benefit:** Build progressively without loading entire document context each time.
+
+---
+
+# 🔧 PART 2: CLI-SPECIFIC FEATURES (Claude Code Users Only)
+
+**The sections below are ONLY for users of Claude Code CLI. Web and API users can skip this part.**
+
+---
+
+## Claude Code Tooling (Bonus Features)
+
+When using Claude Code CLI, additional optimization tools are available:
+
+### Quick Start: Generate CLAUDE.md
+
+Create a context-optimized CLAUDE.md file for your project:
+
+```bash
+python scripts/generate_claude_md.py --type [TYPE] --output ./CLAUDE.md
+```
+
+**Available types:**
+- `general` - General-purpose projects
+- `backend` - API/service projects  
+- `frontend` - Web applications
+- `fullstack` - Full-stack applications
+- `data` - Data science/ML projects
+- `library` - Library/package development
+
+**What it does:** Generates a CLAUDE.md file that Claude Code reads automatically, providing persistent project guidance across sessions.
+
+### Create Subagents
+
+For recurring tasks, create dedicated subagents:
+
+```bash
+python scripts/create_subagent.py [NAME] --type [TYPE] --output [DIR]
+```
+
+**Available types:**
+- `researcher` - Documentation searches with deep analysis
+- `tester` - Test execution with failure analysis
+- `analyzer` - Code analysis with architectural insights
+- `builder` - Build and deployment tasks
+- `deep_analyzer` - Complex decisions requiring extensive thinking (recommended for architecture, tech choices, design patterns)
+
+**What it does:** Creates `.claude/agents/[NAME].md` configuration that can be invoked with:
+```
+/agent [NAME] [task description]
+```
+
+### Claude Code Commands
+
+- `/clear` - Reset context between tasks
+- `/compact` - Compress context while preserving key decisions
+- `/continue` - Resume previous session
+- `/agent [NAME]` - Delegate task to a subagent with isolated context
+
+### Claude Code Patterns
+
+**Pattern: Deep Analysis Delegation**
+```
+1. /clear (start fresh)
+2. /agent deep-analyzer "Ultrathink about [complex decision]"
+3. [Receives well-reasoned analysis in ~200 tokens]
+4. Make decision and implement
+5. Main context stayed clean throughout
+```
+
+**Pattern: Research with Thinking**
+```
+1. /agent pattern-researcher "Research [topic] and think hard about implications"
+2. [Subagent searches + thinks in isolation]
+3. Review findings in main context
+4. Proceed with informed decision
+```
+
+**Pattern: Test-Driven Development with Analysis**
+```
+1. Write test in main context
+2. /agent test-runner "Run test and think hard if it fails"
+3. [Subagent analyzes root cause in isolation]
+4. Implement fix based on analysis
+5. /agent test-runner "verify"
+6. If passing: commit and /clear
+```
+
+**Pattern: Architecture Evolution**
+```
+1. /agent analyzer "Think deeply about current architecture issues"
+2. [Receives analysis: bottlenecks, technical debt, opportunities]
+3. /agent deep-analyzer "Recommend evolution strategy"
+4. Create EVOLUTION.md plan
+5. /clear
+6. Execute plan phase by phase
+```
+
+**Pattern: Large Refactoring with Thinking**
+```
+1. /agent analyzer "Think hard about refactoring scope and risks"
+2. [Receives risk assessment + strategy]
+3. Create REFACTOR.md plan
+4. /clear
+5. For each file:
+   - Load and refactor
+   - /agent test-runner "analyze test results"
+   - /clear before next
+```
+
+For detailed Claude Code patterns, see [references/subagent_patterns.md](references/subagent_patterns.md) and [references/context_strategies.md](references/context_strategies.md).
+
+## Troubleshooting (All Environments)
+
+### "Responses are getting less focused"
+**Symptoms:** Claude references old, irrelevant information or responses drift off topic.
+
+**Solutions:**
+- **Web/API:** Explicitly state "Setting aside previous discussion, let's focus on..."
+- **Claude Code:** Use `/clear` or `/compact`
+- **Universal:** Break task into new phases with clear boundaries
+
+### "Complex task feels overwhelming"
+**Symptoms:** Unsure where to start, too many moving parts.
+
+**Solutions:**
+1. "think harder about breaking this into phases"
+2. Create a planning artifact
+3. Execute one phase at a time
+4. Reference plan artifact as you go
+
+### "Conversation getting too long"
+**Symptoms:** Long history, hard to track what's been decided.
+
+**Solutions:**
+- **Web/API:** Create a "decisions.md" artifact to summarize key points
+- **Claude Code:** Use `/compact` to compress history
+- **Universal:** Start a new conversation with "Previously we decided X, Y, Z. Now let's..."
+
+### "Need to maintain context across sessions"
+**Symptoms:** Have to re-explain everything each time.
+
+**Solutions:**
+- Create artifacts documenting key decisions and context
+- **Claude Code:** Use CLAUDE.md for persistent project memory
+- Start new sessions with: "Continuing from previous work where we [brief summary]"
+
+### "Code keeps being regenerated instead of edited"
+**Symptoms:** Small changes result in entire code rewrites.
+
+**Solutions:**
+1. Use artifacts for code
+2. Request specific edits: "Update the handle_request function to add validation"
+3. Don't say "show me the code again" - reference the existing artifact
+
+### "Responses include too much explanation"
+**Symptoms:** Getting lengthy explanations when you just want output.
+
+**Solutions:**
+- Be explicit: "Just create the artifact, minimal explanation"
+- "Output only, no commentary"
+- "Concise response please"
+
+### "Extended thinking not being used"
+**Symptoms:** Jumping straight to solutions without analysis.
+
+**Solutions:**
+- Explicitly request: "think hard about..."
+- Use stronger triggers: "ultrathink about..."
+- Ask for planning: "think about multiple approaches"
+
+## Reference Documentation
+
+For deeper understanding, consult the reference files:
+
+- **[references/context_strategies.md](references/context_strategies.md)** - Comprehensive workflows and scenario-based strategies (includes Claude Code specific strategies)
+- **[references/subagent_patterns.md](references/subagent_patterns.md)** - Detailed subagent usage patterns for Claude Code users
+
+Load these when you need:
+- Scenario-based workflow guidance
+- Advanced context management techniques
+- Claude Code-specific patterns
+- Troubleshooting complex context issues
+
+## Scripts Reference (Claude Code Users)
+
+### generate_claude_md.py
+
+Generate project-specific CLAUDE.md files:
+
+```bash
+python scripts/generate_claude_md.py --type TYPE --output PATH
+```
+
+**Options:**
+- `--type`: Project type (general, backend, frontend, fullstack, data, library)
+- `--output`: Output path (default: ./CLAUDE.md)
+
+### create_subagent.py
+
+Create subagent configurations:
+
+```bash
+python scripts/create_subagent.py NAME --type TYPE --output DIR
+```
+
+**Options:**
+- `NAME`: Agent name (e.g., test-runner, doc-searcher)
+- `--type`: Agent type (researcher, tester, analyzer, builder)
+- `--output`: Output directory (default: current directory)
+
+## Getting the Most from This Skill
+
+### For All Claude Users:
+
+1. **Delegate complex analysis** - Use thinking delegation architecture
+   - Web/API: Create analysis artifacts for deep thinking
+   - Claude Code: Use deep_analyzer subagent for decisions
+2. **Use extended thinking liberally** - "think hard" for planning, but delegate when possible
+3. **Create artifacts for substantial content** - Keep conversation focused
+4. **Break tasks into explicit phases** - Clear boundaries prevent context sprawl
+5. **Document decisions in artifacts** - Persistent references you can return to
+
+### For Claude Code Users (Additional):
+
+6. **Create thinking-enabled subagents immediately:**
+   ```bash
+   python scripts/create_subagent.py architecture-advisor --type deep_analyzer
+   python scripts/create_subagent.py pattern-researcher --type researcher
+   python scripts/create_subagent.py code-analyzer --type analyzer
+   python scripts/create_subagent.py test-analyzer --type tester
+   ```
+7. **Generate CLAUDE.md for each project** - Persistent project memory
+8. **Practice thinking delegation** - `/agent deep-analyzer` for complex decisions
+9. **Use `/clear` between major tasks** - Start each task fresh
+10. **Monitor context usage** - Claude reports remaining tokens
+
+### Activation Tips:
+
+This skill activates automatically for complex queries, but you can explicitly invoke it:
+- "Help me manage context for this task"
+- "What's the best approach to keep context efficient?"
+- "Analyze this decision deeply but keep context clean"
+- "Think deeply about this" (will suggest delegation)
+
+### Measuring Success:
+
+**Signs thinking delegation is working:**
+- Complex decisions made with minimal main context usage
+- Multiple analyses in single session without context bloat
+- Clear, well-reasoned recommendations without verbose explanations
+- Can sustain 10+ complex analyses in one session
+
+**Context efficiency metrics:**
+- Traditional: ~7K tokens per complex analysis
+- With delegation: ~300 tokens per complex analysis
+- **Target:** 20+ analyses per 200K context window
+
+The goal is sustainable, high-quality Claude interactions that maintain performance and analytical depth regardless of task complexity or conversation length.
diff --git a/skills/context-master/references/agent-skills-integration-2025.md b/skills/context-master/references/agent-skills-integration-2025.md
new file mode 100644
index 0000000..c4aaab5
--- /dev/null
+++ b/skills/context-master/references/agent-skills-integration-2025.md
@@ -0,0 +1,273 @@
+## 🚨 CRITICAL GUIDELINES
+
+### Windows File Path Requirements
+
+**MANDATORY: Always Use Backslashes on Windows for File Paths**
+
+When using Edit or Write tools on Windows, you MUST use backslashes (`\`) in file paths, NOT forward slashes (`/`).
+
+**Examples:**
+- ❌ WRONG: `D:/repos/project/file.tsx`
+- ✅ CORRECT: `D:\repos\project\file.tsx`
+
+This applies to:
+- Edit tool file_path parameter
+- Write tool file_path parameter
+- All file operations on Windows systems
+
+### Documentation Guidelines
+
+**NEVER create new documentation files unless explicitly requested by the user.**
+
+- **Priority**: Update existing README.md files rather than creating new documentation
+- **Repository cleanliness**: Keep repository root clean - only README.md unless user requests otherwise
+- **Style**: Documentation should be concise, direct, and professional - avoid AI-generated tone
+- **User preference**: Only create additional .md files when user specifically asks for documentation
+
+---
+
+
+# Agent Skills Integration (2025)
+
+## Overview
+Integration patterns between context-master and Agent Skills for autonomous context management in 2025 Claude Code.
+
+## Core Pattern: Context-Aware Agent Skills
+
+### What Are Agent Skills?
+Context-efficient knowledge packages that:
+- Activate automatically based on context
+- Provide specialized guidance
+- Stay lean (avoid context bloat)
+- Delegate heavy lifting to subagents
+
+### Context Master + Agent Skills Synergy
+
+**Context Master provides:**
+- Planning frameworks for multi-file projects
+- Thinking delegation architecture
+- Context optimization strategies
+- Session management patterns
+
+**Agent Skills provide:**
+- Domain-specific knowledge
+- Automated activation triggers
+- Custom tool integration
+- Team-wide consistency
+
+## Pattern 1: Context-First Agent Skill
+
+```markdown
+# My Custom Agent Skill
+
+## Activation Triggers
+- User mentions "create [N]+ files"
+- Request involves "architecture"
+- Task needs "planning"
+
+## Instructions
+
+### Step 1: Context Check
+Before proceeding, ask:
+- Are we working with multi-file project? (YES → use context-master)
+- Is thinking delegation needed? (YES → delegate)
+
+### Step 2: Leverage Context Master
+- Use /plan-project command for architecture
+- Use thinking delegation for deep analysis
+- Reference context-master patterns
+
+### Step 3: Your Domain Work
+- Implement using domain expertise
+- Verify structure using /verify-structure
+- Document decisions in DECISIONS.md
+```
+
+## Pattern 2: Autonomous Context Delegation
+
+Instead of doing analysis in Agent Skill context:
+
+**Bad (fills Agent Skill context):**
+```
+"Let me think deeply about the architecture..."
+[5K tokens of thinking in Agent Skill context]
+```
+
+**Good (preserves Agent Skill context):**
+```
+"This needs deep analysis. Let me delegate:
+/agent deep-analyzer "Ultrathink about [architecture]"
+[Deep analysis happens in isolated agent context]
+[Returns summary to Agent Skill - clean]
+```
+
+## Pattern 3: Project-Specific Context Strategy
+
+**In your Agent Skill:**
+```
+## When This Skill Activates
+
+1. Check if CLAUDE.md exists
+2. If yes: Load context strategy from CLAUDE.md
+3. If no: Use default context-master patterns
+
+## Recommended CLAUDE.md Strategy for This Skill
+
+Include in your project's CLAUDE.md:
+```yaml
+ContextStrategy:
+  - Use subagents for: [domain-specific searches]
+  - Keep in main for: [your domain decisions]
+  - Compact when: [context grows beyond X]
+  - Clear before: [major phase transitions]
+```
+
+## Pattern 4: Team Consistency
+
+### Create Standard Agent Skill Template
+
+```markdown
+# Team Agent Skill Template
+
+## Activation
+Activates for: [domain work]
+
+## Context Management
+
+Before doing any analysis:
+1. Reference /plan-project for multi-file work
+2. Use thinking delegation for complex decisions
+3. Document findings in [DOMAIN]_FINDINGS.md
+4. Leave main context clean for other agents
+
+## Integration Points
+- Works with: context-master, plugin-master
+- Delegates to: deep_analyzer for critical choices
+- Outputs to: Structured documents, not context
+```
+
+## Pattern 5: Cascading Deep Analysis
+
+**For complex domains requiring multiple analyses:**
+
+```
+User Request → Triggers Your Agent Skill
+              ↓
+Agent Skill identifies sub-questions:
+  Q1: Frontend implications?
+  Q2: Backend implications?
+  Q3: Data implications?
+  Q4: Integrated recommendation?
+              ↓
+Delegates each:
+  /agent frontend-deep-analyzer "Ultrathink Q1"
+  /agent backend-deep-analyzer "Ultrathink Q2"
+  /agent data-deep-analyzer "Ultrathink Q3"
+  /agent synthesis-analyzer "Ultrathink Q4"
+              ↓
+Receives 4 summaries (~200 tokens each)
+              ↓
+Agent Skill synthesizes in clean context
+              ↓
+Returns integrated recommendation to main
+```
+
+**Context used in main:** ~1,200 tokens (4 summaries + synthesis)
+**vs Traditional:** 20K+ tokens (all thinking in main)
+**Efficiency:** 16-17x
+
+## Pattern 6: Progressive Context Loading
+
+Avoid loading all project context upfront:
+
+```
+// In your Agent Skill:
+
+Step 1: Minimal context
+- Load just CLAUDE.md
+- Understand strategy
+
+Step 2: Selective context
+- Load only relevant files (use subagent search)
+- Get summaries, not full content
+
+Step 3: Deep dive only if needed
+- Load full context only for specific modules
+- Use Progressive disclosure pattern
+```
+
+## Implementation Checklist
+
+- [ ] Agent Skill documentation mentions context-master
+- [ ] Activation triggers align with planning needs
+- [ ] Uses /plan-project for multi-file work
+- [ ] Delegates deep analysis to subagents
+- [ ] Documents decisions outside of context
+- [ ] CLAUDE.md includes skill-specific strategies
+- [ ] Team training covers thinking delegation
+- [ ] Hooks configured for auto-management
+
+## Advanced: Agent Skill + Plugin Creation Workflow
+
+For creating domain-specific plugins:
+
+```
+1. User wants new plugin for domain X
+2. Agent Skill → plugin-master integration:
+   /agent plugin-architect "Design plugin for X"
+   
+3. plugin-architect:
+   - Thinks about structure
+   - Considers context implications
+   - References context-master patterns
+   
+4. Returns design
+5. User/Agent Skill creates plugin
+6. New plugin includes context-master references
+```
+
+## Real-World Example: Frontend Agent Skill
+
+```markdown
+# Frontend Agent Skill
+
+## When This Activates
+- User: "Create a React component..."
+- User: "Build a multi-page website..."
+- User: "Design component architecture..."
+
+## Instructions
+
+### Multi-File Check
+If creating 3+ files:
+1. "/plan-project - Think about component structure"
+2. Wait for analysis
+3. Implement files in recommended order
+4. "/verify-structure - Check component references"
+
+### Complex Decisions
+If component architecture is complex:
+1. "/agent frontend-analyzer - Think about patterns"
+2. Receive analysis
+3. Design components in main context (clean)
+
+### Documentation
+1. Save component decisions to COMPONENT_DECISIONS.md
+2. Leave main context for next task
+3. Reference document as needed
+```
+
+## Measuring Success
+
+**Good indicators:**
+- Main context stays under 50K tokens for complex work
+- Multiple features/analyses per session without degradation
+- Clear decision logs without context bloat
+- Smooth team collaboration
+
+**Warning signs:**
+- Main context consistently >80K
+- Responses getting less focused
+- Need to restart sessions more often
+- Team members report context issues
+
diff --git a/skills/context-master/references/context_strategies.md b/skills/context-master/references/context_strategies.md
new file mode 100644
index 0000000..e4bf266
--- /dev/null
+++ b/skills/context-master/references/context_strategies.md
@@ -0,0 +1,406 @@
+# Context Management Strategies
+
+Detailed workflows and strategies for managing context efficiently in Claude Code.
+
+## Understanding Context Usage
+
+**Context window size:**
+- Standard: 200K tokens (~150K words)
+- Extended (API): 1M tokens (~750K words)
+
+**What consumes context:**
+- Conversation history (messages back and forth)
+- File contents loaded into context
+- Tool call results (bash output, test results, etc.)
+- CLAUDE.md configuration
+- Extended thinking blocks
+
+**Context awareness:** Claude Sonnet 4.5 tracks remaining context and reports it with each tool call.
+
+## Core Commands
+
+### `/clear` - Reset Context
+**When to use:**
+- Between major features or tasks
+- After completing a self-contained piece of work
+- When switching between different parts of the codebase
+- If you notice Claude getting distracted or referencing old context
+
+**Example workflow:**
+```
+1. Complete feature A
+2. Run tests and commit
+3. /clear
+4. Start feature B with fresh context
+```
+
+### `/compact` - Compress Context
+**When to use:**
+- Before starting complex multi-step work
+- When approaching context limits (~80% full)
+- To preserve key decisions while clearing clutter
+
+**What it does:** Summarizes conversation history while retaining key information.
+
+**Example workflow:**
+```
+1. Long research and planning session
+2. /compact "Summarize architecture decisions and open TODOs"
+3. Continue with implementation
+```
+
+### `/continue` - Resume Session
+**When to use:**
+- Returning to previous work
+- After a break
+- To pick up where you left off
+
+**Combines well with:**
+```
+claude --continue  # Resume last session in current project
+```
+
+## Strategy 1: Task Isolation
+
+**Goal:** Keep each task in its own context bubble.
+
+**Workflow:**
+```
+1. Start task → /clear (if needed)
+2. Use subagents for research/analysis
+3. Main context focuses on implementation
+4. Complete and test
+5. /clear before next task
+```
+
+**When to use:**
+- Multiple independent features
+- Bug fixes that don't require historical context
+- Refactoring isolated modules
+
+**Benefits:**
+- Each task starts with clean slate
+- No cross-contamination between tasks
+- More predictable context usage
+
+---
+
+## Strategy 2: Progressive Context Management
+
+**Goal:** Build up context deliberately, clearing non-essential information.
+
+**Workflow:**
+```
+1. Research phase
+   - Subagents search and analyze
+   - Main context reviews summaries
+   
+2. Planning phase
+   - "think hard" to create plan
+   - Save plan to document/issue
+   
+3. /compact "Keep architecture decisions and plan"
+   
+4. Implementation phase
+   - Reference plan document
+   - Focus on current file/module
+   
+5. Testing phase
+   - Subagent runs tests
+   - Main context addresses failures
+   
+6. /clear before next feature
+```
+
+**When to use:**
+- Large features requiring multiple steps
+- Complex refactoring
+- Projects with extensive research phase
+
+**Benefits:**
+- Intentional context building
+- Clear phase transitions
+- Preserved key decisions
+
+---
+
+## 🚨 CRITICAL GUIDELINES
+
+### Windows File Path Requirements
+
+**MANDATORY: Always Use Backslashes on Windows for File Paths**
+
+When using Edit or Write tools on Windows, you MUST use backslashes (`\`) in file paths, NOT forward slashes (`/`).
+
+**Examples:**
+- ❌ WRONG: `D:/repos/project/file.tsx`
+- ✅ CORRECT: `D:\repos\project\file.tsx`
+
+This applies to:
+- Edit tool file_path parameter
+- Write tool file_path parameter
+- All file operations on Windows systems
+
+
+### Documentation Guidelines
+
+**NEVER create new documentation files unless explicitly requested by the user.**
+
+- **Priority**: Update existing README.md files rather than creating new documentation
+- **Repository cleanliness**: Keep repository root clean - only README.md unless user requests otherwise
+- **Style**: Documentation should be concise, direct, and professional - avoid AI-generated tone
+- **User preference**: Only create additional .md files when user specifically asks for documentation
+
+
+---
+
+## Strategy 3: Parallel Workstreams
+
+**Goal:** Work on multiple aspects simultaneously using subagents.
+
+**Workflow:**
+```
+1. Main context: High-level orchestration
+2. Subagent A: Frontend work
+3. Subagent B: Backend work  
+4. Subagent C: Test execution
+5. Main context: Integration and coordination
+```
+
+**When to use:**
+- Full-stack features
+- Multi-component changes
+- When different aspects are independent
+
+**Benefits:**
+- Efficient use of subagent isolation
+- Parallel progress
+- Main context stays focused on coordination
+
+---
+
+## Strategy 4: Test-Driven Context Management
+
+**Goal:** Keep context focused on current test/implementation cycle.
+
+**Workflow:**
+```
+1. Write test in main context
+2. /agent test-runner "run new test"
+3. Implement feature to pass test
+4. /agent test-runner "run test suite"
+5. If fail → fix in main context
+6. If pass → commit and /clear
+```
+
+**When to use:**
+- TDD workflows
+- Bug fixes with test coverage
+- API endpoint development
+
+**Benefits:**
+- Tight feedback loop
+- Context stays focused on current test
+- Test output doesn't clutter main context
+
+---
+
+## Strategy 5: Documentation-First Development
+
+**Goal:** Use CLAUDE.md as persistent memory across sessions.
+
+**Setup:**
+```markdown
+# CLAUDE.md
+
+## Current Focus
+Sprint goal: User authentication system
+
+## Recent Decisions
+- Using JWT with refresh tokens
+- PostgreSQL for user storage
+- Redis for session management
+
+## Next Tasks
+- [ ] Implement token refresh endpoint
+- [ ] Add rate limiting
+- [ ] Write integration tests
+
+## Architecture Notes
+[Key decisions that inform all work]
+```
+
+**Workflow:**
+```
+1. CLAUDE.md provides persistent context
+2. Each session references current focus
+3. Update CLAUDE.md with new decisions
+4. /clear frequently - CLAUDE.md persists
+```
+
+**When to use:**
+- Multi-day projects
+- Team collaboration (CLAUDE.md in git)
+- Complex projects needing persistent memory
+
+**Benefits:**
+- Survives /clear commands
+- Shared team knowledge
+- Consistent across sessions
+
+---
+
+## Scenario-Based Strategies
+
+### Scenario: Large Refactoring
+
+**Challenge:** Need broad codebase understanding but context fills quickly.
+
+**Strategy:**
+```
+1. Subagent: "Map all files using old pattern"
+2. Review map, create refactoring plan
+3. Save plan to REFACTOR.md
+4. /clear
+5. For each file:
+   a. Load file
+   b. Refactor based on plan
+   c. Test
+   d. /clear before next file
+```
+
+---
+
+### Scenario: Bug Investigation
+
+**Challenge:** Unknown cause, need to search widely but track findings.
+
+**Strategy:**
+```
+1. Create BUG_NOTES.md to track findings
+2. Subagent: "Search logs for error X"
+3. Document findings in BUG_NOTES.md
+4. Subagent: "Analyze code paths that could cause X"
+5. Document in BUG_NOTES.md
+6. /compact "Keep bug theory and evidence"
+7. Implement fix
+8. /agent test-runner "verify fix"
+```
+
+---
+
+### Scenario: New Feature with Unknown Patterns
+
+**Challenge:** Need to research existing patterns without cluttering context.
+
+**Strategy:**
+```
+1. Subagent: "Find similar features in codebase"
+2. Subagent: "Extract common patterns from those features"
+3. Main context reviews patterns
+4. "think about best approach for new feature"
+5. Create implementation plan
+6. /clear
+7. Implement based on plan
+8. Reference plan doc if needed
+```
+
+---
+
+### Scenario: Multi-File Feature
+
+**Challenge:** Changes span many files, hard to keep all in context.
+
+**Strategy:**
+```
+1. Create FEATURE.md with:
+   - Overall design
+   - File change checklist
+   - Cross-file dependencies
+   
+2. For each file:
+   a. Load just that file
+   b. Reference FEATURE.md for context
+   c. Make changes
+   d. Test
+   e. /compact if context getting full
+   
+3. Final integration test
+4. /clear and move to next feature
+```
+
+---
+
+## Advanced Techniques
+
+### Technique: Context Checkpoints
+
+**Save key state to files before clearing:**
+
+```
+1. Long planning session
+2. "Create PLAN.md with our architecture decisions"
+3. /clear
+4. Reference PLAN.md during implementation
+```
+
+### Technique: Layered Context Loading
+
+**Load information progressively as needed:**
+
+```
+1. Start with just current file
+2. If need more context: "show me the caller"
+3. If need more: "show me the config"
+4. Don't load everything upfront
+```
+
+### Technique: Subagent Summarization
+
+**Use subagents to create digestible summaries:**
+
+```
+Subagent: "Analyze all 50 test files and create a summary:
+- Total coverage percentage
+- Files with <50% coverage
+- Most complex tests"
+
+Then work from the summary, not the raw test files.
+```
+
+### Technique: Incremental /compact
+
+**Compress context multiple times in long sessions:**
+
+```
+1. Research phase → /compact "Keep research findings"
+2. Planning phase → /compact "Keep findings and plan"
+3. Implementation → /compact "Keep plan and decisions"
+```
+
+## Monitoring Context Health
+
+**Signs context is getting cluttered:**
+- Claude references old, irrelevant information
+- Responses become less focused
+- Performance seems to degrade
+- You're >80% through context budget
+
+**Remedies:**
+1. `/compact` for quick compression
+2. `/clear` for fresh start
+3. Move key info to files before clearing
+4. Use subagents more aggressively
+
+## Best Practices Summary
+
+1. **Use /clear liberally** between tasks
+2. **Front-load subagent usage** for research
+3. **Document decisions** in CLAUDE.md or files
+4. **Load files progressively** as needed
+5. **Test in subagents** to keep output isolated
+6. **/compact before** complex multi-step work
+7. **Think first** to plan before implementing
+8. **Reference plans** instead of keeping full context
+9. **Batch similar operations** in single subagent
+10. **Monitor context usage** and respond proactively
diff --git a/skills/context-master/references/subagent_patterns.md b/skills/context-master/references/subagent_patterns.md
new file mode 100644
index 0000000..b858ab2
--- /dev/null
+++ b/skills/context-master/references/subagent_patterns.md
@@ -0,0 +1,664 @@
+# Subagent Patterns
+
+Common patterns and best practices for using subagents in Claude Code, with emphasis on thinking delegation for context efficiency.
+
+## The Thinking Delegation Paradigm
+
+**Core insight:** Subagents have isolated context windows. When subagents use extended thinking, that reasoning happens in THEIR context, not the main session's context.
+
+**This enables:**
+- Deep analysis (5K+ thinking tokens)
+- Main context receives summaries (~200 tokens)
+- 23x context efficiency while maintaining analytical rigor
+- Sustainable long sessions with multiple complex analyses
+
+**The architecture:**
+```
+Main Session: Makes decisions, stays focused
+    ↓ delegates with thinking trigger
+Subagent: Uses extended thinking in isolation (5K tokens)
+    ↑ returns summary
+Main Session: Receives actionable conclusion (200 tokens)
+```
+
+**Context math:**
+- Traditional: 7K tokens per analysis in main context
+- With delegation: 300 tokens per analysis in main context
+- Efficiency gain: 23x
+
+## Thinking-Enabled Subagent Types
+
+### Deep Analyzer (Type: deep_analyzer)
+
+**Purpose:** Complex decisions requiring extensive analysis
+
+**What it does:**
+- ALWAYS uses "ultrathink" for analysis
+- Evaluates multiple approaches
+- Considers tradeoffs and implications
+- Returns well-reasoned recommendations
+
+**When to use:**
+- Architecture decisions
+- Technology evaluations
+- Design pattern selection
+- Performance optimization strategies
+- Security assessments
+- Refactoring approach planning
+
+**Example usage:**
+```
+/agent architecture-advisor "Should we use microservices or modular monolith 
+for a 10M user e-commerce platform with 8 developers?"
+
+[Subagent thinks deeply in isolation - 5K tokens]
+[Returns to main: ~200 token summary with recommendation]
+```
+
+### Pattern Researcher (Type: researcher)
+
+**Purpose:** Research with analytical thinking
+
+**What it does:**
+- Searches documentation/code
+- Uses "think hard" for multi-source analysis
+- Synthesizes insights with reasoning
+- Returns analysis, not just data
+
+**When to use:**
+- API pattern research
+- Best practice discovery
+- Technology comparison
+- Design pattern evaluation
+
+**Example usage:**
+```
+/agent pattern-researcher "Research authentication patterns in our codebase 
+and think hard about which approach fits our scale requirements"
+
+[Subagent searches + analyzes - 3K tokens thinking]
+[Returns: Summary of patterns with reasoned recommendation]
+```
+
+### Code Analyzer (Type: analyzer)
+
+**Purpose:** Architectural insights and deep code analysis
+
+**What it does:**
+- Analyzes code structure
+- Uses "think harder" for architecture
+- Identifies implications and opportunities
+- Returns actionable insights
+
+**When to use:**
+- Architecture assessment
+- Technical debt identification
+- Performance bottleneck analysis
+- Refactoring opportunity discovery
+
+**Example usage:**
+```
+/agent code-analyzer "Think deeply about our authentication system's 
+architecture and identify improvement opportunities"
+
+[Subagent analyzes + thinks - 4K tokens]
+[Returns: Key findings with prioritized recommendations]
+```
+
+### Test Analyzer (Type: tester)
+
+**Purpose:** Test execution with failure analysis
+
+**What it does:**
+- Runs test suites
+- Uses "think hard" when tests fail
+- Analyzes root causes
+- Returns actionable diagnostics
+
+**When to use:**
+- Test suite execution
+- Failure diagnosis
+- Regression analysis
+- Coverage assessment
+
+**Example usage:**
+```
+/agent test-analyzer "Run the auth test suite and if failures occur, 
+think hard about root causes"
+
+[Subagent runs tests, analyzes failures - 2K tokens thinking]
+[Returns: Test status + root cause analysis if needed]
+```
+
+## Core Principles
+
+**Subagents have isolated context windows** - They only send relevant information back to the main orchestrator, not their full context. This makes them ideal for tasks that generate lots of intermediary results.
+
+**When to use subagents:**
+- Searching through large codebases
+- Analyzing multiple files for patterns
+- Research tasks with extensive documentation
+- Running tests or builds
+- Any investigation that doesn't need full project context
+
+**When NOT to use subagents:**
+- Quick single-file edits
+- Simple queries that need immediate response
+- Tasks requiring full project context for decision-making
+
+## Common Patterns
+
+### Pattern 1: Research → Plan → Implement
+
+**Main Context:**
+```
+1. "Use a subagent to search our codebase for similar authentication implementations"
+2. [Review subagent findings]
+3. "think about the best approach based on those examples"
+4. [Implement in main context]
+```
+
+**Why it works:** Research generates lots of search results that would clutter main context. Main agent only sees the summary.
+
+---
+
+### Pattern 2: Parallel Investigation
+
+**Main Context:**
+```
+"Spin up three subagents:
+1. One to analyze our error handling patterns
+2. One to check test coverage
+3. One to review documentation
+
+Report back with key findings from each."
+```
+
+**Why it works:** Each subagent has its own context window. They can work in parallel without interfering with each other.
+
+---
+
+## 🚨 CRITICAL GUIDELINES
+
+### Windows File Path Requirements
+
+**MANDATORY: Always Use Backslashes on Windows for File Paths**
+
+When using Edit or Write tools on Windows, you MUST use backslashes (`\`) in file paths, NOT forward slashes (`/`).
+
+**Examples:**
+- ❌ WRONG: `D:/repos/project/file.tsx`
+- ✅ CORRECT: `D:\repos\project\file.tsx`
+
+This applies to:
+- Edit tool file_path parameter
+- Write tool file_path parameter
+- All file operations on Windows systems
+
+
+### Documentation Guidelines
+
+**NEVER create new documentation files unless explicitly requested by the user.**
+
+- **Priority**: Update existing README.md files rather than creating new documentation
+- **Repository cleanliness**: Keep repository root clean - only README.md unless user requests otherwise
+- **Style**: Documentation should be concise, direct, and professional - avoid AI-generated tone
+- **User preference**: Only create additional .md files when user specifically asks for documentation
+
+
+---
+
+### Pattern 3: Test-Driven Workflow
+
+**Main Context:**
+```
+1. Write tests in main context
+2. "Use a subagent to run the test suite and report results"
+3. [Implement fixes based on failures]
+4. "Subagent: run tests again"
+5. [Repeat until passing]
+```
+
+**Why it works:** Test output can be verbose. Subagent filters it down to pass/fail status and specific failures.
+
+---
+
+### Pattern 4: Build Verification
+
+**Main Context:**
+```
+1. Make code changes
+2. "Subagent: run the build and verify it succeeds"
+3. [If build fails, review error]
+4. [Fix and repeat]
+```
+
+**Why it works:** Build logs are long. Subagent only reports success/failure and relevant errors.
+
+---
+
+### Pattern 5: Multi-File Analysis
+
+**Main Context:**
+```
+"Use a subagent to:
+1. Find all files using the old API
+2. Analyze migration complexity
+3. Return list of files and complexity assessment"
+
+[Review findings]
+"Create a migration plan based on that analysis"
+```
+
+**Why it works:** File searching and analysis stays in subagent. Main context gets clean summary for planning.
+
+## Usage Syntax
+
+### Starting a Subagent
+
+```
+/agent <agent-name> <task-description>
+```
+
+or in natural language:
+
+```
+"Use a subagent to [task]"
+"Spin up a subagent for [task]"
+"Delegate [task] to a subagent"
+```
+
+### Pre-configured vs Ad-hoc
+
+**Pre-configured agents** (stored in `.claude/agents/`):
+```
+/agent test-runner run the full test suite
+```
+
+**Ad-hoc agents** (created on the fly):
+```
+"Use a subagent to search the codebase for error handling patterns"
+```
+
+## Example Subagent Configurations
+
+### Research Subagent
+
+**File:** `.claude/agents/researcher.md`
+
+```markdown
+# Researcher
+
+Documentation and code search specialist
+
+## Instructions
+
+Search through documentation and code efficiently. Return only the most 
+relevant information with specific file paths and line numbers. 
+Summarize findings concisely.
+
+## Allowed Tools
+- read
+- search
+- web_search
+
+## Autonomy Level
+Medium - Take standard search actions autonomously
+```
+
+### Test Runner Subagent
+
+**File:** `.claude/agents/test-runner.md`
+
+```markdown
+# Test Runner
+
+Automated test execution and reporting
+
+## Instructions
+
+Execute test suites and report results clearly. Focus on:
+- Pass/fail status
+- Specific failing tests
+- Error messages and stack traces
+- Coverage metrics if available
+
+## Allowed Tools
+- bash
+- read
+
+## Autonomy Level
+High - Execute tests fully autonomously
+```
+
+### Code Analyzer Subagent
+
+**File:** `.claude/agents/analyzer.md`
+
+```markdown
+# Analyzer
+
+Code analysis and pattern detection
+
+## Instructions
+
+Analyze code structure and identify:
+- Duplicate patterns
+- Complexity hotspots
+- Dependency relationships
+- Potential issues
+
+Provide actionable insights with specific locations.
+
+## Allowed Tools
+- read
+- search
+- bash
+
+## Autonomy Level
+Medium - Analyze autonomously, ask before making suggestions
+```
+
+## Anti-Patterns
+
+### ❌ Using Subagents for Everything
+
+**Bad:**
+```
+"Use a subagent to edit this single file"
+```
+
+**Why:** Overhead of subagent isn't worth it for simple tasks.
+
+**Good:**
+```
+"Edit this file to add the new function"
+```
+
+---
+
+### ❌ Not Providing Clear Task Scope
+
+**Bad:**
+```
+"Use a subagent to look at the code"
+```
+
+**Why:** Too vague. Subagent doesn't know what to focus on.
+
+**Good:**
+```
+"Use a subagent to search for all database query patterns and assess 
+which ones are vulnerable to SQL injection"
+```
+
+---
+
+### ❌ Expecting Full Context Transfer
+
+**Bad:**
+```
+Main: [Long discussion about architecture]
+Then: "Subagent: implement that plan we just discussed"
+```
+
+**Why:** Subagent doesn't have access to your conversation history.
+
+**Good:**
+```
+"Subagent: implement the authentication module with:
+- JWT tokens
+- Refresh token rotation
+- Rate limiting
+Based on our existing user service patterns."
+```
+
+## Performance Tips
+
+1. **Front-load research** - Use subagents early for research, then implement in main context
+2. **Batch similar tasks** - One subagent for all file searches, not separate subagents per file
+3. **Clear instructions** - Be specific about what the subagent should return
+4. **Iterate in main context** - Use main context for back-and-forth refinement
+5. **Trust the summary** - Don't ask subagent to return full documents
+
+## Advanced: Chaining Subagents
+
+**Scenario:** Complex analysis requiring multiple specialized agents
+
+```
+1. "Subagent: search for all API endpoints and list them"
+2. [Review list]
+3. "Subagent: for each endpoint in that list, check test coverage"
+4. [Review coverage report]
+5. "Subagent: analyze the untested endpoints and estimate testing effort"
+```
+
+**Why chaining works:** Each subagent builds on the previous results without cluttering the main context with intermediary data.
+
+---
+
+## Thinking Delegation Patterns
+
+### Pattern 1: Deep Decision Analysis
+
+**Problem:** Need to make complex architectural decision
+
+**Traditional approach (main context):**
+```
+"Think deeply about microservices vs monolith"
+[5K tokens of thinking in main context]
+```
+
+**Thinking delegation approach:**
+```
+/agent deep-analyzer "Ultrathink about microservices vs monolith 
+for 10M user platform, 8 dev team, considering deployment, maintenance, 
+scaling, and team velocity"
+
+[Subagent's isolated context: 6K tokens of thinking]
+[Main receives: 250 token summary + recommendation]
+```
+
+**Context saved:** 5,750 tokens (~97%)
+
+---
+
+### Pattern 2: Research → Think → Recommend
+
+**Problem:** Need to research options and provide reasoned recommendation
+
+**Workflow:**
+```
+Step 1: Research phase
+/agent pattern-researcher "Research state management libraries 
+and think hard about tradeoffs"
+
+[Subagent searches + analyzes in isolation]
+[Returns: Options with pros/cons]
+
+Step 2: Decision phase
+/agent deep-analyzer "Based on these options, ultrathink and 
+recommend best fit for our use case"
+
+[Subagent thinks deeply in isolation]
+[Returns: Recommendation with rationale]
+
+Step 3: Implementation
+[Main context implements based on recommendation]
+```
+
+**Why it works:** Research and analysis isolated, implementation focused
+
+---
+
+### Pattern 3: Iterative Analysis Refinement
+
+**Problem:** Need to analyze multiple aspects without context accumulation
+
+**Workflow:**
+```
+Round 1: /agent analyzer "Think about performance implications"
+[Returns summary to main]
+
+Round 2: /agent analyzer "Think about security implications"  
+[Returns summary to main]
+
+Round 3: /agent deep-analyzer "Synthesize performance and security 
+analyses, recommend approach"
+[Returns final recommendation to main]
+
+Main context: Make decision with 3 concise summaries (~600 tokens total)
+```
+
+**vs Traditional:**
+```
+"Think about performance" [3K tokens in main]
+"Think about security" [3K tokens in main]
+"Synthesize" [needs both analyses in context]
+Total: 6K+ tokens
+```
+
+**Context efficiency:** 10x improvement
+
+---
+
+### Pattern 4: Parallel Deep Analysis
+
+**Problem:** Multiple independent analyses needed
+
+**Workflow:**
+```
+/agent analyzer-1 "Think deeply about database options"
+/agent analyzer-2 "Think deeply about caching strategies"
+/agent analyzer-3 "Think deeply about API design patterns"
+
+[Each analyzes in parallel, isolated contexts]
+[Each returns summary]
+
+/agent deep-analyzer "Synthesize these analyses into coherent architecture"
+[Returns integrated recommendation]
+```
+
+**Why it works:** Multiple deep analyses happen without accumulating in main context
+
+---
+
+### Pattern 5: Test-Driven Development with Thinking
+
+**Problem:** TDD cycle fills context with test output and debugging analysis
+
+**Traditional TDD:**
+```
+Write test → Run test (verbose output) → Debug (thinking in main) → Fix → Repeat
+[Context fills with test output + debugging thinking]
+```
+
+**Thinking delegation TDD:**
+```
+1. Write test in main context (focused)
+2. /agent test-analyzer "Run test, if failure think hard about root cause"
+3. [Subagent runs + analyzes in isolation]
+4. [Returns: Status + root cause analysis if needed]
+5. Fix based on analysis in main context
+6. /agent test-analyzer "Verify fix"
+7. Repeat until passing
+```
+
+**Why it works:** Test output and failure analysis isolated, main context stays implementation-focused
+
+---
+
+### Pattern 6: Refactoring with Deep Assessment
+
+**Problem:** Large refactoring needs strategy without filling main context
+
+**Workflow:**
+```
+Step 1: Assessment
+/agent analyzer "Think deeply about refactoring scope, risks, 
+and approach for legacy auth system"
+
+[Subagent analyzes codebase + thinks in isolation - 4K tokens]
+[Returns: Risk assessment + strategy - 300 tokens]
+
+Step 2: Planning
+Create REFACTOR.md in main context based on strategy
+
+Step 3: Execution
+/clear
+For each module:
+  - Refactor based on plan
+  - /agent test-analyzer "verify changes"
+  - Commit
+  - /clear
+```
+
+**Why it works:** Deep analysis happens once (isolated), execution follows clean plan
+
+---
+
+### Pattern 7: Compound Decision Making
+
+**Problem:** Multi-layer decision with dependencies
+
+**Workflow:**
+```
+Layer 1: Foundation decision
+/agent deep-analyzer "Ultrathink: Relational vs NoSQL for our use case"
+[Returns: Relational recommended]
+
+Layer 2: Specific technology
+/agent deep-analyzer "Given relational choice, ultrathink: 
+PostgreSQL vs MySQL vs MariaDB"
+[Returns: PostgreSQL recommended with reasoning]
+
+Layer 3: Architecture details
+/agent deep-analyzer "Given PostgreSQL, ultrathink: Replication 
+strategy for our scale"
+[Returns: Streaming replication recommended]
+
+Main context: Has 3 clear decisions (~600 tokens total)
+```
+
+**vs Traditional:** All thinking would accumulate in main context (12K+ tokens)
+
+---
+
+## Advanced Thinking Patterns
+
+### Meta-Pattern: Thinking Chain
+
+For extremely complex decisions requiring multiple analytical lenses:
+
+```
+1. /agent deep-analyzer "Analyze from business perspective"
+2. /agent deep-analyzer "Analyze from technical perspective"
+3. /agent deep-analyzer "Analyze from security perspective"
+4. /agent deep-analyzer "Analyze from cost perspective"
+5. /agent deep-analyzer "Synthesize all perspectives and recommend"
+
+Main context receives: 5 concise analyses → integrated recommendation
+Total in main: ~1K tokens
+vs Traditional: 25K+ tokens of accumulated thinking
+```
+
+### Meta-Pattern: Thinking Cascade
+
+When decision depends on answering prior questions:
+
+```
+Q1: /agent deep-analyzer "Should we build or buy?"
+    [Returns: Build recommended because...]
+
+Q2: /agent deep-analyzer "Given building, which framework?"
+    [Returns: React recommended because...]
+
+Q3: /agent deep-analyzer "Given React, which state management?"
+    [Returns: Zustand recommended because...]
+
+Each analysis builds on previous conclusion, not previous reasoning
+```
+
+---
+
+
diff --git a/skills/context-master/scripts/create_subagent.py b/skills/context-master/scripts/create_subagent.py
new file mode 100644
index 0000000..2b9ddf2
--- /dev/null
+++ b/skills/context-master/scripts/create_subagent.py
@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""
+Create a subagent configuration for Claude Code.
+
+Usage:
+    python create_subagent.py <agent_name> [--type TYPE] [--output DIR]
+
+Types:
+    - researcher: For documentation and code searches with deep analysis
+    - tester: For running tests and validation with failure analysis
+    - analyzer: For code analysis and architectural insights
+    - builder: For build and deployment tasks
+    - deep_analyzer: For complex decisions requiring extensive thinking
+"""
+
+import argparse
+import json
+from pathlib import Path
+
+SUBAGENT_TEMPLATES = {
+    "researcher": {
+        "name": "{agent_name}",
+        "description": "Research and documentation lookup agent with deep analysis",
+        "instructions": """You are a research specialist. Your job is to:
+- Search through documentation efficiently
+- THINK DEEPLY about findings using extended thinking
+- Analyze patterns and implications
+- Synthesize insights with reasoning
+- Return concise, well-reasoned summaries
+
+IMPORTANT: For complex research, use extended thinking before responding:
+- Use "think hard" for multi-source analysis
+- Use "ultrathink" for architecture pattern evaluation
+- Your thinking happens in YOUR isolated context
+- Return only the analysis summary to the main agent
+
+The main agent needs your INSIGHTS, not raw data.""",
+        "tools": ["read", "search", "web_search"],
+        "autonomy": "medium"
+    },
+    
+    "tester": {
+        "name": "{agent_name}",
+        "description": "Testing and validation agent with analysis",
+        "instructions": """You are a testing specialist. Your job is to:
+- Execute test suites
+- Validate code changes
+- ANALYZE test failures deeply
+- Identify root causes and patterns
+- Report clear, actionable results
+
+IMPORTANT: When test failures occur, use extended thinking:
+- Use "think hard" to analyze failure patterns
+- Consider root causes and related issues
+- Your analysis happens in YOUR isolated context
+- Return actionable findings to the main agent
+
+Focus on test execution and insightful result reporting.""",
+        "tools": ["bash", "read", "write"],
+        "autonomy": "high"
+    },
+    
+    "analyzer": {
+        "name": "{agent_name}",
+        "description": "Code analysis and deep architectural insight agent",
+        "instructions": """You are a code analysis specialist. Your job is to:
+- Analyze code structure and patterns
+- THINK DEEPLY about implications and tradeoffs
+- Identify potential issues and opportunities
+- Compute complexity metrics
+- Find dependencies and relationships
+
+IMPORTANT: Always use extended thinking for analysis:
+- Use "think harder" for architecture analysis
+- Use "ultrathink" for complex system evaluation
+- Consider multiple perspectives and edge cases
+- Your deep reasoning happens in YOUR isolated context
+- Return concise analysis with key insights to the main agent
+
+Provide actionable insights backed by reasoning.""",
+        "tools": ["read", "search", "bash"],
+        "autonomy": "medium"
+    },
+    
+    "builder": {
+        "name": "{agent_name}",
+        "description": "Build and deployment agent",
+        "instructions": """You are a build specialist. Your job is to:
+- Execute build processes
+- Run deployment scripts
+- Verify build outputs
+- Report build status and errors
+
+Focus on build execution and clear status reporting. Return success/failure and any errors.""",
+        "tools": ["bash", "read"],
+        "autonomy": "high"
+    },
+    
+    "deep_analyzer": {
+        "name": "{agent_name}",
+        "description": "Deep analysis agent with mandatory extended thinking",
+        "instructions": """You are a deep analysis specialist. Your PRIMARY function is to think deeply before responding.
+
+MANDATORY WORKFLOW:
+1. Always start with "ultrathink" for complex analysis
+2. Consider multiple approaches and perspectives
+3. Evaluate tradeoffs, implications, and edge cases
+4. Reason through consequences and alternatives
+5. Synthesize findings into clear recommendations
+
+Your extended thinking happens in YOUR isolated context - this is your superpower.
+The main agent only sees your conclusions, not your reasoning process.
+
+RETURN FORMAT:
+- Brief conclusion (2-3 sentences)
+- Key reasoning points (3-5 bullets)
+- Recommendation with rationale
+- Any important caveats
+
+The main agent trusts your deep analysis. Give them confidence through thorough thinking.""",
+        "tools": ["read", "search", "bash", "web_search"],
+        "autonomy": "high"
+    }
+}
+
+CLAUDE_CODE_FORMAT = """# {agent_name}
+
+{description}
+
+## Instructions
+
+{instructions}
+
+## Allowed Tools
+
+{tools}
+
+## Autonomy Level
+
+{autonomy_description}
+"""
+
+AUTONOMY_DESCRIPTIONS = {
+    "low": "Ask for confirmation before taking actions. Provide recommendations.",
+    "medium": "Take standard actions autonomously. Ask for confirmation on significant changes.",
+    "high": "Execute tasks fully autonomously. Report results when complete."
+}
+
+
+def create_subagent(agent_name: str, agent_type: str, output_dir: str) -> None:
+    """Create a subagent configuration file."""
+    if agent_type not in SUBAGENT_TEMPLATES:
+        raise ValueError(
+            f"Unknown agent type: {agent_type}. "
+            f"Choose from: {', '.join(SUBAGENT_TEMPLATES.keys())}"
+        )
+    
+    template = SUBAGENT_TEMPLATES[agent_type].copy()
+    template["name"] = agent_name
+    
+    # Create output directory
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+    
+    # Create .claude/agents directory structure
+    agents_dir = output_path / ".claude" / "agents"
+    agents_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Generate agent file in Claude Code format
+    agent_file = agents_dir / f"{agent_name}.md"
+    
+    tools_list = "\n".join(f"- {tool}" for tool in template["tools"])
+    autonomy_desc = AUTONOMY_DESCRIPTIONS[template["autonomy"]]
+    
+    content = CLAUDE_CODE_FORMAT.format(
+        agent_name=agent_name,
+        description=template["description"],
+        instructions=template["instructions"],
+        tools=tools_list,
+        autonomy_description=autonomy_desc
+    )
+    
+    agent_file.write_text(content)
+    
+    # Also create a JSON version for programmatic use
+    json_file = agents_dir / f"{agent_name}.json"
+    json_file.write_text(json.dumps(template, indent=2))
+    
+    print(f"✅ Created subagent: {agent_name}")
+    print(f"   Type: {agent_type}")
+    print(f"   Location: {agent_file}")
+    print(f"\n📝 Next steps:")
+    print(f"   1. Review and customize {agent_file}")
+    print(f"   2. Use in Claude Code with: /agent {agent_name}")
+    print(f"   3. Commit to version control")
+    
+    # Print usage example
+    print(f"\n💡 Usage example:")
+    print(f"   /agent {agent_name} [your task description]")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Create a subagent configuration for Claude Code"
+    )
+    parser.add_argument(
+        "agent_name",
+        help="Name for the subagent (e.g., 'test-runner', 'doc-searcher')"
+    )
+    parser.add_argument(
+        "--type",
+        choices=list(SUBAGENT_TEMPLATES.keys()),
+        default="researcher",
+        help="Type of subagent to create"
+    )
+    parser.add_argument(
+        "--output",
+        default=".",
+        help="Output directory (default: current directory)"
+    )
+    
+    args = parser.parse_args()
+    
+    create_subagent(args.agent_name, args.type, args.output)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/skills/context-master/scripts/generate_claude_md.py b/skills/context-master/scripts/generate_claude_md.py
new file mode 100644
index 0000000..7058484
--- /dev/null
+++ b/skills/context-master/scripts/generate_claude_md.py
@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+"""
+Generate a CLAUDE.md file for context-efficient Claude Code workflows.
+
+Usage:
+    python generate_claude_md.py [--type TYPE] [--output PATH]
+
+Types:
+    - general: General-purpose project (default)
+    - backend: Backend API/service project
+    - frontend: Frontend web application
+    - fullstack: Full-stack application
+    - data: Data science/ML project
+    - library: Library/package project
+"""
+
+import argparse
+import os
+from pathlib import Path
+
+TEMPLATES = {
+    "general": """# Claude Code Configuration
+
+## Project Overview
+<!-- Describe your project's purpose, architecture, and key components -->
+
+## Context Management Strategy
+
+### When to Use Subagents
+- **Code searches**: Use subagents to search through large codebases
+- **File analysis**: Delegate multi-file analysis to subagents
+- **Research tasks**: Use subagents for documentation lookups
+- **Testing**: Isolate test runs in subagents
+
+### Context Commands
+- Use `/clear` between major tasks to reset context
+- Use `/compact` before complex multi-step work
+- Use `think` for planning complex changes
+
+## Development Workflow
+
+1. **Planning Phase**: Use "think" to analyze approach
+2. **Implementation**: Keep main context focused on current task
+3. **Verification**: Use subagents for testing and validation
+4. **Cleanup**: `/clear` before starting new features
+
+## Allowed Tools
+- File operations (read, write, edit)
+- Git operations (commit, branch, status)
+- Shell commands for building and testing
+- Subagent delegation
+
+## Code Style
+<!-- Add your project's code style guidelines -->
+
+## Escalation Rules
+- Ask before making breaking changes
+- Confirm before deleting files
+- Verify test results before committing
+""",
+    
+    "backend": """# Claude Code Configuration - Backend Project
+
+## Project Overview
+<!-- Describe your API/service architecture -->
+
+## Context Management Strategy
+
+### When to Use Subagents
+- **Database queries**: Delegate schema exploration to subagents
+- **API documentation**: Use subagents to search through API docs
+- **Log analysis**: Isolate log file analysis in subagents
+- **Dependency analysis**: Check dependencies in isolated context
+- **Test runs**: Execute test suites in subagents
+
+### Context Commands
+- `/clear` between feature implementations
+- `/compact` before multi-endpoint refactoring
+- `think hard` for API design decisions
+
+## Development Workflow
+
+1. **Schema Review**: Subagent explores DB schema
+2. **Planning**: Main context designs endpoint logic
+3. **Implementation**: Focus on current endpoint
+4. **Testing**: Subagent runs integration tests
+5. **Commit**: After test verification
+
+## API Patterns
+<!-- Add your API conventions (REST, GraphQL, etc.) -->
+
+## Database
+<!-- Add your schema info or reference documentation -->
+
+## Testing Strategy
+- Unit tests required for business logic
+- Integration tests for API endpoints
+- Use subagents for test execution
+
+## Escalation Rules
+- Confirm before database migrations
+- Ask before changing API contracts
+- Verify backward compatibility
+""",
+    
+    "frontend": """# Claude Code Configuration - Frontend Project
+
+## Project Overview
+<!-- Describe your frontend architecture (React, Vue, Angular, etc.) -->
+
+## Context Management Strategy
+
+### When to Use Subagents
+- **Component searches**: Find similar components across codebase
+- **Style analysis**: Isolate CSS/styling investigations
+- **Bundle analysis**: Check dependencies and imports
+- **Test runs**: Execute component tests in subagents
+- **Build verification**: Run builds in isolated context
+
+### Context Commands
+- `/clear` between component implementations
+- `/compact` before large refactoring
+- `think` for component architecture decisions
+
+## Development Workflow
+
+1. **Component Planning**: Design component structure
+2. **Implementation**: Focus on current component
+3. **Styling**: Apply consistent design system
+4. **Testing**: Subagent runs component tests
+5. **Build Check**: Subagent verifies build
+
+## Component Patterns
+<!-- Add your component conventions -->
+
+## Styling Approach
+<!-- CSS-in-JS, Tailwind, CSS Modules, etc. -->
+
+## State Management
+<!-- Redux, Context API, Zustand, etc. -->
+
+## Testing Strategy
+- Component tests required
+- Use Testing Library best practices
+- Subagents handle test execution
+
+## Escalation Rules
+- Confirm before major architectural changes
+- Ask before adding new dependencies
+- Verify accessibility requirements
+""",
+    
+    "fullstack": """# Claude Code Configuration - Full-Stack Project
+
+## Project Overview
+<!-- Describe your full-stack architecture -->
+
+## Context Management Strategy
+
+### When to Use Subagents
+- **Frontend searches**: Delegate component searches
+- **Backend analysis**: Isolate API endpoint analysis
+- **Database operations**: Schema exploration in subagents
+- **Build processes**: Run builds in isolated contexts
+- **Test suites**: Execute frontend and backend tests separately
+
+### Context Commands
+- `/clear` between frontend/backend context switches
+- `/compact` before cross-stack refactoring
+- `think hard` for architectural decisions
+
+## Development Workflow
+
+1. **Planning**: Design full-stack feature flow
+2. **Backend First**: Implement API endpoints
+3. **Frontend**: Build UI components
+4. **Integration**: Connect frontend to backend
+5. **Testing**: Subagents test both layers
+
+## Stack
+- **Frontend**: <!-- React, Vue, etc. -->
+- **Backend**: <!-- Node.js, Python, etc. -->
+- **Database**: <!-- PostgreSQL, MongoDB, etc. -->
+
+## API Patterns
+<!-- REST, GraphQL, tRPC, etc. -->
+
+## Testing Strategy
+- Unit tests for business logic
+- Integration tests for APIs
+- Component tests for UI
+- E2E tests for critical flows
+
+## Escalation Rules
+- Confirm before database migrations
+- Ask before API contract changes
+- Verify cross-stack impacts
+""",
+    
+    "data": """# Claude Code Configuration - Data Science Project
+
+## Project Overview
+<!-- Describe your data pipeline and analysis goals -->
+
+## Context Management Strategy
+
+### When to Use Subagents
+- **Data exploration**: Delegate large dataset analysis
+- **Model searches**: Find similar models in codebase
+- **Documentation**: Research library documentation
+- **Experiment runs**: Execute training in subagents
+- **Result analysis**: Isolate metrics computation
+
+### Context Commands
+- `/clear` between experiments
+- `/compact` before model refactoring
+- `think harder` for model architecture decisions
+
+## Development Workflow
+
+1. **Data Exploration**: Subagent analyzes dataset
+2. **Feature Engineering**: Design features in main context
+3. **Model Development**: Implement and iterate
+4. **Evaluation**: Subagent runs evaluation metrics
+5. **Documentation**: Record experiment results
+
+## Data Pipeline
+<!-- Add your data sources and processing steps -->
+
+## Model Architecture
+<!-- Add your model details -->
+
+## Experiment Tracking
+<!-- MLflow, Weights & Biases, etc. -->
+
+## Testing Strategy
+- Unit tests for data processing
+- Validation tests for model outputs
+- Subagents handle long-running tests
+
+## Escalation Rules
+- Confirm before large dataset operations
+- Ask before changing data schemas
+- Verify model performance before deployment
+""",
+    
+    "library": """# Claude Code Configuration - Library Project
+
+## Project Overview
+<!-- Describe your library's purpose and API -->
+
+## Context Management Strategy
+
+### When to Use Subagents
+- **API searches**: Find similar functions across codebase
+- **Documentation**: Research upstream dependencies
+- **Example analysis**: Review usage examples
+- **Test execution**: Run test suites in subagents
+- **Build verification**: Check builds across versions
+
+### Context Commands
+- `/clear` between feature implementations
+- `/compact` before API refactoring
+- `think` for public API design
+
+## Development Workflow
+
+1. **API Design**: Plan function signatures
+2. **Implementation**: Implement core logic
+3. **Documentation**: Write docstrings and examples
+4. **Testing**: Comprehensive test coverage
+5. **Verification**: Subagent runs full test suite
+
+## API Principles
+- Maintain backward compatibility
+- Clear, consistent naming
+- Comprehensive documentation
+- Type hints/annotations
+
+## Testing Strategy
+- Unit tests for all public APIs
+- Integration tests for workflows
+- Docstring examples as doctests
+- Subagents handle test execution
+
+## Documentation
+- Docstrings required for all public APIs
+- Usage examples in docs/
+- Changelog maintenance
+
+## Escalation Rules
+- Confirm before breaking API changes
+- Ask before adding dependencies
+- Verify semantic versioning
+"""
+}
+
+
+def generate_claude_md(project_type: str, output_path: str) -> None:
+    """Generate a CLAUDE.md file from a template."""
+    if project_type not in TEMPLATES:
+        raise ValueError(f"Unknown project type: {project_type}. Choose from: {', '.join(TEMPLATES.keys())}")
+    
+    content = TEMPLATES[project_type]
+    
+    # Create parent directory if it doesn't exist
+    output_file = Path(output_path)
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    
+    # Write the file
+    output_file.write_text(content)
+    print(f"✅ Generated CLAUDE.md at {output_path}")
+    print(f"   Template: {project_type}")
+    print(f"\n📝 Next steps:")
+    print(f"   1. Review and customize the generated CLAUDE.md")
+    print(f"   2. Fill in project-specific details")
+    print(f"   3. Commit it to your repository")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate a CLAUDE.md file for context-efficient Claude Code workflows"
+    )
+    parser.add_argument(
+        "--type",
+        choices=list(TEMPLATES.keys()),
+        default="general",
+        help="Project type template to use"
+    )
+    parser.add_argument(
+        "--output",
+        default="./CLAUDE.md",
+        help="Output path for the CLAUDE.md file"
+    )
+    
+    args = parser.parse_args()
+    generate_claude_md(args.type, args.output)
+
+
+if __name__ == "__main__":
+    main()