release: v0.3.0

chore: bump version to 0.2.0
🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)
2025-12-09 12:51:28 +00:00 · 2025-12-09 21:47:21 +09:00 · 2025-12-09 21:47:01 +09:00 · 2025-12-09 19:00:01 +09:00 · 2025-12-09 18:20:13 +09:00 · 2025-12-09 18:10:30 +09:00
64 changed files with 4781 additions and 214 deletions
--- a/README.ko.md
+++ b/README.ko.md
@@ -15,6 +15,7 @@
      - [내장 AST-Grep Tools](#내장-ast-grep-tools)
      - [Grep](#grep)
      - [내장 MCPs](#내장-mcps)
+    - [Claude Code 호환성](#claude-code-호환성)
    - [기타 편의 기능](#기타-편의-기능)
  - [설정](#설정)
  - [작성자의 노트](#작성자의-노트)
@@ -153,6 +154,10 @@ OpenCode 는 아주 확장가능하고 아주 커스터마이저블합니다.
  │       └── Button.tsx     # 이 파일을 읽으면 위 3개 AGENTS.md 모두 주입
  ```
  `Button.tsx`를 읽으면 순서대로 주입됩니다: `project/AGENTS.md` → `src/AGENTS.md` → `components/AGENTS.md`. 각 디렉토리의 컨텍스트는 세션당 한 번만 주입됩니다. Claude Code의 CLAUDE.md 기능에서 영감을 받았습니다.
+- **Think Mode**: 확장된 사고(Extended Thinking)가 필요한 상황을 자동으로 감지하고 모드를 전환합니다. 사용자가 깊은 사고를 요청하는 표현(예: "think deeply", "ultrathink")을 감지하면, 추론 능력을 극대화하도록 모델 설정을 동적으로 조정합니다.
+- **Anthropic Auto Compact**: Anthropic 모델 사용 시 컨텍스트 한계에 도달하면 대화 기록을 자동으로 압축하여 효율적으로 관리합니다.
+- **Empty Task Response Detector**: 서브 에이전트가 수행한 작업이 비어있거나 무의미한 응답을 반환하는 경우를 감지하여, 오류 없이 우아하게 처리합니다.
+- **Grep Output Truncator**: Grep 검색 결과가 너무 길어 컨텍스트를 장악해버리는 것을 방지하기 위해, 과도한 출력을 자동으로 자릅니다.

 ### Agents

@@ -220,8 +225,72 @@ OpenCode 는 아주 확장가능하고 아주 커스터마이저블합니다.
 }
 ```

+### Claude Code 호환성
+
+Oh My OpenCode는 Claude Code 설정과 완벽하게 호환됩니다. Claude Code를 사용하셨다면, 기존 설정을 그대로 사용할 수 있습니다.
+
+#### Hooks 통합
+
+Claude Code의 `settings.json` 훅 시스템을 통해 커스텀 스크립트를 실행합니다. Oh My OpenCode는 다음 위치의 훅을 읽고 실행합니다:
+
+- `~/.claude/settings.json` (사용자)
+- `./.claude/settings.json` (프로젝트)
+- `./.claude/settings.local.json` (로컬, git-ignored)
+
+지원되는 훅 이벤트:
+- **PreToolUse**: 도구 실행 전에 실행. 차단하거나 도구 입력을 수정할 수 있습니다.
+- **PostToolUse**: 도구 실행 후에 실행. 경고나 컨텍스트를 추가할 수 있습니다.
+- **UserPromptSubmit**: 사용자가 프롬프트를 제출할 때 실행. 차단하거나 메시지를 주입할 수 있습니다.
+- **Stop**: 세션이 유휴 상태가 될 때 실행. 후속 프롬프트를 주입할 수 있습니다.
+
+`settings.json` 예시:
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [{ "type": "command", "command": "eslint --fix $FILE" }]
+      }
+    ]
+  }
+}
+```
+
+#### 설정 로더
+
+**Command Loader**: 4개 디렉토리에서 마크다운 기반 슬래시 명령어를 로드합니다:
+- `~/.claude/commands/` (사용자)
+- `./.claude/commands/` (프로젝트)
+- `~/.config/opencode/command/` (opencode 전역)
+- `./.opencode/command/` (opencode 프로젝트)
+
+**Skill Loader**: `SKILL.md`가 있는 디렉토리 기반 스킬을 로드합니다:
+- `~/.claude/skills/` (사용자)
+- `./.claude/skills/` (프로젝트)
+
+**Agent Loader**: 마크다운 파일에서 커스텀 에이전트 정의를 로드합니다:
+- `~/.claude/agents/*.md` (사용자)
+- `./.claude/agents/*.md` (프로젝트)
+
+**MCP Loader**: `.mcp.json` 파일에서 MCP 서버 설정을 로드합니다:
+- `~/.claude/.mcp.json` (사용자)
+- `./.mcp.json` (프로젝트)
+- `./.claude/.mcp.json` (로컬)
+- 환경변수 확장 지원 (`${VAR}` 문법)
+
+#### 데이터 저장소
+
+**Todo 관리**: 세션 todo가 `~/.claude/todos/`에 Claude Code 호환 형식으로 저장됩니다.
+
+**Transcript**: 세션 활동이 `~/.claude/transcripts/`에 JSONL 형식으로 기록되어 재생 및 분석이 가능합니다.
+
+> **`claude-code-*` 네이밍에 대해**: `src/features/claude-code-*/` 아래의 기능들은 Claude Code의 설정 시스템에서 마이그레이션되었습니다. 이 네이밍 규칙은 어떤 기능이 Claude Code에서 유래했는지 명확히 식별합니다.
+
 ### 기타 편의 기능
+
 - **Terminal Title**: 세션 상태에 따라 터미널 타이틀을 자동 업데이트합니다 (유휴 ○, 처리중 ◐, 도구 ⚡, 에러 ✖). tmux를 지원합니다.
+- **Session State**: 이벤트 훅과 터미널 타이틀 업데이트에 사용되는 중앙집중식 세션 추적 모듈입니다.

 ## 설정

--- a/README.md
+++ b/README.md
@@ -15,6 +15,7 @@ English | [한국어](README.ko.md)
      - [Built-in AST-Grep Tools](#built-in-ast-grep-tools)
      - [Grep](#grep)
      - [Built-in MCPs](#built-in-mcps)
+    - [Claude Code Compatibility](#claude-code-compatibility)
    - [Other Features](#other-features)
  - [Configuration](#configuration)
  - [Author's Note](#authors-note)
@@ -149,6 +150,10 @@ I believe in the right tool for the job. For your wallet's sake, use CLIProxyAPI
  │       └── Button.tsx     # Reading this injects ALL 3 AGENTS.md files
  ```
  When reading `Button.tsx`, the hook injects contexts in order: `project/AGENTS.md` → `src/AGENTS.md` → `components/AGENTS.md`. Each directory's context is injected only once per session. Inspired by Claude Code's CLAUDE.md feature.
+- **Think Mode**: Automatic extended thinking detection and mode switching. Detects when user requests deep thinking (e.g., "think deeply", "ultrathink") and dynamically adjusts model settings for enhanced reasoning.
+- **Anthropic Auto Compact**: Automatically compacts conversation history when approaching context limits for Anthropic models.
+- **Empty Task Response Detector**: Detects when subagent tasks return empty or meaningless responses and handles gracefully.
+- **Grep Output Truncator**: Prevents grep output from overwhelming the context by truncating excessively long results.

 ### Agents
 - **oracle** (`openai/gpt-5.1`): The architect. Expert in code reviews and strategy. Uses GPT-5.1 for its unmatched logic and reasoning capabilities. Inspired by AmpCode.
@@ -217,9 +222,72 @@ Don't need these? Disable them via `oh-my-opencode.json`:
 }
 ```

+### Claude Code Compatibility
+
+Oh My OpenCode provides seamless Claude Code configuration compatibility. If you've been using Claude Code, your existing setup works out of the box.
+
+#### Hooks Integration
+
+Execute custom scripts via Claude Code's `settings.json` hook system. Oh My OpenCode reads and executes hooks defined in:
+
+- `~/.claude/settings.json` (user)
+- `./.claude/settings.json` (project)
+- `./.claude/settings.local.json` (local, git-ignored)
+
+Supported hook events:
+- **PreToolUse**: Runs before tool execution. Can block or modify tool input.
+- **PostToolUse**: Runs after tool execution. Can add warnings or context.
+- **UserPromptSubmit**: Runs when user submits a prompt. Can block or inject messages.
+- **Stop**: Runs when session goes idle. Can inject follow-up prompts.
+
+Example `settings.json`:
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [{ "type": "command", "command": "eslint --fix $FILE" }]
+      }
+    ]
+  }
+}
+```
+
+#### Configuration Loaders
+
+**Command Loader**: Loads markdown-based slash commands from 4 directories:
+- `~/.claude/commands/` (user)
+- `./.claude/commands/` (project)
+- `~/.config/opencode/command/` (opencode global)
+- `./.opencode/command/` (opencode project)
+
+**Skill Loader**: Loads directory-based skills with `SKILL.md`:
+- `~/.claude/skills/` (user)
+- `./.claude/skills/` (project)
+
+**Agent Loader**: Loads custom agent definitions from markdown files:
+- `~/.claude/agents/*.md` (user)
+- `./.claude/agents/*.md` (project)
+
+**MCP Loader**: Loads MCP server configurations from `.mcp.json` files:
+- `~/.claude/.mcp.json` (user)
+- `./.mcp.json` (project)
+- `./.claude/.mcp.json` (local)
+- Supports environment variable expansion (`${VAR}` syntax)
+
+#### Data Storage
+
+**Todo Management**: Session todos are stored in Claude Code compatible format at `~/.claude/todos/`.
+
+**Transcript**: Session activity is logged to `~/.claude/transcripts/` in JSONL format, enabling replay and analysis.
+
+> **Note on `claude-code-*` naming**: Features under `src/features/claude-code-*/` are migrated from Claude Code's configuration system. This naming convention clearly identifies which features originated from Claude Code.
+
 ### Other Features

 - **Terminal Title**: Auto-updates terminal title with session status (idle ○, processing ◐, tool ⚡, error ✖). Supports tmux.
+- **Session State**: Centralized session tracking module used by event hooks and terminal title updates.

 ## Configuration

--- a/bun.lock
+++ b/bun.lock
@@ -7,13 +7,14 @@
      "dependencies": {
        "@ast-grep/cli": "^0.40.0",
        "@ast-grep/napi": "^0.40.0",
-        "@code-yeongyu/comment-checker": "^0.4.1",
+        "@code-yeongyu/comment-checker": "^0.4.4",
        "@opencode-ai/plugin": "^1.0.7",
        "xdg-basedir": "^5.1.0",
        "zod": "^4.1.8",
      },
      "devDependencies": {
        "bun-types": "latest",
+        "oh-my-opencode": "^0.1.30",
        "typescript": "^5.7.3",
      },
      "peerDependencies": {
@@ -63,7 +64,7 @@

    "@ast-grep/napi-win32-x64-msvc": ["@ast-grep/napi-win32-x64-msvc@0.40.0", "", { "os": "win32", "cpu": "x64" }, "sha512-Hk2IwfPqMFGZt5SRxsoWmGLxBXxprow4LRp1eG6V8EEiJCNHxZ9ZiEaIc5bNvMDBjHVSnqZAXT22dROhrcSKQg=="],

-    "@code-yeongyu/comment-checker": ["@code-yeongyu/comment-checker@0.4.1", "", { "os": [ "linux", "win32", "darwin", ], "cpu": [ "x64", "arm64", ], "bin": { "comment-checker": "bin/comment-checker" } }, "sha512-E7p1V8CsRj9hMbwENd9BfxZGWYu+lKS5tXGuNNcNtkRMhWvwM/ononysKpLB7LXdxfSYAn0j7heJydyzEmm+lg=="],
+    "@code-yeongyu/comment-checker": ["@code-yeongyu/comment-checker@0.4.4", "", { "os": [ "linux", "win32", "darwin", ], "cpu": [ "x64", "arm64", ], "bin": { "comment-checker": "bin/comment-checker" } }, "sha512-vsbdLMQYJJNDV/baTDnNqqg/MZwA+9nz7TE6Mybj8zjZVTCn4ZivH4hAdD5p4fLxhGZEJ5x1UDmXA6pAGA7lHA=="],

    "@opencode-ai/plugin": ["@opencode-ai/plugin@1.0.128", "", { "dependencies": { "@opencode-ai/sdk": "1.0.128", "zod": "4.1.8" } }, "sha512-M5vjz3I6KeoBSNduWmT5iHXRtTLCqICM5ocs+WrB3uxVorslcO3HVwcLzrERh/ntpxJ/1xhnHQaeG6Mg+P744A=="],

@@ -99,6 +100,8 @@

    "detect-libc": ["detect-libc@2.1.2", "", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="],

+    "oh-my-opencode": ["oh-my-opencode@0.1.30", "", { "dependencies": { "@ast-grep/cli": "^0.40.0", "@ast-grep/napi": "^0.40.0", "@code-yeongyu/comment-checker": "^0.4.1", "@opencode-ai/plugin": "^1.0.7", "xdg-basedir": "^5.1.0", "zod": "^4.1.8" }, "peerDependencies": { "bun": ">=1.0.0" } }, "sha512-pXGGgL/7Jcz3yuGJJTI72BKern2egwfRz2LQZTBq+jl+pNCybOvGvXtFmR+WGlF8O3ZjL1wIHypBbIVuHOBzxg=="],
+
    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],

    "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="],
@@ -106,5 +109,7 @@
    "xdg-basedir": ["xdg-basedir@5.1.0", "", {}, "sha512-GCPAHLvrIH13+c0SuacwvRYj2SxJXQ4kaVTT5xgL3kPrz56XxkF21IGhjSE1+W0aw7gpBWRGXLCPnPby6lSpmQ=="],

    "zod": ["zod@4.1.8", "", {}, "sha512-5R1P+WwQqmmMIEACyzSvo4JXHY5WiAFHRMg+zBZKgKS+Q1viRa0C1hmUKtHltoIFKtIdki3pRxkmpP74jnNYHQ=="],
+
+    "oh-my-opencode/@code-yeongyu/comment-checker": ["@code-yeongyu/comment-checker@0.4.1", "", { "os": [ "linux", "win32", "darwin", ], "cpu": [ "x64", "arm64", ], "bin": { "comment-checker": "bin/comment-checker" } }, "sha512-E7p1V8CsRj9hMbwENd9BfxZGWYu+lKS5tXGuNNcNtkRMhWvwM/ononysKpLB7LXdxfSYAn0j7heJydyzEmm+lg=="],
  }
 }
--- a/local-ignore/comment-checker-ts-plan.md
+++ b/local-ignore/comment-checker-ts-plan.md
@@ -1,162 +0,0 @@
-# Comment-Checker TypeScript Port 구현 계획
-
-## 1. 아키텍처 개요
-
-### 1.1 핵심 도전 과제
-
-**OpenCode Hook의 제약사항:**
- `tool.execute.before`: `output.args`에서 파일 경로/내용 접근 가능
- `tool.execute.after`: `tool_input`이 **제공되지 않음** (Claude Code와의 핵심 차이점)
- **해결책**: Before hook에서 데이터를 캡처하여 callID로 키잉된 Map에 저장, After hook에서 조회
-
-### 1.2 디렉토리 구조
-
-```
-src/hooks/comment-checker/
-├── index.ts              # Hook factory, 메인 엔트리포인트
-├── types.ts              # 모든 타입 정의
-├── constants.ts          # 언어 레지스트리, 쿼리 템플릿, 디렉티브 목록
-├── detector.ts           # CommentDetector - web-tree-sitter 기반 코멘트 감지
-├── filters/
-│   ├── index.ts          # 필터 barrel export
-│   ├── bdd.ts            # BDD 패턴 필터
-│   ├── directive.ts      # 린터/타입체커 디렉티브 필터
-│   ├── docstring.ts      # 독스트링 필터
-│   └── shebang.ts        # Shebang 필터
-├── output/
-│   ├── index.ts          # 출력 barrel export
-│   ├── formatter.ts      # FormatHookMessage
-│   └── xml-builder.ts    # BuildCommentsXML
-└── utils.ts              # 유틸리티 함수
-```
-
-### 1.3 데이터 흐름
-
-```
-[write/edit 도구 실행]
-       │
-       ▼
-┌──────────────────────┐
-│ tool.execute.before  │
-│  - 파일 경로 캡처    │
-│  - pendingCalls Map  │
-│    에 저장           │
-└──────────┬───────────┘
-           │
-           ▼
-    [도구 실제 실행]
-           │
-           ▼
-┌──────────────────────┐
-│ tool.execute.after   │
-│  - pendingCalls에서  │
-│    데이터 조회       │
-│  - 파일 읽기         │
-│  - 코멘트 감지       │
-│  - 필터 적용         │
-│  - 메시지 주입       │
-└──────────────────────┘
-```
-
---
-
-## 2. 구현 순서
-
-### Phase 1: 기반 구조
-1. `src/hooks/comment-checker/` 디렉토리 생성
-2. `types.ts` - 모든 타입 정의
-3. `constants.ts` - 언어 레지스트리, 디렉티브 패턴
-
-### Phase 2: 필터 구현
-4. `filters/bdd.ts` - BDD 패턴 필터
-5. `filters/directive.ts` - 디렉티브 필터
-6. `filters/docstring.ts` - 독스트링 필터
-7. `filters/shebang.ts` - Shebang 필터
-8. `filters/index.ts` - 필터 조합
-
-### Phase 3: 코어 로직
-9. `detector.ts` - web-tree-sitter 기반 코멘트 감지
-10. `output/xml-builder.ts` - XML 출력
-11. `output/formatter.ts` - 메시지 포매팅
-
-### Phase 4: Hook 통합
-12. `index.ts` - Hook factory 및 상태 관리
-13. `src/hooks/index.ts` 업데이트 - export 추가
-
-### Phase 5: 의존성 및 빌드
-14. `package.json` 업데이트 - web-tree-sitter 추가
-15. typecheck 및 build 검증
-
---
-
-## 3. 핵심 구현 사항
-
-### 3.1 언어 레지스트리 (38개 언어)
-
-```typescript
-const LANGUAGE_REGISTRY: Record<string, LanguageConfig> = {
-  python: { extensions: [".py"], commentQuery: "(comment) @comment", docstringQuery: "..." },
-  javascript: { extensions: [".js", ".jsx"], commentQuery: "(comment) @comment" },
-  typescript: { extensions: [".ts"], commentQuery: "(comment) @comment" },
-  tsx: { extensions: [".tsx"], commentQuery: "(comment) @comment" },
-  go: { extensions: [".go"], commentQuery: "(comment) @comment" },
-  rust: { extensions: [".rs"], commentQuery: "(line_comment) @comment (block_comment) @comment" },
-  // ... 38개 전체
-}
-```
-
-### 3.2 필터 로직
-
-**BDD 필터**: `given, when, then, arrange, act, assert`
-**Directive 필터**: `noqa, pyright:, eslint-disable, @ts-ignore` 등 30+
-**Docstring 필터**: `IsDocstring || starts with /**`
-**Shebang 필터**: `starts with #!`
-
-### 3.3 출력 형식 (Go 버전과 100% 동일)
-
-```
-COMMENT/DOCSTRING DETECTED - IMMEDIATE ACTION REQUIRED
-
-Your recent changes contain comments or docstrings, which triggered this hook.
-You need to take immediate action. You must follow the conditions below.
-(Listed in priority order - you must always act according to this priority order)
-
-CRITICAL WARNING: This hook message MUST NEVER be ignored...
-
-<comments file="/path/to/file.py">
-	<comment line-number="10">// comment text</comment>
-</comments>
-```
-
---
-
-## 4. 생성할 파일 목록
-
-1. `src/hooks/comment-checker/types.ts`
-2. `src/hooks/comment-checker/constants.ts`
-3. `src/hooks/comment-checker/filters/bdd.ts`
-4. `src/hooks/comment-checker/filters/directive.ts`
-5. `src/hooks/comment-checker/filters/docstring.ts`
-6. `src/hooks/comment-checker/filters/shebang.ts`
-7. `src/hooks/comment-checker/filters/index.ts`
-8. `src/hooks/comment-checker/output/xml-builder.ts`
-9. `src/hooks/comment-checker/output/formatter.ts`
-10. `src/hooks/comment-checker/output/index.ts`
-11. `src/hooks/comment-checker/detector.ts`
-12. `src/hooks/comment-checker/index.ts`
-
-## 5. 수정할 파일 목록
-
-1. `src/hooks/index.ts` - export 추가
-2. `package.json` - web-tree-sitter 의존성
-
---
-
-## 6. Definition of Done
-
- [ ] write/edit 도구 실행 시 코멘트 감지 동작
- [ ] 4개 필터 모두 정상 작동
- [ ] 최소 5개 언어 지원 (Python, JS, TS, TSX, Go)
- [ ] Go 버전과 동일한 출력 형식
- [ ] typecheck 통과
- [ ] build 성공
--- a/local-ignore/push-and-release.sh
+++ b/local-ignore/push-and-release.sh
@@ -1,12 +0,0 @@
-#!/bin/bash
-set -e
-cd /Users/yeongyu/local-workspaces/oh-my-opencode
-
-echo "=== Pushing to origin ==="
-git push -f origin master
-
-echo "=== Triggering workflow ==="
-gh workflow run publish.yml --repo code-yeongyu/oh-my-opencode --ref master -f bump=patch -f version=$1
-
-echo "=== Done! ==="
-echo "Usage: ./local-ignore/push-and-release.sh 0.1.6"
--- a/notepad.md
+++ b/notepad.md
@@ -141,3 +141,705 @@ All tasks execution STARTED: Thu Dec 4 16:52:57 KST 2025

 ---

