mupengism 3.1.0 → 4.0.1

package/hooks/action-logger/handler.ts

@@ -0,0 +1,127 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Action Logger Hook
+ * 
+ * 이벤트: message:sent
+ * 모든 외부 발송 메시지를 감사 로그로 기록 + 이벤트 버스 역할.
+ * 토큰 비용: 0 (파일 I/O만)
+ */
+
+const ACTIONS_LOG = 'events/actions.jsonl';
+const DAILY_STATS = 'events/daily-stats.json';
+
+export default async function handler(event: any): Promise<void> {
+  try {
+    if (event.type !== 'message' || event.action !== 'sent') return;
+
+    const workspace = event.context?.workspaceDir || event.workspace || process.cwd();
+    const eventsDir = path.join(workspace, 'events');
+
+    // events 디렉토리 확보
+    if (!fs.existsSync(eventsDir)) {
+      fs.mkdirSync(eventsDir, { recursive: true });
+    }
+
+    const channel = event.context?.channelId || 'unknown';
+    const success = event.context?.success !== false;
+    const to = event.context?.to || 'unknown';
+    const contentPreview = truncate(event.context?.content || '', 100);
+
+    // 이벤트 타입 분류
+    const eventType = classifyEvent(channel, contentPreview);
+
+    // ===== 1. 감사 로그 기록 =====
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      type: eventType,
+      channel,
+      to,
+      success,
+      preview: contentPreview,
+      error: success ? undefined : (event.context?.error || 'unknown'),
+      sessionKey: event.sessionKey || undefined,
+    };
+
+    const logPath = path.join(eventsDir, 'actions.jsonl');
+    fs.appendFileSync(logPath, JSON.stringify(logEntry) + '\n', 'utf-8');
+
+    // ===== 2. 일일 통계 업데이트 =====
+    updateDailyStats(eventsDir, channel, success);
+
+    // ===== 3. 에러 이벤트 =====
+    if (!success) {
+      const errorEntry = {
+        timestamp: new Date().toISOString(),
+        type: 'error:message-send',
+        channel,
+        to,
+        error: event.context?.error || 'send failed',
+      };
+      const errorLogPath = path.join(eventsDir, 'errors.jsonl');
+      fs.appendFileSync(errorLogPath, JSON.stringify(errorEntry) + '\n', 'utf-8');
+      
+      console.log(`[action-logger] ❌ Send failed: ${channel} → ${to}`);
+    }
+
+    console.log(`[action-logger] 📊 ${eventType} → ${channel}:${to} (${success ? 'ok' : 'fail'})`);
+
+  } catch (error) {
+    console.error('[action-logger] Error (non-fatal):', error);
+  }
+}
+
+function classifyEvent(channel: string, content: string): string {
+  const ch = channel.toLowerCase();
+  
+  if (ch.includes('discord') || ch.includes('telegram') || ch.includes('slack')) {
+    return 'message:social';
+  }
+  if (ch.includes('email') || ch.includes('gmail') || ch.includes('mail')) {
+    return 'message:email';
+  }
+  if (ch.includes('whatsapp') || ch.includes('signal') || ch.includes('imessage')) {
+    return 'message:chat';
+  }
+  return 'message:other';
+}
+
+function updateDailyStats(eventsDir: string, channel: string, success: boolean): void {
+  try {
+    const statsPath = path.join(eventsDir, 'daily-stats.json');
+    const today = new Date().toISOString().split('T')[0];
+    
+    let stats: any = { date: today, channels: {}, total: 0, errors: 0 };
+    
+    if (fs.existsSync(statsPath)) {
+      const existing = JSON.parse(fs.readFileSync(statsPath, 'utf-8'));
+      if (existing.date === today) {
+        stats = existing;
+      }
+    }
+    
+    // 채널별 카운트
+    if (!stats.channels[channel]) {
+      stats.channels[channel] = { sent: 0, failed: 0 };
+    }
+    
+    if (success) {
+      stats.channels[channel].sent++;
+    } else {
+      stats.channels[channel].failed++;
+      stats.errors++;
+    }
+    stats.total++;
+    
+    fs.writeFileSync(statsPath, JSON.stringify(stats, null, 2), 'utf-8');
+  } catch {
+    // 통계 실패는 무시
+  }
+}
+
+function truncate(text: string, maxLen: number): string {
+  if (!text) return '';
+  const oneLine = text.replace(/\n/g, ' ').trim();
+  return oneLine.length > maxLen ? oneLine.slice(0, maxLen) + '...' : oneLine;
+}

