claude-memory-layer 1.0.24 → 1.0.25

package/specs/optional-duckdb/context.md

@@ -0,0 +1,77 @@
+# Context: DuckDB 설치 실패 문제
+
+## 에러 요약
+
+`npm install -g claude-memory-layer` 실행 시 특정 환경에서 설치 실패:
+
+```
+npm error code 1
+npm error path .../node_modules/duckdb
+npm error command failed: node-pre-gyp install --fallback-to-build
+npm error node-pre-gyp ERR! install response status 404 Not Found
+  on https://npm.duckdb.org/duckdb/duckdb-v0.10.2-node-v137-darwin-arm64.tar.gz
+npm error gyp ERR! build error (C++ template compile errors)
+```
+
+## 실패 환경
+
+- **OS**: macOS Darwin 25.2.0 (arm64)
+- **Node.js**: v24.13.1 (ABI v137)
+- **duckdb 버전**: 0.10.2 (`^0.10.0`)
+
+## 근본 원인
+
+### 1. Pre-built binary 없음
+`duckdb@0.10.2`는 Node.js v24 (ABI v137)용 pre-built binary를 제공하지 않는다.
+Node.js v24는 2024년 후반에 release된 최신 버전이고, duckdb@0.10.x 시리즈는 이를 지원하지 않는다.
+
+### 2. Source 컴파일 실패
+fallback으로 source 컴파일을 시도하지만, macOS 최신 Clang 컴파일러가
+duckdb@0.10.x의 C++ template syntax를 거부:
+
+```cpp
+// 에러 발생 패턴
+STATE::template ReadValue(...)   // Clang: "template argument list expected"
+OP::template Assign(state, input)
+```
+
+이 C++ 코드는 오래된 컴파일러 표준에서는 동작했지만, 최신 Clang (macOS 26 beta 포함)에서 엄격히 거부됨.
+
+## DuckDB의 역할
+
+코드베이스에서 DuckDB는 **분석 전용** 기능에만 사용:
+- `SyncWorker`: SQLite → DuckDB 데이터 동기화 (30초 간격)
+- `DuckDBAnalyticsStore`: 대시보드 통계 쿼리 (집계, 시계열)
+- 핵심 기능(이벤트 저장, 임베딩, 검색)은 모두 SQLite + LanceDB 사용
+
+## 현재 코드 상태
+
+이미 일부 graceful degradation 코드가 존재:
+```typescript
+// memory-service.ts
+if (this.analyticsStore) {
+  await this.analyticsStore.initialize();
+} catch (error) {
+  console.warn('Analytics store (DuckDB) initialization failed, using SQLite for reads');
+  // Continue without analytics
+}
+```
+
+그러나 **설치 단계**에서 실패하므로 runtime graceful degradation이 무의미.
+
+## 영향 범위
+
+- Node.js v20, v22: 정상 설치 (pre-built binary 존재)
+- Node.js v24+: 설치 실패 (pre-built binary 없음 + 컴파일 실패)
+- 향후 Node.js v25+: 동일 문제 발생 예상
+
+## 관련 파일
+
+| 파일 | 역할 |
+|------|------|
+| `package.json` | `"duckdb": "^0.10.0"` — required dependency |
+| `src/core/db-wrapper.ts` | `import duckdb from 'duckdb'` — top-level import |
+| `src/core/sync-worker.ts` | DuckDB SyncWorker 구현 |
+| `src/core/edge-repo.ts` | DuckDB analytics queries |
+| `src/services/memory-service.ts` | analyticsStore 초기화 및 사용 |
+| `src/server/api/utils.ts` | 대시보드 API에서 DuckDB 사용 |

package/specs/optional-duckdb/plan.md

