@wooojin/forgen 0.3.0 → 0.3.2

package/dist/engine/solution-weakness.js

@@ -0,0 +1,225 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ME_SOLUTIONS, STATE_DIR } from '../core/paths.js';
+import { parseFrontmatterOnly } from './solution-format.js';
+import { computeFitness } from './solution-fitness.js';
+import { readAllOutcomes } from './solution-outcomes.js';
+import { createLogger } from '../core/logger.js';
+const log = createLogger('solution-weakness');
+function loadSolutionRows(solutionsDir) {
+    if (!fs.existsSync(solutionsDir))
+        return [];
+    const rows = [];
+    for (const file of fs.readdirSync(solutionsDir)) {
+        if (!file.endsWith('.md'))
+            continue;
+        try {
+            const content = fs.readFileSync(path.join(solutionsDir, file), 'utf-8');
+            const fm = parseFrontmatterOnly(content);
+            if (!fm)
+                continue;
+            rows.push({ name: fm.name, tags: fm.tags });
+        }
+        catch { /* skip */ }
+    }
+    return rows;
+}
+function findUnderServedTags(rows, fitnessByName) {
+    // Read correction evidence tags from ~/.forgen/me/behavior/*.json — each
+    // entry carries a `raw_payload` with inferred tags or keywords. Be
+    // tolerant: the schema has drifted historically, so we accept any string
+    // array we can find under likely field names.
+    const behaviorDir = path.join(ME_SOLUTIONS, '..', 'behavior');
+    const correctionTags = new Map();
+    if (fs.existsSync(behaviorDir)) {
+        for (const file of fs.readdirSync(behaviorDir)) {
+            if (!file.endsWith('.json'))
+                continue;
+            try {
+                const data = JSON.parse(fs.readFileSync(path.join(behaviorDir, file), 'utf-8'));
+                const payload = data.raw_payload ?? data.payload ?? {};
+                const tags = collectTags(payload).concat(collectTags(data.axis_refs ?? []));
+                const summary = typeof data.summary === 'string' ? data.summary.toLowerCase() : '';
+                for (const tag of new Set(tags)) {
+                    correctionTags.set(tag, (correctionTags.get(tag) ?? 0) + 1);
+                }
+                // Summary keywords fallback — split on whitespace, filter obvious fillers
+                for (const word of summary.split(/\s+/)) {
+                    if (word.length >= 5 && word.length <= 20) {
+                        correctionTags.set(word, (correctionTags.get(word) ?? 0) + 0.3);
+                    }
+                }
+            }
+            catch { /* skip bad json */ }
+        }
+    }
+    const result = [];
+    for (const [tag, count] of correctionTags) {
+        if (count < 2)
+            continue; // noise cutoff
+        let bestName = null;
+        let bestFitness = 0;
+        for (const row of rows) {
+            if (!row.tags.includes(tag))
+                continue;
+            const fit = fitnessByName.get(row.name)?.fitness ?? 0;
+            if (fit > bestFitness || (bestName === null && fit >= 0)) {
+                bestFitness = fit;
+                bestName = row.name;
+            }
+        }
+        // Under-served: no matching solution, or best match is not a champion
+        const bestFit = bestName ? fitnessByName.get(bestName) : null;
+        const isChampion = bestFit?.state === 'champion';
+        if (!bestName || !isChampion) {
+            result.push({
+                tag,
+                correction_mentions: Math.round(count),
+                best_matching_champion: isChampion ? bestName : null,
+                best_fitness: bestFitness,
+            });
+        }
+    }
+    result.sort((a, b) => b.correction_mentions - a.correction_mentions);
+    return result.slice(0, 10);
+}
+function collectTags(v) {
+    if (Array.isArray(v))
+        return v.filter((x) => typeof x === 'string');
+    if (v && typeof v === 'object') {
+        return Object.values(v)
+            .filter((x) => typeof x === 'string');
+    }
+    return [];
+}
+function findConflictClusters(rows, fitnessByName) {
+    const champions = rows.filter((r) => fitnessByName.get(r.name)?.state === 'champion');
+    const underperformers = rows.filter((r) => fitnessByName.get(r.name)?.state === 'underperform');
+    const clusters = [];
+    for (const ch of champions) {
+        for (const up of underperformers) {
+            const shared = ch.tags.filter((t) => up.tags.includes(t));
+            if (shared.length < 2)
+                continue;
+            clusters.push({
+                shared_tags: shared,
+                champion: { name: ch.name, fitness: fitnessByName.get(ch.name).fitness },
+                underperform: { name: up.name, fitness: fitnessByName.get(up.name).fitness },
+            });
+        }
+    }
+    clusters.sort((a, b) => b.shared_tags.length - a.shared_tags.length);
+    return clusters.slice(0, 5);
+}
+function findDeadCorners(rows, fitnessByName) {
+    // Dead = injected=0. Unique tags = tags present only in this solution.
+    const injectedRows = rows.filter((r) => (fitnessByName.get(r.name)?.injected ?? 0) > 0);
+    const injectedTags = new Set();
+    for (const r of injectedRows)
+        for (const t of r.tags)
+            injectedTags.add(t);
+    const dead = [];
+    for (const r of rows) {
+        const injected = fitnessByName.get(r.name)?.injected ?? 0;
+        if (injected > 0)
+            continue;
+        const unique = r.tags.filter((t) => !injectedTags.has(t));
+        if (unique.length === 0)
+            continue;
+        dead.push({ solution: r.name, unique_tags: unique, injected });
+    }
+    dead.sort((a, b) => b.unique_tags.length - a.unique_tags.length);
+    return dead.slice(0, 10);
+}
+function findVolatile(_fitnessByName) {
+    const events = readAllOutcomes();
+    if (events.length === 0)
+        return [];
+    // Split events into two halves by timestamp; compute per-solution accept
+    // rate delta between halves. Volatile = |delta| > 0.3 and enough data.
+    const mid = events[Math.floor(events.length / 2)].ts;
+    const by = new Map();
+    for (const ev of events) {
+        const c = by.get(ev.solution) ?? { a_accept: 0, a_total: 0, b_accept: 0, b_total: 0 };
+        if (ev.outcome === 'accept' || ev.outcome === 'correct' || ev.outcome === 'error') {
+            const isA = ev.ts < mid;
+            if (isA) {
+                c.a_total++;
+                if (ev.outcome === 'accept')
+                    c.a_accept++;
+            }
+            else {
+                c.b_total++;
+                if (ev.outcome === 'accept')
+                    c.b_accept++;
+            }
+        }
+        by.set(ev.solution, c);
+    }
+    const result = [];
+    for (const [name, c] of by) {
+        if (c.a_total < 3 || c.b_total < 3)
+            continue;
+        const rateA = c.a_accept / c.a_total;
+        const rateB = c.b_accept / c.b_total;
+        const delta = rateB - rateA;
+        if (Math.abs(delta) < 0.3)
+            continue;
+        result.push({
+            solution: name,
+            accept_rate_window_a: Number(rateA.toFixed(3)),
+            accept_rate_window_b: Number(rateB.toFixed(3)),
+            delta: Number(delta.toFixed(3)),
+        });
+    }
+    result.sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta));
+    return result.slice(0, 5);
+}
+export function buildWeaknessReport(solutionsDir = ME_SOLUTIONS) {
+    const rows = loadSolutionRows(solutionsDir);
+    const fitnessList = computeFitness();
+    const fitnessByName = new Map(fitnessList.map((f) => [f.solution, f]));
+    const population = {
+        total: fitnessList.length,
+        champion: fitnessList.filter((f) => f.state === 'champion').length,
+        active: fitnessList.filter((f) => f.state === 'active').length,
+        underperform: fitnessList.filter((f) => f.state === 'underperform').length,
+        draft: fitnessList.filter((f) => f.state === 'draft').length,
+    };
+    return {
+        generated_at: new Date().toISOString(),
+        population,
+        under_served_tags: findUnderServedTags(rows, fitnessByName),
+        conflict_clusters: findConflictClusters(rows, fitnessByName),
+        dead_corners: findDeadCorners(rows, fitnessByName),
+        volatile: findVolatile(fitnessByName),
+    };
+}
+export function saveWeaknessReport(report) {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+    const ts = Date.now();
+    const p = path.join(STATE_DIR, `weakness-report-${ts}.json`);
+    try {
+        fs.writeFileSync(p, JSON.stringify(report, null, 2));
+    }
+    catch (e) {
+        log.debug(`save failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    return p;
+}
+export function latestWeaknessReport() {
+    if (!fs.existsSync(STATE_DIR))
+        return null;
+    const candidates = fs.readdirSync(STATE_DIR)
+        .filter((f) => f.startsWith('weakness-report-') && f.endsWith('.json'))
+        .sort()
+        .reverse();
+    if (candidates.length === 0)
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(path.join(STATE_DIR, candidates[0]), 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/engine/solution-writer.d.ts

@@ -71,6 +71,14 @@ export declare function mutateSolutionByName(name: string, mutator: SolutionMuta
 }): boolean;
 /**
  * Evidence 카운터 단일 증가 helper.
- * mutateSolutionByName + 카운터 증가 패턴을 한 줄로.
+ *
+ * Invariant: status/confidence 같은 lifecycle 필드는 건드리지 않는다.
+ * 모든 status 전이는 compound-lifecycle.ts::runLifecycleCheck(자동, reflected
+ * /sessions/reExtracted + age-gate 기반)과 verifySolution(수동 명령)이라는
+ * 단일 경로로만 일어난다. dual-path 금지.
+ *
+ * 과거에는 inject≥5 자동 verified 승급이 이 함수 안에 있었는데, 그것은 outcome
+ * 증거 없이도 candidate를 승급시켜 self-rewarding 편향을 만들었다. 2026-04-20
+ * 제거 (feedback_core_loop_invariant 참고).
  */
 export declare function incrementEvidence(solutionName: string, field: 'reflected' | 'negative' | 'injected' | 'sessions' | 'reExtracted'): boolean;

package/dist/engine/solution-writer.js

@@ -31,6 +31,7 @@ import { atomicWriteText } from '../hooks/shared/atomic-write.js';
 import { parseFrontmatterOnly, parseSolutionV3, serializeSolutionV3, } from './solution-format.js';
 import { ME_SOLUTIONS, ME_RULES } from '../core/paths.js';
 import { createLogger } from '../core/logger.js';
+import { getOrBuildIndex } from './solution-index.js';
 const log = createLogger('solution-writer');
 /**
  * 단일 .md 파일에 lock 보호된 read-modify-write 수행.
@@ -96,7 +97,40 @@ export function mutateSolutionFile(filePath, mutator) {
  * symlink는 보안상 무시 (lstatSync 가드).
  */
 export function mutateSolutionByName(name, mutator, options) {
-    const dirs = [ME_SOLUTIONS, ME_RULES, ...(options?.extraDirs ?? [])];
+    const extraDirs = options?.extraDirs ?? [];
+    const dirs = [ME_SOLUTIONS, ME_RULES, ...extraDirs];
+    // P0-3 fast path (2026-04-20): solution-index의 캐시에서 name→filePath를
+    // O(1) 조회. 과거에는 매 호출마다 dir readdir + N번 readFileSync + YAML parse
+    // (N=500일 때 hook당 최대 1500회 I/O)로 5초 timeout을 위협했다.
+    // 인덱스 miss/stale 시 아래 기존 O(N) 스캔 경로로 fallback한다.
+    try {
+        const indexDirs = [
+            { dir: ME_SOLUTIONS, scope: 'me' },
+            { dir: ME_RULES, scope: 'me' },
+            ...extraDirs.map((d) => ({ dir: d, scope: 'project' })),
+        ];
+        const idx = getOrBuildIndex(indexDirs);
+        const entry = idx.entries.find(e => e.name === name);
+        if (entry?.filePath && fs.existsSync(entry.filePath)) {
+            let isSymlink = true;
+            try {
+                isSymlink = fs.lstatSync(entry.filePath).isSymbolicLink();
+            }
+            catch { /* fall through to full scan */ }
+            if (!isSymlink) {
+                const result = mutateSolutionFile(entry.filePath, sol => {
+                    if (sol.frontmatter.name !== name)
+                        return false;
+                    return mutator(sol);
+                });
+                if (result)
+                    return true;
+                // 인덱스가 stale(이름이 바뀌었거나 파일이 재생성됨)이면 fallback 경로로.
+            }
+        }
+    }
+    catch { /* 인덱스 빌드 실패 — fallback */ }
+    // Fallback: 전체 디렉터리 스캔 (인덱스 miss / stale 시)
     for (const dir of dirs) {
         if (!fs.existsSync(dir))
             continue;
@@ -144,7 +178,15 @@ export function mutateSolutionByName(name, mutator, options) {
 }
 /**
  * Evidence 카운터 단일 증가 helper.
- * mutateSolutionByName + 카운터 증가 패턴을 한 줄로.
+ *
+ * Invariant: status/confidence 같은 lifecycle 필드는 건드리지 않는다.
+ * 모든 status 전이는 compound-lifecycle.ts::runLifecycleCheck(자동, reflected
+ * /sessions/reExtracted + age-gate 기반)과 verifySolution(수동 명령)이라는
+ * 단일 경로로만 일어난다. dual-path 금지.
+ *
+ * 과거에는 inject≥5 자동 verified 승급이 이 함수 안에 있었는데, 그것은 outcome
+ * 증거 없이도 candidate를 승급시켜 self-rewarding 편향을 만들었다. 2026-04-20
+ * 제거 (feedback_core_loop_invariant 참고).
  */
 export function incrementEvidence(solutionName, field) {
     return mutateSolutionByName(solutionName, sol => {

package/dist/fgx.js

@@ -15,10 +15,17 @@ if (!launchArgs.includes('--dangerously-skip-permissions')) {
     launchArgs.unshift('--dangerously-skip-permissions');
 }
 async function main() {
-    // Security warning — fgx bypasses all Claude Code permission checks
+    // Security warning — fgx bypasses all Claude Code permission checks.
+    //
+    // Audit fix #3 (2026-04-21): The warning banner is shown regardless of
+    // the user's profile trust policy, which means "가드레일 우선" users who
+    // alias `fgx` unknowingly run with zero guardrails. Users who rely on
+    // the profile trust policy should NOT use `fgx`. Surface the mismatch
+    // loudly (harness.ts also prints the Trust 상승 warning downstream).
     console.warn('\n  ⚠  fgx: ALL permission checks are disabled (--dangerously-skip-permissions)');
     console.warn('  ⚠  Claude Code will execute tools without asking for confirmation.');
-    console.warn('  ⚠  Use only in trusted environments.\n');
+    console.warn('  ⚠  Use only in trusted environments. If your profile trust policy is');
+    console.warn('  ⚠  "가드레일 우선" or "승인 완화", consider `forgen` (no flag) instead.\n');
     // fgx는 서브커맨드 없이 바로 Claude Code 실행 전용
     const firstRun = isFirstRun();
     if (firstRun) {

package/dist/forge/cli.js

@@ -58,7 +58,7 @@ async function handleReset(level) {
     }
     // 동적 import로 store 모듈 로드
     const fs = await import('node:fs');
-    const { V1_PROFILE, V1_RULES_DIR, V1_EVIDENCE_DIR, V1_RECOMMENDATIONS_DIR, V1_SESSIONS_DIR, V1_RAW_LOGS_DIR, V1_SOLUTIONS_DIR } = await import('../core/paths.js');
+    const { FORGE_PROFILE, ME_RULES, ME_BEHAVIOR, V1_RECOMMENDATIONS_DIR, V1_SESSIONS_DIR, V1_RAW_LOGS_DIR, ME_SOLUTIONS } = await import('../core/paths.js');
     const deleteDirs = (dirs) => {
         for (const dir of dirs) {
             try {
@@ -75,18 +75,18 @@ async function handleReset(level) {
         catch { /* ignore */ }
     };
     if (level === 'soft') {
-        deleteFile(V1_PROFILE);
-        deleteDirs([V1_RULES_DIR, V1_RECOMMENDATIONS_DIR, V1_SESSIONS_DIR]);
+        deleteFile(FORGE_PROFILE);
+        deleteDirs([ME_RULES, V1_RECOMMENDATIONS_DIR, V1_SESSIONS_DIR]);
         console.log('\n  Soft reset 완료. Profile + Rule + Recommendation + Session 초기화.');
     }
     else if (level === 'learning') {
-        deleteFile(V1_PROFILE);
-        deleteDirs([V1_RULES_DIR, V1_EVIDENCE_DIR, V1_RECOMMENDATIONS_DIR, V1_SESSIONS_DIR, V1_RAW_LOGS_DIR]);
+        deleteFile(FORGE_PROFILE);
+        deleteDirs([ME_RULES, ME_BEHAVIOR, V1_RECOMMENDATIONS_DIR, V1_SESSIONS_DIR, V1_RAW_LOGS_DIR]);
         console.log('\n  Learning reset 완료. 개인 학습 전체 초기화.');
     }
     else if (level === 'full') {
-        deleteFile(V1_PROFILE);
-        deleteDirs([V1_RULES_DIR, V1_EVIDENCE_DIR, V1_RECOMMENDATIONS_DIR, V1_SESSIONS_DIR, V1_RAW_LOGS_DIR, V1_SOLUTIONS_DIR]);
+        deleteFile(FORGE_PROFILE);
+        deleteDirs([ME_RULES, ME_BEHAVIOR, V1_RECOMMENDATIONS_DIR, V1_SESSIONS_DIR, V1_RAW_LOGS_DIR, ME_SOLUTIONS]);
         console.log('\n  Full reset 완료. Compound 포함 전체 초기화.');
     }
     // Reset 후 자동 온보딩 (interactive 환경에서만)

package/dist/hooks/context-guard.js

@@ -19,6 +19,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 +90,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) {
@@ -181,7 +193,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'));

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-failure.js

@@ -105,6 +105,13 @@ async function main() {
     saveFailureState(state);
     // 컨텍스트 신호 업데이트
     incrementFailureSignal(sessionId);
+    // Outcome tracking (Phase 1): attribute this tool failure to pending
+    // solution injections in the same session. Fail-open.
+    try {
+        const { attributeError } = await import('../engine/solution-outcomes.js');
+        attributeError(sessionId);
+    }
+    catch { /* ignore */ }
     const failCount = state.failures[toolName].count;
     const suggestion = getRecoverySuggestion(error, toolName);
     // 3회 이상 반복 실패 시 강화된 경고