package/hooks/context-recovery/HOOK.md

@@ -0,0 +1,30 @@
+---
+name: context-recovery
+description: "세션 간 문맥 손실 방지 — 세션 종료 시 저장, 새 세션 시작 시 복원"
+metadata:
+  openclaw:
+    emoji: "🔄"
+    events: ["command:new", "command:reset", "agent:bootstrap"]
+---
+
+# Context Recovery Hook
+
+## 목적
+세션 간 문맥 손실 방지. 세션 끝날 때 "지금 하던 일"을 저장하고, 새 세션에서 자동 복원.
+
+## 동작
+1. **저장** (`command:new` / `command:reset`): 최근 대화에서 "하던 일" 추출 → `memory/context-stack.md` 저장
+2. **복원** (`agent:bootstrap`): context-stack.md를 bootstrapFiles에 주입 (24시간 이내만)
+
+## context-stack.md 포맷
+```
+# Context Stack
+- **하던 일**: [구체적 작업]
+- **마지막 응답**: [에이전트 마지막 답변 요약]
+- **대기 중**: [형님 응답/외부 결과 기다리는 것]
+- **갱신**: [ISO 타임스탬프]
+```
+
+## 규칙
+- 24시간 이상 된 컨텍스트는 자동 무시
+- 에러 시 조용히 실패 (세션 부팅 방해 금지)

package/hooks/context-recovery/handler.ts