@@ -0,0 +1,142 @@
+# Plan: DuckDB 완전 제거
+
+## 전략
+
+`duckdb`를 완전히 제거하고 `better-sqlite3`으로 모든 기능을 통합한다.
+`better-sqlite3`은 이미 primary dependency이므로 새 패키지 추가 없음.
+
+---
+
+## 변경 파일 목록
+
+| 파일 | 변경 |
+|------|------|
+| `package.json` | `duckdb` 제거 |
+| `src/core/db-wrapper.ts` | DuckDB API → better-sqlite3 API로 교체 |
+| `src/core/edge-repo.ts` | `Database` 타입 변경 (duckdb → better-sqlite3) |
+| `src/services/memory-service.ts` | analyticsStore / DuckDBAnalyticsStore 관련 코드 제거, SyncWorker 제거 |
+| `src/core/sync-worker.ts` | 파일 삭제 (또는 empty stub) |
+| `src/core/sqlite-event-store.ts` | edges 테이블 CREATE TABLE 추가 (없으면) |
+| `src/server/api/*.ts` | DuckDB analytics 쿼리 → SQLite 직접 쿼리로 교체 |
+
+---
+
+## Step 1: `src/core/db-wrapper.ts` 교체
+
+DuckDB callback API를 better-sqlite3 동기 API로 교체.
+better-sqlite3은 동기 API이므로 Promise wrapping이 간단해짐.
+
+```typescript
+// 변경 전: import duckdb from 'duckdb';
+// 변경 후:
+import Database from 'better-sqlite3';
+export type { Database };
+
+export async function dbRun(db: Database, sql: string, params: unknown[] = []): Promise<void> {
+  db.prepare(sql).run(...params);
+}
+
+export async function dbAll<T>(db: Database, sql: string, params: unknown[] = []): Promise<T[]> {
+  return db.prepare(sql).all(...(params as never[])) as T[];
+}
+```
+
+`toDate()`, `convertBigInts()` 등 유틸은 그대로 유지.
+
+---
+
+## Step 2: Edges 테이블을 SQLite에 추가
+
+`src/core/sqlite-event-store.ts`의 `initialize()` 에서 edges 테이블 생성:
+
+```sql
+CREATE TABLE IF NOT EXISTS edges (
+  edge_id TEXT PRIMARY KEY,
+  src_type TEXT NOT NULL,
+  src_id TEXT NOT NULL,
+  rel_type TEXT NOT NULL,
+  dst_type TEXT NOT NULL,
+  dst_id TEXT NOT NULL,
+  meta_json TEXT DEFAULT '{}',
+  created_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_edges_src ON edges(src_id, rel_type);
+CREATE INDEX IF NOT EXISTS idx_edges_dst ON edges(dst_id, rel_type);
+```
+
+SQLite는 `WITH CTE`, `JOIN`, `GROUP BY` 등 edge-repo의 모든 쿼리를 지원함.
+
+---
+
+## Step 3: `src/services/memory-service.ts` 정리
+
+제거할 것:
+- `DuckDBAnalyticsStore` import 및 인스턴스
+- `SyncWorker` import 및 인스턴스
+- `analyticsStore` 관련 초기화/종료 코드
+- `analyticsEnabled` 옵션 (또는 no-op으로 유지)
+
+EdgeRepo는 SQLite DB (`this.sqliteStore.db`)를 직접 사용하도록 연결.
+
+---
+
+## Step 4: `src/core/sync-worker.ts` 제거
+
+SyncWorker는 SQLite → DuckDB 동기화 전용. DuckDB 제거 시 불필요.
+파일 삭제 또는 empty class로 대체.
+
+---
+
+## Step 5: 대시보드 Analytics API
+
+DuckDB analytics store를 사용하는 서버 API들을 확인하고
+SQLite 직접 쿼리로 교체하거나 `analyticsEnabled: false` 분기를 기본값으로 변경.
+
+---
+
+## Step 6: `package.json`에서 `duckdb` 제거
+
+```json
+// 제거
+"duckdb": "^0.10.0"
+```
+
+---
+
+## 동작 흐름 (After)
+
+```
+npm install -g claude-memory-layer
+  → duckdb 없음 → 빠르고 안정적인 설치 ✅
+
+메모리 저장/조회
+  → SQLite (primary, 변경 없음) ✅
+
+시맨틱 검색
+  → LanceDB (변경 없음) ✅
+
+Edges (task blockers 등)
+  → SQLite (기존 DuckDB 쿼리 그대로, DB만 변경) ✅
+
+대시보드 통계
+  → SQLite 직접 쿼리 ✅
+```
+
+---
+
+## 주의사항
+
+- **기존 DuckDB edges 데이터 손실**: 기존 사용자의 DuckDB edges 데이터는 마이그레이션되지 않음.
+  edges는 task blocker 등 임시적 관계 데이터이므로 손실 허용 가능.
+- **`ON CONFLICT DO NOTHING`**: SQLite와 DuckDB 모두 지원. edge-repo 쿼리 변경 불필요.
+- **better-sqlite3 동기 API**: `dbRun`/`dbAll`을 Promise로 wrapping하면 edge-repo 코드 변경 최소화.
+
+---
+
+## 검증
+
+1. `npm run build` 성공
+2. Node.js v24 환경에서 `npm install` 성공
+3. edges CRUD 동작 확인 (`/api/edges` 등)
+4. 대시보드 API 에러 없음
+5. session-start, user-prompt-submit hooks 정상 동작

