a2a-memory 0.9.0 → 0.10.0

package/dist/hooks/session-end.js

@@ -5,308 +5,322 @@
  * 세션 전체를 분석하여 요약 메모리를 생성합니다.
  * autoSync 활성화 시 pending 메모리를 원격 서버로 push합니다.
  */
-import { getSharedDb, closeSharedDb } from './shared.js';
+import { getSharedDb, closeSharedDb, normalizeHookInput } from './shared.js';
 import { ConfigManager } from '../config/manager.js';
 import { parseSessionFile, findSessionFiles } from '../session/parser.js';
 import { extractMemories, extractMemoriesWithLLM, summarizeSession } from '../extraction/extractor.js';
-import { A2AClient } from '../sync/client.js';
+import { createHookClient } from './client-factory.js';
 import { SyncQueue } from '../sync/queue.js';
 import { createLogger } from '../utils/logger.js';
+/** autoSync push + 팀 동기화 */
+async function syncToRemote(_context, config, db, logger) {
+    // autoSync push (pending 메모리 일괄 전송)
+    if (config.autoSync.enabled && config.autoSync.pushOnSessionEnd && config.server.apiKey) {
+        try {
+            const client = createHookClient(config);
+            if (!client)
+                throw new Error('sync client not available');
+            const queue = new SyncQueue(db, client);
+            const flushResult = await queue.flush({ timeoutMs: config.autoSync.timeoutMs });
+            if (flushResult.pushed > 0) {
+                console.error(`[a2a] Synced ${flushResult.pushed} memories to server`);
+            }
+            if (flushResult.errors.length > 0) {
+                console.error(`[a2a] Sync errors: ${flushResult.errors.join(', ')}`);
+            }
+        }
+        catch (syncErr) {
+            logger.warn('Sync push failed', { error: syncErr instanceof Error ? syncErr.message : String(syncErr) });
+        }
+    }
+    // 팀 동기화 (team 모드)
+    if (config.mode === 'team' && config.team && config.server.apiKey) {
+        try {
+            const { TeamSynchronizer } = await import('../sync/team-synchronizer.js');
+            const client = createHookClient(config);
+            if (!client)
+                throw new Error('team sync client not available');
+            const teamSync = new TeamSynchronizer(db, client, config.team.teamPath, config.team.nodeId);
+            const teamResult = await teamSync.syncDelta();
+            if (teamResult.pushed > 0) {
+                console.error(`[a2a] Team synced ${teamResult.pushed} memories`);
+            }
+        }
+        catch (teamErr) {
+            logger.warn('Team sync failed', { error: teamErr instanceof Error ? teamErr.message : String(teamErr) });
+        }
+    }
+}
 export async function handleSessionEnd(context) {
     const config = new ConfigManager().load();
     const logger = createLogger('SessionEnd', config.logging);
     const startTime = performance.now();
     try {
         logger.info('Hook started', { projectPath: context.projectPath });
-        if (!config.sessionSummary.enabled) {
-            logger.info('Session summary disabled');
-            return;
-        }
-        // projectPath 필수 검증
+        // projectPath 필수 검증 — 없으면 아무 작업도 불가
         if (!context.projectPath) {
             logger.warn('No projectPath provided');
             return;
         }
-        // 세션 파일 찾기
-        const sessionFiles = findSessionFiles(context.projectPath);
-        if (sessionFiles.length === 0) {
-            logger.info('No session files found');
-            return;
-        }
-        // 가장 최근 수정된 세션 파일 사용
-        const latestSession = sessionFiles
-            .sort((a, b) => (b.modifiedAt - a.modifiedAt))[0];
-        const messages = parseSessionFile(latestSession.filePath);
-        // 최소 행동 수 미달 시 스킵
-        const toolUseCount = messages.filter((m) => Array.isArray(m.message.content) &&
-            m.message.content.some((b) => b.type === 'tool_use')).length;
-        logger.info('Session analysis', { messages: messages.length, toolUseCount });
-        if (toolUseCount < config.sessionSummary.minActions) {
-            logger.info('Tool use count below threshold', { toolUseCount, threshold: config.sessionSummary.minActions });
-            return;
-        }
         const db = getSharedDb(config.db.path);
-        // 이미 처리된 세션 확인 — 새 메시지가 있으면 증분 추출
-        const existingSession = db.getSession(latestSession.sessionId);
-        const previousMessageCount = existingSession?.messageCount ?? 0;
-        if (existingSession && messages.length <= previousMessageCount) {
-            logger.info('No new messages since last extraction', {
-                sessionId: latestSession.sessionId,
-                previousCount: previousMessageCount,
-                currentCount: messages.length,
-            });
-            return;
-        }
-        // 증분 추출: 이전에 처리된 메시지 이후만 추출
-        const messagesToProcess = existingSession
-            ? messages.slice(previousMessageCount)
-            : messages;
-        logger.info('Processing messages', {
-            total: messages.length,
-            new: messagesToProcess.length,
-            incremental: !!existingSession,
-        });
-        // 메모리 추출 (LLM 활성 시 고급 추출)
-        let result;
-        if (config.llm?.enabled) {
+        // ── Phase 1: 세션 추출 (실패해도 Phase 2 진행) ──
+        const createdIds = [];
+        if (config.sessionSummary.enabled) {
             try {
-                const { createLLMClient } = await import('../llm/index.js');
-                const llmClient = createLLMClient(config.llm);
-                result = await extractMemoriesWithLLM(messagesToProcess, context.projectPath, llmClient);
-                // 세션 요약 생성 (learning 카테고리)
-                const summary = await summarizeSession(messagesToProcess, llmClient);
-                if (summary && summary.length > 10) {
-                    result.memories.push({
-                        content: summary,
-                        category: 'learning',
-                        tier: 'semantic',
-                        tags: ['session-summary'],
-                        projectPath: context.projectPath,
-                    });
-                }
+                await extractSessionMemories(context, config, db, logger, createdIds);
             }
-            catch (llmErr) {
-                // LLM 실패 시 기본 추출
-                logger.warn('LLM extraction failed, using basic', { error: llmErr instanceof Error ? llmErr.message : String(llmErr) });
-                result = extractMemories(messagesToProcess, context.projectPath);
+            catch (extractErr) {
+                logger.warn('Session extraction failed', { error: extractErr instanceof Error ? extractErr.message : String(extractErr) });
             }
         }
         else {
-            result = extractMemories(messagesToProcess, context.projectPath);
+            logger.info('Session summary disabled');
         }
-        logger.info('Memories extracted', { count: result.memories.length });
-        // DB에 저장 + sync_status pending 설정
-        const createdIds = [];
-        for (const memory of result.memories) {
-            const created = db.createMemory({
-                ...memory,
-                sessionId: latestSession.sessionId,
-            });
-            db.setSyncStatus(created.id, null, 'pending');
-            createdIds.push(created.id);
-            // 로컬 임베딩 자동 생성 (~1ms, 동기 처리 가능)
-            if (config.embedding?.enabled && config.embedding.provider === 'local') {
-                try {
-                    const { createEmbeddingProvider } = await import('../embedding/index.js');
-                    const provider = createEmbeddingProvider(config.embedding, config.llm);
-                    const emb = await Promise.resolve(provider.embed(created.content));
-                    if (Array.isArray(emb)) {
-                        db.saveEmbedding(created.id, emb);
-                    }
-                }
-                catch {
-                    // 임베딩 생성 실패 무시 — 다음 세션에서 재시도
-                }
-            }
+        // ── Phase 2: 항상 실행 — Sync, Cleanup (세션 추출과 독립) ──
+        // 숙련도 추적 + 서버 Push (Phase 5)
+        // createdIds.length > 0 게이트 제거: PostToolUse가 세션 중 이미 메모리를 생성했으므로
+        // SessionEnd의 createdIds(세션파일 추출분)과 무관하게 proficiency 평가 수행
+        if (config.proficiency?.enabled) {
+            // 세션 중 생성된 모든 메모리를 DB에서 조회하여 평가 대상으로 사용
+            const sessionMemoryIds = createdIds.length > 0
+                ? createdIds
+                : db.listMemories({ limit: 50 }).map(m => m.id);
+            await trackProficiency(context, config, db, logger, sessionMemoryIds);
         }
-        // OpenAI 임베딩은 일괄 처리 (네트워크 비용 절감)
-        if (config.embedding?.enabled && config.embedding.provider === 'openai' && config.llm?.apiKey && createdIds.length > 0) {
+        // 원격 동기화 (autoSync push + 팀 동기화)
+        await syncToRemote(context, config, db, logger);
+        // 라이프사이클 정리 (설정 활성화 시)
+        if (config.lifecycle?.cleanupOnSessionEnd) {
             try {
-                const { createEmbeddingProvider } = await import('../embedding/index.js');
-                const provider = createEmbeddingProvider(config.embedding, config.llm);
-                const contents = createdIds.map(id => {
-                    const mem = db.getMemory(id);
-                    return mem ? mem.content : '';
-                }).filter(Boolean);
-                if (contents.length > 0) {
-                    const embeddings = await Promise.resolve(provider.embedBatch(contents));
-                    for (let i = 0; i < createdIds.length; i++) {
-                        if (embeddings[i]) {
-                            db.saveEmbedding(createdIds[i], embeddings[i]);
-                        }
-                    }
+                const { cleanupMemories } = await import('../lifecycle/index.js');
+                const cleanupResult = cleanupMemories(db, config.lifecycle);
+                if (cleanupResult.total > 0) {
+                    console.error(`[a2a] Cleaned up ${cleanupResult.total} memories (${cleanupResult.expired} expired, ${cleanupResult.lowQuality} low-quality)`);
                 }
+                logger.info('Cleanup done', { total: cleanupResult.total });
             }
-            catch {
-                // 일괄 임베딩 실패 무시
+            catch (cleanupErr) {
+                logger.warn('Cleanup failed', { error: cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr) });
             }
         }
-        // 세션 기록
-        db.saveSession(latestSession.sessionId, context.projectPath, messages.length);
-        if (result.memories.length > 0) {
-            const mode = existingSession ? ' (incremental)' : '';
-            console.error(`[a2a] Session summary${mode}: ${result.memories.length} memories extracted from ${messagesToProcess.length} messages`);
-        }
-        // 스킬 결정화 평가 (N 세션마다)
-        if (config.skillConversion?.enabled) {
-            try {
-                const sessionCount = db.getSessionCount(context.projectPath);
-                if (sessionCount > 0 && sessionCount % config.skillConversion.evaluationInterval === 0) {
-                    const { SkillEvaluator } = await import('../skill/evaluator.js');
-                    const evaluator = new SkillEvaluator(db, config);
-                    const evalResult = await evaluator.evaluate(context.projectPath);
-                    if (evalResult.created > 0) {
-                        console.error(`[a2a] Skill crystallization: ${evalResult.created} new skills created`);
-                    }
-                }
-            }
-            catch (skillErr) {
-                logger.warn('Skill evaluation failed', { error: skillErr instanceof Error ? skillErr.message : String(skillErr) });
+        logger.info('Hook completed', { durationMs: Math.round(performance.now() - startTime) });
+    }
+    finally {
+        logger.flush();
+    }
+}
+/**
+ * 세션 파일에서 메모리 추출 (Phase 1 내부)
+ */
+async function extractSessionMemories(context, config, db, logger, createdIds) {
+    const sessionFiles = findSessionFiles(context.projectPath);
+    if (sessionFiles.length === 0) {
+        logger.info('No session files found');
+        return;
+    }
+    const latestSession = sessionFiles
+        .sort((a, b) => (b.modifiedAt - a.modifiedAt))[0];
+    const messages = parseSessionFile(latestSession.filePath);
+    const toolUseCount = messages.filter((m) => Array.isArray(m.message.content) &&
+        m.message.content.some((b) => b.type === 'tool_use')).length;
+    logger.info('Session analysis', { messages: messages.length, toolUseCount });
+    if (toolUseCount < config.sessionSummary.minActions) {
+        logger.info('Tool use count below threshold', { toolUseCount, threshold: config.sessionSummary.minActions });
+        return;
+    }
+    // 이미 처리된 세션 확인 — 새 메시지가 있으면 증분 추출
+    const existingSession = db.getSession(latestSession.sessionId);
+    const previousMessageCount = existingSession?.messageCount ?? 0;
+    if (existingSession && messages.length <= previousMessageCount) {
+        logger.info('No new messages since last extraction', {
+            sessionId: latestSession.sessionId,
+            previousCount: previousMessageCount,
+            currentCount: messages.length,
+        });
+        return;
+    }
+    const messagesToProcess = existingSession
+        ? messages.slice(previousMessageCount)
+        : messages;
+    logger.info('Processing messages', {
+        total: messages.length,
+        new: messagesToProcess.length,
+        incremental: !!existingSession,
+    });
+    // 메모리 추출 (LLM 활성 시 고급 추출)
+    let result;
+    if (config.llm?.enabled) {
+        try {
+            const { createLLMClient } = await import('../llm/index.js');
+            const llmClient = createLLMClient(config.llm);
+            result = await extractMemoriesWithLLM(messagesToProcess, context.projectPath, llmClient);
+            const summary = await summarizeSession(messagesToProcess, llmClient);
+            if (summary && summary.length > 10) {
+                result.memories.push({
+                    content: summary,
+                    category: 'learning',
+                    tier: 'semantic',
+                    tags: ['session-summary'],
+                    projectPath: context.projectPath,
+                });
             }
         }
-        // 숙련도 추적 (Phase 5 — Multi-signal detection)
-        const detectedProficiencyEvents = [];
-        if (config.proficiency?.enabled) {
+        catch (llmErr) {
+            logger.warn('LLM extraction failed, using basic', { error: llmErr instanceof Error ? llmErr.message : String(llmErr) });
+            result = extractMemories(messagesToProcess, context.projectPath);
+        }
+    }
+    else {
+        result = extractMemories(messagesToProcess, context.projectPath);
+    }
+    logger.info('Memories extracted', { count: result.memories.length });
+    // DB에 저장 + sync_status pending 설정
+    for (const memory of result.memories) {
+        const created = db.createMemory({
+            ...memory,
+            sessionId: latestSession.sessionId,
+        });
+        db.setSyncStatus(created.id, null, 'pending');
+        createdIds.push(created.id);
+        if (config.embedding?.enabled && config.embedding.provider === 'local') {
             try {
-                const { ProficiencyTracker } = await import('../proficiency/tracker.js');
-                const { detectSkillPractice } = await import('../proficiency/detection.js');
-                const tracker = new ProficiencyTracker(db, config.proficiency);
-                const skills = db.listMemories({ category: 'skill', limit: 100 });
-                // 세션 메모리 수집 (임베딩 포함)
-                const sessionMemories = createdIds
-                    .map(id => {
-                    const mem = db.getMemory(id);
-                    if (!mem)
-                        return null;
-                    const emb = db.getEmbedding(id);
-                    return {
-                        content: mem.content,
-                        tags: mem.tags ?? [],
-                        embedding: emb ?? undefined,
-                    };
-                })
-                    .filter((m) => m !== null);
-                for (const skill of skills) {
-                    const skillInfo = {
-                        id: skill.id,
-                        content: skill.content,
-                        tags: skill.tags ?? [],
-                        embedding: skill.embedding ?? db.getEmbedding(skill.id) ?? undefined,
-                    };
-                    const detection = detectSkillPractice(skillInfo, sessionMemories);
-                    if (!detection)
-                        continue;
-                    // 로컬 숙련도 기록
-                    const levelResult = tracker.recordPractice(skill.id, detection.outcome, detection.difficulty, detection.contextTags, context.sessionId);
-                    if (levelResult.levelChanged) {
-                        console.error(`[a2a] Proficiency: "${skill.content.split('\n')[0].slice(0, 50)}" level ${levelResult.previousLevel} → ${levelResult.newLevel}`);
-                    }
-                    // 서버 push용 이벤트 수집
-                    detectedProficiencyEvents.push({
-                        skillMemoryId: skill.id,
-                        outcome: detection.outcome,
-                        difficulty: detection.difficulty,
-                        contextTags: detection.contextTags,
-                    });
+                const { createEmbeddingProvider } = await import('../embedding/index.js');
+                const provider = createEmbeddingProvider(config.embedding, config.llm);
+                const emb = await Promise.resolve(provider.embed(created.content));
+                if (Array.isArray(emb)) {
+                    db.saveEmbedding(created.id, emb);
                 }
             }
-            catch (profErr) {
-                logger.warn('Proficiency tracking failed', { error: profErr instanceof Error ? profErr.message : String(profErr) });
+            catch {
+                // 임베딩 생성 실패 무시
             }
         }
-        // === Proficiency Server Push ===
-        if (detectedProficiencyEvents.length > 0 && config.server?.apiKey && config.server?.url) {
-            try {
-                const pushClient = new A2AClient({
-                    baseUrl: config.server.url,
-                    apiKey: config.server.apiKey,
-                });
-                const connected = await pushClient.testConnection();
-                if (connected) {
-                    for (const event of detectedProficiencyEvents) {
-                        try {
-                            await pushClient.postProficiencyEvent({
-                                skill_memory_id: event.skillMemoryId,
-                                outcome: event.outcome,
-                                difficulty: event.difficulty,
-                                context_tags: event.contextTags,
-                                session_id: context.sessionId,
-                            });
-                        }
-                        catch (err) {
-                            logger.warn('Failed to push proficiency event', { error: String(err) });
-                        }
+    }
+    // OpenAI 임베딩 일괄 처리
+    if (config.embedding?.enabled && config.embedding.provider === 'openai' && config.llm?.apiKey && createdIds.length > 0) {
+        try {
+            const { createEmbeddingProvider } = await import('../embedding/index.js');
+            const provider = createEmbeddingProvider(config.embedding, config.llm);
+            const contents = createdIds.map(id => {
+                const mem = db.getMemory(id);
+                return mem ? mem.content : '';
+            }).filter(Boolean);
+            if (contents.length > 0) {
+                const embeddings = await Promise.resolve(provider.embedBatch(contents));
+                for (let i = 0; i < createdIds.length; i++) {
+                    if (embeddings[i]) {
+                        db.saveEmbedding(createdIds[i], embeddings[i]);
                     }
-                    logger.info('Proficiency events pushed to server', { count: detectedProficiencyEvents.length });
-                    console.error(`[a2a] Proficiency: ${detectedProficiencyEvents.length} event(s) synced to server`);
-                }
-                else {
-                    logger.debug('Server not reachable, skipping proficiency push');
                 }
             }
-            catch (err) {
-                logger.warn('Proficiency server push failed', { error: String(err) });
-            }
         }
-        // autoSync push (pending 메모리 일괄 전송)
-        if (config.autoSync.enabled && config.autoSync.pushOnSessionEnd && config.server.apiKey) {
-            try {
-                const client = new A2AClient({
-                    baseUrl: config.server.url,
-                    apiKey: config.server.apiKey,
-                });
-                const queue = new SyncQueue(db, client);
-                const flushResult = await queue.flush({ timeoutMs: config.autoSync.timeoutMs }); // hook: config 값 사용
-                if (flushResult.pushed > 0) {
-                    console.error(`[a2a] Synced ${flushResult.pushed} memories to server`);
-                }
-                if (flushResult.errors.length > 0) {
-                    console.error(`[a2a] Sync errors: ${flushResult.errors.join(', ')}`);
-                }
-            }
-            catch (syncErr) {
-                // sync 실패는 무시 — 다음 세션에서 재시도
-                logger.warn('Sync push failed', { error: syncErr instanceof Error ? syncErr.message : String(syncErr) });
-            }
+        catch {
+            // 일괄 임베딩 실패 무시
         }
-        // 팀 동기화 (team 모드)
-        if (config.mode === 'team' && config.team && config.server.apiKey) {
-            try {
-                const { TeamSynchronizer } = await import('../sync/team-synchronizer.js');
-                const client = new A2AClient({
-                    baseUrl: config.server.url,
-                    apiKey: config.server.apiKey,
-                });
-                const teamSync = new TeamSynchronizer(db, client, config.team.teamPath, config.team.nodeId);
-                const teamResult = await teamSync.syncDelta();
-                if (teamResult.pushed > 0) {
-                    console.error(`[a2a] Team synced ${teamResult.pushed} memories`);
+    }
+    // 세션 기록
+    db.saveSession(latestSession.sessionId, context.projectPath, messages.length);
+    if (result.memories.length > 0) {
+        const mode = existingSession ? ' (incremental)' : '';
+        console.error(`[a2a] Session summary${mode}: ${result.memories.length} memories extracted from ${messagesToProcess.length} messages`);
+    }
+    // 스킬 결정화 평가 (N 세션마다)
+    if (config.skillConversion?.enabled) {
+        try {
+            const sessionCount = db.getSessionCount(context.projectPath);
+            if (sessionCount > 0 && sessionCount % config.skillConversion.evaluationInterval === 0) {
+                const { SkillEvaluator } = await import('../skill/evaluator.js');
+                const evaluator = new SkillEvaluator(db, config);
+                // Taxonomy 분류를 위한 A2AClient (선택적)
+                const taxonomyClient = createHookClient(config, 10000) ?? undefined; // taxonomy 분류는 빠르게 (10초)
+                const evalResult = await evaluator.evaluate(context.projectPath, taxonomyClient);
+                if (evalResult.created > 0) {
+                    console.error(`[a2a] Skill crystallization: ${evalResult.created} new skills created`);
                 }
             }
-            catch (teamErr) {
-                // 팀 sync 실패 무시
-                logger.warn('Team sync failed', { error: teamErr instanceof Error ? teamErr.message : String(teamErr) });
+        }
+        catch (skillErr) {
+            logger.warn('Skill evaluation failed', { error: skillErr instanceof Error ? skillErr.message : String(skillErr) });
+        }
+    }
+}
+/**
+ * 숙련도 추적 + 서버 Push
+ */
+async function trackProficiency(context, config, db, logger, createdIds) {
+    const detectedEvents = [];
+    try {
+        const { ProficiencyTracker } = await import('../proficiency/tracker.js');
+        const { detectSkillPractice } = await import('../proficiency/detection.js');
+        const tracker = new ProficiencyTracker(db, config.proficiency);
+        const skills = db.listMemories({ category: 'skill', limit: 100 });
+        const sessionMemories = createdIds
+            .map(id => {
+            const mem = db.getMemory(id);
+            if (!mem)
+                return null;
+            const emb = db.getEmbedding(id);
+            return {
+                content: mem.content,
+                tags: mem.tags ?? [],
+                embedding: emb ?? undefined,
+            };
+        })
+            .filter((m) => m !== null);
+        for (const skill of skills) {
+            const skillInfo = {
+                id: skill.id,
+                content: skill.content,
+                tags: skill.tags ?? [],
+                embedding: skill.embedding ?? db.getEmbedding(skill.id) ?? undefined,
+            };
+            const detection = detectSkillPractice(skillInfo, sessionMemories);
+            if (!detection)
+                continue;
+            const levelResult = tracker.recordPractice(skill.id, detection.outcome, detection.difficulty, detection.contextTags, context.sessionId);
+            if (levelResult.levelChanged) {
+                console.error(`[a2a] Proficiency: "${skill.content.split('\n')[0].slice(0, 50)}" level ${levelResult.previousLevel} → ${levelResult.newLevel}`);
             }
+            detectedEvents.push({
+                skillMemoryId: skill.id,
+                outcome: detection.outcome,
+                difficulty: detection.difficulty,
+                contextTags: detection.contextTags,
+            });
         }
-        // 라이프사이클 정리 (설정 활성화 시)
-        if (config.lifecycle?.cleanupOnSessionEnd) {
-            try {
-                const { cleanupMemories } = await import('../lifecycle/index.js');
-                const cleanupResult = cleanupMemories(db, config.lifecycle);
-                if (cleanupResult.total > 0) {
-                    console.error(`[a2a] Cleaned up ${cleanupResult.total} memories (${cleanupResult.expired} expired, ${cleanupResult.lowQuality} low-quality)`);
+    }
+    catch (profErr) {
+        logger.warn('Proficiency tracking failed', { error: profErr instanceof Error ? profErr.message : String(profErr) });
+    }
+    // Proficiency Server Push
+    if (detectedEvents.length > 0 && config.server?.apiKey && config.server?.url) {
+        try {
+            const pushClient = createHookClient(config);
+            if (!pushClient)
+                return;
+            const connected = await pushClient.testConnection();
+            if (connected) {
+                for (const event of detectedEvents) {
+                    try {
+                        await pushClient.postProficiencyEvent({
+                            skill_memory_id: event.skillMemoryId,
+                            outcome: event.outcome,
+                            difficulty: event.difficulty,
+                            context_tags: event.contextTags,
+                            session_id: context.sessionId,
+                        });
+                    }
+                    catch (err) {
+                        logger.warn('Failed to push proficiency event', { error: String(err) });
+                    }
                 }
-                logger.info('Cleanup done', { total: cleanupResult.total });
-            }
-            catch (cleanupErr) {
-                // cleanup 실패 무시
-                logger.warn('Cleanup failed', { error: cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr) });
+                logger.info('Proficiency events pushed to server', { count: detectedEvents.length });
+                console.error(`[a2a] Proficiency: ${detectedEvents.length} event(s) synced to server`);
             }
         }
-        logger.info('Hook completed', { durationMs: Math.round(performance.now() - startTime) });
-    }
-    finally {
-        logger.flush();
+        catch (err) {
+            logger.warn('Proficiency server push failed', { error: String(err) });
+        }
     }
 }
 /**
@@ -323,7 +337,8 @@ export async function main() {
         process.exit(0);
     }
     try {
-        const context = JSON.parse(input);
+        const raw = JSON.parse(input);
+        const context = normalizeHookInput(raw);
         await handleSessionEnd(context);
     }
     catch (err) {