claude-pro-minmax 1.0.0

package/install.sh

@@ -0,0 +1,154 @@
+#!/bin/bash
+# Claude Pro MinMax - Installation Script
+set -e
+echo "🚀 Installing Claude Pro MinMax (CPMM)"
+
+# Check for dependencies
+if ! command -v jq &> /dev/null; then
+    echo "⚠️ Warning: jq is not installed. Some features (JSON output, cost optimization) may not work."
+    echo "  Install with: brew install jq"
+fi
+
+# Check for mgrep (Critical for output reduction)
+if ! command -v mgrep &> /dev/null; then
+    echo "⚠️ Warning: mgrep is not installed. This is critical for 50% output reduction."
+    echo "  Install with: npm install -g @mixedbread/mgrep && mgrep install-claude-code"
+fi
+
+# Backup and Clean existing ~/.claude (True Overwrite)
+if [ -d ~/.claude ]; then
+    BACKUP_DIR=~/.claude-backup-$(date +"%Y%m%d-%H%M%S")
+    echo "📦 Backing up and clearing existing ~/.claude → $BACKUP_DIR"
+    mv ~/.claude "$BACKUP_DIR"
+    echo "  Clean overwrite enabled. Old settings preserved in backup."
+fi
+
+# Create fresh directories
+mkdir -p ~/.claude/{agents,commands,rules,skills/cli-wrappers/references,contexts,sessions,scripts}
+
+# Copy configurations
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+cp "$SCRIPT_DIR/.claude/CLAUDE.md" ~/.claude/
+cp "$SCRIPT_DIR/.claude/settings.json" ~/.claude/
+if [ -f "$SCRIPT_DIR/.claudeignore" ]; then
+    cp "$SCRIPT_DIR/.claudeignore" ~/.claude/
+fi
+# Copy settings.local.json from example template (users customize after install)
+if [ -f "$SCRIPT_DIR/.claude/settings.local.example.json" ]; then
+    cp "$SCRIPT_DIR/.claude/settings.local.example.json" ~/.claude/settings.local.json
+fi
+cp "$SCRIPT_DIR/.claude/agents/"*.md ~/.claude/agents/
+cp "$SCRIPT_DIR/.claude/commands/"*.md ~/.claude/commands/
+for rule in "$SCRIPT_DIR/.claude/rules/"*.md; do
+  filename=$(basename "$rule")
+  [ "$filename" = "language.md" ] && continue
+  cp "$rule" ~/.claude/rules/
+done
+cp -R "$SCRIPT_DIR/.claude/skills/"* ~/.claude/skills/
+cp "$SCRIPT_DIR/.claude/contexts/"*.md ~/.claude/contexts/
+# sessions/ dir created above; example files stay in repo only (not installed)
+cp -R "$SCRIPT_DIR/scripts/"* ~/.claude/scripts/
+
+# Clean up documentation files from ~/.claude to prevent parsing errors
+# (The 'find' command below removes all README/USER-MANUAL files from the installed directory)
+find ~/.claude -name "README*" -delete
+find ~/.claude -name "USER-MANUAL*" -delete
+
+# Copy MCP Configuration (User Scope - ~/.claude.json)
+if [ -f "$SCRIPT_DIR/.claude.json" ]; then
+    if [ -f ~/.claude.json ]; then
+        echo "📦 Backing up existing ~/.claude.json → ~/.claude.json.bak"
+        cp ~/.claude.json ~/.claude.json.bak
+    fi
+    cp "$SCRIPT_DIR/.claude.json" ~/.claude.json
+    echo "✅ Installed .claude.json to ~/.claude.json (User Scope)"
+
+    # Create .mcp.json symlink (Force recreate to ensure it's a link)
+    if [ -e ~/.mcp.json ] || [ -L ~/.mcp.json ]; then
+        rm ~/.mcp.json
+    fi
+    ln -s ~/.claude.json ~/.mcp.json
+    echo "✅ Created .mcp.json → .claude.json symlink (Ensured Link)"
+    # Interactive Perplexity Setup (Read from /dev/tty for curl support)
+    if [ -t 0 ] || [ -c /dev/tty ]; then
+        echo ""
+        echo "🔍 Perplexity API Setup (Recommended for /dplan)"
+        echo -n "   Enter your API Key (Press Enter to skip): "
+        read -rs PERPLEXITY_KEY < /dev/tty || PERPLEXITY_KEY=""
+        echo "" # Newline for silent read
+
+        if [ -n "$PERPLEXITY_KEY" ]; then
+            # Enable Perplexity (Rename key and inject API Key)
+            # Use jq for reliable JSON editing
+            jq --arg key "$PERPLEXITY_KEY" \
+               '.mcpServers.perplexity = .mcpServers._perplexity_disabled_by_default | 
+                .mcpServers.perplexity.env.PERPLEXITY_API_KEY = $key | 
+                del(.mcpServers._perplexity_disabled_by_default)' \
+               ~/.claude.json > ~/.claude.json.tmp && mv ~/.claude.json.tmp ~/.claude.json
+            echo "✅ Perplexity API Key configured!"
+        else
+            # Skip: Completely remove the disabled block to keep config clean
+            echo "⚠️  Skipping Perplexity setup. Disabling feature..."
+            jq 'del(.mcpServers._perplexity_disabled_by_default)' ~/.claude.json > ~/.claude.json.tmp && mv ~/.claude.json.tmp ~/.claude.json
+            echo "   (Feature removed from config. Add manually to functionality if needed)"
+        fi
+        # No temp file cleanup needed for jq approach as we mv content
+    fi
+fi
+
+# Language Selection (Interactive)
+if [ -t 0 ] || [ -c /dev/tty ]; then
+  echo ""
+  echo "🌍 Output Language"
+  echo "   1) English (default)"
+  echo "   2) 한국어 (Korean)"
+  echo "   3) 日本語 (Japanese)"
+  echo "   4) 中文 (Chinese)"
+  echo -n "   Select [1-4]: "
+  read -r LANG_CHOICE < /dev/tty || LANG_CHOICE="1"
+
+  case $LANG_CHOICE in
+    2)
+      cat > ~/.claude/rules/language.md <<'LANGEOF'
+# Language Policy
+Respond in Korean (한국어). Code, commands, technical terms in English.
+LANGEOF
+      echo "✅ Output language: Korean"
+      ;;
+    3)
+      cat > ~/.claude/rules/language.md <<'LANGEOF'
+# Language Policy
+Respond in Japanese (日本語). Code, commands, technical terms in English.
+LANGEOF
+      echo "✅ Output language: Japanese"
+      ;;
+    4)
+      cat > ~/.claude/rules/language.md <<'LANGEOF'
+# Language Policy
+Respond in Chinese (中文). Code, commands, technical terms in English.
+LANGEOF
+      echo "✅ Output language: Chinese"
+      ;;
+    *)
+      # English: no language.md needed (Claude defaults to English)
+      rm -f ~/.claude/rules/language.md
+      echo "✅ Output language: English"
+      ;;
+  esac
+fi
+
+# Make scripts executable (Recursive)
+find ~/.claude/scripts -name "*.sh" -exec chmod +x {} \;
+find ~/.claude/scripts -name "*.js" -exec chmod +x {} \;
+
+echo "✅ Installation complete!"
+echo ""
+echo "Quick Start:"
+echo "  claude"
+echo "  > /plan Design a new feature"
+echo "  > /dplan Analyze complex architecture"
+echo "  > /do Implement the login page"
+echo ""
+echo "Language:"
+echo "  To change language: edit ~/.claude/rules/language.md"
+echo "  To use English: rm ~/.claude/rules/language.md"

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "claude-pro-minmax",
+  "version": "1.0.0",
+  "description": "Quota-first routing and safety layer for Claude Code Pro workflows.",
+  "author": "donghoon <move-hoon@users.noreply.github.com>",
+  "license": "MIT",
+  "type": "commonjs",
+  "bin": {
+    "cpmm": "bin/cpmm.js"
+  },
+  "files": [
+    "bin",
+    ".claude/CLAUDE.md",
+    ".claude/settings.json",
+    ".claude/settings.local.example.json",
+    ".claude/agents",
+    ".claude/commands",
+    ".claude/contexts",
+    ".claude/rules",
+    ".claude/sessions",
+    ".claude/skills",
+    ".claude.json",
+    ".claudeignore",
+    "install.sh",
+    "scripts",
+    "README.md",
+    "README.ko.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "help": "node bin/cpmm.js --help",
+    "doctor": "node bin/cpmm.js doctor",
+    "test": "node bin/cpmm.js --version && node bin/cpmm.js --help"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "claude-pro",
+    "cpmm",
+    "llmops",
+    "devtools",
+    "agentic-coding",
+    "cost-optimization"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/move-hoon/claude-pro-minmax.git"
+  },
+  "bugs": {
+    "url": "https://github.com/move-hoon/claude-pro-minmax/issues"
+  },
+  "homepage": "https://github.com/move-hoon/claude-pro-minmax#readme"
+}

