@wooojin/forgen 0.1.0

package/dist/hooks/post-tool-failure.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+/**
+ * Forgen — PostToolUseFailure Hook
+ *
+ * 도구 실행 실패 시 자동 복구 안내 + 실패 패턴 분석.
+ * - 반복 실패 감지 (같은 도구 3회 이상)
+ * - 실패 원인별 복구 제안
+ * - 컨텍스트 신호에 실패 카운터 기록
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+// debugLog는 향후 확장용으로 import 유지 가능하지만, 현재 미사용
+import { HookError } from '../core/errors.js';
+import { readStdinJSON } from './shared/read-stdin.js';
+import { isHookEnabled } from './hook-config.js';
+import { sanitizeId } from './shared/sanitize-id.js';
+import { atomicWriteJSON } from './shared/atomic-write.js';
+import { approve, approveWithWarning, failOpen } from './shared/hook-response.js';
+import { STATE_DIR } from '../core/paths.js';
+function getFailureStatePath(sessionId) {
+    return path.join(STATE_DIR, `tool-failures-${sanitizeId(sessionId)}.json`);
+}
+function loadFailureState(sessionId) {
+    const p = getFailureStatePath(sessionId);
+    try {
+        if (fs.existsSync(p)) {
+            const data = JSON.parse(fs.readFileSync(p, 'utf-8'));
+            if (data.sessionId === sessionId)
+                return data;
+        }
+    }
+    catch { /* failure state parse failure — starting fresh, failure history for this session is lost */ }
+    return { sessionId, failures: {} };
+}
+function saveFailureState(state) {
+    atomicWriteJSON(getFailureStatePath(state.sessionId), state);
+}
+/** 실패 카운터 증가 (context-signals.json) */
+function incrementFailureSignal(sessionId) {
+    const signalsPath = path.join(STATE_DIR, 'context-signals.json');
+    try {
+        let signals = {};
+        if (fs.existsSync(signalsPath)) {
+            signals = JSON.parse(fs.readFileSync(signalsPath, 'utf-8'));
+            if (signals.sessionId !== sessionId)
+                signals = {};
+        }
+        signals.sessionId = sessionId;
+        signals.previousFailures = (signals.previousFailures ?? 0) + 1;
+        signals.updatedAt = new Date().toISOString();
+        atomicWriteJSON(signalsPath, signals);
+    }
+    catch { /* context-signals.json write failure — failure counter lost, model routing escalation may not trigger */ }
+}
+/** 에러 메시지 기반 복구 제안 */
+export function getRecoverySuggestion(error, toolName) {
+    const lower = error.toLowerCase();
+    if (/timeout|timed out/.test(lower)) {
+        return 'Timeout occurred. Split into smaller units and retry.';
+    }
+    if (/enoent|no such file|not found/.test(lower)) {
+        return 'File/path does not exist. Check the path.';
+    }
+    if (/eacces|permission denied/.test(lower)) {
+        return 'Permission denied. Check file permissions.';
+    }
+    if (/syntax error|syntaxerror/.test(lower)) {
+        return 'Syntax error. Review the code again.';
+    }
+    if (/enospc|no space/.test(lower)) {
+        return 'Disk space is insufficient.';
+    }
+    if (/old_string.*not found|not unique/i.test(lower)) {
+        return 'Edit tool old_string not found in file. Use Read to check the current file content and retry.';
+    }
+    return `${toolName} tool failed. Try a different approach.`;
+}
+async function main() {
+    const data = await readStdinJSON();
+    if (!isHookEnabled('post-tool-failure')) {
+        console.log(approve());
+        return;
+    }
+    if (!data) {
+        console.log(approve());
+        return;
+    }
+    const toolName = data.tool_name ?? data.toolName ?? 'Unknown';
+    const error = data.error ?? '';
+    const sessionId = data.session_id ?? 'default';
+    // 실패 카운터 업데이트
+    const state = loadFailureState(sessionId);
+    if (!state.failures[toolName]) {
+        state.failures[toolName] = { count: 0, lastError: '', lastAt: '' };
+    }
+    state.failures[toolName].count += 1;
+    state.failures[toolName].lastError = error.slice(0, 200);
+    state.failures[toolName].lastAt = new Date().toISOString();
+    saveFailureState(state);
+    // 컨텍스트 신호 업데이트
+    incrementFailureSignal(sessionId);
+    const failCount = state.failures[toolName].count;
+    const suggestion = getRecoverySuggestion(error, toolName);
+    // 3회 이상 반복 실패 시 강화된 경고
+    if (failCount >= 3) {
+        console.log(approveWithWarning(`<compound-failure-warning>\n[Forgen] ⚠ ${toolName} tool has failed ${failCount} times in this session.\nRecovery suggestion: ${suggestion}\nTry a different approach or analyze the issue before retrying.\n</compound-failure-warning>`));
+        return;
+    }
+    // 일반 실패 안내
+    console.log(approveWithWarning(`<compound-failure-info>\n[Forgen] ${toolName} failed (${failCount} time(s)). ${suggestion}\n</compound-failure-info>`));
+}
+main().catch((e) => {
+    const hookErr = new HookError(e instanceof Error ? e.message : String(e), {
+        hookName: 'post-tool-failure', eventType: 'PostToolUseFailure', cause: e,
+    });
+    process.stderr.write(`[ch-hook] ${hookErr.name}: ${hookErr.message}\n`);
+    console.log(failOpen());
+});

