claude-memory-layer 1.0.27 → 1.0.28

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

@@ -1,4839 +0,0 @@
-
-## 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