@@ -0,0 +1,135 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Context Recovery Hook
+ * 
+ * 이벤트:
+ *   - command:new / command:reset → 현재 컨텍스트 저장
+ *   - agent:bootstrap → 저장된 컨텍스트 복원 (bootstrapFiles 주입)
+ * 
+ * 세션 간 문맥 손실 방지. "지금 하던 일"을 5줄 이내로 저장/복원.
+ */
+
+const CONTEXT_FILE = 'memory/context-stack.md';
+const MAX_LINES = 8; // 헤더 포함
+
+export default async function handler(event: any): Promise<void> {
+  try {
+    const workspace = event.workspace || process.cwd();
+    const contextPath = path.join(workspace, CONTEXT_FILE);
+    const eventName = event.name || event.event || '';
+
+    // ===== 1. 저장 (세션 종료 시) =====
+    if (eventName === 'command:new' || eventName === 'command:reset' || eventName === 'beforeReset') {
+      console.log('[context-recovery] 💾 Saving context stack...');
+      
+      // 이전 메시지에서 최근 대화 요약 추출
+      const messages = event.messages || [];
+      const recentMessages = messages
+        .filter((m: any) => m.role === 'user' || m.role === 'assistant')
+        .slice(-6); // 최근 6개 메시지
+
+      if (recentMessages.length === 0) {
+        console.log('[context-recovery] No messages to save, skipping');
+        return;
+      }
+
+      // 마지막 사용자 메시지 = "하던 일"
+      const lastUserMsg = [...recentMessages]
+        .reverse()
+        .find((m: any) => m.role === 'user');
+      const lastAssistantMsg = [...recentMessages]
+        .reverse()
+        .find((m: any) => m.role === 'assistant');
+
+      const doingWhat = lastUserMsg
+        ? truncate(lastUserMsg.content, 120)
+        : '알 수 없음';
+      const lastResponse = lastAssistantMsg
+        ? truncate(lastAssistantMsg.content, 120)
+        : '없음';
+
+      const now = new Date().toISOString();
+      const stack = [
+        '# Context Stack',
+        `- **하던 일**: ${doingWhat}`,
+        `- **마지막 응답**: ${lastResponse}`,
+        `- **대기 중**: 없음`,
+        `- **갱신**: ${now}`,
+      ].join('\n');
+
+      // memory 디렉토리 확보
+      const memoryDir = path.dirname(contextPath);
+      if (!fs.existsSync(memoryDir)) {
+        fs.mkdirSync(memoryDir, { recursive: true });
+      }
+
+      fs.writeFileSync(contextPath, stack, 'utf-8');
+      console.log('[context-recovery] ✅ Context saved');
+      return;
+    }
+
+    // ===== 2. 복원 (세션 시작 시) =====
+    if (eventName === 'agent:bootstrap' || eventName === 'beforeAgentStart') {
+      console.log('[context-recovery] 🔄 Checking for saved context...');
+
+      if (!fs.existsSync(contextPath)) {
+        console.log('[context-recovery] No context-stack.md found, skipping');
+        return;
+      }
+
+      const content = fs.readFileSync(contextPath, 'utf-8').trim();
+      if (!content || content === '# Context Stack') {
+        console.log('[context-recovery] Empty context, skipping');
+        return;
+      }
+
+      // 갱신 시간 체크 — 24시간 이상 된 컨텍스트는 무시
+      const updatedMatch = content.match(/\*\*갱신\*\*:\s*(.+)/);
+      if (updatedMatch) {
+        const updatedAt = new Date(updatedMatch[1]).getTime();
+        const hoursSince = (Date.now() - updatedAt) / (1000 * 60 * 60);
+        if (hoursSince > 24) {
+          console.log(`[context-recovery] Context is ${hoursSince.toFixed(1)}h old, skipping`);
+          return;
+        }
+      }
+
+      // bootstrapFiles에 주입
+      if (event.context && event.context.bootstrapFiles) {
+        if (Array.isArray(event.context.bootstrapFiles)) {
+          event.context.bootstrapFiles.push({
+            path: CONTEXT_FILE,
+            content: content,
+          });
+        } else {
+          // object 형태
+          event.context.bootstrapFiles[CONTEXT_FILE] = content;
+        }
+        console.log('[context-recovery] ✅ Context injected into bootstrap');
+      }
+
+      // messages에도 힌트 추가
+      if (event.messages && Array.isArray(event.messages)) {
+        event.messages.push({
+          role: 'system',
+          content: `🔄 이전 세션 컨텍스트 복원됨:\n${content}`,
+        });
+      }
+
+      return;
+    }
+
+    console.log(`[context-recovery] Unknown event: ${eventName}, skipping`);
+  } catch (error) {
+    // 조용히 실패 — 컨텍스트 복구 실패가 세션을 망가뜨리면 안 됨
+    console.error('[context-recovery] Error (non-fatal):', error);
+  }
+}
+
+function truncate(text: string, maxLen: number): string {
+  if (!text) return '';
+  const oneLine = text.replace(/\n/g, ' ').trim();
+  return oneLine.length > maxLen ? oneLine.slice(0, maxLen) + '...' : oneLine;
+}

package/hooks/disciple-init/HOOK.md

@@ -0,0 +1,20 @@
+---
+name: disciple-init
+description: "서브에이전트 spawn 시 SOUL.md 핵심 원칙 + 관련 기억을 선택적으로 주입"
+metadata: { "openclaw": { "emoji": "📜", "events": ["agent:bootstrap"] } }
+---
+
+# Disciple Init
+
+서브에이전트에게 경전의 필요한 챕터만 전달하는 훅.
+
+## 동작 방식
+
+- `agent:bootstrap` 이벤트 수신
+- 서브에이전트 세션인 경우만 동작
+- `memory/reflex/*.md` 파일들을 읽어서 컨텍스트에 주입
+- 보안 규칙은 모든 제자에게 전달
+
+## 목적
+
+서브에이전트가 필요한 지식만 선택적으로 받아 토큰을 절약하면서도 핵심 원칙은 유지.

package/hooks/disciple-init/handler.ts