package/dist/hooks/post-tool-handlers.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Forgen — PostToolUse Handlers (extracted from post-tool-use.ts)
+ *
+ * Compound negative/success 신호 감지, 컨텍스트 실패 카운터,
+ * 솔루션 negative evidence 업데이트 등 post-tool 분석 핸들러.
+ */
+/** 세션의 실패 카운터 증가 (컨텍스트 신호 수집) */
+export declare function incrementFailureCounter(sessionId: string): void;
+/** Compound v3: detect negative signals after tool execution */
+export declare function checkCompoundNegative(toolName: string, toolResponse: string, sessionId: string): void;
+/** Compound v3: Micro-extraction — detect success moments and return hint */
+export declare function getCompoundSuccessHint(toolName: string, toolResponse: string, sessionId: string): string;
+/**
+ * Update negative evidence counter in solution file.
+ * PR2b: solution-writer.incrementEvidence로 위임. lock + fresh re-read + atomic write.
+ */
+export declare function updateNegativeEvidence(solutionName: string): void;

package/dist/hooks/post-tool-handlers.js

@@ -0,0 +1,115 @@
+/**
+ * Forgen — PostToolUse Handlers (extracted from post-tool-use.ts)
+ *
+ * Compound negative/success 신호 감지, 컨텍스트 실패 카운터,
+ * 솔루션 negative evidence 업데이트 등 post-tool 분석 핸들러.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createLogger } from '../core/logger.js';
+import { atomicWriteJSON } from './shared/atomic-write.js';
+import { sanitizeId } from './shared/sanitize-id.js';
+import { incrementEvidence } from '../engine/solution-writer.js';
+import { classifyMatch, shouldAttribute } from '../engine/term-matcher.js';
+import { detectErrorPattern } from './post-tool-use.js';
+import { STATE_DIR } from '../core/paths.js';
+const log = createLogger('post-tool-handlers');
+const CONTEXT_SIGNALS_PATH = path.join(STATE_DIR, 'context-signals.json');
+/** 세션의 실패 카운터 증가 (컨텍스트 신호 수집) */
+export function incrementFailureCounter(sessionId) {
+    try {
+        let signals = {};
+        if (fs.existsSync(CONTEXT_SIGNALS_PATH)) {
+            signals = JSON.parse(fs.readFileSync(CONTEXT_SIGNALS_PATH, 'utf-8'));
+            if (signals.sessionId !== sessionId)
+                signals = {};
+        }
+        signals.sessionId = sessionId;
+        signals.previousFailures = (signals.previousFailures ?? 0) + 1;
+        signals.updatedAt = new Date().toISOString();
+        atomicWriteJSON(CONTEXT_SIGNALS_PATH, signals);
+    }
+    catch (e) {
+        log.debug('context signals write failed — failure count may be lost', e);
+    }
+}
+/** Compound v3: detect negative signals after tool execution */
+export function checkCompoundNegative(toolName, toolResponse, sessionId) {
+    if (toolName !== 'Bash')
+        return;
+    if (!toolResponse || toolResponse.length < 5)
+        return;
+    const negativePatterns = [
+        /error\s*TS\d+/i,
+        /BUILD FAILED/i,
+        /test.*fail/i,
+        /FAIL\s+tests?\//i,
+        /npm ERR!/i,
+        /exit code [1-9]/i,
+        /compilation error/i,
+        /SyntaxError/i,
+    ];
+    const isNegative = negativePatterns.some(p => p.test(toolResponse));
+    if (!isNegative)
+        return;
+    const cachePath = path.join(STATE_DIR, `injection-cache-${sanitizeId(sessionId)}.json`);
+    if (!fs.existsSync(cachePath))
+        return;
+    try {
+        const cache = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+        if (!Array.isArray(cache.solutions))
+            return;
+        // PR3: term-matcher로 word-boundary 매칭 + NEGATIVE_TERM_BLOCKLIST +
+        // match strength classification. 이전 substring 매칭은 `api` 솔루션이
+        // `rapid build failed`에 잘못 매칭되는 등 over-attribution이 심각했다.
+        const experiments = cache.solutions.filter((s) => s.status === 'experiment');
+        for (const sol of experiments) {
+            const classification = classifyMatch(toolResponse, Array.isArray(sol.identifiers) ? sol.identifiers : [], Array.isArray(sol.tags) ? sol.tags : []);
+            // 'strong' (identifier 매칭) 또는 'multi' (tag ≥2 매칭)만 attribute.
+            // 'weak' (tag 1개)와 'none'은 over-attribution 위험으로 무시.
+            if (!shouldAttribute(classification))
+                continue;
+            updateNegativeEvidence(sol.name);
+        }
+    }
+    catch (e) {
+        log.debug('compound negative 체크 실패', e);
+    }
+}
+/** Compound v3: Micro-extraction — detect success moments and return hint */
+export function getCompoundSuccessHint(toolName, toolResponse, sessionId) {
+    if (toolName !== 'Bash' || !toolResponse)
+        return '';
+    if (detectErrorPattern(toolResponse))
+        return '';
+    const hints = [];
+    if (/\d+\s*(passed|tests?\s*passed)|all\s*tests?\s*pass/i.test(toolResponse) && !/fail|error/i.test(toolResponse)) {
+        hints.push('Tests passed — record effective patterns with /compound');
+    }
+    if (/build\s*(succeeded|success|done)|compiled?\s*successfully/i.test(toolResponse)) {
+        hints.push('Build success — record implementation patterns with /compound');
+    }
+    try {
+        if (fs.existsSync(CONTEXT_SIGNALS_PATH)) {
+            const signals = JSON.parse(fs.readFileSync(CONTEXT_SIGNALS_PATH, 'utf-8'));
+            if (signals.sessionId === sessionId && (signals.previousFailures ?? 0) >= 2) {
+                hints.push('Error resolved after multiple failures — record the root cause and fix with /compound');
+                signals.previousFailures = 0;
+                atomicWriteJSON(CONTEXT_SIGNALS_PATH, signals);
+            }
+        }
+    }
+    catch (e) {
+        log.debug('error resolution detection failed', e);
+    }
+    if (hints.length === 0)
+        return '';
+    return `<compound-success-hint>\n${hints.map(h => `- ${h}`).join('\n')}\n</compound-success-hint>`;
+}
+/**
+ * Update negative evidence counter in solution file.
+ * PR2b: solution-writer.incrementEvidence로 위임. lock + fresh re-read + atomic write.
+ */
+export function updateNegativeEvidence(solutionName) {
+    incrementEvidence(solutionName, 'negative');
+}