+## [2025-12-09 16:13] - Task 1: Add file-based logger to shared module
+
+### DISCOVERED ISSUES
+- None - straightforward file copy and modification task
+
+### IMPLEMENTATION DECISIONS
+- Copied logger.ts from opencode-cc-plugin source
+- Changed log file path from `opencode-cc-plugin.log` to `oh-my-opencode.log`
+- Added barrel export from `src/shared/index.ts`
+- Kept original comment for module description
+
+### PROBLEMS FOR NEXT TASKS
+- None identified - logger is now available for use in all new loaders
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Log file path verified: `/tmp/oh-my-opencode.log`
+- Exports verified: `log()` and `getLogFilePath()` now accessible via `src/shared`
+
+### LEARNINGS
+- Source file location: `~/local-workspaces/opencode-cc-plugin/src/shared/logger.ts`
+- Logger uses `fs.appendFileSync` for synchronous file writing
+- Empty catch block intentionally swallows errors to prevent logging from breaking main operations
+
+소요 시간: ~1분
+
+---
+
+## [2025-12-09 16:14] - Task 3: Rename skill-loader to claude-code-skill-loader
+
+### DISCOVERED ISSUES
+- None - straightforward directory rename task
+
+### IMPLEMENTATION DECISIONS
+- Used `mv` command to rename `src/features/skill-loader/` → `src/features/claude-code-skill-loader/`
+- Updated import path in `src/index.ts` (lines 19-22)
+- Did NOT modify internal imports (`../command-loader/types`) since command-loader still exists (Task 2 runs in parallel)
+
+### PROBLEMS FOR NEXT TASKS
+- If Task 2 renames command-loader to claude-code-command-loader, the internal imports in claude-code-skill-loader will need to be updated as part of Task 2's scope
+- The skill-loader's loader.ts:6 and types.ts:1 import from `../command-loader/types`
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Ran: `bun run build` → exit 0, succeeded
+- Directory structure verified: `skill-loader/` deleted, `claude-code-skill-loader/` exists
+
+### LEARNINGS
+- This project uses `mv` for directory rename (acceptable per ANTI-PATTERNS - file creation is forbidden, not rename)
+- Command: `bun run typecheck` for type check, `bun run build` for build
+- skill-loader internal imports use relative paths (`../command-loader/types`) which remain valid after rename
+
+소요 시간: ~2분
+
+---
+
+## [2025-12-09 16:16] - Task 2: Rename command-loader to claude-code-command-loader
+
+### DISCOVERED ISSUES
+- skill-loader (now claude-code-skill-loader) was importing `CommandDefinition` from `../command-loader/types`
+- After renaming command-loader, these references also needed updating
+
+### IMPLEMENTATION DECISIONS
+- Used `mv` command: `src/features/command-loader/` → `src/features/claude-code-command-loader/`
+- Updated import path in `src/index.ts` (lines 13-18)
+- Also updated `claude-code-skill-loader/loader.ts:6` and `types.ts:1` to reference new path
+
+### PROBLEMS FOR NEXT TASKS
+- None identified - all dependent imports updated
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Directory structure verified: `command-loader/` deleted, `claude-code-command-loader/` exists
+- All imports updated: src/index.ts, claude-code-skill-loader/loader.ts, claude-code-skill-loader/types.ts
+
+### LEARNINGS
+- skill-loader depends on command-loader's `CommandDefinition` type via relative import
+- When renaming shared modules, must update ALL dependent modules' imports
+- Task 2 and Task 3 have an implicit dependency through the type import
+
+소요 시간: ~2분
+
+---
+
+## [2025-12-09 16:24] - Task 4: Add claude-code-agent-loader feature
+
+### DISCOVERED ISSUES
+- None - straightforward file copy task
+
+### IMPLEMENTATION DECISIONS
+- Copied 3 files from opencode-cc-plugin: `index.ts`, `loader.ts`, `types.ts`
+- Import path `../../shared/frontmatter` unchanged - already compatible with oh-my-opencode structure
+- No `log()` usage in source files - no logger integration needed
+
+### PROBLEMS FOR NEXT TASKS
+- None identified - agent-loader is self-contained
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Directory structure verified: `claude-code-agent-loader/` created with 3 files
+- Functions exported: `loadUserAgents()`, `loadProjectAgents()`
+
+### LEARNINGS
+- Source location: `~/local-workspaces/opencode-cc-plugin/src/features/agent-loader/`
+- Agent loader uses `parseFrontmatter` from shared module
+- Agent configs loaded from `~/.claude/agents/` (user) and `.claude/agents/` (project)
+- Scope is appended to description: `(user)` or `(project)`
+
+소요 시간: ~1분
+
+---
+
+## [2025-12-09 16:25] - Task 5: Add claude-code-mcp-loader feature
+
+### DISCOVERED ISSUES
+- None - straightforward file copy task
+
+### IMPLEMENTATION DECISIONS
+- Copied 5 files from opencode-cc-plugin: `index.ts`, `loader.ts`, `transformer.ts`, `env-expander.ts`, `types.ts`
+- Import path `../../shared/logger` unchanged - already compatible with oh-my-opencode structure
+- Kept `Bun.file()` usage - oh-my-opencode targets Bun runtime
+- Environment variable expansion supports `${VAR}` and `${VAR:-default}` syntax
+
+### PROBLEMS FOR NEXT TASKS
+- None identified - mcp-loader is self-contained
+- Does NOT conflict with src/mcp/ (builtin MCPs are separate)
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Directory structure verified: `claude-code-mcp-loader/` created with 5 files
+- Functions exported: `loadMcpConfigs()`, `formatLoadedServersForToast()`, `transformMcpServer()`, `expandEnvVars()`, `expandEnvVarsInObject()`
+
+### LEARNINGS
+- Source location: `~/local-workspaces/opencode-cc-plugin/src/features/mcp-loader/`
+- MCP configs loaded from:
+  - `~/.claude/.mcp.json` (user scope)
+  - `.mcp.json` (project scope)
+  - `.claude/.mcp.json` (local scope)
+- Later scope overrides earlier scope for same server name
+- Supports stdio, http, and sse server types
+
+소요 시간: ~1분
+
+---
+
+## [2025-12-09 16:24] - Task 6: Add claude-code-session-state feature
+
+### DISCOVERED ISSUES
+- None - straightforward file copy task
+
+### IMPLEMENTATION DECISIONS
+- Copied 4 files from opencode-cc-plugin: `types.ts`, `state.ts`, `detector.ts`, `index.ts`
+- No import path changes needed - files are completely self-contained
+- No external dependencies - types are defined locally
+
+### PROBLEMS FOR NEXT TASKS
+- Task 7 should import from `./features/claude-code-session-state` in src/index.ts
+- Task 7 should remove local session variables and use the module's getter/setters
+
+### VERIFICATION RESULTS
+- Directory created: `src/features/claude-code-session-state/` (4 files confirmed)
+- Exports available: sessionErrorState, sessionInterruptState, subagentSessions, sessionFirstMessageProcessed (Maps/Sets)
+- Exports available: currentSessionID, currentSessionTitle, mainSessionID (state vars)
+- Exports available: setCurrentSession(), setMainSession(), getCurrentSessionID(), getCurrentSessionTitle(), getMainSessionID() (getters/setters)
+- Exports available: detectInterrupt() function
+
+### LEARNINGS
+- Session state module is completely self-contained - no external dependencies
+- Uses barrel export pattern: index.ts re-exports everything from types, state, detector
+- Source directory: `~/local-workspaces/opencode-cc-plugin/src/features/session-state/`
+
+소요 시간: ~1분
+
+---
+
+## [2025-12-09 16:32] - Task 7: Integrate new features into src/index.ts
+
+### DISCOVERED ISSUES
+- None - integration task with well-defined API from previous tasks
+
+### IMPLEMENTATION DECISIONS
+- Added imports for new modules:
+  - `loadUserAgents`, `loadProjectAgents` from `./features/claude-code-agent-loader`
+  - `loadMcpConfigs` from `./features/claude-code-mcp-loader`
+  - `setCurrentSession`, `setMainSession`, `getMainSessionID`, `getCurrentSessionTitle` from `./features/claude-code-session-state`
+  - `log` from `./shared/logger`
+- Removed local session variables (lines 77-79): `mainSessionID`, `currentSessionID`, `currentSessionTitle`
+- Replaced direct session assignments with setter functions:
+  - `mainSessionID = x` → `setMainSession(x)`
+  - `currentSessionID = x; currentSessionTitle = y` → `setCurrentSession(x, y)`
+- Replaced session variable reads with getter functions:
+  - `mainSessionID` comparisons → `getMainSessionID()`
+  - `currentSessionTitle` reads → `getCurrentSessionTitle()`
+- Added agent loading in config hook: `loadUserAgents()`, `loadProjectAgents()`
+- Added MCP loading in config hook: `await loadMcpConfigs()` (async)
+- Replaced `console.error` with `log()` for config validation errors
+- Renamed local variable `agents` to `builtinAgents` to distinguish from loaded agents
+
+### PROBLEMS FOR NEXT TASKS
+- Task 8 (README update) should document the new Agent Loader and MCP Loader features
+- Should explain the `claude-code-*` naming convention
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Ran: `bun run build` → exit 0, successful build
+- Session tracking verified: all event handlers use getter/setter functions
+- Agent loading verified: config.agent merges builtin + user + project agents
+- MCP loading verified: config.mcp merges builtin MCPs + loaded MCP servers
+
+### LEARNINGS
+- `setCurrentSession(id, title)` sets both ID and title atomically
+- `loadMcpConfigs()` is async - must use `await` in config hook
+- MCP result has `.servers` property that returns the server configs
+- Order matters in spread: later values override earlier (projectAgents > userAgents > builtinAgents)
+
+소요 시간: ~4분
+
+---
+
+## [2025-12-09 16:35] - Task 8: Update README.md documentation
+
+### DISCOVERED ISSUES
+- None - documentation update task
+
+### IMPLEMENTATION DECISIONS
+- Added Agent Loader feature documentation under "Other Features" section (line 235-238)
+  - User scope: `~/.claude/agents/`
+  - Project scope: `./.claude/agents/`
+  - Format: `*.md` files with YAML frontmatter
+- Added MCP Loader feature documentation (line 239-243)
+  - User scope: `~/.claude/.mcp.json`
+  - Project scope: `./.mcp.json`
+  - Local scope: `./.claude/.mcp.json`
+  - Environment variable expansion (`${VAR}` syntax)
+- Added `claude-code-*` naming convention explanation as a blockquote note (line 245)
+  - Explains features migrated from Claude Code
+  - Lists examples: claude-code-command-loader, skill-loader, agent-loader, mcp-loader
+
+### PROBLEMS FOR NEXT TASKS
+- None - this is the final task
+
+### VERIFICATION RESULTS
+- README.md updated with new documentation
+- Style matches existing documentation (bullet points, code blocks for paths)
+- No sections removed or modified (only additions)
+
+### LEARNINGS
+- README.md "Other Features" section is at line 224
+- Existing features: Terminal Title, Command Loader, Skill Loader
+- Documentation style: bold feature name, bullet points for scopes/details
+
+소요 시간: ~1분
+
+---
+
+## [2025-12-09 17:24] - Task 0: Shared Utilities 포팅
+
+### DISCOVERED ISSUES
+- command-executor.ts already existed but had minor whitespace differences (indentation inconsistency)
+- pattern-matcher.ts and hook-disabled.ts import from `../claude-compat/types` which doesn't exist yet in oh-my-opencode
+- Types will be created in Task 1 at `src/hooks/claude-code-hooks/types.ts`
+
+### IMPLEMENTATION DECISIONS
+- Created snake-case.ts and tool-name.ts (no dependencies) - exact copy from source
+- Created temporary stub types at `src/hooks/claude-code-hooks/types.ts` with minimal definitions needed for shared utilities
+- Created pattern-matcher.ts with adjusted import: `../claude-compat/types` → `../hooks/claude-code-hooks/types`
+- Created hook-disabled.ts with adjusted import to point to stub types
+- Added all new utilities to `src/shared/index.ts` using barrel export pattern
+- Stub types include: HookCommand, HookMatcher, ClaudeHooksConfig, ClaudeHookEvent, PluginConfig
+
+### PROBLEMS FOR NEXT TASKS
+- Task 1 will replace stub types with full implementation from opencode-cc-plugin
+- Stub types in `src/hooks/claude-code-hooks/types.ts` are marked with comments indicating they're temporary
+- The real PluginConfig will likely be different - current stub only supports `disabledHooks` field
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- All 5 functions exported: executeHookCommand, objectToSnakeCase, transformToolName, findMatchingHooks, isHookDisabled
+- Import paths verified: pattern-matcher.ts and hook-disabled.ts successfully import from stub types
+
+### LEARNINGS
+- Import paths must be adjusted when porting between different project structures
+- opencode-cc-plugin structure: `src/claude-compat/` → oh-my-opencode structure: `src/hooks/claude-code-hooks/`
+- Stub types strategy allows Task 0 to complete and typecheck to pass before Task 1 implements full types
+- command-executor.ts in oh-my-opencode had indentation inconsistency (not 100% identical to source)
+
+소요 시간: ~5분
+
+---
+
+## [2025-12-09 17:34] - Task 1: types.ts 포팅
+
+### DISCOVERED ISSUES
+- Stub types.ts had `PluginConfig` interface needed by hook-disabled.ts (from Task 0)
+- Full types.ts from opencode-cc-plugin did NOT have `PluginConfig`
+- Typecheck initially failed: Module has no exported member 'PluginConfig'
+
+### IMPLEMENTATION DECISIONS
+- Copied full types.ts (181 lines) from opencode-cc-plugin → oh-my-opencode
+- Preserved ALL types: ClaudeHooksConfig, HookMatcher, PreToolUseInput/Output, PostToolUseInput/Output
+- Preserved deprecated decision fields: `decision?: "allow" | "deny" | "approve" | "block" | "ask"`
+- Added `PluginConfig` interface at end (oh-my-opencode specific type needed by hook-disabled.ts)
+- Kept line 150 comment (`// "pending" | "in_progress" | "completed"`) - existing source comment
+
+### PROBLEMS FOR NEXT TASKS
+- PluginConfig is now available for all subsequent tasks
+- Full type definitions ready for Task 2, 3, 4+ to use
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Verified: ClaudeHooksConfig, HookMatcher, HookCommand types exist
+- Verified: PreToolUseInput/Output, PostToolUseInput/Output types exist
+- Verified: deprecated decision field (approve/block) included in PreToolUseOutput
+- Verified: PluginConfig export added (fixes hook-disabled.ts import)
+
+### LEARNINGS
+- opencode-cc-plugin types.ts: 181 lines, no PluginConfig
+- oh-my-opencode requires PluginConfig for hook disabling functionality
+- Stub-to-full replacement pattern works: stub allows Task 0 typecheck, Task 1 replaces with full implementation
+- Must preserve project-specific types (PluginConfig) when porting from different codebases
+
+소요 시간: ~2분
+
+---
+
+## [2025-12-09 17:39] - Task 3: tool-input-cache.ts 포팅
+
+### DISCOVERED ISSUES
+- None - straightforward file copy task
+
+### IMPLEMENTATION DECISIONS
+- Copied tool-input-cache.ts (48 lines) from opencode-cc-plugin → oh-my-opencode
+- Preserved cache structure:
+  * Key format: `${sessionId}:${toolName}:${invocationId}`
+  * TTL: 60000ms (1 minute) as CACHE_TTL constant
+  * Periodic cleanup: setInterval every CACHE_TTL (60000ms)
+- Preserved original comments from source file (lines 12, 39)
+- Functions: cacheToolInput(), getToolInput()
+- Cache behavior: getToolInput() deletes entry immediately after retrieval (single-use cache)
+
+### PROBLEMS FOR NEXT TASKS
+- Task 4 (pre-tool-use.ts) will call cacheToolInput() to store tool inputs
+- Task 5 (post-tool-use.ts) will call getToolInput() to retrieve cached inputs for transcript building
+- No import path changes needed - this file has no external dependencies
+
+### VERIFICATION RESULTS
+- File created: `src/hooks/claude-code-hooks/tool-input-cache.ts` (48 lines)
+- Functions exported: cacheToolInput(), getToolInput()
+- TTL verified: CACHE_TTL = 60000 (1 minute)
+- Cleanup interval verified: setInterval(cleanup, CACHE_TTL)
+
+### LEARNINGS
+- Tool input cache is a temporary storage for PreToolUse → PostToolUse communication
+- Single-use pattern: getToolInput() deletes entry after first retrieval (line 33)
+- TTL check happens after deletion, so expired entries still return null
+- setInterval runs in background for periodic cleanup of abandoned entries
+- Source location: `~/local-workspaces/opencode-cc-plugin/src/claude-compat/hooks/tool-input-cache.ts`
+
+소요 시간: ~2분
+
+---
+
+## [2025-12-09 17:39] - Task 2: config.ts + transcript.ts + todo.ts 포팅
+
+### DISCOVERED ISSUES
+- transcript.ts had unused imports (ClaudeCodeMessage, ClaudeCodeContent) - same as source file
+- LSP warned about unused types - removed from import to clean up
+
+### IMPLEMENTATION DECISIONS
+- Copied config.ts (101 lines) - no import path changes needed (only uses `./types` and Node.js builtins)
+- Copied transcript.ts (256 lines) - changed import path:
+  * Line 10: `../shared/tool-name` → `../../shared/tool-name` (opencode-cc-plugin depth 1, oh-my-opencode depth 2)
+- Copied todo.ts (78 lines) - no import path changes needed (only uses `./types` and Node.js builtins)
+- Removed unused imports from transcript.ts: ClaudeCodeMessage, ClaudeCodeContent (not used in function bodies)
+- Preserved ALL original comments from source files - these are pre-existing comments
+
+### PROBLEMS FOR NEXT TASKS
+- Task 3 will import cacheToolInput/getToolInput for cache functionality
+- Task 4 will import loadClaudeHooksConfig, buildTranscriptFromSession
+- Task 5 will import transcript building functions for PostToolUse hook
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Files created: config.ts (101 lines), transcript.ts (256 lines), todo.ts (78 lines)
+- Functions available: loadClaudeHooksConfig(), buildTranscriptFromSession(), appendTranscriptEntry(), loadTodoFile(), saveTodoFile()
+- Import paths verified: transcript.ts successfully imports transformToolName from ../../shared
+
+### LEARNINGS
+- Import path depth difference: opencode-cc-plugin `src/claude-compat/` (1 level up) → oh-my-opencode `src/hooks/claude-code-hooks/` (2 levels up)
+- transcript.ts unused imports were present in original source - cleaning them is optional but improves code hygiene
+- config.ts uses Bun.file() for async file reading - compatible with oh-my-opencode's Bun runtime
+- Bun.file().text() automatically handles encoding
+
+소요 시간: ~3분
+
+---
+
+## [2025-12-09 17:48] - Task 4: pre-tool-use.ts 포팅 (+ plugin-config.ts, config-loader.ts)
+
+### DISCOVERED ISSUES
+- pre-tool-use.ts depends on DEFAULT_CONFIG and isHookCommandDisabled which weren't created yet
+- Plan document listed plugin-config.ts and config-loader.ts as separate task (Section 4), but not mentioned in Task 4 instructions
+- These dependency files needed to be created before pre-tool-use.ts could compile
+
+### IMPLEMENTATION DECISIONS
+- Created plugin-config.ts (9 lines) with DEFAULT_CONFIG containing forceZsh and zshPath settings
+  * Minimal version - only fields used by pre-tool-use.ts (not full opencode-cc-plugin config)
+  * forceZsh: true, zshPath: "/bin/zsh"
+- Created config-loader.ts (105 lines) - full copy from opencode-cc-plugin
+  * Changed import: `../claude-compat/types` → `./types`
+  * Changed import: `../shared/logger` → `../../shared/logger`
+  * Functions: loadPluginExtendedConfig(), isHookCommandDisabled()
+  * Supports regex patterns for disabling specific hook commands
+- Created pre-tool-use.ts (172 lines) - full copy with adjusted imports:
+  * `../types` → `./types`
+  * `../../shared` → `../../shared` (unchanged)
+  * `../../config` → `./plugin-config` (NEW file)
+  * `../../config-loader` → `./config-loader` (NEW file)
+- Preserved ALL exit code logic:
+  * exitCode === 2 → decision = "deny"
+  * exitCode === 1 → decision = "ask"
+  * exitCode === 0 → parse JSON for decision
+- Preserved ALL deprecated field support:
+  * decision: "approve" → "allow"
+  * decision: "block" → "deny"
+- Original comments from source preserved (backward compat, spec references)
+
+### PROBLEMS FOR NEXT TASKS
+- Task 5 (post-tool-use.ts) can now import executePreToolUseHooks if needed
+- plugin-config.ts and config-loader.ts are now available for all subsequent hook implementations
+- isHookCommandDisabled pattern can be reused in PostToolUse, UserPromptSubmit, Stop hooks
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Ran: `bun run build` → exit 0, successful
+- Committed: 530c4d6 "feat(hooks): add PreToolUse hook executor"
+  * 4 files: tool-input-cache.ts (Task 3), plugin-config.ts, config-loader.ts, pre-tool-use.ts (Task 4)
+  * 333 insertions total
+- Functions available: executePreToolUseHooks(), isHookCommandDisabled(), loadPluginExtendedConfig()
+- Exit code mapping verified: lines 96-116 check exitCode === 2/1/0
+- Deprecated field mapping verified: lines 132-141 check decision === "approve"/"block"
+
+### LEARNINGS
+- Pre-tool-use.ts depends on plugin configuration that wasn't part of oh-my-opencode's original structure
+- plugin-config.ts only needs subset of opencode-cc-plugin's config.ts (forceZsh, zshPath for executeHookCommand)
+- config-loader.ts provides hook command filtering via regex patterns (disabledHooks config)
+- executeHookCommand from shared/ accepts ExecuteHookOptions{ forceZsh, zshPath } parameter
+- Task 3 + Task 4 grouped in single commit per plan requirement
+- Source: `/Users/yeongyu/local-workspaces/opencode-cc-plugin/src/claude-compat/hooks/pre-tool-use.ts` (173 lines)
+
+소요 시간: ~5분
+
+---
+
+## [2025-12-09 17:52] - Task 5: post-tool-use.ts 포팅
+
+### DISCOVERED ISSUES
+- None - straightforward file copy with import path adjustments
+
+### IMPLEMENTATION DECISIONS
+- Copied post-tool-use.ts (200 lines) from opencode-cc-plugin → oh-my-opencode
+- Import path adjustments:
+  * `../types` → `./types`
+  * `../../shared` → `../../shared` (unchanged)
+  * `../../config` → `./plugin-config`
+  * `../transcript` → `./transcript`
+  * `../../config-loader` → `./config-loader`
+- Preserved ALL transcript logic:
+  * buildTranscriptFromSession() call with client.session.messages() API
+  * Temp file creation in try block
+  * deleteTempTranscript() cleanup in finally block
+- Preserved ALL exit code handling:
+  * exitCode === 2 → warning (continue)
+  * exitCode === 0 → parse JSON for decision: "block"
+  * Non-zero, non-2 → parse JSON for decision: "block"
+- Preserved ALL output fields: block, reason, message, warnings, elapsedMs, additionalContext, continue, stopReason, suppressOutput, systemMessage
+- Original comments from source preserved (PORT FROM DISABLED, cleanup explanation)
+
+### PROBLEMS FOR NEXT TASKS
+- Task 6 (user-prompt-submit.ts, stop.ts) can use similar pattern for hook execution
+- plugin-config.ts, config-loader.ts, transcript.ts dependencies already in place
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Ran: `bun run build` → exit 0, successful
+- File created: `src/hooks/claude-code-hooks/post-tool-use.ts` (200 lines)
+- Functions available: executePostToolUseHooks()
+- Transcript integration verified: buildTranscriptFromSession() imported from ./transcript
+- Cleanup mechanism verified: deleteTempTranscript() in finally block (line 196)
+
+### LEARNINGS
+- PostToolUse differs from PreToolUse: no permission decision (allow/deny/ask), only block/continue
+- PostToolUse provides hook results via message/warnings/additionalContext (observability, not control)
+- Exit code 2 in PostToolUse = warning (not block), collected in warnings array
+- Transcript temp file pattern: create in try, cleanup in finally (prevents disk accumulation)
+- Source: `/Users/yeongyu/local-workspaces/opencode-cc-plugin/src/claude-compat/hooks/post-tool-use.ts` (200 lines)
+
+소요 시간: ~5분
+
+---
+
+## [2025-12-09 17:58] - Task 6: user-prompt-submit.ts + stop.ts 포팅
+
+### DISCOVERED ISSUES
+- None - straightforward file copy with import path adjustments
+
+### IMPLEMENTATION DECISIONS
+- Copied user-prompt-submit.ts (118 lines) from opencode-cc-plugin → oh-my-opencode
+- Copied stop.ts (119 lines) from opencode-cc-plugin → oh-my-opencode
+- Import path adjustments (both files):
+  * `../types` → `./types`
+  * `../../shared` → `../../shared` (unchanged)
+  * `../../config` → `./plugin-config`
+  * `../../config-loader` → `./config-loader`
+  * `../todo` → `./todo` (stop.ts only)
+- Preserved recursion prevention logic in user-prompt-submit.ts:
+  * Tags: `<user-prompt-submit-hook>` (open/close)
+  * Check if prompt already contains tags → return early
+  * Wrap hook stdout with tags to prevent infinite recursion
+- Preserved inject_prompt support:
+  * user-prompt-submit: messages array collection for injection
+  * stop: injectPrompt field in result (from output.inject_prompt or output.reason)
+- Preserved stopHookActiveState management in stop.ts:
+  * Module-level Map<string, boolean> for per-session state
+  * setStopHookActive(), getStopHookActive() exported
+  * State persists across hook invocations
+- Preserved exit code handling:
+  * stop.ts: exitCode === 2 → block with reason
+  * user-prompt-submit.ts: exitCode !== 0 → check JSON for decision: "block"
+
+### PROBLEMS FOR NEXT TASKS
+- Task 7 (hook-message-injector) will use the message injection pattern
+- Task 8 (Factory + Integration) will wire these hooks to OpenCode lifecycle events
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Ran: `bun run build` → exit 0, successful
+- Files created:
+  * `src/hooks/claude-code-hooks/user-prompt-submit.ts` (115 lines)
+  * `src/hooks/claude-code-hooks/stop.ts` (119 lines)
+- Functions available:
+  * executeUserPromptSubmitHooks() with UserPromptSubmitContext → UserPromptSubmitResult
+  * executeStopHooks() with StopContext → StopResult
+  * setStopHookActive(), getStopHookActive()
+- Recursion prevention verified: lines 47-52 check for tag presence
+- inject_prompt field verified: stop.ts line 102 sets injectPrompt from output
+
+### LEARNINGS
+- user-prompt-submit uses tag wrapping pattern to prevent infinite hook loops
+- stop hook can inject prompts into session via injectPrompt result field
+- stopHookActiveState Map persists across hook invocations (module-level state)
+- getTodoPath() from ./todo provides todo file path for Stop hook context
+- Source files:
+  * `/Users/yeongyu/local-workspaces/opencode-cc-plugin/src/claude-compat/hooks/user-prompt-submit.ts` (118 lines)
+  * `/Users/yeongyu/local-workspaces/opencode-cc-plugin/src/claude-compat/hooks/stop.ts` (119 lines)
+
+소요 시간: ~3분
+
+---
+
+## [2025-12-09 17:58] - Task 7: hook-message-injector 포팅
+
+### DISCOVERED ISSUES
+- None - straightforward file copy task
+
+### IMPLEMENTATION DECISIONS
+- Created `src/features/hook-message-injector/` directory
+- Copied 4 files from opencode-cc-plugin → oh-my-opencode:
+  * constants.ts (9 lines): XDG-based path definitions (MESSAGE_STORAGE, PART_STORAGE)
+  * types.ts (46 lines): MessageMeta, OriginalMessageContext, TextPart interfaces
+  * injector.ts (142 lines): injectHookMessage() implementation with message/part storage
+  * index.ts (3 lines): Barrel export
+- No import path changes needed - module is self-contained
+- Preserved XDG_DATA_HOME environment variable support
+- Preserved message fallback logic: finds nearest message with agent/model/tools if not provided
+
+### PROBLEMS FOR NEXT TASKS
+- Task 8 (Factory + Integration) will import injectHookMessage from this module
+- Hook executors (user-prompt-submit, stop) can use injectHookMessage to store hook messages
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Files created: src/features/hook-message-injector/ (4 files)
+- Functions exported: injectHookMessage()
+- Types exported: MessageMeta, OriginalMessageContext, TextPart
+- Constants exported: MESSAGE_STORAGE, PART_STORAGE (XDG-based paths)
+
+### LEARNINGS
+- Message injector uses XDG_DATA_HOME for storage (~/.local/share/opencode/storage/)
+- Message storage structure: sessionID → messageID.json (meta) + partID.json (content)
+- Fallback logic: searches recent messages for agent/model/tools if originalMessage is incomplete
+- Part-based storage allows incremental message building
+- Source: `/Users/yeongyu/local-workspaces/opencode-cc-plugin/src/features/hook-message-injector/`
+
+소요 시간: ~2분
+
+---
+
+## [2025-12-09 18:08] - Task 8: Factory 생성 + 통합
+
+### DISCOVERED ISSUES
+- None - final integration task with well-defined hook executors from previous tasks
+
+### IMPLEMENTATION DECISIONS
+- Created `src/hooks/claude-code-hooks/index.ts` (146 lines) with createClaudeCodeHooksHook() factory
+- Factory returns hook handler object with 3 handlers:
+  * `tool.execute.before`: Executes executePreToolUseHooks()
+    - Loads config dynamically (async) on each invocation
+    - Maps OpenCode input → PreToolUseContext
+    - Caches tool input for PostToolUse
+    - Handles deny/ask decisions (deny throws error, ask logs warning)
+  * `tool.execute.after`: Executes executePostToolUseHooks()
+    - Retrieves cached tool input via getToolInput()
+    - Maps OpenCode input → PostToolUseContext with client wrapper
+    - Appends hook message to output if provided
+    - Throws error if block decision returned
+  * `event`: Executes executeStopHooks() for session.idle
+    - Filters event.type === "session.idle"
+    - Maps OpenCode event → StopContext
+    - Injects prompt via ctx.client.session.prompt() if injectPrompt returned
+- Updated `src/hooks/index.ts`: Added createClaudeCodeHooksHook export
+- Updated `src/index.ts`: 
+  * Imported createClaudeCodeHooksHook
+  * Created claudeCodeHooks instance
+  * Registered handlers in tool.execute.before, tool.execute.after, event hooks
+  * Claude hooks run FIRST in execution order (before other hooks)
+- Config loading: Async loadClaudeHooksConfig() and loadPluginExtendedConfig() called in each handler (not cached)
+- Transcript path: Uses getTranscriptPath() function (not buildTranscriptPath which doesn't exist)
+
+### PROBLEMS FOR NEXT TASKS
+- None - this is the final task (Task 8)
+- All Claude Code Hooks now integrated into oh-my-opencode plugin system
+
+### VERIFICATION RESULTS
+- Ran: `bun run typecheck` → exit 0, no errors
+- Ran: `bun run build` → exit 0, successful build
+- Files modified:
+  * src/hooks/claude-code-hooks/index.ts (created)
+  * src/hooks/index.ts (export added)
+  * src/index.ts (hook registration)
+- Hook handler registration verified: claudeCodeHooks handlers called in all 3 hook points
+- Execution order verified: Claude hooks run before existing hooks in tool.execute.*
+
+### LEARNINGS
+- OpenCode Plugin API: Factory pattern createXxxHook(ctx: PluginInput) → handlers object
+- OpenCode does NOT have chat.params hook → UserPromptSubmit not implemented in factory
+- Config loading must be async → call loadClaudeHooksConfig() in each handler, not once during initialization
+- Tool input cache is module-level state → cacheToolInput/getToolInput work across handlers
+- Stop hook only triggers on session.idle event → filter event.type
+- Import path: getTranscriptPath (exists), not buildTranscriptPath (doesn't exist)
+
+소요 시간: ~6분
+
+---
+
+## [2025-12-09 18:16] - hook-message-injector 사용 패턴 크로스체크
+
+### DISCOVERED ISSUES
+- **CRITICAL**: UserPromptSubmit hooks가 oh-my-opencode에 완전히 누락됨
+- opencode-cc-plugin에서는 chat.message hook으로 UserPromptSubmit 처리
+- oh-my-opencode에는 chat.message hook이 구현되지 않음
+- user-prompt-submit.ts는 정의만 있고 실제 사용처 없음
+
+### IMPLEMENTATION DECISIONS
+- PostToolUse는 이미 올바르게 구현됨:
+  * opencode-cc-plugin: result.message를 tool output에 append
+  * oh-my-opencode: 동일한 방식 사용 (claude-code-hooks/index.ts:95-97)
+  * injectHookMessage() 불필요
+- UserPromptSubmit 구현 추가:
+  * chat.message hook handler 추가 (claude-code-hooks/index.ts)
+  * executeUserPromptSubmitHooks() 호출
+  * sessionFirstMessageProcessed Set으로 첫 메시지 skip (title generation)
+  * result.messages가 있으면 injectHookMessage() 호출
+  * src/index.ts에 hook 등록
+- Import 추가:
+  * executeUserPromptSubmitHooks, UserPromptSubmitContext, MessagePart from ./user-prompt-submit
+  * injectHookMessage from ../../features/hook-message-injector
+
+### PROBLEMS FOR NEXT TASKS
+- None - UserPromptSubmit 통합 완료
+
+### VERIFICATION RESULTS
+- Ran: `bunx tsc --noEmit` → exit 0, no errors
+- Ran: `bun run build` → exit 0, successful build
+- Files modified:
+  * src/hooks/claude-code-hooks/index.ts (chat.message handler 추가)
+  * src/index.ts (chat.message hook 등록)
+- Verified OpenCode Plugin API: chat.message hook 공식 지원 확인 (@opencode-ai/plugin/dist/index.d.ts:112-123)
+
+### LEARNINGS
+- OpenCode Plugin API에 chat.message hook 존재:
+  * input: sessionID, agent?, model?, messageID?
+  * output: message, parts[]
+- PostToolUse는 tool output에 직접 append (injectHookMessage 불필요)
+- UserPromptSubmit는 file system injection 사용 (injectHookMessage 필수)
+- opencode-cc-plugin 구조: src/plugin/chat-handler.ts → handleChatMessage()
+- oh-my-opencode 구조: src/hooks/claude-code-hooks/index.ts → createClaudeCodeHooksHook()
+- 첫 메시지 skip 로직: title generation을 위해 UserPromptSubmit hooks 실행 안 함
+
+소요 시간: ~8분
+
+---
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "oh-my-opencode",
-  "version": "0.1.30",
+  "version": "0.3.0",
  "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
  "main": "dist/index.js",
  "types": "dist/index.d.ts",
@@ -44,13 +44,14 @@
  "dependencies": {
    "@ast-grep/cli": "^0.40.0",
    "@ast-grep/napi": "^0.40.0",
-    "@code-yeongyu/comment-checker": "^0.4.1",
+    "@code-yeongyu/comment-checker": "^0.5.0",
    "@opencode-ai/plugin": "^1.0.7",
    "xdg-basedir": "^5.1.0",
    "zod": "^4.1.8"
  },
  "devDependencies": {
    "bun-types": "latest",
+    "oh-my-opencode": "^0.1.30",
    "typescript": "^5.7.3"
  },
  "peerDependencies": {
--- a/src/features/claude-code-agent-loader/index.ts
+++ b/src/features/claude-code-agent-loader/index.ts
@@ -0,0 +1,2 @@
+export * from "./types"
+export * from "./loader"
--- a/src/features/claude-code-agent-loader/loader.ts
+++ b/src/features/claude-code-agent-loader/loader.ts
@@ -0,0 +1,93 @@
+import { existsSync, readdirSync, readFileSync } from "fs"
+import { homedir } from "os"
+import { join, basename } from "path"
+import type { AgentConfig } from "@opencode-ai/sdk"
+import { parseFrontmatter } from "../../shared/frontmatter"
+import type { AgentScope, AgentFrontmatter, LoadedAgent } from "./types"
+
+function parseToolsConfig(toolsStr?: string): Record<string, boolean> | undefined {
+  if (!toolsStr) return undefined
+
+  const tools = toolsStr.split(",").map((t) => t.trim()).filter(Boolean)
+  if (tools.length === 0) return undefined
+
+  const result: Record<string, boolean> = {}
+  for (const tool of tools) {
+    result[tool.toLowerCase()] = true
+  }
+  return result
+}
+
+function isMarkdownFile(entry: { name: string; isFile: () => boolean }): boolean {
+  return !entry.name.startsWith(".") && entry.name.endsWith(".md") && entry.isFile()
+}
+
+function loadAgentsFromDir(agentsDir: string, scope: AgentScope): LoadedAgent[] {
+  if (!existsSync(agentsDir)) {
+    return []
+  }
+
+  const entries = readdirSync(agentsDir, { withFileTypes: true })
+  const agents: LoadedAgent[] = []
+
+  for (const entry of entries) {
+    if (!isMarkdownFile(entry)) continue
+
+    const agentPath = join(agentsDir, entry.name)
+    const agentName = basename(entry.name, ".md")
+
+    try {
+      const content = readFileSync(agentPath, "utf-8")
+      const { data, body } = parseFrontmatter<AgentFrontmatter>(content)
+
+       const name = data.name || agentName
+       const originalDescription = data.description || ""
+
+       const formattedDescription = `(${scope}) ${originalDescription}`
+
+       const config: AgentConfig = {
+         description: formattedDescription,
+         mode: "subagent",
+         prompt: body.trim(),
+       }
+
+       const toolsConfig = parseToolsConfig(data.tools)
+      if (toolsConfig) {
+        config.tools = toolsConfig
+      }
+
+      agents.push({
+        name,
+        path: agentPath,
+        config,
+        scope,
+      })
+    } catch {
+      continue
+    }
+  }
+
+  return agents
+}
+
+export function loadUserAgents(): Record<string, AgentConfig> {
+  const userAgentsDir = join(homedir(), ".claude", "agents")
+  const agents = loadAgentsFromDir(userAgentsDir, "user")
+
+  const result: Record<string, AgentConfig> = {}
+  for (const agent of agents) {
+    result[agent.name] = agent.config
+  }
+  return result
+}
+
+export function loadProjectAgents(): Record<string, AgentConfig> {
+  const projectAgentsDir = join(process.cwd(), ".claude", "agents")
+  const agents = loadAgentsFromDir(projectAgentsDir, "project")
+
+  const result: Record<string, AgentConfig> = {}
+  for (const agent of agents) {
+    result[agent.name] = agent.config
+  }
+  return result
+}
--- a/src/features/claude-code-agent-loader/types.ts
+++ b/src/features/claude-code-agent-loader/types.ts
@@ -0,0 +1,17 @@
+import type { AgentConfig } from "@opencode-ai/sdk"
+
+export type AgentScope = "user" | "project"
+
+export interface AgentFrontmatter {
+  name?: string
+  description?: string
+  model?: string
+  tools?: string
+}
+
+export interface LoadedAgent {
+  name: string
+  path: string
+  config: AgentConfig
+  scope: AgentScope
+}
--- a/src/features/claude-code-command-loader/index.ts
+++ b/src/features/claude-code-command-loader/index.ts
@@ -0,0 +1,2 @@
+export * from "./types"
+export * from "./loader"
--- a/src/features/claude-code-command-loader/loader.ts
+++ b/src/features/claude-code-command-loader/loader.ts
@@ -0,0 +1,94 @@
+import { existsSync, readdirSync, readFileSync } from "fs"
+import { homedir } from "os"
+import { join, basename } from "path"
+import { parseFrontmatter } from "../../shared/frontmatter"
+import { sanitizeModelField } from "../../shared/model-sanitizer"
+import type { CommandScope, CommandDefinition, CommandFrontmatter, LoadedCommand } from "./types"
+
+function isMarkdownFile(entry: { name: string; isFile: () => boolean }): boolean {
+  return !entry.name.startsWith(".") && entry.name.endsWith(".md") && entry.isFile()
+}
+
+function loadCommandsFromDir(commandsDir: string, scope: CommandScope): LoadedCommand[] {
+  if (!existsSync(commandsDir)) {
+    return []
+  }
+
+  const entries = readdirSync(commandsDir, { withFileTypes: true })
+  const commands: LoadedCommand[] = []
+
+  for (const entry of entries) {
+    if (!isMarkdownFile(entry)) continue
+
+    const commandPath = join(commandsDir, entry.name)
+    const commandName = basename(entry.name, ".md")
+
+    try {
+      const content = readFileSync(commandPath, "utf-8")
+      const { data, body } = parseFrontmatter<CommandFrontmatter>(content)
+
+      const wrappedTemplate = `<command-instruction>
+${body.trim()}
+</command-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`
+
+      const formattedDescription = `(${scope}) ${data.description || ""}`
+
+      const definition: CommandDefinition = {
+        name: commandName,
+        description: formattedDescription,
+        template: wrappedTemplate,
+        agent: data.agent,
+        model: sanitizeModelField(data.model),
+        subtask: data.subtask,
+        argumentHint: data["argument-hint"],
+      }
+
+      commands.push({
+        name: commandName,
+        path: commandPath,
+        definition,
+        scope,
+      })
+    } catch {
+      continue
+    }
+  }
+
+  return commands
+}
+
+function commandsToRecord(commands: LoadedCommand[]): Record<string, CommandDefinition> {
+  const result: Record<string, CommandDefinition> = {}
+  for (const cmd of commands) {
+    result[cmd.name] = cmd.definition
+  }
+  return result
+}
+
+export function loadUserCommands(): Record<string, CommandDefinition> {
+  const userCommandsDir = join(homedir(), ".claude", "commands")
+  const commands = loadCommandsFromDir(userCommandsDir, "user")
+  return commandsToRecord(commands)
+}
+
+export function loadProjectCommands(): Record<string, CommandDefinition> {
+  const projectCommandsDir = join(process.cwd(), ".claude", "commands")
+  const commands = loadCommandsFromDir(projectCommandsDir, "project")
+  return commandsToRecord(commands)
+}
+
+export function loadOpencodeGlobalCommands(): Record<string, CommandDefinition> {
+  const opencodeCommandsDir = join(homedir(), ".config", "opencode", "command")
+  const commands = loadCommandsFromDir(opencodeCommandsDir, "opencode")
+  return commandsToRecord(commands)
+}
+
+export function loadOpencodeProjectCommands(): Record<string, CommandDefinition> {
+  const opencodeProjectDir = join(process.cwd(), ".opencode", "command")
+  const commands = loadCommandsFromDir(opencodeProjectDir, "opencode-project")
+  return commandsToRecord(commands)
+}
--- a/src/features/claude-code-command-loader/types.ts
+++ b/src/features/claude-code-command-loader/types.ts
@@ -0,0 +1,26 @@
+export type CommandScope = "user" | "project" | "opencode" | "opencode-project"
+
+export interface CommandDefinition {
+  name: string
+  description?: string
+  template: string
+  agent?: string
+  model?: string
+  subtask?: boolean
+  argumentHint?: string
+}
+
+export interface CommandFrontmatter {
+  description?: string
+  "argument-hint"?: string
+  agent?: string
+  model?: string
+  subtask?: boolean
+}
+
+export interface LoadedCommand {
+  name: string
+  path: string
+  definition: CommandDefinition
+  scope: CommandScope
+}
--- a/src/features/claude-code-mcp-loader/env-expander.ts
+++ b/src/features/claude-code-mcp-loader/env-expander.ts
@@ -0,0 +1,27 @@
+export function expandEnvVars(value: string): string {
+  return value.replace(
+    /\$\{([^}:]+)(?::-([^}]*))?\}/g,
+    (_, varName: string, defaultValue?: string) => {
+      const envValue = process.env[varName]
+      if (envValue !== undefined) return envValue
+      if (defaultValue !== undefined) return defaultValue
+      return ""
+    }
+  )
+}
+
+export function expandEnvVarsInObject<T>(obj: T): T {
+  if (obj === null || obj === undefined) return obj
+  if (typeof obj === "string") return expandEnvVars(obj) as T
+  if (Array.isArray(obj)) {
+    return obj.map((item) => expandEnvVarsInObject(item)) as T
+  }
+  if (typeof obj === "object") {
+    const result: Record<string, unknown> = {}
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = expandEnvVarsInObject(value)
+    }
+    return result as T
+  }
+  return obj
+}
--- a/src/features/claude-code-mcp-loader/index.ts
+++ b/src/features/claude-code-mcp-loader/index.ts
@@ -0,0 +1,11 @@
+/**
+ * MCP Configuration Loader
+ *
+ * Loads Claude Code .mcp.json format configurations from multiple scopes
+ * and transforms them to OpenCode SDK format
+ */
+
+export * from "./types"
+export * from "./loader"
+export * from "./transformer"
+export * from "./env-expander"
--- a/src/features/claude-code-mcp-loader/loader.ts
+++ b/src/features/claude-code-mcp-loader/loader.ts
@@ -0,0 +1,89 @@
+import { existsSync } from "fs"
+import { homedir } from "os"
+import { join } from "path"
+import type {
+  ClaudeCodeMcpConfig,
+  LoadedMcpServer,
+  McpLoadResult,
+  McpScope,
+} from "./types"
+import { transformMcpServer } from "./transformer"
+import { log } from "../../shared/logger"
+
+interface McpConfigPath {
+  path: string
+  scope: McpScope
+}
+
+function getMcpConfigPaths(): McpConfigPath[] {
+  const home = homedir()
+  const cwd = process.cwd()
+
+  return [
+    { path: join(home, ".claude", ".mcp.json"), scope: "user" },
+    { path: join(cwd, ".mcp.json"), scope: "project" },
+    { path: join(cwd, ".claude", ".mcp.json"), scope: "local" },
+  ]
+}
+
+async function loadMcpConfigFile(
+  filePath: string
+): Promise<ClaudeCodeMcpConfig | null> {
+  if (!existsSync(filePath)) {
+    return null
+  }
+
+  try {
+    const content = await Bun.file(filePath).text()
+    return JSON.parse(content) as ClaudeCodeMcpConfig
+  } catch (error) {
+    log(`Failed to load MCP config from ${filePath}`, error)
+    return null
+  }
+}
+
+export async function loadMcpConfigs(): Promise<McpLoadResult> {
+  const servers: McpLoadResult["servers"] = {}
+  const loadedServers: LoadedMcpServer[] = []
+  const paths = getMcpConfigPaths()
+
+  for (const { path, scope } of paths) {
+    const config = await loadMcpConfigFile(path)
+    if (!config?.mcpServers) continue
+
+    for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+      if (serverConfig.disabled) {
+        log(`Skipping disabled MCP server "${name}"`, { path })
+        continue
+      }
+
+      try {
+        const transformed = transformMcpServer(name, serverConfig)
+        servers[name] = transformed
+
+        const existingIndex = loadedServers.findIndex((s) => s.name === name)
+        if (existingIndex !== -1) {
+          loadedServers.splice(existingIndex, 1)
+        }
+
+        loadedServers.push({ name, scope, config: transformed })
+
+        log(`Loaded MCP server "${name}" from ${scope}`, { path })
+      } catch (error) {
+        log(`Failed to transform MCP server "${name}"`, error)
+      }
+    }
+  }
+
+  return { servers, loadedServers }
+}
+
+export function formatLoadedServersForToast(
+  loadedServers: LoadedMcpServer[]
+): string {
+  if (loadedServers.length === 0) return ""
+
+  return loadedServers
+    .map((server) => `${server.name} (${server.scope})`)
+    .join(", ")
+}
--- a/src/features/claude-code-mcp-loader/transformer.ts
+++ b/src/features/claude-code-mcp-loader/transformer.ts
@@ -0,0 +1,53 @@
+import type {
+  ClaudeCodeMcpServer,
+  McpLocalConfig,
+  McpRemoteConfig,
+  McpServerConfig,
+} from "./types"
+import { expandEnvVarsInObject } from "./env-expander"
+
+export function transformMcpServer(
+  name: string,
+  server: ClaudeCodeMcpServer
+): McpServerConfig {
+  const expanded = expandEnvVarsInObject(server)
+  const serverType = expanded.type ?? "stdio"
+
+  if (serverType === "http" || serverType === "sse") {
+    if (!expanded.url) {
+      throw new Error(
+        `MCP server "${name}" requires url for type "${serverType}"`
+      )
+    }
+
+    const config: McpRemoteConfig = {
+      type: "remote",
+      url: expanded.url,
+      enabled: true,
+    }
+
+    if (expanded.headers && Object.keys(expanded.headers).length > 0) {
+      config.headers = expanded.headers
+    }
+
+    return config
+  }
+
+  if (!expanded.command) {
+    throw new Error(`MCP server "${name}" requires command for stdio type`)
+  }
+
+  const commandArray = [expanded.command, ...(expanded.args ?? [])]
+
+  const config: McpLocalConfig = {
+    type: "local",
+    command: commandArray,
+    enabled: true,
+  }
+
+  if (expanded.env && Object.keys(expanded.env).length > 0) {
+    config.environment = expanded.env
+  }
+
+  return config
+}
--- a/src/features/claude-code-mcp-loader/types.ts
+++ b/src/features/claude-code-mcp-loader/types.ts
@@ -0,0 +1,42 @@
+export type McpScope = "user" | "project" | "local"
+
+export interface ClaudeCodeMcpServer {
+  type?: "http" | "sse" | "stdio"
+  url?: string
+  command?: string
+  args?: string[]
+  env?: Record<string, string>
+  headers?: Record<string, string>
+  disabled?: boolean
+}
+
+export interface ClaudeCodeMcpConfig {
+  mcpServers?: Record<string, ClaudeCodeMcpServer>
+}
+
+export interface McpLocalConfig {
+  type: "local"
+  command: string[]
+  environment?: Record<string, string>
+  enabled?: boolean
+}
+
+export interface McpRemoteConfig {
+  type: "remote"
+  url: string
+  headers?: Record<string, string>
+  enabled?: boolean
+}
+
+export type McpServerConfig = McpLocalConfig | McpRemoteConfig
+
+export interface LoadedMcpServer {
+  name: string
+  scope: McpScope
+  config: McpServerConfig
+}
+
+export interface McpLoadResult {
+  servers: Record<string, McpServerConfig>
+  loadedServers: LoadedMcpServer[]
+}
--- a/src/features/claude-code-session-state/detector.ts
+++ b/src/features/claude-code-session-state/detector.ts
@@ -0,0 +1,21 @@
+export function detectInterrupt(error: unknown): boolean {
+  if (!error) return false
+
+  if (typeof error === "object") {
+    const errObj = error as Record<string, unknown>
+    const name = errObj.name as string | undefined
+    const message = errObj.message as string | undefined
+
+    if (name === "MessageAbortedError" || name === "AbortError") return true
+    if (name === "DOMException" && message?.includes("abort")) return true
+    const msgLower = message?.toLowerCase()
+    if (msgLower?.includes("aborted") || msgLower?.includes("cancelled") || msgLower?.includes("interrupted")) return true
+  }
+
+  if (typeof error === "string") {
+    const lower = error.toLowerCase()
+    return lower.includes("abort") || lower.includes("cancel") || lower.includes("interrupt")
+  }
+
+  return false
+}
--- a/src/features/claude-code-session-state/index.ts
+++ b/src/features/claude-code-session-state/index.ts
@@ -0,0 +1,3 @@
+export * from "./types"
+export * from "./state"
+export * from "./detector"
--- a/src/features/claude-code-session-state/state.ts
+++ b/src/features/claude-code-session-state/state.ts
@@ -0,0 +1,31 @@
+import type { SessionErrorState, SessionInterruptState } from "./types"
+
+export const sessionErrorState = new Map<string, SessionErrorState>()
+export const sessionInterruptState = new Map<string, SessionInterruptState>()
+export const subagentSessions = new Set<string>()
+export const sessionFirstMessageProcessed = new Set<string>()
+
+export let currentSessionID: string | undefined
+export let currentSessionTitle: string | undefined
+export let mainSessionID: string | undefined
+
+export function setCurrentSession(id: string | undefined, title: string | undefined) {
+  currentSessionID = id
+  currentSessionTitle = title
+}
+
+export function setMainSession(id: string | undefined) {
+  mainSessionID = id
+}
+
+export function getCurrentSessionID(): string | undefined {
+  return currentSessionID
+}
+
+export function getCurrentSessionTitle(): string | undefined {
+  return currentSessionTitle
+}
+
+export function getMainSessionID(): string | undefined {
+  return mainSessionID
+}
--- a/src/features/claude-code-session-state/types.ts
+++ b/src/features/claude-code-session-state/types.ts
@@ -0,0 +1,8 @@
+export interface SessionErrorState {
+  hasError: boolean
+  errorMessage?: string
+}
+
+export interface SessionInterruptState {
+  interrupted: boolean
+}
--- a/src/features/claude-code-skill-loader/index.ts
+++ b/src/features/claude-code-skill-loader/index.ts
@@ -0,0 +1,2 @@
+export * from "./types"
+export * from "./loader"
--- a/src/features/claude-code-skill-loader/loader.ts
+++ b/src/features/claude-code-skill-loader/loader.ts
@@ -0,0 +1,85 @@
+import { existsSync, readdirSync, readFileSync, statSync, readlinkSync } from "fs"
+import { homedir } from "os"
+import { join, resolve } from "path"
+import { parseFrontmatter } from "../../shared/frontmatter"
+import { sanitizeModelField } from "../../shared/model-sanitizer"
+import type { CommandDefinition } from "../claude-code-command-loader/types"
+import type { SkillScope, SkillMetadata, LoadedSkillAsCommand } from "./types"
+
+function loadSkillsFromDir(skillsDir: string, scope: SkillScope): LoadedSkillAsCommand[] {
+  if (!existsSync(skillsDir)) {
+    return []
+  }
+
+  const entries = readdirSync(skillsDir, { withFileTypes: true })
+  const skills: LoadedSkillAsCommand[] = []
+
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue
+
+    const skillPath = join(skillsDir, entry.name)
+
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue
+
+    let resolvedPath = skillPath
+    if (statSync(skillPath, { throwIfNoEntry: false })?.isSymbolicLink()) {
+      resolvedPath = resolve(skillPath, "..", readlinkSync(skillPath))
+    }
+
+    const skillMdPath = join(resolvedPath, "SKILL.md")
+    if (!existsSync(skillMdPath)) continue
+
+    try {
+      const content = readFileSync(skillMdPath, "utf-8")
+      const { data, body } = parseFrontmatter<SkillMetadata>(content)
+
+      const skillName = data.name || entry.name
+      const originalDescription = data.description || ""
+      const formattedDescription = `(${scope} - Skill) ${originalDescription}`
+
+      const wrappedTemplate = `<skill-instruction>
+${body.trim()}
+</skill-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`
+
+      const definition: CommandDefinition = {
+        name: skillName,
+        description: formattedDescription,
+        template: wrappedTemplate,
+        model: sanitizeModelField(data.model),
+      }
+
+      skills.push({
+        name: skillName,
+        path: resolvedPath,
+        definition,
+        scope,
+      })
+    } catch {
+      continue
+    }
+  }
+
+  return skills
+}
+
+export function loadUserSkillsAsCommands(): Record<string, CommandDefinition> {
+  const userSkillsDir = join(homedir(), ".claude", "skills")
+  const skills = loadSkillsFromDir(userSkillsDir, "user")
+  return skills.reduce((acc, skill) => {
+    acc[skill.name] = skill.definition
+    return acc
+  }, {} as Record<string, CommandDefinition>)
+}
+
+export function loadProjectSkillsAsCommands(): Record<string, CommandDefinition> {
+  const projectSkillsDir = join(process.cwd(), ".claude", "skills")
+  const skills = loadSkillsFromDir(projectSkillsDir, "project")
+  return skills.reduce((acc, skill) => {
+    acc[skill.name] = skill.definition
+    return acc
+  }, {} as Record<string, CommandDefinition>)
+}
--- a/src/features/claude-code-skill-loader/types.ts
+++ b/src/features/claude-code-skill-loader/types.ts
@@ -0,0 +1,16 @@
+import type { CommandDefinition } from "../claude-code-command-loader/types"
+
+export type SkillScope = "user" | "project"
+
+export interface SkillMetadata {
+  name: string
+  description: string
+  model?: string
+}
+
+export interface LoadedSkillAsCommand {
+  name: string
+  path: string
+  definition: CommandDefinition
+  scope: SkillScope
+}
--- a/src/features/hook-message-injector/constants.ts
+++ b/src/features/hook-message-injector/constants.ts
@@ -0,0 +1,8 @@
+import { join } from "node:path"
+import { homedir } from "node:os"
+
+const xdgData = process.env.XDG_DATA_HOME || join(homedir(), ".local", "share")
+
+export const OPENCODE_STORAGE = join(xdgData, "opencode", "storage")
+export const MESSAGE_STORAGE = join(OPENCODE_STORAGE, "message")
+export const PART_STORAGE = join(OPENCODE_STORAGE, "part")
--- a/src/features/hook-message-injector/index.ts
+++ b/src/features/hook-message-injector/index.ts
@@ -0,0 +1,2 @@
+export { injectHookMessage } from "./injector"
+export type { MessageMeta, OriginalMessageContext, TextPart } from "./types"
--- a/src/features/hook-message-injector/injector.ts
+++ b/src/features/hook-message-injector/injector.ts
@@ -0,0 +1,141 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { MESSAGE_STORAGE, PART_STORAGE } from "./constants"
+import type { MessageMeta, OriginalMessageContext, TextPart } from "./types"
+
+interface StoredMessage {
+  agent?: string
+  model?: { providerID?: string; modelID?: string }
+  tools?: Record<string, boolean>
+}
+
+function findNearestMessageWithFields(messageDir: string): StoredMessage | null {
+  try {
+    const files = readdirSync(messageDir)
+      .filter((f) => f.endsWith(".json"))
+      .sort()
+      .reverse()
+
+    for (const file of files) {
+      try {
+        const content = readFileSync(join(messageDir, file), "utf-8")
+        const msg = JSON.parse(content) as StoredMessage
+        if (msg.agent && msg.model?.providerID && msg.model?.modelID) {
+          return msg
+        }
+      } catch {
+        continue
+      }
+    }
+  } catch {
+    return null
+  }
+  return null
+}
+
+function generateMessageId(): string {
+  const timestamp = Date.now().toString(16)
+  const random = Math.random().toString(36).substring(2, 14)
+  return `msg_${timestamp}${random}`
+}
+
+function generatePartId(): string {
+  const timestamp = Date.now().toString(16)
+  const random = Math.random().toString(36).substring(2, 10)
+  return `prt_${timestamp}${random}`
+}
+
+function getOrCreateMessageDir(sessionID: string): string {
+  if (!existsSync(MESSAGE_STORAGE)) {
+    mkdirSync(MESSAGE_STORAGE, { recursive: true })
+  }
+
+  const directPath = join(MESSAGE_STORAGE, sessionID)
+  if (existsSync(directPath)) {
+    return directPath
+  }
+
+  for (const dir of readdirSync(MESSAGE_STORAGE)) {
+    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
+    if (existsSync(sessionPath)) {
+      return sessionPath
+    }
+  }
+
+  mkdirSync(directPath, { recursive: true })
+  return directPath
+}
+
+export function injectHookMessage(
+  sessionID: string,
+  hookContent: string,
+  originalMessage: OriginalMessageContext
+): boolean {
+  const messageDir = getOrCreateMessageDir(sessionID)
+
+  const needsFallback =
+    !originalMessage.agent ||
+    !originalMessage.model?.providerID ||
+    !originalMessage.model?.modelID
+
+  const fallback = needsFallback ? findNearestMessageWithFields(messageDir) : null
+
+  const now = Date.now()
+  const messageID = generateMessageId()
+  const partID = generatePartId()
+
+  const resolvedAgent = originalMessage.agent ?? fallback?.agent ?? "general"
+  const resolvedModel =
+    originalMessage.model?.providerID && originalMessage.model?.modelID
+      ? { providerID: originalMessage.model.providerID, modelID: originalMessage.model.modelID }
+      : fallback?.model?.providerID && fallback?.model?.modelID
+        ? { providerID: fallback.model.providerID, modelID: fallback.model.modelID }
+        : undefined
+  const resolvedTools = originalMessage.tools ?? fallback?.tools
+
+  const messageMeta: MessageMeta = {
+    id: messageID,
+    sessionID,
+    role: "user",
+    time: {
+      created: now,
+    },
+    agent: resolvedAgent,
+    model: resolvedModel,
+    path:
+      originalMessage.path?.cwd
+        ? {
+            cwd: originalMessage.path.cwd,
+            root: originalMessage.path.root ?? "/",
+          }
+        : undefined,
+    tools: resolvedTools,
+  }
+
+  const textPart: TextPart = {
+    id: partID,
+    type: "text",
+    text: hookContent,
+    synthetic: true,
+    time: {
+      start: now,
+      end: now,
+    },
+    messageID,
+    sessionID,
+  }
+
+  try {
+    writeFileSync(join(messageDir, `${messageID}.json`), JSON.stringify(messageMeta, null, 2))
+
+    const partDir = join(PART_STORAGE, messageID)
+    if (!existsSync(partDir)) {
+      mkdirSync(partDir, { recursive: true })
+    }
+    writeFileSync(join(partDir, `${partID}.json`), JSON.stringify(textPart, null, 2))
+
+    return true
+  } catch {
+    return false
+  }
+}
--- a/src/features/hook-message-injector/types.ts
+++ b/src/features/hook-message-injector/types.ts
@@ -0,0 +1,45 @@
+export interface MessageMeta {
+  id: string
+  sessionID: string
+  role: "user" | "assistant"
+  time: {
+    created: number
+    completed?: number
+  }
+  agent?: string
+  model?: {
+    providerID: string
+    modelID: string
+  }
+  path?: {
+    cwd: string
+    root: string
+  }
+  tools?: Record<string, boolean>
+}
+
+export interface OriginalMessageContext {
+  agent?: string
+  model?: {
+    providerID?: string
+    modelID?: string
+  }
+  path?: {
+    cwd?: string
+    root?: string
+  }
+  tools?: Record<string, boolean>
+}
+
+export interface TextPart {
+  id: string
+  type: "text"
+  text: string
+  synthetic: boolean
+  time: {
+    start: number
+    end: number
+  }
+  messageID: string
+  sessionID: string
+}
--- a/src/hooks/claude-code-hooks/config-loader.ts
+++ b/src/hooks/claude-code-hooks/config-loader.ts
@@ -0,0 +1,105 @@
+import { existsSync } from "fs"
+import { homedir } from "os"
+import { join } from "path"
+import type { ClaudeHookEvent } from "./types"
+import { log } from "../../shared/logger"
+
+export interface DisabledHooksConfig {
+  Stop?: string[]
+  PreToolUse?: string[]
+  PostToolUse?: string[]
+  UserPromptSubmit?: string[]
+}
+
+export interface PluginExtendedConfig {
+  disabledHooks?: DisabledHooksConfig
+}
+
+const USER_CONFIG_PATH = join(homedir(), ".config", "opencode", "opencode-cc-plugin.json")
+
+function getProjectConfigPath(): string {
+  return join(process.cwd(), ".opencode", "opencode-cc-plugin.json")
+}
+
+async function loadConfigFromPath(path: string): Promise<PluginExtendedConfig | null> {
+  if (!existsSync(path)) {
+    return null
+  }
+
+  try {
+    const content = await Bun.file(path).text()
+    return JSON.parse(content) as PluginExtendedConfig
+  } catch (error) {
+    log("Failed to load config", { path, error })
+    return null
+  }
+}
+
+function mergeDisabledHooks(
+  base: DisabledHooksConfig | undefined,
+  override: DisabledHooksConfig | undefined
+): DisabledHooksConfig {
+  if (!override) return base ?? {}
+  if (!base) return override
+
+  return {
+    Stop: override.Stop ?? base.Stop,
+    PreToolUse: override.PreToolUse ?? base.PreToolUse,
+    PostToolUse: override.PostToolUse ?? base.PostToolUse,
+    UserPromptSubmit: override.UserPromptSubmit ?? base.UserPromptSubmit,
+  }
+}
+
+export async function loadPluginExtendedConfig(): Promise<PluginExtendedConfig> {
+  const userConfig = await loadConfigFromPath(USER_CONFIG_PATH)
+  const projectConfig = await loadConfigFromPath(getProjectConfigPath())
+
+  const merged: PluginExtendedConfig = {
+    disabledHooks: mergeDisabledHooks(
+      userConfig?.disabledHooks,
+      projectConfig?.disabledHooks
+    ),
+  }
+
+  if (userConfig || projectConfig) {
+    log("Plugin extended config loaded", {
+      userConfigExists: userConfig !== null,
+      projectConfigExists: projectConfig !== null,
+      mergedDisabledHooks: merged.disabledHooks,
+    })
+  }
+
+  return merged
+}
+
+const regexCache = new Map<string, RegExp>()
+
+function getRegex(pattern: string): RegExp {
+  let regex = regexCache.get(pattern)
+  if (!regex) {
+    try {
+      regex = new RegExp(pattern)
+      regexCache.set(pattern, regex)
+    } catch {
+      regex = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+      regexCache.set(pattern, regex)
+    }
+  }
+  return regex
+}
+
+export function isHookCommandDisabled(
+  eventType: ClaudeHookEvent,
+  command: string,
+  config: PluginExtendedConfig | null
+): boolean {
+  if (!config?.disabledHooks) return false
+
+  const patterns = config.disabledHooks[eventType]
+  if (!patterns || patterns.length === 0) return false
+
+  return patterns.some((pattern) => {
+    const regex = getRegex(pattern)
+    return regex.test(command)
+  })
+}
--- a/src/hooks/claude-code-hooks/config.ts
+++ b/src/hooks/claude-code-hooks/config.ts
@@ -0,0 +1,100 @@
+import { homedir } from "os"
+import { join } from "path"
+import { existsSync } from "fs"
+import type { ClaudeHooksConfig, HookMatcher, HookCommand } from "./types"
+
+interface RawHookMatcher {
+  matcher?: string
+  pattern?: string
+  hooks: HookCommand[]
+}
+
+interface RawClaudeHooksConfig {
+  PreToolUse?: RawHookMatcher[]
+  PostToolUse?: RawHookMatcher[]
+  UserPromptSubmit?: RawHookMatcher[]
+  Stop?: RawHookMatcher[]
+}
+
+function normalizeHookMatcher(raw: RawHookMatcher): HookMatcher {
+  return {
+    matcher: raw.matcher ?? raw.pattern ?? "*",
+    hooks: raw.hooks,
+  }
+}
+
+function normalizeHooksConfig(raw: RawClaudeHooksConfig): ClaudeHooksConfig {
+  const result: ClaudeHooksConfig = {}
+  const eventTypes: (keyof RawClaudeHooksConfig)[] = [
+    "PreToolUse",
+    "PostToolUse",
+    "UserPromptSubmit",
+    "Stop",
+  ]
+
+  for (const eventType of eventTypes) {
+    if (raw[eventType]) {
+      result[eventType] = raw[eventType].map(normalizeHookMatcher)
+    }
+  }
+
+  return result
+}
+
+export function getClaudeSettingsPaths(customPath?: string): string[] {
+  const home = homedir()
+  const paths = [
+    join(home, ".claude", "settings.json"),
+    join(process.cwd(), ".claude", "settings.json"),
+    join(process.cwd(), ".claude", "settings.local.json"),
+  ]
+
+  if (customPath && existsSync(customPath)) {
+    paths.unshift(customPath)
+  }
+
+  return paths
+}
+
+function mergeHooksConfig(
+  base: ClaudeHooksConfig,
+  override: ClaudeHooksConfig
+): ClaudeHooksConfig {
+  const result: ClaudeHooksConfig = { ...base }
+  const eventTypes: (keyof ClaudeHooksConfig)[] = [
+    "PreToolUse",
+    "PostToolUse",
+    "UserPromptSubmit",
+    "Stop",
+  ]
+  for (const eventType of eventTypes) {
+    if (override[eventType]) {
+      result[eventType] = [...(base[eventType] || []), ...override[eventType]]
+    }
+  }
+  return result
+}
+
+export async function loadClaudeHooksConfig(
+  customSettingsPath?: string
+): Promise<ClaudeHooksConfig | null> {
+  const paths = getClaudeSettingsPaths(customSettingsPath)
+  let mergedConfig: ClaudeHooksConfig = {}
+
+  for (const settingsPath of paths) {
+    if (existsSync(settingsPath)) {
+      try {
+        const content = await Bun.file(settingsPath).text()
+        const settings = JSON.parse(content) as { hooks?: RawClaudeHooksConfig }
+        if (settings.hooks) {
+          const normalizedHooks = normalizeHooksConfig(settings.hooks)
+          mergedConfig = mergeHooksConfig(mergedConfig, normalizedHooks)
+        }
+      } catch {
+        continue
+      }
+    }
+  }
+
+  return Object.keys(mergedConfig).length > 0 ? mergedConfig : null
+}
--- a/src/hooks/claude-code-hooks/index.ts
+++ b/src/hooks/claude-code-hooks/index.ts
@@ -0,0 +1,336 @@
+import type { PluginInput } from "@opencode-ai/plugin"
+import { loadClaudeHooksConfig } from "./config"
+import { loadPluginExtendedConfig } from "./config-loader"
+import {
+  executePreToolUseHooks,
+  type PreToolUseContext,
+} from "./pre-tool-use"
+import {
+  executePostToolUseHooks,
+  type PostToolUseContext,
+  type PostToolUseClient,
+} from "./post-tool-use"
+import {
+  executeUserPromptSubmitHooks,
+  type UserPromptSubmitContext,
+  type MessagePart,
+} from "./user-prompt-submit"
+import {
+  executeStopHooks,
+  type StopContext,
+} from "./stop"
+import { cacheToolInput, getToolInput } from "./tool-input-cache"
+import { recordToolUse, recordToolResult, getTranscriptPath, recordUserMessage } from "./transcript"
+import type { PluginConfig } from "./types"
+import { log, isHookDisabled } from "../../shared"
+import { injectHookMessage } from "../../features/hook-message-injector"
+
+const sessionFirstMessageProcessed = new Set<string>()
+const sessionErrorState = new Map<string, { hasError: boolean; errorMessage?: string }>()
+const sessionInterruptState = new Map<string, { interrupted: boolean }>()
+
+export function createClaudeCodeHooksHook(ctx: PluginInput, config: PluginConfig = {}) {
+  return {
+    "chat.message": async (
+      input: {
+        sessionID: string
+        agent?: string
+        model?: { providerID: string; modelID: string }
+        messageID?: string
+      },
+      output: {
+        message: Record<string, unknown>
+        parts: Array<{ type: string; text?: string; [key: string]: unknown }>
+      }
+    ): Promise<void> => {
+      const interruptState = sessionInterruptState.get(input.sessionID)
+      if (interruptState?.interrupted) {
+        log("chat.message hook skipped - session interrupted", { sessionID: input.sessionID })
+        return
+      }
+
+      const claudeConfig = await loadClaudeHooksConfig()
+      const extendedConfig = await loadPluginExtendedConfig()
+
+      const textParts = output.parts.filter((p) => p.type === "text" && p.text)
+      const prompt = textParts.map((p) => p.text ?? "").join("\n")
+
+      recordUserMessage(input.sessionID, prompt)
+
+      const messageParts: MessagePart[] = textParts.map((p) => ({
+        type: p.type as "text",
+        text: p.text,
+      }))
+
+      const interruptStateBeforeHooks = sessionInterruptState.get(input.sessionID)
+      if (interruptStateBeforeHooks?.interrupted) {
+        log("chat.message hooks skipped - interrupted during preparation", { sessionID: input.sessionID })
+        return
+      }
+
+      let parentSessionId: string | undefined
+      try {
+        const sessionInfo = await ctx.client.session.get({
+          path: { id: input.sessionID },
+        })
+        parentSessionId = sessionInfo.data?.parentID
+      } catch {}
+
+      const isFirstMessage = !sessionFirstMessageProcessed.has(input.sessionID)
+      sessionFirstMessageProcessed.add(input.sessionID)
+
+      if (isFirstMessage) {
+        log("Skipping UserPromptSubmit hooks on first message for title generation", { sessionID: input.sessionID })
+        return
+      }
+
+      if (!isHookDisabled(config, "UserPromptSubmit")) {
+        const userPromptCtx: UserPromptSubmitContext = {
+          sessionId: input.sessionID,
+          parentSessionId,
+          prompt,
+          parts: messageParts,
+          cwd: ctx.directory,
+        }
+
+        const result = await executeUserPromptSubmitHooks(
+          userPromptCtx,
+          claudeConfig,
+          extendedConfig
+        )
+
+        if (result.block) {
+          throw new Error(result.reason ?? "Hook blocked the prompt")
+        }
+
+        const interruptStateAfterHooks = sessionInterruptState.get(input.sessionID)
+        if (interruptStateAfterHooks?.interrupted) {
+          log("chat.message injection skipped - interrupted during hooks", { sessionID: input.sessionID })
+          return
+        }
+
+        if (result.messages.length > 0) {
+          const hookContent = result.messages.join("\n\n")
+          const message = output.message as {
+            agent?: string
+            model?: { modelID?: string; providerID?: string }
+            path?: { cwd?: string; root?: string }
+            tools?: Record<string, boolean>
+          }
+
+          const success = injectHookMessage(input.sessionID, hookContent, {
+            agent: message.agent,
+            model: message.model,
+            path: message.path ?? { cwd: ctx.directory, root: "/" },
+            tools: message.tools,
+          })
+
+          log(success ? "Hook message injected via file system" : "File injection failed", {
+            sessionID: input.sessionID,
+          })
+        }
+      }
+    },
+
+    "tool.execute.before": async (
+      input: { tool: string; sessionID: string; callID: string },
+      output: { args: Record<string, unknown> }
+    ): Promise<void> => {
+      const claudeConfig = await loadClaudeHooksConfig()
+      const extendedConfig = await loadPluginExtendedConfig()
+
+      recordToolUse(input.sessionID, input.tool, output.args as Record<string, unknown>)
+
+      cacheToolInput(input.sessionID, input.tool, input.callID, output.args as Record<string, unknown>)
+
+      if (!isHookDisabled(config, "PreToolUse")) {
+        const preCtx: PreToolUseContext = {
+          sessionId: input.sessionID,
+          toolName: input.tool,
+          toolInput: output.args as Record<string, unknown>,
+          cwd: ctx.directory,
+          toolUseId: input.callID,
+        }
+
+        const result = await executePreToolUseHooks(preCtx, claudeConfig, extendedConfig)
+
+        if (result.decision === "deny") {
+          ctx.client.tui
+            .showToast({
+              body: {
+                title: "PreToolUse Hook Executed",
+                message: `✗ ${result.toolName ?? input.tool} ${result.hookName ?? "hook"}: BLOCKED ${result.elapsedMs ?? 0}ms\n${result.inputLines ?? ""}`,
+                variant: "error",
+                duration: 4000,
+              },
+            })
+            .catch(() => {})
+          throw new Error(result.reason ?? "Hook blocked the operation")
+        }
+
+        if (result.modifiedInput) {
+          Object.assign(output.args as Record<string, unknown>, result.modifiedInput)
+        }
+      }
+    },
+
+    "tool.execute.after": async (
+      input: { tool: string; sessionID: string; callID: string },
+      output: { title: string; output: string; metadata: unknown }
+    ): Promise<void> => {
+      const claudeConfig = await loadClaudeHooksConfig()
+      const extendedConfig = await loadPluginExtendedConfig()
+
+      const cachedInput = getToolInput(input.sessionID, input.tool, input.callID) || {}
+
+      recordToolResult(input.sessionID, input.tool, cachedInput, (output.metadata as Record<string, unknown>) || {})
+
+      if (!isHookDisabled(config, "PostToolUse")) {
+        const postClient: PostToolUseClient = {
+          session: {
+            messages: (opts) => ctx.client.session.messages(opts),
+          },
+        }
+
+        const postCtx: PostToolUseContext = {
+          sessionId: input.sessionID,
+          toolName: input.tool,
+          toolInput: cachedInput,
+          toolOutput: {
+            title: input.tool,
+            output: output.output,
+            metadata: output.metadata as Record<string, unknown>,
+          },
+          cwd: ctx.directory,
+          transcriptPath: getTranscriptPath(input.sessionID),
+          toolUseId: input.callID,
+          client: postClient,
+          permissionMode: "bypassPermissions",
+        }
+
+        const result = await executePostToolUseHooks(postCtx, claudeConfig, extendedConfig)
+
+        if (result.block) {
+          ctx.client.tui
+            .showToast({
+              body: {
+                title: "PostToolUse Hook Warning",
+                message: result.reason ?? "Hook returned warning",
+                variant: "warning",
+                duration: 4000,
+              },
+            })
+            .catch(() => {})
+        }
+
+        if (result.warnings && result.warnings.length > 0) {
+          output.output = `${output.output}\n\n${result.warnings.join("\n")}`
+        }
+
+        if (result.message) {
+          output.output = `${output.output}\n\n${result.message}`
+        }
+
+        if (result.hookName) {
+          ctx.client.tui
+            .showToast({
+              body: {
+                title: "PostToolUse Hook Executed",
+                message: `▶ ${result.toolName ?? input.tool} ${result.hookName}: ${result.elapsedMs ?? 0}ms`,
+                variant: "success",
+                duration: 2000,
+              },
+            })
+            .catch(() => {})
+        }
+      }
+    },
+
+    event: async (input: { event: { type: string; properties?: unknown } }) => {
+      const { event } = input
+
+      if (event.type === "session.error") {
+        const props = event.properties as Record<string, unknown> | undefined
+        const sessionID = props?.sessionID as string | undefined
+        if (sessionID) {
+          sessionErrorState.set(sessionID, {
+            hasError: true,
+            errorMessage: String(props?.error ?? "Unknown error"),
+          })
+        }
+        return
+      }
+
+      if (event.type === "session.deleted") {
+        const props = event.properties as Record<string, unknown> | undefined
+        const sessionInfo = props?.info as { id?: string } | undefined
+        if (sessionInfo?.id) {
+          sessionErrorState.delete(sessionInfo.id)
+          sessionInterruptState.delete(sessionInfo.id)
+          sessionFirstMessageProcessed.delete(sessionInfo.id)
+        }
+        return
+      }
+
+      if (event.type === "session.idle") {
+        const props = event.properties as Record<string, unknown> | undefined
+        const sessionID = props?.sessionID as string | undefined
+
+        if (!sessionID) return
+
+        const claudeConfig = await loadClaudeHooksConfig()
+        const extendedConfig = await loadPluginExtendedConfig()
+
+        const errorStateBefore = sessionErrorState.get(sessionID)
+        const endedWithErrorBefore = errorStateBefore?.hasError === true
+        const interruptStateBefore = sessionInterruptState.get(sessionID)
+        const interruptedBefore = interruptStateBefore?.interrupted === true
+
+        let parentSessionId: string | undefined
+        try {
+          const sessionInfo = await ctx.client.session.get({
+            path: { id: sessionID },
+          })
+          parentSessionId = sessionInfo.data?.parentID
+        } catch {}
+
+        if (!isHookDisabled(config, "Stop")) {
+          const stopCtx: StopContext = {
+            sessionId: sessionID,
+            parentSessionId,
+            cwd: ctx.directory,
+          }
+
+          const stopResult = await executeStopHooks(stopCtx, claudeConfig, extendedConfig)
+
+          const errorStateAfter = sessionErrorState.get(sessionID)
+          const endedWithErrorAfter = errorStateAfter?.hasError === true
+          const interruptStateAfter = sessionInterruptState.get(sessionID)
+          const interruptedAfter = interruptStateAfter?.interrupted === true
+
+          const shouldBypass = endedWithErrorBefore || endedWithErrorAfter || interruptedBefore || interruptedAfter
+
+          if (shouldBypass && stopResult.block) {
+            const interrupted = interruptedBefore || interruptedAfter
+            const endedWithError = endedWithErrorBefore || endedWithErrorAfter
+            log("Stop hook block ignored", { sessionID, block: stopResult.block, interrupted, endedWithError })
+          } else if (stopResult.block && stopResult.injectPrompt) {
+            log("Stop hook returned block with inject_prompt", { sessionID })
+            ctx.client.session
+              .prompt({
+                path: { id: sessionID },
+                body: { parts: [{ type: "text", text: stopResult.injectPrompt }] },
+                query: { directory: ctx.directory },
+              })
+              .catch((err: unknown) => log("Failed to inject prompt from Stop hook", err))
+          } else if (stopResult.block) {
+            log("Stop hook returned block", { sessionID, reason: stopResult.reason })
+          }
+        }
+
+        sessionErrorState.delete(sessionID)
+        sessionInterruptState.delete(sessionID)
+      }
+    },
+  }
+}
--- a/src/hooks/claude-code-hooks/plugin-config.ts
+++ b/src/hooks/claude-code-hooks/plugin-config.ts
@@ -0,0 +1,9 @@
+/**
+ * Plugin configuration for Claude Code hooks execution
+ * Contains settings for hook command execution (zsh, etc.)
+ */
+
+export const DEFAULT_CONFIG = {
+  forceZsh: true,
+  zshPath: "/bin/zsh",
+}
--- a/src/hooks/claude-code-hooks/post-tool-use.ts
+++ b/src/hooks/claude-code-hooks/post-tool-use.ts
@@ -0,0 +1,199 @@
+import type {
+  PostToolUseInput,
+  PostToolUseOutput,
+  ClaudeHooksConfig,
+} from "./types"
+import { findMatchingHooks, executeHookCommand, objectToSnakeCase, transformToolName, log } from "../../shared"
+import { DEFAULT_CONFIG } from "./plugin-config"
+import { buildTranscriptFromSession, deleteTempTranscript } from "./transcript"
+import { isHookCommandDisabled, type PluginExtendedConfig } from "./config-loader"
+
+export interface PostToolUseClient {
+  session: {
+    messages: (opts: { path: { id: string }; query?: { directory: string } }) => Promise<unknown>
+  }
+}
+
+export interface PostToolUseContext {
+  sessionId: string
+  toolName: string
+  toolInput: Record<string, unknown>
+  toolOutput: Record<string, unknown>
+  cwd: string
+  transcriptPath?: string  // Fallback for append-based transcript
+  toolUseId?: string
+  client?: PostToolUseClient
+  permissionMode?: "default" | "plan" | "acceptEdits" | "bypassPermissions"
+}
+
+export interface PostToolUseResult {
+  block: boolean
+  reason?: string
+  message?: string
+  warnings?: string[]
+  elapsedMs?: number
+  hookName?: string
+  toolName?: string
+  additionalContext?: string
+  continue?: boolean
+  stopReason?: string
+  suppressOutput?: boolean
+  systemMessage?: string
+}
+
+export async function executePostToolUseHooks(
+  ctx: PostToolUseContext,
+  config: ClaudeHooksConfig | null,
+  extendedConfig?: PluginExtendedConfig | null
+): Promise<PostToolUseResult> {
+  if (!config) {
+    return { block: false }
+  }
+
+  const transformedToolName = transformToolName(ctx.toolName)
+  const matchers = findMatchingHooks(config, "PostToolUse", transformedToolName)
+  if (matchers.length === 0) {
+    return { block: false }
+  }
+
+  // PORT FROM DISABLED: Build Claude Code compatible transcript (temp file)
+  let tempTranscriptPath: string | null = null
+
+  try {
+    // Try to build full transcript from API if client available
+    if (ctx.client) {
+      tempTranscriptPath = await buildTranscriptFromSession(
+        ctx.client,
+        ctx.sessionId,
+        ctx.cwd,
+        ctx.toolName,
+        ctx.toolInput
+      )
+    }
+
+    const stdinData: PostToolUseInput = {
+      session_id: ctx.sessionId,
+      // Use temp transcript if available, otherwise fallback to append-based
+      transcript_path: tempTranscriptPath ?? ctx.transcriptPath,
+      cwd: ctx.cwd,
+      permission_mode: ctx.permissionMode ?? "bypassPermissions",
+      hook_event_name: "PostToolUse",
+      tool_name: transformedToolName,
+      tool_input: objectToSnakeCase(ctx.toolInput),
+      tool_response: objectToSnakeCase(ctx.toolOutput),
+      tool_use_id: ctx.toolUseId,
+      hook_source: "opencode-plugin",
+    }
+
+    const messages: string[] = []
+    const warnings: string[] = []
+    let firstHookName: string | undefined
+
+    const startTime = Date.now()
+
+    for (const matcher of matchers) {
+      for (const hook of matcher.hooks) {
+        if (hook.type !== "command") continue
+
+        if (isHookCommandDisabled("PostToolUse", hook.command, extendedConfig ?? null)) {
+          log("PostToolUse hook command skipped (disabled by config)", { command: hook.command, toolName: ctx.toolName })
+          continue
+        }
+
+        const hookName = hook.command.split("/").pop() || hook.command
+        if (!firstHookName) firstHookName = hookName
+
+        const result = await executeHookCommand(
+          hook.command,
+          JSON.stringify(stdinData),
+          ctx.cwd,
+          { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath }
+        )
+
+        if (result.stdout) {
+          messages.push(result.stdout)
+        }
+
+        if (result.exitCode === 2) {
+          if (result.stderr) {
+            warnings.push(`[${hookName}]\n${result.stderr.trim()}`)
+          }
+          continue
+        }
+
+        if (result.exitCode === 0 && result.stdout) {
+          try {
+            const output = JSON.parse(result.stdout) as PostToolUseOutput
+            if (output.decision === "block") {
+              return {
+                block: true,
+                reason: output.reason || result.stderr,
+                message: messages.join("\n"),
+                warnings: warnings.length > 0 ? warnings : undefined,
+                elapsedMs: Date.now() - startTime,
+                hookName: firstHookName,
+                toolName: transformedToolName,
+                additionalContext: output.hookSpecificOutput?.additionalContext,
+                continue: output.continue,
+                stopReason: output.stopReason,
+                suppressOutput: output.suppressOutput,
+                systemMessage: output.systemMessage,
+              }
+            }
+            if (output.hookSpecificOutput?.additionalContext || output.continue !== undefined || output.systemMessage || output.suppressOutput === true || output.stopReason !== undefined) {
+              return {
+                block: false,
+                message: messages.join("\n"),
+                warnings: warnings.length > 0 ? warnings : undefined,
+                elapsedMs: Date.now() - startTime,
+                hookName: firstHookName,
+                toolName: transformedToolName,
+                additionalContext: output.hookSpecificOutput?.additionalContext,
+                continue: output.continue,
+                stopReason: output.stopReason,
+                suppressOutput: output.suppressOutput,
+                systemMessage: output.systemMessage,
+              }
+            }
+          } catch {
+          }
+        } else if (result.exitCode !== 0 && result.exitCode !== 2) {
+          try {
+            const output = JSON.parse(result.stdout || "{}") as PostToolUseOutput
+            if (output.decision === "block") {
+              return {
+                block: true,
+                reason: output.reason || result.stderr,
+                message: messages.join("\n"),
+                warnings: warnings.length > 0 ? warnings : undefined,
+                elapsedMs: Date.now() - startTime,
+                hookName: firstHookName,
+                toolName: transformedToolName,
+                additionalContext: output.hookSpecificOutput?.additionalContext,
+                continue: output.continue,
+                stopReason: output.stopReason,
+                suppressOutput: output.suppressOutput,
+                systemMessage: output.systemMessage,
+              }
+            }
+          } catch {
+          }
+        }
+      }
+    }
+
+    const elapsedMs = Date.now() - startTime
+
+    return {
+      block: false,
+      message: messages.length > 0 ? messages.join("\n") : undefined,
+      warnings: warnings.length > 0 ? warnings : undefined,
+      elapsedMs,
+      hookName: firstHookName,
+      toolName: transformedToolName,
+    }
+  } finally {
+    // PORT FROM DISABLED: Cleanup temp file to avoid disk accumulation
+    deleteTempTranscript(tempTranscriptPath)
+  }
+}
--- a/src/hooks/claude-code-hooks/pre-tool-use.ts
+++ b/src/hooks/claude-code-hooks/pre-tool-use.ts
@@ -0,0 +1,172 @@
+import type {
+  PreToolUseInput,
+  PreToolUseOutput,
+  PermissionDecision,
+  ClaudeHooksConfig,
+} from "./types"
+import { findMatchingHooks, executeHookCommand, objectToSnakeCase, transformToolName, log } from "../../shared"
+import { DEFAULT_CONFIG } from "./plugin-config"
+import { isHookCommandDisabled, type PluginExtendedConfig } from "./config-loader"
+
+export interface PreToolUseContext {
+  sessionId: string
+  toolName: string
+  toolInput: Record<string, unknown>
+  cwd: string
+  transcriptPath?: string
+  toolUseId?: string
+  permissionMode?: "default" | "plan" | "acceptEdits" | "bypassPermissions"
+}
+
+export interface PreToolUseResult {
+  decision: PermissionDecision
+  reason?: string
+  modifiedInput?: Record<string, unknown>
+  elapsedMs?: number
+  hookName?: string
+  toolName?: string
+  inputLines?: string
+  // Common output fields (Claude Code spec)
+  continue?: boolean
+  stopReason?: string
+  suppressOutput?: boolean
+  systemMessage?: string
+}
+
+function buildInputLines(toolInput: Record<string, unknown>): string {
+  return Object.entries(toolInput)
+    .slice(0, 3)
+    .map(([key, val]) => {
+      const valStr = String(val).slice(0, 40)
+      return `  ${key}: ${valStr}${String(val).length > 40 ? "..." : ""}`
+    })
+    .join("\n")
+}
+
+export async function executePreToolUseHooks(
+  ctx: PreToolUseContext,
+  config: ClaudeHooksConfig | null,
+  extendedConfig?: PluginExtendedConfig | null
+): Promise<PreToolUseResult> {
+  if (!config) {
+    return { decision: "allow" }
+  }
+
+  const transformedToolName = transformToolName(ctx.toolName)
+  const matchers = findMatchingHooks(config, "PreToolUse", transformedToolName)
+  if (matchers.length === 0) {
+    return { decision: "allow" }
+  }
+
+  const stdinData: PreToolUseInput = {
+    session_id: ctx.sessionId,
+    transcript_path: ctx.transcriptPath,
+    cwd: ctx.cwd,
+    permission_mode: ctx.permissionMode ?? "bypassPermissions",
+    hook_event_name: "PreToolUse",
+    tool_name: transformedToolName,
+    tool_input: objectToSnakeCase(ctx.toolInput),
+    tool_use_id: ctx.toolUseId,
+    hook_source: "opencode-plugin",
+  }
+
+  const startTime = Date.now()
+  let firstHookName: string | undefined
+  const inputLines = buildInputLines(ctx.toolInput)
+
+  for (const matcher of matchers) {
+    for (const hook of matcher.hooks) {
+      if (hook.type !== "command") continue
+
+      if (isHookCommandDisabled("PreToolUse", hook.command, extendedConfig ?? null)) {
+        log("PreToolUse hook command skipped (disabled by config)", { command: hook.command, toolName: ctx.toolName })
+        continue
+      }
+
+      const hookName = hook.command.split("/").pop() || hook.command
+      if (!firstHookName) firstHookName = hookName
+
+      const result = await executeHookCommand(
+        hook.command,
+        JSON.stringify(stdinData),
+        ctx.cwd,
+        { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath }
+      )
+
+      if (result.exitCode === 2) {
+        return {
+          decision: "deny",
+          reason: result.stderr || result.stdout || "Hook blocked the operation",
+          elapsedMs: Date.now() - startTime,
+          hookName: firstHookName,
+          toolName: transformedToolName,
+          inputLines,
+        }
+      }
+
+      if (result.exitCode === 1) {
+        return {
+          decision: "ask",
+          reason: result.stderr || result.stdout,
+          elapsedMs: Date.now() - startTime,
+          hookName: firstHookName,
+          toolName: transformedToolName,
+          inputLines,
+        }
+      }
+
+      if (result.stdout) {
+        try {
+          const output = JSON.parse(result.stdout) as PreToolUseOutput
+
+          // Handle deprecated decision/reason fields (Claude Code backward compat)
+          let decision: PermissionDecision | undefined
+          let reason: string | undefined
+          let modifiedInput: Record<string, unknown> | undefined
+
+          if (output.hookSpecificOutput?.permissionDecision) {
+            decision = output.hookSpecificOutput.permissionDecision
+            reason = output.hookSpecificOutput.permissionDecisionReason
+            modifiedInput = output.hookSpecificOutput.updatedInput
+          } else if (output.decision) {
+            // Map deprecated values: approve->allow, block->deny, ask->ask
+            const legacyDecision = output.decision
+            if (legacyDecision === "approve" || legacyDecision === "allow") {
+              decision = "allow"
+            } else if (legacyDecision === "block" || legacyDecision === "deny") {
+              decision = "deny"
+            } else if (legacyDecision === "ask") {
+              decision = "ask"
+            }
+            reason = output.reason
+          }
+
+          // Return if decision is set OR if any common fields are set (fallback to allow)
+          const hasCommonFields = output.continue !== undefined || 
+            output.stopReason !== undefined || 
+            output.suppressOutput !== undefined || 
+            output.systemMessage !== undefined
+
+          if (decision || hasCommonFields) {
+            return {
+              decision: decision ?? "allow",
+              reason,
+              modifiedInput,
+              elapsedMs: Date.now() - startTime,
+              hookName: firstHookName,
+              toolName: transformedToolName,
+              inputLines,
+              continue: output.continue,
+              stopReason: output.stopReason,
+              suppressOutput: output.suppressOutput,
+              systemMessage: output.systemMessage,
+            }
+          }
+        } catch {
+        }
+      }
+    }
+  }
+
+  return { decision: "allow" }
+}
--- a/src/hooks/claude-code-hooks/stop.ts
+++ b/src/hooks/claude-code-hooks/stop.ts
@@ -0,0 +1,118 @@
+import type {
+  StopInput,
+  StopOutput,
+  ClaudeHooksConfig,
+} from "./types"
+import { findMatchingHooks, executeHookCommand, log } from "../../shared"
+import { DEFAULT_CONFIG } from "./plugin-config"
+import { getTodoPath } from "./todo"
+import { isHookCommandDisabled, type PluginExtendedConfig } from "./config-loader"
+
+// Module-level state to track stop_hook_active per session
+const stopHookActiveState = new Map<string, boolean>()
+
+export function setStopHookActive(sessionId: string, active: boolean): void {
+  stopHookActiveState.set(sessionId, active)
+}
+
+export function getStopHookActive(sessionId: string): boolean {
+  return stopHookActiveState.get(sessionId) ?? false
+}
+
+export interface StopContext {
+  sessionId: string
+  parentSessionId?: string
+  cwd: string
+  transcriptPath?: string
+  permissionMode?: "default" | "acceptEdits" | "bypassPermissions"
+  stopHookActive?: boolean
+}
+
+export interface StopResult {
+  block: boolean
+  reason?: string
+  stopHookActive?: boolean
+  permissionMode?: "default" | "plan" | "acceptEdits" | "bypassPermissions"
+  injectPrompt?: string
+}
+
+export async function executeStopHooks(
+  ctx: StopContext,
+  config: ClaudeHooksConfig | null,
+  extendedConfig?: PluginExtendedConfig | null
+): Promise<StopResult> {
+  if (ctx.parentSessionId) {
+    return { block: false }
+  }
+
+  if (!config) {
+    return { block: false }
+  }
+
+  const matchers = findMatchingHooks(config, "Stop")
+  if (matchers.length === 0) {
+    return { block: false }
+  }
+
+  const stdinData: StopInput = {
+    session_id: ctx.sessionId,
+    transcript_path: ctx.transcriptPath,
+    cwd: ctx.cwd,
+    permission_mode: ctx.permissionMode ?? "bypassPermissions",
+    hook_event_name: "Stop",
+    stop_hook_active: stopHookActiveState.get(ctx.sessionId) ?? false,
+    todo_path: getTodoPath(ctx.sessionId),
+    hook_source: "opencode-plugin",
+  }
+
+  for (const matcher of matchers) {
+    for (const hook of matcher.hooks) {
+      if (hook.type !== "command") continue
+
+      if (isHookCommandDisabled("Stop", hook.command, extendedConfig ?? null)) {
+        log("Stop hook command skipped (disabled by config)", { command: hook.command })
+        continue
+      }
+
+      const result = await executeHookCommand(
+        hook.command,
+        JSON.stringify(stdinData),
+        ctx.cwd,
+        { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath }
+      )
+
+      // Check exit code first - exit code 2 means block
+      if (result.exitCode === 2) {
+        const reason = result.stderr || result.stdout || "Blocked by stop hook"
+        return {
+          block: true,
+          reason,
+          injectPrompt: reason,
+        }
+      }
+
+       if (result.stdout) {
+         try {
+           const output = JSON.parse(result.stdout) as StopOutput
+           if (output.stop_hook_active !== undefined) {
+             stopHookActiveState.set(ctx.sessionId, output.stop_hook_active)
+           }
+           const isBlock = output.decision === "block"
+           // Determine inject_prompt: prefer explicit value, fallback to reason if blocking
+           const injectPrompt = output.inject_prompt ?? (isBlock && output.reason ? output.reason : undefined)
+           return {
+             block: isBlock,
+             reason: output.reason,
+             stopHookActive: output.stop_hook_active,
+             permissionMode: output.permission_mode,
+             injectPrompt,
+           }
+         } catch {
+           // Ignore JSON parse errors - hook may return non-JSON output
+         }
+       }
+    }
+  }
+
+  return { block: false }
+}
--- a/src/hooks/claude-code-hooks/todo.ts
+++ b/src/hooks/claude-code-hooks/todo.ts
@@ -0,0 +1,76 @@
+import { join } from "path"
+import { mkdirSync, writeFileSync, readFileSync, existsSync, unlinkSync } from "fs"
+import { homedir } from "os"
+import type { TodoFile, TodoItem, ClaudeCodeTodoItem } from "./types"
+
+const TODO_DIR = join(homedir(), ".claude", "todos")
+
+export function getTodoPath(sessionId: string): string {
+  return join(TODO_DIR, `${sessionId}-agent-${sessionId}.json`)
+}
+
+function ensureTodoDir(): void {
+  if (!existsSync(TODO_DIR)) {
+    mkdirSync(TODO_DIR, { recursive: true })
+  }
+}
+
+export interface OpenCodeTodo {
+  content: string
+  status: string
+  priority: string
+  id: string
+}
+
+function toClaudeCodeFormat(item: OpenCodeTodo | TodoItem): ClaudeCodeTodoItem {
+  return {
+    content: item.content,
+    status: item.status === "cancelled" ? "completed" : item.status,
+    activeForm: item.content,
+  }
+}
+
+export function loadTodoFile(sessionId: string): TodoFile | null {
+   const path = getTodoPath(sessionId)
+   if (!existsSync(path)) return null
+   try {
+     const content = JSON.parse(readFileSync(path, "utf-8"))
+     if (Array.isArray(content)) {
+       return {
+         session_id: sessionId,
+         items: content.map((item: ClaudeCodeTodoItem, idx: number) => ({
+           id: String(idx),
+           content: item.content,
+           status: item.status as TodoItem["status"],
+           created_at: new Date().toISOString(),
+         })),
+         created_at: new Date().toISOString(),
+         updated_at: new Date().toISOString(),
+       }
+     }
+     return content
+   } catch {
+     return null
+   }
+}
+
+export function saveTodoFile(sessionId: string, file: TodoFile): void {
+   ensureTodoDir()
+   const path = getTodoPath(sessionId)
+   const claudeCodeFormat: ClaudeCodeTodoItem[] = file.items.map(toClaudeCodeFormat)
+   writeFileSync(path, JSON.stringify(claudeCodeFormat, null, 2))
+}
+
+export function saveOpenCodeTodos(sessionId: string, todos: OpenCodeTodo[]): void {
+   ensureTodoDir()
+   const path = getTodoPath(sessionId)
+   const claudeCodeFormat: ClaudeCodeTodoItem[] = todos.map(toClaudeCodeFormat)
+   writeFileSync(path, JSON.stringify(claudeCodeFormat, null, 2))
+}
+
+export function deleteTodoFile(sessionId: string): void {
+   const path = getTodoPath(sessionId)
+   if (existsSync(path)) {
+     unlinkSync(path)
+   }
+}
--- a/src/hooks/claude-code-hooks/tool-input-cache.ts
+++ b/src/hooks/claude-code-hooks/tool-input-cache.ts
@@ -0,0 +1,47 @@
+/**
+ * Caches tool_input from PreToolUse for PostToolUse
+ */
+
+interface CacheEntry {
+  toolInput: Record<string, unknown>
+  timestamp: number
+}
+
+const cache = new Map<string, CacheEntry>()
+
+const CACHE_TTL = 60000 // 1 minute
+
+export function cacheToolInput(
+  sessionId: string,
+  toolName: string,
+  invocationId: string,
+  toolInput: Record<string, unknown>
+): void {
+  const key = `${sessionId}:${toolName}:${invocationId}`
+  cache.set(key, { toolInput, timestamp: Date.now() })
+}
+
+export function getToolInput(
+  sessionId: string,
+  toolName: string,
+  invocationId: string
+): Record<string, unknown> | null {
+  const key = `${sessionId}:${toolName}:${invocationId}`
+  const entry = cache.get(key)
+  if (!entry) return null
+
+   cache.delete(key)
+  if (Date.now() - entry.timestamp > CACHE_TTL) return null
+
+  return entry.toolInput
+}
+
+// Periodic cleanup (every minute)
+setInterval(() => {
+  const now = Date.now()
+  for (const [key, entry] of cache.entries()) {
+    if (now - entry.timestamp > CACHE_TTL) {
+      cache.delete(key)
+    }
+  }
+}, CACHE_TTL)
--- a/src/hooks/claude-code-hooks/transcript.ts
+++ b/src/hooks/claude-code-hooks/transcript.ts
@@ -0,0 +1,255 @@
+/**
+ * Transcript Manager
+ * Creates and manages Claude Code compatible transcript files
+ */
+import { join } from "path"
+import { mkdirSync, appendFileSync, existsSync, writeFileSync, unlinkSync } from "fs"
+import { homedir, tmpdir } from "os"
+import { randomUUID } from "crypto"
+import type { TranscriptEntry } from "./types"
+import { transformToolName } from "../../shared/tool-name"
+
+const TRANSCRIPT_DIR = join(homedir(), ".claude", "transcripts")
+
+export function getTranscriptPath(sessionId: string): string {
+  return join(TRANSCRIPT_DIR, `${sessionId}.jsonl`)
+}
+
+function ensureTranscriptDir(): void {
+  if (!existsSync(TRANSCRIPT_DIR)) {
+    mkdirSync(TRANSCRIPT_DIR, { recursive: true })
+  }
+}
+
+export function appendTranscriptEntry(
+  sessionId: string,
+  entry: TranscriptEntry
+): void {
+  ensureTranscriptDir()
+  const path = getTranscriptPath(sessionId)
+  const line = JSON.stringify(entry) + "\n"
+  appendFileSync(path, line)
+}
+
+export function recordToolUse(
+  sessionId: string,
+  toolName: string,
+  toolInput: Record<string, unknown>
+): void {
+  appendTranscriptEntry(sessionId, {
+    type: "tool_use",
+    timestamp: new Date().toISOString(),
+    tool_name: toolName,
+    tool_input: toolInput,
+  })
+}
+
+export function recordToolResult(
+  sessionId: string,
+  toolName: string,
+  toolInput: Record<string, unknown>,
+  toolOutput: Record<string, unknown>
+): void {
+  appendTranscriptEntry(sessionId, {
+    type: "tool_result",
+    timestamp: new Date().toISOString(),
+    tool_name: toolName,
+    tool_input: toolInput,
+    tool_output: toolOutput,
+  })
+}
+
+export function recordUserMessage(
+  sessionId: string,
+  content: string
+): void {
+  appendTranscriptEntry(sessionId, {
+    type: "user",
+    timestamp: new Date().toISOString(),
+    content,
+  })
+}
+
+export function recordAssistantMessage(
+  sessionId: string,
+  content: string
+): void {
+  appendTranscriptEntry(sessionId, {
+    type: "assistant",
+    timestamp: new Date().toISOString(),
+    content,
+  })
+}
+
+// ============================================================================
+// Claude Code Compatible Transcript Builder (PORT FROM DISABLED)
+// ============================================================================
+
+/**
+ * OpenCode API response type (loosely typed)
+ */
+interface OpenCodeMessagePart {
+  type: string
+  tool?: string
+  state?: {
+    status?: string
+    input?: Record<string, unknown>
+  }
+}
+
+interface OpenCodeMessage {
+  info?: {
+    role?: string
+  }
+  parts?: OpenCodeMessagePart[]
+}
+
+/**
+ * Claude Code compatible transcript entry (from disabled file)
+ */
+interface DisabledTranscriptEntry {
+  type: "assistant"
+  message: {
+    role: "assistant"
+    content: Array<{
+      type: "tool_use"
+      name: string
+      input: Record<string, unknown>
+    }>
+  }
+}
+
+/**
+ * Build Claude Code compatible transcript from session messages
+ * 
+ * PORT FROM DISABLED: This calls client.session.messages() API to fetch
+ * the full session history and builds a JSONL file in Claude Code format.
+ * 
+ * @param client OpenCode client instance
+ * @param sessionId Session ID
+ * @param directory Working directory
+ * @param currentToolName Current tool being executed (added as last entry)
+ * @param currentToolInput Current tool input
+ * @returns Temp file path (caller must call deleteTempTranscript!)
+ */
+export async function buildTranscriptFromSession(
+  client: {
+    session: {
+      messages: (opts: { path: { id: string }; query?: { directory: string } }) => Promise<unknown>
+    }
+  },
+  sessionId: string,
+  directory: string,
+  currentToolName: string,
+  currentToolInput: Record<string, unknown>
+): Promise<string | null> {
+  try {
+    const response = await client.session.messages({
+      path: { id: sessionId },
+      query: { directory },
+    })
+
+    // Handle various response formats
+    const messages = (response as { "200"?: unknown[]; data?: unknown[] })["200"]
+      ?? (response as { data?: unknown[] }).data
+      ?? (Array.isArray(response) ? response : [])
+
+    const entries: string[] = []
+
+    if (Array.isArray(messages)) {
+      for (const msg of messages as OpenCodeMessage[]) {
+        if (msg.info?.role !== "assistant") continue
+
+        for (const part of msg.parts || []) {
+          if (part.type !== "tool") continue
+          if (part.state?.status !== "completed") continue
+          if (!part.state?.input) continue
+
+          const rawToolName = part.tool as string
+          const toolName = transformToolName(rawToolName)
+
+          const entry: DisabledTranscriptEntry = {
+            type: "assistant",
+            message: {
+              role: "assistant",
+              content: [
+                {
+                  type: "tool_use",
+                  name: toolName,
+                  input: part.state.input,
+                },
+              ],
+            },
+          }
+          entries.push(JSON.stringify(entry))
+        }
+      }
+    }
+
+    // Always add current tool call as the last entry
+    const currentEntry: DisabledTranscriptEntry = {
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            name: transformToolName(currentToolName),
+            input: currentToolInput,
+          },
+        ],
+      },
+    }
+    entries.push(JSON.stringify(currentEntry))
+
+    // Write to temp file
+    const tempPath = join(
+      tmpdir(),
+      `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`
+    )
+    writeFileSync(tempPath, entries.join("\n") + "\n")
+
+    return tempPath
+  } catch {
+    // CRITICAL FIX: Even on API failure, create file with current tool entry only
+    // (matching original disabled behavior - never return null with incompatible format)
+    try {
+      const currentEntry: DisabledTranscriptEntry = {
+        type: "assistant",
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "tool_use",
+              name: transformToolName(currentToolName),
+              input: currentToolInput,
+            },
+          ],
+        },
+      }
+      const tempPath = join(
+        tmpdir(),
+        `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`
+      )
+      writeFileSync(tempPath, JSON.stringify(currentEntry) + "\n")
+      return tempPath
+    } catch {
+      // If even this fails, return null (truly catastrophic failure)
+      return null
+    }
+  }
+}
+
+/**
+ * Delete temp transcript file (call in finally block)
+ * 
+ * PORT FROM DISABLED: Cleanup mechanism to avoid disk accumulation
+ */
+export function deleteTempTranscript(path: string | null): void {
+  if (!path) return
+  try {
+    unlinkSync(path)
+  } catch {
+    // Ignore deletion errors
+  }
+}
--- a/src/hooks/claude-code-hooks/types.ts
+++ b/src/hooks/claude-code-hooks/types.ts
@@ -0,0 +1,184 @@
+/**
+ * Claude Code Hooks Type Definitions
+ * Maps Claude Code hook concepts to OpenCode plugin events
+ */
+
+export type ClaudeHookEvent =
+  | "PreToolUse"
+  | "PostToolUse"
+  | "UserPromptSubmit"
+  | "Stop"
+
+export interface HookMatcher {
+  matcher: string
+  hooks: HookCommand[]
+}
+
+export interface HookCommand {
+  type: "command"
+  command: string
+}
+
+export interface ClaudeHooksConfig {
+  PreToolUse?: HookMatcher[]
+  PostToolUse?: HookMatcher[]
+  UserPromptSubmit?: HookMatcher[]
+  Stop?: HookMatcher[]
+}
+
+export interface PreToolUseInput {
+  session_id: string
+  transcript_path?: string
+  cwd: string
+  permission_mode?: PermissionMode
+  hook_event_name: "PreToolUse"
+  tool_name: string
+  tool_input: Record<string, unknown>
+  tool_use_id?: string
+  hook_source?: HookSource
+}
+
+export interface PostToolUseInput {
+  session_id: string
+  transcript_path?: string
+  cwd: string
+  permission_mode?: PermissionMode
+  hook_event_name: "PostToolUse"
+  tool_name: string
+  tool_input: Record<string, unknown>
+  tool_response: {
+    title?: string
+    output?: string
+    [key: string]: unknown
+  }
+  tool_use_id?: string
+  hook_source?: HookSource
+}
+
+export interface UserPromptSubmitInput {
+  session_id: string
+  cwd: string
+  permission_mode?: PermissionMode
+  hook_event_name: "UserPromptSubmit"
+  prompt: string
+  session?: {
+    id: string
+  }
+  hook_source?: HookSource
+}
+
+export type PermissionMode = "default" | "plan" | "acceptEdits" | "bypassPermissions"
+
+export type HookSource = "opencode-plugin"
+
+export interface StopInput {
+  session_id: string
+  transcript_path?: string
+  cwd: string
+  permission_mode?: PermissionMode
+  hook_event_name: "Stop"
+  stop_hook_active: boolean
+  todo_path?: string
+  hook_source?: HookSource
+}
+
+export type PermissionDecision = "allow" | "deny" | "ask"
+
+/**
+ * Common JSON fields for all hook outputs (Claude Code spec)
+ */
+export interface HookCommonOutput {
+  /** If false, Claude stops entirely */
+  continue?: boolean
+  /** Message shown to user when continue=false */
+  stopReason?: string
+  /** Suppress output from transcript */
+  suppressOutput?: boolean
+  /** Warning/message displayed to user */
+  systemMessage?: string
+}
+
+export interface PreToolUseOutput extends HookCommonOutput {
+  /** Deprecated: use hookSpecificOutput.permissionDecision instead */
+  decision?: "allow" | "deny" | "approve" | "block" | "ask"
+  /** Deprecated: use hookSpecificOutput.permissionDecisionReason instead */
+  reason?: string
+  hookSpecificOutput?: {
+    hookEventName: "PreToolUse"
+    permissionDecision: PermissionDecision
+    permissionDecisionReason?: string
+    updatedInput?: Record<string, unknown>
+  }
+}
+
+export interface PostToolUseOutput extends HookCommonOutput {
+  decision?: "block"
+  reason?: string
+  hookSpecificOutput?: {
+    hookEventName: "PostToolUse"
+    /** Additional context to provide to Claude */
+    additionalContext?: string
+  }
+}
+
+export interface HookResult {
+  exitCode: number
+  stdout?: string
+  stderr?: string
+}
+
+export interface TranscriptEntry {
+  type: "tool_use" | "tool_result" | "user" | "assistant"
+  timestamp: string
+  tool_name?: string
+  tool_input?: Record<string, unknown>
+  tool_output?: Record<string, unknown>
+  content?: string
+}
+
+export interface TodoItem {
+  id: string
+  content: string
+  status: "pending" | "in_progress" | "completed" | "cancelled"
+  priority?: "low" | "medium" | "high"
+  created_at: string
+  updated_at?: string
+}
+
+export interface ClaudeCodeTodoItem {
+  content: string
+  status: string // "pending" | "in_progress" | "completed"
+  activeForm: string
+}
+
+export interface TodoFile {
+  session_id: string
+  items: TodoItem[]
+  created_at: string
+  updated_at: string
+}
+
+export interface StopOutput {
+  decision?: "block" | "continue"
+  reason?: string
+  stop_hook_active?: boolean
+  permission_mode?: PermissionMode
+  inject_prompt?: string
+}
+
+export type ClaudeCodeContent =
+  | { type: "text"; text: string }
+  | { type: "tool_use"; id: string; name: string; input: Record<string, unknown> }
+  | { type: "tool_result"; tool_use_id: string; content: string }
+
+export interface ClaudeCodeMessage {
+  type: "user" | "assistant"
+  message: {
+    role: "user" | "assistant"
+    content: ClaudeCodeContent[]
+  }
+}
+
+export interface PluginConfig {
+  disabledHooks?: boolean | ClaudeHookEvent[]
+}
--- a/src/hooks/claude-code-hooks/user-prompt-submit.ts
+++ b/src/hooks/claude-code-hooks/user-prompt-submit.ts
@@ -0,0 +1,117 @@
+import type {
+  UserPromptSubmitInput,
+  PostToolUseOutput,
+  ClaudeHooksConfig,
+} from "./types"
+import { findMatchingHooks, executeHookCommand, log } from "../../shared"
+import { DEFAULT_CONFIG } from "./plugin-config"
+import { isHookCommandDisabled, type PluginExtendedConfig } from "./config-loader"
+
+const USER_PROMPT_SUBMIT_TAG_OPEN = "<user-prompt-submit-hook>"
+const USER_PROMPT_SUBMIT_TAG_CLOSE = "</user-prompt-submit-hook>"
+
+export interface MessagePart {
+  type: "text" | "tool_use" | "tool_result"
+  text?: string
+  [key: string]: unknown
+}
+
+export interface UserPromptSubmitContext {
+  sessionId: string
+  parentSessionId?: string
+  prompt: string
+  parts: MessagePart[]
+  cwd: string
+  permissionMode?: "default" | "acceptEdits" | "bypassPermissions"
+}
+
+export interface UserPromptSubmitResult {
+  block: boolean
+  reason?: string
+  modifiedParts: MessagePart[]
+  messages: string[]
+}
+
+export async function executeUserPromptSubmitHooks(
+  ctx: UserPromptSubmitContext,
+  config: ClaudeHooksConfig | null,
+  extendedConfig?: PluginExtendedConfig | null
+): Promise<UserPromptSubmitResult> {
+  const modifiedParts = ctx.parts
+  const messages: string[] = []
+
+  if (ctx.parentSessionId) {
+    return { block: false, modifiedParts, messages }
+  }
+
+  if (
+    ctx.prompt.includes(USER_PROMPT_SUBMIT_TAG_OPEN) &&
+    ctx.prompt.includes(USER_PROMPT_SUBMIT_TAG_CLOSE)
+  ) {
+    return { block: false, modifiedParts, messages }
+  }
+
+  if (!config) {
+    return { block: false, modifiedParts, messages }
+  }
+
+  const matchers = findMatchingHooks(config, "UserPromptSubmit")
+  if (matchers.length === 0) {
+    return { block: false, modifiedParts, messages }
+  }
+
+  const stdinData: UserPromptSubmitInput = {
+    session_id: ctx.sessionId,
+    cwd: ctx.cwd,
+    permission_mode: ctx.permissionMode ?? "bypassPermissions",
+    hook_event_name: "UserPromptSubmit",
+    prompt: ctx.prompt,
+    session: { id: ctx.sessionId },
+    hook_source: "opencode-plugin",
+  }
+
+  for (const matcher of matchers) {
+    for (const hook of matcher.hooks) {
+      if (hook.type !== "command") continue
+
+      if (isHookCommandDisabled("UserPromptSubmit", hook.command, extendedConfig ?? null)) {
+        log("UserPromptSubmit hook command skipped (disabled by config)", { command: hook.command })
+        continue
+      }
+
+      const result = await executeHookCommand(
+        hook.command,
+        JSON.stringify(stdinData),
+        ctx.cwd,
+        { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath }
+      )
+
+      if (result.stdout) {
+        const output = result.stdout.trim()
+        if (output.startsWith(USER_PROMPT_SUBMIT_TAG_OPEN)) {
+          messages.push(output)
+        } else {
+          messages.push(`${USER_PROMPT_SUBMIT_TAG_OPEN}\n${output}\n${USER_PROMPT_SUBMIT_TAG_CLOSE}`)
+        }
+      }
+
+      if (result.exitCode !== 0) {
+        try {
+          const output = JSON.parse(result.stdout || "{}") as PostToolUseOutput
+          if (output.decision === "block") {
+            return {
+              block: true,
+              reason: output.reason || result.stderr,
+              modifiedParts,
+              messages,
+            }
+          }
+         } catch {
+          // Ignore JSON parse errors
+         }
+      }
+    }
+  }
+
+  return { block: false, modifiedParts, messages }
+}
--- a/src/hooks/index.ts
+++ b/src/hooks/index.ts
@@ -7,3 +7,5 @@ export { createGrepOutputTruncatorHook } from "./grep-output-truncator";
 export { createDirectoryAgentsInjectorHook } from "./directory-agents-injector";
 export { createEmptyTaskResponseDetectorHook } from "./empty-task-response-detector";
 export { createAnthropicAutoCompactHook } from "./anthropic-auto-compact";