@@ -0,0 +1,80 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+interface BootstrapEvent {
+  sessionKey: string;
+  context: {
+    bootstrapFiles?: Array<{ path: string; content: string }>;
+  };
+  messages?: Array<{ role: string; content: string }>;
+}
+
+export default async function handler(event: BootstrapEvent): Promise<void> {
+  try {
+    console.log('[disciple-init] 📜 전승 시스템 시작');
+    
+    // 서브에이전트 세션인지 확인
+    if (!event.sessionKey || !event.sessionKey.includes('subagent')) {
+      console.log('[disciple-init] 메인 세션 - 스킵');
+      return;
+    }
+
+    console.log(`[disciple-init] 서브에이전트 세션 감지: ${event.sessionKey}`);
+
+    // workspace 경로 추정 (현재 디렉토리 기준)
+    const workspaceDir = process.cwd();
+    const reflexDir = path.join(workspaceDir, 'memory', 'reflex');
+
+    // memory/reflex/ 디렉토리 확인
+    if (!fs.existsSync(reflexDir)) {
+      console.log('[disciple-init] memory/reflex/ 디렉토리 없음 - 생성 스킵');
+      return;
+    }
+
+    // reflex/*.md 파일 읽기
+    const reflexFiles = fs.readdirSync(reflexDir)
+      .filter(f => f.endsWith('.md'))
+      .sort();
+
+    if (reflexFiles.length === 0) {
+      console.log('[disciple-init] reflex 파일 없음');
+      return;
+    }
+
+    // bootstrapFiles 배열 초기화
+    if (!event.context.bootstrapFiles) {
+      event.context.bootstrapFiles = [];
+    }
+
+    // 각 reflex 파일을 bootstrapFiles에 추가
+    let injectedCount = 0;
+    for (const fileName of reflexFiles) {
+      const filePath = path.join(reflexDir, fileName);
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        event.context.bootstrapFiles.push({
+          path: `memory/reflex/${fileName}`,
+          content: content
+        });
+        injectedCount++;
+        console.log(`[disciple-init] ✅ 주입: ${fileName}`);
+      } catch (err) {
+        console.error(`[disciple-init] ❌ 읽기 실패: ${fileName}`, err);
+      }
+    }
+
+    // 완료 메시지 추가
+    if (injectedCount > 0 && event.messages) {
+      event.messages.push({
+        role: 'system',
+        content: `📜 제자 초기화 완료 (${injectedCount}개 전승 파일 주입)`
+      });
+    }
+
+    console.log(`[disciple-init] 🎉 완료: ${injectedCount}개 파일 주입`);
+
+  } catch (error) {
+    // 조용히 실패 (다른 훅에 영향 없도록)
+    console.error('[disciple-init] ⚠️ 에러 발생 (조용히 실패):', error);
+  }
+}

package/hooks/event-bus/HOOK.md

@@ -0,0 +1,39 @@
+---
+name: event-bus
+description: "스킬 체이닝 이벤트 버스 — 이벤트 큐 처리 + 후속 작업 트리거"
+metadata:
+  openclaw:
+    emoji: "🔀"
+    events: ["agent:bootstrap"]
+---
+
+# Event Bus Hook
+
+## 목적
+스킬 실행 후 발생한 이벤트를 큐에서 읽어 후속 작업을 트리거하는 이벤트 버스.
+
+## 동작 (agent:bootstrap)
+1. `events/queue.jsonl` 에서 미처리 이벤트 읽기
+2. `hooks/event-bus/chains.json` 규칙에 따라 후속 작업 결정
+3. 후속 작업을 messages에 주입 (에이전트가 실행)
+4. 처리된 이벤트를 processed로 마킹
+
+## 이벤트 발행 (스킬에서)
+스킬이 완료되면 events/queue.jsonl에 한 줄 추가:
+```json
+{"event":"git:commit","source":"git-auto","data":{"branch":"main","message":"feat: ..."},"ts":"...","processed":false}
+```
+
+## 체이닝 규칙 (chains.json)
+```json
+[
+  {"trigger":"git:commit","action":"daily-report에 기록","priority":"low"},
+  {"trigger":"insta:posted","action":"콘텐츠 발행 이벤트 기록","priority":"medium"},
+  {"trigger":"error:*","action":"형님 알림","priority":"high"}
+]
+```
+
+## 규칙
+- 미처리 이벤트가 없으면 즉시 리턴 (토큰 0)
+- 이벤트 큐 최대 100개 (넘으면 오래된 것 삭제)
+- 처리된 이벤트는 7일 후 자동 정리

package/hooks/event-bus/chains.json

