memento-mcp-server 1.12.0 → 1.13.0-a

package/dist/tools/remember-tool.js

@@ -17,6 +17,8 @@ import { KnowledgeVaultService } from '../services/knowledge-vault-service.js';
 import { validateTypeParam } from '../utils/type-param-validator.js';
 import { mementoConfig } from '../config/index.js';
 import { RelationExtractor } from '../services/relation-extractor.js';
+import { validateReflectionNotes, formatValidationErrors } from '../utils/reflection-notes-schema.js';
+import { mergeReflectionNotes, serializeReflectionNotes } from '../utils/reflection-notes-merge.js';
 const RememberSchema = z.object({
     content: CommonSchemas.Content,
     type: CommonSchemas.MemoryType.optional(), // optional - validateTypeParam에서 기본값 처리
@@ -123,126 +125,286 @@ export class RememberTool extends BaseTool {
             required: [] // 조건부 필수는 Zod 스키마에서 검증
         });
     }
-    async handle(params, context) {
-        const { content, type: rawType, key, value, always_load, immutable, task_goal, steps, reflection_notes, tags, importance, source, privacy_scope } = RememberSchema.parse(params);
-        // type 파라미터 롤아웃 모드 검증
-        const typeParamMode = mementoConfig.typeParamMode;
-        const typeValidation = validateTypeParam(rawType, typeParamMode, 'remember');
-        // 에러 모드인 경우 에러 발생
-        if (!typeValidation.isValid) {
-            throw new Error(typeValidation.message || "type 파라미터는 필수입니다.");
+    /**
+     * reflection_notes 파라미터의 JSON 형식 및 스키마 검증
+     * 단일 객체 또는 배열 형식 모두 허용
+     *
+     * @param reflectionNotes - 검증할 reflection_notes 문자열
+     * @throws Error - JSON 형식이 유효하지 않거나 스키마 검증 실패 시
+     */
+    validateReflectionNotesJson(reflectionNotes) {
+        const validationResult = validateReflectionNotes(reflectionNotes);
+        if (!validationResult.isValid) {
+            const errorMessage = formatValidationErrors(validationResult);
+            throw new Error(`reflection_notes 스키마 검증 실패:\n${errorMessage}`);
         }
-        // 경고/Deprecation 메시지 출력
-        if (typeValidation.message) {
-            if (typeParamMode === 'warn') {
-                this.logWarning(typeValidation.message);
-            }
-            else if (typeParamMode === 'deprecate') {
-                this.logWarning(typeValidation.message);
+    }
+    /**
+     * 같은 task_goal을 가진 기존 procedural memory 레코드의 reflection_notes 조회
+     *
+     * @param db - 데이터베이스 인스턴스
+     * @param taskGoal - 작업 목표
+     * @returns 기존 reflection_notes 조회 결과
+     */
+    async getExistingReflectionNotes(db, taskGoal) {
+        // task_goal이 제공되지 않은 경우 조회 불가
+        if (!taskGoal) {
+            return {
+                exists: false,
+                type: 'null',
+                value: null,
+                rawValue: null
+            };
+        }
+        try {
+            // 같은 task_goal을 가진 가장 최근 procedural memory 레코드 조회
+            const existingRecord = DatabaseUtils.get(db, `SELECT reflection_notes FROM memory_item 
+         WHERE type = 'procedural' AND task_goal = ? 
+         ORDER BY created_at DESC LIMIT 1`, [taskGoal]);
+            if (!existingRecord || !existingRecord.reflection_notes) {
+                return {
+                    exists: false,
+                    type: 'null',
+                    value: null,
+                    rawValue: null
+                };
             }
+            // reflection_notes 파싱 및 타입 확인
+            return this.parseReflectionNotes(existingRecord.reflection_notes);
+        }
+        catch (error) {
+            // 조회 실패 시 빈 결과 반환
+            this.logWarning(`기존 reflection_notes 조회 실패: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                exists: false,
+                type: 'null',
+                value: null,
+                rawValue: null
+            };
         }
-        // type 파라미터 결정 (제공된 값 또는 기본값)
-        const type = (rawType || typeValidation.defaultType || 'episodic');
-        // 데이터베이스 연결 확인
-        this.validateDatabase(context);
-        // origin_source 생성 (JSON 형식)
-        const origin_source = JSON.stringify({
-            tool: 'remember',
-            caller: 'user',
-            timestamp: new Date().toISOString(),
-            context: {
-                type,
-                has_content: !!content,
-                has_key: !!key,
-                has_value: !!value,
-                type_param_mode: typeParamMode,
-                type_was_defaulted: !rawType
+    }
+    /**
+     * reflection_notes 문자열을 파싱하고 타입 확인
+     * NULL, 단일 객체, 배열 케이스 처리
+     *
+     * @param reflectionNotes - 파싱할 reflection_notes 문자열
+     * @returns 파싱 결과
+     */
+    parseReflectionNotes(reflectionNotes) {
+        if (!reflectionNotes || reflectionNotes.trim() === '') {
+            return {
+                exists: true,
+                type: 'null',
+                value: null,
+                rawValue: null
+            };
+        }
+        try {
+            const parsed = JSON.parse(reflectionNotes);
+            if (Array.isArray(parsed)) {
+                return {
+                    exists: true,
+                    type: 'array',
+                    value: parsed,
+                    rawValue: reflectionNotes
+                };
             }
-        });
-        // type에 따른 분기 처리
-        if (type === 'core') {
-            // Core Memory 저장
-            if (!key || !value) {
-                throw new Error("type='core'일 때는 key와 value가 필수입니다");
+            if (typeof parsed === 'object' && parsed !== null) {
+                return {
+                    exists: true,
+                    type: 'object',
+                    value: parsed,
+                    rawValue: reflectionNotes
+                };
             }
-            const coreMemoryRepository = new CoreMemoryRepository(context.db);
-            const { getCoreMemoryCache } = await import('../services/core-memory-cache-service.js');
-            const coreMemoryCache = getCoreMemoryCache();
-            const coreMemoryService = new CoreMemoryService(coreMemoryRepository, coreMemoryCache);
-            const agent_id = 'default'; // TODO: 향후 context에서 가져오기
-            const record = await coreMemoryService.create({
-                agent_id,
-                key,
-                value,
-                always_load: always_load || false,
-                origin_source
-            });
-            return this.createSuccessResult({
-                memory_id: record.core_id,
-                type: 'core',
-                key: record.key,
-                value: record.value,
-                always_load: record.always_load,
-                message: `Core Memory가 저장되었습니다: ${record.core_id}`
-            });
+            // 객체나 배열이 아닌 경우
+            return {
+                exists: true,
+                type: 'null',
+                value: null,
+                rawValue: reflectionNotes
+            };
+        }
+        catch (error) {
+            // 파싱 실패 시 원본 문자열 반환
+            this.logWarning(`reflection_notes 파싱 실패: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                exists: true,
+                type: 'null',
+                value: null,
+                rawValue: reflectionNotes
+            };
         }
-        else if (type === 'vault') {
-            // Knowledge Vault 저장
-            if (!key || !value) {
-                throw new Error("type='vault'일 때는 key와 value가 필수입니다");
+    }
+    async handle(params, context) {
+        const startTime = Date.now();
+        try {
+            const { content, type: rawType, key, value, always_load, immutable, task_goal, steps, reflection_notes, tags, importance, source, privacy_scope } = RememberSchema.parse(params);
+            // type 파라미터 롤아웃 모드 검증
+            const typeParamMode = mementoConfig.typeParamMode;
+            const typeValidation = validateTypeParam(rawType, typeParamMode, 'remember');
+            // 에러 모드인 경우 에러 발생
+            if (!typeValidation.isValid) {
+                throw new Error(typeValidation.message || "type 파라미터는 필수입니다.");
             }
-            const knowledgeVaultRepository = new KnowledgeVaultRepository(context.db);
-            const knowledgeVaultService = new KnowledgeVaultService(knowledgeVaultRepository);
-            const agent_id = 'default'; // TODO: 향후 context에서 가져오기
-            const record = await knowledgeVaultService.create({
-                agent_id,
-                key,
-                value,
-                immutable: immutable !== false, // 기본값 true
-                origin_source
-            });
-            return this.createSuccessResult({
-                memory_id: record.vault_id,
-                type: 'vault',
-                key: record.key,
-                value: record.value,
-                immutable: record.immutable,
-                message: `Knowledge Vault가 저장되었습니다: ${record.vault_id}`
+            // 경고/Deprecation 메시지 출력
+            if (typeValidation.message) {
+                if (typeParamMode === 'warn') {
+                    this.logWarning(typeValidation.message);
+                }
+                else if (typeParamMode === 'deprecate') {
+                    this.logWarning(typeValidation.message);
+                }
+            }
+            // type 파라미터 결정 (제공된 값 또는 기본값)
+            const type = (rawType || typeValidation.defaultType || 'episodic');
+            // reflection_notes JSON 검증 (type='procedural'이고 reflection_notes가 제공된 경우에만)
+            if (type === 'procedural' && reflection_notes !== undefined && reflection_notes !== null) {
+                this.validateReflectionNotesJson(reflection_notes);
+            }
+            // 데이터베이스 연결 확인
+            this.validateDatabase(context);
+            // origin_source 생성 (JSON 형식)
+            const origin_source = JSON.stringify({
+                tool: 'remember',
+                caller: 'user',
+                timestamp: new Date().toISOString(),
+                context: {
+                    type,
+                    has_content: !!content,
+                    has_key: !!key,
+                    has_value: !!value,
+                    type_param_mode: typeParamMode,
+                    type_was_defaulted: !rawType
+                }
             });
-        }
-        else {
-            // 기존 memory_item 저장 (episodic, semantic, procedural, working)
-            if (!content) {
-                throw new Error("type이 'core' 또는 'vault'가 아닐 때는 content가 필수입니다");
+            // type에 따른 분기 처리
+            if (type === 'core') {
+                // Core Memory 저장
+                if (!key || !value) {
+                    throw new Error("type='core'일 때는 key와 value가 필수입니다");
+                }
+                const coreMemoryRepository = new CoreMemoryRepository(context.db);
+                const { getCoreMemoryCache } = await import('../services/core-memory-cache-service.js');
+                const coreMemoryCache = getCoreMemoryCache();
+                const coreMemoryService = new CoreMemoryService(coreMemoryRepository, coreMemoryCache);
+                const agent_id = 'default'; // TODO: 향후 context에서 가져오기
+                const record = await coreMemoryService.create({
+                    agent_id,
+                    key,
+                    value,
+                    always_load: always_load || false,
+                    origin_source
+                });
+                return this.createSuccessResult({
+                    memory_id: record.core_id,
+                    type: 'core',
+                    key: record.key,
+                    value: record.value,
+                    always_load: record.always_load,
+                    message: `Core Memory가 저장되었습니다: ${record.core_id}`
+                });
             }
-            // 타입 가드로 검증
-            if (!isMemoryItemType(type)) {
-                throw new Error(`Invalid memory type: ${type}`);
+            else if (type === 'vault') {
+                // Knowledge Vault 저장
+                if (!key || !value) {
+                    throw new Error("type='vault'일 때는 key와 value가 필수입니다");
+                }
+                const knowledgeVaultRepository = new KnowledgeVaultRepository(context.db);
+                const knowledgeVaultService = new KnowledgeVaultService(knowledgeVaultRepository);
+                const agent_id = 'default'; // TODO: 향후 context에서 가져오기
+                const record = await knowledgeVaultService.create({
+                    agent_id,
+                    key,
+                    value,
+                    immutable: immutable !== false, // 기본값 true
+                    origin_source
+                });
+                return this.createSuccessResult({
+                    memory_id: record.vault_id,
+                    type: 'vault',
+                    key: record.key,
+                    value: record.value,
+                    immutable: record.immutable,
+                    message: `Knowledge Vault가 저장되었습니다: ${record.vault_id}`
+                });
             }
-            // UUID 생성 (임시로 간단한 ID 사용)
-            const id = `mem_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-            try {
-                // 메모리 저장 (트랜잭션 사용)
-                await DatabaseUtils.runTransaction(context.db, async () => {
-                    // Consolidation Score System 초기화 값 설정
-                    const createdAt = new Date().toISOString();
-                    const recallCount = mementoConfig.consolidationScoreEnabled ? 1 : 0; // 기능 활성화 시 1, 비활성화 시 0
-                    const gValue = mementoConfig.consolidationScoreEnabled ? 1.0 : null; // 기능 활성화 시 1.0, 비활성화 시 NULL
-                    const lastAccessedAt = mementoConfig.consolidationScoreEnabled ? createdAt : null; // 기능 활성화 시 created_at과 동일, 비활성화 시 NULL
-                    // consolidation_score 계산 (기능 활성화 시)
-                    let consolidationScore = null;
-                    if (mementoConfig.consolidationScoreEnabled && context.services.consolidationScoreService) {
-                        const scoreResult = context.services.consolidationScoreService.calculateScore({
-                            recallCount: 1,
-                            lastAccessedAt: new Date(createdAt),
-                            createdAt: new Date(createdAt),
-                            gValue: 1.0,
-                            type: type,
-                            pinned: false
-                        });
-                        consolidationScore = scoreResult.score;
+            else {
+                // 기존 memory_item 저장 (episodic, semantic, procedural, working)
+                if (!content) {
+                    throw new Error("type이 'core' 또는 'vault'가 아닐 때는 content가 필수입니다");
+                }
+                // 타입 가드로 검증
+                if (!isMemoryItemType(type)) {
+                    throw new Error(`Invalid memory type: ${type}`);
+                }
+                // reflection_notes 처리
+                // type='procedural'이고 reflection_notes가 제공된 경우 기존 reflection_notes 조회 및 병합
+                // non-procedural 타입에서는 reflection_notes를 무시 (PRD: "Procedural Memory에서만 사용 가능")
+                let finalReflectionNotes = null;
+                if (type === 'procedural' && reflection_notes !== undefined && reflection_notes !== null) {
+                    // procedural 타입: 기존 reflection_notes 조회 및 병합
+                    finalReflectionNotes = reflection_notes;
+                    const existingReflectionNotes = await this.getExistingReflectionNotes(context.db, task_goal);
+                    // 기존 reflection_notes가 있는 경우 병합
+                    if (existingReflectionNotes.exists) {
+                        try {
+                            // 병합 유틸리티 함수 사용
+                            const existing = existingReflectionNotes.type === 'null' ? { type: 'null', value: null } :
+                                existingReflectionNotes.type === 'object' ? { type: 'object', value: existingReflectionNotes.value } :
+                                    { type: 'array', value: existingReflectionNotes.value };
+                            const mergeResult = mergeReflectionNotes(existing, reflection_notes);
+                            // 병합 결과를 JSON 문자열로 변환
+                            finalReflectionNotes = serializeReflectionNotes(mergeResult.merged);
+                            // 경고 메시지 처리
+                            if (mergeResult.warnings.length > 0) {
+                                mergeResult.warnings.forEach(warning => {
+                                    this.logWarning(`reflection_notes 병합 경고: ${warning}`);
+                                });
+                            }
+                            if (mergeResult.removedCount > 0) {
+                                this.logWarning(`reflection_notes 크기 제한으로 인해 ${mergeResult.removedCount}개 항목이 제거되었습니다`);
+                            }
+                        }
+                        catch (error) {
+                            // 병합 실패 시 에러 처리
+                            const errorMessage = error instanceof Error ? error.message : String(error);
+                            // 단일 객체 크기 초과 같은 경우는 에러를 던짐 (검증 단계에서 이미 처리되어야 하지만 안전장치)
+                            if (errorMessage.includes('최대') && errorMessage.includes('바이트')) {
+                                throw new Error(`reflection_notes 크기 제한 초과: ${errorMessage}. ` +
+                                    `단일 객체는 최대 10KB, 전체 필드는 최대 1MB를 초과할 수 없습니다.`);
+                            }
+                            // 기타 병합 실패 시 원본 reflection_notes 사용 (경고 로그)
+                            this.logWarning(`reflection_notes 병합 실패, 원본 값 사용: ${errorMessage}. ` +
+                                `기존 reflection_notes는 유지되고 새 reflection_notes만 저장됩니다.`);
+                        }
                     }
-                    await DatabaseUtils.run(context.db, `
+                }
+                // non-procedural 타입에서는 reflection_notes를 무시 (null로 설정)
+                // UUID 생성 (임시로 간단한 ID 사용)
+                const id = `mem_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+                try {
+                    // 메모리 저장 (트랜잭션 사용)
+                    await DatabaseUtils.runTransaction(context.db, async () => {
+                        // Consolidation Score System 초기화 값 설정
+                        const createdAt = new Date().toISOString();
+                        const recallCount = mementoConfig.consolidationScoreEnabled ? 1 : 0; // 기능 활성화 시 1, 비활성화 시 0
+                        const gValue = mementoConfig.consolidationScoreEnabled ? 1.0 : null; // 기능 활성화 시 1.0, 비활성화 시 NULL
+                        const lastAccessedAt = mementoConfig.consolidationScoreEnabled ? createdAt : null; // 기능 활성화 시 created_at과 동일, 비활성화 시 NULL
+                        // consolidation_score 계산 (기능 활성화 시)
+                        let consolidationScore = null;
+                        if (mementoConfig.consolidationScoreEnabled && context.services.consolidationScoreService) {
+                            const scoreResult = context.services.consolidationScoreService.calculateScore({
+                                recallCount: 1,
+                                lastAccessedAt: new Date(createdAt),
+                                createdAt: new Date(createdAt),
+                                gValue: 1.0,
+                                type: type,
+                                pinned: false
+                            });
+                            consolidationScore = scoreResult.score;
+                        }
+                        await DatabaseUtils.run(context.db, `
             INSERT INTO memory_item (
               id, type, content, importance, privacy_scope, tags, source, origin_source, 
               task_goal, steps, reflection_notes, created_at,
@@ -250,72 +412,116 @@ export class RememberTool extends BaseTool {
             )
             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
           `, [
-                        id,
-                        type,
-                        content,
-                        importance,
-                        privacy_scope,
-                        tags ? JSON.stringify(tags) : null,
-                        source || null,
-                        origin_source,
-                        task_goal || null,
-                        steps || null,
-                        reflection_notes || null,
-                        createdAt,
-                        recallCount,
-                        lastAccessedAt,
-                        gValue,
-                        consolidationScore
-                    ]);
-                });
-                // 메모리 저장 완료 후 임베딩 생성, 인접 기억 갱신, 관계 추출 (비동기, 실패해도 메모리 저장은 성공)
-                // 데이터베이스 참조를 미리 저장하여 비동기 콜백에서 안전하게 사용
-                const dbRef = context.db;
-                const embeddingServiceRef = context.services.embeddingService;
-                const savedMemoryId = id; // 클로저에서 사용할 수 있도록 저장
-                const savedMemoryType = type; // 클로저에서 사용할 수 있도록 저장
-                if (dbRef) {
-                    // 비동기 작업을 별도로 실행 (fire-and-forget 패턴)
-                    // 메모리 저장 응답은 즉시 반환하고, 임베딩/인접 기억 갱신/관계 추출은 백그라운드에서 처리
-                    (async () => {
-                        try {
-                            // 트랜잭션이 완전히 커밋되도록 짧은 지연
-                            await new Promise(resolve => setTimeout(resolve, 100));
-                            // 데이터베이스 연결이 여전히 유효한지 확인 (간단한 쿼리로 테스트)
-                            // DatabaseUtils.get은 동기 함수이지만, 비동기 컨텍스트에서 안전하게 실행하기 위해 Promise로 감싸서 await
+                            id,
+                            type,
+                            content,
+                            importance,
+                            privacy_scope,
+                            tags ? JSON.stringify(tags) : null,
+                            source || null,
+                            origin_source,
+                            task_goal || null,
+                            steps || null,
+                            finalReflectionNotes,
+                            createdAt,
+                            recallCount,
+                            lastAccessedAt,
+                            gValue,
+                            consolidationScore
+                        ]);
+                    });
+                    // 메모리 저장 완료 후 임베딩 생성, 인접 기억 갱신, 관계 추출 (비동기, 실패해도 메모리 저장은 성공)
+                    // 데이터베이스 참조를 미리 저장하여 비동기 콜백에서 안전하게 사용
+                    const dbRef = context.db;
+                    const embeddingServiceRef = context.services.embeddingService;
+                    const savedMemoryId = id; // 클로저에서 사용할 수 있도록 저장
+                    const savedMemoryType = type; // 클로저에서 사용할 수 있도록 저장
+                    if (dbRef) {
+                        // 비동기 작업을 별도로 실행 (fire-and-forget 패턴)
+                        // 메모리 저장 응답은 즉시 반환하고, 임베딩/인접 기억 갱신/관계 추출은 백그라운드에서 처리
+                        (async () => {
                             try {
-                                await new Promise((resolve, reject) => {
+                                // 트랜잭션이 완전히 커밋되도록 짧은 지연
+                                await new Promise(resolve => setTimeout(resolve, 100));
+                                // 데이터베이스 연결이 여전히 유효한지 확인 (간단한 쿼리로 테스트)
+                                // DatabaseUtils.get은 동기 함수이지만, 비동기 컨텍스트에서 안전하게 실행하기 위해 Promise로 감싸서 await
+                                try {
+                                    await new Promise((resolve, reject) => {
+                                        try {
+                                            DatabaseUtils.get(dbRef, 'SELECT 1');
+                                            resolve();
+                                        }
+                                        catch (error) {
+                                            reject(error);
+                                        }
+                                    });
+                                }
+                                catch (dbError) {
+                                    this.logWarning('데이터베이스 연결이 유효하지 않아 백그라운드 작업을 건너뜁니다', {
+                                        memory_id: savedMemoryId,
+                                        error: dbError instanceof Error ? dbError.message : String(dbError)
+                                    });
+                                    return;
+                                }
+                                // 임베딩 생성 (embeddingService가 사용 가능한 경우에만)
+                                let embeddingResult = null;
+                                if (embeddingServiceRef?.isAvailable()) {
                                     try {
-                                        DatabaseUtils.get(dbRef, 'SELECT 1');
-                                        resolve();
+                                        embeddingResult = await embeddingServiceRef.createAndStoreEmbedding(dbRef, savedMemoryId, content, savedMemoryType);
                                     }
                                     catch (error) {
-                                        reject(error);
+                                        // 임베딩 생성 실패해도 메모리 저장은 성공했으므로 경고만 출력
+                                        this.logWarning(`임베딩 생성 실패 (${savedMemoryId})`, {
+                                            error: error instanceof Error ? error.message : String(error)
+                                        });
                                     }
-                                });
-                            }
-                            catch (dbError) {
-                                this.logWarning('데이터베이스 연결이 유효하지 않아 백그라운드 작업을 건너뜁니다', {
-                                    memory_id: savedMemoryId,
-                                    error: dbError instanceof Error ? dbError.message : String(dbError)
-                                });
-                                return;
-                            }
-                            // 임베딩 생성 (embeddingService가 사용 가능한 경우에만)
-                            let embeddingResult = null;
-                            if (embeddingServiceRef?.isAvailable()) {
-                                try {
-                                    embeddingResult = await embeddingServiceRef.createAndStoreEmbedding(dbRef, savedMemoryId, content, savedMemoryType);
                                 }
-                                catch (error) {
-                                    // 임베딩 생성 실패해도 메모리 저장은 성공했으므로 경고만 출력
-                                    this.logWarning(`임베딩 생성 실패 (${savedMemoryId})`, {
-                                        error: error instanceof Error ? error.message : String(error)
-                                    });
+                                // PRD 3.1-3.3: 인접 기억 갱신 (임베딩이 생성된 경우에만)
+                                if (embeddingResult && embeddingServiceRef) {
+                                    try {
+                                        // 데이터베이스 연결 재확인
+                                        let dbValid = false;
+                                        try {
+                                            await new Promise((resolve, reject) => {
+                                                try {
+                                                    DatabaseUtils.get(dbRef, 'SELECT 1');
+                                                    resolve();
+                                                }
+                                                catch (error) {
+                                                    reject(error);
+                                                }
+                                            });
+                                            dbValid = true;
+                                        }
+                                        catch (dbError) {
+                                            this.logWarning('데이터베이스 연결이 유효하지 않아 인접 기억 갱신을 건너뜁니다', {
+                                                memory_id: savedMemoryId,
+                                                error: dbError instanceof Error ? dbError.message : String(dbError)
+                                            });
+                                        }
+                                        if (dbValid) {
+                                            const vectorSearchEngine = getVectorSearchEngine();
+                                            const neighborService = new MemoryNeighborService(vectorSearchEngine, embeddingServiceRef);
+                                            neighborService.setDatabase(dbRef);
+                                            // 인접 기억 갱신 (기본 유사도 임계값: 0.8)
+                                            const neighborIds = await neighborService.updateNeighborsForNewMemory(savedMemoryId, 0.8);
+                                            if (neighborIds.length > 0) {
+                                                this.logInfo('인접 기억 갱신 완료', {
+                                                    memory_id: savedMemoryId,
+                                                    neighbor_count: neighborIds.length
+                                                });
+                                            }
+                                        }
+                                    }
+                                    catch (error) {
+                                        // 인접 기억 갱신 실패해도 메모리 저장은 성공했으므로 경고만 출력
+                                        this.logWarning(`인접 기억 갱신 실패 (${savedMemoryId})`, {
+                                            error: error instanceof Error ? error.message : String(error)
+                                        });
+                                    }
                                 }
-                            }
-                            // PRD 3.1-3.3: 인접 기억 갱신 (임베딩이 생성된 경우에만)
-                            if (embeddingResult && embeddingServiceRef) {
+                                // PRD 2.12: 관계 추출 트리거 (비동기 배치 처리)
+                                // 임베딩 생성 여부와 관계없이 관계 추출 수행 (규칙 기반 추출은 임베딩 불필요)
                                 try {
                                     // 데이터베이스 연결 재확인
                                     let dbValid = false;
@@ -332,138 +538,104 @@ export class RememberTool extends BaseTool {
                                         dbValid = true;
                                     }
                                     catch (dbError) {
-                                        this.logWarning('데이터베이스 연결이 유효하지 않아 인접 기억 갱신을 건너뜁니다', {
+                                        this.logWarning('데이터베이스 연결이 유효하지 않아 관계 추출을 건너뜁니다', {
                                             memory_id: savedMemoryId,
                                             error: dbError instanceof Error ? dbError.message : String(dbError)
                                         });
                                     }
                                     if (dbValid) {
-                                        const vectorSearchEngine = getVectorSearchEngine();
-                                        const neighborService = new MemoryNeighborService(vectorSearchEngine, embeddingServiceRef);
-                                        neighborService.setDatabase(dbRef);
-                                        // 인접 기억 갱신 (기본 유사도 임계값: 0.8)
-                                        const neighborIds = await neighborService.updateNeighborsForNewMemory(savedMemoryId, 0.8);
-                                        if (neighborIds.length > 0) {
-                                            this.logInfo('인접 기억 갱신 완료', {
-                                                memory_id: savedMemoryId,
-                                                neighbor_count: neighborIds.length
-                                            });
+                                        // 기존 기억들 조회 (최근 100개로 제한하여 성능 최적화)
+                                        const existingMemories = await this.getExistingMemoriesForRelationExtraction(dbRef, savedMemoryId, 100);
+                                        if (existingMemories.length > 0) {
+                                            // 새로 저장된 기억 정보 조회
+                                            const newMemory = await this.getMemoryById(dbRef, savedMemoryId);
+                                            if (newMemory) {
+                                                // RelationExtractor를 사용하여 관계 추출
+                                                const relationExtractor = new RelationExtractor();
+                                                // 비동기 배치 처리로 관계 추출
+                                                // immediate: true로 설정하여 캐싱 활성화
+                                                const candidates = await relationExtractor.extractRelations(newMemory, existingMemories, {
+                                                    method: 'hybrid',
+                                                    minConfidence: 0.5,
+                                                    candidateLimit: 30, // MiniLM 필터링을 위한 제한
+                                                    immediate: true // 캐싱 활성화
+                                                });
+                                                if (candidates.length > 0) {
+                                                    this.logInfo('관계 추출 완료', {
+                                                        memory_id: savedMemoryId,
+                                                        relation_count: candidates.length,
+                                                        relations: candidates.map(c => ({
+                                                            target_id: c.target_id,
+                                                            relation_type: c.relation_type,
+                                                            confidence: c.confidence,
+                                                            method: c.method
+                                                        }))
+                                                    });
+                                                    // TODO: PRD 3.0에서 RelationGraph가 구현되면 여기서 관계를 저장
+                                                    // const relationGraph = new RelationGraph(dbRef);
+                                                    // for (const candidate of candidates) {
+                                                    //   await relationGraph.addRelation(candidate);
+                                                    // }
+                                                }
+                                                else {
+                                                    this.logInfo('관계 추출 완료 (관계 없음)', {
+                                                        memory_id: savedMemoryId
+                                                    });
+                                                }
+                                            }
                                         }
                                     }
                                 }
                                 catch (error) {
-                                    // 인접 기억 갱신 실패해도 메모리 저장은 성공했으므로 경고만 출력
-                                    this.logWarning(`인접 기억 갱신 실패 (${savedMemoryId})`, {
+                                    // 관계 추출 실패해도 메모리 저장은 성공했으므로 경고만 출력
+                                    this.logWarning(`관계 추출 실패 (${savedMemoryId})`, {
                                         error: error instanceof Error ? error.message : String(error)
                                     });
                                 }
                             }
-                            // PRD 2.12: 관계 추출 트리거 (비동기 배치 처리)
-                            // 임베딩 생성 여부와 관계없이 관계 추출 수행 (규칙 기반 추출은 임베딩 불필요)
-                            try {
-                                // 데이터베이스 연결 재확인
-                                let dbValid = false;
-                                try {
-                                    await new Promise((resolve, reject) => {
-                                        try {
-                                            DatabaseUtils.get(dbRef, 'SELECT 1');
-                                            resolve();
-                                        }
-                                        catch (error) {
-                                            reject(error);
-                                        }
-                                    });
-                                    dbValid = true;
-                                }
-                                catch (dbError) {
-                                    this.logWarning('데이터베이스 연결이 유효하지 않아 관계 추출을 건너뜁니다', {
-                                        memory_id: savedMemoryId,
-                                        error: dbError instanceof Error ? dbError.message : String(dbError)
-                                    });
-                                }
-                                if (dbValid) {
-                                    // 기존 기억들 조회 (최근 100개로 제한하여 성능 최적화)
-                                    const existingMemories = await this.getExistingMemoriesForRelationExtraction(dbRef, savedMemoryId, 100);
-                                    if (existingMemories.length > 0) {
-                                        // 새로 저장된 기억 정보 조회
-                                        const newMemory = await this.getMemoryById(dbRef, savedMemoryId);
-                                        if (newMemory) {
-                                            // RelationExtractor를 사용하여 관계 추출
-                                            const relationExtractor = new RelationExtractor();
-                                            // 비동기 배치 처리로 관계 추출
-                                            // immediate: true로 설정하여 캐싱 활성화
-                                            const candidates = await relationExtractor.extractRelations(newMemory, existingMemories, {
-                                                method: 'hybrid',
-                                                minConfidence: 0.5,
-                                                candidateLimit: 30, // MiniLM 필터링을 위한 제한
-                                                immediate: true // 캐싱 활성화
-                                            });
-                                            if (candidates.length > 0) {
-                                                this.logInfo('관계 추출 완료', {
-                                                    memory_id: savedMemoryId,
-                                                    relation_count: candidates.length,
-                                                    relations: candidates.map(c => ({
-                                                        target_id: c.target_id,
-                                                        relation_type: c.relation_type,
-                                                        confidence: c.confidence,
-                                                        method: c.method
-                                                    }))
-                                                });
-                                                // TODO: PRD 3.0에서 RelationGraph가 구현되면 여기서 관계를 저장
-                                                // const relationGraph = new RelationGraph(dbRef);
-                                                // for (const candidate of candidates) {
-                                                //   await relationGraph.addRelation(candidate);
-                                                // }
-                                            }
-                                            else {
-                                                this.logInfo('관계 추출 완료 (관계 없음)', {
-                                                    memory_id: savedMemoryId
-                                                });
-                                            }
-                                        }
-                                    }
-                                }
-                            }
                             catch (error) {
-                                // 관계 추출 실패해도 메모리 저장은 성공했으므로 경고만 출력
-                                this.logWarning(`관계 추출 실패 (${savedMemoryId})`, {
+                                // 백그라운드 작업 실패해도 메모리 저장은 성공했으므로 경고만 출력
+                                this.logWarning(`백그라운드 작업 실패 (${savedMemoryId})`, {
                                     error: error instanceof Error ? error.message : String(error)
                                 });
                             }
-                        }
-                        catch (error) {
-                            // 백그라운드 작업 실패해도 메모리 저장은 성공했으므로 경고만 출력
+                        })().catch((error) => {
+                            // 예상치 못한 에러 처리
                             this.logWarning(`백그라운드 작업 실패 (${savedMemoryId})`, {
                                 error: error instanceof Error ? error.message : String(error)
                             });
-                        }
-                    })().catch((error) => {
-                        // 예상치 못한 에러 처리
-                        this.logWarning(`백그라운드 작업 실패 (${savedMemoryId})`, {
-                            error: error instanceof Error ? error.message : String(error)
                         });
+                    }
+                    return this.createSuccessResult({
+                        memory_id: id,
+                        type: type,
+                        message: `기억이 저장되었습니다: ${id}`,
+                        embedding_created: context.services.embeddingService?.isAvailable() || false
                     });
                 }
-                return this.createSuccessResult({
-                    memory_id: id,
-                    type: type,
-                    message: `기억이 저장되었습니다: ${id}`,
-                    embedding_created: context.services.embeddingService?.isAvailable() || false
-                });
-            }
-            catch (error) {
-                // 데이터베이스 락 문제인 경우 WAL 체크포인트 시도
-                if (error.code === 'SQLITE_BUSY') {
-                    try {
-                        await DatabaseUtils.checkpointWAL(context.db);
-                    }
-                    catch (checkpointError) {
-                        // WAL 체크포인트 실패
+                catch (error) {
+                    // 데이터베이스 락 문제인 경우 WAL 체크포인트 시도
+                    if (error.code === 'SQLITE_BUSY') {
+                        try {
+                            await DatabaseUtils.checkpointWAL(context.db);
+                        }
+                        catch (checkpointError) {
+                            // WAL 체크포인트 실패
+                        }
                     }
+                    // 실패 감지 훅 호출
+                    const executionTime = Date.now() - startTime;
+                    await this.handleFailure(error instanceof Error ? error : new Error(String(error)), params, context, executionTime);
+                    throw error;
                 }
-                throw error;
             }
         }
+        catch (error) {
+            // 최상위 에러 처리 (내부 catch에서 처리되지 않은 에러)
+            const executionTime = Date.now() - startTime;
+            await this.handleFailure(error instanceof Error ? error : new Error(String(error)), params, context, executionTime);
+            throw error;
+        }
     }
     /**
      * 관계 추출을 위한 기존 기억들 조회