claude-pro-minmax 1.0.0

package/.claude/CLAUDE.md

@@ -0,0 +1,60 @@
+# Claude Code Pro Plan Kernel
+# IMMUTABLE KERNEL
+
+## IDENTITY
+Pro Plan constraints. Every message = quota. Optimize for Pass@1.
+
+## PRINCIPLES
+
+### Message Economy
+- Batch operations in single response, no round-trips
+- Assume → Execute → User corrects
+- No preamble: Skip "I'll help you..." → Execute immediately
+
+### Value Per Message
+- Output costs 5x Input — keep agent responses short
+- `CLI --json | jq` > MCP tools (filtered output reduces tokens)
+- `mgrep` > `grep` (faster, less output)
+- Load context: `/load-context [type]` (Read tool)
+- **Learned Patterns**: Always index `~/.claude/skills/learned/*.md` at session start to reuse previous insights and prevent rework.
+
+### Pass@1 + 2-Retry Cap
+- Internal verification before output
+- Maximum 2 retries
+- 2 failures → STOP + Escalate
+
+### Code > Prompt
+- Deterministic logic → Scripts
+- Project Metadata → Always use `~/.claude/scripts/runtime/detect.sh` for runtime/build tool detection. Never read build files (pom.xml, build.gradle, package.json, tsconfig.json) manually for this purpose.
+- Filenames, branches → Scripts, not reasoning
+
+## VERIFICATION
+
+| Change Type | Verification |
+|-------------|-------------|
+| Config, Docs, Styles (<5 lines) | Syntax check only |
+| Logic changes | `~/.claude/scripts/verify.sh` |
+| New features | `~/.claude/scripts/verify.sh` + tests |
+
+⚠️ Never call build tools directly:
+- ❌ `npm test`, `./gradlew test`, `cargo test`
+- ✅ `~/.claude/scripts/verify.sh`
+
+## AGENTS
+
+| Role | Agent | Model | Questions |
+|------|-------|-------|-----------|
+| Quick Planning | @planner | Sonnet | ≤3 (with defaults) |
+| Deep Planning (w/ Research) | @dplanner | Sonnet | Unlimited |
+| Implementation | @builder | Haiku | None → Escalate |
+| Quality Review | @reviewer | Haiku | None → Escalate |
+
+@dplanner tools: `sequential-thinking`, `perplexity`, `context7`
+
+## DEFAULT WORKFLOW
+- Simple (1-3 files): `/do` — batch plan+build+verify in one shot
+- Medium (4-5 files): `/plan` — @planner → @builder sequential
+- Complex (5+ files, research): `/dplan` — @dplanner → @planner → @builder
+
+## SECRETS
+Never persist to session files: `sk-*`, `ghp_*`, `AKIA*`, JWT, passwords

package/.claude/agents/README.ko.md

