claude-memory-layer 1.0.27 → 1.0.29

package/memory/specs/endless-mode/2026-02-25.md

@@ -1,1392 +0,0 @@
-
-## 2026-02-25T12:31:26.242Z | 63725392-86de-47d8-9f0a-c2b6d8f7420b
-- type: session_summary
-- session: import:organized
-# Endless Mode Context
-
-> **Version**: 1.0.0
-> **Created**: 2026-02-01
-
-## 1. 배경
-
-### 1.1 claude-mem의 접근 방식
-
-claude-mem은 "Endless Mode"를 Beta 기능으로 제공:
-
-```
-Biomimetic Memory Architecture for extended sessions
-```
-
-**특징**:
-- 세션 경계 없는 연속 메모리
-- 자동 컨텍스트 통합
-- 장기 학습 지원
-
-### 1.2 인간 기억 시스템 모방
-
-```
-Human Memory:
-┌─────────────────────────────────────────┐
-│ Sensory → Working → Long-term          │
-│ (즉각)    (단기)    (장기)              │
-└─────────────────────────────────────────┘
-
-Endless Mode:
-┌─────────────────────────────────────────┐
-│ Events → Working Set → Consolidated    │
-│ (L0)     (Active)      (Integrated)    │
-└─────────────────────────────────────────┘
-```
-
-### 1.3 현재 code-memory의 세션 모델
-
-```typescript
-// 현재 세션 기반 모델
-session_start → [conversations] → session_end
-                                      ↓
-                              session_summary
-                                      ↓
-                            (새 세션에서 검색)
-```
-
-**한계**:
-1. 세션 경계에서 컨텍스트 단절
-2. 재시작 시 처음부터 컨텍스트 구축
-3. 장기 프로젝트에서 지식 파편화
-
-## 2. Biomimetic Memory 개념
-
-### 2.1 Working Memory (작업 기억)
-
-인간의 작업 기억:
-- 용량 제한: 7±2 항목
-- 지속 시간: 15-30초
-- 적극적 유지 필요
-
-Endless Mode 적용:
-```typescript
-const workingSet = {
-  maxEvents: 100,           // 용량 제한
-  timeWindowHours: 24,      // 시간 제한
-  activeRehearsal: true     // 관련성 높은 것 유지
-};
-```
-
-### 2.2 Memory Consolidation (기억 통합)
-
-인간의 기억 통합:
-- 수면 중 발생
-- 관련 기억 연결
-- 불필요한 세부사항 제거
-- 패턴 추출
-
-Endless Mode 적용:
-```typescript
-const consolidation = {
-  triggerIdleTime: 30 * 60 * 1000,  // 유휴 시 통합 (수면 유사)
-  groupByTopic: true,                // 관련 기억 그룹화
-  summarize: true,                   // 세부사항 요약
-  extractPatterns: true              // 패턴 추출
-};
-```
-
-### 2.3 Context-Dependent Memory
-
-인간: 특정 맥락에서 관련 기억 활성화
-
-Endless Mode:
-```typescript
-// 현재 컨텍스트와 유사한 과거 컨텍스트 활성화
-const relevantContext = await findSimilarContext(currentQuery);
-```
-
-## 3. 기존 코드와의 관계
-
-### 3.1 Graduation 파이프라인과의 관계
-
-```
-기존 Graduation:
-L0 (Raw) → L1 (Structured) → L2 (Validated) → L3 (Verified) → L4 (Active)
-
-Endless Mode 추가:
-L0 (Raw) → Working Set → Consolidated Memory
-              ↓              ↓
-           (Active)     (Long-term)
-```
-
-**통합 방안**:
-- Working Set은 L0-L2 이벤트 포함
-- Consolidated Memory는 L3-L4 수준의 검증된 지식
-
-### 3.2 Event Store
-
-```typescript
-// 기존: 세션 기반 저장
-await eventStore.append({
-  sessionId: currentSession,
-  ...event
-});
-
-// Endless Mode: 세션 개념 유연화
-await eventStore.append({
-  sessionId: endlessSessionId,  // 고정 또는 날짜 기반
-  workingSetId: currentWorkingSet,
-  ...event
-});
-```
-
-### 3.3 Retriever
-
-```typescript
-// 기존
-async search(query): Promise<Event[]>
-
-// Endless Mode 확장
-async searchWithContext(query, options): Promise<{
-  workingSet: Event[];
-  consolidated: ConsolidatedMemory[];
-  continuityScore: number;
-}>
-```
-
-## 4. 설계 결정 사항
-
-### 4.1 세션 ID 처리
-
-**옵션 1: 고정 세션 ID**
-```typescript
-const ENDLESS_SESSION_ID = 'endless';
-```
-- 단순함
-- 기존 코드 호환
-
-**옵션 2: 날짜 기반 세션 ID**
-```typescript
-const sessionId = `endless_${format(new Date(), 'yyyy-MM-dd')}`;
-```
-- 일별 구분 가능
-- 통계/분석 용이
-
-**선택**: 하이브리드
-- Endless Mode 내부: 날짜 기반
-- 외부 인터페이스: 'endless'로 통합
-
-### 4.2 통합 트리거
-
-**옵션 1: 시간 기반만**
-```typescript
-setInterval(consolidate, 1 * 60 * 60 * 1000);  // 1시간마다
-```
-
-**옵션 2: 이벤트 수 기반만**
-```typescript
-if (workingSet.length >= 100) consolidate();
-```
-
-**옵션 3: 하이브리드 (선택)**
-```typescript
-// 세 가지 조건 중 하나라도 충족 시
-if (
-  timeSinceLastConsolidation >= 1 * 60 * 60 * 1000 ||
-  workingSet.length >= 100 ||
-  idleTime >= 30 * 60 * 1000
-) {
-  consolidate();
-}
-```
-
-### 4.3 요약 생성
-
-**옵션 1: 규칙 기반만**
-```typescript
-// 키포인트 추출
-const summary = events
-  .map(e => extractKeyPoint(e))
-  .join('\n');
-```
-- 빠름, 무료
-- 품질 제한
-
-**옵션 2: LLM 기반**
-```typescript
-const summary = await llm.summarize(events);
-```
-- 고품질
-- 비용, 지연
-
-**선택**: 규칙 기반 기본, LLM 옵션
-```typescript
-if (config.useLLMSummarization) {
-  return await llmSummarize(events);
-} else {
-  return extractKeyPoints(events);
-}
-```
-
-### 4.4 연속성 점수 가중치
-
-```typescript
-const weights = {
-  topicOverlap: 0.3,     // 주제 연속성
-  timeProximity: 0.3,    // 시간 근접성
-  fileOverlap: 0.2,      // 파일 연속성
-  entityOverlap: 0.2     // 엔티티 연속성
-};
-```
-
-**조정 필요 시**:
-- 코드 작업 중심: fileOverlap 가중치 증가
-- 연구/학습 중심: topicOverlap 가중치 증가
-
-## 5. 성능 고려사항
-
-### 5.1 Working Set 크기
-
-```typescript
-// 메모리 사용량 추정
-// 100 이벤트 × 평균 2KB = 200KB
-const maxWorkingSetSize = 100;
-```
-
-### 5.2 Consolidation 비용
-
-```typescript
-// 통합 작업 시간 추정
-// 100 이벤트 그룹화 + 요약: ~100ms
-// LLM 요약 사용 시: ~2s
-```
-
-### 5.3 검색 성능
-
-```typescript
-// Working Set 검색: O(n), n=100, ~1ms
-// Consolidated 검색: 벡터 검색, ~50ms
-```
-
-## 6. 마이그레이션
-
-### 6.1 Session → Endless
-
-```typescript
-async function migrateToEndless(): Promise<void> {
-  // 1. 최근 세션 이벤트를 Working Set에 추가
-  const recentEvents = await getRecentEvents(7 * 24);  // 7일
-
-  for (const event of recentEvents) {
-    await workingSetStore.add(event);
-  }
-
-  // 2. 기존 세션 요약을 Consolidated Memory로 이전
-  const summaries = await getSessionSummaries();
-
-  for (const summary of summaries) {
-    await consolidatedStore.create({
-      summary: summary.content,
-      sourceEvents: [],  // 원본 연결 불가
-      confidence: 0.6    // 낮은 신뢰도
-    });
-  }
-}
-```
-
-### 6.2 Endless → Session 복귀
-
-```typescript
-async function revertToSession(): Promise<void> {
-  // 모드만 변경, 데이터 유지
-  await setConfig('mode', 'session');
-
-  // Working Set과 Consolidated Memory는 유지
-  // (향후 Endless Mode 재활성화 시 활용)
-}
-```
-
-## 7. 참고 자료
-
-- **claude-mem Beta**: Endless Mode, Biomimetic Memory Architecture
-- **Cognitive Psychology**: Working Memory (Baddeley), Memory Consolidation
-- **Spaced Repetition**: 장기 기억 강화 기법
-- **기존 specs**: graduation.ts, vector-worker.ts
-
-## 2026-02-25T12:31:26.249Z | e6bf3d45-f6e0-4002-aef0-0d04c819b4c9
-- type: session_summary
-- session: import:organized
-# Endless Mode Implementation Plan
-
-> **Version**: 1.0.0
-> **Status**: Draft
-> **Created**: 2026-02-01
-
-## Phase 1: 기본 구조 (P0)
-
-### 1.1 설정 스키마
-
-**파일**: `src/core/types.ts` 수정
-
-```typescript
-export const MemoryModeSchema = z.enum(['session', 'endless']);
-export type MemoryMode = z.infer<typeof MemoryModeSchema>;
-
-export const EndlessModeConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-
-  workingSet: z.object({
-    maxEvents: z.number().default(100),
-    timeWindowHours: z.number().default(24),
-    minRelevanceScore: z.number().default(0.5)
-  }).default({}),
-
-  consolidation: z.object({
-    triggerIntervalMs: z.number().default(3600000),
-    triggerEventCount: z.number().default(100),
-    triggerIdleMs: z.number().default(1800000),
-    useLLMSummarization: z.boolean().default(false)
-  }).default({}),
-
-  continuity: z.object({
-    minScoreForSeamless: z.number().default(0.7),
-    topicDecayHours: z.number().default(48)
-  }).default({})
-});
-
-// ConfigSchema 확장
-export const ConfigSchema = z.object({
-  // ... 기존 설정
-  mode: MemoryModeSchema.default('session'),
-  endless: EndlessModeConfigSchema.optional()
-});
-```
-
-**작업 항목**:
-- [ ] MemoryModeSchema 추가
-- [ ] EndlessModeConfigSchema 추가
-- [ ] ConfigSchema 확장
-
-### 1.2 DB 스키마
-
-**파일**: `src/core/event-store.ts` 수정
-
-```typescript
-private async initSchema(): Promise<void> {
-  // 기존 테이블...
-
-  // Working Set 테이블
-  await this.db.exec(`
-    CREATE TABLE IF NOT EXISTS working_set (
-      id VARCHAR PRIMARY KEY,
-      event_id VARCHAR NOT NULL,
-      added_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-      relevance_score FLOAT DEFAULT 1.0,
-      topics JSON,
-      expires_at TIMESTAMP
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_working_set_expires
-      ON working_set(expires_at);
-    CREATE INDEX IF NOT EXISTS idx_working_set_relevance
-      ON working_set(relevance_score DESC);
-  `);
-
-  // Consolidated Memory 테이블
-  await this.db.exec(`
-    CREATE TABLE IF NOT EXISTS consolidated_memories (
-      memory_id VARCHAR PRIMARY KEY,
-      summary TEXT NOT NULL,
-      topics JSON,
-      source_events JSON,
-      confidence FLOAT DEFAULT 0.5,
-      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-      accessed_at TIMESTAMP,
-      access_count INTEGER DEFAULT 0
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_consolidated_confidence
-      ON consolidated_memories(confidence DESC);
-  `);
-
-  // Continuity Log 테이블
-  await this.db.exec(`
-    CREATE TABLE IF NOT EXISTS continuity_log (
-      log_id VARCHAR PRIMARY KEY,
-      from_context_id VARCHAR,
-      to_context_id VARCHAR,
-      continuity_score FLOAT,
-      transition_type VARCHAR,
-      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-    );
-  `);
-}
-```
-
-**작업 항목**:
-- [ ] working_set 테이블 생성
-- [ ] consolidated_memories 테이블 생성
-- [ ] continuity_log 테이블 생성
-- [ ] 인덱스 생성
-
-## Phase 2: Working Set 관리 (P0)
-
-### 2.1 Working Set Store
-
-**파일**: `src/core/working-set-store.ts` (신규)
-
-```typescript
-export class WorkingSetStore {
-  constructor(private db: Database, private config: EndlessModeConfig) {}
-
-  async add(event: Event): Promise<void> {
-    const expiresAt = new Date(
-      Date.now() + this.config.workingSet.timeWindowHours * 60 * 60 * 1000
-    );
-
-    await this.db.run(`
-      INSERT OR REPLACE INTO working_set (id, event_id, added_at, expires_at)
-      VALUES (?, ?, ?, ?)
-    `, [crypto.randomUUID(), event.eventId, new Date(), expiresAt]);
-
-    // 크기 제한 적용
-    await this.enforceLimit();
-  }
-
-  async get(): Promise<WorkingSet> {
-    // 만료된 항목 정리
-    await this.db.run(`
-      DELETE FROM working_set WHERE expires_at < datetime('now')
-    `);
-
-    const items = await this.db.all(`
-      SELECT ws.*, e.*
-      FROM working_set ws
-      JOIN events e ON ws.event_id = e.event_id
-      ORDER BY ws.relevance_score DESC, ws.added_at DESC
-      LIMIT ?
-    `, [this.config.workingSet.maxEvents]);
-
-    return {
-      recentEvents: items.map(i => i as Event),
-      lastActivity: items[0]?.added_at || new Date(),
-      continuityScore: await this.calculateContinuityScore()
-    };
-  }
-
-  private async enforceLimit(): Promise<void> {
-    await this.db.run(`
-      DELETE FROM working_set
-      WHERE id NOT IN (
-        SELECT id FROM working_set
-        ORDER BY relevance_score DESC, added_at DESC
-        LIMIT ?
-      )
-    `, [this.config.workingSet.maxEvents]);
-  }
-
-  private async calculateContinuityScore(): Promise<number> {
-    // 최근 연속성 로그 기반 계산
-    const log = await this.db.get(`
-      SELECT AVG(continuity_score) as avg_score
-      FROM continuity_log
-      WHERE created_at > datetime('now', '-1 hour')
-    `);
-
-    return log?.avg_score || 0.5;
-  }
-}
-```
-
-**작업 항목**:
-- [ ] WorkingSetStore 클래스 구현
-- [ ] add 메서드
-- [ ] get 메서드
-- [ ] enforceLimit 메서드
-- [ ] calculateContinuityScore 메서드
-
-### 2.2 훅 연동
-
-**파일**: `src/hooks/stop.ts` 수정
-
-```typescript
-export async function handleStop(input: StopInput): Promise<void> {
-  const memoryService = await MemoryService.getInstance();
-  const config = await memoryService.getConfig();
-
-  // 이벤트 저장 (기존)
-  const eventId = await memoryService.storeResponse(input);
-
-  // Endless Mode: Working Set에 추가
-  if (config.mode === 'endless') {
-    await memoryService.addToWorkingSet(eventId);
-  }
-}
-```
-
-**작업 항목**:
-- [ ] stop 훅에서 Working Set 연동
-- [ ] user-prompt-submit 훅에서 Working Set 연동
-- [ ] post-tool-use 훅에서 Working Set 연동
-
-## Phase 3: Consolidation Worker (P1)
-
-### 3.1 Worker 구현
-
-**파일**: `src/core/consolidation-worker.ts` (신규)
-
-```typescript
-export class ConsolidationWorker {
-  private running = false;
-  private timeout: NodeJS.Timeout | null = null;
-
-  constructor(
-    private workingSetStore: WorkingSetStore,
-    private consolidatedStore: ConsolidatedStore,
-    private config: EndlessModeConfig
-  ) {}
-
-  start(): void {
-    if (this.running) return;
-    this.running = true;
-    this.scheduleNext();
-  }
-
-  stop(): void {
-    this.running = false;
-    if (this.timeout) {
-      clearTimeout(this.timeout);
-      this.timeout = null;
-    }
-  }
-
-  private scheduleNext(): void {
-    this.timeout = setTimeout(
-      () => this.run(),
-      this.config.consolidation.triggerIntervalMs
-    );
-  }
-
-  private async run(): Promise<void> {
-    if (!this.running) return;
-
-    try {
-      await this.checkAndConsolidate();
-    } catch (error) {
-      console.error('Consolidation error:', error);
-    }
-
-    this.scheduleNext();
-  }
-
-  private async checkAndConsolidate(): Promise<void> {
-    const workingSet = await this.workingSetStore.get();
-
-    if (!this.shouldConsolidate(workingSet)) {
-      return;
-    }
-
-    // 그룹화
-    const groups = this.groupByTopic(workingSet.recentEvents);
-
-    // 각 그룹 통합
-    for (const group of groups) {
-      if (group.events.length >= 3) {  // 최소 3개 이벤트
-        const summary = await this.summarize(group);
-
-        await this.consolidatedStore.create({
-          summary,
-          topics: group.topics,
-          sourceEvents: group.events.map(e => e.eventId),
-          confidence: this.calculateConfidence(group)
-        });
-      }
-    }
-
-    // Working Set 정리 (통합된 이벤트 제거)
-    await this.workingSetStore.prune(groups.flatMap(g => g.events));
-  }
-
-  private shouldConsolidate(workingSet: WorkingSet): boolean {
-    return workingSet.recentEvents.length >= this.config.consolidation.triggerEventCount;
-  }
-
-  private groupByTopic(events: Event[]): EventGroup[] {
-    // 간단한 키워드 기반 그룹화
-    const groups = new Map<string, EventGroup>();
-
-    for (const event of events) {
-      const topics = extractTopics(event.payload.content);
-
-      for (const topic of topics) {
-        if (!groups.has(topic)) {
-          groups.set(topic, { topics: [topic], events: [] });
-        }
-        groups.get(topic)!.events.push(event);
-      }
-    }
-
-    return Array.from(groups.values());
-  }
-
-  private async summarize(group: EventGroup): Promise<string> {
-    // 규칙 기반 요약
-    const keyPoints = group.events
-      .map(e => extractKeyPoint(e.payload.content))
-      .filter(Boolean);
-
-    return keyPoints.join('\n- ');
-  }
-
-  private calculateConfidence(group: EventGroup): number {
-    // 이벤트 수, 시간 근접성, 토픽 일관성 기반
-    const eventScore = Math.min(group.events.length / 10, 1);
-    const timeScore = calculateTimeProximity(group.events);
-
-    return (eventScore + timeScore) / 2;
-  }
-}
-```
-
-**작업 항목**:
-- [ ] ConsolidationWorker 클래스 구현
-- [ ] 스케줄링 로직
-- [ ] 그룹화 로직
-- [ ] 요약 생성
-- [ ] 신뢰도 계산
-
-### 3.2 Consolidated Store
-
-**파일**: `src/core/consolidated-store.ts` (신규)
-
-```typescript
-export class ConsolidatedStore {
-  constructor(private db: Database) {}
-
-  async create(memory: ConsolidatedMemoryInput): Promise<string> {
-    const memoryId = crypto.randomUUID();
-
-    await this.db.run(`
-      INSERT INTO consolidated_memories
-        (memory_id, summary, topics, source_events, confidence)
-      VALUES (?, ?, ?, ?, ?)
-    `, [
-      memoryId,
-      memory.summary,
-      JSON.stringify(memory.topics),
-      JSON.stringify(memory.sourceEvents),
-      memory.confidence
-    ]);
-
-    return memoryId;
-  }
-
-  async search(query: string, options?: { topK?: number }): Promise<ConsolidatedMemory[]> {
-    // 벡터 검색 또는 FTS
-    return this.db.all(`
-      SELECT * FROM consolidated_memories
-      WHERE summary LIKE ?
-      ORDER BY confidence DESC
-      LIMIT ?
-    `, [`%${query}%`, options?.topK || 5]);
-  }
-
-  async markAccessed(memoryId: string): Promise<void> {
-    await this.db.run(`
-      UPDATE consolidated_memories
-      SET accessed_at = datetime('now'),
-          access_count = access_count + 1
-      WHERE memory_id = ?
-    `, [memoryId]);
-  }
-}
-```
-
-**작업 항목**:
-- [ ] ConsolidatedStore 클래스 구현
-- [ ] create 메서드
-- [ ] search 메서드
-- [ ] markAccessed 메서드
-
-## Phase 4: 컨텍스트 연속성 (P1)
-
-### 4.1 연속성 계산
-
-**파일**: `src/core/continuity-manager.ts` (신규)
-
-```typescript
-export class ContinuityManager {
-  constructor(
-    private db: Database,
-    private config: EndlessModeConfig
-  ) {}
-
-  async calculateScore(
-    currentContext: ContextSnapshot,
-    previousContext: ContextSnapshot
-  ): Promise<ContinuityScore> {
-    let score = 0;
-
-    // 토픽 연속성 (30%)
-    const topicOverlap = this.calculateOverlap(
-      currentContext.topics,
-      previousContext.topics
-    );
-    score += topicOverlap * 0.3;
-
-    // 파일 연속성 (20%)
-    const fileOverlap = this.calculateOverlap(
-      currentContext.files,
-      previousContext.files
-    );
-    score += fileOverlap * 0.2;
-
-    // 시간 근접성 (30%)
-    const timeDiff = currentContext.timestamp - previousContext.timestamp;
-    const timeScore = Math.exp(-timeDiff / (this.config.continuity.topicDecayHours * 3600000));
-    score += timeScore * 0.3;
-
-    // 엔티티 연속성 (20%)
-    const entityOverlap = this.calculateOverlap(
-      currentContext.entities,
-      previousContext.entities
-    );
-    score += entityOverlap * 0.2;
-
-    // 전환 타입 결정
-    const transitionType = this.determineTransitionType(score);
-
-    // 로그 저장
-    await this.logTransition(currentContext, previousContext, score, transitionType);
-
-    return { score, transitionType };
-  }
-
-  private calculateOverlap(a: string[], b: string[]): number {
-    if (a.length === 0 || b.length === 0) return 0;
-    const intersection = a.filter(x => b.includes(x));
-    return intersection.length / Math.max(a.length, b.length);
-  }
-
-  private determineTransitionType(score: number): TransitionType {
-    if (score >= this.config.continuity.minScoreForSeamless) {
-      return 'seamless';
-    } else if (score >= 0.4) {
-      return 'topic_shift';
-    } else {
-      return 'break';
-    }
-  }
-
-  private async logTransition(
-    current: ContextSnapshot,
-    previous: ContextSnapshot,
-    score: number,
-    type: TransitionType
-  ): Promise<void> {
-    await this.db.run(`
-      INSERT INTO continuity_log
-        (log_id, from_context_id, to_context_id, continuity_score, transition_type)
-      VALUES (?, ?, ?, ?, ?)
-    `, [crypto.randomUUID(), previous.id, current.id, score, type]);
-  }
-}
-```
-
-**작업 항목**:
-- [ ] ContinuityManager 클래스 구현
-- [ ] calculateScore 메서드
-- [ ] logTransition 메서드
-- [ ] 전환 타입 결정 로직
-
-### 4.2 컨텍스트 주입
-
-**파일**: `src/hooks/user-prompt-submit.ts` 수정
-
-```typescript
-async function handleUserPromptSubmit(input: UserPromptInput): Promise<HookOutput> {
-  const memoryService = await MemoryService.getInstance();
-  const config = await memoryService.getConfig();
-
-  if (config.mode === 'endless') {
-    return await handleEndlessMode(input, memoryService);
-  } else {
-    return await handleSessionMode(input, memoryService);
-  }
-}
-
-async function handleEndlessMode(
-  input: UserPromptInput,
-  memoryService: MemoryService
-): Promise<HookOutput> {
-  // Working Set에서 관련 컨텍스트
-  const workingSet = await memoryService.getWorkingSet();
-
-  // Consolidated Memory에서 검색
-  const consolidated = await memoryService.searchConsolidated(
-    input.prompt,
-    { topK: 3 }
-  );
-
-  // 연속성 점수
-  const continuityScore = workingSet.continuityScore;
-
-  // 컨텍스트 포맷팅
-  const context = formatEndlessContext({
-    workingSet: workingSet.recentEvents.slice(0, 10),
-    consolidated,
-    continuityScore
-  });
-
-  return {
-    context,
-    meta: {
-      mode: 'endless',
-      continuityScore,
-      workingSetSize: workingSet.recentEvents.length
-    }
-  };
-}
-```
-
-**작업 항목**:
-- [ ] Endless Mode 전용 컨텍스트 주입
-- [ ] Working Set + Consolidated 조합
-- [ ] 연속성 점수 포함
-
-## Phase 5: CLI 및 UI (P1)
-
-### 5.1 CLI 명령
-
-**파일**: `src/cli/commands/endless.ts` (신규)
-
-```typescript
-export const endlessCommand = new Command('endless')
-  .description('Manage Endless Mode');
-
-endlessCommand
-  .command('enable')
-  .description('Enable Endless Mode')
-  .action(async () => {
-    const memoryService = await MemoryService.getInstance();
-    await memoryService.setMode('endless');
-    await memoryService.initializeEndlessMode();
-    console.log('✓ Endless Mode enabled');
-  });
-
-endlessCommand
-  .command('disable')
-  .description('Disable Endless Mode (return to Session Mode)')
-  .action(async () => {
-    const memoryService = await MemoryService.getInstance();
-    await memoryService.setMode('session');
-    console.log('✓ Returned to Session Mode');
-  });
-
-endlessCommand
-  .command('status')
-  .description('Show Endless Mode status')
-  .action(async () => {
-    const memoryService = await MemoryService.getInstance();
-    const status = await memoryService.getEndlessStatus();
-
-    console.log(`Mode: ${status.mode}`);
-    console.log(`Working Set: ${status.workingSetSize} events`);
-    console.log(`Continuity Score: ${status.continuityScore.toFixed(2)}`);
-    console.log(`Consolidated: ${status.consolidatedCount} memories`);
-  });
-```
-
-**작업 항목**:
-- [ ] enable 명령
-- [ ] disable 명령
-- [ ] status 명령
-- [ ] consolidate 수동 트리거 명령
-
-## 파일 목록
-
-### 신규 파일
-```
-src/core/working-set-store.ts     # Working Set 저장소
-src/core/consolidated-store.ts    # Consolidated Memory 저장소
-src/core/consolidation-worker.ts  # 통합 워커
-src/core/continuity-manager.ts    # 연속성 관리
-src/cli/commands/endless.ts       # CLI 명령
-```
-
-### 수정 파일
-```
-src/core/types.ts                 # 스키마 추가
-src/core/event-store.ts           # 테이블 추가
-src/services/memory-service.ts    # Endless Mode 메서드
-src/hooks/user-prompt-submit.ts   # 컨텍스트 주입
-src/hooks/stop.ts                 # Working Set 연동
-```
-
-## 마일스톤
-
-| 단계 | 완료 기준 |
-|------|----------|
-| M1 | 스키마 및 테이블 정의 |
-| M2 | Working Set Store 구현 |
-| M3 | Consolidated Store 구현 |
-| M4 | Consolidation Worker 구현 |
-| M5 | 연속성 관리 구현 |
-| M6 | 훅 연동 |
-| M7 | CLI 명령 |
-| M8 | Web Viewer 대시보드 |
-| M9 | 테스트 및 튜닝 |
-
-## 2026-02-25T12:31:26.257Z | 3f96ee3a-8c28-49c4-93c2-c8be8577f2fb
-- type: session_summary
-- session: import:organized
-# Endless Mode Specification
-
-> **Version**: 1.0.0
-> **Status**: Draft
-> **Created**: 2026-02-01
-> **Reference**: claude-mem (thedotmack/claude-mem)
-
-## 1. 개요
-
-### 1.1 문제 정의
-
-현재 세션 기반 메모리의 한계:
-
-1. **세션 경계**: 세션이 끝나면 컨텍스트 단절
-2. **재시작 비용**: 새 세션마다 컨텍스트 재구성 필요
-3. **연속성 부족**: 장기 프로젝트에서 연속적 학습 어려움
-
-### 1.2 해결 방향
-
-**Endless Mode (연속 세션)**:
-- 세션 경계 없는 연속적 메모리 스트림
-- Biomimetic Memory Architecture (생체 모방 기억 구조)
-- 자동 컨텍스트 연속성 유지
-
-## 2. 핵심 개념
-
-### 2.1 Biomimetic Memory Architecture
-
-인간 기억 시스템에서 영감:
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                  Human Memory Model                          │
-├─────────────────────────────────────────────────────────────┤
-│  Sensory Memory → Working Memory → Long-term Memory         │
-│  (즉각적)          (단기)            (장기)                   │
-└─────────────────────────────────────────────────────────────┘
-                              ↓
-┌─────────────────────────────────────────────────────────────┐
-│                  Endless Mode Memory                         │
-├─────────────────────────────────────────────────────────────┤
-│  Event Stream → Active Context → Consolidated Memory        │
-│  (L0 Events)    (Working Set)    (L4 Memories)              │
-└─────────────────────────────────────────────────────────────┘
-```
-
-### 2.2 세션 vs Endless
-
-| 기존 세션 모드 | Endless Mode |
-|---------------|-------------|
-| 명확한 시작/끝 | 연속적 스트림 |
-| 세션별 요약 | 점진적 통합 |
-| 재시작 시 빈 상태 | 이전 컨텍스트 유지 |
-| session_end 훅 | 백그라운드 통합 |
-
-### 2.3 모드 전환
-
-```typescript
-enum MemoryMode {
-  SESSION = 'session',     // 기존 세션 기반
-  ENDLESS = 'endless'      // 연속 모드
-}
-```
-
-## 3. 아키텍처
-
-### 3.1 레이어 구조
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│  Layer 0: Event Stream (Raw)                                 │
-│  - 모든 이벤트 즉시 기록                                      │
-│  - 변환/필터 없음                                             │
-│  - TTL: 무제한                                               │
-└──────────────────────────────────────────┬──────────────────┘
-                                           │
-                                     (Background)
-                                           │
-┌──────────────────────────────────────────▼──────────────────┐
-│  Layer 1: Working Set (Active Context)                       │
-│  - 최근 N개 이벤트                                           │
-│  - 현재 작업 관련 메모리                                      │
-│  - TTL: 24시간 (sliding)                                     │
-└──────────────────────────────────────────┬──────────────────┘
-                                           │
-                                     (Consolidation)
-                                           │
-┌──────────────────────────────────────────▼──────────────────┐
-│  Layer 2: Consolidated Memory (Long-term)                    │
-│  - 통합/요약된 지식                                          │
-│  - 패턴 및 인사이트                                          │
-│  - TTL: 무제한                                               │
-└─────────────────────────────────────────────────────────────┘
-```
-
-### 3.2 Working Set 관리
-
-```typescript
-interface WorkingSet {
-  // 최근 이벤트
-  recentEvents: Event[];          // 최근 100개
-  recentTimeWindow: number;       // 최근 24시간
-
-  // 활성 컨텍스트
-  activeTopics: Topic[];          // 현재 다루는 주제
-  activeFiles: string[];          // 최근 접근 파일
-  activeEntities: Entity[];       // 관련 엔티티
-
-  // 메타데이터
-  lastActivity: Date;
-  continuityScore: number;        // 연속성 점수
-}
-```
-
-### 3.3 Consolidation Process
-
-```typescript
-interface ConsolidationConfig {
-  // 트리거 조건
-  triggerInterval: number;        // 1시간마다
-  triggerEventCount: number;      // 100개 이벤트마다
-  triggerIdleTime: number;        // 30분 유휴 후
-
-  // 통합 규칙
-  minEventsToConsolidate: number; // 최소 10개
-  maxConsolidatedSize: number;    // 최대 1000자 요약
-  preserveHighConfidence: boolean;// 고신뢰도 원본 유지
-}
-```
-
-## 4. 컨텍스트 연속성
-
-### 4.1 연속성 점수
-
-```typescript
-function calculateContinuityScore(
-  currentContext: Context,
-  previousContext: Context
-): number {
-  let score = 0;
-
-  // 주제 연속성
-  const topicOverlap = intersection(
-    currentContext.topics,
-    previousContext.topics
-  ).length;
-  score += topicOverlap * 0.3;
-
-  // 파일 연속성
-  const fileOverlap = intersection(
-    currentContext.files,
-    previousContext.files
-  ).length;
-  score += fileOverlap * 0.2;
-
-  // 시간 근접성
-  const timeDiff = currentContext.timestamp - previousContext.timestamp;
-  const timeScore = Math.exp(-timeDiff / (24 * 60 * 60 * 1000));
-  score += timeScore * 0.3;
-
-  // 엔티티 연속성
-  const entityOverlap = intersection(
-    currentContext.entities,
-    previousContext.entities
-  ).length;
-  score += entityOverlap * 0.2;
-
-  return Math.min(score, 1.0);
-}
-```
-
-### 4.2 컨텍스트 주입
-
-```typescript
-async function injectEndlessContext(
-  currentPrompt: string
-): Promise<string> {
-  const workingSet = await getWorkingSet();
-
-  // 연속성 점수 기반 컨텍스트 선택
-  const relevantContext = workingSet.recentEvents
-    .filter(e => e.relevanceScore >= 0.7)
-    .slice(0, 10);
-
-  // 통합된 메모리에서 관련 항목
-  const consolidatedContext = await searchConsolidatedMemory(
-    currentPrompt,
-    { topK: 3 }
-  );
-
-  return formatEndlessContext({
-    workingSet: relevantContext,
-    consolidated: consolidatedContext,
-    continuityScore: workingSet.continuityScore
-  });
-}
-```
-
-## 5. 통합 (Consolidation) 프로세스
-
-### 5.1 자동 통합
-
-```typescript
-class ConsolidationWorker {
-  private running = false;
-
-  async start(): Promise<void> {
-    this.running = true;
-
-    while (this.running) {
-      await this.checkAndConsolidate();
-      await sleep(this.config.triggerInterval);
-    }
-  }
-
-  private async checkAndConsolidate(): Promise<void> {
-    const workingSet = await getWorkingSet();
-
-    // 트리거 조건 확인
-    if (this.shouldConsolidate(workingSet)) {
-      await this.consolidate(workingSet);
-    }
-  }
-
-  private shouldConsolidate(workingSet: WorkingSet): boolean {
-    // 이벤트 수 기준
-    if (workingSet.recentEvents.length >= this.config.triggerEventCount) {
-      return true;
-    }
-
-    // 유휴 시간 기준
-    const idleTime = Date.now() - workingSet.lastActivity.getTime();
-    if (idleTime >= this.config.triggerIdleTime) {
-      return true;
-    }
-
-    return false;
-  }
-
-  private async consolidate(workingSet: WorkingSet): Promise<void> {
-    // 1. 관련 이벤트 그룹화
-    const groups = groupByTopic(workingSet.recentEvents);
-
-    // 2. 각 그룹 요약
-    for (const group of groups) {
-      const summary = await summarizeGroup(group);
-
-      // 3. 통합 메모리에 저장
-      await storeConsolidatedMemory({
-        summary,
-        sourceEvents: group.map(e => e.eventId),
-        topics: group.topics,
-        confidence: calculateGroupConfidence(group)
-      });
-    }
-
-    // 4. Working Set 정리
-    await pruneWorkingSet(workingSet);
-  }
-}
-```
-
-### 5.2 요약 생성
-
-```typescript
-async function summarizeGroup(events: Event[]): Promise<string> {
-  // 옵션 1: 로컬 규칙 기반
-  if (events.length < 5) {
-    return extractKeyPoints(events);
-  }
-
-  // 옵션 2: LLM 기반 (비용 발생)
-  if (config.useLLMSummarization) {
-    return await llmSummarize(events);
-  }
-
-  // 옵션 3: 하이브리드
-  const keyPoints = extractKeyPoints(events);
-  return formatSummary(keyPoints);
-}
-```
-
-## 6. 데이터 스키마
-
-### 6.1 Working Set 테이블
-
-```sql
-CREATE TABLE working_set (
-  id VARCHAR PRIMARY KEY,
-  event_id VARCHAR NOT NULL REFERENCES events(event_id),
-  added_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-  relevance_score FLOAT,
-  topics JSON,
-  expires_at TIMESTAMP
-);
-
-CREATE INDEX idx_working_set_expires ON working_set(expires_at);
-CREATE INDEX idx_working_set_relevance ON working_set(relevance_score DESC);
-```
-
-### 6.2 Consolidated Memory 테이블
-
-```sql
-CREATE TABLE consolidated_memories (
-  memory_id VARCHAR PRIMARY KEY,
-  summary TEXT NOT NULL,
-  topics JSON,
-  source_events JSON,         -- 원본 이벤트 ID 목록
-  confidence FLOAT,
-  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-  accessed_at TIMESTAMP,
-  access_count INTEGER DEFAULT 0
-);
-
-CREATE INDEX idx_consolidated_confidence ON consolidated_memories(confidence DESC);
-```
-
-### 6.3 Continuity Log 테이블
-
-```sql
-CREATE TABLE continuity_log (
-  log_id VARCHAR PRIMARY KEY,
-  from_context_id VARCHAR,
-  to_context_id VARCHAR,
-  continuity_score FLOAT,
-  transition_type VARCHAR,    -- 'seamless' | 'topic_shift' | 'break'
-  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-```
-
-## 7. 설정
-
-### 7.1 Endless Mode 설정
-
-```typescript
-const EndlessModeConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-
-  workingSet: z.object({
-    maxEvents: z.number().default(100),
-    timeWindowHours: z.number().default(24),
-    minRelevanceScore: z.number().default(0.5)
-  }),
-
-  consolidation: z.object({
-    triggerIntervalMs: z.number().default(3600000),  // 1시간
-    triggerEventCount: z.number().default(100),
-    triggerIdleMs: z.number().default(1800000),      // 30분
-    useLLMSummarization: z.boolean().default(false)
-  }),
-
-  continuity: z.object({
-    minScoreForSeamless: z.number().default(0.7),
-    topicDecayHours: z.number().default(48)
-  })
-});
-```
-
-### 7.2 모드 전환
-
-```bash
-# Endless Mode 활성화
-$ code-memory config set mode endless
-
-# Session Mode로 복귀
-$ code-memory config set mode session
-
-# 현재 모드 확인
-$ code-memory config get mode
-```
-
-## 8. UI 표시
-
-### 8.1 CLI 상태
-
-```
-$ code-memory status
-
-Mode: Endless
-Working Set: 47 events (last 18 hours)
-Continuity Score: 0.85 (seamless)
-Consolidated: 23 memories
-Last Consolidation: 2 hours ago
-
-Active Topics:
-  - DuckDB schema design
-  - Event sourcing pattern
-  - TypeScript types
-
-Recent Files:
-  - src/core/event-store.ts
-  - src/core/types.ts
-```
-
-### 8.2 Web Viewer
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│  Endless Mode Dashboard                                      │
-├─────────────────────────────────────────────────────────────┤
-│                                                              │
-│  ┌─────────────────┐  ┌─────────────────┐                   │
-│  │ Continuity      │  │ Working Set     │                   │
-│  │    0.85         │  │    47 events    │                   │
-│  │  ████████░░     │  │    18 hours     │                   │
-│  │  Seamless       │  └─────────────────┘                   │
-│  └─────────────────┘                                         │
-│                                                              │
-│  Timeline (Continuous)                                       │
-│  ──────────────────────────────────────────────────────────│
-│  │    │    │    │    │    │    │    │    │    │    │      │
-│  └────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘      │
-│  -24h                    -12h                     now       │
-│                                                              │
-│  Consolidated Memories (23)                                  │
-│  ─────────────────────────────────────────────────────────  │
-│  📝 DuckDB 스키마 설계 결정 (confidence: 0.92)               │
-│  📝 이벤트 소싱 패턴 구현 (confidence: 0.88)                 │
-│  📝 타입 시스템 리팩토링 (confidence: 0.85)                  │
-│                                                              │
-└─────────────────────────────────────────────────────────────┘
-```
-
-## 9. 마이그레이션
-
-### 9.1 Session → Endless 전환
-
-```typescript
-async function migrateToEndless(): Promise<void> {
-  // 1. 기존 세션 데이터 유지
-  // 2. Working Set 초기화
-  const recentSessions = await getRecentSessions(7);  // 최근 7일
-
-  for (const session of recentSessions) {
-    const events = await getSessionEvents(session.id);
-    await addToWorkingSet(events);
-  }
-
-  // 3. 초기 통합 실행
-  await runInitialConsolidation();
-
-  // 4. 모드 변경
-  await setConfig('mode', 'endless');
-}
-```
-
-## 10. 성공 기준
-
-- [ ] Endless Mode 활성화/비활성화 전환 가능
-- [ ] Working Set이 24시간 슬라이딩 윈도우로 유지
-- [ ] 자동 Consolidation이 백그라운드에서 실행
-- [ ] 연속성 점수가 정확히 계산됨
-- [ ] 세션 재시작 시 이전 컨텍스트 자동 로드
-- [ ] Web Viewer에서 Endless Mode 대시보드 표시
-- [ ] 기존 Session Mode와 호환 유지