claude-memory-layer 1.0.11 → 1.0.12

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

@@ -0,0 +1,1392 @@
+
+## 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와 호환 유지