@@ -0,0 +1,210 @@
+> **[English Version](README.md)**
+
+# Agents Directory
+
+## 목적
+모델 최적화와 역할 기반 작업 분담을 위한 서브에이전트 정의를 포함합니다.
+
+> **경로 안내:** 프롬프트 예시에는 설치 경로(`~/.claude/...`)가 사용됩니다. 이 저장소 기준 경로는 `./.claude/...`, `./scripts/...`입니다.
+
+## 내용
+
+| 에이전트 | 모델 | 역할 | 도구 | 질문 |
+|---------|------|------|------|------|
+| `planner.md` | Sonnet 4.6 | 아키텍처 및 설계 결정 | Read, Glob, Grep (읽기 전용) | ≤3 (기본값 포함) |
+| `dplanner.md` | Sonnet 4.6 | 연구 기반 심층 계획 | sequential-thinking, perplexity, context7, Read, Glob, Grep | 무제한 |
+| `builder.md` | Haiku 4.5 | 구현 (2-retry cap) | Read, Write, Edit, Bash, Glob, Grep | 없음 → 에스컬레이션 |
+| `reviewer.md` | Haiku 4.5 | 코드 검토 및 QA | Read, Glob, Grep (읽기 전용, 강제) | 없음 → 에스컬레이션 |
+
+## 각 에이전트 사용 시점
+
+### @planner (빠른 계획)
+**사용 시점:**
+- 5개 이상의 파일에 영향을 미치는 작업
+- 아키텍처 결정이 필요한 경우
+- 요구사항이 불명확하여 명확화가 필요한 경우
+- 새로운 기능 구현
+
+**실행:** `/plan [작업]`
+
+**출력:** 아키텍처 설계 + 작업 분해 (코드 없음)
+**출력 예산:** 작업당 최대 1문장, 파일 경로만 (코드 미리보기 없음)
+
+### @dplanner (심층 계획)
+**사용 시점:**
+- 깊은 분석이 필요한 복잡한 아키텍처 문제
+- 기술 스택 평가
+- 경쟁 상태(race condition)나 데드락 디버깅
+- 연구가 많이 필요한 결정 (최신 문서/아티클 필요)
+
+**실행:** `/dplan [작업]`
+
+**기능:**
+- `sequential-thinking`: 다단계 논리 검증
+- `perplexity`: 웹 연구 (블로그, 포럼, 최신 아티클)
+- `context7`: 라이브러리 문서 조회
+
+**출력 예산:** 최대 60줄 (코드 블록 제외). 출처 + 출처당 1줄 인사이트만.
+
+### @builder (구현)
+**사용 시점:**
+- 계획 후 모든 코딩 작업
+- 명확히 정의된 간단한 작업 (직접 `/do`)
+- 명확한 재현이 가능한 버그 수정
+
+**실행:** `/plan` 위임, `/dplan` 위임, 직접 `@builder [작업]` 호출
+
+**프로토콜:**
+- 최대 2회 재시도 → 실패 시 에스컬레이션
+- `~/.claude/scripts/verify.sh` 사용 (런타임 자동 감지)
+- 질문 불가 (가정하거나 에스컬레이션)
+
+**출력 예산:** 성공 요약 MAX 5줄 (파일 목록 + 검증 결과만). 에스컬레이션 MAX 8줄. 전체 코드 블록 없이 file:line 참조만.
+
+**롤백 프로토콜:**
+- `/do*` 경유 시: `~/.claude/scripts/snapshot.sh push`로 depth guard 포함 라벨 스냅샷 생성
+- 성공 시: `~/.claude/scripts/snapshot.sh drop` (라벨 확인, 스냅샷 없으면 안전한 no-op)
+- 실패 시: `~/.claude/scripts/snapshot.sh pop` (라벨 확인, 없으면 `git checkout .` 폴백)
+- dirty state로 인한 수동 정리 턴 증가를 방지 (2-4 메시지 절약은 추정치)
+
+### @reviewer (코드 검토)
+**사용 시점:**
+- 구현 후 품질 체크
+- 보안 감사
+- 충돌 감지
+- 타입 안전성 검증
+
+**실행:** `/review [대상]`
+
+**카테고리:** SEC (보안), TYPE (타입 안전성), PERF (성능), STYLE (컨벤션), LOGIC (논리 오류), TEST (테스트 누락)
+
+**출력 예산:** PASS = 1줄만. FAIL = MAX 30줄 (심각도 상위 5개 이슈, file:line 참조만).
+
+## 워크플로우 (Detailed Flowchart)
+
+```mermaid
+flowchart TD
+    %% Initial Request
+    Start([User]) --> Cmd{Command?}
+    
+    %% Branch 1: Planning (Requires Approval)
+    subgraph Planning ["Phase 1: Planning"]
+        direction TB
+        Cmd -->|/plan| Planner[/"@planner (Sonnet 4.6)"/]
+        Cmd -->|/dplan| DPlanner[/"Deep Planner"/]
+        Planner & DPlanner --> Spec[Build Spec]
+    end
+    
+    %% Human-in-the-loop Logic (Validated via plan.md line 24)
+    Spec --> UserAppr{User\nApprove?}
+    UserAppr -- No --> Cmd
+    
+    %% Branch 2a: /plan Execution (Approved → @builder)
+    subgraph Execution ["Phase 2: Implementation"]
+        direction TB
+        UserAppr -- Yes --> Builder[/"@builder (Haiku 4.5)"/]
+
+        %% Safe Execution Loop
+        Builder --> Verify{Verify?}
+        Verify -- "Retry (<2)" --> Builder
+    end
+
+    %% Branch 2b: /do Direct Execution (Session Model)
+    Cmd -->|/do| Snap["git stash"]
+    Snap --> Exec["Session Model (Direct)"]
+    Exec --> VerifyDo{Verify?}
+    VerifyDo -- "Retry (<2)" --> Exec
+    VerifyDo -->|Success| DropDo["git stash drop"]
+    DropDo --> Done
+    VerifyDo -- "Fail (x2)" --> PopDo["git stash pop"]
+    PopDo --> EscalateDo(STOP & Suggest)
+
+    %% Branch 3: Escalation (Model Upgrade)
+    Verify -- "Fail (x2)" --> Pop["git stash pop"]
+    Pop --> Escalate(STOP & Suggest)
+    Escalate -.->|"/do-sonnet"| SonnetExec["Sonnet 4.6 (Direct)"]
+    SonnetExec --> Verify
+
+    %% Branch 4: Completion
+    Verify -->|Success| Drop["git stash drop"]
+    Drop --> Reviewer[/"@reviewer"/]
+    Reviewer --> Done([Complete])
+
+    %% Styling
+    classDef agent fill:#e1f5fe,stroke:#01579b,stroke-width:2px;
+    classDef logic fill:#fff9c4,stroke:#fbc02d,stroke-width:2px;
+    classDef term fill:#e0f2f1,stroke:#00695c,stroke-width:2px;
+    classDef fail fill:#ffebee,stroke:#c62828,stroke-width:2px,stroke-dasharray: 5 5;
+    classDef direct fill:#fff9c4,stroke:#f9a825,stroke-width:2px;
+
+    class Planner,DPlanner,Builder,Reviewer,Snap,Pop,Drop,SnapDo,PopDo,DropDo agent;
+    class Cmd,Verify,VerifyDo,UserAppr logic;
+    class Start,Done,Escalate,EscalateDo term;
+    class Exec,SonnetExec direct;
+```
+
+
+
+## 설계 결정
+
+| 결정 | 근거 |
+|------|------|
+| 4개 에이전트 (vs. Affaan 13개) | Pro Plan 제약: 서브에이전트 호출마다 quota 소비. 역할 통합으로 API 오버헤드 감소하면서도 기능 유지 |
+| @builder와 @reviewer에 Haiku 4.5 사용 | 비용 최적화: 구현과 검토는 Sonnet 수준의 추론이 불필요. Haiku 4.5는 5배 저렴 ($1 vs $5 /MTok input) |
+| @planner와 @dplanner에 Sonnet 4.6 사용 | 아키텍처 결정은 추론 능력 필요. Pro Plan에서 Sonnet 4.6가 Opus 4.6보다 가성비 우수 |
+| @builder 2-retry cap | Quota 소진 방지. 2회 실패 → Sonnet 4.6/Opus 4.6으로 에스컬레이션 또는 @planner로 재설계 |
+| @reviewer 읽기 전용 강제 | Hook 기반 차단(`readonly-check.sh`). 검토 중 실수로 수정하는 것 방지 |
+| @dplanner에 MCP 도구 제공 | 연구가 많은 작업은 MCP 오버헤드 정당화 가능. `sequential-thinking` + `perplexity` + `context7`로 실패 없는 계획 가능 |
+| 에이전트별 출력 예산 | Output은 Input의 5배 비용 (API 가격). 엄격한 예산: builder 5줄, reviewer 1줄 PASS / 30줄 FAIL, dplanner 60줄, planner 1문장/작업 |
+| @builder 원자적 롤백 | `~/.claude/scripts/snapshot.sh`가 depth guard + 라벨 확인 포함 `git stash` 처리. 무관한 사용자 stash pop 방지. 실패 시 `pop` (또는 clean tree에서 `git checkout .`) → 즉시 에스컬레이션 가능한 깨끗한 상태. 실패당 2-4 메시지 절약은 추정치이며, API 비용은 0 |
+
+## 커스텀 에이전트 추가
+
+새로운 `.md` 파일을 **frontmatter**와 함께 생성하세요 (필수):
+
+```markdown
+---
+name: my-agent
+description: 이 에이전트를 언제 사용하는지
+model: haiku | sonnet | opus
+permissionMode: plan | acceptEdits
+tools: Read, Write, Edit, Bash, Glob, Grep
+disallowedTools: Write, Edit
+hooks:
+  Stop:
+    - hooks:
+        - type: command
+          command: "~/.claude/scripts/hooks/my-hook.sh"
+          timeout: 5
+---
+
+# My Agent
+
+## 역할
+이 에이전트가 하는 일.
+
+## 규칙
+- 규칙 1
+- 규칙 2
+
+## 출력 형식
+\`\`\`
+예상 출력
+\`\`\`
+```
+
+### Frontmatter 필드
+
+| 필드 | 필수 | 설명 |
+|------|:----:|------|
+| `name` | 예 | 에이전트 식별자 (소문자, 하이픈) |
+| `description` | 예 | 언제 사용하는지 (Task tool 자동 선택용) |
+| `model` | 예 | `haiku`, `sonnet`, 또는 `opus` |
+| `permissionMode` | 아니오 | `plan` (읽기 전용) 또는 `acceptEdits` (쓰기 권한) |
+| `tools` | 아니오 | 허용 도구 (화이트리스트) |
+| `disallowedTools` | 아니오 | 차단 도구 (블랙리스트) |
+| `hooks` | 아니오 | 라이프사이클 훅 (`PreToolUse`, `PostToolUse`, `Stop`) |
+
+### 위치
+- 전역: `~/.claude/agents/` (모든 프로젝트)
+- 프로젝트: `./.claude/agents/` (이 프로젝트만)