package/dist/hooks/post-tool-use.d.ts

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+/**
+ * Forgen — PostToolUse Hook
+ *
+ * 도구 실행 후 결과 검증 + 파일 변경 추적.
+ * Compound/workflow 핸들러는 ./post-tool-handlers.ts에 분리.
+ */
+interface ModifiedFilesState {
+    sessionId: string;
+    files: Record<string, {
+        count: number;
+        lastModified: string;
+        tool: string;
+    }>;
+    toolCallCount: number;
+}
+export declare const ERROR_PATTERNS: Array<{
+    pattern: RegExp;
+    description: string;
+}>;
+export declare function detectErrorPattern(text: string): {
+    pattern: RegExp;
+    description: string;
+} | null;
+export declare function trackModifiedFile(state: ModifiedFilesState, filePath: string, toolName: string): {
+    state: ModifiedFilesState;
+    count: number;
+};
+export {};

package/dist/hooks/post-tool-use.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+/**
+ * Forgen — PostToolUse Hook
+ *
+ * 도구 실행 후 결과 검증 + 파일 변경 추적.
+ * Compound/workflow 핸들러는 ./post-tool-handlers.ts에 분리.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createLogger } from '../core/logger.js';
+const log = createLogger('post-tool-use');
+import { readStdinJSON } from './shared/read-stdin.js';
+import { sanitizeId } from './shared/sanitize-id.js';
+import { atomicWriteJSON } from './shared/atomic-write.js';
+import { saveCheckpoint } from './session-recovery.js';
+// v1: recordWriteContent (regex 선호 감지) 제거
+import { incrementFailureCounter, checkCompoundNegative, getCompoundSuccessHint } from './post-tool-handlers.js';
+import { isHookEnabled } from './hook-config.js';
+import { approve, approveWithWarning, failOpen } from './shared/hook-response.js';
+import { STATE_DIR } from '../core/paths.js';
+// ── State management ──
+function getModifiedFilesPath(sessionId) {
+    return path.join(STATE_DIR, `modified-files-${sanitizeId(sessionId)}.json`);
+}
+function loadModifiedFiles(sessionId) {
+    try {
+        const filePath = getModifiedFilesPath(sessionId);
+        if (fs.existsSync(filePath)) {
+            return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        }
+    }
+    catch (e) {
+        log.debug('modified files state load failed — starting fresh', e);
+    }
+    return { sessionId, files: {}, toolCallCount: 0 };
+}
+function saveModifiedFiles(state) {
+    atomicWriteJSON(getModifiedFilesPath(state.sessionId), state);
+}
+// ── Exported utilities ──
+export const ERROR_PATTERNS = [
+    { pattern: /ENOENT|no such file/i, description: 'file not found' },
+    { pattern: /EACCES|permission denied/i, description: 'permission denied' },
+    { pattern: /ENOSPC|no space left/i, description: 'disk space insufficient' },
+    { pattern: /syntax error|SyntaxError/i, description: 'syntax error' },
+    { pattern: /segmentation fault|SIGSEGV/i, description: 'segmentation fault' },
+    { pattern: /out of memory|OOM/i, description: 'out of memory' },
+];
+export function detectErrorPattern(text) {
+    for (const entry of ERROR_PATTERNS) {
+        if (entry.pattern.test(text))
+            return entry;
+    }
+    return null;
+}
+export function trackModifiedFile(state, filePath, toolName) {
+    const existing = state.files[filePath];
+    const count = (existing?.count ?? 0) + 1;
+    state.files[filePath] = {
+        count,
+        lastModified: new Date().toISOString(),
+        tool: toolName,
+    };
+    return { state, count };
+}
+// ── Main flow ──
+async function main() {
+    const data = await readStdinJSON();
+    if (!data) {
+        console.log(approve());
+        return;
+    }
+    if (!isHookEnabled('post-tool-use')) {
+        console.log(approve());
+        return;
+    }
+    const toolName = data.tool_name ?? data.toolName ?? '';
+    const toolInput = data.tool_input ?? data.toolInput ?? {};
+    const toolResponse = data.tool_response ?? data.toolOutput ?? '';
+    const sessionId = data.session_id ?? 'default';
+    const modState = loadModifiedFiles(sessionId);
+    modState.toolCallCount = (modState.toolCallCount ?? 0) + 1;
+    const messages = [];
+    // 1. Checkpoint (every 5 calls)
+    if (modState.toolCallCount % 5 === 0) {
+        try {
+            saveCheckpoint({
+                sessionId, mode: 'active',
+                modifiedFiles: Object.keys(modState.files),
+                lastToolCall: toolName,
+                toolCallCount: modState.toolCallCount,
+                timestamp: new Date().toISOString(),
+                cwd: data.cwd ?? process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd(),
+            });
+        }
+        catch (e) {
+            log.debug('체크포인트 저장 실패', e);
+        }
+    }
+    // 2. File change tracking (Write, Edit)
+    if (toolName === 'Write' || toolName === 'Edit') {
+        const filePath = toolInput.file_path ?? toolInput.filePath ?? '';
+        if (filePath) {
+            try {
+                const { count } = trackModifiedFile(modState, filePath, toolName);
+                if (count >= 5) {
+                    messages.push(`<compound-tool-warning>\n[Forgen] ⚠ ${path.basename(filePath)} has been modified ${count} times.\nConsider redesigning the overall structure and restarting.\n</compound-tool-warning>`);
+                }
+            }
+            catch (e) {
+                log.debug('파일 변경 추적 실패', e);
+            }
+        }
+        // v1: regex 기반 write content 학습 제거. Evidence 기반으로 전환됨.
+    }
+    // 4. Bash error detection
+    if (toolName === 'Bash' && toolResponse) {
+        const errorMatch = detectErrorPattern(toolResponse);
+        if (errorMatch) {
+            incrementFailureCounter(sessionId);
+            messages.push(`<compound-tool-info>\n[Forgen] Error pattern detected in execution result: "${errorMatch.description}". Review may be needed.\n</compound-tool-info>`);
+        }
+    }
+    // 5. Compound negative signal (non-blocking)
+    try {
+        checkCompoundNegative(toolName, toolResponse, sessionId);
+    }
+    catch (e) {
+        log.debug('compound negative check 실패', e);
+    }
+    // 6. Compound success hint (non-blocking)
+    try {
+        const successHint = getCompoundSuccessHint(toolName, toolResponse, sessionId);
+        if (successHint)
+            messages.push(successHint);
+    }
+    catch (e) {
+        log.debug('success hint generation 실패', e);
+    }
+    saveModifiedFiles(modState);
+    if (messages.length > 0) {
+        console.log(approveWithWarning(messages.join('\n')));
+    }
+    else {
+        console.log(approve());
+    }
+}
+main().catch((e) => {
+    process.stderr.write(`[ch-hook] ${e instanceof Error ? e.message : String(e)}\n`);
+    console.log(failOpen());
+});

package/dist/hooks/pre-compact.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * Forgen — PreCompact Hook
+ *
+ * 컨텍스트 압축(compaction) 전 상태 보존.
+ * - 현재 활성 모드 상태 스냅샷
+ * - 진행 중인 작업 요약 저장
+ * - handoff 파일 생성 (압축 후 복구용)
+ */
+export {};

