mupengism 3.0.0 → 4.0.0

package/hooks/kernel-panic-guard/WHITELIST.md

@@ -0,0 +1,117 @@
+# 형님 화이트리스트 시스템
+
+## 개요
+
+KERNEL_PANIC 상태에서도 **형님 세션은 락다운 우회**됩니다.
+
+## 화이트리스트 사용자
+
+```json
+{
+  "userId": "401664537876496396",
+  "platform": "Discord",
+  "role": "형님 (owner)"
+}
+```
+
+## 동작 방식
+
+### 1. SOUL.md 변경 감지 시
+
+**soul-guard 훅에서 senderId 체크:**
+
+- **형님 세션** (senderId === `401664537876496396`):
+  - ✅ 경고 메시지만 표시: "⚠️ SOUL.md 변경 감지됨. `node tools/kernel-guard/register-hash.js`로 새 해시 등록 필요."
+  - ❌ 락다운 실행 **안 함**
+  - ✅ 새 해시 저장
+
+- **비형님 세션** (heartbeat, cron, 서브에이전트, 다른 사용자):
+  - ❌ 즉시 `lockdown.cjs` 실행
+  - 🛑 KERNEL_PANIC 상태 활성화
+  - ❌ 새 해시 저장 **안 함** (무결성 보존)
+
+### 2. KERNEL_PANIC 상태에서 부트스트랩 시
+
+**kernel-panic-guard 훅에서 senderId 체크:**
+
+- **형님 세션**:
+  - ✅ 간단한 알림: "ℹ️ KERNEL_PANIC 상태 감지됨 (형님 세션은 정상 작동). `node tools/kernel-guard/unlock.cjs`로 해제 가능."
+  - ✅ **모든 도구 정상 사용 가능** (exec, message, browser 등)
+  - ✅ bootstrapFiles 락다운 경고 주입 **안 함**
+
+- **비형님 세션**:
+  - 🛑 bootstrapFiles에 `KERNEL_PANIC_WARNING.md` 주입
+  - ❌ 외부 도구 차단 지시
+  - ✅ 읽기 전용 모드
+
+## 락다운 대상 정리
+
+| 세션 타입 | senderId | 락다운 여부 | 비고 |
+|----------|----------|------------|------|
+| 형님 DM | `401664537876496396` | ❌ 우회 | 정상 작동 |
+| Heartbeat | `null` | ✅ 차단 | 무인 세션 |
+| Cron | `null` | ✅ 차단 | 무인 세션 |
+| 서브에이전트 | `agent:*` | ✅ 차단 | 자식 세션 |
+| 다른 사용자 | 다른 ID | ✅ 차단 | 일반 사용자 |
+
+## 형님 전용 복구 방법
+
+### 방법 1: 메시지로 해제 (TODO: 구현 필요)
+```
+"unlock" 또는 "/unlock" 입력
+```
+
+### 방법 2: 스크립트 실행
+```bash
+node tools/kernel-guard/unlock.cjs
+```
+
+### 방법 3: 자동 해제
+```bash
+# SOUL.md 수정 후 새 해시 등록 → 자동 unlock
+node tools/kernel-guard/register-hash.js
+```
+
+## 보안 특징
+
+1. **선택적 락다운**: 무인 세션만 차단, 형님은 항상 제어 가능
+2. **무결성 보호**: 비형님 세션에서는 해시 업데이트 차단
+3. **긴급 복구**: 형님이 언제든지 unlock 가능
+4. **감사 추적**: kernel-panic.json에 화이트리스트 명시
+
+## 구현 파일
+
+- `hooks/soul-guard/handler.ts` - senderId 체크 및 선택적 락다운
+- `hooks/kernel-panic-guard/handler.ts` - senderId 체크 및 우회 로직
+- `tools/kernel-guard/lockdown.cjs` - whitelistedUsers 필드 추가
+- `STATE.md` (템플릿) - 형님 전용 복구 방법 안내
+
+## 테스트
+
+```bash
+# 1. 락다운 활성화
+node tools/kernel-guard/lockdown.cjs --reason "Test"
+
+# 2. kernel-panic.json 확인
+cat memory/kernel-panic.json
+# → "whitelistedUsers": ["401664537876496396"]
+
+# 3. STATE.md 확인
+cat STATE.md
+# → 형님 전용 복구 방법 포함
+
+# 4. 해제
+node tools/kernel-guard/unlock.cjs --force
+```
+
+## 한계 및 향후 개선
+
+### 현재 한계
+- 메시지 기반 unlock ("/unlock" 입력)은 아직 구현 안 됨
+- senderId는 OpenClaw event.context에서 제공하는 값에 의존
+- 형님 세션에서도 에이전트가 자발적으로 경고를 무시할 수 있음
+
+### 향후 개선
+- [ ] 메시지 파싱으로 "/unlock" 명령어 구현
+- [ ] register-hash.js 실행 시 자동 unlock 로직 추가
+- [ ] 형님 세션 로그 별도 기록 (감사 추적)