package/scripts/README.ko.md

@@ -0,0 +1,150 @@
+> **[English Version](README.md)**
+
+# Scripts Directory
+
+## 목적
+"프롬프트"로 처리하는 것이 아니라 "코드"로 처리해야 하는 작업을 위한 결정론적 스크립트를 포함합니다.
+
+**철학:** "코드로 할 수 있는 것을 프롬프트하지 마세요."
+
+> **경로 안내:** 이 저장소에서는 `scripts/` 아래에 있으며, 설치 후 실행 경로는 `~/.claude/scripts/`입니다.
+
+## 유니버설 스크립트
+
+| 스크립트 | 목적 | 이점 |
+|--------|---------|---------|
+| `verify.sh` | 런타임 적응형 검증 (빌드+테스트+린트) | 결정론적 실행, 프롬프팅 불필요 |
+| `build.sh` | 런타임 적응형 빌드 | 런타임 자동 감지, 모델 추측 제거 |
+| `test.sh` | 런타임 적응형 테스트 | 런타임별 명령을 직접 실행 |
+| `lint.sh` | 런타임 적응형 린트 | 로컬 처리, 즉각적 결과 |
+
+## 런타임 감지 레이어
+
+```
+runtime/
+├── detect.sh         # 프로젝트 런타임 자동 감지 (JSON 출력)
+└── adapters/
+    ├── _interface.sh # 어댑터 계약 정의
+    ├── jvm.sh        # Java/Kotlin (Gradle/Maven)
+    ├── node.sh       # TypeScript/JS (npm/pnpm/yarn/bun)
+    ├── go.sh         # Go 모듈
+    ├── rust.sh       # Cargo
+    ├── python.sh     # pip/poetry/uv
+    ├── generic.sh    # Makefile 폴백
+    └── _template.sh  # 새 어댑터용 템플릿
+```
+
+## 유틸리티 스크립트
+
+| 스크립트 | 목적 | 이점 |
+|--------|---------|---------|
+| `scrub-secrets.js` | 텍스트에서 비밀 정보 제거 | 보안 + 토큰 노출 방지 |
+| `analyze-failures.sh` | 도구 실패 로그 분석 및 패턴 추출 | LLM 분석 전 로그 전처리 |
+| `create-branch.sh` | 결정론적 브랜치 생성 | 일관된 명명, 추측 불필요 |
+| `commit.sh` | Conventional Commit 형식 | 컨벤션 자동 적용 |
+| `snapshot.sh` | `/do` 명령의 원자적 롤백 | 결정론적 `git stash` + depth guard + 라벨 안전장치 |
+
+## Hooks 디렉토리
+
+| Hook 스크립트 | 이벤트 | 목적 | 실행 비용 |
+|-------------|-------|---------|------------|
+| `hooks/critical-action-check.sh` | PreToolUse | 위험한 명령 차단 | 로컬 (무료), 차단 시 메시지 |
+| `hooks/post-edit-format.sh` | PostToolUse | 편집된 파일 자동 포맷 | 로컬 (무료) |
+| `hooks/compact-suggest.sh` | PostToolUse | 3단계 컴팩션 경고 (25 권고 / 50 경고 / 75 위험) | 로컬 (무료), 티어당 ~30 토큰 |
+| `hooks/notification.sh` | Notification | 데스크톱 알림 | 로컬 (무료) |
+| `hooks/session-start.sh` | SessionStart | 환경변수 설정 + 예산 알림 + 세션 알림 | 로컬 (무료), 예산 컨텍스트 ~40 입력 토큰 |
+| `hooks/session-cleanup.sh` | SessionEnd | 세션에서 비밀 정보 제거 | 로컬 (무료) |
+| `hooks/pre-compact.sh` | PreCompact | 컴팩트 전 상태 저장 | 로컬 (무료) |
+| `hooks/retry-check.sh` | Stop | 연속 2회 실패 시 차단 (builder) | 로컬 (무료), 에스컬레이션 메시지 |
+| `hooks/stop-collect-context.sh` | Stop | 중단 시 실패 컨텍스트 수집 (선택) | 로컬 (무료) |
+| `hooks/readonly-check.sh` | PreToolUse | 읽기 전용 (reviewer) | 로컬 (무료), 차단 시 메시지 |
+| `hooks/tool-failure-log.sh` | PostToolUseFailure | 도구 실패 로깅 | 로컬 (무료) |
+
+**비용 설명:** 모든 Hook은 로컬에서 실행되어 API 호출이 없습니다. Hook이 Claude에게 메시지를 표시할 때만(예: 명령 차단, 컴팩션 제안) 해당 메시지가 입력 토큰을 소비하며, 이러한 메시지는 의도적으로 간결합니다.
+
+## scrub-secrets.js
+
+**목적:** 15개 이상의 비밀 패턴을 스캔하고 교체합니다.
+
+**사용법:**
+```bash
+# 입력 파이프
+cat session.md | node scrub-secrets.js > clean.md
+
+# /session-save에 의해 자동으로 사용됨
+```
+
+**감지된 패턴:**
+- OpenAI, Anthropic, Stripe, GitHub, AWS 키
+- 자격 증명이 포함된 데이터베이스 URL
+- JWT 토큰
+- 비밀번호/비밀 필드
+- 개인 키 (PEM)
+
+## create-branch.sh
+
+**목적:** 결정론적 브랜치 명명.
+
+**사용법:**
+```bash
+./create-branch.sh feature user-profile
+# 생성: feature/user-profile
+
+./create-branch.sh fix login-bug
+# 생성: fix/login-bug
+```
+
+**유형:** feature, fix, hotfix, refactor, chore
+
+## analyze-failures.sh
+
+**목적:** 축적된 도구 실패 로그를 분석하고 반복되는 패턴을 추출합니다.
+
+**사용법:**
+```bash
+# 최근 50개 실패 분석
+./analyze-failures.sh 50
+
+# /analyze-failures 명령어에 의해 사용됨
+# LLM 분석 전 로그 전처리
+```
+
+**출력:** LLM 분석을 위해 포맷된 실패 요약
+
+## commit.sh
+
+**목적:** Conventional Commit 형식 지정.
+
+**사용법:**
+```bash
+./commit.sh feat auth "add JWT refresh tokens"
+# 커밋: feat(auth): add JWT refresh tokens
+```
+
+**유형:** feat, fix, docs, style, refactor, perf, test, chore
+
+## 왜 스크립트인가요?
+
+| 접근 방식 | 실행 비용 | 신뢰성 | 속도 |
+|----------|----------|----------|-------|
+| Claude 프롬프트 | Quota 소비 | 모델 의존적 | API 왕복 필요 |
+| 쉘 스크립트 | 로컬 (무료) | 규칙 기반 반복 실행 가능 | 즉시 |
+
+**장점:** 스크립트는 결정론적 작업을 quota 소비 없이 로컬에서 처리하여, Claude가 창의적/추론 작업에 집중할 수 있게 합니다.
+
+## 커스텀 스크립트 추가
+
+```bash
+#!/bin/bash
+# my-script.sh - Description
+
+set -e  # 오류 발생 시 종료
+
+# 여기에 결정론적 로직 작성
+```
+
+실행 가능하게 만들기:
+```bash
+chmod +x scripts/my-script.sh
+# 설치 경로: chmod +x ~/.claude/scripts/my-script.sh
+```

