claude-pro-minmax 1.0.0

package/.claude/sessions/README.md

@@ -0,0 +1,195 @@
+> **[한국어 버전](README.ko.md)**
+
+# Sessions Directory
+
+## Purpose
+Stores session state files created by `/session-save`. Enables continuity across sessions.
+
+> **Path note:** Examples include installed paths (`~/.claude/...`). In this repository, source paths are `./.claude/...` and `./scripts/...`.
+
+## Session Lifecycle
+
+```mermaid
+flowchart TB
+    %% Style definitions %%
+    classDef command fill:#e8f5e9,stroke:#43a047,stroke-width:2px;
+    classDef file fill:#fff3e0,stroke:#fb8c00,stroke-width:2px;
+    classDef process fill:#e3f2fd,stroke:#1e88e5,stroke-width:2px;
+    classDef hook fill:#ffebee,stroke:#e53935,stroke-width:2px;
+    classDef builtin fill:#f3e5f5,stroke:#8e24aa,stroke-width:2px;
+    classDef note fill:#fffde7,stroke:#fdd835,stroke-width:1px,stroke-dasharray: 3 3;
+
+    %% Main Session Flow %%
+    Start((🚀 Session Start)):::process
+    Start --> Work[🔨 Working on Tasks]:::process
+    
+    Work --> Decision{Save Session?}:::process
+    Decision -->|Yes| SaveCmd[/"💾 /session-save auth-feature"/]:::command
+    Decision -->|No| Continue[Continue Working]:::process
+    Continue --> Work
+    
+    %% Save Process %%
+    SaveCmd --> Collect["📋 Collect State<br/>• Completed tasks<br/>• Current state<br/>• Next actions<br/>• Key files"]:::process
+    Collect --> Scrub{{"🔐 scrub-secrets.js<br/>Remove 15+ secret patterns"}}:::hook
+    Scrub --> Write["✍️ Write to<br/>.claude/sessions/<br/>2025-01-28-auth-feature.md"]:::file
+    Write --> Notify["✅ Session saved!<br/>Scrubbed: N secrets"]:::note
+    
+    %% Load Process %%
+    Notify -.->|"Later..."| LoadStart((📂 New Session)):::process
+    LoadStart --> LoadCmd[/"📂 /session-load auth-feature"/]:::command
+    LoadCmd --> Read["📖 Read session file"]:::process
+    Read --> Restore["🔄 Restore Context<br/>• Set completed tasks<br/>• Load next actions<br/>• Reference key files"]:::process
+    Restore --> Ready["✅ Ready to continue!"]:::note
+    
+    %% Built-in Alternative %%
+    subgraph BuiltInCLI["🔧 Alternative: Built-in CLI"]
+        direction TB
+        BuiltinNote["For exact conversation replay<br/>(not human-readable summary)"]:::note
+        CLI1["claude -c / --continue<br/>→ Resume most recent"]:::builtin
+        CLI2["claude -r abc123 / --resume abc123<br/>→ Resume specific session"]:::builtin
+        JSONL["~/.claude/projects/*.jsonl<br/>(raw conversation history)"]:::file
+        CLI1 --> JSONL
+        CLI2 --> JSONL
+    end
+```
+
+### Custom vs Built-in Sessions
+
+| Feature | `/session-save` + `/session-load` | `claude --continue` |
+|---------|-----------------------------------|---------------------|
+| **Format** | Human-readable `.md` | Raw `.jsonl` |
+| **Location** | `.claude/sessions/` (project) | `~/.claude/projects/` (global) |
+| **Content** | Summary (tasks, decisions, next steps) | Full conversation transcript |
+| **Secret Scrubbing** | ✅ Automatic | ❌ Not scrubbed |
+| **Best For** | Sharing context, documentation | Exact conversation replay |
+
+### When to Use What?
+
+| Situation | Recommended | Why |
+|-----------|-------------|-----|
+| Short break (same day) | `claude -c` | Fast, exact conversation resume |
+| Long break (next day) | `/session-load` | Load only key context, reduce cost |
+| Share context with team | `/session-save` | Human-readable `.md` for sharing |
+| After working with secrets | `/session-save` | Auto-scrubbing for safety |
+| Need exact conversation | `claude --resume` | Full transcript replay |
+
+### Recommended Workflow
+
+```
+📅 Day 1 Morning: Start new task
+📅 Day 1 Afternoon: After lunch → claude -c (quick resume with built-in CLI)
+📅 Day 1 Evening: /session-save feature-v1 (save work summary)
+
+📅 Day 2: /session-load feature-v1 (start fresh with clean context)
+📅 Day 2 Afternoon: claude -c (quick resume same day)
+📅 Day 2 Evening: /session-save feature-v2 (save progress)
+```
+
+> **💡 Tip**: These two systems are **complementary, not competing**. Use both based on the situation!
+
+## File Naming
+
+```
+YYYY-MM-DD-[name].md
+```
+
+Examples:
+- `2025-01-27-auth-jwt.md`
+- `2025-01-27-payment-integration.md`
+
+## Security
+
+**All session files are automatically scrubbed before writing.**
+
+Scrubbed patterns include:
+- API keys (OpenAI, Anthropic, Stripe, GitHub, AWS)
+- Database URLs with credentials
+- JWT tokens
+- Password fields
+- Private keys
+
+## Usage
+
+```bash
+# Save current session
+/session-save auth-feature
+
+# Load most recent
+/session-load
+
+# Load specific session
+/session-load auth-feature
+
+# List available sessions
+/session-load --list
+```
+
+## Session File Format
+
+```markdown
+# Session: [name]
+Date: [timestamp]
+Duration: [messages]
+Security: [items scrubbed]
+
+## Context
+- Project: [name]
+- Branch: [branch]
+- Focus: [description]
+
+## Completed
+- [x] [task]
+
+## In Progress
+- [ ] [task] - [status]
+
+## Decisions Made
+- [decision]: [reasoning]
+
+## Next Steps
+1. [action]
+
+## Key Files
+- [file]: [why relevant]
+
+## Loaded Contexts
+- [type]: [status]
+
+## Learned Patterns
+- [pattern]
+```
+
+## Maintenance
+
+```bash
+# List sessions
+ls -la .claude/sessions/
+
+# Delete old sessions (>30 days)
+find .claude/sessions/ -mtime +30 -delete
+
+# Manual scrub (if needed)
+node scripts/scrub-secrets.js < session.md > clean.md
+# Installed path: node ~/.claude/scripts/scrub-secrets.js < session.md > clean.md
+```
+
+## Claude Built-in Session Commands
+
+In addition to custom `/session-save` and `/session-load`, Claude Code has built-in session features:
+
+| Command | Purpose |
+|---------|---------|
+| `claude -c` / `--continue` | Resume most recent session |
+| `claude -r "id"` / `--resume "id"` | Resume specific session by ID |
+| `claude --resume` | Show recent sessions to select |
+
+> **Note:** Built-in sessions are stored in `~/.claude/projects/.../*.jsonl`. Custom `/session-save` creates human-readable `.md` summaries in `.claude/sessions/`.
+
+## Best Practices
+
+1. Save after completing logical phases
+2. Save before long breaks (>4 hours)
+3. Use descriptive names
+4. Prune old sessions periodically
+5. **Ensure scripts are executable**: `chmod +x scripts/hooks/*.sh`  
+   (Installed path: `chmod +x ~/.claude/scripts/hooks/*.sh`)