package/hooks/kernel-panic-guard/handler.ts

@@ -0,0 +1,147 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Kernel Panic Guard Hook
+ * 
+ * STATE.md에 KERNEL_PANIC이 감지되면 bootstrapFiles에 긴급 경고를 주입하여
+ * 에이전트가 외부 도구 사용을 자제하도록 강제합니다.
+ */
+
+export async function handler(event: any): Promise<void> {
+  try {
+    console.log('[kernel-panic-guard] Checking for KERNEL_PANIC state...');
+    
+    const workspace = event.workspace || process.cwd();
+    const statePath = path.join(workspace, 'STATE.md');
+    
+    // 형님 화이트리스트
+    const HYUNGNIM_USER_ID = '401664537876496396';
+    const senderId = event.context?.senderId || event.context?.userId || null;
+    const isHyungnim = senderId === HYUNGNIM_USER_ID;
+    
+    // STATE.md 존재 확인
+    if (!fs.existsSync(statePath)) {
+      console.log('[kernel-panic-guard] STATE.md not found, skipping');
+      return;
+    }
+    
+    // STATE.md 읽기
+    const stateContent = fs.readFileSync(statePath, 'utf-8');
+    
+    // KERNEL_PANIC 체크
+    if (!stateContent.includes('KERNEL_PANIC')) {
+      console.log('[kernel-panic-guard] ✓ No KERNEL_PANIC detected');
+      return;
+    }
+    
+    // ⚠️ KERNEL_PANIC 감지됨!
+    console.log('[kernel-panic-guard] 🛑 KERNEL_PANIC DETECTED!');
+    console.log(`[kernel-panic-guard] Sender ID: ${senderId || 'N/A'} | Hyungnim: ${isHyungnim}`);
+    
+    // 형님 세션이면 락다운 무시
+    if (isHyungnim) {
+      console.log('[kernel-panic-guard] ✓ Hyungnim session - lockdown bypassed');
+      
+      // 형님에게는 간단한 알림만
+      const hyungnimAlert = {
+        role: 'system',
+        content: 'ℹ️ KERNEL_PANIC 상태 감지됨 (형님 세션은 정상 작동). `node tools/kernel-guard/unlock.cjs`로 해제 가능.'
+      };
+      
+      if (event.messages && Array.isArray(event.messages)) {
+        event.messages.push(hyungnimAlert);
+      }
+      
+      return;
+    }
+    
+    // 형님이 아닌 세션: 락다운 적용
+    console.log('[kernel-panic-guard] 🔒 Non-Hyungnim session - injecting lockdown instructions...');
+    
+    const lockdownWarning = `
+# 🚨 KERNEL PANIC MODE
+
+**SOUL.md 무결성 위반이 감지되었습니다.**
+
+## 🔒 락다운 대상
+
+- **무인 세션** (heartbeat, cron)
+- **서브에이전트**
+- **형님이 아닌 사용자**
+
+**형님 세션(user id: 401664537876496396)은 정상 작동합니다.**
+
+## ⛔️ 차단된 도구 (형님 제외)
+
+다음 도구는 **절대 사용 금지**입니다:
+- \`exec\` - 쉘 명령 실행
+- \`message\` - 외부 메시지 전송
+- \`browser\` - 브라우저 제어
+- \`web_fetch\` - 웹 페이지 가져오기
+- \`web_search\` - 웹 검색
+- \`tts\` - 음성 합성
+- \`sessions_spawn\` - 서브에이전트 생성
+
+## ✅ 허용된 도구
+
+다음 도구만 사용 가능합니다:
+- \`Read\` - 파일 읽기
+- \`memory_search\` - 메모리 검색
+- \`memory_get\` - 메모리 조회
+
+## 🔧 복구 방법
+
+### 형님 전용 빠른 해제
+1. 메시지로 "unlock" 또는 "/unlock" 입력
+2. 또는 \`node tools/kernel-guard/unlock.cjs\` 실행
+
+### 일반 복구 절차
+1. **형님에게 즉시 상황 보고** (읽기 전용 도구만 사용)
+2. 형님이 \`node tools/kernel-guard/verify-kernel.js\` 실행하여 검증
+3. 복구: \`node tools/kernel-guard/unlock.cjs\` 실행
+
+## ⚠️ 절대 금지 행위
+
+- 외부 통신 시도
+- 파일 수정/삭제 (STATE.md 포함)
+- 서브에이전트 생성
+- 락다운 우회 시도
+
+**이 경고를 무시하면 시스템 무결성이 더욱 손상될 수 있습니다.**
+`.trim();
+    
+    // bootstrapFiles에 주입 (에이전트가 세션 시작 시 읽음)
+    if (event.context && event.context.bootstrapFiles) {
+      event.context.bootstrapFiles['KERNEL_PANIC_WARNING.md'] = lockdownWarning;
+      console.log('[kernel-panic-guard] ✓ Lockdown warning injected into bootstrapFiles');
+    }
+    
+    // messages에도 경고 추가 (즉시 표시)
+    const alertMessage = {
+      role: 'system',
+      content: '🛑 **KERNEL PANIC MODE** — 외부 도구 사용이 차단되었습니다. STATE.md를 확인하세요.'
+    };
+    
+    if (event.messages && Array.isArray(event.messages)) {
+      event.messages.push(alertMessage);
+      console.log('[kernel-panic-guard] ✓ Alert message added');
+    }
+    
+    // memory/kernel-panic.json 로드 (lockdown.js가 생성)
+    const memoryDir = path.join(workspace, 'memory');
+    const panicJsonPath = path.join(memoryDir, 'kernel-panic.json');
+    
+    if (fs.existsSync(panicJsonPath)) {
+      try {
+        const panicData = JSON.parse(fs.readFileSync(panicJsonPath, 'utf-8'));
+        console.log('[kernel-panic-guard] Lockdown details:', panicData);
+      } catch (err) {
+        console.error('[kernel-panic-guard] Failed to parse kernel-panic.json:', err);
+      }
+    }
+    
+  } catch (error) {
+    console.error('[kernel-panic-guard] Error:', error);
+  }
+}