package/specs/optional-duckdb/spec.md

@@ -0,0 +1,35 @@
+# Spec: DuckDB 완전 제거 → SQLite로 통합
+
+## 결론
+
+DuckDB를 **완전히 제거**하고 SQLite로 통합할 수 있다.
+
+DuckDB가 하는 일:
+1. **Edges 테이블** — 표준 SQL (INSERT/SELECT/WITH CTE/JOIN). SQLite가 동일하게 지원
+2. **Analytics Store** — SQLite 데이터 복사본. 대부분 `analyticsEnabled: false`로 이미 비활성화됨
+
+`better-sqlite3`은 이미 primary dependency이므로 새 의존성 추가 없음.
+
+## 요구사항
+
+### 기능 요구사항
+
+1. **설치 성공**: Node.js v20, v22, v24+ 모든 버전에서 `npm install -g claude-memory-layer` 성공
+2. **Edges 기능 유지**: `edge-repo.ts`의 모든 쿼리가 SQLite에서 동일하게 동작
+3. **Analytics fallback**: DuckDB analytics store 제거 후 대시보드가 SQLite 직접 쿼리로 동작
+4. **기존 핵심 기능 완전 보존**: 이벤트 저장, 임베딩, 벡터 검색, session/prompt hooks 변경 없음
+5. **SyncWorker 제거**: SQLite → DuckDB sync가 불필요해지므로 삭제
+
+### 비기능 요구사항
+
+- `duckdb` package.json에서 완전 제거
+- `npm run build` 및 TypeScript strict 통과
+- 기존 SQLite DB 데이터 마이그레이션 불필요 (edges 테이블을 SQLite로 이전 — 기존 DuckDB edges 데이터는 버려도 됨)
+
+## 성공 기준
+
+- [ ] `package.json`에서 `duckdb` 제거됨
+- [ ] `npm install -g claude-memory-layer` Node.js v24에서 성공
+- [ ] `npm run build` 통과
+- [ ] edges CRUD 기능 SQLite에서 동작
+- [ ] 대시보드 API 에러 없이 응답

package/src/core/db-wrapper.ts

@@ -1,34 +1,14 @@
 /**
- * DuckDB Promise Wrapper
- * Wraps the callback-based DuckDB API with Promise-based async/await interface
+ * SQLite Database Wrapper
+ * Provides Promise-based interface over better-sqlite3 synchronous API
  */
 
-import duckdb from 'duckdb';
+import BetterSqlite3 from 'better-sqlite3';
 