package/.claude/settings.json

@@ -0,0 +1,167 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-settings.json",
+  "env": {
+    "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "75",
+    "CLAUDE_FAILURE_NOTIFY": "0"
+  },
+  "permissions": {
+    "allow": [
+      "Read",
+      "Glob",
+      "Grep",
+      "WebFetch(domain:platform.claude.com)",
+      "WebFetch(domain:code.claude.com)",
+      "WebFetch(domain:docs.anthropic.com)",
+      "WebFetch(domain:github.com)",
+      "WebFetch(domain:support.anthropic.com)",
+      "Bash(git log *)",
+      "Bash(git status *)",
+      "Bash(git diff *)",
+      "Bash(git add *)",
+      "Bash(git commit *)",
+      "Bash(git checkout *)",
+      "Bash(git branch *)",
+      "Bash(git fetch *)",
+      "Bash(git pull *)",
+      "Bash(git merge *)",
+      "Bash(git stash *)",
+      "Bash(gh *)",
+      "Bash(npm *)",
+      "Bash(pnpm *)",
+      "Bash(yarn *)",
+      "Bash(bun *)",
+      "Bash(mgrep *)",
+      "Bash(grep *)",
+      "Bash(find *)",
+      "Bash(cat *)",
+      "Bash(head *)",
+      "Bash(tail *)",
+      "Bash(wc *)",
+      "Bash(ls *)",
+      "Bash(mkdir *)",
+      "Bash(cp *)",
+      "Bash(mv *)",
+      "Bash(node *)",
+      "Bash(npx *)",
+      "Bash(tsc *)",
+      "Bash(jest *)",
+      "Bash(vitest *)",
+      "Bash(prettier *)",
+      "Bash(eslint *)",
+      "Bash(jq *)",
+      "Bash(tmux *)",
+      "Bash(./gradlew *)",
+      "Bash(gradle *)",
+      "Bash(mvn *)",
+      "Bash(cargo *)",
+      "Bash(go *)",
+      "Bash(poetry *)",
+      "Bash(pip *)",
+      "Bash(uv *)",
+      "Bash(mix *)",
+      "Bash(make *)"
+    ],
+    "ask": [
+      "Write",
+      "Edit",
+      "Bash(git push *)",
+      "Bash(curl *)"
+    ],
+    "deny": [
+      "Bash(sudo *)",
+      "Bash(rm -rf /)",
+      "Bash(rm -rf ~)",
+      "Bash(rm -rf .git)",
+      "Read(./.env)",
+      "Read(./.env.*)",
+      "Read(./secrets/**)"
+    ]
+  },
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/scripts/hooks/critical-action-check.sh",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/scripts/hooks/post-edit-format.sh",
+            "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "~/.claude/scripts/hooks/compact-suggest.sh",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "Notification": [
+      {
+        "matcher": "permission_prompt|idle_prompt",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/scripts/hooks/notification.sh",
+            "timeout": 3
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/scripts/hooks/session-start.sh",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/scripts/hooks/session-cleanup.sh",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/scripts/hooks/pre-compact.sh",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "PostToolUseFailure": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/scripts/hooks/tool-failure-log.sh",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}