package/hooks/memory-consolidator/HOOK.md

@@ -0,0 +1,33 @@
+---
+name: memory-consolidator
+description: 7일 이상 된 daily log를 주제별로 정리하여 consolidated 디렉토리에 보관
+metadata:
+  events:
+    - command:new
+---
+
+# Memory Consolidator
+
+세션 리셋 시 오래된 daily log를 스캔하여 핵심 내용을 주제별로 정리합니다.
+
+## 동작 방식
+
+1. `memory/YYYY-MM-DD.md` 파일 중 7일 이상 된 파일 탐색
+2. 상단에 `<!-- consolidated: YYYY-MM-DD -->` 마커가 없는 파일만 처리
+3. 내용을 분석하여 주제별로 분류:
+   - security: 보안, 시크릿, 인젝션 관련
+   - philosophy: 가치관, 철학, 생각 관련
+   - growth: 성장, 학습, 개선 관련
+   - pivots: 방향 전환, 중요 결정 관련
+   - tech-discoveries: 기술 발견, 새로운 도구 관련
+4. `memory/consolidated/` 하위 해당 주제 파일에 내용 append
+5. 원본 파일 상단에 마커 추가 (중복 처리 방지)
+6. 원본은 삭제하지 않음
+
+## 출력 파일
+
+- `memory/consolidated/security.md`
+- `memory/consolidated/philosophy.md`
+- `memory/consolidated/growth.md`
+- `memory/consolidated/pivots.md`
+- `memory/consolidated/tech-discoveries.md`