package/scripts/README.md

@@ -0,0 +1,150 @@
+> **[한국어 버전](README.ko.md)**
+
+# Scripts Directory
+
+## Purpose
+Contains deterministic scripts for operations that shouldn't be "prompted" - they should be "coded".
+
+**Philosophy:** "Don't prompt what you can code."
+
+> **Path note:** In this repository, scripts live under `scripts/`. After installation, they run from `~/.claude/scripts/`.
+
+## Universal Scripts
+
+| Script | Purpose | Benefit |
+|--------|---------|---------|
+| `verify.sh` | Runtime-adaptive verification (build+test+lint) | Deterministic execution, no prompting needed |
+| `build.sh` | Runtime-adaptive build | Auto-detects runtime, eliminates model guessing |
+| `test.sh` | Runtime-adaptive test | Direct execution with runtime-specific commands |
+| `lint.sh` | Runtime-adaptive lint | Local processing, instant results |
+
+## Runtime Detection Layer
+
+```
+runtime/
+├── detect.sh         # Auto-detect project runtime (JSON output)
+└── adapters/
+    ├── _interface.sh # Adapter contract definition
+    ├── jvm.sh        # Java/Kotlin (Gradle/Maven)
+    ├── node.sh       # TypeScript/JS (npm/pnpm/yarn/bun)
+    ├── go.sh         # Go modules
+    ├── rust.sh       # Cargo
+    ├── python.sh     # pip/poetry/uv
+    ├── generic.sh    # Makefile fallback
+    └── _template.sh  # Template for new adapters
+```
+
+## Utility Scripts
+
+| Script | Purpose | Benefit |
+|--------|---------|---------|
+| `scrub-secrets.js` | Remove secrets from text | Security + no token exposure |
+| `analyze-failures.sh` | Analyze tool failure logs and extract patterns | Preprocesses logs before LLM analysis |
+| `create-branch.sh` | Deterministic branch creation | Consistent naming, no guessing |
+| `commit.sh` | Conventional commit format | Enforces convention automatically |
+| `snapshot.sh` | Atomic rollback for `/do` commands | Deterministic `git stash` with depth guard + label safety |
+
+## Hooks Directory
+
+| Hook Script | Event | Purpose | Execution Cost |
+|-------------|-------|---------|----------------|
+| `hooks/critical-action-check.sh` | PreToolUse | Block dangerous commands | Local (zero), blocking message if triggered |
+| `hooks/post-edit-format.sh` | PostToolUse | Auto-format edited files | Local (zero) |
+| `hooks/compact-suggest.sh` | PostToolUse | 3-tier compact warnings (25 advisory / 50 warning / 75 critical) | Local (zero), ~30 tokens per tier |
+| `hooks/notification.sh` | Notification | Desktop alerts | Local (zero) |
+| `hooks/session-start.sh` | SessionStart | Env setup + budget reminder + session notify | Local (zero), ~40 input tokens for budget context |
+| `hooks/session-cleanup.sh` | SessionEnd | Scrub secrets from sessions | Local (zero) |
+| `hooks/pre-compact.sh` | PreCompact | Save state before compaction | Local (zero) |
+| `hooks/retry-check.sh` | Stop | 2-retry cap (builder) | Local (zero), escalation message if triggered |
+| `hooks/stop-collect-context.sh` | Stop | Collect failure context on interruption (optional) | Local (zero) |
+| `hooks/readonly-check.sh` | PreToolUse | Read-only (reviewer) | Local (zero), blocking message if triggered |
+| `hooks/tool-failure-log.sh` | PostToolUseFailure | Log tool failures | Local (zero) |
+
+**Note:** Hook execution itself is free (runs locally). Only their output messages (when displayed to Claude) consume minimal input tokens.
+
+## scrub-secrets.js
+
+**Purpose:** Scan and replace 15+ secret patterns.
+
+**Usage:**
+```bash
+# Pipe input
+cat session.md | node scrub-secrets.js > clean.md
+
+# Used automatically by /session-save
+```
+
+**Patterns detected:**
+- OpenAI, Anthropic, Stripe, GitHub, AWS keys
+- Database URLs with credentials
+- JWT tokens
+- Password/secret fields
+- Private keys (PEM)
+
+## create-branch.sh
+
+**Purpose:** Deterministic branch naming.
+
+**Usage:**
+```bash
+./create-branch.sh feature user-profile
+# Creates: feature/user-profile
+
+./create-branch.sh fix login-bug
+# Creates: fix/login-bug
+```
+
+**Types:** feature, fix, hotfix, refactor, chore
+
+## analyze-failures.sh
+
+**Purpose:** Analyze accumulated tool failure logs and extract recurring patterns.
+
+**Usage:**
+```bash
+# Analyze last 50 failures
+./analyze-failures.sh 50
+
+# Used by /analyze-failures command
+# Preprocesses logs before LLM analysis
+```
+
+**Output:** Formatted failure summary ready for LLM analysis
+
+## commit.sh
+
+**Purpose:** Conventional commit formatting.
+
+**Usage:**
+```bash
+./commit.sh feat auth "add JWT refresh tokens"
+# Commits: feat(auth): add JWT refresh tokens
+```
+
+**Types:** feat, fix, docs, style, refactor, perf, test, chore
+
+## Why Scripts?
+
+| Approach | Execution Cost | Reliability | Speed |
+|----------|---------------|----------|-------|
+| Prompt Claude | Consumes quota | Model-dependent | Requires API round-trip |
+| Shell script | Local (zero) | Rule-based and repeatable | Instant |
+
+**Advantage:** Scripts handle deterministic operations locally without consuming quota, freeing Claude to focus on creative/reasoning tasks.
+
+## Adding Custom Scripts
+
+```bash
+#!/bin/bash
+# my-script.sh - Description
+
+set -e  # Exit on error
+
+# Your deterministic logic here
+```
+
+Make executable:
+```bash
+chmod +x scripts/my-script.sh
+# Installed path: chmod +x ~/.claude/scripts/my-script.sh
+```