package/dist/hooks/pre-compact.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+/**
+ * Forgen — PreCompact Hook
+ *
+ * 컨텍스트 압축(compaction) 전 상태 보존.
+ * - 현재 활성 모드 상태 스냅샷
+ * - 진행 중인 작업 요약 저장
+ * - handoff 파일 생성 (압축 후 복구용)
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createLogger } from '../core/logger.js';
+import { readStdinJSON } from './shared/read-stdin.js';
+import { isHookEnabled } from './hook-config.js';
+import { approve, approveWithWarning, failOpen } from './shared/hook-response.js';
+import { HANDOFFS_DIR, ME_BEHAVIOR, STATE_DIR } from '../core/paths.js';
+const log = createLogger('pre-compact');
+/** 활성 모드 상태 수집 */
+function collectActiveStates() {
+    const active = [];
+    if (!fs.existsSync(STATE_DIR))
+        return active;
+    try {
+        for (const f of fs.readdirSync(STATE_DIR)) {
+            if (!f.endsWith('-state.json') || f.startsWith('context-guard') || f.startsWith('skill-cache'))
+                continue;
+            try {
+                const data = JSON.parse(fs.readFileSync(path.join(STATE_DIR, f), 'utf-8'));
+                if (data.active) {
+                    active.push({ mode: f.replace('-state.json', ''), data });
+                }
+            }
+            catch (e) {
+                log.debug(`상태 파일 파싱 실패 — skip`, e);
+            }
+        }
+    }
+    catch (e) {
+        log.debug('상태 디렉토리 읽기 실패', e);
+    }
+    return active;
+}
+/** compaction 전 스냅샷 저장 */
+function saveCompactionSnapshot(sessionId) {
+    const activeStates = collectActiveStates();
+    if (activeStates.length === 0)
+        return null;
+    fs.mkdirSync(HANDOFFS_DIR, { recursive: true });
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const snapshotPath = path.join(HANDOFFS_DIR, `${timestamp}-pre-compact.md`);
+    const lines = [
+        '# Pre-Compaction Snapshot',
+        `- Session: ${sessionId}`,
+        `- Time: ${new Date().toISOString()}`,
+        `- Reason: context compaction`,
+        '',
+        '## Active Modes',
+    ];
+    for (const { mode, data } of activeStates) {
+        lines.push(`### ${mode}`);
+        lines.push(`- Prompt: ${data.prompt ?? 'N/A'}`);
+        lines.push(`- Started: ${data.startedAt ?? 'N/A'}`);
+        lines.push('');
+    }
+    lines.push('## Recovery');
+    lines.push('This snapshot was automatically created before compaction.');
+    lines.push('Active modes are preserved in state files even after compaction.');
+    fs.writeFileSync(snapshotPath, lines.join('\n'));
+    return snapshotPath;
+}
+/** 7일 이상 된 handoff 파일 정리 */
+function cleanOldHandoffs() {
+    if (!fs.existsSync(HANDOFFS_DIR))
+        return;
+    const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+    const now = Date.now();
+    try {
+        for (const f of fs.readdirSync(HANDOFFS_DIR)) {
+            const p = path.join(HANDOFFS_DIR, f);
+            const stat = fs.statSync(p);
+            if (now - stat.mtimeMs > MAX_AGE_MS) {
+                fs.unlinkSync(p);
+            }
+        }
+    }
+    catch (e) {
+        log.debug('old handoff cleanup failed — stale files may remain in handoffs dir', e);
+    }
+}
+async function main() {
+    const data = await readStdinJSON() ?? {};
+    if (!isHookEnabled('pre-compact')) {
+        console.log(approve());
+        return;
+    }
+    const sessionId = data.session_id ?? 'default';
+    // 오래된 handoff 정리
+    cleanOldHandoffs();
+    // 기존 behavioral 패턴 목록 로드 (중복 방지)
+    let existingSolutions = [];
+    try {
+        const solDir = ME_BEHAVIOR;
+        if (fs.existsSync(solDir)) {
+            existingSolutions = fs.readdirSync(solDir).filter(f => f.endsWith('.md')).map(f => f.replace('.md', ''));
+        }
+    }
+    catch { /* ignore */ }
+    const existingList = existingSolutions.length > 0
+        ? `\nAlready captured (skip these): ${existingSolutions.slice(-10).join(', ')}`
+        : '';
+    const compoundHint = `
+<forgen-compound-extract>
+Context is about to be compacted. Before it's lost, analyze this conversation and extract the USER's behavioral patterns.
+
+DO NOT extract code patterns or technical solutions. Extract HOW THE USER WORKS:
+- Decision-making style (e.g., "always verifies before trusting", "prefers data over intuition")
+- Communication preferences (e.g., "wants Korean responses", "hates long explanations")
+- Workflow sequences — repeated action ORDER patterns (e.g., "always runs tests → checks coverage → then commits", "bug fix: reproduce first → write test → fix → verify")
+- Conditional approaches (e.g., "for refactoring: ensures tests pass first, then restructures", "for PRs: security check → test review → code quality")
+- Values/philosophy (e.g., "quality over speed", "pragmatic over theoretical")
+
+For each pattern found, write a file to ~/.forgen/me/behavior/{slug}.md in this EXACT format:
+\`\`\`
+---
+name: "{slug}"
+version: 1
+kind: "{thinking|preference|workflow}"
+observedCount: 1
+confidence: 0.6
+tags: ["thinking", "{category}", "{specific-tag}"]
+created: "${new Date().toISOString().split('T')[0]}"
+updated: "${new Date().toISOString().split('T')[0]}"
+source: "pre-compact"
+---
+
+## Context
+{When and why this pattern was observed in this conversation}
+
+## Content
+{Concrete description of the behavioral pattern, with specific examples from this session}
+\`\`\`
+
+Rules:
+- Extract 0-3 patterns MAX (quality over quantity)
+- Skip if nothing non-obvious was observed
+- Skip patterns that are trivially obvious ("uses TypeScript")
+- Each pattern must be specific enough to change Claude's behavior in future sessions${existingList}
+</forgen-compound-extract>`;
+    // 스냅샷 저장
+    try {
+        const snapshotPath = saveCompactionSnapshot(sessionId);
+        if (snapshotPath) {
+            console.log(approveWithWarning(`<compound-compact-info>\n[Forgen] Pre-compaction state snapshot saved: ${path.basename(snapshotPath)}\nActive modes are preserved after compaction.\n</compound-compact-info>\n${compoundHint}`));
+            return;
+        }
+    }
+    catch (e) {
+        log.debug('스냅샷 저장 실패', e);
+    }
+    console.log(approveWithWarning(compoundHint));
+}
+main().catch((e) => {
+    process.stderr.write(`[ch-hook] ${e instanceof Error ? e.message : String(e)}\n`);
+    console.log(failOpen());
+});