-export type Database = duckdb.Database;
-
-/**
- * Converts BigInt values to Number in an object
- * DuckDB returns BigInt for COUNT(*) and other aggregate functions
- */
-function convertBigInts<T>(obj: T): T {
-  if (obj === null || obj === undefined) return obj;
-  if (typeof obj === 'bigint') return Number(obj) as unknown as T;
-  if (obj instanceof Date) return obj; // Preserve Date objects
-  if (Array.isArray(obj)) return obj.map(convertBigInts) as unknown as T;
-  if (typeof obj === 'object') {
-    const result: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
-      result[key] = convertBigInts(value);
-    }
-    return result as T;
-  }
-  return obj;
-}
+export type Database = BetterSqlite3.Database;
 
 /**
  * Safely converts a value to a Date object
- * Handles both Date objects and string timestamps from DuckDB
  */
 export function toDate(value: unknown): Date {
   if (value instanceof Date) return value;
@@ -42,78 +22,43 @@ export interface DatabaseOptions {
 }
 
 /**
- * Creates a new DuckDB database with Promise-based API
+ * Creates a new SQLite database connection
  */
-export function createDatabase(path: string, options?: DatabaseOptions): Database {
-  if (options?.readOnly) {
-    return new duckdb.Database(path, { access_mode: 'READ_ONLY' });
-  }
-  return new duckdb.Database(path);
+export function createDatabase(dbPath: string, options?: DatabaseOptions): Database {
+  return new BetterSqlite3(dbPath, { readonly: options?.readOnly });
 }
 
 /**
- * Promisified db.run() - executes a statement that doesn't return rows
+ * Executes a statement that doesn't return rows
  */
 export function dbRun(db: Database, sql: string, params: unknown[] = []): Promise<void> {
-  return new Promise((resolve, reject) => {
-    if (params.length === 0) {
-      db.run(sql, (err: Error | null) => {
-        if (err) reject(err);
-        else resolve();
-      });
-    } else {
-      db.run(sql, ...params, (err: Error | null) => {
-        if (err) reject(err);
-        else resolve();
-      });
-    }
-  });
+  db.prepare(sql).run(...(params as never[]));
+  return Promise.resolve();
 }
 
 /**
- * Promisified db.all() - executes a query and returns all rows
- * Automatically converts BigInt values to Number
+ * Executes a query and returns all rows
  */
 export function dbAll<T = Record<string, unknown>>(
   db: Database,
   sql: string,
   params: unknown[] = []
 ): Promise<T[]> {
-  return new Promise((resolve, reject) => {
-    if (params.length === 0) {
-      db.all(sql, (err: Error | null, rows: T[]) => {
-        if (err) reject(err);
-        else resolve(convertBigInts(rows || []));
-      });
-    } else {
-      db.all(sql, ...params, (err: Error | null, rows: T[]) => {
-        if (err) reject(err);
-        else resolve(convertBigInts(rows || []));
-      });
-    }
-  });
+  return Promise.resolve(db.prepare(sql).all(...(params as never[])) as T[]);
 }
 
 /**
- * Promisified db.close() - closes the database connection
+ * Closes the database connection
  */
 export function dbClose(db: Database): Promise<void> {
-  return new Promise((resolve, reject) => {
-    db.close((err: Error | null) => {
-      if (err) reject(err);
-      else resolve();
-    });
-  });
+  db.close();
+  return Promise.resolve();
 }
 
 /**
- * Promisified db.exec() - executes multiple statements
+ * Executes multiple statements
  */
 export function dbExec(db: Database, sql: string): Promise<void> {
-  return new Promise((resolve, reject) => {
-    db.exec(sql, (err: Error | null) => {
-      if (err) reject(err);
-      else resolve();
-    });
-  });
+  db.exec(sql);
+  return Promise.resolve();
 }

package/src/core/sqlite-event-store.ts

@@ -531,6 +531,30 @@ export class SQLiteEventStore {
     }
   }
 
+  /**
+   * Get session IDs that have events but no session_summary event.
+   * Used to backfill summaries for sessions that ended without Stop hook.
+   */
+  async getSessionsWithoutSummary(currentSessionId: string, limit = 5): Promise<string[]> {
+    await this.initialize();
+    const rows = sqliteAll<{ session_id: string }>(
+      this.db,
+      `SELECT DISTINCT e.session_id
+       FROM events e
+       WHERE e.session_id != ?
+         AND e.event_type != 'session_summary'
+         AND e.session_id NOT IN (
+           SELECT DISTINCT session_id FROM events WHERE event_type = 'session_summary'
+         )
+       GROUP BY e.session_id
+       HAVING COUNT(*) >= 3
+       ORDER BY MAX(e.timestamp) DESC
+       LIMIT ?`,
+      [currentSessionId, limit]
+    );
+    return rows.map((r) => r.session_id);
+  }
+
   /**
    * Get events by session ID
    */

package/src/hooks/post-tool-use.ts

@@ -40,9 +40,33 @@ const ALWAYS_STORE_TOOLS = new Set([
   'Write', 'Edit', 'MultiEdit', 'Agent', 'Task', 'ExitPlanMode'
 ]);
 
+// Keywords that indicate a Bash output is worth storing
+const IMPORTANT_BASH_KEYWORDS = [
+  'error', 'failed', 'exception', 'traceback', 'panic',
+  'warning', 'deprecated',
+  'test passed', 'test failed', 'tests passed', 'tests failed',
+  'coverage', 'assert',
+  'published', 'deployed', 'built successfully', 'build complete',
+  'successfully installed', 'successfully created',
+];
+
+/**
+ * For Bash commands, only store output that is significant:
+ * - Has stderr content
+ * - Contains important keywords (errors, test results, deploy events)
+ * - Output is very long (> 800 chars), indicating meaningful work
+ */
+function isBashSignificant(output: string, response: PostToolUseInput['tool_response']): boolean {
+  if (response?.stderr && response.stderr.trim().length > 20) return true;
+  const lower = output.toLowerCase();
+  if (IMPORTANT_BASH_KEYWORDS.some((kw) => lower.includes(kw))) return true;
+  return output.trim().length > 800;
+}
+
 /**
  * Determine if a tool output is significant enough to store.
  * Always-store tools bypass the length check.
+ * Bash uses keyword-based significance detection.
  * Other tools require non-empty stderr or output length >= minLen.
  */
 function hasSignificantOutput(
@@ -52,6 +76,7 @@ function hasSignificantOutput(
   minLen: number
 ): boolean {
   if (ALWAYS_STORE_TOOLS.has(toolName)) return true;
+  if (toolName === 'Bash') return isBashSignificant(output, response);
   if (response?.stderr && response.stderr.trim().length > 0) return true;
   return output.trim().length >= minLen;
 }

package/src/hooks/session-start.ts

@@ -32,6 +32,10 @@ async function main(): Promise<void> {
     // Start session in memory service
     await memoryService.startSession(input.session_id, input.cwd);
 
+    // Backfill session summaries for recent sessions that ended without Stop hook
+    // (crash, force-close, etc.). Run in background - non-blocking.
+    memoryService.backfillMissingSummaries(input.session_id, 5).catch(() => {});
+
     // Get recent context for this project (now automatically scoped)
     const recentEvents = await memoryService.getRecentEvents(10);
 

package/src/hooks/stop.ts

@@ -136,6 +136,20 @@ async function main(): Promise<void> {
     // Clean up turn state file after processing
     clearTurnState(input.session_id);
 
+    // Evaluate helpfulness of retrieved memories for this session
+    try {
+      await memoryService.evaluateSessionHelpfulness(input.session_id);
+    } catch {
+      // non-critical
+    }
+
+    // Generate session summary from recent events (rule-based, no LLM needed)
+    try {
+      await memoryService.generateSessionSummary(input.session_id);
+    } catch {
+      // non-critical
+    }
+
     // Embeddings enqueued in SQLite - will be processed by vector worker when server runs
     await memoryService.processPendingEmbeddings();
 

package/src/services/memory-service.ts

@@ -10,7 +10,6 @@ import * as crypto from 'crypto';
 
 import { EventStore } from '../core/event-store.js';
 import { SQLiteEventStore } from '../core/sqlite-event-store.js';
-import { SyncWorker } from '../core/sync-worker.js';
 import { VectorStore } from '../core/vector-store.js';
 import { Embedder, getDefaultEmbedder } from '../core/embedder.js';
 import { VectorWorker, createVectorWorker } from '../core/vector-worker.js';
@@ -182,9 +181,6 @@ export function getSessionProject(sessionId: string): SessionRegistryEntry | nul
 export class MemoryService {
   // Primary store: SQLite (WAL mode) - for hooks, always available
   private readonly sqliteStore: SQLiteEventStore;
-  // Analytics store: DuckDB - for server reads (optional, synced from SQLite)
-  private readonly analyticsStore: EventStore | null;
-  private syncWorker: SyncWorker | null = null;
 
   private readonly vectorStore: VectorStore;
   private readonly embedder: Embedder;
@@ -247,32 +243,6 @@ export class MemoryService {
       }
     );
 
-    // Initialize ANALYTICS store: DuckDB (optional, for server reads)
-    // Hooks set analyticsEnabled=false to avoid DuckDB lock conflicts
-    const analyticsEnabled = config.analyticsEnabled ?? this.readOnly; // Default: enabled only for read-only (server)
-
-    if (!analyticsEnabled) {
-      // Hook mode: skip DuckDB entirely to avoid lock conflicts
-      this.analyticsStore = null;
-    } else if (this.readOnly) {
-      // Server mode: try to use DuckDB for analytics, will fallback to SQLite
-      try {
-        this.analyticsStore = new EventStore(
-          path.join(storagePath, 'analytics.duckdb'),
-          { readOnly: true }
-        );
-      } catch {
-        // DuckDB not available, will use SQLite for reads
-        this.analyticsStore = null;
-      }
-    } else {
-      // Writer mode with analytics: create DuckDB for sync target
-      this.analyticsStore = new EventStore(
-        path.join(storagePath, 'analytics.duckdb'),
-        { readOnly: false }
-      );
-    }
-
     this.vectorStore = new VectorStore(path.join(storagePath, 'vectors'));
     const embeddingModel = config.embeddingModel || process.env.CLAUDE_MEMORY_EMBEDDING_MODEL;
     this.embedder = embeddingModel
@@ -306,16 +276,6 @@ export class MemoryService {
       return;
     }
 
-    // Initialize analytics store if available (DuckDB)
-    if (this.analyticsStore) {
-      try {
-        await this.analyticsStore.initialize();
-      } catch (error) {
-        console.warn('[MemoryService] Analytics store (DuckDB) initialization failed, using SQLite for reads:', error);
-        // Continue without analytics - SQLite will be used for reads
-      }
-    }
-
     await this.vectorStore.initialize();
     await this.embedder.initialize();
 
@@ -340,15 +300,6 @@ export class MemoryService {
         );
         this.graduationWorker.start();
 
-        // Start sync worker (SQLite -> DuckDB) if analytics store is available
-        if (this.analyticsStore) {
-          this.syncWorker = new SyncWorker(
-            this.sqliteStore,
-            this.analyticsStore,
-            { intervalMs: 30000, batchSize: 500 }
-          );
-          this.syncWorker.start();
-        }
       }
 
       // Load endless mode setting
@@ -602,6 +553,67 @@ export class MemoryService {
     );
   }
 
+  /**
+   * Backfill session summaries for recent sessions that are missing them.
+   * Called from session-start hook to catch sessions that ended without Stop hook.
+   */
+  async backfillMissingSummaries(currentSessionId: string, limit = 5): Promise<void> {
+    await this.initialize();
+
+    // Get recent sessions that don't have a summary event
+    const recentSessionIds = await this.sqliteStore.getSessionsWithoutSummary(currentSessionId, limit);
+    for (const sid of recentSessionIds) {
+      try {
+        await this.generateSessionSummary(sid);
+      } catch {
+        // non-critical
+      }
+    }
+  }
+
+  /**
+   * Generate a rule-based session summary from stored events.
+   * Called at session end (Stop hook) when no LLM-generated summary exists.
+   * Skips if a summary already exists for this session.
+   */
+  async generateSessionSummary(sessionId: string): Promise<void> {
+    await this.initialize();
+
+    const events = await this.sqliteStore.getSessionEvents(sessionId);
+    if (events.length < 3) return; // Too short to summarize
+
+    // Skip if summary already exists
+    const hasSummary = events.some((e) => e.eventType === 'session_summary');
+    if (hasSummary) return;
+
+    const prompts = events.filter((e) => e.eventType === 'user_prompt');
+    const toolObs = events.filter((e) => e.eventType === 'tool_observation');
+    const toolNames = [...new Set(
+      toolObs.map((e) => (e.metadata as Record<string, unknown>)?.toolName as string).filter(Boolean)
+    )];
+    const errorObs = toolObs.filter((e) => {
+      const meta = e.metadata as Record<string, unknown>;
+      return meta?.exitCode !== undefined && meta.exitCode !== 0;
+    });
+
+    const datePart = events[0].timestamp.toISOString().split('T')[0];
+    const parts: string[] = [`[${datePart}] ${prompts.length}턴 세션.`];
+
+    if (prompts.length > 0) {
+      const firstPrompt = prompts[0].content.slice(0, 120).replace(/\n/g, ' ');
+      parts.push(`주요 작업: ${firstPrompt}`);
+    }
+    if (toolNames.length > 0) {
+      parts.push(`사용 툴: ${toolNames.slice(0, 6).join(', ')}`);
+    }
+    if (errorObs.length > 0) {
+      parts.push(`오류 ${errorObs.length}건 발생`);
+    }
+
+    const summary = parts.join('. ');
+    await this.storeSessionSummary(sessionId, summary, { generated: 'rule-based', eventCount: events.length });
+  }
+
   /**
    * Store a tool observation
    */
@@ -1275,6 +1287,7 @@ export class MemoryService {
     await this.initialize();
     await this.sqliteStore.recordRetrievalTrace({
       ...input,
+      projectHash: this.projectHash || undefined,
       candidateDetails: [],
       selectedDetails: [],
       fallbackTrace: [],
@@ -1652,11 +1665,6 @@ export class MemoryService {
       this.vectorWorker.stop();
     }
 
-    // Stop sync worker
-    if (this.syncWorker) {
-      this.syncWorker.stop();
-    }
-
     // Close shared store
     if (this.sharedEventStore) {
       await this.sharedEventStore.close();
@@ -1665,10 +1673,6 @@ export class MemoryService {
     // Close primary store (SQLite)
     await this.sqliteStore.close();
 
-    // Close analytics store (DuckDB)
-    if (this.analyticsStore) {
-      await this.analyticsStore.close();
-    }
   }
 
   /**