package/.claude/settings.local.example.json

@@ -0,0 +1,3 @@
+{
+  "enableAllProjectMcpServers": true
+}

package/.claude/skills/README.ko.md

@@ -0,0 +1,60 @@
+# 스킬 디렉토리 (퍼사드 패턴 최적화)
+
+> **[English Version](README.md)**
+
+## 목적
+이 디렉토리는 **메시지당 최대 가치 (Maximum Value Per Message)**를 위해 퍼사드 패턴(Facade Pattern)으로 설계된 재사용 가능한 스킬 정의를 포함합니다. 방대한 기술 세부 정보를 인터페이스와 분리하여 과도한 컨텍스트 로딩을 방지합니다.
+
+## 구조 (퍼사드 패턴)
+
+```text
+skills/
+└── 스킬이름/
+    ├── SKILL.md           # 인터페이스 (경량: 약 30-50줄)
+    └── references/        # 세부 구현 (중량: 필요 시에만 로드)
+        ├── api-docs.md
+        └── cli-patterns.md
+```
+
+## 작동 원리: "온디맨드(On-Demand)" 전략
+
+매번 방대한 문서를 로드하는 대신, Claude는 처음에 **인터페이스(SKILL.md)**만 로드합니다.
+
+1. **1단계 (경량화)**: Claude가 간결한 `SKILL.md` 인터페이스를 읽습니다.
+2. **2단계 (트리거)**: 인터페이스에 정의된 "트리거 조건"에 맞는 작업이 발생하면, Claude가 명시적으로 참조 파일을 로드합니다.
+3. **3단계 (실행)**: 해당 턴에서만 상세 정보를 사용하고, 이후 `/compact` 시점에서 제거될 수 있도록 관리합니다.
+
+## 스킬 목록
+
+| 스킬 | 용도 | 주요 이점 |
+| :--- | :--- | :--- |
+| `cli-wrappers` | 무거운 MCP 서버를 가벼운 CLI 패턴으로 대체 | 출력을 상당히 줄임 |
+| `learned` | `/learn` 명령어를 통해 학습된 패턴 저장 | 재작업 및 반복 질문 방지 |
+
+## 커스텀 스킬 추가 방법
+
+### 1. 파일 템플릿: `SKILL.md`
+```markdown
+# [스킬 이름] 인터페이스
+
+## 목적
+이 스킬이 제공하는 기능에 대한 짧은 설명.
+
+## 빠른 참조
+- 핵심 사실 1
+- 핵심 사실 2
+
+## 참조 로드 프로토콜 (Reference Loading Protocol)
+Claude는 아래 조건이 충족될 때만 `read_file` 도구를 사용하여 참조 파일을 로드해야 합니다:
+
+- **로직 세부 사항**: 핵심 로직 작성 시 `.claude/skills/[스킬]/references/logic.md` 로드.
+- **CLI 패턴**: 셸 명령어 실행 시 `.claude/skills/[스킬]/references/cli.md` 로드.
+```
+
+### 2. 파일 템플릿: `references/*.md`
+방대한 API 문서, 긴 코드 예제, 에러 메시지 테이블 등 무거운 내용을 여기에 작성합니다.
+
+## 권장 사항
+1. **50줄 규칙**: `SKILL.md`가 50줄을 넘어가면 세부 내용을 `references/`로 옮기세요.
+2. **명시적 트리거**: **"Claude는 반드시 ...을 로드해야 합니다"**와 같은 강조 문구를 사용하여 모델이 패턴을 따르게 하세요.
+3. **상대 경로**: 도구 실행 실패를 방지하기 위해 항상 프로젝트 루트부터의 전체 경로(`.claude/skills/...`)를 제공하세요.

