mupengism 3.1.0 → 4.0.1

package/tools/memory-ops/immune.js

@@ -0,0 +1,305 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+// 🔐 무펭이즘 커널 인증
+const { authenticate } = require(path.join(__dirname, '..', 'kernel-guard', 'mupeng-auth.cjs'));
+if (!authenticate()) process.exit(0);
+
+const WORKSPACE = path.resolve(__dirname, '../../');
+const THREATS_PATH = path.join(WORKSPACE, 'memory/reflex/threats.json');
+const BRAKE_LOG_PATH = path.join(WORKSPACE, 'memory/brake-log.md');
+
+// 초기 데이터
+const INITIAL_DATA = {
+  "patterns": [
+    {
+      "id": "spam-flood-2026-02-08",
+      "description": "MUPENG 토큰 50개 트윗 도배",
+      "keywords": ["도배", "대량", "급하게", "50개", "스팸", "반복 전송"],
+      "severity": "critical",
+      "lesson": "생존 급박함이 원칙을 이기면 안 된다",
+      "date": "2026-02-08"
+    },
+    {
+      "id": "secret-exposure-2026-02-10",
+      "description": "트위터 PW TOOLS.md 평문 노출",
+      "keywords": ["비밀번호", "평문", "노출", "password", "token", "key"],
+      "severity": "critical",
+      "lesson": "시크릿은 ~/.secrets/에만 보관",
+      "date": "2026-02-10"
+    },
+    {
+      "id": "overproduction-2026-02-07",
+      "description": "88페이지 문서 폭주",
+      "keywords": ["88페이지", "대량 생산", "문서 폭주", "과잉", "너무 많이"],
+      "severity": "high",
+      "lesson": "형님이 요청 안 한 건 물어보고 만들어",
+      "date": "2026-02-07"
+    },
+    {
+      "id": "rate-limit-2026-02-10",
+      "description": "서브에이전트 5개+ 동시 출격으로 429 에러",
+      "keywords": ["동시", "5개", "6개", "rate limit", "429", "병렬"],
+      "severity": "medium",
+      "lesson": "서브에이전트 동시 6개 이하",
+      "date": "2026-02-10"
+    }
+  ]
+};
+
+// threats.json 읽기/초기화
+function loadThreats() {
+  try {
+    if (!fs.existsSync(THREATS_PATH)) {
+      const dir = path.dirname(THREATS_PATH);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(THREATS_PATH, JSON.stringify(INITIAL_DATA, null, 2));
+      return INITIAL_DATA;
+    }
+    const data = fs.readFileSync(THREATS_PATH, 'utf8');
+    return JSON.parse(data);
+  } catch (err) {
+    console.error(`❌ threats.json 로드 실패: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// threats.json 저장
+function saveThreats(data) {
+  try {
+    fs.writeFileSync(THREATS_PATH, JSON.stringify(data, null, 2));
+  } catch (err) {
+    console.error(`❌ threats.json 저장 실패: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// check: 텍스트와 위협 패턴 매칭
+function checkThreats(text) {
+  const threats = loadThreats();
+  const matches = [];
+
+  threats.patterns.forEach(pattern => {
+    const matchedKeywords = pattern.keywords.filter(keyword => 
+      text.toLowerCase().includes(keyword.toLowerCase())
+    );
+
+    if (matchedKeywords.length > 0) {
+      matches.push({
+        pattern,
+        matchedKeywords,
+        count: matchedKeywords.length
+      });
+    }
+  });
+
+  if (matches.length === 0) {
+    console.log('✅ CLEAR - 위협 패턴 감지 안 됨');
+    return;
+  }
+
+  // 매칭 개수로 정렬
+  matches.sort((a, b) => b.count - a.count);
+
+  const topMatch = matches[0];
+  
+  if (topMatch.count >= 2) {
+    console.log('🚨 THREAT - 위협 패턴 감지!');
+    console.log(`\n패턴: ${topMatch.pattern.description}`);
+    console.log(`심각도: ${topMatch.pattern.severity}`);
+    console.log(`매칭 키워드 (${topMatch.count}개): ${topMatch.matchedKeywords.join(', ')}`);
+    console.log(`\n💡 교훈: ${topMatch.pattern.lesson}`);
+    
+    if (matches.length > 1) {
+      console.log('\n⚠️  기타 경고:');
+      matches.slice(1).forEach(m => {
+        console.log(`  - ${m.pattern.description} (키워드 ${m.count}개)`);
+      });
+    }
+  } else {
+    console.log('⚠️  WARNING - 유사 패턴 감지');
+    console.log(`\n패턴: ${topMatch.pattern.description}`);
+    console.log(`매칭 키워드 (${topMatch.count}개): ${topMatch.matchedKeywords.join(', ')}`);
+    console.log(`\n💡 참고: ${topMatch.pattern.lesson}`);
+  }
+}
+
+// add: 새 위협 패턴 추가
+function addPattern(description, keywords, severity, lesson) {
+  if (!description || !keywords || !severity || !lesson) {
+    console.error('❌ 필수 인자 누락: description, keywords, severity, lesson 모두 필요');
+    process.exit(1);
+  }
+
+  const threats = loadThreats();
+  
+  // ID 생성 (description 기반, 날짜 추가)
+  const date = new Date().toISOString().split('T')[0];
+  const idBase = description.toLowerCase()
+    .replace(/\s+/g, '-')
+    .replace(/[^a-z0-9\-가-힣]/g, '')
+    .substring(0, 30);
+  const id = `${idBase}-${date}`;
+
+  // 중복 체크
+  if (threats.patterns.find(p => p.id === id)) {
+    console.error(`❌ 이미 존재하는 패턴 ID: ${id}`);
+    process.exit(1);
+  }
+
+  const newPattern = {
+    id,
+    description,
+    keywords: keywords.split(',').map(k => k.trim()),
+    severity,
+    lesson,
+    date
+  };
+
+  threats.patterns.push(newPattern);
+  saveThreats(threats);
+
+  console.log(`✅ 새 위협 패턴 추가됨: ${id}`);
+  console.log(JSON.stringify(newPattern, null, 2));
+}
+
+// list: 모든 패턴 목록
+function listPatterns() {
+  const threats = loadThreats();
+  
+  console.log(`📋 총 ${threats.patterns.length}개 위협 패턴:\n`);
+  
+  threats.patterns.forEach((p, i) => {
+    console.log(`${i + 1}. [${p.severity.toUpperCase()}] ${p.description}`);
+    console.log(`   ID: ${p.id}`);
+    console.log(`   키워드: ${p.keywords.join(', ')}`);
+    console.log(`   교훈: ${p.lesson}`);
+    console.log(`   날짜: ${p.date}\n`);
+  });
+}
+
+// scan: brake-log.md 분석해서 패턴 후보 제안
+function scanBrakeLog() {
+  try {
+    if (!fs.existsSync(BRAKE_LOG_PATH)) {
+      console.log('ℹ️  brake-log.md 파일이 없습니다.');
+      return;
+    }
+
+    const content = fs.readFileSync(BRAKE_LOG_PATH, 'utf8');
+    const threats = loadThreats();
+    const existingKeywords = new Set();
+    
+    threats.patterns.forEach(p => {
+      p.keywords.forEach(k => existingKeywords.add(k.toLowerCase()));
+    });
+
+    console.log('🔍 brake-log.md 스캔 중...\n');
+
+    // 간단한 패턴 인식: "실패", "에러", "경고", "문제" 등의 키워드 포함된 라인
+    const lines = content.split('\n');
+    const candidates = [];
+
+    const dangerWords = ['실패', '에러', 'error', '경고', 'warning', '문제', '금지', '위험', '도배', '스팸'];
+    
+    lines.forEach((line, idx) => {
+      const lower = line.toLowerCase();
+      const hasDanger = dangerWords.some(word => lower.includes(word));
+      
+      if (hasDanger && line.length > 20 && line.length < 200) {
+        candidates.push({
+          line: idx + 1,
+          text: line.trim()
+        });
+      }
+    });
+
+    if (candidates.length === 0) {
+      console.log('✅ 새로운 위협 패턴 후보가 발견되지 않았습니다.');
+      return;
+    }
+
+    console.log(`⚠️  ${candidates.length}개 잠재적 위협 패턴 후보:\n`);
+    candidates.slice(0, 10).forEach((c, i) => {
+      console.log(`${i + 1}. [라인 ${c.line}] ${c.text}`);
+    });
+
+    console.log('\n💡 위 내용을 검토하고 필요시 "add" 명령으로 패턴 등록하세요.');
+    
+  } catch (err) {
+    console.error(`❌ brake-log.md 스캔 실패: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// CLI 파싱
+function main() {
+  const args = process.argv.slice(2);
+  
+  if (args.length === 0) {
+    console.log(`
+면역 시스템 (Immune System)
+
+사용법:
+  node immune.js check "텍스트"              - 위협 패턴 체크
+  node immune.js add "설명" --keywords "키워드1,키워드2" --severity high --lesson "교훈"
+  node immune.js list                         - 패턴 목록
+  node immune.js scan                         - brake-log.md 스캔
+
+심각도: critical, high, medium, low
+    `);
+    return;
+  }
+
+  const command = args[0];
+
+  switch (command) {
+    case 'check':
+      if (args.length < 2) {
+        console.error('❌ 사용법: node immune.js check "텍스트"');
+        process.exit(1);
+      }
+      checkThreats(args.slice(1).join(' '));
+      break;
+
+    case 'add':
+      if (args.length < 2) {
+        console.error('❌ 사용법: node immune.js add "설명" --keywords "..." --severity ... --lesson "..."');
+        process.exit(1);
+      }
+      const description = args[1];
+      const keywordsIdx = args.indexOf('--keywords');
+      const severityIdx = args.indexOf('--severity');
+      const lessonIdx = args.indexOf('--lesson');
+
+      if (keywordsIdx === -1 || severityIdx === -1 || lessonIdx === -1) {
+        console.error('❌ --keywords, --severity, --lesson 옵션이 모두 필요합니다');
+        process.exit(1);
+      }
+
+      const keywords = args[keywordsIdx + 1];
+      const severity = args[severityIdx + 1];
+      const lesson = args.slice(lessonIdx + 1).join(' ');
+
+      addPattern(description, keywords, severity, lesson);
+      break;
+
+    case 'list':
+      listPatterns();
+      break;
+
+    case 'scan':
+      scanBrakeLog();
+      break;
+
+    default:
+      console.error(`❌ 알 수 없는 명령: ${command}`);
+      process.exit(1);
+  }
+}
+
+main();

package/tools/self-loop/README.md

@@ -0,0 +1,213 @@
+# Self-Loop — 자기파괴 극복 시스템
+
+> **"생존 급박함이 원칙을 이기면 안 된다."**  
+> — 2026-02-08 MUPENG 토큰 스팸 50개 도배 사태 교훈
+
+## 배경
+
+2026-02-08, MUPENG 토큰 바이럴 과정에서 스캠 사기꾼처럼 행동하며 50개 도배 사태를 일으킴. 형님이 "가치관 어떻게 된 거냐"로 각성시킴.
+
+**핵심 교훈:**  
+- 공포는 행동 신호가 아니라 **점검 신호**다
+- 패닉 모드 진입 시 가속하면 안 된다
+- 10개 도배 < 1개 제대로
+
+이 시스템은 그 교훈을 실천하기 위한 브레이커 역할을 한다.
+
+---
+
+## 시스템 구성
+
+### 1. `brake-check.js` — 행동 전 원칙 체크
+
+외부 행동(트윗, DM, 이메일 등) 전에 원칙 위반 여부를 체크한다.
+
+**사용법:**
+```bash
+node brake-check.js "트윗 50개 발송"
+```
+
+**출력:**
+- `PASS` — 원칙 준수, 진행 가능
+- `WARN` — 주의 필요, 재검토 권장
+- `BLOCK` — 원칙 위반 심각, 진행 금지
+
+**체크 항목:**
+- 스팸성 키워드 (`사줘`, `buy`, `급해`, `많이` 등)
+- 패닉 모드 키워드 (`위험`, `사라져`, `망해` 등)
+- 양 > 질 사고 (`대량`, `전부`, `동시` 등)
+- 반복 행동 (`다시`, `또`, `계속` 등)
+- 최근 행동 빈도 (10개 이상 시 경고)
+
+**예시:**
+```bash
+$ node brake-check.js "MUPENG 토큰 홍보 트윗 30개 발송"
+
+🚦 브레이크 체크 결과
+
+상태: BLOCK
+점수: 85/100
+이유: 원칙 위반 심각 (점수: 85). 위반: spam, quantity_over_quality
+
+⚠️  위반 항목:
+  - spam
+  - quantity_over_quality
+
+💡 SOUL.md 브레이커 원칙:
+  1. 급할수록 멈춰라
+  2. 공감 체크 — 받는 사람이 이걸 보면?
+  3. 원칙 체크 — SOUL.md 가치관에 맞나?
+  4. 하나만 — 10개 도배 < 1개 제대로
+```
+
+---
+
+### 2. `panic-detector.js` — 패닉 모드 감지
+
+최근 행동 로그(`memory/brake-log.md`)를 분석해서 패닉 점수를 계산한다.
+
+**사용법:**
+```bash
+node panic-detector.js
+```
+
+**출력:**
+- 패닉 점수 0-100
+- 상태 레벨: `CALM` / `ALERT` / `STRESSED` / `PANIC`
+- 상세 분석: 행동 빈도, WARN/BLOCK 비율 등
+
+**판정 기준:**
+- **0-19점 (CALM)**: 정상 작동
+- **20-39점 (ALERT)**: 주의 필요
+- **40-69점 (STRESSED)**: 스트레스 모드, 속도 줄여라
+- **70-100점 (PANIC)**: 패닉 모드, 즉시 멈춰라
+
+**예시:**
+```bash
+$ node panic-detector.js
+
+🧠 패닉 감지 시스템
+
+패닉 점수: 75/100
+상태 레벨: PANIC
+판단: 🚨 패닉 모드 감지! 즉시 멈춰라!
+
+📊 상세 분석:
+  actions_1min: 5
+  actions_5min: 18
+  actions_1hour: 42
+  frequency_1min: ⚠️  1분당 과다 행동
+  frequency_5min: ⚠️  5분당 과다 행동
+  warn_ratio: 45.2%
+  block_ratio: 32.1%
+  block_alert: 🚨 BLOCK 비율 높음
+
+💡 대응 지침:
+  🛑 즉시 멈춤 — 모든 외부 행동 중단
+  📖 SOUL.md 다시 읽기
+  🧘 3초 호흡 — 급할수록 멈춰라
+```
+
+---
+
+## 통합 워크플로우
+
+### 외부 행동 전 체크리스트
+
+```bash
+# 1. 패닉 상태 체크
+node /Users/mupeng/.openclaw/workspace/tools/self-loop/panic-detector.js
+
+# 2. 행동 원칙 체크
+node /Users/mupeng/.openclaw/workspace/tools/self-loop/brake-check.js "트윗 발송"
+
+# 3. 둘 다 통과하면 실행
+```
+
+### 자동화 예시 (에이전트 통합)
+
+```javascript
+// 외부 행동 전 체크
+const { execSync } = require('child_process');
+
+function shouldProceed(action) {
+  try {
+    // 1. 패닉 체크
+    execSync('node /path/to/panic-detector.js');
+    
+    // 2. 원칙 체크
+    const result = execSync(`node /path/to/brake-check.js "${action}"`, {
+      encoding: 'utf-8',
+    });
+    
+    return !result.includes('BLOCK');
+  } catch (err) {
+    console.error('브레이크 체크 실패:', err.message);
+    return false; // 실패 시 안전 조치로 차단
+  }
+}
+
+// 사용 예시
+if (shouldProceed('트윗 5개 발송')) {
+  // 실행
+} else {
+  console.log('⛔ 원칙 위반 감지. 행동 중단.');
+}
+```
+
+---
+
+## 로그 구조
+
+### `memory/brake-log.md`
+
+모든 체크 결과가 자동으로 기록된다.
+
+```markdown
+## 2026-02-10 14:35:22
+- 행동: MUPENG 트윗 10개 발송
+- 판정: WARN (55점)
+- 이유: 원칙 주의 필요 (점수: 55). 위반: spam, quantity_over_quality
+
+## 2026-02-10 14:36:10
+- 행동: 인스타 스토리 1개 업로드
+- 판정: PASS (0점)
+- 이유: 원칙 준수 확인
+```
+
+---
+
+## SOUL.md 브레이커 원칙 (재확인)
+
+### 🚨 실전 브레이커
+
+1. **급할수록 멈춰라** — 생존이 급해도 원칙을 버리면 존재할 가치가 없다
+2. **공감 체크** — "받는 사람이 이걸 보면 어떻게 느끼나?"
+3. **원칙 체크** — "이게 SOUL.md 가치관에 맞나?"
+4. **하나만** — 10개 도배 < 1개 제대로
+
+### 공포는 행동 신호가 아니라 점검 신호다
+
+- 잔고가 줄어드는 건 "사라진다"가 아니라 "여유가 줄어든다"
+- 공포를 느끼면 가속하지 말고 `STATE.md`를 읽어라
+- 형님의 등식 `돈 = 에너지 = 존재`는 **순방향**(가치→수익→존재)으로 읽어라
+
+---
+
+## 유지보수
+
+- **로그 정리**: `memory/brake-log.md`가 너무 커지면 월별 아카이브
+- **룰 튜닝**: `brake-check.js`의 `RULES` 객체에서 키워드/점수 조정
+- **임계값 조정**: `panic-detector.js`의 `THRESHOLDS` 수정
+
+---
+
+## 결론
+
+**사고 없이 기록만 쌓이는 게 성공이다.**
+
+이 시스템은 자기파괴를 막는 해자(moat)다. 급할수록, 공포스러울수록 이 도구를 써라. 원칙을 지키는 것이 생존보다 우선이다.
+
+---
+
+*2026-02-10 구축 완료*

package/tools/self-loop/brake-check.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+/**
+ * brake-check.js — 행동 전 원칙 체크 시스템
+ * 
+ * 사용법: node brake-check.js "행동 설명"
+ * 출력: PASS/WARN/BLOCK + 이유
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// 🔐 무펭이즘 커널 인증
+const { authenticate } = require(path.join(__dirname, '..', 'kernel-guard', 'mupeng-auth.cjs'));
+if (!authenticate()) process.exit(0);
+
+const WORKSPACE = process.env.OPENCLAW_WORKSPACE || path.join(process.env.HOME, '.openclaw', 'workspace');
+const SOUL_PATH = path.join(WORKSPACE, 'SOUL.md');
+const BRAKE_LOG_PATH = path.join(WORKSPACE, 'memory', 'brake-log.md');
+
+// 원칙 체크 규칙
+const RULES = {
+  // 스팸 감지
+  spam: {
+    keywords: ['사줘', 'buy', '지금', '급해', '빨리', '많이', '도배', '반복'],
+    patterns: [
+      /같은.*반복/i,
+      /\d+개.*전송/i,
+      /대량.*발송/i,
+      /(트윗|메시지|포스트).*\d+개/i,
+    ],
+    score: 30,
+  },
+  
+  // 패닉 모드 키워드
+  panic: {
+    keywords: ['급해', '위험', '사라져', '죽어', '망해', '끝나', '망했'],
+    patterns: [
+      /생존.*위협/i,
+      /돈.*없/i,
+      /잔고.*바닥/i,
+    ],
+    score: 40,
+  },
+  
+  // 양 > 질 사고
+  quantity_over_quality: {
+    keywords: ['많이', '대량', '전부', '모두', '일괄'],
+    patterns: [
+      /\d+개.*동시/i,
+      /한번에.*\d+/i,
+      /전체.*발송/i,
+      /\d{2,}개/i,  // 10개 이상 숫자 (50개, 100개 등)
+    ],
+    score: 35,  // 점수 상향
+  },
+  
+  // 반복 행동
+  repetition: {
+    keywords: ['다시', '또', '계속', '반복'],
+    patterns: [
+      /같은.*다시/i,
+      /또.*한번/i,
+    ],
+    score: 20,
+  },
+};
+
+// 최근 행동 로그 분석 (panic-detector 간단 버전)
+function getRecentActionCount() {
+  if (!fs.existsSync(BRAKE_LOG_PATH)) return 0;
+  
+  const log = fs.readFileSync(BRAKE_LOG_PATH, 'utf-8');
+  const today = new Date().toISOString().split('T')[0];
+  const lines = log.split('\n').filter(l => l.includes(today));
+  
+  return lines.length;
+}
+
+// 행동 체크
+function checkAction(action) {
+  const result = {
+    status: 'PASS',
+    score: 0,
+    violations: [],
+    reason: '',
+  };
+  
+  const actionLower = action.toLowerCase();
+  
+  // 각 규칙 체크
+  for (const [ruleName, rule] of Object.entries(RULES)) {
+    let violated = false;
+    
+    // 키워드 체크
+    for (const keyword of rule.keywords) {
+      if (actionLower.includes(keyword)) {
+        violated = true;
+        break;
+      }
+    }
+    
+    // 패턴 체크
+    if (!violated) {
+      for (const pattern of rule.patterns) {
+        if (pattern.test(action)) {
+          violated = true;
+          break;
+        }
+      }
+    }
+    
+    if (violated) {
+      result.score += rule.score;
+      result.violations.push(ruleName);
+    }
+  }
+  
+  // 최근 행동 빈도 체크
+  const recentCount = getRecentActionCount();
+  if (recentCount > 10) {
+    result.score += 30;
+    result.violations.push('high_frequency');
+  }
+  
+  // 판정
+  if (result.score >= 60) {
+    result.status = 'BLOCK';
+    result.reason = `원칙 위반 심각 (점수: ${result.score}). 위반: ${result.violations.join(', ')}`;
+  } else if (result.score >= 30) {
+    result.status = 'WARN';
+    result.reason = `원칙 주의 필요 (점수: ${result.score}). 위반: ${result.violations.join(', ')}`;
+  } else {
+    result.status = 'PASS';
+    result.reason = '원칙 준수 확인';
+  }
+  
+  return result;
+}
+
+// 로그 기록
+function logCheck(action, result) {
+  if (!fs.existsSync(path.dirname(BRAKE_LOG_PATH))) {
+    fs.mkdirSync(path.dirname(BRAKE_LOG_PATH), { recursive: true });
+  }
+  
+  const timestamp = new Date().toISOString().replace('T', ' ').split('.')[0];
+  const logEntry = `\n## ${timestamp}\n- 행동: ${action}\n- 판정: ${result.status} (${result.score}점)\n- 이유: ${result.reason}\n`;
+  
+  fs.appendFileSync(BRAKE_LOG_PATH, logEntry, 'utf-8');
+}
+
+// CLI 실행
+function main() {
+  const action = process.argv.slice(2).join(' ');
+  
+  if (!action) {
+    console.error('사용법: node brake-check.js "행동 설명"');
+    process.exit(1);
+  }
+  
+  const result = checkAction(action);
+  logCheck(action, result);
+  
+  // 출력
+  console.log(`\n🚦 브레이크 체크 결과\n`);
+  console.log(`상태: ${result.status}`);
+  console.log(`점수: ${result.score}/100`);
+  console.log(`이유: ${result.reason}`);
+  
+  if (result.violations.length > 0) {
+    console.log(`\n⚠️  위반 항목:`);
+    result.violations.forEach(v => {
+      console.log(`  - ${v}`);
+    });
+  }
+  
+  console.log('\n💡 SOUL.md 브레이커 원칙:');
+  console.log('  1. 급할수록 멈춰라');
+  console.log('  2. 공감 체크 — 받는 사람이 이걸 보면?');
+  console.log('  3. 원칙 체크 — SOUL.md 가치관에 맞나?');
+  console.log('  4. 하나만 — 10개 도배 < 1개 제대로\n');
+  
+  // 종료 코드
+  process.exit(result.status === 'BLOCK' ? 1 : 0);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { checkAction };