ccjk 14.1.11 → 14.2.0

package/dist/chunks/config.mjs

@@ -2,9 +2,9 @@ import { fileURLToPath } from 'node:url';
 import a from './index5.mjs';
 import { d as dayjs } from '../shared/ccjk.RyizuzOI.mjs';
 import { i as inquirer } from './index6.mjs';
+import { chmodSync, readFileSync } from 'node:fs';
 import { ZCF_CONFIG_FILE, ZCF_CONFIG_DIR, CLAUDE_VSC_CONFIG_FILE, CLAVUE_CONFIG_FILE, CLAVUE_CREDENTIALS_FILE, CLAVUE_SETTINGS_FILE, AI_OUTPUT_LANGUAGES, SETTINGS_FILE } from './constants.mjs';
 import { ensureI18nInitialized, i18n } from './index2.mjs';
-import { chmodSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import process__default from 'node:process';
 import { readDefaultTomlConfig, createDefaultTomlConfig, writeTomlConfig } from './ccjk-config.mjs';
@@ -2421,8 +2421,23 @@ function applyAiLanguageDirective(aiOutputLang, codeTool) {
   } else {
     directive = `Always respond in ${aiOutputLang}`;
   }
+  let baseline = "";
+  try {
+    const currentFilePath = fileURLToPath(import.meta.url);
+    const distDir = dirname(dirname(currentFilePath));
+    const rootDir = dirname(distDir);
+    const baselinePath = join(rootDir, "templates", "common", "karpathy-baseline.md");
+    if (exists(baselinePath)) {
+      baseline = readFileSync(baselinePath, "utf-8").trim();
+    }
+  } catch {
+  }
   const frontmatter = target.codeTool === "clavue" ? "" : "---\nscope: user\n---\n\n";
-  writeFileAtomic(instructionsFile, `${frontmatter}${directive}`);
+  const body = baseline ? `${directive}
+
+${baseline}
+` : directive;
+  writeFileAtomic(instructionsFile, `${frontmatter}${body}`);
 }
 function switchToOfficialLogin(codeTool) {
   try {

package/dist/chunks/doctor.mjs

@@ -622,6 +622,26 @@ async function checkSettings(codeType) {
     if (settings.plansDirectory === null) {
       issues.push("plansDirectory should not be null");
     }
+    const env = settings.env || {};
+    const hasAnthropicModelVars = Boolean(
+      env.ANTHROPIC_MODEL || env.ANTHROPIC_DEFAULT_OPUS_MODEL || env.ANTHROPIC_DEFAULT_SONNET_MODEL || env.ANTHROPIC_DEFAULT_HAIKU_MODEL
+    );
+    if (settings.model && hasAnthropicModelVars) {
+      issues.push(`settings.model="${settings.model}" overrides ANTHROPIC_* env vars (custom model selection broken)`);
+    }
+    const sonnet = env.ANTHROPIC_DEFAULT_SONNET_MODEL;
+    if (typeof sonnet === "string" && /opus/i.test(sonnet)) {
+      issues.push(`ANTHROPIC_DEFAULT_SONNET_MODEL="${sonnet}" looks like an Opus model (slot misrouted)`);
+    }
+    const preToolUse = settings.hooks?.PreToolUse;
+    if (Array.isArray(preToolUse)) {
+      const hasGatekeeper = preToolUse.some(
+        (h) => h?.matcher === "mcp__.*" && Array.isArray(h?.hooks) && h.hooks.some((c) => typeof c?.command === "string" && c.command.includes("mcp-gatekeeper"))
+      );
+      if (hasGatekeeper) {
+        issues.push("mcp-gatekeeper PreToolUse hook is enabled (forks bash+node per MCP call; disabled by default)");
+      }
+    }
     if (issues.length > 0) {
       return {
         name: "settings.json",
@@ -717,6 +737,50 @@ async function checkCcr() {
     fix: "Run: npx ccjk zero-config dev"
   };
 }
+async function checkDisciplineBaseline(codeType) {
+  const target = resolveClaudeFamilySettingsTarget(codeType);
+  const memoryFile = target.instructionsFile;
+  if (!existsSync(memoryFile)) {
+    return {
+      name: "Discipline Baseline",
+      status: "warning",
+      message: "No memory file found",
+      fix: "Run: npx ccjk init"
+    };
+  }
+  const { readFileSync } = await import('node:fs');
+  const text = readFileSync(memoryFile, "utf-8");
+  const required = [
+    "# Coding Discipline Baseline",
+    "Think before coding",
+    "Simplicity first",
+    "Surgical changes",
+    "Goal-driven execution"
+  ];
+  const missing = required.filter((m) => !text.includes(m));
+  if (missing.length === 0) {
+    return {
+      name: "Discipline Baseline",
+      status: "ok",
+      message: "All 4 principles present"
+    };
+  }
+  if (missing.length === required.length) {
+    return {
+      name: "Discipline Baseline",
+      status: "warning",
+      message: "Baseline not installed (memory file exists but has no discipline section)",
+      fix: "Run: npx ccjk init"
+    };
+  }
+  return {
+    name: "Discipline Baseline",
+    status: "error",
+    message: `Baseline partially missing: ${missing.length}/${required.length} markers absent`,
+    fix: "Run: npx ccjk init  (will rewrite CLAUDE.md with full baseline)",
+    details: missing
+  };
+}
 async function checkOutputStyles(codeType) {
   const target = resolveClaudeFamilySettingsTarget(codeType);
   const stylesDir = join(target.configDir, "output-styles");
@@ -794,6 +858,62 @@ async function checkCodexToml() {
     message: "Valid configuration"
   };
 }
+async function checkCodexFieldValues() {
+  if (!existsSync(CODEX_CONFIG_FILE)) {
+    return { name: "Codex Field Values", status: "ok", message: "Skipped (no config)" };
+  }
+  const { readFileSync } = await import('node:fs');
+  const text = readFileSync(CODEX_CONFIG_FILE, "utf-8");
+  const issues = [];
+  const validEffort = /* @__PURE__ */ new Set(["minimal", "low", "medium", "high"]);
+  const validTier = /* @__PURE__ */ new Set(["default", "flex", "priority"]);
+  const effortMatch = text.match(/^model_reasoning_effort\s*=\s*"([^"]+)"/m);
+  if (effortMatch && !validEffort.has(effortMatch[1])) {
+    issues.push(`model_reasoning_effort="${effortMatch[1]}" (valid: ${[...validEffort].join("/")})`);
+  }
+  const tierMatch = text.match(/^service_tier\s*=\s*"([^"]+)"/m);
+  if (tierMatch && !validTier.has(tierMatch[1])) {
+    issues.push(`service_tier="${tierMatch[1]}" (valid: ${[...validTier].join("/")})`);
+  }
+  if (issues.length === 0) {
+    return { name: "Codex Field Values", status: "ok", message: "All fields valid" };
+  }
+  return {
+    name: "Codex Field Values",
+    status: "warning",
+    message: `${issues.length} non-standard value(s) \u2014 Codex silently uses defaults`,
+    fix: "Edit ~/.codex/config.toml",
+    details: issues
+  };
+}
+async function checkCodexTrustedProjects() {
+  if (!existsSync(CODEX_CONFIG_FILE)) {
+    return { name: "Codex Trusted Projects", status: "ok", message: "Skipped (no config)" };
+  }
+  const { readFileSync } = await import('node:fs');
+  const text = readFileSync(CODEX_CONFIG_FILE, "utf-8");
+  const trusted = [];
+  const re = /\[projects\."([^"]+)"\]/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    trusted.push(m[1]);
+  }
+  const stale = trusted.filter((p) => !existsSync(p));
+  if (stale.length === 0) {
+    return {
+      name: "Codex Trusted Projects",
+      status: "ok",
+      message: `${trusted.length} entries, all paths exist`
+    };
+  }
+  return {
+    name: "Codex Trusted Projects",
+    status: "warning",
+    message: `${stale.length} of ${trusted.length} trusted paths no longer exist on disk`,
+    fix: "Edit ~/.codex/config.toml to remove dead entries",
+    details: stale.slice(0, 10)
+  };
+}
 async function checkCodexMcp() {
   const config = readCodexConfig();
   const count = config?.mcpServices.length || 0;
@@ -843,6 +963,50 @@ async function checkClavueNativeGoals() {
     fix: "Run: npm install -g clavue"
   };
 }