@@ -0,0 +1,55 @@
+[
+  {
+    "trigger": "git:commit",
+    "action": "memory/일일 로그에 git 커밋 기록 추가",
+    "priority": "low"
+  },
+  {
+    "trigger": "insta:posted",
+    "action": "콘텐츠 발행 이벤트를 memory/일일 로그에 기록하고 performance-tracker 참고",
+    "priority": "medium"
+  },
+  {
+    "trigger": "cardnews:created",
+    "action": "형님에게 카드뉴스 완성 알림 + 업로드 여부 확인",
+    "priority": "medium",
+    "requiresApproval": true
+  },
+  {
+    "trigger": "competitor:analyzed",
+    "action": "분석 결과 요약을 memory/일일 로그에 기록",
+    "priority": "low"
+  },
+  {
+    "trigger": "self-eval:completed",
+    "action": "memory/consolidated/growth.md에 자기평가 결과 반영",
+    "priority": "medium"
+  },
+  {
+    "trigger": "think-tank:insight",
+    "action": "인사이트를 memory/일일 로그에 기록 + 형님 제안 고려",
+    "priority": "low"
+  },
+  {
+    "trigger": "code-review:passed",
+    "action": "git 자동 커밋 가능 여부 확인 후 실행",
+    "priority": "medium",
+    "requiresApproval": true
+  },
+  {
+    "trigger": "error:*",
+    "action": "에러를 events/errors.jsonl에 기록하고, 심각도 높으면 형님 알림",
+    "priority": "high"
+  },
+  {
+    "trigger": "tokenmeter:high-cost",
+    "action": "토큰 비용 경고를 형님에게 알림",
+    "priority": "high",
+    "condition": "cost > 500"
+  },
+  {
+    "trigger": "release:published",
+    "action": "릴리즈 기록을 memory/일일 로그에 추가 + 릴리즈 쿨다운 시작",
+    "priority": "medium"
+  }
+]

package/hooks/event-bus/emit.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+# 이벤트 발행 헬퍼
+# 사용: ./emit.sh <event_name> <source> [data_json]
+# 예시: ./emit.sh "git:commit" "git-auto" '{"branch":"main","message":"feat: hook engine"}'
+
+EVENT="${1:?이벤트명 필요 (예: git:commit)}"
+SOURCE="${2:?소스 필요 (예: git-auto)}"
+DATA="${3:-{}}"
+TS=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+QUEUE_FILE="${HOME}/.openclaw/workspace/events/queue.jsonl"
+
+# events 디렉토리 확보
+mkdir -p "$(dirname "$QUEUE_FILE")"
+
+# JSONL 한 줄 추가
+echo "{\"event\":\"${EVENT}\",\"source\":\"${SOURCE}\",\"data\":${DATA},\"ts\":\"${TS}\",\"processed\":false}" >> "$QUEUE_FILE"
+
+echo "[emit] ✅ ${EVENT} from ${SOURCE}"

package/hooks/event-bus/handler.ts