package/.claude/skills/README.md

@@ -0,0 +1,60 @@
+# Skills Directory (Facade Pattern Optimization)
+
+> **[한국어 버전](README.ko.md)**
+
+## Purpose
+This directory contains reusable skill definitions designed for **Maximum Value Per Message** using the Facade Pattern. It prevents excessive context loading by separating high-level interfaces from verbose technical details.
+
+## Structure (Facade Pattern)
+
+```text
+skills/
+└── skill-name/
+    ├── SKILL.md           # Interface (Thin: ~30-50 lines)
+    └── references/        # Implementation (Verbose: Loaded on-demand)
+        ├── api-docs.md
+        └── cli-patterns.md
+```
+
+## How It Works: The "On-Demand" Strategy
+
+Instead of loading extensive documentation every time, Claude starts with only the **Interface (SKILL.md)**.
+
+1. **Phase 1 (Lightweight)**: Claude reads the compact `SKILL.md` interface.
+2. **Phase 2 (Trigger)**: When a specific task matches a "Trigger Condition" defined in the interface, Claude explicitly loads the reference file.
+3. **Phase 3 (Execution)**: Claude uses the detailed info only for that specific turn, then it can be discarded during `/compact`.
+
+## Skill Inventory
+
+| Skill | Purpose | Key Benefit |
+| :--- | :--- | :--- |
+| `cli-wrappers` | Replaces heavy MCP servers with slim CLI patterns. | Significantly reduces output tokens. |
+| `learned` | Stores project-specific patterns via `/learn`. | Prevents rework & repeat questions. |
+
+## Adding a Custom Skill
+
+### 1. File Template: `SKILL.md`
+```markdown
+# [Skill Name] Interface
+
+## Purpose
+Short description of what this skill does.
+
+## Quick Reference
+- Fast fact 1
+- Fast fact 2
+
+## Reference Loading Protocol
+Claude **MUST** use the `read_file` tool to load these files ONLY when the conditions are met:
+
+- **Logic Details**: Load `.claude/skills/[skill]/references/logic.md` when writing core logic.
+- **CLI Patterns**: Load `.claude/skills/[skill]/references/cli.md` when running shell commands.
+```
+
+### 2. File Template: `references/*.md`
+Contains the heavy stuff: Full API docs, long code examples, error message tables.
+
+## Best Practices
+1. **The 50-Line Rule**: If `SKILL.md` exceeds 50 lines, move details to `references/`.
+2. **Explicit Triggers**: Use bold text like **"Claude MUST load..."** to ensure the model follows the pattern.
+3. **Relative Paths**: Always provide the full path from the project root (e.g., `.claude/skills/...`) to avoid tool failures.