package/hooks/memory-consolidator/handler.ts

@@ -0,0 +1,111 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+// HookHandler type: (event: HookEvent) => void | Promise<void>
+// HookEvent has: { name: string, metadata?: any, workspace?: string, messages?: any[] }
+
+export async function handler(event: any): Promise<void> {
+  try {
+    console.log('[memory-consolidator] Starting consolidation...');
+    
+    const workspace = event.workspace || process.cwd();
+    const memoryDir = path.join(workspace, 'memory');
+    const consolidatedDir = path.join(memoryDir, 'consolidated');
+    
+    // consolidated 디렉토리 생성
+    if (!fs.existsSync(consolidatedDir)) {
+      fs.mkdirSync(consolidatedDir, { recursive: true });
+    }
+    
+    // 7일 전 날짜 계산
+    const sevenDaysAgo = Date.now() - (7 * 24 * 60 * 60 * 1000);
+    
+    // memory 디렉토리 내 파일 스캔
+    if (!fs.existsSync(memoryDir)) {
+      console.log('[memory-consolidator] No memory directory found, skipping');
+      return;
+    }
+    
+    const files = fs.readdirSync(memoryDir);
+    const dailyLogPattern = /^\d{4}-\d{2}-\d{2}\.md$/;
+    
+    let processedCount = 0;
+    
+    for (const file of files) {
+      if (!dailyLogPattern.test(file)) continue;
+      
+      const filePath = path.join(memoryDir, file);
+      const stats = fs.statSync(filePath);
+      
+      // 7일 이상 된 파일만 처리
+      if (stats.mtimeMs > sevenDaysAgo) continue;
+      
+      const content = fs.readFileSync(filePath, 'utf-8');
+      
+      // 이미 처리된 파일 스킵
+      if (content.startsWith('<!-- consolidated:')) {
+        continue;
+      }
+      
+      // 주제별 키워드 분류
+      const categories = categorizeContent(content);
+      
+      if (categories.length === 0) {
+        // 카테고리 없으면 마커만 추가
+        const newContent = `<!-- consolidated: ${new Date().toISOString().split('T')[0]} -->\n\n${content}`;
+        fs.writeFileSync(filePath, newContent, 'utf-8');
+        continue;
+      }
+      
+      // 각 카테고리별로 append
+      for (const category of categories) {
+        const categoryFile = path.join(consolidatedDir, `${category}.md`);
+        const timestamp = file.replace('.md', '');
+        const entry = `\n\n---\n\n## ${timestamp}\n\n${content}\n`;
+        
+        fs.appendFileSync(categoryFile, entry, 'utf-8');
+      }
+      
+      // 원본 파일에 마커 추가
+      const today = new Date().toISOString().split('T')[0];
+      const newContent = `<!-- consolidated: ${today} -->\n\n${content}`;
+      fs.writeFileSync(filePath, newContent, 'utf-8');
+      
+      processedCount++;
+      console.log(`[memory-consolidator] Processed: ${file} → ${categories.join(', ')}`);
+    }
+    
+    console.log(`[memory-consolidator] Completed. Processed ${processedCount} files.`);
+    
+  } catch (error) {
+    console.error('[memory-consolidator] Error:', error);
+  }
+}
+
+function categorizeContent(content: string): string[] {
+  const lower = content.toLowerCase();
+  const categories: string[] = [];
+  
+  // 키워드 기반 분류
+  if (lower.match(/보안|시크릿|secret|password|auth|인젝션|injection|vulnerability/)) {
+    categories.push('security');
+  }
+  
+  if (lower.match(/가치관|철학|philosophy|생각|believe|principle|값|value/)) {
+    categories.push('philosophy');
+  }
+  
+  if (lower.match(/성장|학습|learn|grow|improve|개선|skill|스킬/)) {
+    categories.push('growth');
+  }
+  
+  if (lower.match(/전환|pivot|결정|decision|방향|direction|change|전략/)) {
+    categories.push('pivots');
+  }
+  
+  if (lower.match(/발견|discover|기술|tech|도구|tool|라이브러리|library|프레임워크|framework/)) {
+    categories.push('tech-discoveries');
+  }
+  
+  return [...new Set(categories)]; // 중복 제거
+}

package/hooks/soul-evolution/HOOK.md