package/scripts/analyze-failures.sh

@@ -0,0 +1,145 @@
+#!/bin/bash
+# analyze-failures.sh
+# Failure log analysis and pattern extraction
+# Usage: bash scripts/analyze-failures.sh [limit]
+
+set -euo pipefail
+
+LIMIT="${1:-50}"
+LOG_FILE="$HOME/.claude/logs/tool-failures.log"
+
+if [ ! -f "$LOG_FILE" ]; then
+  echo "✅ No failure logs found. Your tools are working perfectly!"
+  exit 0
+fi
+
+TOTAL_COUNT=$(wc -l < "$LOG_FILE" | tr -d ' ')
+
+if [ "$TOTAL_COUNT" -eq 0 ]; then
+  echo "✅ No failure logs found. Your tools are working perfectly!"
+  exit 0
+fi
+
+echo "## Failure Analysis"
+echo ""
+echo "**Total failures logged**: $TOTAL_COUNT"
+echo "**Analyzing last**: $LIMIT"
+echo ""
+
+# Extract and analyze the last N entries
+FAILURES=$(tail -"$LIMIT" "$LOG_FILE")
+
+echo "### Top Failures"
+echo ""
+
+# Group errors by tool and calculate frequency
+echo "$FAILURES" | awk -F'|' '
+{
+  # Extract tool name from first field (after "Tool: ")
+  tool = $1
+  sub(/.*Tool: /, "", tool)
+  gsub(/^[[:space:]]+|[[:space:]]+$/, "", tool)
+
+  # Extract error from second field (after "Error: ")
+  error = $2
+  sub(/.*Error: /, "", error)
+  gsub(/^[[:space:]]+|[[:space:]]+$/, "", error)
+
+  # Normalize error messages to find patterns
+  if (error ~ /old_string.*not found/) {
+    error = "old_string not found"
+  } else if (error ~ /pattern.*syntax/) {
+    error = "pattern syntax error"
+  } else if (error ~ /permission denied/i) {
+    error = "permission denied"
+  } else if (error ~ /file not found|no such file/i) {
+    error = "file not found"
+  } else if (error ~ /timeout/i) {
+    error = "timeout"
+  } else if (error ~ /exceeds maximum.*size/) {
+    error = "file size exceeds limit"
+  }
+
+  # Store tool and error separately
+  key = NR
+  tool_map[key] = tool
+  error_map[key] = error
+
+  # Count occurrences
+  combo = tool ":::" error
+  count[combo]++
+  tool_count[tool]++
+}
+END {
+  # Create sorted array by count
+  n = 0
+  for (c in count) {
+    sorted[n] = count[c] ":::" c
+    n++
+  }
+
+  # Bubble sort by count (descending)
+  for (i = 0; i < n; i++) {
+    for (j = i + 1; j < n; j++) {
+      split(sorted[i], a, ":::")
+      split(sorted[j], b, ":::")
+      if (a[1] + 0 < b[1] + 0) {
+        temp = sorted[i]
+        sorted[i] = sorted[j]
+        sorted[j] = temp
+      }
+    }
+  }
+
+  # Print top 10
+  limit = (n < 10) ? n : 10
+  for (i = 0; i < limit; i++) {
+    split(sorted[i], parts, ":::")
+    cnt = parts[1]
+    tool = parts[2]
+    err = parts[3]
+    printf "%d. **%s**: \"%s\" (%d times)\n", i+1, tool, err, cnt
+  }
+
+  print ""
+  print "### Most Problematic Tools"
+  print ""
+
+  # Create sorted array for tools
+  m = 0
+  for (t in tool_count) {
+    tool_sorted[m] = tool_count[t] ":::" t
+    m++
+  }
+
+  # Bubble sort by tool count (descending)
+  for (i = 0; i < m; i++) {
+    for (j = i + 1; j < m; j++) {
+      split(tool_sorted[i], a, ":::")
+      split(tool_sorted[j], b, ":::")
+      if (a[1] + 0 < b[1] + 0) {
+        temp = tool_sorted[i]
+        tool_sorted[i] = tool_sorted[j]
+        tool_sorted[j] = temp
+      }
+    }
+  }
+
+  # Print top 5 tools
+  tool_limit = (m < 5) ? m : 5
+  for (i = 0; i < tool_limit; i++) {
+    split(tool_sorted[i], parts, ":::")
+    printf "- **%s**: %d failures\n", parts[2], parts[1]
+  }
+}'
+
+echo ""
+echo "---"
+echo ""
+echo "💡 **Recommendations**:"
+echo ""
+echo "- Review frequent failures and update your approach"
+echo "- Consider saving learned patterns with \`/learn [pattern]\`"
+echo "- Use \`/do-sonnet\` or \`/plan\` for complex tasks to reduce trial-and-error"
+echo ""
+echo "📝 **Clear logs**: \`rm $LOG_FILE\`"

package/scripts/build.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+# build.sh - Universal Build
+# Delegates to runtime-specific adapter
+set -euo pipefail
+
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-.}"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+RUNTIME_DIR="$SCRIPT_DIR/runtime"
+
+# Detect runtime
+RUNTIME=$("$RUNTIME_DIR/detect.sh" "$@")
+
+# Parse JSON - prefer jq, fallback to bash
+parse_json() {
+  local key="$1"
+  if command -v jq &>/dev/null; then
+    echo "$RUNTIME" | jq -r ".$key"
+  else
+    echo "$RUNTIME" | sed 's/.*"'"$key"'":"\([^"]*\)".*/\1/'
+  fi
+}
+
+ADAPTER=$(parse_json adapter)
+RUNTIME_NAME=$(parse_json runtime)
+TOOL_NAME=$(parse_json tool)
+
+echo "🔍 Detected: $RUNTIME_NAME ($TOOL_NAME)"
+
+# Source adapter
+source "$RUNTIME_DIR/adapters/$ADAPTER"
+
+# Execute
+echo "🔨 Building..."
+adapter_build