package/.claude/skills/cli-wrappers/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: cli-wrappers
+description: Use CLI tools instead of MCP to reduce cost. Provides JSON output patterns for gh, mgrep, psql, etc.
+---
+
+# CLI Wrappers Skill
+
+## Purpose
+Replace MCPs with CLI. ALWAYS use JSON output + jq.
+
+## GitHub (gh)
+```bash
+gh pr list --json number,title | jq -c '.[]'
+gh pr create --title "feat: X" --body "desc"
+gh issue list --json number,title | jq -c '.[]'
+```
+Full reference: `@references/github-cli.md`
+
+## Search (mgrep)
+```bash
+mgrep "pattern" src/
+mgrep -t py "class"      # Python
+mgrep -t java "public"   # Java
+mgrep -t go "func"       # Go
+mgrep --web "docs query"
+```
+Full reference: `@references/mgrep.md`
+
+## Database
+```bash
+psql -t -A -F',' -c "SELECT..."
+```
+
+## Benefits
+| Tool | Benefit |
+|------|---------|
+| gh pr list | JSON output reduces verbosity significantly |
+| psql | CSV format eliminates table formatting overhead |

package/.claude/skills/cli-wrappers/references/github-cli.md

@@ -0,0 +1,18 @@
+# GitHub CLI Reference
+
+## Pull Requests
+```bash
+gh pr list --json number,title,state | jq -c '.[]'
+gh pr create --title "feat: X" --body "desc"
+gh pr view 123 --json title,body | jq '.'
+gh pr merge 123 --squash
+gh pr checks 123 --json name,state | jq -c '.[]'
+```
+
+## Issues
+```bash
+gh issue list --json number,title | jq -c '.[]'
+gh issue create --title "X" --body "desc"
+```
+
+## Key: Always --json | jq, never raw output

package/.claude/skills/cli-wrappers/references/mgrep.md

@@ -0,0 +1,18 @@
+# mgrep Reference
+
+## Why mgrep?
+50% less output than grep/ripgrep
+
+## Usage
+```bash
+mgrep "pattern" src/          # Local
+mgrep -t ts "interface"       # Type filter
+mgrep --web "Next.js docs"    # Web search
+mgrep "TODO|FIXME" --include "*.ts"
+```
+
+## vs grep
+| Tool | Output |
+|------|--------|
+| grep | ~2000 |
+| mgrep | ~1000 |

package/.claude/skills/learned/README.ko.md

