@su-record/vibe 2.6.35 → 2.6.42

package/hooks/scripts/autonomy-controller.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+/**
+ * Autonomy Controller — /autonomy suggest|auto|disabled|status
+ *
+ * config.json의 autonomy.mode를 변경하거나 상태를 표시합니다.
+ */
+import fs from 'fs';
+import path from 'path';
+
+const prompt = process.argv[2] || '';
+const match = /^\/autonomy\s+(\w+)/i.exec(prompt);
+if (!match) process.exit(0);
+
+const action = match[1].toLowerCase();
+const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const configPath = path.join(PROJECT_DIR, '.claude', 'vibe', 'config.json');
+
+function loadConfig() {
+  try {
+    if (fs.existsSync(configPath)) {
+      return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    }
+  } catch { /* ignore */ }
+  return {};
+}
+
+function saveConfig(config) {
+  try {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  } catch (e) {
+    process.stderr.write(`[Autonomy] Config save error: ${e.message}\n`);
+  }
+}
+
+const VALID_MODES = ['suggest', 'auto', 'disabled'];
+
+if (VALID_MODES.includes(action)) {
+  const config = loadConfig();
+  if (!config.autonomy) config.autonomy = {};
+  config.autonomy.mode = action;
+  saveConfig(config);
+
+  const modeDesc = {
+    suggest: 'Suggest mode — 분해 결과만 표시, 사용자 승인 후 실행',
+    auto: 'Auto mode — LOW/MEDIUM 자동 실행, HIGH는 오너 확인',
+    disabled: 'Disabled — TaskDecomposer 비활성화',
+  };
+
+  console.log(`🤖 Autonomy mode → ${action}`);
+  console.log(`   ${modeDesc[action]}`);
+} else if (action === 'status') {
+  const config = loadConfig();
+  const mode = config.autonomy?.mode || 'suggest';
+  const sentinelEnabled = config.sentinel?.enabled !== false;
+  const proactiveEnabled = config.autonomy?.proactive?.enabled !== false;
+  const timeout = config.sentinel?.confirmationTimeout || 300;
+  const maxSteps = config.autonomy?.maxConcurrentSteps || 3;
+
+  console.log(`🤖 Agent Autonomy: ${mode} mode`);
+  console.log(`   🛡️ Sentinel: ${sentinelEnabled ? 'enabled' : 'disabled'}`);
+  console.log(`   💡 Proactive: ${proactiveEnabled ? 'enabled' : 'disabled'}`);
+  console.log(`   ⏱️ Confirmation timeout: ${timeout}s`);
+  console.log(`   🔄 Max concurrent steps: ${maxSteps}`);
+
+  // DB 통계 (가능하면)
+  try {
+    const { getLibBaseUrl } = await import('./utils.js');
+    const LIB_BASE = getLibBaseUrl();
+    const memMod = await import(`${LIB_BASE}memory/MemoryStorage.js`);
+    const storage = new memMod.MemoryStorage(PROJECT_DIR);
+    const db = storage.getDatabase();
+
+    const last24h = new Date(Date.now() - 86_400_000).toISOString();
+
+    let totalActions = 0;
+    let blockedActions = 0;
+    let pendingSuggestions = 0;
+    let pendingConfirmations = 0;
+
+    try {
+      totalActions = db.prepare('SELECT COUNT(*) as c FROM audit_events WHERE createdAt >= ?').get(last24h)?.c ?? 0;
+      blockedActions = db.prepare("SELECT COUNT(*) as c FROM audit_events WHERE createdAt >= ? AND outcome = 'blocked'").get(last24h)?.c ?? 0;
+    } catch { /* table may not exist */ }
+
+    try {
+      pendingSuggestions = db.prepare("SELECT COUNT(*) as c FROM suggestions WHERE status = 'pending'").get()?.c ?? 0;
+    } catch { /* table may not exist */ }
+
+    try {
+      pendingConfirmations = db.prepare("SELECT COUNT(*) as c FROM confirmations WHERE status = 'pending'").get()?.c ?? 0;
+    } catch { /* table may not exist */ }
+
+    if (totalActions > 0 || pendingSuggestions > 0 || pendingConfirmations > 0) {
+      console.log(`   📊 Last 24h: ${totalActions} actions (${totalActions - blockedActions} allowed, ${blockedActions} blocked)`);
+      if (pendingSuggestions > 0) console.log(`   💡 ${pendingSuggestions} pending suggestions`);
+      if (pendingConfirmations > 0) console.log(`   ⏳ ${pendingConfirmations} pending confirmations`);
+    }
+
+    storage.close();
+  } catch { /* DB not available, skip stats */ }
+}