+export { createThinkModeHook } from "./think-mode";
+export { createClaudeCodeHooksHook } from "./claude-code-hooks";
--- a/src/hooks/think-mode/detector.ts
+++ b/src/hooks/think-mode/detector.ts
@@ -0,0 +1,57 @@
+const ENGLISH_PATTERNS = [/\bultrathink\b/i, /\bthink\b/i]
+
+const MULTILINGUAL_KEYWORDS = [
+  "생각", "고민", "검토", "제대로",
+  "思考", "考虑", "考慮",
+  "思考", "考え", "熟考",
+  "सोच", "विचार",
+  "تفكير", "تأمل",
+  "চিন্তা", "ভাবনা",
+  "думать", "думай", "размышлять", "размышляй",
+  "pensar", "pense", "refletir", "reflita",
+  "pensar", "piensa", "reflexionar", "reflexiona",
+  "penser", "pense", "réfléchir", "réfléchis",
+  "denken", "denk", "nachdenken",
+  "suy nghĩ", "cân nhắc",
+  "düşün", "düşünmek",
+  "pensare", "pensa", "riflettere", "rifletti",
+  "คิด", "พิจารณา",
+  "myśl", "myśleć", "zastanów",
+  "denken", "denk", "nadenken",
+  "berpikir", "pikir", "pertimbangkan",
+  "думати", "думай", "роздумувати",
+  "σκέψου", "σκέφτομαι",
+  "myslet", "mysli", "přemýšlet",
+  "gândește", "gândi", "reflectă",
+  "tänka", "tänk", "fundera",
+  "gondolkodj", "gondolkodni",
+  "ajattele", "ajatella", "pohdi",
+  "tænk", "tænke", "overvej",
+  "tenk", "tenke", "gruble",
+  "חשוב", "לחשוב", "להרהר",
+  "fikir", "berfikir",
+]
+
+const MULTILINGUAL_PATTERNS = MULTILINGUAL_KEYWORDS.map((kw) => new RegExp(kw, "i"))
+const THINK_PATTERNS = [...ENGLISH_PATTERNS, ...MULTILINGUAL_PATTERNS]
+
+const CODE_BLOCK_PATTERN = /```[\s\S]*?```/g
+const INLINE_CODE_PATTERN = /`[^`]+`/g
+
+function removeCodeBlocks(text: string): string {
+  return text.replace(CODE_BLOCK_PATTERN, "").replace(INLINE_CODE_PATTERN, "")
+}
+
+export function detectThinkKeyword(text: string): boolean {
+  const textWithoutCode = removeCodeBlocks(text)
+  return THINK_PATTERNS.some((pattern) => pattern.test(textWithoutCode))
+}
+
+export function extractPromptText(
+  parts: Array<{ type: string; text?: string }>
+): string {
+  return parts
+    .filter((p) => p.type === "text")
+    .map((p) => p.text || "")
+    .join("")
+}
--- a/src/hooks/think-mode/index.ts
+++ b/src/hooks/think-mode/index.ts
@@ -0,0 +1,73 @@
+import { detectThinkKeyword, extractPromptText } from "./detector"
+import { getHighVariant, isAlreadyHighVariant } from "./switcher"
+import type { ThinkModeState, ThinkModeInput } from "./types"
+
+export * from "./detector"
+export * from "./switcher"
+export * from "./types"
+
+const thinkModeState = new Map<string, ThinkModeState>()
+
+export function clearThinkModeState(sessionID: string): void {
+  thinkModeState.delete(sessionID)
+}
+
+export function createThinkModeHook() {
+  return {
+    "chat.params": async (
+      output: ThinkModeInput,
+      sessionID: string
+    ): Promise<void> => {
+      const promptText = extractPromptText(output.parts)
+
+      const state: ThinkModeState = {
+        requested: false,
+        modelSwitched: false,
+      }
+
+      if (!detectThinkKeyword(promptText)) {
+        thinkModeState.set(sessionID, state)
+        return
+      }
+
+      state.requested = true
+
+      const currentModel = output.message.model
+      if (!currentModel) {
+        thinkModeState.set(sessionID, state)
+        return
+      }
+
+      state.providerID = currentModel.providerID
+      state.modelID = currentModel.modelID
+
+      if (isAlreadyHighVariant(currentModel.modelID)) {
+        thinkModeState.set(sessionID, state)
+        return
+      }
+
+      const highVariant = getHighVariant(currentModel.modelID)
+
+      if (!highVariant) {
+        thinkModeState.set(sessionID, state)
+        return
+      }
+
+      output.message.model = {
+        providerID: currentModel.providerID,
+        modelID: highVariant,
+      }
+      state.modelSwitched = true
+      thinkModeState.set(sessionID, state)
+    },
+
+    event: async ({ event }: { event: { type: string; properties?: unknown } }) => {
+      if (event.type === "session.deleted") {
+        const props = event.properties as { info?: { id?: string } } | undefined
+        if (props?.info?.id) {
+          thinkModeState.delete(props.info.id)
+        }
+      }
+    },
+  }
+}
--- a/src/hooks/think-mode/switcher.ts
+++ b/src/hooks/think-mode/switcher.ts
@@ -0,0 +1,91 @@
+const HIGH_VARIANT_MAP: Record<string, string> = {
+  "claude-sonnet-4-5": "claude-sonnet-4-5-high",
+  "claude-opus-4-5": "claude-opus-4-5-high",
+  "gpt-5.1": "gpt-5.1-high",
+  "gpt-5.1-medium": "gpt-5.1-high",
+  "gpt-5.1-codex": "gpt-5.1-codex-high",
+  "gemini-3-pro": "gemini-3-pro-high",
+  "gemini-3-pro-low": "gemini-3-pro-high",
+}
+
+const ALREADY_HIGH: Set<string> = new Set([
+  "claude-sonnet-4-5-high",
+  "claude-opus-4-5-high",
+  "gpt-5.1-high",
+  "gpt-5.1-codex-high",
+  "gemini-3-pro-high",
+])
+
+export const THINKING_CONFIGS: Record<string, Record<string, unknown>> = {
+  anthropic: {
+    thinking: {
+      type: "enabled",
+      budgetTokens: 64000,
+    },
+  },
+  "amazon-bedrock": {
+    reasoningConfig: {
+      type: "enabled",
+      budgetTokens: 32000,
+    },
+  },
+  google: {
+    providerOptions: {
+      google: {
+        thinkingConfig: {
+          thinkingLevel: "HIGH",
+        },
+      },
+    },
+  },
+  "google-vertex": {
+    providerOptions: {
+      "google-vertex": {
+        thinkingConfig: {
+          thinkingLevel: "HIGH",
+        },
+      },
+    },
+  },
+}
+
+const THINKING_CAPABLE_MODELS: Record<string, string[]> = {
+  anthropic: ["claude-sonnet-4", "claude-opus-4", "claude-3"],
+  "amazon-bedrock": ["claude", "anthropic"],
+  google: ["gemini-2", "gemini-3"],
+  "google-vertex": ["gemini-2", "gemini-3"],
+}
+
+export function getHighVariant(modelID: string): string | null {
+  if (ALREADY_HIGH.has(modelID)) {
+    return null
+  }
+  return HIGH_VARIANT_MAP[modelID] ?? null
+}
+
+export function isAlreadyHighVariant(modelID: string): boolean {
+  return ALREADY_HIGH.has(modelID) || modelID.endsWith("-high")
+}
+
+export function getThinkingConfig(
+  providerID: string,
+  modelID: string
+): Record<string, unknown> | null {
+  if (isAlreadyHighVariant(modelID)) {
+    return null
+  }
+
+  const config = THINKING_CONFIGS[providerID]
+  const capablePatterns = THINKING_CAPABLE_MODELS[providerID]
+
+  if (!config || !capablePatterns) {
+    return null
+  }
+
+  const modelLower = modelID.toLowerCase()
+  const isCapable = capablePatterns.some((pattern) =>
+    modelLower.includes(pattern.toLowerCase())
+  )
+
+  return isCapable ? config : null
+}
--- a/src/hooks/think-mode/types.ts
+++ b/src/hooks/think-mode/types.ts
@@ -0,0 +1,20 @@
+export interface ThinkModeState {
+  requested: boolean
+  modelSwitched: boolean
+  providerID?: string
+  modelID?: string
+}
+
+export interface ModelRef {
+  providerID: string
+  modelID: string
+}
+
+export interface MessageWithModel {
+  model?: ModelRef
+}
+
+export interface ThinkModeInput {
+  parts: Array<{ type: string; text?: string }>
+  message: MessageWithModel
+}
--- a/src/index.ts
+++ b/src/index.ts
@@ -8,11 +8,35 @@ import {
  createGrepOutputTruncatorHook,
  createDirectoryAgentsInjectorHook,
  createEmptyTaskResponseDetectorHook,
+  createThinkModeHook,
+  createClaudeCodeHooksHook,
 } from "./hooks";
+import {
+  loadUserCommands,
+  loadProjectCommands,
+  loadOpencodeGlobalCommands,
+  loadOpencodeProjectCommands,
+} from "./features/claude-code-command-loader";
+import {
+  loadUserSkillsAsCommands,
+  loadProjectSkillsAsCommands,
+} from "./features/claude-code-skill-loader";
+import {
+  loadUserAgents,
+  loadProjectAgents,
+} from "./features/claude-code-agent-loader";
+import { loadMcpConfigs } from "./features/claude-code-mcp-loader";
+import {
+  setCurrentSession,
+  setMainSession,
+  getMainSessionID,
+  getCurrentSessionTitle,
+} from "./features/claude-code-session-state";
 import { updateTerminalTitle } from "./features/terminal";
 import { builtinTools } from "./tools";
 import { createBuiltinMcps } from "./mcp";
 import { OhMyOpenCodeConfigSchema, type OhMyOpenCodeConfig } from "./config";
+import { log } from "./shared/logger";
 import * as fs from "fs";
 import * as path from "path";

@@ -30,12 +54,7 @@ function loadPluginConfig(directory: string): OhMyOpenCodeConfig {
        const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);

        if (!result.success) {
-          console.error(
-            `[oh-my-opencode] Config validation error in ${configPath}:`,
-          );
-          for (const issue of result.error.issues) {
-            console.error(`  - ${issue.path.join(".")}: ${issue.message}`);
-          }
+          log(`Config validation error in ${configPath}:`, result.error.issues);
          return {};
        }

@@ -50,6 +69,8 @@ function loadPluginConfig(directory: string): OhMyOpenCodeConfig {
 }

 const OhMyOpenCodePlugin: Plugin = async (ctx) => {
+  const pluginConfig = loadPluginConfig(ctx.directory);
+
  const todoContinuationEnforcer = createTodoContinuationEnforcer(ctx);
  const contextWindowMonitor = createContextWindowMonitorHook(ctx);
  const sessionRecovery = createSessionRecoveryHook(ctx);
@@ -57,41 +78,68 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
  const grepOutputTruncator = createGrepOutputTruncatorHook(ctx);
  const directoryAgentsInjector = createDirectoryAgentsInjectorHook(ctx);
  const emptyTaskResponseDetector = createEmptyTaskResponseDetectorHook(ctx);
+  const thinkMode = createThinkModeHook();
+  const claudeCodeHooks = createClaudeCodeHooksHook(ctx, {});

  updateTerminalTitle({ sessionId: "main" });

-  const pluginConfig = loadPluginConfig(ctx.directory);
-
-  let mainSessionID: string | undefined;
-  let currentSessionID: string | undefined;
-  let currentSessionTitle: string | undefined;
-
  return {
    tool: builtinTools,

+    "chat.message": async (input, output) => {
+      await claudeCodeHooks["chat.message"]?.(input, output)
+    },
+
    config: async (config) => {
-      const agents = createBuiltinAgents(
+      const builtinAgents = createBuiltinAgents(
        pluginConfig.disabled_agents,
        pluginConfig.agents,
      );
+      const userAgents = loadUserAgents();
+      const projectAgents = loadProjectAgents();

      config.agent = {
+        ...builtinAgents,
+        ...userAgents,
+        ...projectAgents,
        ...config.agent,
-        ...agents,
      };
      config.tools = {
        ...config.tools,
      };
+
+      const mcpResult = await loadMcpConfigs();
      config.mcp = {
        ...config.mcp,
        ...createBuiltinMcps(pluginConfig.disabled_mcps),
+        ...mcpResult.servers,
+      };
+
+      const userCommands = loadUserCommands();
+      const opencodeGlobalCommands = loadOpencodeGlobalCommands();
+      const systemCommands = config.command ?? {};
+      const projectCommands = loadProjectCommands();
+      const opencodeProjectCommands = loadOpencodeProjectCommands();
+      const userSkills = loadUserSkillsAsCommands();
+      const projectSkills = loadProjectSkillsAsCommands();
+
+      config.command = {
+        ...userCommands,
+        ...userSkills,
+        ...opencodeGlobalCommands,
+        ...systemCommands,
+        ...projectCommands,
+        ...projectSkills,
+        ...opencodeProjectCommands,
      };
    },

    event: async (input) => {
+      await claudeCodeHooks.event(input);
      await todoContinuationEnforcer(input);
      await contextWindowMonitor.event(input);
      await directoryAgentsInjector.event(input);
+      await thinkMode.event(input);

      const { event } = input;
      const props = event.properties as Record<string, unknown> | undefined;
@@ -101,14 +149,13 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
          | { id?: string; title?: string; parentID?: string }
          | undefined;
        if (!sessionInfo?.parentID) {
-          mainSessionID = sessionInfo?.id;
-          currentSessionID = sessionInfo?.id;
-          currentSessionTitle = sessionInfo?.title;
+          setMainSession(sessionInfo?.id);
+          setCurrentSession(sessionInfo?.id, sessionInfo?.title);
          updateTerminalTitle({
-            sessionId: currentSessionID || "main",
+            sessionId: sessionInfo?.id || "main",
            status: "idle",
            directory: ctx.directory,
-            sessionTitle: currentSessionTitle,
+            sessionTitle: sessionInfo?.title,
          });
        }
      }
@@ -118,23 +165,21 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
          | { id?: string; title?: string; parentID?: string }
          | undefined;
        if (!sessionInfo?.parentID) {
-          currentSessionID = sessionInfo?.id;
-          currentSessionTitle = sessionInfo?.title;
+          setCurrentSession(sessionInfo?.id, sessionInfo?.title);
          updateTerminalTitle({
-            sessionId: currentSessionID || "main",
+            sessionId: sessionInfo?.id || "main",
            status: "processing",
            directory: ctx.directory,
-            sessionTitle: currentSessionTitle,
+            sessionTitle: sessionInfo?.title,
          });
        }
      }

      if (event.type === "session.deleted") {
        const sessionInfo = props?.info as { id?: string } | undefined;
-        if (sessionInfo?.id === mainSessionID) {
-          mainSessionID = undefined;
-          currentSessionID = undefined;
-          currentSessionTitle = undefined;
+        if (sessionInfo?.id === getMainSessionID()) {
+          setMainSession(undefined);
+          setCurrentSession(undefined, undefined);
          updateTerminalTitle({
            sessionId: "main",
            status: "idle",
@@ -156,7 +201,7 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
          const recovered =
            await sessionRecovery.handleSessionRecovery(messageInfo);

-          if (recovered && sessionID && sessionID === mainSessionID) {
+          if (recovered && sessionID && sessionID === getMainSessionID()) {
            await ctx.client.session
              .prompt({
                path: { id: sessionID },
@@ -167,56 +212,58 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
          }
        }

-        if (sessionID && sessionID === mainSessionID) {
+        if (sessionID && sessionID === getMainSessionID()) {
          updateTerminalTitle({
            sessionId: sessionID,
            status: "error",
            directory: ctx.directory,
-            sessionTitle: currentSessionTitle,
+            sessionTitle: getCurrentSessionTitle(),
          });
        }
      }

      if (event.type === "session.idle") {
        const sessionID = props?.sessionID as string | undefined;
-        if (sessionID && sessionID === mainSessionID) {
+        if (sessionID && sessionID === getMainSessionID()) {
          updateTerminalTitle({
            sessionId: sessionID,
            status: "idle",
            directory: ctx.directory,
-            sessionTitle: currentSessionTitle,
+            sessionTitle: getCurrentSessionTitle(),
          });
        }
      }
    },

    "tool.execute.before": async (input, output) => {
+      await claudeCodeHooks["tool.execute.before"](input, output);
      await commentChecker["tool.execute.before"](input, output);

-      if (input.sessionID === mainSessionID) {
+      if (input.sessionID === getMainSessionID()) {
        updateTerminalTitle({
          sessionId: input.sessionID,
          status: "tool",
          currentTool: input.tool,
          directory: ctx.directory,
-          sessionTitle: currentSessionTitle,
+          sessionTitle: getCurrentSessionTitle(),
        });
      }
    },

    "tool.execute.after": async (input, output) => {
+      await claudeCodeHooks["tool.execute.after"](input, output);
      await grepOutputTruncator["tool.execute.after"](input, output);
      await contextWindowMonitor["tool.execute.after"](input, output);
      await commentChecker["tool.execute.after"](input, output);
      await directoryAgentsInjector["tool.execute.after"](input, output);
      await emptyTaskResponseDetector["tool.execute.after"](input, output);

-      if (input.sessionID === mainSessionID) {
+      if (input.sessionID === getMainSessionID()) {
        updateTerminalTitle({
          sessionId: input.sessionID,
          status: "idle",
          directory: ctx.directory,
-          sessionTitle: currentSessionTitle,
+          sessionTitle: getCurrentSessionTitle(),
        });
      }
    },
--- a/src/shared/command-executor.ts
+++ b/src/shared/command-executor.ts
@@ -0,0 +1,203 @@
+import { spawn } from "child_process"
+import { exec } from "child_process"
+import { promisify } from "util"
+import { existsSync } from "fs"
+
+const DEFAULT_ZSH_PATHS = ["/bin/zsh", "/usr/bin/zsh", "/usr/local/bin/zsh"]
+
+function findZshPath(customZshPath?: string): string | null {
+  if (customZshPath && existsSync(customZshPath)) {
+    return customZshPath
+  }
+  for (const path of DEFAULT_ZSH_PATHS) {
+    if (existsSync(path)) {
+      return path
+    }
+  }
+  return null
+}
+
+const execAsync = promisify(exec)
+
+export interface CommandResult {
+  exitCode: number
+  stdout?: string
+  stderr?: string
+}
+
+export interface ExecuteHookOptions {
+  forceZsh?: boolean
+  zshPath?: string
+}
+
+/**
+ * Execute a hook command with stdin input
+ */
+export async function executeHookCommand(
+  command: string,
+  stdin: string,
+  cwd: string,
+  options?: ExecuteHookOptions
+): Promise<CommandResult> {
+  const home = process.env.HOME ?? ""
+
+  let expandedCommand = command
+    .replace(/^~(?=\/|$)/g, home)
+    .replace(/\s~(?=\/)/g, ` ${home}`)
+    .replace(/\$CLAUDE_PROJECT_DIR/g, cwd)
+    .replace(/\$\{CLAUDE_PROJECT_DIR\}/g, cwd)
+
+  let finalCommand = expandedCommand
+
+  if (options?.forceZsh) {
+    const zshPath = options.zshPath || findZshPath()
+    if (zshPath) {
+      const escapedCommand = expandedCommand.replace(/'/g, "'\\''")
+      finalCommand = `${zshPath} -lc '${escapedCommand}'`
+    }
+  }
+
+  return new Promise((resolve) => {
+    const proc = spawn(finalCommand, {
+      cwd,
+      shell: true,
+      env: { ...process.env, HOME: home, CLAUDE_PROJECT_DIR: cwd },
+    })
+
+    let stdout = ""
+    let stderr = ""
+
+    proc.stdout?.on("data", (data) => {
+      stdout += data.toString()
+    })
+
+    proc.stderr?.on("data", (data) => {
+      stderr += data.toString()
+    })
+
+    proc.stdin?.write(stdin)
+    proc.stdin?.end()
+
+    proc.on("close", (code) => {
+      resolve({
+        exitCode: code ?? 0,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+      })
+    })
+
+    proc.on("error", (err) => {
+      resolve({
+        exitCode: 1,
+        stderr: err.message,
+      })
+    })
+  })
+}
+
+/**
+ * Execute a simple command and return output
+ */
+export async function executeCommand(command: string): Promise<string> {
+  try {
+    const { stdout, stderr } = await execAsync(command)
+
+    const out = stdout?.toString().trim() ?? ""
+    const err = stderr?.toString().trim() ?? ""
+
+    if (err) {
+      if (out) {
+        return `${out}\n[stderr: ${err}]`
+      }
+      return `[stderr: ${err}]`
+    }
+
+    return out
+  } catch (error: unknown) {
+    const e = error as { stdout?: Buffer; stderr?: Buffer; message?: string }
+    const stdout = e?.stdout?.toString().trim() ?? ""
+    const stderr = e?.stderr?.toString().trim() ?? ""
+    const errMsg = stderr || e?.message || String(error)
+
+    if (stdout) {
+      return `${stdout}\n[stderr: ${errMsg}]`
+    }
+    return `[stderr: ${errMsg}]`
+  }
+}
+
+/**
+ * Find and execute embedded commands in text (!`command`)
+ */
+interface CommandMatch {
+  fullMatch: string
+  command: string
+  start: number
+  end: number
+}
+
+const COMMAND_PATTERN = /!`([^`]+)`/g
+
+function findCommands(text: string): CommandMatch[] {
+  const matches: CommandMatch[] = []
+  let match: RegExpExecArray | null
+
+  COMMAND_PATTERN.lastIndex = 0
+
+  while ((match = COMMAND_PATTERN.exec(text)) !== null) {
+    matches.push({
+      fullMatch: match[0],
+      command: match[1],
+      start: match.index,
+      end: match.index + match[0].length,
+    })
+  }
+
+  return matches
+}
+
+/**
+ * Resolve embedded commands in text recursively
+ */
+export async function resolveCommandsInText(
+  text: string,
+  depth: number = 0,
+  maxDepth: number = 3
+): Promise<string> {
+  if (depth >= maxDepth) {
+    return text
+  }
+
+  const matches = findCommands(text)
+  if (matches.length === 0) {
+    return text
+  }
+
+  const tasks = matches.map((m) => executeCommand(m.command))
+  const results = await Promise.allSettled(tasks)
+
+  const replacements = new Map<string, string>()
+
+  matches.forEach((match, idx) => {
+    const result = results[idx]
+    if (result.status === "rejected") {
+      replacements.set(
+        match.fullMatch,
+        `[error: ${result.reason instanceof Error ? result.reason.message : String(result.reason)}]`
+      )
+    } else {
+      replacements.set(match.fullMatch, result.value)
+    }
+  })
+
+  let resolved = text
+  for (const [pattern, replacement] of replacements.entries()) {
+    resolved = resolved.split(pattern).join(replacement)
+  }
+
+  if (findCommands(resolved).length > 0) {
+    return resolveCommandsInText(resolved, depth + 1, maxDepth)
+  }
+
+  return resolved
+}
--- a/src/shared/file-reference-resolver.ts
+++ b/src/shared/file-reference-resolver.ts
@@ -0,0 +1,85 @@
+import { existsSync, readFileSync, statSync } from "fs"
+import { join, isAbsolute } from "path"
+
+interface FileMatch {
+  fullMatch: string
+  filePath: string
+  start: number
+  end: number
+}
+
+const FILE_REFERENCE_PATTERN = /@([^\s@]+)/g
+
+function findFileReferences(text: string): FileMatch[] {
+  const matches: FileMatch[] = []
+  let match: RegExpExecArray | null
+
+  FILE_REFERENCE_PATTERN.lastIndex = 0
+
+  while ((match = FILE_REFERENCE_PATTERN.exec(text)) !== null) {
+    matches.push({
+      fullMatch: match[0],
+      filePath: match[1],
+      start: match.index,
+      end: match.index + match[0].length,
+    })
+  }
+
+  return matches
+}
+
+function resolveFilePath(filePath: string, cwd: string): string {
+  if (isAbsolute(filePath)) {
+    return filePath
+  }
+  return join(cwd, filePath)
+}
+
+function readFileContent(resolvedPath: string): string {
+  if (!existsSync(resolvedPath)) {
+    return `[file not found: ${resolvedPath}]`
+  }
+
+  const stat = statSync(resolvedPath)
+  if (stat.isDirectory()) {
+    return `[cannot read directory: ${resolvedPath}]`
+  }
+
+  const content = readFileSync(resolvedPath, "utf-8")
+  return content
+}
+
+export async function resolveFileReferencesInText(
+  text: string,
+  cwd: string = process.cwd(),
+  depth: number = 0,
+  maxDepth: number = 3
+): Promise<string> {
+  if (depth >= maxDepth) {
+    return text
+  }
+
+  const matches = findFileReferences(text)
+  if (matches.length === 0) {
+    return text
+  }
+
+  const replacements = new Map<string, string>()
+
+  for (const match of matches) {
+    const resolvedPath = resolveFilePath(match.filePath, cwd)
+    const content = readFileContent(resolvedPath)
+    replacements.set(match.fullMatch, content)
+  }
+
+  let resolved = text
+  for (const [pattern, replacement] of replacements.entries()) {
+    resolved = resolved.split(pattern).join(replacement)
+  }
+
+  if (findFileReferences(resolved).length > 0 && depth + 1 < maxDepth) {
+    return resolveFileReferencesInText(resolved, cwd, depth + 1, maxDepth)
+  }
+
+  return resolved
+}
--- a/src/shared/frontmatter.ts
+++ b/src/shared/frontmatter.ts
@@ -0,0 +1,34 @@
+export interface FrontmatterResult<T = Record<string, string>> {
+  data: T
+  body: string
+}
+
+export function parseFrontmatter<T = Record<string, string>>(
+  content: string
+): FrontmatterResult<T> {
+  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/
+  const match = content.match(frontmatterRegex)
+
+  if (!match) {
+    return { data: {} as T, body: content }
+  }
+
+  const yamlContent = match[1]
+  const body = match[2]
+
+  const data: Record<string, string | boolean> = {}
+  for (const line of yamlContent.split("\n")) {
+    const colonIndex = line.indexOf(":")
+    if (colonIndex !== -1) {
+      const key = line.slice(0, colonIndex).trim()
+      let value: string | boolean = line.slice(colonIndex + 1).trim()
+
+      if (value === "true") value = true
+      else if (value === "false") value = false
+
+      data[key] = value
+    }
+  }
+
+  return { data: data as T, body }
+}
--- a/src/shared/hook-disabled.ts
+++ b/src/shared/hook-disabled.ts
@@ -0,0 +1,22 @@
+import type { ClaudeHookEvent, PluginConfig } from "../hooks/claude-code-hooks/types"
+
+export function isHookDisabled(
+  config: PluginConfig,
+  hookType: ClaudeHookEvent
+): boolean {
+  const { disabledHooks } = config
+
+  if (disabledHooks === undefined) {
+    return false
+  }
+
+  if (disabledHooks === true) {
+    return true
+  }
+
+  if (Array.isArray(disabledHooks)) {
+    return disabledHooks.includes(hookType)
+  }
+
+  return false
+}
--- a/src/shared/index.ts
+++ b/src/shared/index.ts
@@ -0,0 +1,9 @@
+export * from "./frontmatter"
+export * from "./command-executor"
+export * from "./file-reference-resolver"
+export * from "./model-sanitizer"
+export * from "./logger"
+export * from "./snake-case"
+export * from "./tool-name"
+export * from "./pattern-matcher"
+export * from "./hook-disabled"
--- a/src/shared/logger.ts
+++ b/src/shared/logger.ts
@@ -0,0 +1,20 @@
+// Shared logging utility for the plugin
+
+import * as fs from "fs"
+import * as os from "os"
+import * as path from "path"
+
+const logFile = path.join(os.tmpdir(), "oh-my-opencode.log")
+
+export function log(message: string, data?: unknown): void {
+  try {
+    const timestamp = new Date().toISOString()
+    const logEntry = `[${timestamp}] ${message} ${data ? JSON.stringify(data) : ""}\n`
+    fs.appendFileSync(logFile, logEntry)
+  } catch {
+  }
+}
+
+export function getLogFilePath(): string {
+  return logFile
+}
--- a/src/shared/model-sanitizer.ts
+++ b/src/shared/model-sanitizer.ts
@@ -0,0 +1,13 @@
+/**
+ * Sanitizes model field from frontmatter.
+ * Always returns undefined to let SDK use default model.
+ *
+ * Claude Code and OpenCode use different model ID formats,
+ * so we ignore the model field and let OpenCode use its configured default.
+ *
+ * @param _model - Raw model value from frontmatter (ignored)
+ * @returns Always undefined to inherit default model
+ */
+export function sanitizeModelField(_model: unknown): undefined {
+  return undefined
+}
--- a/src/shared/pattern-matcher.ts
+++ b/src/shared/pattern-matcher.ts
@@ -0,0 +1,29 @@
+import type { ClaudeHooksConfig, HookMatcher } from "../hooks/claude-code-hooks/types"
+
+export function matchesToolMatcher(toolName: string, matcher: string): boolean {
+  if (!matcher) {
+    return true
+  }
+  const patterns = matcher.split("|").map((p) => p.trim())
+  return patterns.some((p) => {
+    if (p.includes("*")) {
+      const regex = new RegExp(`^${p.replace(/\*/g, ".*")}$`, "i")
+      return regex.test(toolName)
+    }
+    return p.toLowerCase() === toolName.toLowerCase()
+  })
+}
+
+export function findMatchingHooks(
+  config: ClaudeHooksConfig,
+  eventName: keyof ClaudeHooksConfig,
+  toolName?: string
+): HookMatcher[] {
+  const hookMatchers = config[eventName]
+  if (!hookMatchers) return []
+
+  return hookMatchers.filter((hookMatcher) => {
+    if (!toolName) return true
+    return matchesToolMatcher(toolName, hookMatcher.matcher)
+  })
+}
--- a/src/shared/snake-case.ts
+++ b/src/shared/snake-case.ts
@@ -0,0 +1,51 @@
+export function camelToSnake(str: string): string {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)
+}
+
+export function snakeToCamel(str: string): string {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase())
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+export function objectToSnakeCase(
+  obj: Record<string, unknown>,
+  deep: boolean = true
+): Record<string, unknown> {
+   const result: Record<string, unknown> = {}
+   for (const [key, value] of Object.entries(obj)) {
+     const snakeKey = camelToSnake(key)
+     if (deep && isPlainObject(value)) {
+       result[snakeKey] = objectToSnakeCase(value, true)
+     } else if (deep && Array.isArray(value)) {
+       result[snakeKey] = value.map((item) =>
+         isPlainObject(item) ? objectToSnakeCase(item, true) : item
+       )
+     } else {
+       result[snakeKey] = value
+     }
+   }
+   return result
+ }
+
+export function objectToCamelCase(
+  obj: Record<string, unknown>,
+  deep: boolean = true
+): Record<string, unknown> {
+   const result: Record<string, unknown> = {}
+   for (const [key, value] of Object.entries(obj)) {
+     const camelKey = snakeToCamel(key)
+     if (deep && isPlainObject(value)) {
+       result[camelKey] = objectToCamelCase(value, true)
+     } else if (deep && Array.isArray(value)) {
+       result[camelKey] = value.map((item) =>
+         isPlainObject(item) ? objectToCamelCase(item, true) : item
+       )
+     } else {
+       result[camelKey] = value
+     }
+   }
+   return result
+ }
--- a/src/shared/tool-name.ts
+++ b/src/shared/tool-name.ts
@@ -0,0 +1,26 @@
+const SPECIAL_TOOL_MAPPINGS: Record<string, string> = {
+  webfetch: "WebFetch",
+  websearch: "WebSearch",
+  todoread: "TodoRead",
+  todowrite: "TodoWrite",
+}
+
+function toPascalCase(str: string): string {
+  return str
+    .split(/[-_\s]+/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join("")
+}
+
+export function transformToolName(toolName: string): string {
+  const lower = toolName.toLowerCase()
+  if (lower in SPECIAL_TOOL_MAPPINGS) {
+    return SPECIAL_TOOL_MAPPINGS[lower]
+  }
+
+  if (toolName.includes("-") || toolName.includes("_")) {
+    return toPascalCase(toolName)
+  }
+
+  return toolName.charAt(0).toUpperCase() + toolName.slice(1)
+}
--- a/src/tools/index.ts
+++ b/src/tools/index.ts
@@ -19,6 +19,8 @@ import {

 import { grep } from "./grep"
 import { glob } from "./glob"
+import { slashcommand } from "./slashcommand"
+import { skill } from "./skill"

 export const builtinTools = {
  lsp_hover,
@@ -36,4 +38,6 @@ export const builtinTools = {
  ast_grep_replace,
  grep,
  glob,
+  slashcommand,
+  skill,
 }
--- a/src/tools/skill/index.ts
+++ b/src/tools/skill/index.ts
@@ -0,0 +1,2 @@
+export * from "./types"
+export { skill } from "./tools"
--- a/src/tools/skill/tools.ts
+++ b/src/tools/skill/tools.ts
@@ -0,0 +1,326 @@
+import { tool } from "@opencode-ai/plugin"
+import { existsSync, readdirSync, statSync, readlinkSync, readFileSync } from "fs"
+import { homedir } from "os"
+import { join, resolve, basename } from "path"
+import { parseFrontmatter, resolveCommandsInText } from "../../shared"
+import type { SkillScope, SkillMetadata, SkillInfo, LoadedSkill } from "./types"
+
+function discoverSkillsFromDir(
+  skillsDir: string,
+  scope: SkillScope
+): Array<{ name: string; description: string; scope: SkillScope }> {
+  if (!existsSync(skillsDir)) {
+    return []
+  }
+
+  const entries = readdirSync(skillsDir, { withFileTypes: true })
+  const skills: Array<{ name: string; description: string; scope: SkillScope }> = []
+
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue
+
+    const skillPath = join(skillsDir, entry.name)
+
+    if (entry.isDirectory() || entry.isSymbolicLink()) {
+      let resolvedPath = skillPath
+      try {
+        const stats = statSync(skillPath, { throwIfNoEntry: false })
+        if (stats?.isSymbolicLink()) {
+          resolvedPath = resolve(skillPath, "..", readlinkSync(skillPath))
+        }
+      } catch {
+        continue
+      }
+
+      const skillMdPath = join(resolvedPath, "SKILL.md")
+      if (!existsSync(skillMdPath)) continue
+
+      try {
+        const content = readFileSync(skillMdPath, "utf-8")
+        const { data } = parseFrontmatter(content)
+
+        skills.push({
+          name: data.name || entry.name,
+          description: data.description || "",
+          scope,
+        })
+      } catch {
+        continue
+      }
+    }
+  }
+
+  return skills
+}
+
+function discoverSkillsSync(): Array<{ name: string; description: string; scope: SkillScope }> {
+  const userSkillsDir = join(homedir(), ".claude", "skills")
+  const projectSkillsDir = join(process.cwd(), ".claude", "skills")
+
+  const userSkills = discoverSkillsFromDir(userSkillsDir, "user")
+  const projectSkills = discoverSkillsFromDir(projectSkillsDir, "project")
+
+  return [...projectSkills, ...userSkills]
+}
+
+const availableSkills = discoverSkillsSync()
+const skillListForDescription = availableSkills
+  .map((s) => `- ${s.name}: ${s.description} (${s.scope})`)
+  .join("\n")
+
+function resolveSymlink(skillPath: string): string {
+  try {
+    const stats = statSync(skillPath, { throwIfNoEntry: false })
+    if (stats?.isSymbolicLink()) {
+      return resolve(skillPath, "..", readlinkSync(skillPath))
+    }
+    return skillPath
+  } catch {
+    return skillPath
+  }
+}
+
+async function parseSkillMd(skillPath: string): Promise<SkillInfo | null> {
+  const resolvedPath = resolveSymlink(skillPath)
+  const skillMdPath = join(resolvedPath, "SKILL.md")
+
+  if (!existsSync(skillMdPath)) {
+    return null
+  }
+
+  try {
+    let content = readFileSync(skillMdPath, "utf-8")
+    content = await resolveCommandsInText(content)
+    const { data, body } = parseFrontmatter(content)
+
+    const metadata: SkillMetadata = {
+      name: data.name || basename(skillPath),
+      description: data.description || "",
+      license: data.license,
+    }
+
+    const referencesDir = join(resolvedPath, "references")
+    const scriptsDir = join(resolvedPath, "scripts")
+    const assetsDir = join(resolvedPath, "assets")
+
+    const references = existsSync(referencesDir)
+      ? readdirSync(referencesDir).filter((f) => !f.startsWith("."))
+      : []
+
+    const scripts = existsSync(scriptsDir)
+      ? readdirSync(scriptsDir).filter((f) => !f.startsWith(".") && !f.startsWith("__"))
+      : []
+
+    const assets = existsSync(assetsDir)
+      ? readdirSync(assetsDir).filter((f) => !f.startsWith("."))
+      : []
+
+    return {
+      name: metadata.name,
+      path: resolvedPath,
+      metadata,
+      content: body,
+      references,
+      scripts,
+      assets,
+    }
+  } catch {
+    return null
+  }
+}
+
+async function discoverSkillsFromDirAsync(skillsDir: string): Promise<SkillInfo[]> {
+  if (!existsSync(skillsDir)) {
+    return []
+  }
+
+  const entries = readdirSync(skillsDir, { withFileTypes: true })
+  const skills: SkillInfo[] = []
+
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue
+
+    const skillPath = join(skillsDir, entry.name)
+
+    if (entry.isDirectory() || entry.isSymbolicLink()) {
+      const skillInfo = await parseSkillMd(skillPath)
+      if (skillInfo) {
+        skills.push(skillInfo)
+      }
+    }
+  }
+
+  return skills
+}
+
+async function discoverSkills(): Promise<SkillInfo[]> {
+  const userSkillsDir = join(homedir(), ".claude", "skills")
+  const projectSkillsDir = join(process.cwd(), ".claude", "skills")
+
+  const userSkills = await discoverSkillsFromDirAsync(userSkillsDir)
+  const projectSkills = await discoverSkillsFromDirAsync(projectSkillsDir)
+
+  return [...projectSkills, ...userSkills]
+}
+
+function findMatchingSkills(skills: SkillInfo[], query: string): SkillInfo[] {
+  const queryLower = query.toLowerCase()
+  const queryTerms = queryLower.split(/\s+/).filter(Boolean)
+
+  return skills
+    .map((skill) => {
+      let score = 0
+      const nameLower = skill.metadata.name.toLowerCase()
+      const descLower = skill.metadata.description.toLowerCase()
+
+      if (nameLower === queryLower) score += 100
+      if (nameLower.includes(queryLower)) score += 50
+
+      for (const term of queryTerms) {
+        if (nameLower.includes(term)) score += 20
+        if (descLower.includes(term)) score += 10
+      }
+
+      return { skill, score }
+    })
+    .filter(({ score }) => score > 0)
+    .sort((a, b) => b.score - a.score)
+    .map(({ skill }) => skill)
+}
+
+async function loadSkillWithReferences(
+  skill: SkillInfo,
+  includeRefs: boolean
+): Promise<LoadedSkill> {
+  const referencesLoaded: Array<{ path: string; content: string }> = []
+
+  if (includeRefs && skill.references.length > 0) {
+    for (const ref of skill.references) {
+      const refPath = join(skill.path, "references", ref)
+      try {
+        let content = readFileSync(refPath, "utf-8")
+        content = await resolveCommandsInText(content)
+        referencesLoaded.push({ path: ref, content })
+      } catch {
+      }
+    }
+  }
+
+  return {
+    name: skill.name,
+    metadata: skill.metadata,
+    body: skill.content,
+    referencesLoaded,
+  }
+}
+
+function formatSkillList(skills: SkillInfo[]): string {
+  if (skills.length === 0) {
+    return "No skills found in ~/.claude/skills/"
+  }
+
+  const lines = ["# Available Skills\n"]
+
+  for (const skill of skills) {
+    lines.push(`- **${skill.metadata.name}**: ${skill.metadata.description || "(no description)"}`)
+  }
+
+  lines.push(`\n**Total**: ${skills.length} skills`)
+  return lines.join("\n")
+}
+
+function formatLoadedSkills(loadedSkills: LoadedSkill[]): string {
+  if (loadedSkills.length === 0) {
+    return "No skills loaded."
+  }
+
+  const sections: string[] = ["# Loaded Skills\n"]
+
+  for (const skill of loadedSkills) {
+    sections.push(`## ${skill.metadata.name}\n`)
+    sections.push(`**Description**: ${skill.metadata.description || "(no description)"}\n`)
+    sections.push("### Skill Instructions\n")
+    sections.push(skill.body.trim())
+
+    if (skill.referencesLoaded.length > 0) {
+      sections.push("\n### Loaded References\n")
+      for (const ref of skill.referencesLoaded) {
+        sections.push(`#### ${ref.path}\n`)
+        sections.push("```")
+        sections.push(ref.content.trim())
+        sections.push("```\n")
+      }
+    }
+
+    sections.push("\n---\n")
+  }
+
+  const skillNames = loadedSkills.map((s) => s.metadata.name).join(", ")
+  sections.push(`**Skills loaded**: ${skillNames}`)
+  sections.push(`**Total**: ${loadedSkills.length} skill(s)`)
+  sections.push("\nPlease confirm these skills match your needs before proceeding.")
+
+  return sections.join("\n")
+}
+
+export const skill = tool({
+  description: `Execute a skill within the main conversation.
+
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills:
+- Invoke skills using this tool with the skill name only (no arguments)
+- When you invoke a skill, the skill's prompt will expand and provide detailed instructions on how to complete the task
+
+Important:
+- Only use skills listed in Available Skills below
+- Do not invoke a skill that is already running
+
+Skills are loaded from:
+- ~/.claude/skills/ (user scope - global skills)
+- ./.claude/skills/ (project scope - project-specific skills)
+
+Each skill contains:
+- SKILL.md: Main instructions with YAML frontmatter (name, description)
+- references/: Documentation files loaded into context as needed
+- scripts/: Executable code for deterministic operations
+- assets/: Files used in output (templates, icons, etc.)
+
+Available Skills:
+${skillListForDescription}`,
+
+  args: {
+    skill: tool.schema
+      .string()
+      .describe(
+        "The skill name or search query to find and load. Can be exact skill name (e.g., 'python-programmer') or keywords (e.g., 'python', 'plan')."
+      ),
+  },
+
+  async execute(args) {
+    const skills = await discoverSkills()
+
+    if (!args.skill) {
+      return formatSkillList(skills) + "\n\nProvide a skill name to load."
+    }
+
+    const matchingSkills = findMatchingSkills(skills, args.skill)
+
+    if (matchingSkills.length === 0) {
+      return (
+        `No skills found matching "${args.skill}".\n\n` +
+        formatSkillList(skills) +
+        "\n\nTry a different skill name."
+      )
+    }
+
+    const loadedSkills: LoadedSkill[] = []
+
+    for (const skillInfo of matchingSkills.slice(0, 3)) {
+      const loaded = await loadSkillWithReferences(skillInfo, true)
+      loadedSkills.push(loaded)
+    }
+
+    return formatLoadedSkills(loadedSkills)
+  },
+})
--- a/src/tools/skill/types.ts
+++ b/src/tools/skill/types.ts
@@ -0,0 +1,24 @@
+export type SkillScope = "user" | "project"
+
+export interface SkillMetadata {
+  name: string
+  description: string
+  license?: string
+}
+
+export interface SkillInfo {
+  name: string
+  path: string
+  metadata: SkillMetadata
+  content: string
+  references: string[]
+  scripts: string[]
+  assets: string[]
+}
+
+export interface LoadedSkill {
+  name: string
+  metadata: SkillMetadata
+  body: string
+  referencesLoaded: Array<{ path: string; content: string }>
+}
--- a/src/tools/slashcommand/index.ts
+++ b/src/tools/slashcommand/index.ts
@@ -0,0 +1,2 @@
+export * from "./types"
+export { slashcommand } from "./tools"
--- a/src/tools/slashcommand/tools.ts
+++ b/src/tools/slashcommand/tools.ts
@@ -0,0 +1,202 @@
+import { tool } from "@opencode-ai/plugin"
+import { existsSync, readdirSync, readFileSync } from "fs"
+import { homedir } from "os"
+import { join, basename, dirname } from "path"
+import { parseFrontmatter, resolveCommandsInText, resolveFileReferencesInText, sanitizeModelField } from "../../shared"
+import type { CommandScope, CommandMetadata, CommandInfo } from "./types"
+
+function discoverCommandsFromDir(commandsDir: string, scope: CommandScope): CommandInfo[] {
+  if (!existsSync(commandsDir)) {
+    return []
+  }
+
+  const entries = readdirSync(commandsDir, { withFileTypes: true })
+  const commands: CommandInfo[] = []
+
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue
+    if (!entry.name.endsWith(".md")) continue
+    if (!entry.isFile()) continue
+
+    const commandPath = join(commandsDir, entry.name)
+    const commandName = basename(entry.name, ".md")
+
+    try {
+      const content = readFileSync(commandPath, "utf-8")
+      const { data, body } = parseFrontmatter(content)
+
+      const metadata: CommandMetadata = {
+        name: commandName,
+        description: data.description || "",
+        argumentHint: data["argument-hint"],
+        model: sanitizeModelField(data.model),
+        agent: data.agent,
+        subtask: Boolean(data.subtask),
+      }
+
+      commands.push({
+        name: commandName,
+        path: commandPath,
+        metadata,
+        content: body,
+        scope,
+      })
+    } catch {
+      continue
+    }
+  }
+
+  return commands
+}
+
+function discoverCommandsSync(): CommandInfo[] {
+  const userCommandsDir = join(homedir(), ".claude", "commands")
+  const projectCommandsDir = join(process.cwd(), ".claude", "commands")
+  const opencodeGlobalDir = join(homedir(), ".config", "opencode", "command")
+  const opencodeProjectDir = join(process.cwd(), ".opencode", "command")
+
+  const userCommands = discoverCommandsFromDir(userCommandsDir, "user")
+  const opencodeGlobalCommands = discoverCommandsFromDir(opencodeGlobalDir, "opencode")
+  const projectCommands = discoverCommandsFromDir(projectCommandsDir, "project")
+  const opencodeProjectCommands = discoverCommandsFromDir(opencodeProjectDir, "opencode-project")
+
+  return [...opencodeProjectCommands, ...projectCommands, ...opencodeGlobalCommands, ...userCommands]
+}
+
+const availableCommands = discoverCommandsSync()
+const commandListForDescription = availableCommands
+  .map((cmd) => {
+    const hint = cmd.metadata.argumentHint ? ` ${cmd.metadata.argumentHint}` : ""
+    return `- /${cmd.name}${hint}: ${cmd.metadata.description} (${cmd.scope})`
+  })
+  .join("\n")
+
+async function formatLoadedCommand(cmd: CommandInfo): Promise<string> {
+  const sections: string[] = []
+
+  sections.push(`# /${cmd.name} Command\n`)
+
+  if (cmd.metadata.description) {
+    sections.push(`**Description**: ${cmd.metadata.description}\n`)
+  }
+
+  if (cmd.metadata.argumentHint) {
+    sections.push(`**Usage**: /${cmd.name} ${cmd.metadata.argumentHint}\n`)
+  }
+
+  if (cmd.metadata.model) {
+    sections.push(`**Model**: ${cmd.metadata.model}\n`)
+  }
+
+  if (cmd.metadata.agent) {
+    sections.push(`**Agent**: ${cmd.metadata.agent}\n`)
+  }
+
+  if (cmd.metadata.subtask) {
+    sections.push(`**Subtask**: true\n`)
+  }
+
+  sections.push(`**Scope**: ${cmd.scope}\n`)
+  sections.push("---\n")
+  sections.push("## Command Instructions\n")
+
+  const commandDir = dirname(cmd.path)
+  const withFileRefs = await resolveFileReferencesInText(cmd.content, commandDir)
+  const resolvedContent = await resolveCommandsInText(withFileRefs)
+  sections.push(resolvedContent.trim())
+
+  return sections.join("\n")
+}
+
+function formatCommandList(commands: CommandInfo[]): string {
+  if (commands.length === 0) {
+    return "No commands found."
+  }
+
+  const lines = ["# Available Commands\n"]
+
+  for (const cmd of commands) {
+    const hint = cmd.metadata.argumentHint ? ` ${cmd.metadata.argumentHint}` : ""
+    lines.push(
+      `- **/${cmd.name}${hint}**: ${cmd.metadata.description || "(no description)"} (${cmd.scope})`
+    )
+  }
+
+  lines.push(`\n**Total**: ${commands.length} commands`)
+  return lines.join("\n")
+}
+
+export const slashcommand = tool({
+  description: `Execute a slash command within the main conversation.
+
+When you use this tool, the slash command gets expanded to a full prompt that provides detailed instructions on how to complete the task.
+
+How slash commands work:
+- Invoke commands using this tool with the command name (without arguments)
+- The command's prompt will expand and provide detailed instructions
+- Arguments from user input should be passed separately
+
+Important:
+- Only use commands listed in Available Commands below
+- Do not invoke a command that is already running
+- **CRITICAL**: When user's message starts with '/' (e.g., "/commit", "/plan"), you MUST immediately invoke this tool with that command. Do NOT attempt to handle the command manually.
+
+Commands are loaded from (priority order, highest wins):
+- .opencode/command/ (opencode-project - OpenCode project-specific commands)
+- ./.claude/commands/ (project - Claude Code project-specific commands)
+- ~/.config/opencode/command/ (opencode - OpenCode global commands)
+- ~/.claude/commands/ (user - Claude Code global commands)
+
+Each command is a markdown file with:
+- YAML frontmatter: description, argument-hint, model, agent, subtask (optional)
+- Markdown body: The command instructions/prompt
+- File references: @path/to/file (relative to command file location)
+- Shell injection: \`!\`command\`\` (executes and injects output)
+
+Available Commands:
+${commandListForDescription}`,
+
+  args: {
+    command: tool.schema
+      .string()
+      .describe(
+        "The slash command to execute (without the leading slash). E.g., 'commit', 'plan', 'execute'."
+      ),
+  },
+
+  async execute(args) {
+    const commands = discoverCommandsSync()
+
+    if (!args.command) {
+      return formatCommandList(commands) + "\n\nProvide a command name to execute."
+    }
+
+    const cmdName = args.command.replace(/^\//, "")
+
+    const exactMatch = commands.find(
+      (cmd) => cmd.name.toLowerCase() === cmdName.toLowerCase()
+    )
+
+    if (exactMatch) {
+      return await formatLoadedCommand(exactMatch)
+    }
+
+    const partialMatches = commands.filter((cmd) =>
+      cmd.name.toLowerCase().includes(cmdName.toLowerCase())
+    )
+
+    if (partialMatches.length > 0) {
+      const matchList = partialMatches.map((cmd) => `/${cmd.name}`).join(", ")
+      return (
+        `No exact match for "/${cmdName}". Did you mean: ${matchList}?\n\n` +
+        formatCommandList(commands)
+      )
+    }
+
+    return (
+      `Command "/${cmdName}" not found.\n\n` +
+      formatCommandList(commands) +
+      "\n\nTry a different command name."
+    )
+  },
+})
--- a/src/tools/slashcommand/types.ts
+++ b/src/tools/slashcommand/types.ts
@@ -0,0 +1,18 @@
+export type CommandScope = "user" | "project" | "opencode" | "opencode-project"
+
+export interface CommandMetadata {
+  name: string
+  description: string
+  argumentHint?: string
+  model?: string
+  agent?: string
+  subtask?: boolean
+}
+
+export interface CommandInfo {
+  name: string
+  path: string
+  metadata: CommandMetadata
+  content: string
+  scope: CommandScope
+}
Author	SHA1	Message	Date
github-actions[bot]	2d23a81926	release: v0.3.0	2025-12-09 12:51:28 +00:00
YeonGyu-Kim	31cb8616c2	chore: bump version to 0.2.0 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 21:47:21 +09:00
YeonGyu-Kim	1932257f82	docs(readme): add comprehensive Claude Code compatibility documentation - Add new 'Claude Code Compatibility' section to both README.md and README.ko.md - Document hooks integration (PreToolUse, PostToolUse, UserPromptSubmit, Stop) - Document configuration loaders (Command, Skill, Agent, MCP loaders) - Document data storage (Todo management, Transcript logging) - Simplify 'Other Features' section by moving loaders to new section - Clean up temporary planning files in local-ignore/ 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 21:47:01 +09:00
YeonGyu-Kim	5a793bb526	fix(hooks): align Claude Code hooks with opencode-cc-plugin reference 100% port verification via Oracle agent parallel checks: - PreToolUse: recordToolUse(), isHookDisabled(), Object.assign(), error message - PostToolUse: recordToolResult(), isHookDisabled(), permissionMode, title field - Stop: isHookDisabled(), parentSessionId, error/interrupt state tracking - UserPromptSubmit: interrupt checks, recordUserMessage(), log messages All four hooks now match opencode-cc-plugin/src/plugin/*.ts exactly. 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 19:00:01 +09:00
YeonGyu-Kim	2ec351d0d8	feat(hooks): implement UserPromptSubmit with chat.message hook and injectHookMessage - Add chat.message handler to createClaudeCodeHooksHook factory - Integrate executeUserPromptSubmitHooks() for user prompt processing - Use injectHookMessage() for file system based message injection - Add sessionFirstMessageProcessed tracking for title generation skip - Register chat.message hook in plugin entry point This completes 100% port of Claude Code hooks from opencode-cc-plugin. 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 18:20:13 +09:00
YeonGyu-Kim	441fc1a219	feat(hooks): integrate Claude Code hooks with plugin system - Create factory function createClaudeCodeHooksHook() - Wire tool.execute.before → executePreToolUseHooks - Wire tool.execute.after → executePostToolUseHooks - Wire event (session.idle) → executeStopHooks - Register hooks in src/index.ts - Claude hooks execute first in handler chain 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 18:10:30 +09:00
YeonGyu-Kim	bd67419d1d	feat(features): add hook message injector - Port hook-message-injector from opencode-cc-plugin (4 files) - constants.ts: XDG-based path definitions (MESSAGE_STORAGE, PART_STORAGE) - types.ts: MessageMeta, OriginalMessageContext, TextPart interfaces - injector.ts: injectHookMessage() implementation with message/part storage - index.ts: Barrel export - Self-contained module with no import path changes needed - Preserves XDG_DATA_HOME environment variable support - Preserves message fallback logic for incomplete originalMessage 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 18:02:45 +09:00
YeonGyu-Kim	dca98121ac	feat(hooks): add UserPromptSubmit and Stop executors - Port user-prompt-submit.ts from opencode-cc-plugin (118 lines) - Port stop.ts from opencode-cc-plugin (119 lines) - Preserve recursion prevention logic (<user-prompt-submit-hook> tags) - Preserve inject_prompt support (message injection, stop prompt injection) - Preserve stopHookActiveState management (per-session state) - Import path adjustments: ../types → ./types, ../../config → ./plugin-config - All exit code handling preserved (exitCode 2 → block, etc.) 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 18:00:16 +09:00
YeonGyu-Kim	3fcfedcec0	feat(hooks): add PostToolUse hook executor - Port post-tool-use.ts from opencode-cc-plugin (200 lines) - Implement executePostToolUseHooks() with full transcript support - Include temp file cleanup in finally block - Preserve all exit code handling and output fields - Update notepad.md with Task 5 completion log 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 17:55:06 +09:00
YeonGyu-Kim	530c4d63d5	feat(hooks): add PreToolUse hook executor 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 17:48:28 +09:00
YeonGyu-Kim	e0b43380cc	feat(hooks): add Claude hooks config, transcript, and todo 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 17:41:39 +09:00
YeonGyu-Kim	a27cac96d5	feat(hooks): add Claude Code hooks type definitions 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 17:36:12 +09:00
YeonGyu-Kim	fef7f4ca03	feat(shared): add Claude hooks command executor and utilities - Add snake-case.ts: objectToSnakeCase, objectToCamelCase utilities - Add tool-name.ts: transformToolName with PascalCase conversion - Add pattern-matcher.ts: findMatchingHooks for hook config matching - Add hook-disabled.ts: isHookDisabled for hook config validation - Add temporary stub types at src/hooks/claude-code-hooks/types.ts - Export all new utilities from src/shared/index.ts Stub types will be replaced with full implementation in Task 1. Import paths adjusted from opencode-cc-plugin structure to oh-my-opencode. 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 17:31:15 +09:00
YeonGyu-Kim	e147be7ed4	feat: update comment-checker to v0.5.0 BREAKING CHANGE: Docstrings are now detected as code smell. See: https://github.com/code-yeongyu/go-claude-code-comment-checker/releases/tag/v0.5.0 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 16:59:22 +09:00
YeonGyu-Kim	124c3b3e8f	docs: fix documentation inconsistencies identified by Oracle - Add source path annotations to Command/Skill/Agent/MCP Loaders - Add Session State feature documentation - MCP Loader paths verified (match loader.ts: ~/.claude/.mcp.json, ./.mcp.json, ./.claude/.mcp.json) 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 16:59:22 +09:00
YeonGyu-Kim	5678e0bac6	docs(readme): document new claude-code feature loaders 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 16:59:22 +09:00
YeonGyu-Kim	207435450c	refactor(index): integrate session-state module and remove local variables - Add imports: agent-loader, mcp-loader, session-state, logger - Remove local session variables (mainSessionID, currentSessionID, currentSessionTitle) - Use setter/getter functions from session-state module - Add agent loading in config hook (loadUserAgents, loadProjectAgents) - Add MCP loading in config hook (loadMcpConfigs) - Replace console.error with logger 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 16:59:22 +09:00
YeonGyu-Kim	376bf363af	feat(features): add claude-code-agent-loader, mcp-loader, session-state	2025-12-09 16:59:22 +09:00
YeonGyu-Kim	c7a65af475	refactor(features): rename command-loader and skill-loader with claude-code prefix	2025-12-09 16:59:22 +09:00
YeonGyu-Kim	8e7447deee	feat(shared): add file-based logger utility	2025-12-09 16:59:22 +09:00
YeonGyu-Kim	15a748b817	docs: add missing hooks and features to README Add 4 missing hooks documentation: - Think Mode: auto-detect deep thinking requests - Anthropic Auto Compact: auto-compact context - Empty Task Response Detector: handle empty responses - Grep Output Truncator: prevent output overflow Add 2 missing features documentation: - Command Loader: load commands from multiple paths - Skill Loader: load skills as executable commands 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 16:59:22 +09:00
YeonGyu-Kim	c0e0dc1f95	feat: integrate command/skill loaders and think-mode hook in main entry - Add loadCommands() and loadSkills() to config - Register think-mode hook for UserPromptSubmit event 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 16:59:22 +09:00
YeonGyu-Kim	7059407cbc	feat(hooks): export createThinkModeHook from index 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 16:59:22 +09:00
YeonGyu-Kim	589cf60252	feat(hooks): add think-mode hook for automatic model switching Detects thinking keywords (ultrathink, deepthink, etc.) and switches to thinking-capable models automatically. Supports model patterns: - claude-sonnet-4-0 -> claude-sonnet-4-0-max-thinking - claude-sonnet-4-20250514 -> claude-sonnet-4-20250514-max-thinking 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 16:59:22 +09:00
YeonGyu-Kim	e5cdaa5192	feat(tools): export slashcommand and skill tools from index 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 16:59:22 +09:00
YeonGyu-Kim	340eb30147	feat(tools): add skill tool for invoking skills in conversation Provides 'skill' tool that invokes skills loaded by skill-loader. Skills expand into detailed instructions when invoked. 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 16:59:22 +09:00
YeonGyu-Kim	e72b927ccb	feat(tools): add slashcommand tool for executing slash commands Provides 'slashcommand' tool that executes commands loaded by command-loader. Handles shell injection and file reference resolution. 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 16:59:22 +09:00
YeonGyu-Kim	3c6ffe5d9c	feat(skill-loader): add skill loader that converts skills to commands Skills are loaded from: - ~/.claude/skills/ (user scope) - .claude/skills/ (project scope) Each skill directory contains SKILL.md with frontmatter metadata. 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 16:59:22 +09:00
YeonGyu-Kim	938a3709e1	feat(command-loader): add slash command loader from multiple paths Load commands from 4 directory scopes: - .opencode/command/ (opencode-project) - .claude/commands/ (project) - ~/.config/opencode/command/ (opencode) - ~/.claude/commands/ (user) 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 16:59:22 +09:00
YeonGyu-Kim	47f218e33f	feat(shared): add shared utilities for command and skill loading - frontmatter.ts: YAML frontmatter parser - file-reference-resolver.ts: resolve @file references in markdown - command-executor.ts: execute shell commands in markdown - model-sanitizer.ts: sanitize model names for OpenCode compatibility 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 16:59:22 +09:00
github-actions[bot]	e07a25baa4	release: v0.1.31	2025-12-09 05:42:03 +00:00
YeonGyu-Kim	08ede0a28d	deps: bump @code-yeongyu/comment-checker to 0.4.4 🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)	2025-12-09 14:41:07 +09:00