@@ -0,0 +1,64 @@
+# 학습된 패턴 데이터베이스 (Learned Patterns)
+
+이 디렉토리는 Claude Code 환경의 **장기 기억(Long-Term Memory)** 저장소입니다. `/learn` 명령어를 통해 추출된 반복적인 코딩 패턴, 아키텍처 결정 사항, 그리고 개인적인 코딩 스타일 선호도를 보관합니다.
+
+## 핵심 개념: 지식 순환 아키텍처
+
+1. **감지 (Detection)**: 작업 도중 반복되는 패턴이나 중요한 규칙을 발견합니다.
+2. **추출 (Extraction)**: `/learn` 명령어를 실행하여 해당 지식을 정형화합니다.
+3. **저장 (Persistence)**: 메타데이터가 포함된 마크다운 파일로 이 폴더에 저장됩니다.
+4. **부활 (Resurrection)**: 다음 세션이 시작될 때 Claude는 이 폴더를 인덱싱하여, **과거의 실수를 반복하지 않고 이미 결정된 규칙을 다시 묻지 않습니다.**
+
+## 사용 방법 및 실행
+
+### 1. 명시적 학습 (Manual Learning)
+기억해야 할 규칙이 생겼을 때 직접 입력합니다:
+`> /learn "API 에러 핸들링 시 항상 try-catch와 전역 로거를 사용해줘"`
+
+### 2. 세션 분석 (Session Analysis)
+복잡한 작업을 마친 후, Claude에게 패턴을 찾아내라고 시킵니다:
+`> /learn`
+Claude가 전체 대화 기록을 분석하여 저장할만한 패턴을 제안합니다.
+
+### 3. 목록 확인 (Management)
+`> /learn --show` (현재 저장된 모든 패턴 목록을 확인합니다.)
+
+## 분류 체계 및 저장 위치
+
+| 카테고리 | 저장 위치 | 용도 |
+| :--- | :--- | :--- |
+| **CONVENTION** | `.claude/rules/` | 구조적 규칙 (예: 폴더 구조, 네이밍 컨벤션) |
+| **PATTERN** | **이 폴더 (learned/)** | 재사용 가능한 로직 블록 (예: 인증 흐름, 에러 처리 패턴) |
+| **PREFERENCE** | `.claude/rules/` | 개인적 취향 (예: "나는 trailing comma를 선호함") |
+
+## 패턴 파일 구조
+
+모든 패턴 파일은 Claude가 읽기 최적화된 아래 형식을 따릅니다:
+
+```markdown
+---
+name: api-response-format
+category: PATTERN
+tags: [api, nodejs, json]
+---
+# 패턴: 표준 API 응답 형식
+
+## 문제점
+API 응답 형식이 일관되지 않아 프론트엔드에서 파싱 에러가 자주 발생함.
+
+## 해결책
+`src/types/api.ts`에 정의된 `BaseResponse` 인터페이스를 반드시 사용함.
+
+## 예시
+```typescript
+res.json({
+  success: true,
+  data: result,
+  error: null
+});
+```
+```
+
+## ⚠️ 주의 사항
+- **비밀번호/키 제외**: `/learn` 명령어 실행 시 `scrub-secrets.js`가 자동으로 작동하여 API 키나 토큰이 저장되지 않도록 검열합니다.
+- **프로젝트 컨텍스트**: 패턴은 사용자 홈 디렉토리에 저장되지만, Claude는 현재 프로젝트와 연관된 패턴을 우선적으로 인덱싱합니다.

package/.claude/skills/learned/README.md

@@ -0,0 +1,64 @@
+# Learned Patterns Database
+
+This directory serves as the **Long-Term Memory** for your Claude Code environment. It stores recurring patterns, specific architectural decisions, and coding style preferences extracted through the `/learn` command.
+
+## Core Concept: The Knowledge Cycle
+
+1. **Detection**: During a session, you (or the `Stop hook`) identify a reusable pattern.
+2. **Extraction**: You run `/learn` to formalize that insight.
+3. **Persistence**: The pattern is saved as a Markdown file with specific metadata.
+4. **Resurrection**: In future sessions, Claude automatically indexes these files, ensuring it doesn't repeat past mistakes or ask the same questions.
+
+## Usage & Implementation
+
+### 1. Manual Learning
+If you notice a convention you want to keep:
+`> /learn "Always use useServerSideProps for data fetching in /pages"`
+
+### 2. Session Analysis
+If you've just finished a complex task and want to extract the "how-to":
+`> /learn`
+Claude will analyze the transcript and propose patterns to save.
+
+### 3. Management
+`> /learn --show` (Lists all active patterns)
+
+## Categorization Logic
+
+| Category | Storage Target | Purpose |
+| :--- | :--- | :--- |
+| **CONVENTION** | `.claude/rules/` | Structural rules (e.g., Folder structure, Naming). |
+| **PATTERN** | **This folder** | Reusable logic blocks (e.g., Auth flow, Error handling). |
+| **PREFERENCE** | `.claude/rules/` | Personal taste (e.g., "I prefer trailing commas"). |
+
+## Pattern File Structure
+
+Every learned file follows this high-efficiency schema for LLM ingestion:
+
+```markdown
+---
+name: auth-error-handling
+category: PATTERN
+tags: [auth, nextjs, security]
+---
+# Pattern: Centralized Auth Error Handling
+
+## Problem
+Auth errors were being handled inconsistently across different API routes.
+
+## Solution
+Use the `handleAuthError` utility located in `src/utils/auth`.
+
+## Example
+```typescript
+try {
+  // ... auth logic
+} catch (e) {
+  return handleAuthError(e);
+}
+```
+```
+
+## ⚠️ Important Notes
+- **No Secrets**: The `/learn` command automatically triggers `scrub-secrets.js` to ensure no API keys or tokens are stored in the patterns.
+- **Project Specific**: While saved in your user home, these patterns are indexed based on project context.