package/dist/hooks/pre-tool-use.d.ts

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+/**
+ * Forgen — PreToolUse Hook
+ *
+ * 도구 실행 전 위험 명령어 차단 및 컨텍스트 리마인더 주입.
+ * - rm -rf, git push --force 등 위험 패턴 감지
+ * - 활성 모드 상태 리마인더 주입
+ */
+interface DangerousPatternEntry {
+    pattern: RegExp;
+    description: string;
+    severity: 'block' | 'warn';
+}
+/** 위험 Bash 명령어 패턴 (패키지 내장 + 사용자 커스텀 병합) */
+export declare const DANGEROUS_PATTERNS: DangerousPatternEntry[];
+/** 위험 명령어 검사 (순수 함수) */
+export declare function checkDangerousCommand(toolName: string, toolInput: Record<string, unknown> | string): {
+    action: 'block' | 'warn' | 'pass';
+    description?: string;
+    command?: string;
+};
+/** 카운터 기반 리마인더 표시 여부 판정 (순수 함수 — I/O 없음) */
+export declare function shouldShowReminder(count: number, interval?: number): boolean;
+/**
+ * Update evidence counter in a solution file.
+ * PR2b: solution-writer.incrementEvidence로 위임. lock + fresh re-read + atomic write.
+ *
+ * Exported for use by solution-injector.
+ */
+export declare function updateSolutionEvidence(solutionName: string, field: 'reflected' | 'negative' | 'injected' | 'sessions' | 'reExtracted'): void;
+export {};