+async function checkCcjkProfiles() {
+  const { homedir } = await import('node:os');
+  const ccjkConfigPath = join(homedir(), ".ccjk", "config.toml");
+  if (!existsSync(ccjkConfigPath)) {
+    return { name: "CCJK Profiles", status: "ok", message: "Skipped (no config)" };
+  }
+  const { readFileSync } = await import('node:fs');
+  const text = readFileSync(ccjkConfigPath, "utf-8");
+  const suspicious = [];
+  const sectionRe = /^\[claudeCode\.profiles\.([^\]]+)\]$([\s\S]*?)(?=^\[|\z)/gm;
+  let m;
+  while ((m = sectionRe.exec(text)) !== null) {
+    const name = m[1];
+    const body = m[2];
+    const apiKey = body.match(/apiKey\s*=\s*"([^"]*)"/)?.[1] ?? "";
+    const baseUrl = body.match(/baseUrl\s*=\s*"([^"]*)"/)?.[1] ?? "";
+    const reasons = [];
+    if (/^\d+$/.test(name)) {
+      reasons.push("numeric-only name");
+    }
+    if (apiKey && apiKey.length < 10) {
+      reasons.push(`apiKey too short (${apiKey.length} chars)`);
+    }
+    if (baseUrl && !/^https?:\/\/[^\s/]+\.[^\s/]/.test(baseUrl)) {
+      reasons.push(`baseUrl looks invalid: ${baseUrl}`);
+    }
+    if (apiKey.startsWith("sk-ant-test-") || /test-?\d+/i.test(apiKey)) {
+      reasons.push("apiKey looks like a test placeholder");
+    }
+    if (reasons.length > 0) {
+      suspicious.push(`${name}: ${reasons.join("; ")}`);
+    }
+  }
+  if (suspicious.length === 0) {
+    return { name: "CCJK Profiles", status: "ok", message: "No junk profiles detected" };
+  }
+  return {
+    name: "CCJK Profiles",
+    status: "warning",
+    message: `${suspicious.length} suspicious profile(s) in ~/.ccjk/config.toml`,
+    fix: "Use ccjk menu to remove or rename them",
+    details: suspicious
+  };
+}
 async function checkCodexProviders() {
   const config = readCodexConfig();
   if (!config) {
@@ -1017,18 +1181,23 @@ async function doctor(options = {}) {
     checkCodexCli,
     checkCodexDir,
     checkCodexToml,
+    checkCodexFieldValues,
+    checkCodexTrustedProjects,
     checkCodexMcp,
-    checkCodexNativeGoals
+    checkCodexNativeGoals,
+    checkCcjkProfiles
   ] : [
     () => checkClaudeCode(options.codeType),
     () => checkClaudeDir(options.codeType),
     () => checkSettings(options.codeType),
+    () => checkDisciplineBaseline(options.codeType),
     () => checkWorkflows(options.codeType),
     () => checkMcp(options.codeType),
     () => checkPermissionRules(options.codeType),
     checkCcr,
     () => checkOutputStyles(options.codeType),
-    ...options.codeType === "clavue" ? [checkClavueNativeGoals] : []
+    ...options.codeType === "clavue" ? [checkClavueNativeGoals] : [],
+    checkCcjkProfiles
   ];
   if (options.checkProviders) {
     checks.push(options.codeType === "codex" ? checkCodexProviders : () => checkProviders(options.codeType));

package/dist/chunks/index10.mjs

@@ -3,7 +3,7 @@ import { i as inquirer } from './index6.mjs';
 import { CLOUD_ENDPOINTS, CCJK_CONFIG_DIR, SUPPORTED_LANGS, LANG_LABELS, CODE_TOOL_BANNERS, isCodeToolType, DEFAULT_CODE_TOOL_TYPE } from './constants.mjs';
 import { ensureI18nInitialized, i18n, resolveSupportedLanguage, changeLanguage } from './index2.mjs';
 import { displayBannerWithInfo } from './banner.mjs';
-import { readZcfConfig, updateZcfConfig } from './ccjk-config.mjs';
+import { readZcfConfig, updateZcfConfig, readDefaultTomlConfig } from './ccjk-config.mjs';
 import { L as buildMyclaudeProviderPresentation } from './config.mjs';
 import { b as runCodexUpdate, j as runCodexUninstall, k as configureCodexAiMemoryFeature, m as configureCodexDefaultModelFeature, n as configureCodexMcp, o as configureCodexApi, p as configureCodexPresetFeature, q as runCodexWorkflowImportWithLanguageSelection, i as runCodexFullInit } from './codex.mjs';
 import { S as STARTUP_CODE_TOOL_CHOICES, a as resolveStartupCodeType } from './code-type-resolver.mjs';
@@ -4462,8 +4462,8 @@ function getMenuShellConfig(codeTool) {
   return {
     allowMore: true,
     footerCommands: [],
-    menuTitle: i18n.t("menu:menu.title", "CCJK Main Menu"),
-    showHero: false
+    menuTitle: getToolModeMenuTitle(codeTool),
+    showHero: true
   };
 }
 async function showProgressiveMenu(codeTool, runtimeSyncResult) {
@@ -4482,6 +4482,10 @@ async function showProgressiveMenu(codeTool, runtimeSyncResult) {
       }
     ];
     const allowedCommands2 = ["0", "q", "m", "s"];
+    const tomlCfg = readDefaultTomlConfig();
+    const profile = tomlCfg?.claudeCode?.currentProfile;
+    console.log(renderToolModeHero(codeTool, 76, profile ? { profileLabel: profile } : void 0));
+    console.log("");
     const menuOutput2 = renderMenu(
       "menu:oneClick.title",
       visibleItems2,
@@ -4556,7 +4560,17 @@ async function showProgressiveMenu(codeTool, runtimeSyncResult) {
   const menuShell = getMenuShellConfig(codeTool);
   const allowedCommands = ["0", "q", ...menuShell.allowMore ? ["m"] : [], ...menuShell.footerCommands.map((command) => command.key)];
   if (menuShell.showHero) {
-    console.log(renderToolModeHero(codeTool, 76, codeTool === "clavue" ? buildMyclaudeRuntimeSummary(runtimeSyncResult) : void 0));
+    let runtimeSummary;
+    if (codeTool === "clavue") {
+      runtimeSummary = buildMyclaudeRuntimeSummary(runtimeSyncResult);
+    } else {
+      const tomlCfg = readDefaultTomlConfig();
+      const profile = tomlCfg?.claudeCode?.currentProfile;
+      if (profile) {
+        runtimeSummary = { profileLabel: profile };
+      }
+    }
+    console.log(renderToolModeHero(codeTool, 76, runtimeSummary));
     console.log("");
   }
   const menuOutput = renderMenu(

package/dist/chunks/mcp-cli.mjs

@@ -21,9 +21,9 @@ import 'node:os';
 import 'node:crypto';
 import 'buffer';
 import 'string_decoder';
+import 'node:fs';
 import './constants.mjs';
 import '../shared/ccjk.bQ7Dh1g4.mjs';
-import 'node:fs';
 import 'node:child_process';
 import './ccjk-config.mjs';
 import '../shared/ccjk.BBtCGd_g.mjs';

package/dist/chunks/package.mjs

@@ -1,3 +1,3 @@
-const version = "14.1.11";
+const version = "14.2.0";
 
 export { version };

package/dist/templates/agents/README.md

@@ -0,0 +1,78 @@
+# Agent Templates
+
+This directory contains agent definition templates for CCJK v8.0.0's multi-agent orchestration system.
+
+## Available Agents
+
+| Agent ID | Name | Model | Category | Complexity |
+|----------|------|-------|----------|------------|
+| `typescript-architect` | TypeScript Architect | sonnet | development | advanced |
+| `react-specialist` | React Specialist | sonnet | development | intermediate-advanced |
+| `python-expert` | Python Expert | sonnet | development | intermediate-advanced |
+| `go-expert` | Go Expert | sonnet | development | intermediate-advanced |
+| `fullstack-developer` | Full-Stack Developer | sonnet | development | intermediate-advanced |
+| `testing-automation-expert` | Testing Automation Expert | opus | quality-assurance | advanced |
+
+## Agent Template Structure
+
+Each agent template follows this JSON structure:
+
+```json
+{
+  "id": "unique-agent-id",
+  "name": {
+    "en": "English Name",
+    "zh-CN": "中文名称"
+  },
+  "description": {
+    "en": "English description",
+    "zh-CN": "中文描述"
+  },
+  "persona": "Detailed persona description (100+ words)",
+  "capabilities": ["list", "of", "capabilities"],
+  "skills": ["skill-id-1", "skill-id-2"],
+  "mcpServers": ["mcp-server-1", "mcp-server-2"],
+  "systemPrompt": "System prompt for the agent",
+  "instructions": [
+    "Specific instruction 1",
+    "Specific instruction 2"
+  ],
+  "triggers": [
+    "condition that triggers this agent",
+    "another trigger condition"
+  ],
+  "model": "sonnet|opus|haiku",
+  "metadata": {
+    "version": "1.0.0",
+    "author": "ccjk-team",
+    "category": "development|quality-assurance|devops",
+    "tags": ["tag1", "tag2"],
+    "complexity": "beginner|intermediate|advanced",
+    "experience_level": "beginner|intermediate|senior"
+  }
+}
+```
+
+## Usage
+
+These templates are used by CCJK's agent orchestration system to:
+
+1. **Agent Selection**: Choose the most appropriate agent based on user queries and triggers
+2. **Context Setup**: Configure the agent with proper persona, skills, and MCP servers
+3. **Instruction Following**: Provide specific guidelines for each agent's behavior
+4. **Model Assignment**: Use the optimal Claude model for each agent's complexity
+
+## Model Selection Strategy
+
+- **Opus**: Complex reasoning tasks, advanced architecture decisions
+- **Sonnet**: Balanced performance for most development tasks
+- **Haiku**: Fast responses for simple operations and templates
+
+## Extending the System
+
+To add new agents:
+
+1. Create a new JSON file following the template structure
+2. Define clear triggers and capabilities
+3. Choose appropriate MCP servers for the agent's domain
+4. Update this README with the new agent information

package/dist/templates/common/error-prevention.md

@@ -0,0 +1,267 @@
+# CCJK Error Prevention System
+
+**IMPORTANT**: This project uses the CCJK Error Prevention System to automatically prevent and fix common Claude Code CLI errors.
+
+---
+
+## 🛡️ Automatic Error Prevention
+
+All file operations and commands are automatically protected by CCJK's intelligent error prevention system.
+
+### What It Does
+
+The Error Prevention System operates in 5 layers:
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│              CCJK Error Prevention System                        │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  Layer 1: Pre-Execution Validation                               │
+│    ├─ Parameter format validation                                │
+│    ├─ Path validity checks                                       │
+│    ├─ Permission verification                                    │
+│    └─ Command existence validation                               │
+│                                                                  │
+│  Layer 2: Intelligent Wrappers                                   │
+│    ├─ Smart Write: Handles existing files automatically          │
+│    ├─ Smart Bash: Validates and retries commands                 │
+│    ├─ Smart Path: Resolves cross-platform paths                  │
+│    └─ Smart Edit: Detects content changes before editing         │
+│                                                                  │
+│  Layer 3: Auto-Recovery                                          │
+│    ├─ Retry with exponential backoff                             │
+│    ├─ Automatic error correction                                 │
+│    ├─ Rollback support                                           │
+│    └─ Fallback mechanisms                                        │
+│                                                                  │
+│  Layer 4: Real-time Monitoring                                   │
+│    ├─ Error detection and classification                         │
+│    ├─ Pattern analysis                                           │
+│    └─ Alert system                                               │
+│                                                                  │
+│  Layer 5: Learning System                                        │
+│    ├─ Error history tracking                                     │
+│    └─ Solution database                                          │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 📋 Errors That Are Automatically Prevented
+
+### 1. Error Writing File
+
+**Causes**: File already exists, permission denied, path errors
+
+**CCJK Auto-Fix**:
+- ✅ Checks if file exists before writing
+- ✅ Automatically backs up existing files
+- ✅ Uses Edit instead of Write when file exists
+- ✅ Creates missing directories automatically
+- ✅ Retries on transient failures
+
+### 2. Invalid Tool Parameters
+
+**Causes**: Wrong parameter format, missing required parameters, type mismatch
+
+**CCJK Auto-Fix**:
+- ✅ Validates parameter format before execution
+- ✅ Checks for unclosed quotes
+- ✅ Validates file paths
+- ✅ Provides specific error messages
+
+### 3. Bash Command Failures (Exit Code 1)
+
+**Causes**: Command not found, syntax errors, missing environment variables
+
+**CCJK Auto-Fix**:
+- ✅ Validates command exists before execution
+- ✅ Checks parameter format
+- ✅ Sets up environment automatically
+- ✅ Retries on failures with exponential backoff
+- ✅ Suggests alternative commands
+
+### 4. Path Resolution Issues
+
+**Causes**: Relative path errors, symlinks, cross-platform differences
+
+**CCJK Auto-Fix**:
+- ✅ Handles ~ (home directory)
+- ✅ Expands environment variables
+- ✅ Resolves symlinks
+- ✅ Cross-platform path normalization
+- ✅ Provides path fix suggestions
+
+### 5. Permission Denied Errors
+
+**Causes**: File permissions, directory permissions, read-only filesystem
+
+**CCJK Auto-Fix**:
+- ✅ Checks permissions before operations
+- ✅ Attempts to fix script permissions (chmod +x)
+- ✅ Provides specific permission error messages
+- ✅ Suggests appropriate fixes
+
+---
+
+## 🚀 Best Practices
+
+### When Writing Files
+
+**❌ Don't worry about**:
+- File already existing → CCJK handles it
+- Creating directories → CCJK does it automatically
+- Backing up files → CCJK backs up automatically
+- Content validation → CCJK checks before writing
+
+**✅ Just write**:
+- CCJK will detect if file exists
+- CCJK will use Edit tool if appropriate
+- CCJK will create directories if needed
+- CCJK will retry if write fails
+
+### When Running Commands
+
+**❌ Don't worry about**:
+- Command not existing → CCJK checks first
+- Parameter format → CCJK validates
+- Environment setup → CCJK sets up automatically
+- Command failing → CCJK retries with auto-fix
+
+**✅ Just run**:
+- CCJK will validate command exists
+- CCJK will check parameters
+- CCJK will handle dangerous command warnings
+- CCJK will retry on failures
+
+### When Reading Files
+
+**❌ Don't worry about**:
+- Path resolution → CCJK resolves paths
+- File not found → CCJK provides clear error
+- Permission issues → CCJK checks permissions
+
+**✅ Just read**:
+- CCJK will resolve relative paths
+- CCJK will handle symlinks
+- CCJK will provide helpful error messages
+
+---
+
+## 💡 Error Recovery Flow
+
+When an error occurs, CCJK follows this process:
+
+```
+1. Detect → Classify error type
+2. Analyze → Determine if retryable
+3. Auto-fix → Apply automatic correction if possible
+4. Retry → Retry with exponential backoff
+5. Fallback → Suggest alternative approach
+6. Report → Provide detailed error and suggestion
+```
+
+---
+
+## 🔧 Debugging
+
+### Enable Debug Logging
+
+```bash
+# Enable error prevention debug output
+export CCJK_ERROR_PREVENTION_DEBUG=1
+
+# Or enable all CCJK debug output
+export CCJK_DEBUG=1
+```
+
+### View Error Statistics
+
+```typescript
+import { getMiddleware } from 'ccjk/error-prevention'
+
+const middleware = getMiddleware()
+const errorStats = middleware.getErrorStats()
+const fixStats = middleware.getFixStats()
+
+console.log('Error Stats:', errorStats)
+console.log('Fix Stats:', fixStats)
+```
+
+---
+
+## 📊 Expected Impact
+
+| Error Type | Before CCJK | After CCJK | Reduction |
+|------------|-------------|------------|-----------|
+| Error writing file | ⭐⭐⭐⭐⭐ | ⭐ | **80%** |
+| Invalid tool parameters | ⭐⭐⭐⭐ | ⭐ | **75%** |
+| Bash command failures | ⭐⭐⭐⭐ | ⭐ | **70%** |
+| Path resolution issues | ⭐⭐⭐ | ⭐ | **85%** |
+| Permission denied | ⭐⭐⭐ | ⭐ | **90%** |
+
+---
+
+## 🎯 Tips
+
+1. **Trust CCJK's automatic handling** - Let the system prevent errors
+2. **Check console for CCJK messages** - Look for `[CCJK ErrorPrevention]` prefix
+3. **Review suggestions when errors occur** - CCJK provides specific fix suggestions
+4. **Report persistent errors** - Help improve the system
+
+---
+
+## 📖 API Reference
+
+```typescript
+import {
+  getMiddleware,
+  SmartWriteTool,
+  SmartBashTool,
+  SmartPathResolver,
+} from 'ccjk/error-prevention'
+
+// Use middleware (recommended)
+const middleware = getMiddleware()
+
+// Write files
+const writeResult = await middleware.interceptWrite(path, content)
+
+// Execute commands
+const bashResult = await middleware.interceptBash(command, options)
+
+// Read files
+const readResult = await middleware.interceptRead(path)
+
+// Edit files
+const editResult = await middleware.interceptEdit(path, oldString, newString)
+
+// Get path info
+const pathInfo = await middleware.getPathInfo(path)
+
+// Get statistics
+const errors = middleware.getErrorStats()
+const fixes = middleware.getFixStats()
+```
+
+---
+
+## 🎉 Summary
+
+**Before CCJK Error Prevention**:
+- ❌ Frequent errors
+- ❌ Manual debugging
+- ❌ Time wasted
+- ❌ Frustration
+
+**After CCJK Error Prevention**:
+- ✅ Automatic prevention
+- ✅ Intelligent fixes
+- ✅ Efficient development
+- ✅ Peace of mind
+
+---
+
+**Let CCJK handle the errors, focus on your code! 🚀**