package/hooks/scripts/context-save.js

@@ -1,11 +1,12 @@
 /**
- * Notification Hook - 컨텍스트 자동 저장 (80/90/95%) + 세션 요약
+ * Notification Hook - 컨텍스트 자동 저장 (80/90/95%) + 세션 요약 + Reflection
  * Usage: node context-save.js <urgency>
  *   urgency: medium | high | critical
  */
-import { getToolsBaseUrl, PROJECT_DIR } from './utils.js';
+import { getToolsBaseUrl, getLibBaseUrl, PROJECT_DIR } from './utils.js';
 
 const BASE_URL = getToolsBaseUrl();
+const LIB_URL = getLibBaseUrl();
 
 const urgency = process.argv[2] || 'medium';
 const summaryMap = {
@@ -14,6 +15,9 @@ const summaryMap = {
   critical: 'Context at 95% - CRITICAL save before session end',
 };
 
+// Debounce: track last reflection level per session to avoid duplicates
+let lastReflectionLevel = null;
+
 async function main() {
   try {
     const module = await import(`${BASE_URL}memory/index.js`);
@@ -29,11 +33,22 @@ async function main() {
     // 무시
   }
 
-  // Critical (95%): 세션 요약 자동 생성
+  // Minor Reflection (80% = medium): 컨텍스트 압력 시 자동 성찰
+  if (urgency === 'medium' && lastReflectionLevel !== 'medium') {
+    lastReflectionLevel = 'medium';
+    // Fire-and-forget: 기존 context-save에 영향 없음
+    setImmediate(() => {
+      triggerMinorReflection().catch(e => {
+        process.stderr.write(`[REFLECTION] minor reflection failed: ${e.message}\n`);
+      });
+    });
+  }
+
+  // Critical (95%): 세션 요약 자동 생성 + Major Reflection
   if (urgency === 'critical') {
     try {
-      const { SessionSummarizer } = await import(`${BASE_URL}../lib/memory/SessionSummarizer.js`);
-      const { MemoryStorage } = await import(`${BASE_URL}../lib/memory/MemoryStorage.js`);
+      const { SessionSummarizer } = await import(`${LIB_URL}memory/SessionSummarizer.js`);
+      const { MemoryStorage } = await import(`${LIB_URL}memory/MemoryStorage.js`);
 
       const storage = new MemoryStorage(PROJECT_DIR);
       const summarizer = new SessionSummarizer(storage);
@@ -47,6 +62,138 @@ async function main() {
     } catch {
       // 세션 요약 생성 실패해도 무시
     }
+
+    // Major Reflection: 세션 종료 시 전체 성찰
+    if (lastReflectionLevel !== 'critical') {
+      lastReflectionLevel = 'critical';
+      setImmediate(() => {
+        triggerMajorReflection().catch(e => {
+          process.stderr.write(`[REFLECTION] major reflection failed: ${e.message}\n`);
+        });
+      });
+    }
+  }
+}
+
+/**
+ * Minor Reflection: 컨텍스트 압력 시 현재 세션 상태 저장 (< 200ms)
+ */
+async function triggerMinorReflection() {
+  try {
+    const { MemoryManager } = await import(`${LIB_URL}MemoryManager.js`);
+    const mm = MemoryManager.getInstance(PROJECT_DIR);
+
+    // 현재 세션의 활성 컨텍스트 수집
+    const activeCtx = mm.retrieveActiveContext();
+    const insights = [];
+    const decisions = [];
+    const patterns = [];
+
+    // 활성 Goals에서 insights 추출
+    if (activeCtx.goals?.length > 0) {
+      for (const goal of activeCtx.goals.slice(0, 5)) {
+        insights.push(`Goal: ${goal.title} (${goal.progressPercent || 0}%)`);
+      }
+    }
+
+    // 최근 Decisions에서 결정사항 추출
+    if (activeCtx.decisions?.length > 0) {
+      for (const decision of activeCtx.decisions.slice(0, 5)) {
+        decisions.push(`${decision.title}${decision.rationale ? ': ' + decision.rationale : ''}`);
+      }
+    }
+
+    // 최근 Constraints에서 패턴 추출
+    if (activeCtx.constraints?.length > 0) {
+      for (const constraint of activeCtx.constraints.slice(0, 3)) {
+        patterns.push(`Constraint: ${constraint.title}`);
+      }
+    }
+
+    if (insights.length === 0 && decisions.length === 0 && patterns.length === 0) {
+      return; // 저장할 내용 없으면 스킵
+    }
+
+    const store = mm.getReflectionStore();
+    store.save({
+      type: 'minor',
+      trigger: 'context_pressure',
+      insights,
+      decisions,
+      patterns,
+      score: 0.5,
+      sessionId: `session_${Date.now()}`,
+    });
+  } catch {
+    // Silent fail — 기존 context-save에 영향 없음
+  }
+}
+
+/**
+ * Major Reflection: 세션 종료 시 전체 성찰 (< 500ms)
+ */
+async function triggerMajorReflection() {
+  try {
+    const { MemoryManager } = await import(`${LIB_URL}MemoryManager.js`);
+    const mm = MemoryManager.getInstance(PROJECT_DIR);
+
+    const activeCtx = mm.retrieveActiveContext();
+    const recentObs = mm.getRecentObservations(10);
+
+    const insights = [];
+    const decisions = [];
+    const patterns = [];
+    const filesContext = [];
+
+    // 완료된 목표
+    if (activeCtx.goals?.length > 0) {
+      const completed = activeCtx.goals.filter(g => g.status === 'completed');
+      const inProgress = activeCtx.goals.filter(g => g.status === 'active' || g.status === 'in_progress');
+      if (completed.length > 0) {
+        insights.push(`Completed goals: ${completed.map(g => g.title).join(', ')}`);
+      }
+      if (inProgress.length > 0) {
+        insights.push(`In-progress goals: ${inProgress.map(g => `${g.title} (${g.progressPercent || 0}%)`).join(', ')}`);
+      }
+    }
+
+    // 결정사항
+    if (activeCtx.decisions?.length > 0) {
+      for (const d of activeCtx.decisions.slice(0, 5)) {
+        decisions.push(d.title + (d.rationale ? ` — ${d.rationale}` : ''));
+      }
+    }
+
+    // 관찰에서 패턴/파일 추출
+    if (recentObs.length > 0) {
+      for (const obs of recentObs) {
+        if (obs.type === 'discovery' || obs.type === 'bugfix') {
+          patterns.push(`[${obs.type}] ${obs.title}`);
+        }
+        if (obs.filesModified?.length > 0) {
+          filesContext.push(...obs.filesModified);
+        }
+      }
+    }
+
+    // 중복 제거
+    const uniqueFiles = [...new Set(filesContext)].slice(0, 20);
+
+    const score = Math.min(1.0, 0.5 + (insights.length * 0.1) + (decisions.length * 0.05));
+
+    const store = mm.getReflectionStore();
+    store.save({
+      type: 'major',
+      trigger: 'session_end',
+      insights,
+      decisions,
+      patterns,
+      filesContext: uniqueFiles,
+      score,
+      sessionId: `session_${Date.now()}`,
+    });
+  } catch {
+    // Silent fail
   }
 }
 

package/hooks/scripts/evolution-engine.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+/**
+ * Evolution Engine Hook - PostToolUse (Write/Edit)
+ * Triggers insight extraction and optional generation every N tool uses.
+ * Fire-and-forget: hook returns immediately, processing runs in background.
+ */
+import { getToolsBaseUrl, getLibBaseUrl, PROJECT_DIR } from './utils.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+// Throttle: only run every 5th tool use per session
+let toolUseCount = 0;
+const TRIGGER_EVERY = 5;
+
+// Read config
+function getEvolutionConfig() {
+  try {
+    const configPath = path.join(PROJECT_DIR, '.claude', 'vibe', 'config.json');
+    if (fs.existsSync(configPath)) {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      return config.evolution || {};
+    }
+  } catch { /* ignore */ }
+  return {};
+}
+
+// stdin에서 hook input 읽기
+let inputData = '';
+for await (const chunk of process.stdin) {
+  inputData += chunk;
+}
+
+let hookInput;
+try {
+  hookInput = JSON.parse(inputData);
+} catch {
+  process.exit(0);
+}
+
+// Only trigger on Write/Edit tool completions
+const toolName = hookInput?.tool_name || '';
+if (toolName !== 'Write' && toolName !== 'Edit') {
+  process.exit(0);
+}
+
+toolUseCount++;
+if (toolUseCount % TRIGGER_EVERY !== 0) {
+  process.exit(0);
+}
+
+// Check if evolution is enabled
+const config = getEvolutionConfig();
+if (config.enabled === false) {
+  process.exit(0);
+}
+
+// Fire-and-forget: schedule background processing
+setImmediate(async () => {
+  try {
+    const LIB_BASE = getLibBaseUrl();
+    const [memModule, insightModule, orchestratorModule] = await Promise.all([
+      import(`${LIB_BASE}memory/MemoryStorage.js`),
+      import(`${LIB_BASE}evolution/InsightExtractor.js`),
+      import(`${LIB_BASE}evolution/EvolutionOrchestrator.js`),
+    ]);
+
+    const storage = new memModule.MemoryStorage(PROJECT_DIR);
+    const extractor = new insightModule.InsightExtractor(storage);
+
+    // Step 1: Extract insights
+    const result = extractor.extractFromRecent(20);
+
+    if (result.newInsights.length > 0) {
+      const mode = config.mode || 'suggest';
+
+      // Step 2: Generate if new insights found
+      const orchestrator = new orchestratorModule.EvolutionOrchestrator(storage, {
+        mode,
+        maxGenerationsPerCycle: config.maxGenerationsPerCycle || 5,
+        minQualityScore: config.minQualityScore || 60,
+      });
+
+      const genResult = orchestrator.generate();
+
+      if (mode === 'suggest' && genResult.generated.length > 0) {
+        // Notify user about new candidates
+        process.stderr.write(
+          `[Evolution] New candidates: ${genResult.generated.length} generated, ` +
+          `${genResult.rejected.length} rejected\n`
+        );
+      }
+    }
+
+    storage.close();
+  } catch (error) {
+    process.stderr.write(
+      `[Evolution] Background error: ${error instanceof Error ? error.message : 'Unknown'}\n`
+    );
+  }
+});

package/hooks/scripts/keyword-detector.js

@@ -4,7 +4,7 @@
  * 매직 키워드 감지 및 조합 처리
  */
 
-import { VIBE_PATH, PROJECT_DIR } from './utils.js';
+import { CORE_PATH, PROJECT_DIR } from './utils.js';
 
 // 매직 키워드 정의
 const MAGIC_KEYWORDS = {