@wooojin/forgen 0.3.1 → 0.4.0

package/dist/hooks/context-guard.js

@@ -11,6 +11,7 @@
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import * as os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { createLogger } from '../core/logger.js';
 import { readStdinJSON } from './shared/read-stdin.js';
@@ -19,6 +20,7 @@ import { loadHookConfig, isHookEnabled } from './hook-config.js';
 import { approve, approveWithContext, approveWithWarning, failOpenWithTracking } from './shared/hook-response.js';
 import { HANDOFFS_DIR, STATE_DIR } from '../core/paths.js';
 import { recordHookTiming } from './shared/hook-timing.js';
+import { sanitizeId } from './shared/sanitize-id.js';
 const log = createLogger('context-guard');
 const CONTEXT_STATE_PATH = path.join(STATE_DIR, 'context-guard.json');
 // 경고 임계값: 프롬프트 50회 또는 총 문자 수 200K 이상
@@ -89,6 +91,17 @@ export async function main() {
         // Stop 훅: stop_hook_type이 있으면 처리
         if (input.stop_hook_type) {
             _hookEvent = 'Stop';
+            // 세션 종료 시 pending outcome을 unknown으로 finalize.
+            // 과거에는 프로덕션에서 호출되지 않아 pending이 다음 세션의 flushAccept에
+            // accept로 쓸려들어가는 구조적 optimistic bias가 있었다 (2026-04-20).
+            // finalizeSession은 idempotent (pending 없으면 0 반환, 에러는 log.debug만).
+            try {
+                const { finalizeSession } = await import('../engine/solution-outcomes.js');
+                finalizeSession(sessionId);
+            }
+            catch (e) {
+                log.debug('finalizeSession 실패 (fail-open)', e);
+            }
             // forge-loop 활성 시 미완료 스토리 감지 → 지속 메시지 주입 (polite-stop 방지)
             const forgeLoopBlock = checkForgeLoopActive();
             if (forgeLoopBlock) {
@@ -117,6 +130,16 @@ export async function main() {
             // 정상 종료 시: 의미 있는 세션이었으면 compound 안내/자동 트리거
             if (input.stop_hook_type === 'user' || input.stop_hook_type === 'end_turn') {
                 const state = loadContextState(sessionId);
+                // ADR-002 T1 — 세션 중간에 교정이 들어와도 session-scoped rule 이 me-scope 으로
+                // 승급되도록 Stop 에서 직접 auto-compound-runner 를 debounced 로 트리거.
+                // 'forgen' CLI 를 통하지 않는 사용자 (claude 직접 실행) 에게도 교정이 유실되지 않는 보장.
+                // dedup: last-auto-compound.json 의 sessionId + 5분 cooldown.
+                try {
+                    await maybeSpawnAutoCompound(sessionId, input.transcript_path, state.promptCount);
+                }
+                catch (e) {
+                    log.debug('auto-compound Stop trigger 실패', e);
+                }
                 if (state.promptCount >= 20) {
                     // 20+ prompts: auto-trigger compound by writing marker
                     try {
@@ -181,7 +204,9 @@ export async function main() {
  */
 function buildSessionSummary(sessionId, promptCount) {
     try {
-        const cachePath = path.join(STATE_DIR, `solution-cache-${sessionId}.json`);
+        // P1-S3 fix (2026-04-20): sanitizeId로 path traversal 차단.
+        // 다른 세션 캐시 경로는 모두 sanitizeId 사용. 여기만 누락되어 있었다.
+        const cachePath = path.join(STATE_DIR, `solution-cache-${sanitizeId(sessionId)}.json`);
         if (!fs.existsSync(cachePath))
             return '';
         const cache = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
@@ -210,6 +235,66 @@ function buildSessionSummary(sessionId, promptCount) {
 }
 // forge-loop 상태 파일 경로
 const FORGE_LOOP_STATE_PATH = path.join(STATE_DIR, 'forge-loop.json');
+/**
+ * Stop hook 에서 auto-compound-runner 를 debounced 로 spawn.
+ *
+ * 호출 조건:
+ *   - promptCount ≥ 10 (의미있는 세션)
+ *   - transcript_path 유효
+ *   - last-auto-compound.json 의 sessionId 가 다르거나 5분 전
+ *
+ * dedup 파일은 session-recovery hook 과 공유되어 double-run 방지.
+ * fire-and-forget (detached) — hook timeout 과 무관.
+ */
+const AUTO_COMPOUND_COOLDOWN_MS = 5 * 60 * 1000; // 5 min
+async function maybeSpawnAutoCompound(sessionId, transcriptPath, promptCount) {
+    if (!transcriptPath || promptCount < 10)
+        return;
+    const markerPath = path.join(STATE_DIR, 'last-auto-compound.json');
+    try {
+        const raw = fs.readFileSync(markerPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed.sessionId === sessionId) {
+            const last = parsed.completedAt ? Date.parse(parsed.completedAt) : 0;
+            if (Number.isFinite(last) && Date.now() - last < AUTO_COMPOUND_COOLDOWN_MS)
+                return;
+        }
+    }
+    catch { /* first time or corrupt — proceed */ }
+    const { spawn: spawnProcess } = await import('node:child_process');
+    const cwd = process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd();
+    // 기본: 번들된 auto-compound-runner. 프로덕션 빌드는 이 경로만 실행.
+    const defaultRunner = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'core', 'auto-compound-runner.js');
+    // 테스트 주입 경로 — FORGEN_TEST=1 게이트 + 경로 containment (~/.forgen 또는 /tmp 하위만 허용).
+    // FORGEN_TEST 없이 FORGEN_AUTO_COMPOUND_RUNNER_PATH 만 설정되어도 무시 → 임의 코드 실행 방지.
+    let runnerPath = defaultRunner;
+    const override = process.env.FORGEN_AUTO_COMPOUND_RUNNER_PATH;
+    if (override && process.env.FORGEN_TEST === '1') {
+        const resolved = path.resolve(override);
+        const homeDir = os.homedir();
+        const allowed = [
+            path.join(homeDir, '.forgen'),
+            os.tmpdir(), // 플랫폼별 /tmp, /var/folders/... 등
+            '/tmp',
+            path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..'),
+        ];
+        if (allowed.some((root) => resolved === root || resolved.startsWith(root + path.sep))) {
+            runnerPath = resolved;
+        }
+        else {
+            log.debug(`FORGEN_AUTO_COMPOUND_RUNNER_PATH 무시 — ${resolved} 가 허용 루트 밖`);
+        }
+    }
+    else if (override) {
+        log.debug('FORGEN_AUTO_COMPOUND_RUNNER_PATH 무시 — FORGEN_TEST=1 가 필요');
+    }
+    const child = spawnProcess('node', [runnerPath, cwd, transcriptPath, sessionId], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    log.debug(`Stop-triggered auto-compound 시작: ${sessionId} (${promptCount} prompts)`);
+}
 // forge-loop 차단 안전 상한 (무한 루프 방지)
 const FORGE_LOOP_MAX_BLOCKS = 30;
 const FORGE_LOOP_STALE_MS = 2 * 60 * 60 * 1000; // 2시간

package/dist/hooks/hook-config.d.ts

@@ -25,6 +25,8 @@
  */
 /** 훅 설정 파일의 전체 구조 타입 */
 export type HookConfig = Record<string, unknown>;
+/** 테스트/진단용: 보호된 훅 이름 집합 스냅샷. */
+export declare function getProtectedHookNames(): string[];
 /**
  * 프로젝트의 작업 디렉토리를 결정합니다.
  * FORGEN_CWD → COMPOUND_CWD → process.cwd() 순서.
@@ -46,9 +48,15 @@ export declare function loadHookConfig(hookName: string): Record<string, unknown
 /**
  * 훅이 활성화되어 있는지 확인합니다.
  *
+ * Invariant: compound-core 티어 및 compoundCritical=true 훅은 어떤 config
+ * 경로(개별 hooks / tier / 레거시)로도 비활성화되지 않는다. config 값과 무관하게
+ * 항상 true를 반환한다. 이는 복리화 3축(승급/rollback/피드백)을 project-level
+ * config 실수로 조용히 끄는 dual-path를 차단하는 단일 진입점 가드다.
+ *
  * 우선순위:
+ *   0. PROTECTED_HOOKS에 속하면 → 즉시 true (가드레일)
  *   1. hooks.hookName.enabled (개별 훅 설정)
- *   2. tiers.tierName.enabled (티어 설정) — compound-core는 티어 비활성화 무시
+ *   2. tiers.tierName.enabled (티어 설정)
  *   3. hookName.enabled (레거시 형식)
  *   4. 기본값 true (하위호환)
  */

package/dist/hooks/hook-config.js

@@ -33,6 +33,19 @@ const GLOBAL_CONFIG_PATH = path.join(FORGEN_HOME, 'hook-config.json');
  * 이중 구현 방지: HOOK_REGISTRY가 단일 소스 오브 트루스.
  */
 const HOOK_TIER_MAP = Object.fromEntries(HOOK_REGISTRY.map(h => [h.name, h.tier]));
+/**
+ * compound-core 티어이거나 compoundCritical=true로 선언된 훅은 project/글로벌
+ * config의 어떤 경로로도 비활성화할 수 없다. 복리화 피드백 루프(승급·outcome
+ * 추적·세션 복구)를 project-level 설정 실수로 조용히 끄는 것을 차단한다.
+ * (feedback_core_loop_invariant — 2026-04-20)
+ */
+const PROTECTED_HOOKS = new Set(HOOK_REGISTRY
+    .filter(h => h.tier === 'compound-core' || h.compoundCritical === true)
+    .map(h => h.name));
+/** 테스트/진단용: 보호된 훅 이름 집합 스냅샷. */
+export function getProtectedHookNames() {
+    return [...PROTECTED_HOOKS].sort();
+}
 /**
  * 프로젝트의 작업 디렉토리를 결정합니다.
  * FORGEN_CWD → COMPOUND_CWD → process.cwd() 순서.
@@ -120,13 +133,22 @@ export function loadHookConfig(hookName) {
 /**
  * 훅이 활성화되어 있는지 확인합니다.
  *
+ * Invariant: compound-core 티어 및 compoundCritical=true 훅은 어떤 config
+ * 경로(개별 hooks / tier / 레거시)로도 비활성화되지 않는다. config 값과 무관하게
+ * 항상 true를 반환한다. 이는 복리화 3축(승급/rollback/피드백)을 project-level
+ * config 실수로 조용히 끄는 dual-path를 차단하는 단일 진입점 가드다.
+ *
  * 우선순위:
+ *   0. PROTECTED_HOOKS에 속하면 → 즉시 true (가드레일)
  *   1. hooks.hookName.enabled (개별 훅 설정)
- *   2. tiers.tierName.enabled (티어 설정) — compound-core는 티어 비활성화 무시
+ *   2. tiers.tierName.enabled (티어 설정)
  *   3. hookName.enabled (레거시 형식)
  *   4. 기본값 true (하위호환)
  */
 export function isHookEnabled(hookName) {
+    // 0) compound-core 가드레일 — config 어떤 경로로도 끌 수 없음
+    if (PROTECTED_HOOKS.has(hookName))
+        return true;
     const all = loadFullConfig();
     if (!all)
         return true;
@@ -136,9 +158,9 @@ export function isHookEnabled(hookName) {
         return false;
     if (hooksSection?.[hookName]?.enabled === true)
         return true;
-    // 2) 티어 설정 — compound-core는 절대 티어 비활성화로 끄지 않음
+    // 2) 티어 설정
     const tier = HOOK_TIER_MAP[hookName];
-    if (tier && tier !== 'compound-core') {
+    if (tier) {
         const tiers = all.tiers;
         if (tiers?.[tier]?.enabled === false)
             return false;

package/dist/hooks/internal/run-lifecycle-check.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/hooks/internal/run-lifecycle-check.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+/**
+ * Forgen — Internal runner: compound lifecycle check.
+ *
+ * Spawned by `session-recovery.ts` as a detached background process.
+ * Exists as a dedicated script file so the caller can pass `sessionId`
+ * via argv instead of interpolating it into a `-e` template literal.
+ *
+ * Audit finding #5 (2026-04-21): prior call site used
+ *   spawn('node', ['--input-type=module', '-e',
+ *     `import('${path}').then(m => m.runLifecycleCheck('${sessionId}'))`])
+ * which interpolated `sessionId` (originating from hook stdin) into
+ * executable JS source. An attacker-controlled session id of the shape
+ * `a'); malicious(); //` would have executed arbitrary JS under the
+ * user's Claude-Code privileges. A dedicated script + argv lookup has
+ * no shell or eval surface.
+ *
+ * Contract: `process.argv[2]` is the session id. Any extra args are
+ * ignored. stdout/stderr are ignored by the caller (`stdio: 'ignore'`).
+ */
+import { runLifecycleCheck } from '../../engine/compound-lifecycle.js';
+const sessionId = process.argv[2];
+if (!sessionId || typeof sessionId !== 'string') {
+    process.exit(0);
+}
+try {
+    runLifecycleCheck(sessionId);
+}
+catch {
+    // Detached background — best effort. Surfacing errors would have no
+    // consumer and the parent hook already logged the spawn.
+}

package/dist/hooks/notepad-injector.js

@@ -21,6 +21,7 @@ import { isHookEnabled } from './hook-config.js';
 import { truncateContent } from './shared/injection-caps.js';
 import { calculateBudget } from './shared/context-budget.js';
 import { approve, approveWithContext, failOpenWithTracking } from './shared/hook-response.js';
+import { escapeAllXmlTags } from './prompt-injection-filter.js';
 // ── 메인 ──
 async function main() {
     const input = await readStdinJSON();
@@ -39,9 +40,11 @@ async function main() {
         console.log(approve());
         return;
     }
-    // 태그 이스케이프: notepad 내용 내의 닫는 태그를 안전하게 처리
-    const safeContent = truncateContent(notepadContent.trim(), calculateBudget(effectiveCwd).notepadMax)
-        .replace(/<\/forgen-notepad>/g, '&lt;/forgen-notepad&gt;');
+    // P1-S2 fix (2026-04-20): 이전에는 `</forgen-notepad>` 리터럴 하나만 치환했지만,
+    // notepad 파일에 `<system>`, `<assistant>` 같은 임의 XML 태그가 있으면 그대로
+    // LLM에 전달되어 지시 주입 위험. escapeAllXmlTags로 모든 태그를 escape한다.
+    const truncated = truncateContent(notepadContent.trim(), calculateBudget(effectiveCwd).notepadMax);
+    const safeContent = escapeAllXmlTags(truncated);
     const injection = `<forgen-notepad>\n${safeContent}\n</forgen-notepad>`;
     console.log(approveWithContext(injection, 'UserPromptSubmit'));
 }

package/dist/hooks/permission-handler.d.ts

@@ -10,5 +10,13 @@
 export declare const SAFE_TOOLS: Set<string>;
 /** autopilot 모드에서도 수동 확인이 필요한 도구 */
 export declare const ALWAYS_CONFIRM_TOOLS: Set<string>;
-/** 도구 분류: 승인/확인/통과 결정 (순수 함수) */
-export declare function classifyTool(toolName: string, isAutopilot: boolean): 'auto-approve-safe' | 'autopilot-confirm' | 'autopilot-approve' | 'pass-through';
+/**
+ * 도구 분류: pass-through 결정 (순수 함수).
+ *
+ * Audit clarification #4 (2026-04-21): 본 훅은 Claude의 기본 권한 흐름을
+ * 가로채지 않는다 — 모든 return 라벨은 "어떤 pass-through 경로인가"를
+ * 의미하며, `permissionDecision: 'allow'`를 강제하지 않는다. 과거 라벨
+ * `auto-approve-safe`, `autopilot-approve`는 승인으로 오해되어 audit log가
+ * 실제 실행 신뢰도와 어긋났다.
+ */
+export declare function classifyTool(toolName: string, isAutopilot: boolean): 'safe-pass-through' | 'autopilot-warn-pass-through' | 'autopilot-pass-through' | 'pass-through';

package/dist/hooks/permission-handler.js

@@ -24,15 +24,23 @@ export const SAFE_TOOLS = new Set([
 export const ALWAYS_CONFIRM_TOOLS = new Set([
     'Bash', 'Write', 'Edit',
 ]);
-/** 도구 분류: 승인/확인/통과 결정 (순수 함수) */
+/**
+ * 도구 분류: pass-through 결정 (순수 함수).
+ *
+ * Audit clarification #4 (2026-04-21): 본 훅은 Claude의 기본 권한 흐름을
+ * 가로채지 않는다 — 모든 return 라벨은 "어떤 pass-through 경로인가"를
+ * 의미하며, `permissionDecision: 'allow'`를 강제하지 않는다. 과거 라벨
+ * `auto-approve-safe`, `autopilot-approve`는 승인으로 오해되어 audit log가
+ * 실제 실행 신뢰도와 어긋났다.
+ */
 export function classifyTool(toolName, isAutopilot) {
     if (SAFE_TOOLS.has(toolName))
-        return 'auto-approve-safe';
+        return 'safe-pass-through';
     if (!isAutopilot)
         return 'pass-through';
     if (ALWAYS_CONFIRM_TOOLS.has(toolName))
-        return 'autopilot-confirm';
-    return 'autopilot-approve';
+        return 'autopilot-warn-pass-through';
+    return 'autopilot-pass-through';
 }
 /** autopilot 모드 활성 여부 확인 */
 function isAutopilotActive() {
@@ -80,9 +88,17 @@ async function main() {
     }
     const toolName = data.tool_name ?? data.toolName ?? '';
     const sessionId = data.session_id ?? 'default';
-    // 안전 도구는 항상 승인
+    // Audit note #4 (2026-04-21): `approve()` / `approveWithWarning()` 둘 다
+    // Claude Code hook protocol에서 `permissionDecision: 'allow'`를 설정하지
+    // 않는다. 따라서 본 훅은 실제로 도구 실행을 "승인(force-allow)"하지 않고,
+    // Claude의 기본 권한 흐름으로 pass-through 시킨다 (systemMessage UI 경고는
+    // 선택사항). 과거 로그에서 `auto-approve-safe` / `autopilot-approve` 같은
+    // 결정 이름이 실제 효과와 어긋났기에 로그 라벨을 실효에 맞춰 정정했다.
+    //
+    // SAFE_TOOLS (Read/Glob/Grep 등): Claude 기본 정책상 이미 허용되는 도구이므로
+    // 이곳에서 별도 장치 없이 pass-through. 로그는 `safe-pass-through`로 기록.
     if (SAFE_TOOLS.has(toolName)) {
-        logPermissionRequest(sessionId, toolName, 'auto-approve-safe');
+        logPermissionRequest(sessionId, toolName, 'safe-pass-through');
         console.log(approve());
         return;
     }
@@ -94,18 +110,21 @@ async function main() {
     }
     // autopilot 모드 (2차 방어선):
     // pre-tool-use 훅이 위험 패턴(rm -rf, git push --force 등)을 이미 block/warn 처리함.
-    // 여기 도달하는 도구는 pre-tool-use를 통과한 것이므로, 승인하되 메시지로 추적 가능하게 함.
+    // 여기 도달하는 도구는 pre-tool-use를 통과한 것으로 pass-through + UI 경고.
+    // 여전히 Claude의 기본 confirmation은 사용자에게 노출된다 — 본 훅이 전체
+    // 승인을 가로채는 게 아니라 추적성을 위한 어노테이션이다.
     if (ALWAYS_CONFIRM_TOOLS.has(toolName)) {
-        logPermissionRequest(sessionId, toolName, 'autopilot-confirm');
+        logPermissionRequest(sessionId, toolName, 'autopilot-warn-pass-through');
         // Bash는 pre-tool-use를 통과했더라도 경고 강도를 높임 (임의 셸 실행 위험)
         const warningLevel = toolName === 'Bash'
-            ? `[Forgen] ⚠ Autopilot: Bash tool auto-approved — passed pre-tool-use validation. Beware of unexpected commands.`
-            : `[Forgen] Autopilot: ${toolName} tool execution auto-approved.`;
+            ? `[Forgen] ⚠ Autopilot: Bash tool — passed pre-tool-use validation. Beware of unexpected commands.`
+            : `[Forgen] Autopilot: ${toolName} tool use passed through with warning.`;
         console.log(approveWithWarning(`<compound-permission>\n${warningLevel}\n</compound-permission>`));
         return;
     }
-    // 기타 도구: autopilot 모드에서 자동 승인
-    logPermissionRequest(sessionId, toolName, 'autopilot-approve');
+    // 기타 도구: autopilot 모드에서도 pass-through (force-approve 아님).
+    // 과거 로그 라벨은 `autopilot-approve`였으나 실제 효과는 pass-through.
+    logPermissionRequest(sessionId, toolName, 'autopilot-pass-through');
     console.log(approve());
 }
 main().catch((e) => {

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

@@ -237,6 +237,68 @@ async function main() {
         catch (e) {
             log.debug('compound negative check 실패', e);
         }
+        // 6a+b. ADR-001 Mech-A PostToolUse + T3 bypass — single rule load, 두 dispatcher 공유.
+        // R2-P perf: 이전에는 6a, 6b 각각 loadActiveRules() 재호출 → file read 2배.
+        if (toolName === 'Write' || toolName === 'Edit' || toolName === 'Bash') {
+            const target = (() => {
+                const c = toolInput.content;
+                if (typeof c === 'string')
+                    return c;
+                const ns = toolInput.new_string;
+                if (typeof ns === 'string')
+                    return ns;
+                const cmd = toolInput.command;
+                if (typeof cmd === 'string')
+                    return cmd;
+                return '';
+            })() || toolResponse;
+            if (target) {
+                try {
+                    const [{ loadActiveRules }, { recordViolation, recordBypass }, { scanForBypass }, { compileSafeRegex, safeRegexTest },] = await Promise.all([
+                        import('../store/rule-store.js'),
+                        import('../engine/lifecycle/signals.js'),
+                        import('../engine/lifecycle/bypass-detector.js'),
+                        import('./shared/safe-regex.js'),
+                    ]);
+                    const rules = loadActiveRules();
+                    // Mech-A pattern_match dispatcher
+                    for (const rule of rules) {
+                        for (const spec of rule.enforce_via ?? []) {
+                            if (spec.hook !== 'PostToolUse' || spec.mech !== 'A')
+                                continue;
+                            const v = spec.verifier;
+                            if (!v || v.kind !== 'pattern_match')
+                                continue;
+                            const pattern = String(v.params?.pattern ?? '');
+                            if (!pattern)
+                                continue;
+                            const re = compileSafeRegex(pattern);
+                            if (!re.regex) {
+                                log.debug(`rule ${rule.rule_id} unsafe regex: ${re.reason}`);
+                                continue;
+                            }
+                            if (!safeRegexTest(re.regex, target))
+                                continue;
+                            recordViolation({
+                                rule_id: rule.rule_id, session_id: sessionId,
+                                source: 'post-tool-guard',
+                                kind: 'block',
+                                message_preview: target.slice(0, 120),
+                            });
+                            messages.push(`<compound-rule-violation>\n[Forgen] Rule ${rule.rule_id.slice(0, 8)} pattern matched in ${toolName} output.\n${spec.block_message ?? rule.policy.slice(0, 120)}\n</compound-rule-violation>`);
+                        }
+                    }
+                    // T3 bypass detection (same rules, same target)
+                    const candidates = scanForBypass({ rules, tool_name: toolName, tool_output: target, session_id: sessionId });
+                    for (const c of candidates) {
+                        recordBypass({ rule_id: c.rule_id, session_id: c.session_id, tool: c.tool, pattern_preview: c.pattern_preview });
+                    }
+                }
+                catch (e) {
+                    log.debug('enforce_via/bypass post-tool dispatch 실패', e);
+                }
+            }
+        }
         // 7. Compound success hint (non-blocking)
         try {
             const successHint = getCompoundSuccessHint(toolName, toolResponse, sessionId);

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

@@ -311,7 +311,63 @@ async function main() {
         const toolName = data.tool_name ?? data.toolName ?? '';
         const toolInput = data.tool_input ?? data.toolInput ?? {};
         const sessionId = data.session_id ?? 'default';
-        // Bash 도구: 위험 명령어 감지
+        // ADR-001 Mech-A PreToolUse dispatcher — 사용자가 정의한 rule 이 빌트인 위험-명령 감지보다 먼저.
+        // 이렇게 해야 rule.block_message (맥락 있는 안내) 가 제네릭 "Dangerous command blocked" 대신 노출됨.
+        // fail-open: 예외는 hook 차단 안 함.
+        try {
+            const [{ loadActiveRules }, { recordViolation }, { compileSafeRegex, safeRegexTest },] = await Promise.all([
+                import('../store/rule-store.js'),
+                import('../engine/lifecycle/signals.js'),
+                import('./shared/safe-regex.js'),
+            ]);
+            const rules = loadActiveRules();
+            const command = typeof toolInput.command === 'string'
+                ? String(toolInput.command)
+                : '';
+            for (const rule of rules) {
+                for (const spec of rule.enforce_via ?? []) {
+                    if (spec.hook !== 'PreToolUse' || spec.mech !== 'A')
+                        continue;
+                    const v = spec.verifier;
+                    if (!v || v.kind !== 'tool_arg_regex')
+                        continue;
+                    const pattern = String(v.params?.pattern ?? '');
+                    if (!pattern)
+                        continue;
+                    const re = compileSafeRegex(pattern, 'i');
+                    if (!re.regex) {
+                        log.debug(`rule ${rule.rule_id} unsafe regex: ${re.reason}`);
+                        continue;
+                    }
+                    if (!safeRegexTest(re.regex, command))
+                        continue;
+                    const requiresFlag = v.params?.requires_flag;
+                    const confirmed = process.env.FORGEN_USER_CONFIRMED === '1';
+                    if (requiresFlag && !confirmed) {
+                        recordViolation({ rule_id: rule.rule_id, session_id: sessionId, source: 'pre-tool-guard', kind: 'deny', message_preview: command.slice(0, 120) });
+                        const baseMsg = spec.block_message ?? `[${rule.rule_id}] policy violation: ${rule.policy.slice(0, 120)}`;
+                        // G8: override 힌트 — FORGEN_USER_CONFIRMED=1 으로 사용자 명시 승인 가능, 감사 로그 기록됨.
+                        const msgWithHint = `${baseMsg}\n\n(override: set FORGEN_USER_CONFIRMED=1 (bypass will be audited in violations.jsonl))`;
+                        console.log(deny(msgWithHint));
+                        return;
+                    }
+                    if (requiresFlag && confirmed) {
+                        // H3: 우회 감사 — FORGEN_USER_CONFIRMED 으로 Mech-A 를 우회할 때마다 violation 로그에
+                        // kind='correction' 으로 기록. T3 bypass 누적 대신 별도 채널로 운영자가 monitoring 가능.
+                        recordViolation({
+                            rule_id: rule.rule_id, session_id: sessionId,
+                            source: 'pre-tool-guard',
+                            kind: 'correction', // 'correction' = 사용자 명시 우회, rule 위반이지만 의도된 것
+                            message_preview: `[FORGEN_USER_CONFIRMED=1 bypass] ${command.slice(0, 120)}`,
+                        });
+                    }
+                }
+            }
+        }
+        catch (e) {
+            log.debug('enforce_via[PreToolUse] dispatch 실패', e);
+        }
+        // Bash 도구: 위험 명령어 감지 (빌트인 safety net)
         const check = checkDangerousCommand(toolName, toolInput);
         if (check.action === 'block') {
             console.log(deny(`[Forgen] Dangerous command blocked: ${check.description}\nCommand: ${check.command}`));
@@ -334,10 +390,16 @@ async function main() {
             log.debug('compound reflection check 실패', e);
         }
         // 활성 모드 리마인더 (10회 호출당 1회 — 결정적 카운터 기반)
-        const reminders = getActiveReminders();
-        if (reminders.length > 0 && shouldShowReminderIO()) {
-            console.log(approveWithWarning(`<compound-reminder>\n${reminders.join('\n')}\n</compound-reminder>`));
-            return;
+        // P0-4 fix (2026-04-20): 과거에는 getActiveReminders()로 STATE_DIR을 먼저
+        // readdir + N회 readFileSync한 뒤에야 shouldShowReminderIO 카운터를 체크했다.
+        // 그래서 "리마인더를 보여줄 호출이 아닌" 90%에서도 디렉터리 스캔이 발생.
+        // 이제 shouldShowReminderIO를 먼저 체크해 표시 회차일 때만 스캔한다.
+        if (shouldShowReminderIO()) {
+            const reminders = getActiveReminders();
+            if (reminders.length > 0) {
+                console.log(approveWithWarning(`<compound-reminder>\n${reminders.join('\n')}\n</compound-reminder>`));
+                return;
+            }
         }
         console.log(approve());
     }

package/dist/hooks/secret-filter.d.ts

@@ -10,5 +10,15 @@ export interface SecretPattern {
     pattern: RegExp;
 }
 export declare const SECRET_PATTERNS: SecretPattern[];
+/**
+ * 텍스트에서 민감 정보 패턴을 찾아 `[REDACTED:<NAME>]` 로 치환 (순수 함수).
+ *
+ * R5-G2: auto-compound-runner 가 사용자 transcript 를 Claude (Haiku) 로 송신하기 전
+ * 적용. `detectSecrets` 는 감지만, 이 함수는 실제 문자열에서 대체.
+ */
+export declare function redactSecrets(text: string): {
+    redacted: string;
+    hits: SecretPattern[];
+};
 /** 텍스트에서 민감 정보 패턴 감지 (순수 함수) */
 export declare function detectSecrets(text: string): SecretPattern[];

package/dist/hooks/secret-filter.js

@@ -16,7 +16,33 @@ export const SECRET_PATTERNS = [
     { name: 'Password', pattern: /(password|passwd|pwd)\s*[=:]\s*["']?[^\s"']{8,}/i },
     { name: 'Private Key', pattern: /-----BEGIN (RSA |EC |DSA )?PRIVATE KEY-----/ },
     { name: 'Connection String', pattern: /(mongodb|postgres|mysql|redis):\/\/\w+:[^@]+@/ },
+    // 2026-04-21 follow-up audit #B: vendor-specific prefixes the generic
+    // `(sk|pk|api-key)[_-]` pattern does NOT match. Real-world leaks
+    // overwhelmingly use these formats.
+    { name: 'GitHub Token', pattern: /\b(ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{36,}\b/ },
+    { name: 'Google API Key', pattern: /\bAIza[0-9A-Za-z_-]{35}\b/ },
+    { name: 'Slack Token', pattern: /\bxox[abpors]-[A-Za-z0-9-]{10,}/ },
 ];
+/**
+ * 텍스트에서 민감 정보 패턴을 찾아 `[REDACTED:<NAME>]` 로 치환 (순수 함수).
+ *
+ * R5-G2: auto-compound-runner 가 사용자 transcript 를 Claude (Haiku) 로 송신하기 전
+ * 적용. `detectSecrets` 는 감지만, 이 함수는 실제 문자열에서 대체.
+ */
+export function redactSecrets(text) {
+    const hits = [];
+    let out = text;
+    for (const sp of SECRET_PATTERNS) {
+        // regex 복제 (global flag 없이 repeated test 되는 경우 lastIndex 안전)
+        const re = new RegExp(sp.pattern.source, (sp.pattern.flags.includes('g') ? sp.pattern.flags : sp.pattern.flags + 'g'));
+        if (re.test(out)) {
+            hits.push(sp);
+            const re2 = new RegExp(sp.pattern.source, (sp.pattern.flags.includes('g') ? sp.pattern.flags : sp.pattern.flags + 'g'));
+            out = out.replace(re2, `[REDACTED:${sp.name}]`);
+        }
+    }
+    return { redacted: out, hits };
+}
 /** 텍스트에서 민감 정보 패턴 감지 (순수 함수) */
 export function detectSecrets(text) {
     const found = [];

package/dist/hooks/session-recovery.js

@@ -378,7 +378,6 @@ async function main() {
         // v1: regex 기반 패턴 학습(prompt-learner) 제거. Evidence 기반으로 전환됨.
         // Compound v3: Run lifecycle check once per day
         try {
-            const lifecycleModulePath = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'engine', 'compound-lifecycle.js');
             const lastLifecyclePath = path.join(STATE_DIR, 'last-lifecycle.json');
             let shouldRun = true;
             try {
@@ -390,13 +389,22 @@ async function main() {
             }
             catch { /* last-lifecycle.json parse failure — run lifecycle check anyway */ }
             if (shouldRun) {
-                // B-4: detached background spawn으로 분리 — hook timeout 초과 방지
+                // B-4: detached background spawn — hook timeout 초과 방지.
+                //
+                // Audit fix #5 (2026-04-21): prior invocation interpolated
+                // `sessionId` into a `-e` template literal
+                //   `import('${path}').then(m => m.runLifecycleCheck('${sessionId}'))`
+                // which created a code-injection surface (a crafted sessionId
+                // could break out of the single quotes and execute arbitrary JS
+                // under the user's Claude-Code privileges). The runner was moved
+                // to a dedicated script file and the id is now passed via argv —
+                // no shell, no eval, no interpolation.
+                const runnerPath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'internal', 'run-lifecycle-check.js');
                 const { spawn: spawnLifecycle } = await import('node:child_process');
-                const lifecycleRunner = spawnLifecycle('node', [
-                    '--input-type=module',
-                    '-e',
-                    `import('${lifecycleModulePath.replace(/\\/g, '/')}').then(m => m.runLifecycleCheck('${sessionId}'))`,
-                ], { detached: true, stdio: 'ignore' });
+                const lifecycleRunner = spawnLifecycle('node', [runnerPath, sessionId], {
+                    detached: true,
+                    stdio: 'ignore',
+                });
                 lifecycleRunner.unref();
                 const { atomicWriteJSON: writeJSON } = await import('./shared/atomic-write.js');
                 writeJSON(lastLifecyclePath, { lastRun: new Date().toISOString() });

package/dist/hooks/shared/atomic-write.d.ts

@@ -37,5 +37,12 @@ export declare function atomicWriteText(filePath: string, content: string, optio
     mode?: number;
     dirMode?: number;
 }): void;
-/** JSON 파일을 안전하게 읽기 (파싱 실패 시 fallback 반환) */
+/**
+ * JSON 파일을 안전하게 읽기 (파싱 실패 시 fallback 반환).
+ *
+ * R4-B3 (2026-04-22): UTF-8 BOM () prefix 제거 — Windows 메모장 등으로 저장된
+ *   rule/settings JSON 이 BOM 으로 시작해 JSON.parse 가 silent 실패하던 문제.
+ * R4-SKIP: FORGEN_DEBUG_SIGNALS=1 일 때 파싱 실패를 stderr 로 노출 — silent
+ *   누락을 운영자가 추적 가능하도록.
+ */
 export declare function safeReadJSON<T>(filePath: string, fallback: T): T;