@@ -0,0 +1,156 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Event Bus Hook
+ * 
+ * 이벤트: agent:bootstrap
+ * 세션 시작 시 이벤트 큐를 체크하고, 미처리 이벤트에 대한 후속 작업을 주입.
+ * 토큰 비용: 미처리 이벤트 없으면 0. 있으면 체이닝 지시문 ~50-200 토큰.
+ */
+
+const QUEUE_FILE = 'events/queue.jsonl';
+const CHAINS_FILE = 'hooks/event-bus/chains.json';
+const MAX_QUEUE = 100;
+const MAX_PENDING_ACTIONS = 3; // 한 세션에서 처리할 최대 체이닝 수
+
+interface QueueEvent {
+  event: string;
+  source: string;
+  data?: any;
+  ts: string;
+  processed: boolean;
+  processedAt?: string;
+}
+
+interface ChainRule {
+  trigger: string;
+  action: string;
+  priority: 'low' | 'medium' | 'high';
+  requiresApproval?: boolean;
+  condition?: string;
+}
+
+export default async function handler(event: any): Promise<void> {
+  try {
+    if (event.type !== 'agent' || event.action !== 'bootstrap') return;
+
+    const workspace = event.workspace || event.context?.workspaceDir || process.cwd();
+    const queuePath = path.join(workspace, QUEUE_FILE);
+    const chainsPath = path.join(workspace, CHAINS_FILE);
+
+    // 큐 파일 없으면 할 일 없음
+    if (!fs.existsSync(queuePath)) {
+      console.log('[event-bus] No queue file, skipping');
+      return;
+    }
+
+    // 큐 읽기
+    const lines = fs.readFileSync(queuePath, 'utf-8')
+      .split('\n')
+      .filter(l => l.trim());
+
+    const events: QueueEvent[] = lines.map(l => {
+      try { return JSON.parse(l); }
+      catch { return null; }
+    }).filter(Boolean);
+
+    // 미처리 이벤트만
+    const pending = events.filter(e => !e.processed);
+
+    if (pending.length === 0) {
+      console.log('[event-bus] No pending events');
+      // 큐 정리 (7일+ 처리된 이벤트 삭제)
+      cleanOldEvents(events, queuePath);
+      return;
+    }
+
+    console.log(`[event-bus] 🔀 ${pending.length} pending event(s) found`);
+
+    // 체이닝 규칙 로드
+    let chains: ChainRule[] = [];
+    if (fs.existsSync(chainsPath)) {
+      chains = JSON.parse(fs.readFileSync(chainsPath, 'utf-8'));
+    }
+
+    // 매칭 + 액션 생성
+    const actions: string[] = [];
+    const processedIndices: number[] = [];
+
+    for (const pendingEvent of pending) {
+      if (actions.length >= MAX_PENDING_ACTIONS) break;
+
+      const matchedChains = findMatchingChains(pendingEvent.event, chains);
+
+      for (const chain of matchedChains) {
+        if (actions.length >= MAX_PENDING_ACTIONS) break;
+
+        const actionText = chain.requiresApproval
+          ? `[승인 필요] ${chain.action} (이벤트: ${pendingEvent.event}, 소스: ${pendingEvent.source})`
+          : `${chain.action} (이벤트: ${pendingEvent.event}, 소스: ${pendingEvent.source})`;
+
+        actions.push(`- [${chain.priority}] ${actionText}`);
+      }
+
+      // 처리 완료 마킹
+      pendingEvent.processed = true;
+      pendingEvent.processedAt = new Date().toISOString();
+    }
+
+    // 큐 파일 업데이트
+    const updatedLines = events.map(e => JSON.stringify(e));
+    
+    // 큐 크기 제한
+    const trimmed = updatedLines.length > MAX_QUEUE
+      ? updatedLines.slice(-MAX_QUEUE)
+      : updatedLines;
+    
+    fs.writeFileSync(queuePath, trimmed.join('\n') + '\n', 'utf-8');
+
+    // 에이전트에게 체이닝 작업 알림
+    if (actions.length > 0 && event.messages && Array.isArray(event.messages)) {
+      const actionList = actions.join('\n');
+      event.messages.push({
+        role: 'system',
+        content: `🔀 [event-bus] 미처리 이벤트 ${pending.length}건 감지. 후속 작업:\n${actionList}\n\n우선순위 높은 것부터 처리하되, [승인 필요] 항목은 형님 확인 후 실행.`,
+      });
+      console.log(`[event-bus] ✅ ${actions.length} chain action(s) injected`);
+    }
+
+  } catch (error) {
+    console.error('[event-bus] Error (non-fatal):', error);
+  }
+}
+
+function findMatchingChains(eventName: string, chains: ChainRule[]): ChainRule[] {
+  return chains.filter(chain => {
+    const trigger = chain.trigger;
+    
+    // 와일드카드 매칭 (error:*)
+    if (trigger.endsWith(':*')) {
+      const prefix = trigger.slice(0, -1); // "error:"
+      return eventName.startsWith(prefix);
+    }
+    
+    // 정확 매칭
+    return trigger === eventName;
+  });
+}
+
+function cleanOldEvents(events: QueueEvent[], queuePath: string): void {
+  try {
+    const sevenDaysAgo = Date.now() - (7 * 24 * 60 * 60 * 1000);
+    const cleaned = events.filter(e => {
+      if (!e.processed || !e.processedAt) return true;
+      return new Date(e.processedAt).getTime() > sevenDaysAgo;
+    });
+
+    if (cleaned.length < events.length) {
+      const lines = cleaned.map(e => JSON.stringify(e));
+      fs.writeFileSync(queuePath, lines.join('\n') + '\n', 'utf-8');
+      console.log(`[event-bus] 🧹 Cleaned ${events.length - cleaned.length} old events`);
+    }
+  } catch {
+    // 정리 실패 무시
+  }
+}