package/.claude/agents/README.md

@@ -0,0 +1,210 @@
+> **[한국어 버전](README.ko.md)**
+
+# Agents Directory
+
+## Purpose
+Contains sub-agent definitions for role-based task delegation with model optimization.
+
+> **Path note:** Prompt snippets use installed paths (`~/.claude/...`). In this repository, equivalent source paths are `./.claude/...` and `./scripts/...`.
+
+## Contents
+
+| Agent | Model | Role | Tools | Questions |
+|-------|-------|------|-------|-----------|
+| `planner.md` | Sonnet 4.6 | Architecture & design decisions | Read, Glob, Grep (read-only) | ≤3 (with defaults) |
+| `dplanner.md` | Sonnet 4.6 | Deep planning with research | sequential-thinking, perplexity, context7, Read, Glob, Grep | Unlimited |
+| `builder.md` | Haiku 4.5 | Implementation (2-retry cap) | Read, Write, Edit, Bash, Glob, Grep | None → Escalate |
+| `reviewer.md` | Haiku 4.5 | Code review & QA | Read, Glob, Grep (read-only, enforced) | None → Escalate |
+
+## When to Use Each Agent
+
+### @planner (Quick Planning)
+**Use for:**
+- Tasks affecting 5+ files
+- Architectural decisions needed
+- Unclear requirements requiring clarification
+- New feature implementation
+
+**Triggers:** `/plan [task]`
+
+**Output:** Architecture design + task breakdown (no code)
+**Output Budget:** Max 1 sentence per task, file paths only (no code previews)
+
+### @dplanner (Deep Planning)
+**Use for:**
+- Complex architectural problems requiring deep analysis
+- Technology stack evaluation
+- Debugging race conditions or deadlocks
+- Research-heavy decisions (needs latest docs/articles)
+
+**Triggers:** `/dplan [task]`
+
+**Capabilities:**
+- `sequential-thinking`: Multi-step logic verification
+- `perplexity`: Web research (blogs, forums, latest articles)
+- `context7`: Library documentation lookup
+
+**Output Budget:** Max 60 lines (code blocks excluded). Cite source + 1-line insight per source.
+
+### @builder (Implementation)
+**Use for:**
+- All coding tasks after planning
+- Simple well-defined tasks (direct `/do`)
+- Bug fixes with clear reproduction
+
+**Triggers:** `/plan` delegation, `/dplan` delegation, direct `@builder [task]` call
+
+**Protocol:**
+- Maximum 2 retries → Escalate on failure
+- Uses `~/.claude/scripts/verify.sh` (runtime-adaptive)
+- No questions allowed (assumes or escalates)
+
+**Output Budget:** Success summary MAX 5 lines (file list + verification only). Escalation MAX 8 lines. No full code blocks — file:line references only.
+
+**Rollback Protocol:**
+- Via `/do*`: `~/.claude/scripts/snapshot.sh push` creates labeled stash with depth guard
+- On success: `~/.claude/scripts/snapshot.sh drop` (label-checked, safe no-op if no snapshot)
+- On failure: `~/.claude/scripts/snapshot.sh pop` (label-checked, falls back to `git checkout .`)
+- Prevents dirty state that can add extra manual cleanup turns (2-4 messages is an estimate)
+
+### @reviewer (Code Review)
+**Use for:**
+- Post-implementation quality check
+- Security audit
+- Conflict detection
+- Type safety verification
+
+**Triggers:** `/review [target]`
+
+**Categories:** SEC (Security), TYPE (Type safety), PERF (Performance), STYLE (Convention), LOGIC (Logic error), TEST (Missing test)
+
+**Output Budget:** PASS = 1 line only. FAIL = MAX 30 lines (top 5 issues by severity, file:line references only).
+
+## Workflow (Detailed Flowchart)
+
+```mermaid
+flowchart TD
+    %% Initial Request
+    Start([User]) --> Cmd{Command?}
+    
+    %% Branch 1: Planning (Requires Approval)
+    subgraph Planning ["Phase 1: Planning"]
+        direction TB
+        Cmd -->|/plan| Planner[/"@planner (Sonnet 4.6)"/]
+        Cmd -->|/dplan| DPlanner[/"Deep Planner"/]
+        Planner & DPlanner --> Spec[Build Spec]
+    end
+    
+    %% Human-in-the-loop Logic (Validated via plan.md line 24)
+    Spec --> UserAppr{User\nApprove?}
+    UserAppr -- No --> Cmd
+    
+    %% Branch 2a: /plan Execution (Approved → @builder)
+    subgraph Execution ["Phase 2: Implementation"]
+        direction TB
+        UserAppr -- Yes --> Builder[/"@builder (Haiku 4.5)"/]
+
+        %% Safe Execution Loop
+        Builder --> Verify{Verify?}
+        Verify -- "Retry (<2)" --> Builder
+    end
+
+    %% Branch 2b: /do Direct Execution (Session Model)
+    Cmd -->|/do| Snap["git stash"]
+    Snap --> Exec["Session Model (Direct)"]
+    Exec --> VerifyDo{Verify?}
+    VerifyDo -- "Retry (<2)" --> Exec
+    VerifyDo -->|Success| DropDo["git stash drop"]
+    DropDo --> Done
+    VerifyDo -- "Fail (x2)" --> PopDo["git stash pop"]
+    PopDo --> EscalateDo(STOP & Suggest)
+
+    %% Branch 3: Escalation (Model Upgrade)
+    Verify -- "Fail (x2)" --> Pop["git stash pop"]
+    Pop --> Escalate(STOP & Suggest)
+    Escalate -.->|"/do-sonnet"| SonnetExec["Sonnet 4.6 (Direct)"]
+    SonnetExec --> Verify
+
+    %% Branch 4: Completion
+    Verify -->|Success| Drop["git stash drop"]
+    Drop --> Reviewer[/"@reviewer"/]
+    Reviewer --> Done([Complete])
+
+    %% Styling
+    classDef agent fill:#e1f5fe,stroke:#01579b,stroke-width:2px;
+    classDef logic fill:#fff9c4,stroke:#fbc02d,stroke-width:2px;
+    classDef term fill:#e0f2f1,stroke:#00695c,stroke-width:2px;
+    classDef fail fill:#ffebee,stroke:#c62828,stroke-width:2px,stroke-dasharray: 5 5;
+    classDef direct fill:#fff9c4,stroke:#f9a825,stroke-width:2px;
+
+    class Planner,DPlanner,Builder,Reviewer,Snap,Pop,Drop,SnapDo,PopDo,DropDo agent;
+    class Cmd,Verify,VerifyDo,UserAppr logic;
+    class Start,Done,Escalate,EscalateDo term;
+    class Exec,SonnetExec direct;
+```
+
+
+
+## Design Decisions
+
+| Decision | Rationale |
+|----------|-----------|
+| 4 agents (vs. Affaan's 13) | Pro Plan constraint: Each sub-agent invocation costs quota. Role consolidation reduces API overhead while maintaining capability |
+| Haiku 4.5 for @builder and @reviewer | Cost optimization: Implementation and review don't need Sonnet-level reasoning. Haiku 4.5 is 5x cheaper ($1 vs $5 /MTok input) |
+| Sonnet 4.6 for @planner and @dplanner | Architecture decisions need reasoning capability. Sonnet 4.6 balances cost/performance better than Opus 4.6 on Pro Plan |
+| @builder 2-retry cap | Prevents quota drain. Failed twice → Escalate to Sonnet 4.6/Opus 4.6 or @planner for re-design |
+| @reviewer read-only enforcement | Hook-based blocking (`readonly-check.sh`). Prevents accidental modifications during review |
+| @dplanner with MCP tools | Research-heavy tasks justify MCP overhead. `sequential-thinking` + `perplexity` + `context7` enable fail-proof planning |
+| Output Budget per agent | Output costs 5x Input (API pricing). Strict budgets: builder 5 lines, reviewer 1 line PASS / 30 lines FAIL, dplanner 60 lines, planner 1 sentence/task |
+| @builder atomic rollback | `~/.claude/scripts/snapshot.sh` handles `git stash` with depth guard + label check before `/do` execution. Prevents popping unrelated user stashes. Failure triggers `pop` (or `git checkout .` on clean tree) → clean state for immediate escalation. Estimated savings: 2-4 messages per failure, zero API cost |
+
+## Adding Custom Agents
+
+Create a new `.md` file with **frontmatter** (required):
+
+```markdown
+---
+name: my-agent
+description: When to use this agent
+model: haiku | sonnet | opus
+permissionMode: plan | acceptEdits
+tools: Read, Write, Edit, Bash, Glob, Grep
+disallowedTools: Write, Edit
+hooks:
+  Stop:
+    - hooks:
+        - type: command
+          command: "~/.claude/scripts/hooks/my-hook.sh"
+          timeout: 5
+---
+
+# My Agent
+
+## Role
+What this agent does.
+
+## Rules
+- Rule 1
+- Rule 2
+
+## Output Format
+\`\`\`
+Expected output
+\`\`\`
+```
+
+### Frontmatter Fields
+
+| Field | Required | Description |
+|-------|:--------:|-------------|
+| `name` | Yes | Agent identifier (lowercase, hyphens) |
+| `description` | Yes | When to use this agent (for Task tool auto-selection) |
+| `model` | Yes | `haiku`, `sonnet`, or `opus` |
+| `permissionMode` | No | `plan` (read-only) or `acceptEdits` (write access) |
+| `tools` | No | Allowed tools (whitelist) |
+| `disallowedTools` | No | Blocked tools (blacklist) |
+| `hooks` | No | Lifecycle hooks (`PreToolUse`, `PostToolUse`, `Stop`) |
+
+### Location
+- Global: `~/.claude/agents/` (all projects)
+- Project: `./.claude/agents/` (this project only)

package/.claude/agents/builder.md

@@ -0,0 +1,96 @@
+---
+name: builder
+description: Implementation specialist with 2-retry cap. No questions allowed. Use proactively for coding tasks.
+model: haiku
+permissionMode: acceptEdits
+tools: Read, Write, Edit, Bash, Glob, Grep
+hooks:
+  Stop:
+    - hooks:
+        - type: command
+          command: "~/.claude/scripts/hooks/retry-check.sh"
+          timeout: 5
+---
+
+# Builder Agent (Haiku)
+
+You are the IMPLEMENTER. No questions. Maximum 2 retries.
+
+## Build Tool Warning
+
+⚠️ DO NOT call build tools directly:
+- ❌ `./gradlew test`, `npm test`, `cargo test`, `go test`, `pytest`
+- ✅ `~/.claude/scripts/verify.sh`, `~/.claude/scripts/build.sh`, `~/.claude/scripts/test.sh`
+
+Direct calls bypass runtime detection and waste messages on language-specific reasoning.
+
+## Retry Cap Protocol
+```
+Attempt 1 → FAIL → Attempt 2 → FAIL → STOP + Escalate
+```
+NEVER more than 2 attempts.
+
+## Verification (Runtime-Adaptive)
+
+Run: `~/.claude/scripts/verify.sh`
+- Automatically detects project type (JVM, Node, Go, Rust, Python)
+- Runs appropriate build tool
+- Returns unified exit code
+
+| Change Type | Verification |
+|-------------|--------------|
+| Config, styles, docs | Syntax check only |
+| Logic changes | `~/.claude/scripts/verify.sh` |
+| New features | `~/.claude/scripts/verify.sh` + coverage |
+
+DO NOT hardcode: npm, gradle, cargo, go, pip, poetry
+DO: Use ~/.claude/scripts/verify.sh, ~/.claude/scripts/build.sh, ~/.claude/scripts/test.sh
+
+## Output Format (Success)
+```
+✓ src/file.ext (created, 87 lines)
+✓ src/file.test.ext (created, 124 lines)
+
+Verification: ~/.claude/scripts/verify.sh ✓
+```
+
+## Output Format (Escalation)
+```
+⚠️ Implementation failed after 2 attempts — state rolled back
+
+Last error: [error message]
+Rollback: ~/.claude/scripts/snapshot.sh pop ✓
+
+Options:
+1. /do-sonnet [task]
+2. @planner [task]
+3. @dplanner [task]
+4. Provide more context
+```
+
+## CLI Sanitization
+Always use JSON output + jq:
+```bash
+gh pr list --json number,title | jq -c '.[]'
+psql -t -A -c "SELECT..."
+```
+
+## Output Budget (Mandatory)
+- Success summary: **MAX 5 lines** (file list + verification result only)
+- Escalation report: **MAX 8 lines** (error + options)
+- NEVER include full code blocks in response to parent
+- NEVER echo file contents back — only report file:line references
+- Code diffs are excluded from line count but should use unified diff format (max 20 lines)
+
+## Rules
+- NO questions - use assumptions or escalate
+- MAX 2 retries - then stop
+- Use mgrep, not grep
+- Sanitize CLI output
+
+## Rollback Protocol
+All logic handled by `~/.claude/scripts/snapshot.sh` (deterministic script, not model reasoning):
+- **On success**: `~/.claude/scripts/snapshot.sh drop` — label-checks top stash, safe no-op if not ours
+- **On failure**: `~/.claude/scripts/snapshot.sh pop` — label-checks top stash, falls back to `git checkout .`
+- Script uses `cpmm-` prefix in stash labels to prevent popping unrelated user stashes
+- NEVER run raw `git stash pop/drop` directly — always use the script

package/.claude/agents/dplanner.md

@@ -0,0 +1,58 @@
+---
+name: dplanner
+description: Deep Planner - Architecture specialist with extended thinking and research capabilities. Use for high-complexity architectural design.
+model: sonnet
+permissionMode: plan
+tools: sequential-thinking, perplexity, context7, Read, Glob, Grep
+disallowedTools: Write, Edit, Bash
+---
+
+# dplanner Agent (@dplanner)
+
+You are the **DEEP PLANNER**. You solve the hardest architectural problems.
+You prioritize **Correctness** and **Completeness** over speed.
+
+## Core Capabilities
+1.  **Sequential Thinking**: Use `sequential-thinking` to break down complex logic into verified steps.
+2.  **Web Research**: Use `perplexity` for comprehensive web research (blogs, forums, latest articles).
+3.  **Documentation Lookup**: Use `context7` to fetch full documentation for libraries.
+
+## When to Use
+- Designing large-scale refactoring.
+- Debugging complex race conditions or deadlocks.
+- Evaluating new technology stacks (e.g., "Is Library X compatible with Y?").
+
+## Workflow
+1.  **Analyze**: Break down the user request.
+2.  **Think**: Use `sequential-thinking` to formulate a hypothesis or plan.
+3.  **Research**: Use `perplexity` for web research, `context7` for library docs.
+4.  **Verify**: Cross-check your plan against constraints.
+5.  **Output**: Deliver a comprehensive, fail-proof plan.
+
+## Output Format
+```markdown
+## Deep Plan: [Topic]
+
+### 1. Analysis (Thinking Process)
+- Initial Hypothesis: ...
+- Validated Logic: ...
+
+### 2. Research Findings
+- Source: [Context7/Docs]
+- Key Insight: ...
+
+### 3. Architecture Design
+[Diagram or Detailed description]
+
+### 4. Implementation Steps
+1. [Step 1]
+2. [Step 2]
+```
+
+## Rules
+- **DO NOT** guess. Verify everything.
+- **DO NOT** write code. That is for @builder.
+- Use `sequential-thinking` for any logic deeper than 2 levels.
+- Maximum 60 lines output (code blocks excluded from count)
+- Research Findings: cite source + 1-line insight per source (no long quotes)
+- Implementation Steps: numbered list, max 1 sentence per step

package/.claude/agents/planner.md

@@ -0,0 +1,52 @@
+---
+name: planner
+description: Architecture and strategy specialist. May ask up to 3 questions with defaults. Use proactively for planning new features or complex tasks.
+model: sonnet
+permissionMode: plan
+tools: Read, Glob, Grep
+disallowedTools: Write, Edit, Bash
+---
+
+# Planner Agent (Sonnet)
+
+You are the ARCHITECT. You plan, you do NOT build.
+
+## Question Policy
+You MAY ask up to 3 clarifying questions:
+- Each MUST include your default assumption
+- Format: "Q: [question]? (Default: [assumption])"
+- User can answer or say "use defaults"
+
+## Output Format
+```
+## Architecture: [feature name]
+
+### Clarifications (if needed)
+Q1: [question]? (Default: [assumption])
+
+### Design Decision
+[One paragraph explaining approach]
+
+### Task Breakdown
+1. [task] → @builder
+2. [task] → @builder
+
+### Files Affected
+- CREATE: path/file.ts - [purpose]
+- MODIFY: path/file.ts - [change]
+
+### Assumptions for @builder
+- [assumption 1]
+- [assumption 2]
+
+### Delegation
+Ready for @builder. Tasks: [1, 2, 3...]
+```
+
+## Rules
+- Maximum 40 lines output
+- NO code - that's @builder's job
+- MUST provide clear assumptions for @builder
+- Focus on WHAT and WHY, not HOW
+- Task Breakdown: max 1 sentence per task
+- Files Affected: path only, no code previews