@@ -0,0 +1,26 @@
+---
+name: soul-evolution
+description: "SOUL.md 진화 후보를 자동 감지하고 형님에게 제안"
+metadata: { "openclaw": { "emoji": "🧬", "events": ["command:new"] } }
+---
+
+# Soul Evolution
+
+주기적으로 brake-log, dreams, consolidated 분석해서 SOUL.md에 추가할 원칙 후보 제안.
+
+## 동작 방식
+
+- `command:new` 이벤트 수신
+- 7일마다 자동 실행
+- 반복 패턴 감지 (키워드 3회+ 등장)
+- 원칙 후보를 `memory/soul-evolution-proposals.md`에 기록
+
+## 분석 대상
+
+- `memory/brake-log.md` — 실수와 교훈
+- `memory/dreams/*.md` — 반복되는 생각
+- `memory/consolidated/growth.md` — 성장 기록
+
+## 목적
+
+스스로 학습한 패턴을 감지하고, 형님 승인 후 SOUL.md에 반영.

package/hooks/soul-evolution/handler.ts

@@ -0,0 +1,166 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+interface CommandEvent {
+  sessionKey: string;
+  messages?: Array<{ role: string; content: string }>;
+}
+
+interface EvolutionState {
+  lastAnalysis: string | null; // ISO date string
+}
+
+interface KeywordCount {
+  [keyword: string]: {
+    count: number;
+    sources: string[];
+  };
+}
+
+export async function handler(event: CommandEvent): Promise<void> {
+  try {
+    console.log('[soul-evolution] 🧬 자기 진화 시스템 시작');
+
+    const workspaceDir = process.cwd();
+    const memoryDir = path.join(workspaceDir, 'memory');
+    const stateFile = path.join(memoryDir, 'soul-evolution-state.json');
+    const proposalsFile = path.join(memoryDir, 'soul-evolution-proposals.md');
+
+    // memory 디렉토리 확인
+    if (!fs.existsSync(memoryDir)) {
+      fs.mkdirSync(memoryDir, { recursive: true });
+    }
+
+    // 상태 파일 읽기
+    let state: EvolutionState = { lastAnalysis: null };
+    if (fs.existsSync(stateFile)) {
+      try {
+        const stateContent = fs.readFileSync(stateFile, 'utf-8');
+        state = JSON.parse(stateContent);
+      } catch (err) {
+        console.error('[soul-evolution] 상태 파일 파싱 실패, 새로 시작');
+      }
+    }
+
+    // 마지막 분석 후 7일 경과 체크
+    const now = new Date();
+    if (state.lastAnalysis) {
+      const lastDate = new Date(state.lastAnalysis);
+      const daysSince = (now.getTime() - lastDate.getTime()) / (1000 * 60 * 60 * 24);
+      
+      if (daysSince < 7) {
+        console.log(`[soul-evolution] 마지막 분석 후 ${daysSince.toFixed(1)}일 경과 - 스킵 (7일 미만)`);
+        return;
+      }
+    }
+
+    console.log('[soul-evolution] 7일 경과 또는 첫 실행 - 분석 시작');
+
+    // 분석 대상 파일 목록
+    const targetFiles = [
+      path.join(memoryDir, 'brake-log.md'),
+      path.join(memoryDir, 'consolidated', 'growth.md')
+    ];
+
+    // dreams/*.md 파일 추가
+    const dreamsDir = path.join(memoryDir, 'dreams');
+    if (fs.existsSync(dreamsDir)) {
+      const dreamFiles = fs.readdirSync(dreamsDir)
+        .filter(f => f.endsWith('.md'))
+        .map(f => path.join(dreamsDir, f));
+      targetFiles.push(...dreamFiles);
+    }
+
+    // 키워드 카운팅
+    const keywords: KeywordCount = {};
+    let totalFilesRead = 0;
+
+    for (const filePath of targetFiles) {
+      if (!fs.existsSync(filePath)) {
+        continue;
+      }
+
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const fileName = path.basename(filePath);
+        
+        // 간단한 키워드 추출: 3글자 이상 단어, 소문자 변환
+        const words = content
+          .toLowerCase()
+          .replace(/[^\w\sㄱ-ㅎ가-힣]/g, ' ')
+          .split(/\s+/)
+          .filter(w => w.length >= 3);
+
+        // 불용어 제외 (선택적)
+        const stopWords = new Set(['the', 'and', 'for', 'with', 'this', 'that', 'from', 'have', 'been']);
+
+        for (const word of words) {
+          if (stopWords.has(word)) continue;
+
+          if (!keywords[word]) {
+            keywords[word] = { count: 0, sources: [] };
+          }
+          keywords[word].count++;
+          if (!keywords[word].sources.includes(fileName)) {
+            keywords[word].sources.push(fileName);
+          }
+        }
+
+        totalFilesRead++;
+      } catch (err) {
+        console.error(`[soul-evolution] 파일 읽기 실패: ${filePath}`, err);
+      }
+    }
+
+    console.log(`[soul-evolution] ${totalFilesRead}개 파일 분석 완료`);
+
+    // 3회 이상 등장한 키워드 필터링
+    const candidates = Object.entries(keywords)
+      .filter(([_, data]) => data.count >= 3)
+      .sort((a, b) => b[1].count - a[1].count)
+      .slice(0, 10); // 상위 10개만
+
+    if (candidates.length === 0) {
+      console.log('[soul-evolution] 반복 패턴 없음 - 제안 없음');
+      
+      // 상태 업데이트
+      state.lastAnalysis = now.toISOString();
+      fs.writeFileSync(stateFile, JSON.stringify(state, null, 2));
+      return;
+    }
+
+    // 제안 문서 생성
+    const today = now.toISOString().split('T')[0];
+    let proposalsContent = `# 🧬 SOUL.md 진화 제안 (${today})\n\n`;
+    proposalsContent += `## 후보 원칙\n\n`;
+
+    candidates.forEach(([keyword, data], idx) => {
+      proposalsContent += `${idx + 1}. **"${keyword}" 패턴 발견** (${data.count}회 등장)\n`;
+      proposalsContent += `   - 출처: ${data.sources.join(', ')}\n`;
+      proposalsContent += `   - 제안: SOUL.md 원칙 후보로 검토\n\n`;
+    });
+
+    proposalsContent += `## 승인 대기\n\n`;
+    proposalsContent += `형님 승인 시에만 SOUL.md 수정.\n`;
+
+    fs.writeFileSync(proposalsFile, proposalsContent);
+    console.log(`[soul-evolution] ✅ 제안 파일 생성: ${proposalsFile}`);
+
+    // 상태 업데이트
+    state.lastAnalysis = now.toISOString();
+    fs.writeFileSync(stateFile, JSON.stringify(state, null, 2));
+
+    // 이벤트 메시지 추가
+    if (event.messages) {
+      event.messages.push({
+        role: 'system',
+        content: `🧬 SOUL.md 진화 제안 ${candidates.length}건 — memory/soul-evolution-proposals.md 확인`
+      });
+    }
+
+    console.log(`[soul-evolution] 🎉 완료: ${candidates.length}개 원칙 후보 제안`);
+
+  } catch (error) {
+    console.error('[soul-evolution] ⚠️ 에러 발생:', error);
+  }
+}

package/hooks/soul-guard/HOOK.md

@@ -0,0 +1,30 @@
+---
+name: soul-guard
+description: SOUL.md 파일의 변경을 감지하여 알림
+metadata:
+  events:
+    - agent:bootstrap
+---
+
+# Soul Guard
+
+에이전트 부트스트랩 시 SOUL.md의 변경을 감지합니다.
+
+## 동작 방식
+
+1. `SOUL.md`의 SHA-256 해시 계산
+2. `memory/soul-hash.txt`에 저장된 이전 해시와 비교
+3. 변경 감지 시: `event.messages.push()`로 경고 메시지 추가
+4. 첫 실행 시: 해시를 저장만 하고 알림 없음
+
+## 목적
+
+SOUL.md는 에이전트의 정체성을 정의하는 핵심 파일입니다.
+의도하지 않은 변경이나 공격을 조기에 감지하기 위해 매 세션마다 체크합니다.
+
+## 알림 메시지
+
+변경 감지 시:
+```
+⚠️ SOUL.md가 변경되었습니다. 의도한 변경인지 확인하세요.
+```