claude-memory-layer 1.0.11 → 1.0.12

package/memory/default/uncategorized/2026-02-25.md

@@ -0,0 +1,4839 @@
+
+## 2026-02-25T12:31:21.747Z | b9246a1c-4968-424a-aee5-d4c62a2d1346
+- type: session_summary
+- session: import:organized
+# Codex / AI Agent Instructions
+
+이 저장소는 **Claude Code용 메모리 플러그인 + CLI + 로컬 대시보드 서버**입니다.
+Codex(또는 다른 코딩 에이전트)가 작업할 때 아래 규칙을 우선으로 따르세요.
+
+## Quick Commands
+
+```bash
+npm install
+npm run build
+
+# 웹 대시보드(로컬)
+node dist/server/index.js
+# 또는
+npx claude-memory-layer dashboard
+```
+
+## Key Entry Points
+
+- `scripts/build.ts`: esbuild 기반 빌드. `dist/` 생성 + `.claude-plugin/` 및 `src/ui` 복사
+- `src/cli/index.ts`: CLI 엔트리포인트 (`bin`: `claude-memory-layer`)
+- `src/server/index.ts`: 대시보드/REST API 서버 (기본 포트 `37777`)
+- `src/server/api/chat.ts`: **외부 `claude` CLI**를 `spawn('claude', ...)`로 호출 (환경에 따라 미설치일 수 있음)
+
+## Local Side-Effects (주의)
+
+- `claude-memory-layer install` / `uninstall` 은 **사용자 머신의** `~/.claude/settings.json` 을 수정합니다.
+  - 자동 실행/테스트 목적으로 임의 실행하지 말고, 사용자가 명시적으로 요청할 때만 실행하세요.
+- 훅/CLI/서버는 기본적으로 `~/.claude-code/memory` 아래에 데이터를 읽고/씁니다.
+  - 메모리 스토리지를 삭제/초기화하는 동작은 요청 없이는 하지 마세요.
+
+## Common Pitfall: Self-dependency (반복 발생)
+
+`package.json`의 `dependencies`에 **자기 자신**을 추가하면 설치가 꼬입니다.
+
+- 금지 예: `"claude-memory-layer": "^1.0.x"`
+- 진단: `npm list claude-memory-layer` 결과가 `(empty)` 여야 정상
+- 복구:
+
+```bash
+rm package-lock.json && rm -rf node_modules
+npm install
+npm list claude-memory-layer
+```
+
+## Release / Publish Workflow
+
+1. Self-dependency 확인: `npm list claude-memory-layer` → `(empty)`
+2. 버전 업데이트: `npm version patch` 또는 `package.json` 수정
+3. 빌드: `npm run build`
+4. 배포: `npm publish --otp=<code>`
+5. 확인: `npm view claude-memory-layer versions`
+
+## Dev Notes
+
+- Node.js: `>=18` (ESM 프로젝트)
+- 스토리지: **SQLite(WAL) 기반**으로 훅(쓰기) + 서버(읽기) 동시 동작을 전제로 함
+- 테스트/정적분석 스크립트는 존재하지만, 현재 시점에서 전부 “항상 green”을 보장하지 않을 수 있으니
+  변경 전후로 실제 실행 결과를 확인하고 진행하세요.
+
+
+## 2026-02-25T12:31:21.748Z | ac708211-cc0a-4817-aa7d-372f6ec29338
+- type: session_summary
+- session: import:organized
+# Code Memory - Project Instructions
+
+## Common Mistakes to Avoid
+
+### ⚠️ Self-dependency in package.json (반복 발생 주의!)
+- **절대로** package.json의 dependencies에 자기 자신의 패키지를 추가하지 말 것
+- 예: `"claude-memory-layer": "^1.0.x"` 같은 순환 의존성 금지
+- npm list 시 이상한 중첩 구조가 보이면 self-dependency 의심할 것
+
+#### 원인
+- `package-lock.json`에 self-dependency가 저장되면, `npm install` 시 package.json에 복원됨
+- 한번 잘못 들어가면 lock 파일 때문에 계속 복원되는 악순환 발생
+
+#### 해결 방법
+```bash
+# 1. package.json에서 self-dependency 제거
+# 2. lock 파일과 node_modules 삭제
+rm package-lock.json && rm -rf node_modules
+# 3. 새로 설치
+npm install
+# 4. 확인 (empty가 나와야 정상)
+npm list claude-memory-layer
+```
+
+## npm Publish Workflow
+1. Self-dependency 확인: `npm list claude-memory-layer` → `(empty)` 확인
+2. 버전 업데이트: package.json 직접 수정 또는 `npm version patch`
+3. 빌드: `npm run build`
+4. 배포: `npm publish --otp=<코드>`
+5. 확인: `npm view claude-memory-layer versions`
+
+## 2026-02-25T12:31:21.749Z | f509ff1e-5ec2-4749-83c7-f96eedd933e8
+- type: session_summary
+- session: import:organized
+# Claude Memory Layer - 작업 핸드오프 문서
+
+## 현재 상태
+**날짜**: 2026-02-01
+**상태**: SQLite WAL 마이그레이션 완료 ✅
+
+## 문제 해결 완료
+
+### 기존 문제
+- DuckDB 다중 프로세스 동시 접근 충돌
+- 웹 대시보드 (localhost:37777)에서 500 에러
+- 훅과 서버 동시 실행 불가
+
+### 해결책: 2-tier 스토리지 아키텍처
+```
+Hooks (쓰기) ──▶ SQLite (WAL) ◀── Server (읽기)
+                     │
+                     └── 동시 접근 가능 ✅
+```
+
+## 구현된 변경사항
+
+### 새 파일
+1. **`src/core/sqlite-wrapper.ts`** - SQLite WAL 모드 래퍼
+2. **`src/core/sqlite-event-store.ts`** - SQLite 기반 EventStore
+3. **`src/core/sync-worker.ts`** - SQLite→DuckDB 동기화 워커 (미래 분석용)
+
+### 수정된 파일
+1. **`src/services/memory-service.ts`** - 이중 스토어 아키텍처 통합
+   - `sqliteStore`: Primary store (항상 사용)
+   - `analyticsStore`: DuckDB (옵션, 분석용)
+   - `analyticsEnabled` 옵션 추가
+
+2. **`src/core/index.ts`** - 새 모듈 export
+
+3. **`scripts/build.ts`** - better-sqlite3 external 추가
+
+4. **`package.json`** - better-sqlite3 의존성 추가
+
+## 테스트 결과
+```bash
+# 서버 실행 중 훅 테스트
+$ node dist/server/index.js &
+$ echo '{"session_id":"test","prompt":"test","cwd":"/tmp"}' | node dist/hooks/user-prompt-submit.js
+{"context":""}  # 성공!
+
+# 동시 실행 테스트 (5개 훅 병렬)
+All hooks completed ✅
+eventCount: 7
+```
+
+## 아키텍처 결정
+
+### Primary Store: SQLite (WAL 모드)
+- 훅에서 직접 쓰기
+- 서버에서 직접 읽기
+- WAL 모드: 다중 리더 + 단일 라이터 지원
+- 락 충돌 없음
+
+### Analytics Store: DuckDB (옵션, 미래용)
+- 복잡한 분석 쿼리용
+- 배치 동기화 (SyncWorker)
+- 현재는 비활성화
+
+## 빌드 및 실행
+
+```bash
+# 빌드
+npm run build
+
+# 서버 시작
+node dist/server/index.js
+
+# 훅 테스트 (서버 실행 중에도 가능!)
+echo '{"session_id":"test","prompt":"test","cwd":"/tmp"}' | node dist/hooks/user-prompt-submit.js
+
+# 대시보드
+open http://localhost:37777
+```
+
+## 향후 작업 (선택사항)
+
+1. **DuckDB 분석 기능 활성화**
+   - SyncWorker로 SQLite→DuckDB 동기화
+   - 복잡한 통계/분석 쿼리에 DuckDB 사용
+
+2. **Shared Store SQLite 마이그레이션**
+   - 현재: 훅에서 비활성화
+   - 향후: SQLite 기반으로 전환
+
+3. **마이그레이션 도구**
+   - 기존 DuckDB 데이터를 SQLite로 마이그레이션
+
+## 2026-02-25T12:31:21.750Z | 51d82e23-a7ef-4b51-92d0-1d5d33f1b606
+- type: session_summary
+- session: import:organized
+# Claude Memory Layer
+
+Claude Code 플러그인으로, 대화 내용을 기억하여 사용할수록 똑똑해지는 AI 어시스턴트를 만듭니다.
+
+## 개요
+
+Claude Memory Layer는 Claude Code에서 사용자와 AI 간의 모든 대화를 저장하고, 새로운 질문을 할 때 관련된 과거 대화를 자동으로 검색하여 컨텍스트로 제공합니다. 이를 통해:
+
+- **연속성 있는 대화**: 이전 세션에서 논의한 내용을 기억
+- **프로젝트 맥락 이해**: 프로젝트별로 축적된 지식 활용
+- **개인화된 응답**: 사용자의 선호도와 패턴 학습
+
+## Features
+
+### Core Features
+
+- **Conversation Memory**: 사용자 프롬프트와 AI 응답 저장
+- **Semantic Search**: 벡터 임베딩을 통한 의미 기반 검색
+- **AXIOMMIND Architecture**: 7가지 원칙 기반 안정적 메모리 관리
+- **Memory Graduation**: L0→L4 단계별 메모리 승격
+- **Evidence Alignment**: 응답이 실제 기억에 기반했는지 검증
+- **History Import**: 기존 Claude Code 세션 기록 임포트
+
+### Advanced Features
+
+- **Citations System**: 메모리 출처 추적 (`[mem:abc123]` 형식)으로 검색 결과의 원본 확인 가능
+- **Endless Mode**: 세션 경계 없는 연속적 메모리 스트림, Biomimetic Memory Architecture 기반
+- **Entity-Edge Model**: entries/entities/edges 3-layer 모델로 데이터 관계 명시적 모델링
+- **Evidence Aligner V2**: Quote 기반 3단계 정렬 (exact → normalized → fuzzy)
+- **MCP Desktop Integration**: Claude Desktop용 MCP 서버로 CLI와 동일한 메모리 공유
+- **PostToolUse Hook**: 도구 실행 결과 (Read, Write, Bash 등) 캡처 및 저장
+- **Private Tags**: `<private>` 태그로 민감 정보를 명시적으로 제외
+- **Progressive Disclosure**: 3-Layer 검색 (인덱스 → 타임라인 → 상세)으로 토큰 효율화
+- **memU-inspired Retrieval**: fast/deep 전략 + 스코프 필터(session prefix, canonical key prefix, metadata path)
+- **Append-only Markdown Mirror**: 저장 이벤트를 `memory/<namespace>/<category...>/YYYY-MM-DD.md`에도 동기 append (기본값: `namespace=default`, `category=uncategorized`, 경로 세그먼트 sanitize)
+  - `memory/_index.md` 인덱스를 자동 갱신
+- **Task Entity System**: Task를 Entity로 승격하여 세션 간 상태 추적
+- **Vector Outbox V2**: Transactional Outbox 패턴으로 DuckDB-LanceDB 정합성 보장
+- **Web Viewer UI**: localhost:37777 대시보드로 실시간 메모리 모니터링
+
+## 설치 방법
+
+### 1. 의존성 설치
+
+```bash
+cd claude-memory-layer
+npm install
+```
+
+### 2. 빌드
+
+```bash
+npm run build
+```
+
+### 3. Claude Code에 플러그인 등록
+
+빌드된 플러그인을 Claude Code 설정에 추가합니다:
+
+```bash
+# Claude Code 설정 디렉토리에 플러그인 복사
+cp -r dist/.claude-plugin ~/.claude/plugins/claude-memory-layer/
+```
+
+## 사용 방법
+
+### 자동 동작 (Hooks)
+
+플러그인은 Claude Code 세션에 자동으로 연결되어 동작합니다:
+
+| Hook | 동작 |
+|------|------|
+| **SessionStart** | 세션 시작 시 프로젝트 관련 컨텍스트 로드 |
+| **UserPromptSubmit** | 프롬프트 입력 시 관련 기억 검색 및 저장 |
+| **Stop** | AI 응답 완료 시 응답 내용 저장 |
+| **SessionEnd** | 세션 종료 시 요약 생성 및 저장 |
+
+### Slash 명령어
+
+Claude Code 내에서 사용할 수 있는 명령어:
+
+```bash
+# 메모리 검색 - 관련 기억 찾기
+/memory-search "authentication 구현 방법"
+
+# 대화 기록 보기
+/memory-history
+/memory-history --limit 50
+/memory-history --session <session-id>
+
+# 통계 확인
+/memory-stats
+
+# 기존 대화 기록 임포트
+/memory-import                            # 현재 프로젝트
+/memory-import --all                      # 모든 프로젝트
+/memory-import --project /path/to/project # 특정 프로젝트
+
+# 임포트 가능한 세션 목록
+/memory-list
+
+# 메모리 삭제
+/memory-forget --session <id> --confirm
+```
+
+### 기존 메모리 정리 Import (구조화)
+
+레거시 markdown 메모리를 읽어서 구조화 경로로 재저장(import)할 수 있습니다.
+
+```bash
+# 미리보기(실제 저장 없음)
+claude-memory-layer organize-import /path/to/legacy-memory --dry-run
+
+# 실제 import
+claude-memory-layer organize-import /path/to/legacy-memory --project /path/to/project
+
+# 일부만 import
+claude-memory-layer organize-import /path/to/legacy-memory --limit 100
+
+# source에 markdown이 없으면 자동 bootstrap(코드+git 분석)
+claude-memory-layer organize-import /path/to/empty-dir --project /path/to/project
+
+# bootstrap 강제 실행
+claude-memory-layer organize-import /path/to/memory --force-bootstrap --repo /path/to/project
+
+# 자동 bootstrap 비활성화
+claude-memory-layer organize-import /path/to/empty-dir --no-bootstrap-if-empty
+
+# markdown이 없는 초기 상태면 bootstrap 생성 + import
+claude-memory-layer organize-import /path/to/empty-dir --bootstrap --repo /path/to/codebase
+
+# bootstrap 강제 재생성 (기존 markdown 있어도)
+claude-memory-layer organize-import /path/to/legacy-memory --force-bootstrap --repo /path/to/codebase --out /path/to/legacy-memory/bootstrap-kb
+
+# 증분 bootstrap (기본값): 이전 manifest를 기준으로 변경분 중심 업데이트
+claude-memory-layer organize-import /path/to/legacy-memory --bootstrap --repo /path/to/codebase --incremental
+
+# 전체 재생성 bootstrap
+claude-memory-layer organize-import /path/to/legacy-memory --bootstrap --repo /path/to/codebase --no-incremental
+```
+
+### CLI 명령어
+
+터미널에서 직접 사용:
+
+```bash
+# 메모리 검색
+npx claude-memory-layer search "React 컴포넌트 패턴"
+npx claude-memory-layer search "API 에러 처리" --top-k 10
+
+# 대화 기록 조회
+npx claude-memory-layer history
+npx claude-memory-layer history --limit 50 --type user_prompt
+
+# 통계 확인
+npx claude-memory-layer stats
+
+# 기존 세션 임포트
+npx claude-memory-layer import                    # 현재 프로젝트
+npx claude-memory-layer import --all              # 모든 프로젝트
+npx claude-memory-layer import --all --verbose    # 상세 로그
+
+# 임포트 가능한 세션 목록
+npx claude-memory-layer list
+npx claude-memory-layer list --project /path/to/project
+
+# 임베딩 수동 처리
+npx claude-memory-layer process
+
+# MongoDB 동기화 (옵션, 멀티 서버 협업)
+# - 여러 서버에서 같은 프로젝트를 개발할 때, 각 서버의 로컬 SQLite(events.sqlite) 이벤트를
+#   하나의 MongoDB로 모아 push/pull 동기화할 수 있습니다.
+# - 동일 프로젝트는 반드시 같은 project key로 실행해야 합니다.
+export CLAUDE_MEMORY_MONGO_URI="mongodb://USER:PASSWORD@HOST:PORT/"
+export CLAUDE_MEMORY_MONGO_DB="claude_memory_layer"
+export CLAUDE_MEMORY_MONGO_PROJECT="my-project"
+
+# 1회 동기화 (push+pull)
+npx claude-memory-layer mongo-sync
+
+# 지속 동기화 (주기적으로 push+pull)
+npx claude-memory-layer mongo-sync --watch --interval 30000
+```
+
+### memU-inspired Retrieval 사용 예시
+
+아래 예시는 SDK/서비스 레벨에서 `retrieveMemories()` 호출 시 적용되는 옵션입니다.
+
+```ts
+import { getMemoryServiceForProject } from './src/services/memory-service.js';
+
+const memory = getMemoryServiceForProject('/path/to/project');
+
+// 1) Fast: 키워드 기반 빠른 검색
+const fast = await memory.retrieveMemories('브리핑 포맷', {
+  strategy: 'fast',
+  topK: 5,
+  minScore: 0.6
+});
+
+// 2) Deep: 벡터 검색 + 키워드 오버랩 재정렬
+const deep = await memory.retrieveMemories('브리핑 포맷', {
+  strategy: 'deep',
+  topK: 10,
+  rerankWithKeyword: true
+});
+
+// 3) Scoped filter: 세션/타입/계층형 메타데이터로 범위 제한
+const scoped = await memory.retrieveMemories('아침 브리핑', {
+  strategy: 'deep',
+  scope: {
+    sessionIdPrefix: 'agent:main:',
+    eventTypes: ['user_prompt', 'agent_response'],
+    canonicalKeyPrefix: 'pref/briefing',
+    contentIncludes: ['아침'],
+    metadata: {
+      'scope.project.id': 'alpha'
+    }
+  }
+});
+```
+
+팁:
+- `strategy: 'auto'`는 기본적으로 `deep` 경로를 사용합니다.
+- 저지연 응답이 중요하면 `fast`, 정확도 우선이면 `deep`를 권장합니다.
+
+## Privacy 기능
+
+### Private Tags
+
+민감한 정보를 메모리에서 제외하려면 `<private>` 태그를 사용합니다:
+
+```markdown
+이 부분은 저장됩니다.
+
+<private>
+API_KEY=sk-xxxx
+SECRET_TOKEN=abc123
+이 내용은 메모리에 저장되지 않습니다.
+</private>
+
+이 부분도 저장됩니다.
+```
+
+저장 결과:
+```
+이 부분은 저장됩니다.
+[PRIVATE]
+이 부분도 저장됩니다.
+```
+
+### 자동 필터링
+
+다음 패턴은 자동으로 마스킹됩니다:
+- `password`, `api_key`, `secret`, `token`
+- Bearer 토큰
+- Private Key 블록
+
+## Citations (인용 시스템)
+
+검색 결과에는 인용 ID가 포함됩니다:
+
+```
+🔍 Search Results:
+
+#1 [mem:a7Bc3x] (score: 0.94)
+   "DuckDB를 사용하여 이벤트 소싱 패턴을..."
+   📅 2026-01-30 | 🔗 Session abc123
+```
+
+원본 확인:
+```bash
+claude-memory-layer show mem:a7Bc3x
+```
+
+## Endless Mode
+
+세션 경계 없이 연속적인 메모리 스트림을 유지합니다:
+
+```bash
+# Endless Mode 활성화
+claude-memory-layer config set mode endless
+
+# 상태 확인
+claude-memory-layer status
+
+# 출력 예시:
+# Mode: Endless
+# Working Set: 47 events (last 18 hours)
+# Continuity Score: 0.85 (seamless)
+# Consolidated: 23 memories
+```
+
+### 모드 비교
+
+| 기존 세션 모드 | Endless Mode |
+|---------------|-------------|
+| 명확한 시작/끝 | 연속적 스트림 |
+| 세션별 요약 | 점진적 통합 |
+| 재시작 시 빈 상태 | 이전 컨텍스트 유지 |
+
+## MCP Desktop Integration
+
+Claude Desktop에서 메모리 검색을 사용하려면:
+
+```bash
+# MCP 서버 설치
+claude-memory-layer mcp install
+
+# 또는 수동 설정: ~/Library/Application Support/Claude/claude_desktop_config.json
+{
+  "mcpServers": {
+    "claude-memory-layer": {
+      "command": "npx",
+      "args": ["claude-memory-layer-mcp"]
+    }
+  }
+}
+```
+
+### 제공되는 MCP 도구
+
+| 도구 | 설명 |
+|------|------|
+| `mem-search` | 메모리 검색 |
+| `mem-timeline` | 타임라인 조회 |
+| `mem-details` | 상세 정보 조회 |
+| `mem-stats` | 통계 조회 |
+
+## Web Viewer
+
+브라우저에서 메모리 대시보드를 확인할 수 있습니다:
+
+```bash
+# 웹 서버 시작
+claude-memory-layer dashboard
+
+# 브라우저에서 접속
+# http://localhost:37777
+```
+
+### 주요 기능
+- 실시간 이벤트 스트림
+- 세션/프로젝트별 탐색
+- 벡터 검색 인터페이스
+- 저장소 통계 대시보드
+- Outbox 상태 모니터링
+
+## 기존 대화 기록 임포트
+
+이미 Claude Code를 사용해왔다면, 기존 대화 기록을 임포트하여 바로 활용할 수 있습니다:
+
+```bash
+# 1. 먼저 임포트 가능한 세션 확인
+npx claude-memory-layer list
+
+# 2. 현재 프로젝트의 모든 세션 임포트
+npx claude-memory-layer import
+
+# 3. 또는 모든 프로젝트의 세션 임포트
+npx claude-memory-layer import --all --verbose
+```
+
+### 임포트 결과 예시
+
+```
+📥 Importing all sessions from all projects
+
+⏳ Processing embeddings...
+
+✅ Import Complete
+
+Sessions processed: 15
+Total messages: 342
+Imported prompts: 156
+Imported responses: 186
+Skipped duplicates: 0
+Embeddings processed: 342
+```
+
+### 중복 처리
+
+임포트는 콘텐츠 해시 기반으로 중복을 자동 감지합니다. 여러 번 실행해도 같은 내용이 중복 저장되지 않습니다.
+
+## 동작 원리
+
+### 1. 메모리 저장
+
+```
+사용자 프롬프트 입력
+        ↓
+    EventStore에 저장 (DuckDB, append-only)
+        ↓
+    Outbox에 임베딩 요청 등록
+        ↓
+    Vector Worker가 임베딩 생성
+        ↓
+    VectorStore에 저장 (LanceDB)
+```
+
+### 2. 메모리 검색
+
+```
+새 프롬프트 입력
+        ↓
+    임베딩 생성
+        ↓
+    VectorStore에서 유사 벡터 검색
+        ↓
+    AXIOMMIND Matcher로 신뢰도 계산
+        ↓
+    컨텍스트로 Claude에 제공
+```
+
+### 3. 메모리 승격 (Graduation)
+
+자주 참조되는 메모리는 더 높은 레벨로 승격됩니다:
+
+| Level | 이름 | 설명 | 승격 조건 |
+|-------|------|------|-----------|
+| L0 | EventStore | 원본 이벤트 | 기본 저장 |
+| L1 | Structured | 구조화된 패턴 | 3회 이상 접근 |
+| L2 | Candidates | 검증된 스키마 | 5회 이상, 다중 세션 참조 |
+| L3 | Verified | 교차 검증됨 | 높은 신뢰도 |
+| L4 | Active | 활성 지식 | 10회 이상, 3개 이상 세션 |
+
+## 매칭 신뢰도
+
+검색 결과는 신뢰도에 따라 분류됩니다:
+
+| 신뢰도 | 점수 | Gap | 동작 |
+|--------|------|-----|------|
+| **High** | ≥0.92 | ≥0.03 | 자동으로 컨텍스트에 포함 |
+| **Suggested** | ≥0.75 | <0.03 | 대안 제시 |
+| **None** | <0.75 | - | 매칭 없음 |
+
+## Architecture
+
+### System Overview
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                     Claude Code Hooks                       │
+│  SessionStart │ UserPromptSubmit │ Stop │ PostToolUse │ End │
+└──────────────────────────┬──────────────────────────────────┘
+                           │
+                           ▼
+┌─────────────────────────────────────────────────────────────┐
+│                    Memory Service                           │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
+│  │  Retriever  │  │   Matcher   │  │  Graduation │         │
+│  │  Progressive│  │   Evidence  │  │   L0 → L4   │         │
+│  └─────────────┘  └─────────────┘  └─────────────┘         │
+└──────────────────────────┬──────────────────────────────────┘
+                           │
+        ┌──────────────────┴──────────────────┐
+        ▼                                      ▼
+┌───────────────┐                    ┌───────────────┐
+│  EventStore   │ ──── Outbox ────▶ │  VectorStore  │
+│   (DuckDB)    │    (V2 Pattern)   │   (LanceDB)   │
+└───────────────┘                    └───────────────┘
+```
+
+### Entity-Edge Model (3-Layer)
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                        edges                                 │
+│  ┌──────────┐    evidence_of    ┌──────────┐               │
+│  │  Entry   │ ─────────────────▶│  Entity  │               │
+│  │ (Fact,   │                   │ (Task,   │               │
+│  │ Decision)│                   │ Artifact)│               │
+│  └──────────┘                   └──────────┘               │
+│       │                              │                       │
+│       │ derived_from                 │ blocked_by           │
+│       ▼                              ▼                       │
+│  ┌──────────┐                   ┌──────────┐               │
+│  │  Entry   │                   │  Entity  │               │
+│  └──────────┘                   └──────────┘               │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Progressive Disclosure (토큰 효율화)
+
+```
+Layer 1: Search Index (~50-100 tokens/result)
+    │     { id, summary, score }
+    │
+    └──▶ Layer 2: Timeline Context (~200 tokens)
+              │     시간순 전후 맥락
+              │
+              └──▶ Layer 3: Full Details (~500-1000 tokens)
+                        선택된 항목만 전체 로드
+```
+
+### MCP Integration
+
+```
+┌─────────────────────┐         ┌─────────────────────┐
+│   Claude Desktop    │◀────────│ claude-memory-layer │
+│   (MCP Client)      │  stdio  │    (MCP Server)     │
+└─────────────────────┘         └──────────┬──────────┘
+                                           │
+                                           ▼
+                                ┌─────────────────────┐
+                                │   Shared Storage    │
+                                │  ~/.claude-code/    │
+                                └─────────────────────┘
+```
+
+## AXIOMMIND 7 원칙
+
+1. **Single Source of Truth**: DuckDB EventStore가 유일한 진실의 원천
+2. **Append-Only**: 이벤트는 수정/삭제 없이 추가만
+3. **Idempotency**: dedupe_key로 중복 이벤트 감지
+4. **Evidence Alignment**: 주장이 실제 소스에 기반했는지 검증
+5. **Entity-Based Tasks**: canonical_key로 일관된 엔티티 식별
+6. **Vector Store Consistency**: DuckDB → LanceDB 단방향 흐름
+7. **Standard JSON**: 모든 데이터는 이식 가능한 JSON 형식
+
+## 저장 위치
+
+메모리는 기본적으로 다음 위치에 저장됩니다:
+
+```
+~/.claude-code/memory/
+├── events.duckdb     # 이벤트 저장소
+└── vectors/          # 벡터 임베딩
+```
+
+Claude Code 세션 기록 위치:
+
+```
+~/.claude/projects/<project-hash>/<session-id>.jsonl
+```
+
+## 개발
+
+```bash
+# 의존성 설치
+npm install
+
+# 빌드
+npm run build
+
+# 테스트
+npm test
+
+# 타입 체크
+npm run typecheck
+
+# 개발 모드 실행
+npm run dev
+```
+
+## 기술 스택
+
+- **DuckDB**: 이벤트 저장소 (append-only SQL)
+- **LanceDB**: 벡터 저장소 (고성능 벡터 검색)
+- **@xenova/transformers**: 로컬 임베딩 생성
+- **Zod**: 런타임 타입 검증
+- **Commander**: CLI 인터페이스
+- **TypeScript**: 타입 안전한 코드
+- **Bun**: HTTP 서버 (Web Viewer)
+- **Hono**: 경량 라우터
+- **MCP SDK**: Claude Desktop 통합
+
+## Specification Documents
+
+상세 설계 문서는 `specs/` 디렉토리에서 확인할 수 있습니다:
+
+| 문서 | 설명 |
+|------|------|
+| [citations-system](specs/citations-system/spec.md) | 메모리 인용 시스템 |
+| [endless-mode](specs/endless-mode/spec.md) | 연속 세션 모드 |
+| [entity-edge-model](specs/entity-edge-model/spec.md) | 3-Layer 데이터 모델 |
+| [evidence-aligner-v2](specs/evidence-aligner-v2/spec.md) | 증거 정렬 시스템 |
+| [mcp-desktop-integration](specs/mcp-desktop-integration/spec.md) | MCP 서버 통합 |
+| [post-tool-use-hook](specs/post-tool-use-hook/spec.md) | 도구 사용 기록 |
+| [private-tags](specs/private-tags/spec.md) | 프라이버시 태그 |
+| [progressive-disclosure](specs/progressive-disclosure/spec.md) | 토큰 효율화 검색 |
+| [task-entity-system](specs/task-entity-system/spec.md) | Task Entity 관리 |
+| [vector-outbox-v2](specs/vector-outbox-v2/spec.md) | Transactional Outbox |
+| [web-viewer-ui](specs/web-viewer-ui/spec.md) | 웹 대시보드 |
+
+## Roadmap
+
+### Phase 1: Core (완료)
+- [x] Event Store (DuckDB)
+- [x] Vector Store (LanceDB)
+- [x] Memory Graduation (L0→L4)
+- [x] Evidence Alignment
+- [x] History Import
+
+### Phase 2: Advanced Features (진행 중)
+- [ ] Citations System
+- [ ] Endless Mode
+- [ ] Entity-Edge Model
+- [ ] Evidence Aligner V2
+- [ ] Private Tags
+
+### Phase 3: Integration
+- [ ] MCP Desktop Integration
+- [ ] Web Viewer UI
+- [ ] PostToolUse Hook
+- [ ] Progressive Disclosure
+
+### Phase 4: Optimization
+- [ ] Vector Outbox V2
+- [ ] Task Entity System
+- [ ] Performance Tuning
+
+## License
+
+MIT
+
+## 2026-02-25T12:31:21.752Z | 4b1b77d6-27a5-4d41-8a7b-f4d6890d71ae
+- type: session_summary
+- session: import:organized
+# Context: Claude Code Memory Plugin
+
+## 1. 프로젝트 배경
+
+이 문서는 Claude Code용 Memory Plugin 개발을 위한 배경 연구와 참조 자료를 정리합니다.
+
+### 1.1 목표
+
+사용자가 Claude Code를 사용할수록 더 똑똑해지는 Agent를 만들기 위한 플러그인 개발:
+- 사용자 prompt와 agent 응답을 지속적으로 기억
+- 새로운 prompt 입력 시 관련된 과거 기억을 검색하여 컨텍스트로 활용
+- 시간이 지남에 따라 개인화된 경험 제공
+
+---
+
+## 2. Claude Code Plugin System 분석
+
+### 2.1 플러그인 구조
+
+```
+plugin-name/
+├── .claude-plugin/
+│   └── plugin.json          # 플러그인 메타데이터 (필수)
+├── commands/                # 슬래시 명령어 (선택)
+├── agents/                  # 전문화된 에이전트 (선택)
+├── skills/                  # 에이전트 스킬 (선택)
+├── hooks/                   # 이벤트 핸들러 (선택)
+├── .mcp.json               # MCP 서버 구성 (선택)
+└── README.md               # 문서
+```
+
+### 2.2 사용 가능한 Hook 이벤트
+
+| Hook Event | 용도 | Memory Plugin 활용 |
+|------------|------|-------------------|
+| `SessionStart` | 세션 시작 시 실행 | 이전 세션 기억 로드 |
+| `SessionEnd` | 세션 종료 시 실행 | 현재 세션 기억 저장 |
+| `UserPromptSubmit` | 사용자 입력 시 실행 | 관련 기억 검색 및 주입 |
+| `PreToolUse` | 도구 실행 전 | 도구별 과거 사용 패턴 제공 |
+| `PostToolUse` | 도구 실행 후 | 도구 결과 기억 |
+| `Stop` | Agent 응답 완료 시 | 전체 대화 기억 저장 |
+| `PreCompact` | 컨텍스트 압축 전 | 중요 기억 보존 |
+
+### 2.3 Hook Input/Output 형식
+
+```json
+// UserPromptSubmit hook input
+{
+  "session_id": "...",
+  "prompt": "사용자가 입력한 텍스트",
+  "timestamp": "..."
+}
+
+// Hook은 stdout으로 결과 반환
+// - 빈 출력: 변경 없음
+// - JSON 출력: 컨텍스트 주입 또는 수정
+```
+
+---
+
+## 3. AI Memory System 연구
+
+### 3.1 Memory의 종류
+
+| 유형 | 설명 | 지속성 |
+|------|------|--------|
+| **Short-term Memory** | 현재 대화 컨텍스트 | 세션 내 |
+| **Long-term Memory** | 사용자 선호도, 과거 인사이트 | 영구적 |
+| **Episodic Memory** | 구체적인 대화/이벤트 기억 | 영구적 |
+| **Semantic Memory** | 추출된 지식과 관계 | 영구적 |
+
+### 3.2 주요 Memory 솔루션 비교
+
+| 솔루션 | 특징 | 장점 |
+|--------|------|------|
+| **Mem0** | Y Combinator 투자, 그래프 기반 | 복잡한 관계 표현 |
+| **LangChain Memory** | 프레임워크 내장 | 쉬운 통합 |
+| **Zep/Graphiti** | 시간적 지식 그래프 | 시계열 추적 |
+| **AWS AgentCore Memory** | 비동기 파이프라인 | 확장성 |
+| **Google Vertex Memory Bank** | 유사도 검색 | 엔터프라이즈 |
+
+### 3.3 Memory vs RAG
+
+- **RAG**: 외부 문서에서 정보 검색 (stateless)
+- **Memory**: 과거 상호작용에서 컨텍스트 검색 (stateful)
+- **이 플러그인**: Memory 중심 + 선택적 RAG 통합
+
+---
+
+## 4. AXIOMMIND Memory System 참조
+
+Gist에서 제공된 AXIOMMIND 시스템의 핵심 개념:
+
+### 4.1 아키텍처 레이어
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  L0 EventStore (Single Source of Truth)                 │
+│  - Append-only events table                             │
+│  - Event deduplication via dedupe_key                   │
+│  - Projection offset tracking                           │
+└─────────────────────────────────────────────────────────┘
+                         ↓
+┌─────────────────────────────────────────────────────────┐
+│  Extraction/Sorting Layer (LLM Processing)              │
+│  - LLM extracts structured JSON from raw input          │
+│  - Evidence alignment and validation                    │
+└─────────────────────────────────────────────────────────┘
+                         ↓
+┌─────────────────────────────────────────────────────────┐
+│  Derived Stores (Rebuildable from Events)               │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐    │
+│  │   DuckDB    │  │   LanceDB   │  │  Relational │    │
+│  │  (FTS/SQL)  │  │  (Vectors)  │  │   Views     │    │
+│  └─────────────┘  └─────────────┘  └─────────────┘    │
+└─────────────────────────────────────────────────────────┘
+```
+
+### 4.2 핵심 원칙
+
+- **Append-only EventStore**: 모든 변경 추적, 파생 저장소에서 언제든 재구성 가능
+- **Canonical Key 정규화**: 동일 개념의 여러 표현을 단일 키로 통합
+- **단일 진실 공급원(SoT)**: events 테이블만 영구 저장, 나머지는 파생
+- **멱등성 보장**: `dedupe_key`로 중복 이벤트 차단
+
+### 4.3 Canonical Key 정규화 (핵심 알고리즘)
+
+```python
+# canonical_key.py - 결정론적 키 생성
+def make_canonical_key(title: str, project: str = None) -> str:
+    """
+    동일한 제목은 항상 동일한 키를 생성
+
+    정규화 단계:
+    1. NFKC 유니코드 정규화
+    2. 소문자 변환
+    3. 구두점 제거
+    4. 연속 공백 정리
+    5. (선택) 프로젝트/도메인 컨텍스트 추가
+    6. 긴 키는 MD5 체크섬으로 truncate
+    """
+    import unicodedata
+    import re
+    import hashlib
+
+    # Step 1-4: 정규화
+    normalized = unicodedata.normalize('NFKC', title)
+    normalized = normalized.lower()
+    normalized = re.sub(r'[^\w\s]', '', normalized)
+    normalized = re.sub(r'\s+', ' ', normalized).strip()
+
+    # Step 5: 컨텍스트 추가
+    if project:
+        key = f"{project}::{normalized}"
+    else:
+        key = normalized
+
+    # Step 6: 긴 키 처리
+    MAX_KEY_LENGTH = 200
+    if len(key) > MAX_KEY_LENGTH:
+        hash_suffix = hashlib.md5(key.encode()).hexdigest()[:8]
+        key = key[:MAX_KEY_LENGTH - 9] + "_" + hash_suffix
+
+    return key
+```
+
+**Memory Plugin 적용**:
+- 사용자 prompt의 canonical key로 중복 질문 감지
+- 유사한 질문들을 그룹화하여 패턴 추출
+
+### 4.4 Matching Thresholds (엄격한 매칭 기준)
+
+```python
+# task_matcher.py - 매칭 임계값
+MATCH_THRESHOLDS = {
+    "min_combined_score": 0.92,   # 최소 결합 점수
+    "min_gap": 0.03,              # 1위와 2위 간 최소 점수 차이
+    "suggestion_threshold": 0.75, # 제안 모드 임계값
+}
+
+def calculate_weighted_score(result: SearchResult) -> float:
+    """
+    가중치 점수 계산 (stage, status, recency)
+    """
+    weights = {
+        "semantic_similarity": 0.4,  # 벡터 유사도
+        "fts_score": 0.25,           # 전문 검색 점수
+        "recency_bonus": 0.2,        # 최신성 가산점
+        "status_weight": 0.15,       # 상태별 가중치
+    }
+
+    score = (
+        result.vector_score * weights["semantic_similarity"] +
+        result.fts_score * weights["fts_score"] +
+        result.recency_score * weights["recency_bonus"] +
+        result.status_score * weights["status_weight"]
+    )
+    return score
+
+def match_with_confidence(query: str, candidates: list) -> MatchResult:
+    """
+    엄격한 매칭: top-1이 확실히 우세할 때만 확정
+    """
+    if len(candidates) == 0:
+        return MatchResult(match=None, confidence="none")
+
+    top = candidates[0]
+
+    if top.score < MATCH_THRESHOLDS["suggestion_threshold"]:
+        return MatchResult(match=None, confidence="none")
+
+    if top.score >= MATCH_THRESHOLDS["min_combined_score"]:
+        if len(candidates) == 1:
+            return MatchResult(match=top, confidence="high")
+
+        gap = top.score - candidates[1].score
+        if gap >= MATCH_THRESHOLDS["min_gap"]:
+            return MatchResult(match=top, confidence="high")
+
+    # 점수가 높지만 확실하지 않음 → 제안 모드
+    return MatchResult(match=top, confidence="suggested")
+```
+
+**Memory Plugin 적용**:
+- 관련 기억 검색 시 엄격한 임계값 적용
+- 애매한 매칭은 "suggested" 상태로 표시
+
+### 4.5 Single-Writer Pattern (벡터 동시성 제어)
+
+```python
+# vector_worker.py - Outbox 패턴으로 동시성 제어
+
+"""
+LanceDB는 동시 쓰기에 취약하므로 Single-Writer 패턴 사용:
+1. 이벤트 저장 시 embedding_outbox 테이블에 작업 추가
+2. 별도 워커가 outbox를 순차적으로 처리
+3. 처리 완료 시 outbox에서 삭제
+"""
+
+# DuckDB의 outbox 테이블
+CREATE TABLE embedding_outbox (
+    id              UUID PRIMARY KEY,
+    event_id        UUID NOT NULL,
+    content         TEXT NOT NULL,
+    status          VARCHAR DEFAULT 'pending',  -- 'pending' | 'processing' | 'done'
+    created_at      TIMESTAMP DEFAULT NOW(),
+    processed_at    TIMESTAMP
+);
+
+# Python 워커 (단일 프로세스)
+class VectorWorker:
+    def __init__(self, db: DuckDB, lance: LanceDB, embedder: Embedder):
+        self.db = db
+        self.lance = lance
+        self.embedder = embedder
+
+    async def process_outbox(self, batch_size: int = 32):
+        """
+        Outbox에서 pending 항목을 가져와 순차 처리
+        """
+        # 1. Pending 항목 가져오기 (락 획득)
+        pending = self.db.execute("""
+            UPDATE embedding_outbox
+            SET status = 'processing'
+            WHERE id IN (
+                SELECT id FROM embedding_outbox
+                WHERE status = 'pending'
+                ORDER BY created_at
+                LIMIT ?
+            )
+            RETURNING *
+        """, [batch_size])
+
+        if not pending:
+            return
+
+        # 2. 배치 임베딩 생성
+        contents = [p.content for p in pending]
+        vectors = await self.embedder.embed_batch(contents)
+
+        # 3. LanceDB에 저장 (단일 쓰기)
+        records = [
+            {"event_id": p.event_id, "content": p.content, "vector": v}
+            for p, v in zip(pending, vectors)
+        ]
+        self.lance.add(records)
+
+        # 4. Outbox 정리
+        ids = [p.id for p in pending]
+        self.db.execute("""
+            DELETE FROM embedding_outbox WHERE id = ANY(?)
+        """, [ids])
+```
+
+**Memory Plugin 적용**:
+- 대화 저장 시 즉시 반환, 임베딩은 비동기 처리
+- 동시성 문제 없이 안정적인 벡터 인덱싱
+
+### 4.6 Blocker/Condition 분류 전략
+
+```python
+# task_resolver.py - 애매한 참조 처리
+
+"""
+Blocker 분류 전략:
+1. Artifact: URL, Jira, GitHub 이슈 등 명확한 참조
+2. Task: 엄격한 매칭만 허용 (score >= 0.92)
+3. Condition: 애매한 참조 흡수 (나중에 해결 가능)
+"""
+
+class BlockerType(Enum):
+    ARTIFACT = "artifact"    # 명확한 외부 참조
+    TASK = "task"            # 확정된 작업 참조
+    CONDITION = "condition"  # 애매한 조건/참조
+
+def classify_blocker(reference: str, match_result: MatchResult) -> BlockerType:
+    # URL, 이슈 번호 등은 Artifact
+    if is_artifact_reference(reference):
+        return BlockerType.ARTIFACT
+
+    # 높은 신뢰도 매칭은 Task
+    if match_result.confidence == "high":
+        return BlockerType.TASK
+
+    # 나머지는 Condition으로 흡수
+    return BlockerType.CONDITION
+
+# Condition은 나중에 실제 Task로 해결될 수 있음
+# resolves_to edge로 연결
+```
+
+**Memory Plugin 적용**:
+- 불완전한 컨텍스트도 일단 저장
+- 나중에 추가 정보로 보강 가능
+
+### 4.7 Query Patterns (효과적인 뷰 활용)
+
+```sql
+-- v_task_blockers_effective: Condition 해결을 반영한 최종 blocker 뷰
+CREATE VIEW v_memory_context_effective AS
+SELECT
+    m.id,
+    m.session_id,
+    m.content,
+    m.event_type,
+    m.timestamp,
+    -- Condition이 해결된 경우 실제 참조로 대체
+    COALESCE(r.resolved_content, m.content) as effective_content,
+    COALESCE(r.resolved_id, m.id) as effective_id
+FROM memories m
+LEFT JOIN memory_resolutions r ON m.id = r.condition_id
+WHERE r.resolution_type IS NULL OR r.resolution_type = 'confirmed';
+
+-- 4가지 주요 쿼리 패턴
+-- 1. 확정된 관련 기억
+SELECT * FROM v_memory_context_effective
+WHERE semantic_score >= 0.92;
+
+-- 2. 제안 상태의 기억 (확인 대기)
+SELECT * FROM memories
+WHERE match_confidence = 'suggested';
+
+-- 3. 자동 플레이스홀더 감지
+SELECT * FROM memories
+WHERE auto_placeholder = true;
+
+-- 4. 해결된 조건 매핑
+SELECT condition_id, resolved_to_id
+FROM memory_resolutions
+WHERE resolution_type = 'confirmed';
+```
+
+### 4.8 Placeholder 자동 생성
+
+```python
+# 정보가 불완전할 때 플레이스홀더 생성
+def create_placeholder_if_needed(event: MemoryEvent) -> Optional[Placeholder]:
+    """
+    컨텍스트가 불완전하면 자동 플레이스홀더 생성
+    - auto_placeholder=true 플래그 설정
+    - 나중에 추가 정보로 해결 가능
+    """
+    if is_incomplete_context(event):
+        return Placeholder(
+            id=generate_uuid(),
+            event_id=event.id,
+            placeholder_type="unknown_context",
+            auto_placeholder=True,
+            created_at=datetime.now()
+        )
+    return None
+```
+
+### 4.9 주요 모듈 요약
+
+| 모듈 | 역할 | Memory Plugin 대응 |
+|------|------|-------------------|
+| `canonical_key.py` | 결정론적 키 정규화 | `normalizer.ts` |
+| `event_store.py` | append-only 이벤트 저장 | `event-store.ts` |
+| `task_matcher.py` | 가중치 기반 매칭 | `matcher.ts` |
+| `task_resolver.py` | 상태 전이 검증 | `resolver.ts` |
+| `projector_task.py` | 이벤트→엔티티 투영 | `projector.ts` |
+| `vector_worker.py` | 단일 쓰기 임베딩 | `vector-worker.ts` |
+
+### 4.10 Memory Graduation Pipeline (L0 → L4)
+
+AXIOMMIND의 핵심 개념인 **다단계 메모리 승격 파이프라인**:
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    Memory Graduation Pipeline                    │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  L0: EventStore (Raw)                                           │
+│  ├── 원본 채팅 로그, 프롬프트/응답                                │
+│  ├── Append-only, 불변                                          │
+│  └── dedupe_key로 멱등성 보장                                    │
+│                         ↓                                        │
+│  L1: Structured JSON                                            │
+│  ├── LLM이 추출한 구조화된 데이터                                │
+│  ├── 엔티티, 관계, 인사이트                                      │
+│  └── EvidenceAligner로 증거 스팬 정렬                            │
+│                         ↓                                        │
+│  L2: Idris Candidates (검증 대상)                               │
+│  ├── 타입 안전한 표현으로 변환                                   │
+│  ├── 의존적 타입으로 불변식 검증                                 │
+│  └── idris_generator.py가 생성                                  │
+│                         ↓                                        │
+│  L3: Verified Knowledge                                         │
+│  ├── Idris 타입체커 통과                                        │
+│  ├── 모순 없음 확인                                              │
+│  └── 신뢰도 높은 지식                                            │
+│                         ↓                                        │
+│  L4: Active Memory (검색 가능)                                  │
+│  ├── 벡터 인덱싱 완료                                            │
+│  ├── 실시간 검색 가능                                            │
+│  └── 컨텍스트 주입에 사용                                        │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+**Memory Plugin 적용**:
+- L0: 모든 대화를 `events` 테이블에 저장
+- L1: 주기적으로 인사이트 추출 (LLM 기반)
+- L2: TypeScript 강타입으로 검증 (Idris2 개념 적용)
+- L3: 테스트 통과한 검증된 지식
+- L4: LanceDB에 인덱싱되어 검색 가능한 상태
+
+### 4.11 AXIOMMIND 7가지 필수 원칙
+
+| # | 원칙 | 설명 | Memory Plugin 적용 |
+|---|------|------|-------------------|
+| 1 | **진실의 원천(SoT)은 이벤트 로그** | 파생 테이블은 언제든 재구성 가능 | `events` 테이블만 영구 저장 |
+| 2 | **추가전용 구조** | events에 UPDATE/DELETE 금지 | `append()` 메서드만 제공 |
+| 3 | **멱등성 보장** | `dedupe_key`로 중복 제어 | content_hash + session_id |
+| 4 | **증거 범위는 파이프라인이 확정** | LLM은 인용문만, aligner가 스팬 계산 | `EvidenceAligner` 모듈 |
+| 5 | **Task는 엔티티** | 세션마다 새 항목 아닌 기존 업데이트 | `canonical_key`로 동일성 판단 |
+| 6 | **벡터 저장소 정합성** | DuckDB → outbox → LanceDB 단방향 | Single-Writer Pattern |
+| 7 | **DuckDB JSON 사용** | JSONB 제거, 표준 JSON만 | `metadata JSON` 컬럼 |
+
+```typescript
+// 원칙 적용 예시: EventStore 인터페이스
+interface EventStoreInterface {
+  // 원칙 2: 추가전용 - append만 허용
+  append(event: MemoryEvent): Promise<AppendResult>;
+
+  // 조회는 자유롭게
+  getBySession(sessionId: string): Promise<MemoryEvent[]>;
+  getRecent(limit: number): Promise<MemoryEvent[]>;
+
+  // 원칙 2 위반: UPDATE/DELETE 메서드 없음
+  // update(): ❌ 금지
+  // delete(): ❌ 금지
+}
+```
+
+### 4.12 Evidence Aligner (증거 정렬기)
+
+```python
+# evidence_aligner.py - LLM 인용문을 정확한 스팬으로 변환
+
+class EvidenceAligner:
+    """
+    원칙 4: LLM은 인용문만 제공, aligner가 정확한 스팬 계산
+
+    LLM이 추출한 대략적인 인용문을 원본 텍스트에서
+    정확한 (start, end) 위치로 변환
+    """
+
+    def align(
+        self,
+        source_text: str,
+        llm_quote: str,
+        fuzzy_threshold: float = 0.85
+    ) -> Optional[EvidenceSpan]:
+        """
+        1. 정확한 매칭 시도
+        2. 실패 시 fuzzy matching (Levenshtein)
+        3. 임계값 미달 시 None 반환
+        """
+        # 정확한 매칭
+        exact_pos = source_text.find(llm_quote)
+        if exact_pos >= 0:
+            return EvidenceSpan(
+                start=exact_pos,
+                end=exact_pos + len(llm_quote),
+                confidence=1.0,
+                match_type="exact"
+            )
+
+        # Fuzzy 매칭
+        best_match = self._fuzzy_search(source_text, llm_quote)
+        if best_match and best_match.score >= fuzzy_threshold:
+            return EvidenceSpan(
+                start=best_match.start,
+                end=best_match.end,
+                confidence=best_match.score,
+                match_type="fuzzy"
+            )
+
+        return None
+
+    def _fuzzy_search(self, text: str, query: str) -> Optional[FuzzyMatch]:
+        # 슬라이딩 윈도우 + Levenshtein 거리
+        ...
+```
+
+**Memory Plugin 적용**:
+- 사용자가 "이전에 rate limiting 얘기했잖아"라고 하면
+- LLM이 대략적인 인용문 추출
+- EvidenceAligner가 정확한 원본 위치 찾기
+- 해당 컨텍스트를 정확히 주입
+
+### 5.1 Vector Database: LanceDB
+
+선택 이유:
+- **Embedded 모드**: SQLite처럼 서버 없이 로컬 실행
+- **Apache Arrow 기반**: 빠른 디스크 접근
+- **다중 모달 지원**: 텍스트, 이미지, 오디오 임베딩
+- **DuckDB 호환**: SQL 쿼리 가능
+
+```python
+import lancedb
+
+db = lancedb.connect("~/.claude-memory")
+table = db.create_table("conversations", data)
+results = table.search(query_embedding).limit(10).to_list()
+```
+
+### 5.2 관계형 저장소: DuckDB
+
+선택 이유:
+- **임베디드**: 파일 기반, 서버 불필요
+- **분석 최적화**: OLAP 워크로드에 적합
+- **SQL 지원**: 친숙한 쿼리 언어
+- **Lance 포맷 호환**: LanceDB와 통합
+
+### 5.3 Embedding Model
+
+옵션:
+1. **OpenAI text-embedding-3-small**: 고품질, API 비용
+2. **sentence-transformers**: 로컬 실행, 무료
+3. **Ollama embeddings**: 로컬 LLM 활용
+
+권장: sentence-transformers (로컬 우선) + OpenAI fallback
+
+---
+
+## 6. Idris2 활용 고려사항
+
+### 6.1 Idris2 개요
+
+- **의존적 타입 시스템**: 타입 수준에서 프로그램 검증
+- **Type-Driven Development**: 타입이 프로그램 설계를 가이드
+- **Quantitative Type Theory (QTT)**: 선형 타입 지원
+
+### 6.2 적용 가능 영역
+
+1. **타입 안전한 이벤트 스키마**
+   ```idris
+   data MemoryEvent : Type where
+     UserPrompt : (sessionId : String) -> (content : String) -> MemoryEvent
+     AgentResponse : (sessionId : String) -> (content : String) -> MemoryEvent
+   ```
+
+2. **불변성 보장**
+   - Append-only EventStore의 불변성을 타입 수준에서 강제
+
+3. **정확성 증명**
+   - 중복 제거 로직의 정확성 검증
+   - 검색 알고리즘의 속성 증명
+
+### 6.3 실용적 접근
+
+Idris2를 직접 사용하기보다 **개념적 영감**으로 활용:
+- TypeScript의 강타입 시스템 적극 활용
+- Zod/io-ts로 런타임 타입 검증
+- 불변 데이터 구조 (Immutable.js 또는 순수 함수형 패턴)
+
+---
+
+## 7. 참조 링크
+
+### Claude Code Plugin 개발
+- [Create plugins - Claude Code Docs](https://code.claude.com/docs/en/plugins)
+- [Claude Code Plugins README](https://github.com/anthropics/claude-code/blob/main/plugins/README.md)
+- [Hook Development SKILL](https://github.com/anthropics/claude-code/blob/main/plugins/plugin-dev/skills/hook-development/SKILL.md)
+- [Claude Code Plugins Complete Guide](https://jangwook.net/en/blog/en/claude-code-plugins-complete-guide/)
+
+### AI Memory Systems
+- [Mem0: Building Production-Ready AI Agents](https://arxiv.org/pdf/2504.19413)
+- [AWS AgentCore Long-term Memory](https://aws.amazon.com/blogs/machine-learning/building-smarter-ai-agents-agentcore-long-term-memory-deep-dive/)
+- [Google Vertex AI Memory Bank](https://docs.cloud.google.com/agent-builder/agent-engine/memory-bank/overview)
+- [LangChain Conversational Memory](https://www.pinecone.io/learn/series/langchain/langchain-conversational-memory/)
+
+### Vector Databases
+- [LanceDB](https://lancedb.com/)
+- [Lance Format on GitHub](https://github.com/lance-format/lance)
+
+### Idris2
+- [Idris2 Official Site](https://www.idris-lang.org/)
+- [Idris 2: Quantitative Type Theory in Practice](https://arxiv.org/abs/2104.00480)
+- [Idris2 GitHub](https://github.com/idris-lang/Idris2)
+
+---
+
+## 8. 용어 정의
+
+| 용어 | 정의 |
+|------|------|
+| **Memory** | 과거 대화에서 추출/저장된 정보 |
+| **Embedding** | 텍스트를 벡터로 변환한 표현 |
+| **Semantic Search** | 의미 기반 유사도 검색 |
+| **EventStore** | 모든 이벤트를 시간순으로 저장하는 append-only 저장소 |
+| **Hook** | 특정 이벤트 발생 시 실행되는 스크립트 |
+| **MCP** | Model Context Protocol - Claude와 외부 도구 연결 |
+
+## 2026-02-25T12:31:21.755Z | 235651b6-564e-4b06-8fa5-48a5e946455a
+- type: session_summary
+- session: import:organized
+# memU Adoption Notes (claude-memory-layer)
+
+이 프로젝트에 적용된 memU 장점 요약입니다.
+
+## 1) Dual Retrieval Strategy
+- `strategy: "fast" | "deep" | "auto"`
+- `fast`: 키워드 기반(FTS/keyword) 우선 탐색으로 저지연 검색
+- `deep`: 임베딩 + 벡터 검색 + 재정렬(키워드 오버랩 가중)로 정밀 검색
+
+## 2) Scoped Retrieval Filters
+`scope`로 검색 범위를 좁혀 정확도를 높입니다.
+
+- `sessionId` / `sessionIdPrefix`
+- `eventTypes`
+- `canonicalKeyPrefix`
+- `contentIncludes` (부분 문자열 OR)
+- `metadata` (dot-path, 예: `scope.project.id`)
+
+## 3) Hybrid Rerank Behavior
+`rerankWithKeyword=true`일 때 semantic score에 키워드 오버랩/최근성 점수를 가중해 재정렬합니다.
+
+## 4) Test Coverage
+- `tests/retriever.memu-adoption.test.ts`
+  - metadata dot-path 스코프 필터
+  - fast 전략 키워드 경로
+- `tests/retriever-strategy-scope.test.ts`
+  - fast/deep 전략 및 복합 스코프 필터
+
+## Quick Example
+```ts
+await retriever.retrieve('브리핑', {
+  strategy: 'deep',
+  topK: 10,
+  scope: {
+    sessionIdPrefix: 'agent:main:',
+    canonicalKeyPrefix: 'pref/briefing',
+    metadata: { 'scope.project.id': 'alpha' }
+  }
+});
+```
+
+## 2026-02-25T12:31:21.756Z | 50c73261-3d2b-490d-ad69-3a4c68cff7c9
+- type: session_summary
+- session: import:organized
+# Operations Runbook
+
+## Health scripts
+
+- `npm run ops:sync-gap:report`
+- `npm run ops:sync-gap:fix`
+- `npm run ops:sync-gap:heal`
+- `npm run ops:review:resolve`
+- `npm run ops:heartbeat`
+
+## Status policy
+
+- `ok`: no failed outbox items and no un-leveled events after heal
+- `needs-attention`: failed outbox remains or level sync still broken
+
+## Notes
+
+These scripts are best-effort operational automation for Claude memory DB (`~/.claude-code/memory/events.sqlite`).
+
+## 2026-02-25T12:31:26.190Z | 6813c625-f6f1-44bf-8758-088cf3ba1434
+- type: session_summary
+- session: import:organized
+# Implementation Plan: Claude Code Memory Plugin
+
+## 1. 개발 단계 개요
+
+AXIOMMIND 파이프라인 구현 단계에 맞춰 구성:
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  P0: 필수 품질 (Must Have)                                      │
+│  ├── EventStore (append-only, dedupe)                          │
+│  ├── EvidenceAligner (증거 스팬 정렬)                           │
+│  ├── Task Entity System (canonical_key)                        │
+│  ├── Vector Outbox (single-writer)                             │
+│  ├── Basic Hooks (SessionStart, Stop)                          │
+│  └── CLI 기본 명령어                                            │
+├─────────────────────────────────────────────────────────────────┤
+│  P1: 운영 (Operations)                                          │
+│  ├── build_runs 테이블 (파이프라인 실행 추적)                    │
+│  ├── conflict_ledger (충돌 기록)                                │
+│  ├── decision_ledger (의사결정 기록)                            │
+│  ├── 메트릭 스켈레톤                                            │
+│  └── 에러 복구 메커니즘                                          │
+├─────────────────────────────────────────────────────────────────┤
+│  P2: 검색 (Retrieval)                                           │
+│  ├── 하이브리드 검색 (Vector + FTS)                             │
+│  ├── 골드셋 평가 시스템                                          │
+│  ├── 인사이트 추출 (LLM 기반)                                   │
+│  └── L2→L3→L4 승격 파이프라인                                   │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### 구현 Phase 매핑
+
+| AXIOMMIND | 플러그인 Phase | 핵심 산출물 |
+|-----------|---------------|-------------|
+| **P0** | Phase 0-1 | EventStore, VectorWorker, 기본 Hook |
+| **P0** | Phase 2-3 | Embedder, Retriever, Hook 통합 |
+| **P1** | Phase 4 | CLI, 운영 도구, 메트릭 |
+| **P2** | Phase 5 | 하이브리드 검색, 평가, 최적화 |
+
+```
+Phase 0: 프로젝트 설정
+    ↓
+Phase 1: Core Storage Layer (P0 - EventStore, Outbox)
+    ↓
+Phase 2: Embedding & Retrieval (P0 - Vector, Matcher)
+    ↓
+Phase 3: Hook Integration (P0 - 기본 동작)
+    ↓
+Phase 4: Commands & CLI (P1 - 운영)
+    ↓
+Phase 5: Testing & Polish (P2 - 검색 최적화)
+```
+
+---
+
+## Phase 0: 프로젝트 설정
+
+### 0.1 디렉토리 구조 생성
+
+```
+code-memory/
+├── .claude-plugin/
+│   └── plugin.json              # 플러그인 메타데이터
+├── commands/
+│   ├── search.md                # /code-memory:search
+│   ├── history.md               # /code-memory:history
+│   ├── insights.md              # /code-memory:insights
+│   ├── forget.md                # /code-memory:forget
+│   └── stats.md                 # /code-memory:stats
+├── hooks/
+│   └── hooks.json               # Hook 설정
+├── src/
+│   ├── cli/
+│   │   ├── index.ts             # CLI 엔트리포인트
+│   │   ├── commands/
+│   │   │   ├── session-start.ts
+│   │   │   ├── session-end.ts
+│   │   │   ├── search.ts
+│   │   │   ├── save.ts
+│   │   │   └── init.ts
+│   │   └── utils.ts
+│   ├── core/
+│   │   ├── canonical-key.ts     # 정규화된 키 생성 (AXIOMMIND)
+│   │   ├── event-store.ts       # DuckDB 이벤트 저장소
+│   │   ├── vector-store.ts      # LanceDB 벡터 저장소
+│   │   ├── vector-worker.ts     # Single-writer 패턴 워커 (AXIOMMIND)
+│   │   ├── embedder.ts          # 임베딩 생성
+│   │   ├── matcher.ts           # 가중치 기반 매칭 (AXIOMMIND)
+│   │   ├── evidence-aligner.ts  # 증거 스팬 정렬 (AXIOMMIND 원칙4)
+│   │   ├── retriever.ts         # 기억 검색
+│   │   ├── projector.ts         # 이벤트→엔티티 투영 (AXIOMMIND)
+│   │   ├── graduation.ts        # L0→L4 승격 파이프라인 (AXIOMMIND)
+│   │   └── types.ts             # 타입 정의
+│   ├── hooks/
+│   │   ├── session-start.ts
+│   │   ├── user-prompt-submit.ts
+│   │   ├── stop.ts
+│   │   └── session-end.ts
+│   └── index.ts
+├── tests/
+│   ├── event-store.test.ts
+│   ├── vector-store.test.ts
+│   ├── retriever.test.ts
+│   └── integration.test.ts
+├── scripts/
+│   └── build.ts
+├── package.json
+├── tsconfig.json
+├── vitest.config.ts
+├── README.md
+├── spec.md
+├── plan.md
+└── context.md
+```
+
+### 0.2 초기 설정 작업
+
+```bash
+# 1. package.json 생성
+npm init -y
+
+# 2. TypeScript 및 핵심 의존성 설치
+npm install -D typescript @types/node tsx esbuild vitest
+
+# 3. 런타임 의존성
+npm install zod commander duckdb lancedb
+
+# 4. 임베딩 (선택)
+npm install @xenova/transformers  # 또는 Python sentence-transformers
+```
+
+### 0.3 TypeScript 설정
+
+```json
+// tsconfig.json
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}
+```
+
+---
+
+## Phase 1: Core Storage Layer
+
+### 1.1 타입 정의 (src/core/types.ts)
+
+```typescript
+// Idris2 영감: 완전하고 불변한 타입 정의
+
+import { z } from 'zod';
+
+// 이벤트 타입 스키마
+export const EventTypeSchema = z.enum([
+  'user_prompt',
+  'agent_response',
+  'session_summary'
+]);
+export type EventType = z.infer<typeof EventTypeSchema>;
+
+// 메모리 이벤트 스키마
+export const MemoryEventSchema = z.object({
+  id: z.string().uuid(),
+  eventType: EventTypeSchema,
+  sessionId: z.string(),
+  timestamp: z.date(),
+  content: z.string(),
+  contentHash: z.string(),
+  metadata: z.record(z.unknown()).optional()
+});
+export type MemoryEvent = z.infer<typeof MemoryEventSchema>;
+
+// 세션 스키마
+export const SessionSchema = z.object({
+  id: z.string(),
+  startedAt: z.date(),
+  endedAt: z.date().optional(),
+  projectPath: z.string().optional(),
+  summary: z.string().optional(),
+  tags: z.array(z.string()).optional()
+});
+export type Session = z.infer<typeof SessionSchema>;
+
+// 검색 결과
+export const MemoryMatchSchema = z.object({
+  event: MemoryEventSchema,
+  score: z.number().min(0).max(1),
+  relevanceReason: z.string().optional()
+});
+export type MemoryMatch = z.infer<typeof MemoryMatchSchema>;
+
+// 설정 스키마
+export const ConfigSchema = z.object({
+  storage: z.object({
+    path: z.string().default('~/.claude-code/memory'),
+    maxSizeMB: z.number().default(500)
+  }),
+  embedding: z.object({
+    provider: z.enum(['local', 'openai']).default('local'),
+    model: z.string().default('all-MiniLM-L6-v2'),
+    batchSize: z.number().default(32)
+  }),
+  retrieval: z.object({
+    topK: z.number().default(5),
+    minScore: z.number().default(0.7),
+    maxTokens: z.number().default(2000)
+  })
+});
+export type Config = z.infer<typeof ConfigSchema>;
+
+// AXIOMMIND: Matching 결과 타입
+export const MatchConfidenceSchema = z.enum(['high', 'suggested', 'none']);
+export type MatchConfidence = z.infer<typeof MatchConfidenceSchema>;
+
+export const MatchResultSchema = z.object({
+  match: MemoryMatchSchema.nullable(),
+  confidence: MatchConfidenceSchema,
+  gap: z.number().optional(),
+  alternatives: z.array(MemoryMatchSchema).optional()
+});
+export type MatchResult = z.infer<typeof MatchResultSchema>;
+
+// AXIOMMIND: Matching Thresholds
+export const MATCH_THRESHOLDS = {
+  minCombinedScore: 0.92,
+  minGap: 0.03,
+  suggestionThreshold: 0.75
+} as const;
+```
+
+### 1.2 Canonical Key 구현 (src/core/canonical-key.ts) - AXIOMMIND
+
+```typescript
+/**
+ * AXIOMMIND canonical_key.py 포팅
+ * 동일한 제목은 항상 동일한 키를 생성하는 결정론적 정규화
+ */
+
+import { createHash } from 'crypto';
+
+const MAX_KEY_LENGTH = 200;
+
+/**
+ * 텍스트를 정규화된 canonical key로 변환
+ *
+ * 정규화 단계:
+ * 1. NFKC 유니코드 정규화
+ * 2. 소문자 변환
+ * 3. 구두점 제거
+ * 4. 연속 공백 정리
+ * 5. 컨텍스트 추가 (선택)
+ * 6. 긴 키 truncate + MD5
+ */
+export function makeCanonicalKey(
+  title: string,
+  context?: { project?: string; sessionId?: string }
+): string {
+  // Step 1: NFKC 정규화
+  let normalized = title.normalize('NFKC');
+
+  // Step 2: 소문자 변환
+  normalized = normalized.toLowerCase();
+
+  // Step 3: 구두점 제거 (유니코드 호환)
+  normalized = normalized.replace(/[^\p{L}\p{N}\s]/gu, '');
+
+  // Step 4: 연속 공백 정리
+  normalized = normalized.replace(/\s+/g, ' ').trim();
+
+  // Step 5: 컨텍스트 추가
+  let key = normalized;
+  if (context?.project) {
+    key = `${context.project}::${key}`;
+  }
+
+  // Step 6: 긴 키 처리
+  if (key.length > MAX_KEY_LENGTH) {
+    const hashSuffix = createHash('md5').update(key).digest('hex').slice(0, 8);
+    key = key.slice(0, MAX_KEY_LENGTH - 9) + '_' + hashSuffix;
+  }
+
+  return key;
+}
+
+/**
+ * 두 텍스트가 동일한 canonical key를 가지는지 확인
+ */
+export function isSameCanonicalKey(a: string, b: string): boolean {
+  return makeCanonicalKey(a) === makeCanonicalKey(b);
+}
+
+/**
+ * Dedupe key 생성 (content + session으로 유일성 보장)
+ */
+export function makeDedupeKey(content: string, sessionId: string): string {
+  const contentHash = createHash('sha256').update(content).digest('hex');
+  return `${sessionId}:${contentHash}`;
+}
+```
+
+### 1.3 Event Store 구현 (src/core/event-store.ts)
+
+```typescript
+// AXIOMMIND 스타일: append-only, 멱등성, 단일 진실 공급원
+
+import { Database } from 'duckdb';
+import { createHash } from 'crypto';
+import { MemoryEvent, EventType } from './types';
+
+export class EventStore {
+  private db: Database;
+
+  constructor(dbPath: string) {
+    this.db = new Database(dbPath);
+    this.initialize();
+  }
+
+  private initialize(): void {
+    // 이벤트 테이블 (불변, append-only)
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS events (
+        id VARCHAR PRIMARY KEY,
+        event_type VARCHAR NOT NULL,
+        session_id VARCHAR NOT NULL,
+        timestamp TIMESTAMP NOT NULL,
+        content TEXT NOT NULL,
+        metadata JSON,
+        content_hash VARCHAR UNIQUE
+      )
+    `);
+
+    // 중복 방지 테이블
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS event_dedup (
+        content_hash VARCHAR PRIMARY KEY,
+        event_id VARCHAR NOT NULL
+      )
+    `);
+
+    // 세션 테이블
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id VARCHAR PRIMARY KEY,
+        started_at TIMESTAMP NOT NULL,
+        ended_at TIMESTAMP,
+        project_path VARCHAR,
+        summary TEXT
+      )
+    `);
+  }
+
+  // 멱등성 보장 저장
+  async append(event: Omit<MemoryEvent, 'id' | 'contentHash'>): Promise<{
+    success: boolean;
+    eventId?: string;
+    isDuplicate?: boolean;
+  }> {
+    const contentHash = this.hashContent(event.content);
+
+    // 중복 확인
+    const existing = this.db.prepare(`
+      SELECT event_id FROM event_dedup WHERE content_hash = ?
+    `).get(contentHash);
+
+    if (existing) {
+      return { success: true, eventId: existing.event_id, isDuplicate: true };
+    }
+
+    const id = crypto.randomUUID();
+
+    this.db.run(`
+      INSERT INTO events (id, event_type, session_id, timestamp, content, metadata, content_hash)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `, [id, event.eventType, event.sessionId, event.timestamp, event.content,
+        JSON.stringify(event.metadata), contentHash]);
+
+    this.db.run(`
+      INSERT INTO event_dedup (content_hash, event_id) VALUES (?, ?)
+    `, [contentHash, id]);
+
+    return { success: true, eventId: id, isDuplicate: false };
+  }
+
+  private hashContent(content: string): string {
+    return createHash('sha256').update(content).digest('hex');
+  }
+
+  // 세션별 이벤트 조회
+  async getSessionEvents(sessionId: string): Promise<MemoryEvent[]> {
+    return this.db.prepare(`
+      SELECT * FROM events WHERE session_id = ? ORDER BY timestamp ASC
+    `).all(sessionId);
+  }
+
+  // 최근 이벤트 조회
+  async getRecentEvents(limit: number = 100): Promise<MemoryEvent[]> {
+    return this.db.prepare(`
+      SELECT * FROM events ORDER BY timestamp DESC LIMIT ?
+    `).all(limit);
+  }
+}
+```
+
+### 1.3 Vector Store 구현 (src/core/vector-store.ts)
+
+```typescript
+import * as lancedb from 'lancedb';
+
+export class VectorStore {
+  private db: lancedb.Connection;
+  private table: lancedb.Table | null = null;
+
+  constructor(private dbPath: string) {}
+
+  async initialize(): Promise<void> {
+    this.db = await lancedb.connect(this.dbPath);
+
+    // 테이블이 없으면 생성 (첫 데이터 삽입 시)
+    try {
+      this.table = await this.db.openTable('conversations');
+    } catch {
+      // 테이블이 없으면 나중에 생성
+      this.table = null;
+    }
+  }
+
+  async upsert(data: {
+    id: string;
+    eventId: string;
+    sessionId: string;
+    eventType: string;
+    content: string;
+    vector: number[];
+    timestamp: string;
+    metadata?: Record<string, unknown>;
+  }): Promise<void> {
+    if (!this.table) {
+      // 첫 데이터로 테이블 생성
+      this.table = await this.db.createTable('conversations', [data]);
+      return;
+    }
+
+    await this.table.add([data]);
+  }
+
+  async search(queryVector: number[], options: {
+    limit?: number;
+    minScore?: number;
+    filter?: string;
+  } = {}): Promise<Array<{
+    id: string;
+    eventId: string;
+    content: string;
+    score: number;
+  }>> {
+    if (!this.table) {
+      return [];
+    }
+
+    const { limit = 5, minScore = 0.7 } = options;
+
+    const results = await this.table
+      .search(queryVector)
+      .limit(limit)
+      .execute();
+
+    return results
+      .filter(r => r._distance <= (1 - minScore))  // distance to score
+      .map(r => ({
+        id: r.id,
+        eventId: r.eventId,
+        content: r.content,
+        score: 1 - r._distance
+      }));
+  }
+
+  async delete(eventId: string): Promise<void> {
+    if (!this.table) return;
+    await this.table.delete(`eventId = "${eventId}"`);
+  }
+}
+```
+
+### 1.4 Vector Worker 구현 (src/core/vector-worker.ts) - AXIOMMIND Single-Writer
+
+```typescript
+/**
+ * AXIOMMIND vector_worker.py 포팅
+ * Single-Writer 패턴으로 LanceDB 동시성 문제 해결
+ *
+ * 원리:
+ * 1. 이벤트 저장 시 embedding_outbox에 작업 추가 (빠름)
+ * 2. 별도 워커가 outbox를 순차적으로 처리 (단일 쓰기)
+ * 3. 처리 완료 시 outbox에서 삭제
+ */
+
+import { Database } from 'duckdb';
+import { VectorStore } from './vector-store';
+import { Embedder } from './embedder';
+
+interface OutboxItem {
+  id: string;
+  eventId: string;
+  content: string;
+  status: 'pending' | 'processing' | 'done' | 'failed';
+  retryCount: number;
+  createdAt: Date;
+}
+
+export class VectorWorker {
+  private isRunning = false;
+  private pollInterval = 1000; // 1초
+
+  constructor(
+    private db: Database,
+    private vectorStore: VectorStore,
+    private embedder: Embedder
+  ) {}
+
+  /**
+   * Outbox에 임베딩 작업 추가 (빠른 반환)
+   */
+  async enqueue(eventId: string, content: string): Promise<string> {
+    const id = crypto.randomUUID();
+
+    this.db.run(`
+      INSERT INTO embedding_outbox (id, event_id, content, status, retry_count, created_at)
+      VALUES (?, ?, ?, 'pending', 0, NOW())
+    `, [id, eventId, content]);
+
+    return id;
+  }
+
+  /**
+   * 워커 시작 (백그라운드에서 실행)
+   */
+  async start(): Promise<void> {
+    if (this.isRunning) return;
+    this.isRunning = true;
+
+    while (this.isRunning) {
+      await this.processOutbox();
+      await this.sleep(this.pollInterval);
+    }
+  }
+
+  /**
+   * 워커 중지
+   */
+  stop(): void {
+    this.isRunning = false;
+  }
+
+  /**
+   * Outbox 처리 (핵심 로직)
+   */
+  private async processOutbox(batchSize: number = 32): Promise<number> {
+    // 1. Pending 항목 가져오기 + 락 획득 (atomic update)
+    const pending = this.db.prepare(`
+      UPDATE embedding_outbox
+      SET status = 'processing'
+      WHERE id IN (
+        SELECT id FROM embedding_outbox
+        WHERE status = 'pending'
+        ORDER BY created_at
+        LIMIT ?
+      )
+      RETURNING *
+    `).all(batchSize) as OutboxItem[];
+
+    if (pending.length === 0) {
+      return 0;
+    }
+
+    try {
+      // 2. 배치 임베딩 생성
+      const contents = pending.map(p => p.content);
+      const vectors = await this.embedder.embedBatch(contents);
+
+      // 3. LanceDB에 저장 (단일 쓰기 - 동시성 안전)
+      for (let i = 0; i < pending.length; i++) {
+        const item = pending[i];
+        await this.vectorStore.upsert({
+          id: crypto.randomUUID(),
+          eventId: item.eventId,
+          sessionId: '', // 필요시 조회
+          eventType: '',
+          content: item.content.slice(0, 1000), // 미리보기용
+          vector: vectors[i],
+          timestamp: new Date().toISOString()
+        });
+      }
+
+      // 4. 성공한 항목 삭제
+      const ids = pending.map(p => `'${p.id}'`).join(',');
+      this.db.run(`DELETE FROM embedding_outbox WHERE id IN (${ids})`);
+
+      return pending.length;
+
+    } catch (error) {
+      // 5. 실패 시 retry_count 증가
+      const ids = pending.map(p => `'${p.id}'`).join(',');
+      this.db.run(`
+        UPDATE embedding_outbox
+        SET status = CASE WHEN retry_count >= 3 THEN 'failed' ELSE 'pending' END,
+            retry_count = retry_count + 1,
+            error_message = ?
+        WHERE id IN (${ids})
+      `, [String(error)]);
+
+      return 0;
+    }
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+```
+
+### 1.5 Matcher 구현 (src/core/matcher.ts) - AXIOMMIND Weighted Scoring
+
+```typescript
+/**
+ * AXIOMMIND task_matcher.py 포팅
+ * 가중치 기반 스코어링 + 엄격한 매칭 임계값
+ */
+
+import { MemoryMatch, MatchResult, MATCH_THRESHOLDS } from './types';
+
+interface ScoringWeights {
+  semanticSimilarity: number;
+  ftsScore: number;
+  recencyBonus: number;
+  statusWeight: number;
+}
+
+const DEFAULT_WEIGHTS: ScoringWeights = {
+  semanticSimilarity: 0.4,
+  ftsScore: 0.25,
+  recencyBonus: 0.2,
+  statusWeight: 0.15
+};
+
+interface RawSearchResult {
+  id: string;
+  eventId: string;
+  content: string;
+  vectorScore: number;      // 벡터 유사도 (0-1)
+  ftsScore?: number;        // 전문 검색 점수 (0-1)
+  timestamp: Date;
+  eventType: string;
+}
+
+/**
+ * 가중치 결합 점수 계산
+ */
+export function calculateWeightedScore(
+  result: RawSearchResult,
+  weights: ScoringWeights = DEFAULT_WEIGHTS
+): number {
+  // 최신성 가산점 (30일 이내 = 1.0, 이후 감소)
+  const daysSince = (Date.now() - result.timestamp.getTime()) / (1000 * 60 * 60 * 24);
+  const recencyScore = Math.max(0, 1 - daysSince / 30);
+
+  // 상태별 가중치 (agent_response > user_prompt)
+  const statusScore = result.eventType === 'agent_response' ? 1.0 : 0.8;
+
+  const score =
+    result.vectorScore * weights.semanticSimilarity +
+    (result.ftsScore ?? 0) * weights.ftsScore +
+    recencyScore * weights.recencyBonus +
+    statusScore * weights.statusWeight;
+
+  return Math.min(1, Math.max(0, score)); // 0-1 범위로 클램프
+}
+
+/**
+ * 엄격한 매칭: top-1이 확실히 우세할 때만 확정
+ *
+ * AXIOMMIND 규칙:
+ * - combined score >= 0.92 AND gap >= 0.03 → 'high' (확정)
+ * - 0.75 <= score < 0.92 → 'suggested' (제안)
+ * - score < 0.75 → 'none' (매칭 없음)
+ */
+export function matchWithConfidence(
+  candidates: MemoryMatch[]
+): MatchResult {
+  if (candidates.length === 0) {
+    return { match: null, confidence: 'none' };
+  }
+
+  // 점수순 정렬
+  const sorted = [...candidates].sort((a, b) => b.score - a.score);
+  const top = sorted[0];
+
+  // 임계값 미달
+  if (top.score < MATCH_THRESHOLDS.suggestionThreshold) {
+    return { match: null, confidence: 'none' };
+  }
+
+  // 확정 매칭 체크
+  if (top.score >= MATCH_THRESHOLDS.minCombinedScore) {
+    // 단일 후보
+    if (sorted.length === 1) {
+      return { match: top, confidence: 'high' };
+    }
+
+    // 2위와의 gap 체크
+    const gap = top.score - sorted[1].score;
+    if (gap >= MATCH_THRESHOLDS.minGap) {
+      return { match: top, confidence: 'high', gap };
+    }
+  }
+
+  // 제안 모드 (확실하지 않음)
+  return {
+    match: top,
+    confidence: 'suggested',
+    gap: sorted.length > 1 ? top.score - sorted[1].score : undefined,
+    alternatives: sorted.slice(1, 4) // 상위 3개 대안
+  };
+}
+
+/**
+ * 검색 결과를 MemoryMatch로 변환
+ */
+export function toMemoryMatch(
+  result: RawSearchResult,
+  weights?: ScoringWeights
+): MemoryMatch {
+  const score = calculateWeightedScore(result, weights);
+
+  return {
+    event: {
+      id: result.eventId,
+      eventType: result.eventType as any,
+      sessionId: '',
+      timestamp: result.timestamp,
+      content: result.content,
+      contentHash: ''
+    },
+    score,
+    relevanceReason: `Weighted score: ${(score * 100).toFixed(1)}% ` +
+      `(vector: ${(result.vectorScore * 100).toFixed(0)}%)`
+  };
+}
+```
+
+### 1.6 Evidence Aligner 구현 (src/core/evidence-aligner.ts) - AXIOMMIND 원칙4
+
+```typescript
+/**
+ * AXIOMMIND 원칙 4: 증거 범위는 파이프라인이 확정
+ *
+ * LLM이 추출한 대략적인 인용문을 원본 텍스트에서
+ * 정확한 (start, end) 위치로 변환
+ */
+
+interface EvidenceSpan {
+  start: number;
+  end: number;
+  confidence: number;
+  matchType: 'exact' | 'fuzzy' | 'none';
+  originalQuote: string;
+  alignedText: string;
+}
+
+interface FuzzyMatch {
+  start: number;
+  end: number;
+  score: number;
+  text: string;
+}
+
+export class EvidenceAligner {
+  private fuzzyThreshold: number;
+
+  constructor(fuzzyThreshold: number = 0.85) {
+    this.fuzzyThreshold = fuzzyThreshold;
+  }
+
+  /**
+   * LLM 인용문을 원본 텍스트에서 정확한 스팬으로 변환
+   */
+  align(sourceText: string, llmQuote: string): EvidenceSpan | null {
+    // 1. 정확한 매칭 시도
+    const exactPos = sourceText.indexOf(llmQuote);
+    if (exactPos >= 0) {
+      return {
+        start: exactPos,
+        end: exactPos + llmQuote.length,
+        confidence: 1.0,
+        matchType: 'exact',
+        originalQuote: llmQuote,
+        alignedText: llmQuote
+      };
+    }
+
+    // 2. 정규화 후 매칭 (공백, 대소문자 무시)
+    const normalizedMatch = this.normalizedSearch(sourceText, llmQuote);
+    if (normalizedMatch && normalizedMatch.score >= 0.95) {
+      return {
+        start: normalizedMatch.start,
+        end: normalizedMatch.end,
+        confidence: normalizedMatch.score,
+        matchType: 'exact',
+        originalQuote: llmQuote,
+        alignedText: normalizedMatch.text
+      };
+    }
+
+    // 3. Fuzzy 매칭 (Levenshtein 거리)
+    const fuzzyMatch = this.fuzzySearch(sourceText, llmQuote);
+    if (fuzzyMatch && fuzzyMatch.score >= this.fuzzyThreshold) {
+      return {
+        start: fuzzyMatch.start,
+        end: fuzzyMatch.end,
+        confidence: fuzzyMatch.score,
+        matchType: 'fuzzy',
+        originalQuote: llmQuote,
+        alignedText: fuzzyMatch.text
+      };
+    }
+
+    // 4. 매칭 실패
+    return null;
+  }
+
+  /**
+   * 정규화된 검색 (공백/대소문자 무시)
+   */
+  private normalizedSearch(text: string, query: string): FuzzyMatch | null {
+    const normalize = (s: string) => s.toLowerCase().replace(/\s+/g, ' ').trim();
+    const normalizedText = normalize(text);
+    const normalizedQuery = normalize(query);
+
+    const pos = normalizedText.indexOf(normalizedQuery);
+    if (pos < 0) return null;
+
+    // 원본 텍스트에서 실제 위치 찾기
+    let originalStart = 0;
+    let normalizedPos = 0;
+    for (let i = 0; i < text.length && normalizedPos < pos; i++) {
+      if (!/\s/.test(text[i]) || (i > 0 && !/\s/.test(text[i-1]))) {
+        normalizedPos++;
+      }
+      originalStart = i + 1;
+    }
+
+    return {
+      start: originalStart,
+      end: originalStart + query.length,
+      score: 0.98,
+      text: text.slice(originalStart, originalStart + query.length)
+    };
+  }
+
+  /**
+   * Fuzzy 검색 (슬라이딩 윈도우 + Levenshtein)
+   */
+  private fuzzySearch(text: string, query: string): FuzzyMatch | null {
+    const windowSize = Math.min(query.length * 1.5, text.length);
+    let bestMatch: FuzzyMatch | null = null;
+
+    for (let i = 0; i <= text.length - query.length; i++) {
+      const window = text.slice(i, i + Math.ceil(windowSize));
+      const score = this.similarity(window.slice(0, query.length), query);
+
+      if (!bestMatch || score > bestMatch.score) {
+        bestMatch = {
+          start: i,
+          end: i + query.length,
+          score,
+          text: window.slice(0, query.length)
+        };
+      }
+    }
+
+    return bestMatch;
+  }
+
+  /**
+   * Levenshtein 기반 유사도 (0-1)
+   */
+  private similarity(a: string, b: string): number {
+    const distance = this.levenshteinDistance(a.toLowerCase(), b.toLowerCase());
+    const maxLen = Math.max(a.length, b.length);
+    return maxLen === 0 ? 1 : 1 - distance / maxLen;
+  }
+
+  private levenshteinDistance(a: string, b: string): number {
+    const matrix: number[][] = [];
+    for (let i = 0; i <= b.length; i++) {
+      matrix[i] = [i];
+    }
+    for (let j = 0; j <= a.length; j++) {
+      matrix[0][j] = j;
+    }
+    for (let i = 1; i <= b.length; i++) {
+      for (let j = 1; j <= a.length; j++) {
+        const cost = a[j - 1] === b[i - 1] ? 0 : 1;
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j] + 1,
+          matrix[i][j - 1] + 1,
+          matrix[i - 1][j - 1] + cost
+        );
+      }
+    }
+    return matrix[b.length][a.length];
+  }
+}
+```
+
+### 1.7 Graduation Pipeline 구현 (src/core/graduation.ts) - AXIOMMIND L0→L4
+
+```typescript
+/**
+ * AXIOMMIND Memory Graduation Pipeline
+ * L0(Raw) → L1(Structured) → L2(Candidates) → L3(Verified) → L4(Active)
+ */
+
+import { EventStore } from './event-store';
+import { VectorStore } from './vector-store';
+import { VectorWorker } from './vector-worker';
+import { MemoryEvent } from './types';
+
+type MemoryLevel = 'L0' | 'L1' | 'L2' | 'L3' | 'L4';
+
+interface GraduationResult {
+  eventId: string;
+  fromLevel: MemoryLevel;
+  toLevel: MemoryLevel;
+  success: boolean;
+  reason?: string;
+}
+
+interface LevelStatus {
+  level: MemoryLevel;
+  count: number;
+  lastUpdated: Date | null;
+}
+
+export class GraduationPipeline {
+  constructor(
+    private eventStore: EventStore,
+    private vectorStore: VectorStore,
+    private vectorWorker: VectorWorker
+  ) {}
+
+  /**
+   * L0 → L1: 원본 이벤트에서 구조화된 데이터 추출
+   * (LLM 기반 추출은 별도 서비스에서 처리)
+   */
+  async promoteToL1(eventId: string): Promise<GraduationResult> {
+    // L1 승격은 LLM 추출 완료 후 마킹
+    // 여기서는 메타데이터만 업데이트
+    return {
+      eventId,
+      fromLevel: 'L0',
+      toLevel: 'L1',
+      success: true
+    };
+  }
+
+  /**
+   * L1 → L2: 타입 검증 대상으로 승격
+   * TypeScript 타입 체크 통과 여부 확인
+   */
+  async promoteToL2(eventId: string, structuredData: unknown): Promise<GraduationResult> {
+    try {
+      // Zod 스키마로 검증
+      // const validated = SomeSchema.parse(structuredData);
+
+      return {
+        eventId,
+        fromLevel: 'L1',
+        toLevel: 'L2',
+        success: true
+      };
+    } catch (error) {
+      return {
+        eventId,
+        fromLevel: 'L1',
+        toLevel: 'L2',
+        success: false,
+        reason: `Validation failed: ${error}`
+      };
+    }
+  }
+
+  /**
+   * L2 → L3: 검증 완료 (모순 없음 확인)
+   */
+  async promoteToL3(eventId: string): Promise<GraduationResult> {
+    // 기존 지식과의 모순 체크
+    // 중복 체크
+    // 신뢰도 계산
+
+    return {
+      eventId,
+      fromLevel: 'L2',
+      toLevel: 'L3',
+      success: true
+    };
+  }
+
+  /**
+   * L3 → L4: 검색 가능 상태로 승격 (벡터 인덱싱)
+   */
+  async promoteToL4(eventId: string, content: string): Promise<GraduationResult> {
+    try {
+      // VectorWorker의 outbox에 추가 (비동기 인덱싱)
+      await this.vectorWorker.enqueue(eventId, content);
+
+      return {
+        eventId,
+        fromLevel: 'L3',
+        toLevel: 'L4',
+        success: true
+      };
+    } catch (error) {
+      return {
+        eventId,
+        fromLevel: 'L3',
+        toLevel: 'L4',
+        success: false,
+        reason: `Indexing failed: ${error}`
+      };
+    }
+  }
+
+  /**
+   * 전체 파이프라인 실행 (L0 → L4)
+   */
+  async graduateFull(event: MemoryEvent): Promise<GraduationResult[]> {
+    const results: GraduationResult[] = [];
+
+    // L0 → L1 (구조화)
+    const l1Result = await this.promoteToL1(event.id);
+    results.push(l1Result);
+    if (!l1Result.success) return results;
+
+    // L1 → L2 (타입 검증)
+    const l2Result = await this.promoteToL2(event.id, event);
+    results.push(l2Result);
+    if (!l2Result.success) return results;
+
+    // L2 → L3 (모순 체크)
+    const l3Result = await this.promoteToL3(event.id);
+    results.push(l3Result);
+    if (!l3Result.success) return results;
+
+    // L3 → L4 (인덱싱)
+    const l4Result = await this.promoteToL4(event.id, event.content);
+    results.push(l4Result);
+
+    return results;
+  }
+
+  /**
+   * 각 레벨별 통계 조회
+   */
+  async getLevelStats(): Promise<LevelStatus[]> {
+    // 실제 구현에서는 DB 쿼리
+    return [
+      { level: 'L0', count: 0, lastUpdated: null },
+      { level: 'L1', count: 0, lastUpdated: null },
+      { level: 'L2', count: 0, lastUpdated: null },
+      { level: 'L3', count: 0, lastUpdated: null },
+      { level: 'L4', count: 0, lastUpdated: null }
+    ];
+  }
+}
+```
+
+---
+
+## Phase 2: Embedding & Retrieval
+
+### 2.1 Embedder 구현 (src/core/embedder.ts)
+
+```typescript
+import { pipeline, Pipeline } from '@xenova/transformers';
+
+export class Embedder {
+  private model: Pipeline | null = null;
+  private modelName: string;
+
+  constructor(modelName: string = 'Xenova/all-MiniLM-L6-v2') {
+    this.modelName = modelName;
+  }
+
+  async initialize(): Promise<void> {
+    this.model = await pipeline('feature-extraction', this.modelName);
+  }
+
+  async embed(text: string): Promise<number[]> {
+    if (!this.model) {
+      await this.initialize();
+    }
+
+    const result = await this.model!(text, {
+      pooling: 'mean',
+      normalize: true
+    });
+
+    return Array.from(result.data);
+  }
+
+  async embedBatch(texts: string[]): Promise<number[][]> {
+    return Promise.all(texts.map(t => this.embed(t)));
+  }
+}
+```
+
+### 2.2 Retriever 구현 (src/core/retriever.ts)
+
+```typescript
+import { Embedder } from './embedder';
+import { VectorStore } from './vector-store';
+import { EventStore } from './event-store';
+import { MemoryMatch, Config } from './types';
+
+export class Retriever {
+  constructor(
+    private embedder: Embedder,
+    private vectorStore: VectorStore,
+    private eventStore: EventStore,
+    private config: Config
+  ) {}
+
+  async search(query: string): Promise<MemoryMatch[]> {
+    // 1. 쿼리 임베딩
+    const queryVector = await this.embedder.embed(query);
+
+    // 2. 벡터 검색
+    const vectorResults = await this.vectorStore.search(queryVector, {
+      limit: this.config.retrieval.topK,
+      minScore: this.config.retrieval.minScore
+    });
+
+    // 3. 이벤트 정보 보강
+    const matches: MemoryMatch[] = [];
+
+    for (const result of vectorResults) {
+      // 원본 이벤트 조회
+      const events = await this.eventStore.getSessionEvents(result.eventId);
+      const event = events.find(e => e.id === result.eventId);
+
+      if (event) {
+        matches.push({
+          event,
+          score: result.score,
+          relevanceReason: `Semantic similarity: ${(result.score * 100).toFixed(1)}%`
+        });
+      }
+    }
+
+    return matches;
+  }
+
+  // 컨텍스트 포맷팅
+  formatContext(matches: MemoryMatch[]): string {
+    if (matches.length === 0) {
+      return '';
+    }
+
+    const lines = ['## Relevant Memories\n'];
+
+    for (const match of matches) {
+      const date = new Date(match.event.timestamp).toLocaleDateString();
+      lines.push(`### ${match.event.eventType} (${date})`);
+      lines.push(`> ${match.event.content.slice(0, 500)}...`);
+      lines.push(`_Relevance: ${(match.score * 100).toFixed(0)}%_\n`);
+    }
+
+    return lines.join('\n');
+  }
+}
+```
+
+---
+
+## Phase 3: Hook Integration
+
+### 3.1 hooks.json 설정
+
+```json
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "type": "command",
+        "command": "npx code-memory session-start",
+        "timeout": 5000
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "type": "command",
+        "command": "npx code-memory search --stdin",
+        "timeout": 3000
+      }
+    ],
+    "Stop": [
+      {
+        "type": "command",
+        "command": "npx code-memory save --stdin",
+        "timeout": 5000
+      }
+    ],
+    "SessionEnd": [
+      {
+        "type": "command",
+        "command": "npx code-memory session-end --stdin",
+        "timeout": 10000
+      }
+    ]
+  }
+}
+```
+
+### 3.2 UserPromptSubmit Hook (src/hooks/user-prompt-submit.ts)
+
+```typescript
+import { Retriever } from '../core/retriever';
+import { loadServices } from '../core/services';
+
+export async function handleUserPromptSubmit(input: {
+  session_id: string;
+  prompt: string;
+}): Promise<{ context?: string }> {
+  const { retriever } = await loadServices();
+
+  // 관련 기억 검색
+  const matches = await retriever.search(input.prompt);
+
+  if (matches.length === 0) {
+    return {};
+  }
+
+  // 컨텍스트 포맷팅
+  const context = retriever.formatContext(matches);
+
+  return { context };
+}
+
+// CLI 엔트리포인트
+if (process.stdin.isTTY === false) {
+  let data = '';
+  process.stdin.on('data', chunk => data += chunk);
+  process.stdin.on('end', async () => {
+    const input = JSON.parse(data);
+    const result = await handleUserPromptSubmit(input);
+    console.log(JSON.stringify(result));
+  });
+}
+```
+
+### 3.3 Stop Hook (src/hooks/stop.ts)
+
+```typescript
+import { EventStore } from '../core/event-store';
+import { VectorStore } from '../core/vector-store';
+import { Embedder } from '../core/embedder';
+import { loadServices } from '../core/services';
+
+export async function handleStop(input: {
+  session_id: string;
+  messages: Array<{ role: string; content: string }>;
+}): Promise<void> {
+  const { eventStore, vectorStore, embedder } = await loadServices();
+
+  // 마지막 user-assistant 쌍 저장
+  const messages = input.messages.slice(-2);
+
+  for (const msg of messages) {
+    const eventType = msg.role === 'user' ? 'user_prompt' : 'agent_response';
+
+    // 1. 이벤트 저장
+    const result = await eventStore.append({
+      eventType,
+      sessionId: input.session_id,
+      timestamp: new Date(),
+      content: msg.content,
+      metadata: {}
+    });
+
+    // 2. 임베딩 생성 및 벡터 저장 (중복 아닌 경우)
+    if (result.success && !result.isDuplicate) {
+      const vector = await embedder.embed(msg.content);
+
+      await vectorStore.upsert({
+        id: crypto.randomUUID(),
+        eventId: result.eventId!,
+        sessionId: input.session_id,
+        eventType,
+        content: msg.content.slice(0, 1000),  // 미리보기용
+        vector,
+        timestamp: new Date().toISOString()
+      });
+    }
+  }
+}
+```
+
+---
+
+## Phase 4: Commands & CLI
+
+### 4.1 Search Command (commands/search.md)
+
+```markdown
+---
+description: Search through your conversation memory
+---
+
+# Memory Search
+
+Search for relevant memories based on your query.
+
+## Usage
+
+The user wants to search their conversation memory for: "$ARGUMENTS"
+
+Search the memory database and return the most relevant past conversations, code snippets, and insights related to the query.
+
+Display the results in a clear format showing:
+1. The date of the memory
+2. A brief excerpt of the content
+3. The relevance score
+
+If no relevant memories are found, inform the user and suggest they can build up their memory by having more conversations.
+```
+
+### 4.2 CLI Entry Point (src/cli/index.ts)
+
+```typescript
+import { Command } from 'commander';
+import { handleSessionStart } from './commands/session-start';
+import { handleSearch } from './commands/search';
+import { handleSave } from './commands/save';
+import { handleSessionEnd } from './commands/session-end';
+import { handleInit } from './commands/init';
+
+const program = new Command();
+
+program
+  .name('code-memory')
+  .description('Claude Code Memory Plugin CLI')
+  .version('1.0.0');
+
+program
+  .command('init')
+  .description('Initialize the memory database')
+  .action(handleInit);
+
+program
+  .command('session-start')
+  .description('Handle session start')
+  .option('--session-id <id>', 'Session ID')
+  .option('--cwd <path>', 'Current working directory')
+  .action(handleSessionStart);
+
+program
+  .command('search')
+  .description('Search memories')
+  .option('--query <text>', 'Search query')
+  .option('--stdin', 'Read from stdin')
+  .option('--limit <n>', 'Max results', '5')
+  .action(handleSearch);
+
+program
+  .command('save')
+  .description('Save conversation')
+  .option('--stdin', 'Read from stdin')
+  .action(handleSave);
+
+program
+  .command('session-end')
+  .description('Handle session end')
+  .option('--stdin', 'Read from stdin')
+  .action(handleSessionEnd);
+
+program.parse();
+```
+
+---
+
+## Phase 5: Testing & Polish
+
+### 5.1 테스트 케이스 (tests/event-store.test.ts)
+
+```typescript
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { EventStore } from '../src/core/event-store';
+import { unlink } from 'fs/promises';
+
+describe('EventStore', () => {
+  let store: EventStore;
+  const testDbPath = './test-events.db';
+
+  beforeEach(() => {
+    store = new EventStore(testDbPath);
+  });
+
+  afterEach(async () => {
+    await unlink(testDbPath).catch(() => {});
+  });
+
+  it('should append events with deduplication', async () => {
+    const event = {
+      eventType: 'user_prompt' as const,
+      sessionId: 'test-session',
+      timestamp: new Date(),
+      content: 'Hello, how are you?',
+      metadata: {}
+    };
+
+    // 첫 번째 저장
+    const result1 = await store.append(event);
+    expect(result1.success).toBe(true);
+    expect(result1.isDuplicate).toBe(false);
+
+    // 중복 저장 시도
+    const result2 = await store.append(event);
+    expect(result2.success).toBe(true);
+    expect(result2.isDuplicate).toBe(true);
+    expect(result2.eventId).toBe(result1.eventId);
+  });
+
+  it('should retrieve events by session', async () => {
+    const sessionId = 'test-session';
+
+    await store.append({
+      eventType: 'user_prompt',
+      sessionId,
+      timestamp: new Date(),
+      content: 'First message',
+      metadata: {}
+    });
+
+    await store.append({
+      eventType: 'agent_response',
+      sessionId,
+      timestamp: new Date(),
+      content: 'First response',
+      metadata: {}
+    });
+
+    const events = await store.getSessionEvents(sessionId);
+    expect(events.length).toBe(2);
+  });
+});
+```
+
+### 5.2 통합 테스트 (tests/integration.test.ts)
+
+```typescript
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { EventStore } from '../src/core/event-store';
+import { VectorStore } from '../src/core/vector-store';
+import { Embedder } from '../src/core/embedder';
+import { Retriever } from '../src/core/retriever';
+
+describe('Integration: Memory Retrieval', () => {
+  let eventStore: EventStore;
+  let vectorStore: VectorStore;
+  let embedder: Embedder;
+  let retriever: Retriever;
+
+  beforeAll(async () => {
+    eventStore = new EventStore('./test-integration.db');
+    vectorStore = new VectorStore('./test-integration-vectors');
+    embedder = new Embedder();
+
+    await vectorStore.initialize();
+    await embedder.initialize();
+
+    retriever = new Retriever(eventStore, vectorStore, embedder, {
+      retrieval: { topK: 5, minScore: 0.5, maxTokens: 2000 }
+    });
+
+    // 테스트 데이터 삽입
+    const testData = [
+      { content: 'How to implement rate limiting in Express?', type: 'user_prompt' },
+      { content: 'You can use express-rate-limit middleware...', type: 'agent_response' },
+      { content: 'How to add authentication to my API?', type: 'user_prompt' },
+      { content: 'Use Passport.js or JWT for authentication...', type: 'agent_response' }
+    ];
+
+    for (const data of testData) {
+      const result = await eventStore.append({
+        eventType: data.type as any,
+        sessionId: 'test-session',
+        timestamp: new Date(),
+        content: data.content,
+        metadata: {}
+      });
+
+      const vector = await embedder.embed(data.content);
+      await vectorStore.upsert({
+        id: crypto.randomUUID(),
+        eventId: result.eventId!,
+        sessionId: 'test-session',
+        eventType: data.type,
+        content: data.content,
+        vector,
+        timestamp: new Date().toISOString()
+      });
+    }
+  });
+
+  it('should find relevant memories', async () => {
+    const matches = await retriever.search('rate limiting');
+
+    expect(matches.length).toBeGreaterThan(0);
+    expect(matches[0].event.content).toContain('rate limiting');
+  });
+
+  it('should format context correctly', () => {
+    const matches = [
+      {
+        event: {
+          id: '1',
+          eventType: 'user_prompt',
+          sessionId: 'test',
+          timestamp: new Date(),
+          content: 'Test content',
+          contentHash: 'hash'
+        },
+        score: 0.95,
+        relevanceReason: 'High similarity'
+      }
+    ];
+
+    const context = retriever.formatContext(matches);
+    expect(context).toContain('Relevant Memories');
+    expect(context).toContain('Test content');
+  });
+});
+```
+
+### 5.3 빌드 스크립트 (scripts/build.ts)
+
+```typescript
+import * as esbuild from 'esbuild';
+
+async function build() {
+  // CLI 빌드
+  await esbuild.build({
+    entryPoints: ['src/cli/index.ts'],
+    bundle: true,
+    platform: 'node',
+    target: 'node18',
+    outfile: 'dist/cli.js',
+    external: ['duckdb', 'lancedb', '@xenova/transformers']
+  });
+
+  console.log('Build complete!');
+}
+
+build().catch(console.error);
+```
+
+---
+
+## 마일스톤 체크리스트
+
+### Phase 0: 프로젝트 설정
+- [ ] 디렉토리 구조 생성
+- [ ] package.json 초기화
+- [ ] 의존성 설치
+- [ ] TypeScript 설정
+- [ ] plugin.json 생성
+
+### Phase 1: Core Storage Layer
+- [ ] types.ts - Zod 스키마 정의
+- [ ] event-store.ts - DuckDB 연동
+- [ ] vector-store.ts - LanceDB 연동
+- [ ] 단위 테스트
+
+### Phase 2: Embedding & Retrieval
+- [ ] embedder.ts - 로컬 임베딩
+- [ ] retriever.ts - 검색 로직
+- [ ] 컨텍스트 포맷터
+- [ ] 단위 테스트
+
+### Phase 3: Hook Integration
+- [ ] hooks.json 설정
+- [ ] session-start hook
+- [ ] user-prompt-submit hook
+- [ ] stop hook
+- [ ] session-end hook
+
+### Phase 4: Commands & CLI
+- [ ] CLI 엔트리포인트
+- [ ] search 명령어
+- [ ] history 명령어
+- [ ] forget 명령어
+- [ ] stats 명령어
+
+### Phase 5: Testing & Polish
+- [ ] 통합 테스트
+- [ ] README.md
+- [ ] 에러 처리 개선
+- [ ] 성능 최적화
+- [ ] 첫 릴리스 준비
+
+---
+
+## 리스크 및 대응
+
+| 리스크 | 영향 | 대응 |
+|--------|------|------|
+| 임베딩 모델 로드 시간 | 세션 시작 지연 | 모델 캐싱, 지연 로드 |
+| 대용량 대화 처리 | 메모리 부족 | 스트리밍, 배치 처리 |
+| DuckDB/LanceDB 호환성 | 설치 실패 | fallback 구현, 순수 JS 대안 |
+| Hook 타임아웃 | 기능 미작동 | 비동기 처리, 캐싱 |
+
+---
+
+## 다음 단계
+
+1. **Phase 0 완료 후**: 기본 플러그인 구조 동작 확인
+2. **Phase 1-2 완료 후**: 기억 저장/검색 기능 데모
+3. **Phase 3-4 완료 후**: 실제 Claude Code에서 테스트
+4. **Phase 5 완료 후**: 커뮤니티 마켓플레이스 등록
+
+## 2026-02-25T12:31:26.199Z | 5808e4d1-65b8-46d8-8745-b6208eafa711
+- type: session_summary
+- session: import:organized
+# Specification: Claude Code Memory Plugin
+
+## 1. 개요
+
+### 1.1 플러그인 정보
+
+| 항목 | 값 |
+|------|-----|
+| **이름** | `code-memory` |
+| **버전** | `1.0.0` |
+| **설명** | 대화 기억을 통해 사용자 맞춤형 경험을 제공하는 Claude Code 플러그인 |
+| **핵심 가치** | "사용할수록 똑똑해지는 Agent" |
+
+### 1.2 핵심 기능
+
+1. **대화 기억 저장**: 모든 사용자 prompt와 agent 응답을 영구 저장
+2. **지능형 검색**: 새로운 prompt와 관련된 과거 기억을 의미 기반 검색
+3. **컨텍스트 주입**: 관련 기억을 현재 대화에 자동 주입
+4. **학습 및 진화**: 패턴 인식을 통한 개인화
+
+---
+
+## 2. 아키텍처
+
+### 2.1 시스템 구조
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Claude Code Session                       │
+└─────────────────────────────────────────────────────────────┘
+         │                    │                    │
+         ▼                    ▼                    ▼
+┌─────────────┐      ┌─────────────┐      ┌─────────────┐
+│ SessionStart│      │UserPrompt   │      │ Stop/       │
+│    Hook     │      │Submit Hook  │      │ SessionEnd  │
+└─────────────┘      └─────────────┘      └─────────────┘
+         │                    │                    │
+         ▼                    ▼                    ▼
+┌─────────────────────────────────────────────────────────────┐
+│                    Memory Service (Core)                     │
+│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐    │
+│  │ Ingester │  │ Embedder │  │ Retriever│  │ Ranker   │    │
+│  └──────────┘  └──────────┘  └──────────┘  └──────────┘    │
+└─────────────────────────────────────────────────────────────┘
+         │                    │                    │
+         ▼                    ▼                    ▼
+┌─────────────────────────────────────────────────────────────┐
+│                    Storage Layer                             │
+│  ┌───────────────────┐      ┌───────────────────┐          │
+│  │    LanceDB        │      │     DuckDB        │          │
+│  │ (Vector Store)    │      │ (Event Store)     │          │
+│  └───────────────────┘      └───────────────────┘          │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### 2.2 데이터 흐름
+
+```
+1. [SessionStart]
+   → 이전 세션 요약 로드
+   → 사용자 선호도/패턴 로드
+
+2. [UserPromptSubmit]
+   → 현재 prompt 임베딩 생성
+   → 관련 기억 검색 (top-k)
+   → 기억을 시스템 프롬프트로 주입
+
+3. [Stop/AgentResponse]
+   → 전체 대화 쌍 (prompt + response) 저장
+   → 비동기 임베딩 생성 및 인덱싱
+
+4. [SessionEnd]
+   → 세션 요약 생성 및 저장
+   → 장기 기억으로 통합
+```
+
+### 2.3 Memory Graduation Pipeline (L0 → L4)
+
+AXIOMMIND 기반 다단계 메모리 승격 구조:
+
+| 레벨 | 이름 | 설명 | 저장소 | 상태 |
+|------|------|------|--------|------|
+| **L0** | EventStore | 원본 대화 로그 (불변) | DuckDB `events` | 즉시 저장 |
+| **L1** | Structured | LLM 추출 구조화 데이터 | DuckDB `insights` | 비동기 처리 |
+| **L2** | Candidates | 타입 검증 대상 | TypeScript 검증 | 배치 처리 |
+| **L3** | Verified | 검증 완료 지식 | DuckDB `verified_knowledge` | 검증 후 |
+| **L4** | Active | 검색 가능 메모리 | LanceDB | 인덱싱 후 |
+
+```
+User Prompt → L0 (즉시) → L1 (비동기) → L2 (배치) → L3 (검증) → L4 (검색 가능)
+                ↑                                              ↓
+                └──────────── 검색 시 L4에서 조회 ─────────────┘
+```
+
+### 2.4 AXIOMMIND 7가지 필수 원칙
+
+본 플러그인은 다음 원칙을 준수합니다:
+
+| # | 원칙 | 구현 |
+|---|------|------|
+| 1 | 진실의 원천은 이벤트 로그 | `events` 테이블에서 모든 파생 데이터 재구성 가능 |
+| 2 | 추가전용 구조 | `EventStore.append()` 만 제공, UPDATE/DELETE 없음 |
+| 3 | 멱등성 보장 | `dedupe_key = session_id + content_hash` |
+| 4 | 증거 범위는 파이프라인이 확정 | `EvidenceAligner`가 정확한 스팬 계산 |
+| 5 | Task는 엔티티 | `canonical_key`로 동일 개념 통합 |
+| 6 | 벡터 저장소 정합성 | DuckDB → outbox → LanceDB 단방향 |
+| 7 | DuckDB JSON 사용 | JSONB 대신 표준 JSON |
+
+---
+
+## 3. 데이터 모델
+
+### 3.1 Event Schema (DuckDB) - AXIOMMIND 스타일
+
+```sql
+-- ============================================================
+-- L0 EventStore: Single Source of Truth (불변, append-only)
+-- ============================================================
+
+CREATE TABLE events (
+    id              UUID PRIMARY KEY,
+    event_type      VARCHAR NOT NULL,    -- 'user_prompt' | 'agent_response' | 'session_summary'
+    session_id      VARCHAR NOT NULL,
+    timestamp       TIMESTAMP NOT NULL,
+    content         TEXT NOT NULL,
+    canonical_key   VARCHAR NOT NULL,    -- 정규화된 키 (NFKC, lowercase, no punctuation)
+    metadata        JSON,
+    dedupe_key      VARCHAR UNIQUE       -- 멱등성 보장 (content_hash + session_id)
+);
+
+-- 중복 방지 테이블 (event_dedup)
+CREATE TABLE event_dedup (
+    dedupe_key      VARCHAR PRIMARY KEY,
+    event_id        UUID NOT NULL REFERENCES events(id),
+    created_at      TIMESTAMP DEFAULT NOW()
+);
+
+-- Projection offset 추적 (증분 처리용)
+CREATE TABLE projection_offsets (
+    projection_name VARCHAR PRIMARY KEY,
+    last_event_id   UUID,
+    last_timestamp  TIMESTAMP,
+    updated_at      TIMESTAMP DEFAULT NOW()
+);
+
+-- ============================================================
+-- 세션 메타데이터
+-- ============================================================
+
+CREATE TABLE sessions (
+    id              VARCHAR PRIMARY KEY,
+    started_at      TIMESTAMP NOT NULL,
+    ended_at        TIMESTAMP,
+    project_path    VARCHAR,
+    summary         TEXT,
+    tags            JSON
+);
+
+-- ============================================================
+-- 추출된 인사이트 (파생 데이터, 재구성 가능)
+-- ============================================================
+
+CREATE TABLE insights (
+    id              UUID PRIMARY KEY,
+    insight_type    VARCHAR NOT NULL,    -- 'preference' | 'pattern' | 'expertise'
+    content         TEXT NOT NULL,
+    canonical_key   VARCHAR NOT NULL,    -- 정규화된 키
+    confidence      FLOAT,
+    source_events   JSON,                -- 원본 이벤트 ID 목록
+    created_at      TIMESTAMP,
+    last_updated    TIMESTAMP
+);
+
+-- ============================================================
+-- Embedding Outbox (Single-Writer Pattern)
+-- ============================================================
+
+CREATE TABLE embedding_outbox (
+    id              UUID PRIMARY KEY,
+    event_id        UUID NOT NULL REFERENCES events(id),
+    content         TEXT NOT NULL,
+    status          VARCHAR DEFAULT 'pending',  -- 'pending' | 'processing' | 'done' | 'failed'
+    retry_count     INT DEFAULT 0,
+    created_at      TIMESTAMP DEFAULT NOW(),
+    processed_at    TIMESTAMP,
+    error_message   TEXT
+);
+
+-- ============================================================
+-- Memory Resolutions (Condition → Task 해결)
+-- ============================================================
+
+CREATE TABLE memory_resolutions (
+    id              UUID PRIMARY KEY,
+    condition_id    UUID NOT NULL,       -- 원본 조건/참조
+    resolved_to_id  UUID,                -- 해결된 대상
+    resolution_type VARCHAR,             -- 'confirmed' | 'rejected' | 'pending'
+    confidence      FLOAT,
+    resolved_at     TIMESTAMP
+);
+
+-- ============================================================
+-- Effective View (Condition 해결 반영)
+-- ============================================================
+
+CREATE VIEW v_memory_context_effective AS
+SELECT
+    e.id,
+    e.session_id,
+    e.content,
+    e.canonical_key,
+    e.event_type,
+    e.timestamp,
+    COALESCE(r.resolved_to_id, e.id) as effective_id,
+    CASE
+        WHEN r.resolution_type = 'confirmed' THEN 'resolved'
+        WHEN r.resolution_type = 'pending' THEN 'pending'
+        ELSE 'direct'
+    END as resolution_status
+FROM events e
+LEFT JOIN memory_resolutions r ON e.id = r.condition_id;
+```
+
+### 3.2 Vector Schema (LanceDB)
+
+```python
+# 대화 임베딩 테이블
+conversations_schema = {
+    "id": str,              # UUID
+    "event_id": str,        # events 테이블 참조
+    "session_id": str,
+    "event_type": str,      # 'user_prompt' | 'agent_response'
+    "content": str,         # 원본 텍스트 (검색 결과 표시용)
+    "vector": list[float],  # 임베딩 벡터 (384 또는 1536 차원)
+    "timestamp": str,
+    "metadata": dict        # 추가 메타데이터
+}
+
+# 인사이트 임베딩 테이블
+insights_schema = {
+    "id": str,
+    "insight_id": str,      # insights 테이블 참조
+    "content": str,
+    "vector": list[float],
+    "insight_type": str,
+    "confidence": float
+}
+```
+
+### 3.3 TypeScript 타입 정의 (Idris2 영감)
+
+```typescript
+// 불변성과 타입 안전성을 강조한 설계
+
+// 이벤트 타입 (Union Type으로 완전성 보장)
+type EventType = 'user_prompt' | 'agent_response' | 'session_summary';
+
+// 이벤트 구조 (Readonly로 불변성 강제)
+interface MemoryEvent {
+  readonly id: string;
+  readonly eventType: EventType;
+  readonly sessionId: string;
+  readonly timestamp: Date;
+  readonly content: string;
+  readonly contentHash: string;
+  readonly metadata: Readonly<Record<string, unknown>>;
+}
+
+// 검색 결과 (신뢰도 점수 포함)
+interface MemoryMatch {
+  readonly event: MemoryEvent;
+  readonly score: number;        // 0.0 ~ 1.0
+  readonly relevanceReason: string;
+}
+
+// 컨텍스트 주입 결과
+interface ContextInjection {
+  readonly memories: ReadonlyArray<MemoryMatch>;
+  readonly systemPromptAddition: string;
+  readonly totalTokensUsed: number;
+}
+
+// 저장 결과 (성공/실패 명시적 표현)
+type SaveResult =
+  | { success: true; eventId: string }
+  | { success: false; error: string; isDuplicate: boolean };
+```
+
+---
+
+## 4. Hook 명세
+
+### 4.1 SessionStart Hook
+
+**목적**: 세션 시작 시 관련 컨텍스트 로드
+
+```json
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "type": "command",
+        "command": "code-memory session-start",
+        "timeout": 5000
+      }
+    ]
+  }
+}
+```
+
+**입력**:
+```json
+{
+  "session_id": "sess_abc123",
+  "cwd": "/path/to/project"
+}
+```
+
+**출력**:
+```json
+{
+  "context": "## Previous Session Context\n- Last worked on: API authentication\n- User preference: Prefers TypeScript\n- Recent patterns: Uses Zod for validation"
+}
+```
+
+### 4.2 UserPromptSubmit Hook
+
+**목적**: 사용자 입력 시 관련 기억 검색 및 주입
+
+```json
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "type": "command",
+        "command": "code-memory search",
+        "timeout": 3000
+      }
+    ]
+  }
+}
+```
+
+**입력**:
+```json
+{
+  "session_id": "sess_abc123",
+  "prompt": "How do I add rate limiting to the API?"
+}
+```
+
+**출력**:
+```json
+{
+  "context": "## Relevant Memories\n\n### Previous Discussion (2 weeks ago)\nYou implemented rate limiting for the /users endpoint using express-rate-limit...\n\n### Your Preferences\n- Prefers middleware-based solutions\n- Uses Redis for distributed rate limiting"
+}
+```
+
+### 4.3 Stop Hook
+
+**목적**: Agent 응답 완료 시 대화 저장
+
+```json
+{
+  "hooks": {
+    "Stop": [
+      {
+        "type": "command",
+        "command": "code-memory save",
+        "timeout": 5000
+      }
+    ]
+  }
+}
+```
+
+**입력**:
+```json
+{
+  "session_id": "sess_abc123",
+  "stop_reason": "end_turn",
+  "messages": [
+    {"role": "user", "content": "..."},
+    {"role": "assistant", "content": "..."}
+  ]
+}
+```
+
+### 4.4 SessionEnd Hook
+
+**목적**: 세션 종료 시 요약 저장
+
+```json
+{
+  "hooks": {
+    "SessionEnd": [
+      {
+        "type": "command",
+        "command": "code-memory session-end",
+        "timeout": 10000
+      }
+    ]
+  }
+}
+```
+
+---
+
+## 5. 명령어 인터페이스
+
+### 5.1 슬래시 명령어
+
+| 명령어 | 설명 | 예시 |
+|--------|------|------|
+| `/code-memory:search` | 기억 수동 검색 | `/code-memory:search rate limiting` |
+| `/code-memory:history` | 최근 대화 이력 | `/code-memory:history 10` |
+| `/code-memory:insights` | 추출된 인사이트 보기 | `/code-memory:insights` |
+| `/code-memory:forget` | 특정 기억 삭제 | `/code-memory:forget <id>` |
+| `/code-memory:export` | 기억 내보내기 | `/code-memory:export json` |
+| `/code-memory:stats` | 통계 보기 | `/code-memory:stats` |
+
+### 5.2 CLI 명령어 (Hook에서 호출)
+
+```bash
+# 세션 시작
+code-memory session-start --session-id <id> --cwd <path>
+
+# 기억 검색
+code-memory search --query <text> --limit 5 --threshold 0.7
+
+# 대화 저장
+code-memory save --stdin  # JSON 입력 수신
+
+# 세션 종료
+code-memory session-end --session-id <id>
+
+# 데이터베이스 초기화
+code-memory init
+
+# 임베딩 재생성
+code-memory reindex
+```
+
+---
+
+## 6. 설정
+
+### 6.1 plugin.json
+
+```json
+{
+  "name": "code-memory",
+  "description": "Learn from conversations to provide personalized assistance",
+  "version": "1.0.0",
+  "author": {
+    "name": "Buzzni"
+  },
+  "homepage": "https://github.com/buzzni/code-memory",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/buzzni/code-memory.git"
+  },
+  "license": "MIT",
+  "engines": {
+    "claude-code": ">=1.0.33"
+  },
+  "keywords": ["memory", "learning", "personalization", "context"]
+}
+```
+
+### 6.2 사용자 설정 (config.json)
+
+```json
+{
+  "storage": {
+    "path": "~/.claude-code/memory",
+    "maxSizeMB": 500
+  },
+  "embedding": {
+    "provider": "local",           // "local" | "openai"
+    "model": "all-MiniLM-L6-v2",   // local 모델
+    "openaiModel": "text-embedding-3-small",
+    "batchSize": 32
+  },
+  "retrieval": {
+    "topK": 5,
+    "minScore": 0.7,
+    "maxTokens": 2000              // 주입할 최대 토큰 수
+  },
+  "matching": {
+    "minCombinedScore": 0.92,      // 확정 매칭 최소 점수 (AXIOMMIND)
+    "minGap": 0.03,                // 1위-2위 간 최소 점수 차이
+    "suggestionThreshold": 0.75,   // 제안 모드 임계값
+    "weights": {
+      "semanticSimilarity": 0.4,   // 벡터 유사도 가중치
+      "ftsScore": 0.25,            // 전문 검색 가중치
+      "recencyBonus": 0.2,         // 최신성 가산점
+      "statusWeight": 0.15         // 상태별 가중치
+    }
+  },
+  "privacy": {
+    "excludePatterns": [           // 저장 제외 패턴
+      "password",
+      "secret",
+      "api_key"
+    ],
+    "anonymize": false
+  },
+  "features": {
+    "autoSave": true,
+    "sessionSummary": true,
+    "insightExtraction": true,
+    "crossProjectLearning": false, // 프로젝트 간 학습
+    "singleWriterMode": true       // Outbox 패턴 사용 (권장)
+  }
+}
+```
+
+### 6.3 Matching Thresholds (AXIOMMIND 기반)
+
+검색 결과의 신뢰도를 3단계로 분류:
+
+| 신뢰도 | 조건 | 동작 |
+|--------|------|------|
+| **high** | score ≥ 0.92 AND gap ≥ 0.03 | 확정 매칭, 자동 컨텍스트 주입 |
+| **suggested** | 0.75 ≤ score < 0.92 | 제안 모드, 사용자 확인 권장 |
+| **none** | score < 0.75 | 매칭 없음 |
+
+```typescript
+// Matching 결과 타입
+interface MatchResult {
+  readonly match: MemoryMatch | null;
+  readonly confidence: 'high' | 'suggested' | 'none';
+  readonly gap?: number;  // top-1과 top-2 간 점수 차이
+  readonly alternatives?: ReadonlyArray<MemoryMatch>;  // suggested일 때 대안들
+}
+```
+
+---
+
+## 7. 보안 및 프라이버시
+
+### 7.1 데이터 보호
+
+1. **로컬 저장**: 모든 데이터는 사용자 로컬에만 저장
+2. **민감 정보 필터링**: password, secret, api_key 등 자동 제외
+3. **선택적 익명화**: 개인 식별 정보 마스킹 옵션
+
+### 7.2 데이터 삭제
+
+```bash
+# 특정 기억 삭제
+code-memory forget --id <event_id>
+
+# 세션 전체 삭제
+code-memory forget --session <session_id>
+
+# 기간별 삭제
+code-memory forget --before "2024-01-01"
+
+# 전체 초기화
+code-memory reset --confirm
+```
+
+---
+
+## 8. 성능 요구사항
+
+| 항목 | 목표 | 비고 |
+|------|------|------|
+| **검색 지연** | < 500ms | 10만 건 기준 |
+| **저장 지연** | < 100ms | 비동기 처리 |
+| **메모리 사용** | < 200MB | 실행 시 |
+| **디스크 사용** | < 500MB | 기본 제한 |
+| **시작 시간** | < 2s | 세션 시작 |
+
+---
+
+## 9. 의존성
+
+### 9.1 런타임 의존성
+
+| 패키지 | 버전 | 용도 |
+|--------|------|------|
+| `lancedb` | ^0.5.0 | 벡터 저장소 |
+| `duckdb` | ^0.10.0 | 이벤트 저장소 |
+| `sentence-transformers` | ^2.2.0 | 로컬 임베딩 (Python) |
+| `@xenova/transformers` | ^2.15.0 | 로컬 임베딩 (JS) |
+| `zod` | ^3.22.0 | 스키마 검증 |
+| `commander` | ^12.0.0 | CLI 파싱 |
+
+### 9.2 개발 의존성
+
+| 패키지 | 버전 | 용도 |
+|--------|------|------|
+| `typescript` | ^5.4.0 | 타입 시스템 |
+| `vitest` | ^1.4.0 | 테스트 |
+| `tsx` | ^4.7.0 | TS 실행 |
+| `esbuild` | ^0.20.0 | 빌드 |
+
+---
+
+## 10. 향후 확장
+
+### Phase 2 (v1.1.0)
+- [ ] 그래프 기반 관계 저장 (Neo4j/Graphiti)
+- [ ] 멀티 프로젝트 학습
+- [ ] 팀 기억 공유 (암호화)
+
+### Phase 3 (v2.0.0)
+- [ ] 자동 인사이트 추출 (LLM 기반)
+- [ ] 코드 스니펫 특화 기억
+- [ ] IDE 통합 (VSCode extension)
+
+---
+
+## 11. 성공 지표
+
+| 지표 | 측정 방법 | 목표 |
+|------|----------|------|
+| **관련성** | 사용자 피드백 | 80%+ 유용 |
+| **속도** | 응답 지연 | < 500ms |
+| **채택률** | 활성 사용자 | 1000+ |
+| **재사용률** | 기억 활용 빈도 | 50%+ 세션 |
+
+## 2026-02-25T12:44:49.770Z | c15348b2-9c17-4b7f-abd6-06abcf83c7fa
+- type: session_summary
+- session: import:organized
+# Decisions (extracted)
+
+- confidence: high
+
+## 2026-01-31 | feat: implement complete code-memory plugin
+- status: active (inferred)
+- source: commit:111f400e73f0568b192a5b1b37a88622fd44d648
+- author: Claude
+- changedFiles: 31
+- confidence: mid
+
+## 2026-01-31 | feat: add session history import functionality
+- status: active (inferred)
+- source: commit:22b1c43d9b9f095cd2a210f529ca8bee5a1100c5
+- author: Claude
+- changedFiles: 5
+- confidence: mid
+
+## 2026-02-01 | docs: Update README with comprehensive feature documentation (#3)
+- status: active (inferred)
+- source: commit:3662dfae8381fdf35923b115f58c362e091c474a
+- author: justinbuzzni
+- changedFiles: 1
+- confidence: mid
+
+## 2026-02-01 | feat: Add cross-project shared troubleshooting store
+- status: active (inferred)
+- source: commit:d04e562b5b011e0f07cdea0664db823f0caca5d0
+- author: justinbuzzni
+- changedFiles: 9
+- confidence: mid
+
+## 2026-02-01 | refactor: Extract DuckDB wrapper for consistent async API
+- status: active (inferred)
+- source: commit:65b0f64da3fd2c4b0b758b89f9d0f22301df23a7
+- author: justinbuzzni
+- changedFiles: 19
+- confidence: mid
+
+## 2026-02-01 | feat: Add web dashboard for memory visualization
+- status: active (inferred)
+- source: commit:665cf11bb9a01f1bcba51ec49f53382e95cd7e32
+- author: justinbuzzni
+- changedFiles: 5
+- confidence: mid
+
+## 2026-02-01 | refactor: Rename project from code-memory to claude-memory-layer
+- status: active (inferred)
+- source: commit:f35da2b92704d7d1b5655edac3516c64a829eeef
+- author: justinbuzzni
+- changedFiles: 7
+- confidence: mid
+
+## 2026-02-01 | feat: Migrate primary store from DuckDB to SQLite (WAL mode)
+- status: active (inferred)
+- source: commit:be36be70f69d42d2373ac26e6c0b8e8b53ca0340
+- author: justinbuzzni
+- changedFiles: 8
+- confidence: mid
+
+## 2026-02-01 | feat: Enhance dashboard, CLI, and memory graduation system
+- status: active (inferred)
+- source: commit:babfd15284754bc3dbb698fcc4c81efcf53fcd85
+- author: justinbuzzni
+- changedFiles: 13
+- confidence: mid
+
+## 2026-02-07 | feat: Add memory helpfulness tracking and dashboard sort controls
+- status: active (inferred)
+- source: commit:794640023652fc38b010e1ab46ca6a9a504a09e8
+- author: justinbuzzni
+- changedFiles: 9
+- confidence: mid
+
+## 2026-02-08 | feat: Add interactive dashboard with modals, navigation, and detail views
+- status: active (inferred)
+- source: commit:20c37b2cdffd271eaf04df9d2e87e5f23a4f853e
+- author: justinbuzzni
+- changedFiles: 5
+- confidence: mid
+
+## 2026-02-08 | fix: Align hooks with actual Claude Code input format and use lightweight service
+- status: active (inferred)
+- source: commit:a1d93af414821eb92d74cd02abb748849366ebfb
+- author: justinbuzzni
+- changedFiles: 4
+- confidence: mid
+
+## 2026-02-08 | feat: Add real-time progress display for import command
+- status: active (inferred)
+- source: commit:fd8f38af7cecf7d31a32a5aba9b1902178f986b1
+- author: justinbuzzni
+- changedFiles: 2
+- confidence: mid
+
+## 2026-02-08 | feat: Add turn-based event grouping, force reimport, and session registry support
+- status: active (inferred)
+- source: commit:938ec34bdf5fe1e4c43274424497ca081d62023a
+- author: justinbuzzni
+- changedFiles: 9
+- confidence: mid
+
+## 2026-02-08 | feat: Add per-project dashboard with project selector and turns API
+- status: active (inferred)
+- source: commit:af18cee5277324c78a9e1bca5873bc86ee5b2719
+- author: justinbuzzni
+- changedFiles: 12
+- confidence: mid
+
+## 2026-02-08 | fix: Handle vector store table race condition and auto-create SQLite directories
+- status: active (inferred)
+- source: commit:5b7401917611b50ee49e38bdf080983d1c763d5e
+- author: justinbuzzni
+- changedFiles: 2
+- confidence: mid
+
+## 2026-02-08 | feat: Add Ask Memory chat service to dashboard
+- status: active (inferred)
+- source: commit:a7b260f0ceeff6d768fefb675e6425f5b4717d7e
+- author: justinbuzzni
+- changedFiles: 5
+- confidence: mid
+
+## 2026-02-08 | feat: Widen chat panel and add conversation history with localStorage
+- status: active (inferred)
+- source: commit:15547d41e952350d095dfe3c01b2afa749638532
+- author: justinbuzzni
+- changedFiles: 3
+- confidence: mid
+
+## 2026-02-08 | fix: Knowledge Graph shows data even when no memories have been accessed
+- status: active (inferred)
+- source: commit:78b0956610eb7d22c28a821c67e10e6e9996c5be
+- author: justinbuzzni
+- changedFiles: 2
+- confidence: mid
+
+## 2026-02-20 | feat(ops): add heartbeat orchestrator and sync-gap auto-heal scripts
+- status: active (inferred)
+- source: commit:d56d22ba3271c1d51ea8bbaddb21f5f3d0a79d49
+- author: namsangboy
+- changedFiles: 7
+- confidence: mid
+
+## 2026-02-09 | feat: optional MongoDB sync for project events
+- status: active (inferred)
+- source: commit:11d3092e372836f784a760fc0b4269fd44e9159f
+- author: Justin
+- changedFiles: 9
+- confidence: mid
+
+## 2026-02-22 | feat: add Codex session history importer, MongoDB sync config, and AGENTS.md
+- status: active (inferred)
+- source: commit:4855172b8f92fff0c148c106de4e10c494d2bb09
+- author: Justin
+- changedFiles: 4
+- confidence: mid
+
+## 2026-02-24 | feat(memory): adopt memU-style scoped retrieval and staged ingest hooks
+- status: active (inferred)
+- source: commit:d278200d0f0666616a8556f2f25f9758b3ab9afd
+- author: justinbuzzni
+- changedFiles: 6
+- confidence: mid
+
+## 2026-02-24 | feat(memory): add append-only markdown mirror for categorized event archives
+- status: active (inferred)
+- source: commit:917ad7fc97a1c2de68637dfbe4b4cdd51776ec30
+- author: justinbuzzni
+- changedFiles: 4
+- confidence: mid
+
+## 2026-02-24 | feat: append-only markdown mirror in sqlite ingest flow
+- status: active (inferred)
+- source: commit:72250046152e851ed70476a8704ca38ca633ffab
+- author: justinbuzzni
+- changedFiles: 3
+- confidence: mid
+
+## 2026-02-24 | feat(memory): auto-refresh markdown mirror index
+- status: active (inferred)
+- source: commit:3a34d45a594affb034d6e416e3a29b6d2dcc20a5
+- author: justinbuzzni
+- changedFiles: 3
+- confidence: mid
+
+## 2026-02-24 | feat(cli): add organize-import command for structured markdown memory import
+- status: active (inferred)
+- source: commit:fe9ef67e5acabb81885a3c752a5b8525f80856a5
+- author: justinbuzzni
+- changedFiles: 3
+- confidence: mid
+
+## 2026-02-24 | feat(retrieval): add auto fallback chain fast→deep→scope-expand→summary
+- status: active (inferred)
+- source: commit:0dceb2d914e67e10d140848340f30e6fd07c4f67
+- author: justinbuzzni
+- changedFiles: 2
+- confidence: mid
+
+## 2026-02-24 | feat(ranking): add helpfulness-driven adaptive rerank weights v1
+- status: active (inferred)
+- source: commit:7de02967a1d59aea3e04ef1239585b93828c503a
+- author: justinbuzzni
+- changedFiles: 3
+- confidence: mid
+
+## 2026-02-24 | feat(retrieval): add ttl/decay ranking policy v1
+- status: active (inferred)
+- source: commit:46f2cfa2d99f0c8fb3a48709a97f62800f01d4fe
+- author: justinbuzzni
+- changedFiles: 2
+- confidence: mid
+
+## 2026-02-24 | feat(retrieval): add intent-rewrite deep retrieval merge flow
+- status: active (inferred)
+- source: commit:5fd950beee4d02f00b0c93be668a2e114ce9b257
+- author: justinbuzzni
+- changedFiles: 3
+- confidence: mid
+
+## 2026-02-24 | feat(retrieval): add graph-hop expansion with hop penalty
+- status: active (inferred)
+- source: commit:d1dfe03f881d1a76ecd9a916cbf04c3ff2a4bf7e
+- author: justinbuzzni
+- changedFiles: 2
+- confidence: mid
+
+## 2026-02-24 | feat(consolidation): add hierarchical summary→rule automation with report
+- status: active (inferred)
+- source: commit:7c84b5eacff733d8cb692eb9d47b7297a0872e43
+- author: justinbuzzni
+- changedFiles: 6
+- confidence: mid
+
+## 2026-02-25 | Feat/organize import bootstrap kb (#10)
+- status: active (inferred)
+- source: commit:db38c7e606a59478c03bac7e5bb5951954ca0813
+- author: justinbuzzni
+- changedFiles: 4
+- confidence: mid
+
+## Sources
+- source: git-log:since=180 days ago;max=1000
+
+## 2026-02-25T12:44:49.793Z | ad99702b-0e3a-4054-ab3c-27d4d1c83850
+- type: session_summary
+- session: import:organized
+# Glossary (auto-extracted)
+
+- confidence: mid
+
+- context
+- spec
+- plan
+- memory
+- store
+- sync
+- worker
+- retriever
+- event
+- mirror
+- session
+- shared
+- vector
+- gap
+- history
+- matcher
+- sqlite
+- task
+- aligner
+- auto
+- bootstrap
+- canonical
+- config
+- consolidation
+- evidence
+- graduation
+- importer
+- ingest
+- interceptor
+- key
+- markdown
+- mongo
+- organizer
+- package
+- repo
+- resolver
+- search
+- stats
+- wrapper
+
+## Sources
+- source: repo-scan:/home/walter/workspace/opensource/claude-memory-layer
+
+## 2026-02-25T12:44:49.802Z | df87a07f-4efe-4925-829a-2dd51fb27014
+- type: session_summary
+- session: import:organized
+# Module: .claude-plugin
+
+- responsibility: inferred from top-level path `.claude-plugin/`
+- files: 8
+- languages: Markdown, JSON
+- confidence: high
+
+## Entry Candidates
+- none detected
+
+## Related Commits (recent sample)
+- 2026-01-31 111f400e feat: implement complete code-memory plugin
+- 2026-01-31 22b1c43d feat: add session history import functionality
+- 2026-02-01 504ec3dd docs: Add citations and endless mode specification documents (#2)
+- 2026-02-01 f35da2b9 refactor: Rename project from code-memory to claude-memory-layer
+
+## Sources
+- source: repo-path:.claude-plugin/**
+- source: commit:111f400e73f0568b192a5b1b37a88622fd44d648
+- source: commit:22b1c43d9b9f095cd2a210f529ca8bee5a1100c5
+- source: commit:504ec3ddd7f451fabf2cf01e073fc96e65ae124e
+- source: commit:f35da2b92704d7d1b5655edac3516c64a829eeef
+
+## 2026-02-25T12:44:49.817Z | 7a188e68-aab0-4d23-ae8c-b904d850224f
+- type: session_summary
+- session: import:organized
+# Module: AGENTS.md
+
+- responsibility: inferred from top-level path `AGENTS.md/`
+- files: 1
+- languages: Markdown
+- confidence: low
+
+## Entry Candidates
+- none detected
+
+## Related Commits (recent sample)
+- none in selected range
+
+## Sources
+- source: repo-path:AGENTS.md/**
+
+## 2026-02-25T12:44:49.826Z | 9f2abb09-0094-4864-b1d1-8481675491bd
+- type: session_summary
+- session: import:organized
+# Module: CLAUDE.md
+
+- responsibility: inferred from top-level path `CLAUDE.md/`
+- files: 1
+- languages: Markdown
+- confidence: low
+
+## Entry Candidates
+- none detected
+
+## Related Commits (recent sample)
+- none in selected range
+
+## Sources
+- source: repo-path:CLAUDE.md/**
+
+## 2026-02-25T12:44:49.834Z | a410152a-449c-4f76-b5e9-5bbecacd4370
+- type: session_summary
+- session: import:organized
+# Module: context.md
+
+- responsibility: inferred from top-level path `context.md/`
+- files: 1
+- languages: Markdown
+- confidence: low
+
+## Entry Candidates
+- none detected
+
+## Related Commits (recent sample)
+- none in selected range
+
+## Sources
+- source: repo-path:context.md/**
+
+## 2026-02-25T12:44:49.841Z | 7b9b955f-89a4-4b90-a75f-35a50e59b14d
+- type: session_summary
+- session: import:organized
+# Module: docs
+
+- responsibility: inferred from top-level path `docs/`
+- files: 2
+- languages: Markdown
+- confidence: mid
+
+## Entry Candidates
+- none detected
+
+## Related Commits (recent sample)
+- 2026-02-20 d56d22ba feat(ops): add heartbeat orchestrator and sync-gap auto-heal scripts
+- 2026-02-24 4447e64f docs(memory): document memU-inspired retrieval strategies and scoped filters
+
+## Sources
+- source: repo-path:docs/**
+- source: commit:d56d22ba3271c1d51ea8bbaddb21f5f3d0a79d49
+- source: commit:4447e64fa00065bfb364d38c597ad87484770891
+
+## 2026-02-25T12:44:49.849Z | 39062a82-1fd5-47ba-850c-36adb9aaad2a
+- type: session_summary
+- session: import:organized
+# Module: HANDOFF.md
+
+- responsibility: inferred from top-level path `HANDOFF.md/`
+- files: 1
+- languages: Markdown
+- confidence: low
+
+## Entry Candidates
+- none detected
+
+## Related Commits (recent sample)
+- none in selected range
+
+## Sources
+- source: repo-path:HANDOFF.md/**
+
+## 2026-02-25T12:44:49.856Z | ede06b47-7e54-4a2b-8e59-0d87fec83fa5
+- type: session_summary
+- session: import:organized
+# Module: package-lock.json
+
+- responsibility: inferred from top-level path `package-lock.json/`
+- files: 1
+- languages: JSON
+- confidence: low
+
+## Entry Candidates
+- none detected
+
+## Related Commits (recent sample)
+- none in selected range
+
+## Sources
+- source: repo-path:package-lock.json/**
+
+## 2026-02-25T12:44:49.863Z | ccfcd6c5-95fb-4a1c-9708-d518cad72a84
+- type: session_summary
+- session: import:organized
+# Module: package.json
+
+- responsibility: inferred from top-level path `package.json/`
+- files: 1
+- languages: JSON
+- confidence: low
+
+## Entry Candidates
+- none detected
+
+## Related Commits (recent sample)
+- none in selected range
+
+## Sources
+- source: repo-path:package.json/**
+
+## 2026-02-25T12:44:49.869Z | 698bcbda-e8a5-47c8-8b97-4cffebd4c1d6
+- type: session_summary
+- session: import:organized
+# Module: plan.md
+
+- responsibility: inferred from top-level path `plan.md/`
+- files: 1
+- languages: Markdown
+- confidence: low
+
+## Entry Candidates
+- none detected
+
+## Related Commits (recent sample)
+- none in selected range
+
+## Sources
+- source: repo-path:plan.md/**
+
+## 2026-02-25T12:44:49.876Z | 3c641407-4507-4025-a30a-1ba8bc3ba6a9
+- type: session_summary
+- session: import:organized
+# Module: README.md
+
+- responsibility: inferred from top-level path `README.md/`
+- files: 1
+- languages: Markdown
+- confidence: low
+
+## Entry Candidates
+- none detected
+
+## Related Commits (recent sample)
+- none in selected range
+
+## Sources
+- source: repo-path:README.md/**
+
+## 2026-02-25T12:44:49.883Z | f948c223-8747-48a2-aacb-eb3c0f4d7ef1
+- type: session_summary
+- session: import:organized
+# Module: scripts
+
+- responsibility: inferred from top-level path `scripts/`
+- files: 6
+- languages: JavaScript, Shell, TypeScript
+- confidence: high
+
+## Entry Candidates
+- none detected
+
+## Related Commits (recent sample)
+- 2026-01-31 111f400e feat: implement complete code-memory plugin
+- 2026-02-01 665cf11b feat: Add web dashboard for memory visualization
+- 2026-02-01 f35da2b9 refactor: Rename project from code-memory to claude-memory-layer
+- 2026-02-01 be36be70 feat: Migrate primary store from DuckDB to SQLite (WAL mode)
+- 2026-02-20 d56d22ba feat(ops): add heartbeat orchestrator and sync-gap auto-heal scripts
+- 2026-02-09 11d3092e feat: optional MongoDB sync for project events
+
+## Sources
+- source: repo-path:scripts/**
+- source: commit:111f400e73f0568b192a5b1b37a88622fd44d648
+- source: commit:665cf11bb9a01f1bcba51ec49f53382e95cd7e32
+- source: commit:f35da2b92704d7d1b5655edac3516c64a829eeef
+- source: commit:be36be70f69d42d2373ac26e6c0b8e8b53ca0340
+- source: commit:d56d22ba3271c1d51ea8bbaddb21f5f3d0a79d49
+- source: commit:11d3092e372836f784a760fc0b4269fd44e9159f
+
+## 2026-02-25T12:44:49.889Z | 2da127d3-7fff-44bb-85aa-3858635b10e1
+- type: session_summary
+- session: import:organized
+# Module: spec.md
+
+- responsibility: inferred from top-level path `spec.md/`
+- files: 1
+- languages: Markdown
+- confidence: low
+
+## Entry Candidates
+- none detected
+
+## Related Commits (recent sample)
+- none in selected range
+
+## Sources
+- source: repo-path:spec.md/**
+
+## 2026-02-25T12:44:49.896Z | c7f1b00c-61ee-4621-a012-4cb83d80fd99
+- type: session_summary
+- session: import:organized
+# Module: specs
+
+- responsibility: inferred from top-level path `specs/`
+- files: 35
+- languages: Markdown
+- confidence: high
+
+## Entry Candidates
+- none detected
+
+## Related Commits (recent sample)
+- 2026-02-01 4bbbc717 Merge pull request #1 from buzzni/claude/idris2-memory-storage-JLk7J
+- 2026-02-01 504ec3dd docs: Add citations and endless mode specification documents (#2)
+- 2026-02-08 20c37b2c feat: Add interactive dashboard with modals, navigation, and detail views
+
+## Sources
+- source: repo-path:specs/**
+- source: commit:4bbbc7174f920434cfc67ee02746a9b9824ec101
+- source: commit:504ec3ddd7f451fabf2cf01e073fc96e65ae124e
+- source: commit:20c37b2cdffd271eaf04df9d2e87e5f23a4f853e
+
+## 2026-02-25T12:44:49.902Z | 8315c023-3a7a-451d-82de-1629672658c6
+- type: session_summary
+- session: import:organized
+# Module: src
+
+- responsibility: inferred from top-level path `src/`
+- files: 70
+- languages: TypeScript, JavaScript
+- confidence: high
+
+## Entry Candidates
+- src/cli/index.ts
+- src/core/index.ts
+- src/core/privacy/index.ts
+- src/core/task/index.ts
+- src/mcp/index.ts
+- src/server/api/index.ts
+- src/server/index.ts
+- src/ui/app.js
+
+## Related Commits (recent sample)
+- 2026-01-31 111f400e feat: implement complete code-memory plugin
+- 2026-01-31 22b1c43d feat: add session history import functionality
+- 2026-02-01 4bbbc717 Merge pull request #1 from buzzni/claude/idris2-memory-storage-JLk7J
+- 2026-02-01 504ec3dd docs: Add citations and endless mode specification documents (#2)
+- 2026-02-01 d04e562b feat: Add cross-project shared troubleshooting store
+- 2026-02-01 65b0f64d refactor: Extract DuckDB wrapper for consistent async API
+- 2026-02-01 665cf11b feat: Add web dashboard for memory visualization
+- 2026-02-01 f35da2b9 refactor: Rename project from code-memory to claude-memory-layer
+- 2026-02-01 be36be70 feat: Migrate primary store from DuckDB to SQLite (WAL mode)
+- 2026-02-01 babfd152 feat: Enhance dashboard, CLI, and memory graduation system
+- 2026-02-02 543643e7 perf: Add fast keyword search and optimize hook performance
+- 2026-02-07 79464002 feat: Add memory helpfulness tracking and dashboard sort controls
+- 2026-02-08 20c37b2c feat: Add interactive dashboard with modals, navigation, and detail views
+- 2026-02-08 a1d93af4 fix: Align hooks with actual Claude Code input format and use lightweight service
+- 2026-02-08 fd8f38af feat: Add real-time progress display for import command
+
+## Sources
+- source: repo-path:src/**
+- source: commit:111f400e73f0568b192a5b1b37a88622fd44d648
+- source: commit:22b1c43d9b9f095cd2a210f529ca8bee5a1100c5
+- source: commit:4bbbc7174f920434cfc67ee02746a9b9824ec101
+- source: commit:504ec3ddd7f451fabf2cf01e073fc96e65ae124e
+- source: commit:d04e562b5b011e0f07cdea0664db823f0caca5d0
+- source: commit:65b0f64da3fd2c4b0b758b89f9d0f22301df23a7
+- source: commit:665cf11bb9a01f1bcba51ec49f53382e95cd7e32
+- source: commit:f35da2b92704d7d1b5655edac3516c64a829eeef
+- source: commit:be36be70f69d42d2373ac26e6c0b8e8b53ca0340
+- source: commit:babfd15284754bc3dbb698fcc4c81efcf53fcd85
+- source: commit:543643e7a9f1d4a94f3216c2369d0212a51ff32d
+- source: commit:794640023652fc38b010e1ab46ca6a9a504a09e8
+- source: commit:20c37b2cdffd271eaf04df9d2e87e5f23a4f853e
+- source: commit:a1d93af414821eb92d74cd02abb748849366ebfb
+- source: commit:fd8f38af7cecf7d31a32a5aba9b1902178f986b1
+
+## 2026-02-25T12:44:49.909Z | c2836359-ecb1-4c15-86ab-42163c79b489
+- type: session_summary
+- session: import:organized
+# Module: tests
+
+- responsibility: inferred from top-level path `tests/`
+- files: 12
+- languages: TypeScript
+- confidence: high
+
+## Entry Candidates
+- none detected
+
+## Related Commits (recent sample)
+- 2026-01-31 111f400e feat: implement complete code-memory plugin
+- 2026-02-09 11d3092e feat: optional MongoDB sync for project events
+- 2026-02-24 d278200d feat(memory): adopt memU-style scoped retrieval and staged ingest hooks
+- 2026-02-24 917ad7fc feat(memory): add append-only markdown mirror for categorized event archives
+- 2026-02-24 72250046 feat: append-only markdown mirror in sqlite ingest flow
+- 2026-02-24 3a34d45a feat(memory): auto-refresh markdown mirror index
+- 2026-02-24 df15146c chore(memory): normalize markdown mirror default category to uncategorized
+- 2026-02-24 0dceb2d9 feat(retrieval): add auto fallback chain fast→deep→scope-expand→summary
+- 2026-02-24 7de02967 feat(ranking): add helpfulness-driven adaptive rerank weights v1
+- 2026-02-24 46f2cfa2 feat(retrieval): add ttl/decay ranking policy v1
+- 2026-02-24 5fd950be feat(retrieval): add intent-rewrite deep retrieval merge flow
+- 2026-02-24 d1dfe03f feat(retrieval): add graph-hop expansion with hop penalty
+- 2026-02-24 7c84b5ea feat(consolidation): add hierarchical summary→rule automation with report
+- 2026-02-25 db38c7e6 Feat/organize import bootstrap kb (#10)
+
+## Sources
+- source: repo-path:tests/**
+- source: commit:111f400e73f0568b192a5b1b37a88622fd44d648
+- source: commit:11d3092e372836f784a760fc0b4269fd44e9159f
+- source: commit:d278200d0f0666616a8556f2f25f9758b3ab9afd
+- source: commit:917ad7fc97a1c2de68637dfbe4b4cdd51776ec30
+- source: commit:72250046152e851ed70476a8704ca38ca633ffab
+- source: commit:3a34d45a594affb034d6e416e3a29b6d2dcc20a5
+- source: commit:df15146c2a8c3e389c1a2b8d6fcfb4a33f7a772d
+- source: commit:0dceb2d914e67e10d140848340f30e6fd07c4f67
+- source: commit:7de02967a1d59aea3e04ef1239585b93828c503a
+- source: commit:46f2cfa2d99f0c8fb3a48709a97f62800f01d4fe
+- source: commit:5fd950beee4d02f00b0c93be668a2e114ce9b257
+- source: commit:d1dfe03f881d1a76ecd9a916cbf04c3ff2a4bf7e
+- source: commit:7c84b5eacff733d8cb692eb9d47b7297a0872e43
+- source: commit:db38c7e606a59478c03bac7e5bb5951954ca0813
+
+## 2026-02-25T12:44:49.916Z | 5b4e83de-4ba2-4475-9b94-47f66c4571d4
+- type: session_summary
+- session: import:organized
+# Module: tsconfig.json
+
+- responsibility: inferred from top-level path `tsconfig.json/`
+- files: 1
+- languages: JSON
+- confidence: low
+
+## Entry Candidates
+- none detected
+
+## Related Commits (recent sample)
+- none in selected range
+
+## Sources
+- source: repo-path:tsconfig.json/**
+
+## 2026-02-25T12:44:49.923Z | baf71944-cc8e-411f-96d2-a861944fe5c4
+- type: session_summary
+- session: import:organized
+# Module: vitest.config.ts
+
+- responsibility: inferred from top-level path `vitest.config.ts/`
+- files: 1
+- languages: TypeScript
+- confidence: low
+
+## Entry Candidates
+- none detected
+
+## Related Commits (recent sample)
+- none in selected range
+
+## Sources
+- source: repo-path:vitest.config.ts/**
+
+## 2026-02-25T12:44:49.931Z | b68be7e7-e001-42ca-be4e-d5c07a37bf0d
+- type: session_summary
+- session: import:organized
+# Codebase Overview
+
+- generatedAt: 2026-02-25T12:44:49.677Z
+- deterministicPipeline: true
+- repo: /home/walter/workspace/opensource/claude-memory-layer
+- filesAnalyzed: 150
+- commitsAnalyzed: 47
+- confidence: high
+
+## Directory / Module Map
+- src: 70 files (TypeScript, JavaScript)
+- specs: 35 files (Markdown)
+- tests: 12 files (TypeScript)
+- .claude-plugin: 8 files (Markdown, JSON)
+- scripts: 6 files (JavaScript, Shell, TypeScript)
+- .omc: 4 files (JSON)
+- docs: 2 files (Markdown)
+- AGENTS.md: 1 files (Markdown)
+- CLAUDE.md: 1 files (Markdown)
+- context.md: 1 files (Markdown)
+- d.sh: 1 files (Shell)
+- deploy.sh: 1 files (Shell)
+- HANDOFF.md: 1 files (Markdown)
+- package-lock.json: 1 files (JSON)
+- package.json: 1 files (JSON)
+- plan.md: 1 files (Markdown)
+- README.md: 1 files (Markdown)
+- spec.md: 1 files (Markdown)
+- tsconfig.json: 1 files (JSON)
+- vitest.config.ts: 1 files (TypeScript)
+
+## Fact
+- Generated from deterministic file scan and git history parsing.
+
+## Inference
+- Module responsibilities should be reviewed by maintainers for nuanced boundaries.
+
+## Sources
+- source: repo-scan:/home/walter/workspace/opensource/claude-memory-layer
+- source: git-log:since=180 days ago;max=1000
+
+## 2026-02-25T12:44:49.939Z | a238e1a3-f03a-415a-b90c-ed2c563c2db2
+- type: session_summary
+- session: import:organized
+# Sources Manifest
+
+- deterministicPipeline: true
+- mode: incremental
+- sourceCount: 197
+
+## Outputs
+- decisions/decisions.md
+- glossary/glossary.md
+- modules/.claude-plugin.md
+- modules/agents.md.md
+- modules/claude.md.md
+- modules/context.md.md
+- modules/docs.md
+- modules/handoff.md.md
+- modules/package-lock.json.md
+- modules/package.json.md
+- modules/plan.md.md
+- modules/readme.md.md
+- modules/scripts.md
+- modules/spec.md.md
+- modules/specs.md
+- modules/src.md
+- modules/tests.md
+- modules/tsconfig.json.md
+- modules/vitest.config.ts.md
+- overview/overview.md
+- timeline/timeline.md
+
+## Sources (sample)
+- file:.claude-plugin/commands/memory-forget.md
+- file:.claude-plugin/commands/memory-history.md
+- file:.claude-plugin/commands/memory-import.md
+- file:.claude-plugin/commands/memory-list.md
+- file:.claude-plugin/commands/memory-search.md
+- file:.claude-plugin/commands/memory-stats.md
+- file:.claude-plugin/hooks.json
+- file:.claude-plugin/plugin.json
+- file:.omc/project-memory.json
+- file:.omc/sessions/9d7106b0-883c-4ad7-b7be-39de88a483e5.json
+- file:.omc/sessions/dccdf47f-f9ef-4621-a49d-f333667baf0a.json
+- file:.omc/state/subagent-tracking.json
+- file:AGENTS.md
+- file:CLAUDE.md
+- file:HANDOFF.md
+- file:README.md
+- file:context.md
+- file:d.sh
+- file:deploy.sh
+- file:docs/MEMU_ADOPTION.md
+- file:docs/OPERATIONS.md
+- file:package-lock.json
+- file:package.json
+- file:plan.md
+- file:scripts/build.ts
+- file:scripts/fix-sync-gap.js
+- file:scripts/heartbeat-memory-orchestrator.sh
+- file:scripts/report-sync-gap.js
+- file:scripts/review-queue-auto-resolve.js
+- file:scripts/sync-gap-auto-heal.sh
+- file:spec.md
+- file:specs/20260207-dashboard-upgrade/context.md
+- file:specs/20260207-dashboard-upgrade/spec.md
+- file:specs/citations-system/context.md
+- file:specs/citations-system/plan.md
+- file:specs/citations-system/spec.md
+- file:specs/endless-mode/context.md
+- file:specs/endless-mode/plan.md
+- file:specs/endless-mode/spec.md
+- file:specs/entity-edge-model/context.md
+- file:specs/entity-edge-model/plan.md
+- file:specs/entity-edge-model/spec.md
+- file:specs/evidence-aligner-v2/context.md
+- file:specs/evidence-aligner-v2/plan.md
+- file:specs/evidence-aligner-v2/spec.md
+- file:specs/mcp-desktop-integration/context.md
+- file:specs/mcp-desktop-integration/plan.md
+- file:specs/mcp-desktop-integration/spec.md
+- file:specs/post-tool-use-hook/context.md
+- file:specs/post-tool-use-hook/plan.md
+- file:specs/post-tool-use-hook/spec.md
+- file:specs/private-tags/context.md
+- file:specs/private-tags/plan.md
+- file:specs/private-tags/spec.md
+- file:specs/progressive-disclosure/context.md
+- file:specs/progressive-disclosure/plan.md
+- file:specs/progressive-disclosure/spec.md
+- file:specs/task-entity-system/context.md
+- file:specs/task-entity-system/plan.md
+- file:specs/task-entity-system/spec.md
+- file:specs/vector-outbox-v2/context.md
+- file:specs/vector-outbox-v2/plan.md
+- file:specs/vector-outbox-v2/spec.md
+- file:specs/web-viewer-ui/context.md
+- file:specs/web-viewer-ui/plan.md
+- file:specs/web-viewer-ui/spec.md
+- file:src/cli/index.ts
+- file:src/core/canonical-key.ts
+- file:src/core/citation-generator.ts
+- file:src/core/consolidated-store.ts
+- file:src/core/consolidation-worker.ts
+- file:src/core/context-formatter.ts
+- file:src/core/continuity-manager.ts
+- file:src/core/db-wrapper.ts
+- file:src/core/edge-repo.ts
+- file:src/core/embedder.ts
+- file:src/core/entity-repo.ts
+- file:src/core/event-store.ts
+- file:src/core/evidence-aligner.ts
+- file:src/core/graduation-worker.ts
+- file:src/core/graduation.ts
+- file:src/core/index.ts
+- file:src/core/ingest-interceptor.ts
+- file:src/core/markdown-mirror.ts
+- file:src/core/matcher.ts
+- file:src/core/md-mirror.ts
+- file:src/core/metadata-extractor.ts
+- file:src/core/mongo-sync-config.ts
+- file:src/core/mongo-sync-worker.ts
+- file:src/core/privacy/filter.ts
+- file:src/core/privacy/index.ts
+- file:src/core/privacy/tag-parser.ts
+- file:src/core/progressive-retriever.ts
+- file:src/core/retriever.ts
+- file:src/core/shared-event-store.ts
+- file:src/core/shared-promoter.ts
+- file:src/core/shared-store.ts
+- file:src/core/shared-vector-store.ts
+- file:src/core/sqlite-event-store.ts
+- file:src/core/sqlite-wrapper.ts
+- file:src/core/sync-worker.ts
+- file:src/core/task/blocker-resolver.ts
+- file:src/core/task/index.ts
+- file:src/core/task/task-matcher.ts
+- file:src/core/task/task-projector.ts
+- file:src/core/task/task-resolver.ts
+- file:src/core/turn-state.ts
+- file:src/core/types.ts
+- file:src/core/vector-outbox.ts
+- file:src/core/vector-store.ts
+- file:src/core/vector-worker.ts
+- file:src/core/working-set-store.ts
+- file:src/hooks/post-tool-use.ts
+- file:src/hooks/session-end.ts
+- file:src/hooks/session-start.ts
+- file:src/hooks/stop.ts
+- file:src/hooks/user-prompt-submit.ts
+- file:src/mcp/handlers.ts
+- file:src/mcp/index.ts
+- file:src/mcp/tools.ts
+- file:src/server/api/chat.ts
+- file:src/server/api/citations.ts
+- file:src/server/api/events.ts
+- file:src/server/api/index.ts
+- file:src/server/api/projects.ts
+- file:src/server/api/search.ts
+- file:src/server/api/sessions.ts
+- file:src/server/api/stats.ts
+- file:src/server/api/turns.ts
+- file:src/server/api/utils.ts
+- file:src/server/index.ts
+- file:src/services/bootstrap-organizer.ts
+- file:src/services/codex-session-history-importer.ts
+- file:src/services/memory-service.ts
+- file:src/services/session-history-importer.ts
+- file:src/ui/app.js
+- file:tests/bootstrap-organizer.test.ts
+- file:tests/canonical-key.test.ts
+- file:tests/consolidation-worker.test.ts
+- file:tests/evidence-aligner.test.ts
+- file:tests/ingest-interceptor.test.ts
+- file:tests/markdown-mirror.test.ts
+- file:tests/matcher.test.ts
+- file:tests/md-mirror.test.ts
+- file:tests/retriever-fallback-chain.test.ts
+- file:tests/retriever-strategy-scope.test.ts
+- file:tests/retriever.memu-adoption.test.ts
+- file:tests/sqlite-event-store-replication.test.ts
+- file:tsconfig.json
+- file:vitest.config.ts
+- commit:09a27030ac03dc003fc725ce1fd360a53ca3159f
+- commit:e0fb3078d786dd6f6a4cd8fac87e547668c04466
+- commit:83614efe2baf9ca3223508daecfff2e55fbf092e
+- commit:111f400e73f0568b192a5b1b37a88622fd44d648
+- commit:22b1c43d9b9f095cd2a210f529ca8bee5a1100c5
+- commit:ead5da9868336e6bb0696fd5ee236bc32c327079
+- commit:03ce3f8393e52df24f86ffc10756d3974204c373
+- commit:4bbbc7174f920434cfc67ee02746a9b9824ec101
+- commit:504ec3ddd7f451fabf2cf01e073fc96e65ae124e
+- commit:3662dfae8381fdf35923b115f58c362e091c474a
+- commit:d04e562b5b011e0f07cdea0664db823f0caca5d0
+- commit:65b0f64da3fd2c4b0b758b89f9d0f22301df23a7
+- commit:665cf11bb9a01f1bcba51ec49f53382e95cd7e32
+- commit:f35da2b92704d7d1b5655edac3516c64a829eeef
+- commit:d4f1f16858e2bf2436f12e4141fedbecf3a75851
+- commit:be36be70f69d42d2373ac26e6c0b8e8b53ca0340
+- commit:babfd15284754bc3dbb698fcc4c81efcf53fcd85
+- commit:543643e7a9f1d4a94f3216c2369d0212a51ff32d
+- commit:a8a8b4edb28a04c1d07abd6e67625f6b68b67b55
+- commit:794640023652fc38b010e1ab46ca6a9a504a09e8
+- commit:20c37b2cdffd271eaf04df9d2e87e5f23a4f853e
+- commit:a1d93af414821eb92d74cd02abb748849366ebfb
+- commit:fd8f38af7cecf7d31a32a5aba9b1902178f986b1
+- commit:938ec34bdf5fe1e4c43274424497ca081d62023a
+- commit:af18cee5277324c78a9e1bca5873bc86ee5b2719
+- commit:5b7401917611b50ee49e38bdf080983d1c763d5e
+- commit:a7b260f0ceeff6d768fefb675e6425f5b4717d7e
+- commit:15547d41e952350d095dfe3c01b2afa749638532
+- commit:78b0956610eb7d22c28a821c67e10e6e9996c5be
+- commit:d56d22ba3271c1d51ea8bbaddb21f5f3d0a79d49
+- commit:11d3092e372836f784a760fc0b4269fd44e9159f
+- commit:4855172b8f92fff0c148c106de4e10c494d2bb09
+- commit:d278200d0f0666616a8556f2f25f9758b3ab9afd
+- commit:4447e64fa00065bfb364d38c597ad87484770891
+- commit:e25f03a7680d82532d10620d3495ac6dc2b67a46
+- commit:917ad7fc97a1c2de68637dfbe4b4cdd51776ec30
+- commit:72250046152e851ed70476a8704ca38ca633ffab
+- commit:3a34d45a594affb034d6e416e3a29b6d2dcc20a5
+- commit:df15146c2a8c3e389c1a2b8d6fcfb4a33f7a772d
+- commit:fe9ef67e5acabb81885a3c752a5b8525f80856a5
+- commit:0dceb2d914e67e10d140848340f30e6fd07c4f67
+- commit:7de02967a1d59aea3e04ef1239585b93828c503a
+- commit:46f2cfa2d99f0c8fb3a48709a97f62800f01d4fe
+- commit:5fd950beee4d02f00b0c93be668a2e114ce9b257
+- commit:d1dfe03f881d1a76ecd9a916cbf04c3ff2a4bf7e
+- commit:7c84b5eacff733d8cb692eb9d47b7297a0872e43
+- commit:db38c7e606a59478c03bac7e5bb5951954ca0813
+
+## 2026-02-25T12:44:49.946Z | 244d330a-f728-4c93-bcfc-93c4096cd3b5
+- type: session_summary
+- session: import:organized
+# Timeline
+
+- confidence: mid
+
+## 2026-01
+- 2026-01-31 09a27030 docs: add specification documents for code-memory plugin
+- 2026-01-31 e0fb3078 docs: enhance AXIOMMIND integration in specification documents
+- 2026-01-31 83614efe docs: add Memory Graduation Pipeline and 7 AXIOMMIND principles
+- 2026-01-31 111f400e feat: implement complete code-memory plugin
+- 2026-01-31 22b1c43d feat: add session history import functionality
+- 2026-01-31 ead5da98 docs: update README with detailed Korean documentation
+- 2026-01-31 03ce3f83 Add implementation guide for AxiomMind Memory Pipeline
+
+## 2026-02
+- 2026-02-01 4bbbc717 Merge pull request #1 from buzzni/claude/idris2-memory-storage-JLk7J
+- 2026-02-01 504ec3dd docs: Add citations and endless mode specification documents (#2)
+- 2026-02-01 3662dfae docs: Update README with comprehensive feature documentation (#3)
+- 2026-02-01 d04e562b feat: Add cross-project shared troubleshooting store
+- 2026-02-01 65b0f64d refactor: Extract DuckDB wrapper for consistent async API
+- 2026-02-01 665cf11b feat: Add web dashboard for memory visualization
+- 2026-02-01 f35da2b9 refactor: Rename project from code-memory to claude-memory-layer
+- 2026-02-01 d4f1f168 docs: Update README for claude-memory-layer rename
+- 2026-02-01 be36be70 feat: Migrate primary store from DuckDB to SQLite (WAL mode)
+- 2026-02-01 babfd152 feat: Enhance dashboard, CLI, and memory graduation system
+- 2026-02-02 543643e7 perf: Add fast keyword search and optimize hook performance
+- 2026-02-06 a8a8b4ed chore: Bump version to 1.0.10 and add project configuration
+- 2026-02-07 79464002 feat: Add memory helpfulness tracking and dashboard sort controls
+- 2026-02-08 20c37b2c feat: Add interactive dashboard with modals, navigation, and detail views
+- 2026-02-08 a1d93af4 fix: Align hooks with actual Claude Code input format and use lightweight service
+- 2026-02-08 fd8f38af feat: Add real-time progress display for import command
+- 2026-02-08 938ec34b feat: Add turn-based event grouping, force reimport, and session registry support
+- 2026-02-08 af18cee5 feat: Add per-project dashboard with project selector and turns API
+- 2026-02-08 5b740191 fix: Handle vector store table race condition and auto-create SQLite directories
+- 2026-02-08 a7b260f0 feat: Add Ask Memory chat service to dashboard
+- 2026-02-08 15547d41 feat: Widen chat panel and add conversation history with localStorage
+- 2026-02-08 78b09566 fix: Knowledge Graph shows data even when no memories have been accessed
+- 2026-02-20 d56d22ba feat(ops): add heartbeat orchestrator and sync-gap auto-heal scripts
+- 2026-02-09 11d3092e feat: optional MongoDB sync for project events
+- 2026-02-22 4855172b feat: add Codex session history importer, MongoDB sync config, and AGENTS.md
+- 2026-02-24 d278200d feat(memory): adopt memU-style scoped retrieval and staged ingest hooks
+- 2026-02-24 4447e64f docs(memory): document memU-inspired retrieval strategies and scoped filters
+- 2026-02-24 e25f03a7 docs(readme): add practical examples for memU-inspired retrieval options
+- 2026-02-24 917ad7fc feat(memory): add append-only markdown mirror for categorized event archives
+- 2026-02-24 72250046 feat: append-only markdown mirror in sqlite ingest flow
+- 2026-02-24 3a34d45a feat(memory): auto-refresh markdown mirror index
+- 2026-02-24 df15146c chore(memory): normalize markdown mirror default category to uncategorized
+- 2026-02-24 fe9ef67e feat(cli): add organize-import command for structured markdown memory import
+- 2026-02-24 0dceb2d9 feat(retrieval): add auto fallback chain fast→deep→scope-expand→summary
+- 2026-02-24 7de02967 feat(ranking): add helpfulness-driven adaptive rerank weights v1
+- 2026-02-24 46f2cfa2 feat(retrieval): add ttl/decay ranking policy v1
+- 2026-02-24 5fd950be feat(retrieval): add intent-rewrite deep retrieval merge flow
+- 2026-02-24 d1dfe03f feat(retrieval): add graph-hop expansion with hop penalty
+- 2026-02-24 7c84b5ea feat(consolidation): add hierarchical summary→rule automation with report
+- 2026-02-25 db38c7e6 Feat/organize import bootstrap kb (#10)
+
+## Sources
+- source: git-log:since=180 days ago;max=1000