@wooojin/forgen 0.4.0 → 0.4.3

package/dist/core/spawn.js

@@ -7,13 +7,11 @@ import { buildEnv } from './config-injector.js';
 import { loadGlobalConfig } from './global-config.js';
 import { createLogger } from './logger.js';
 import { STATE_DIR } from './paths.js';
+import { getHostRuntime } from '../host/host-runtime.js';
 const log = createLogger('spawn');
-/** claude CLI 경로 탐색 */
-function findClaude() {
-    return 'claude';
-}
+/** Phase 2: host-runtime 어댑터 위임. */
 function findRuntimeLauncher(runtime) {
-    return runtime === 'codex' ? 'codex' : findClaude();
+    return getHostRuntime(runtime).launcher;
 }
 function transcriptProjectDir(cwd) {
     // Claude Code는 cwd의 /를 -로 치환하고 선행 -를 유지
@@ -161,12 +159,7 @@ export async function spawnClaude(args, context, runtime = 'claude') {
         });
         child.on('error', (err) => {
             if (err.code === 'ENOENT') {
-                if (runtime === 'codex') {
-                    reject(new Error('Codex is not installed.'));
-                }
-                else {
-                    reject(new Error('Claude Code is not installed. npm install -g @anthropic-ai/claude-code'));
-                }
+                reject(new Error(getHostRuntime(runtime).missingInstallMessage));
             }
             else {
                 reject(err);

package/dist/core/stats-cli.d.ts

@@ -9,6 +9,27 @@ export interface StatsSnapshot {
     drift7d: number;
     retired7d: number;
     lastExtraction: string;
+    /**
+     * H3 / v0.4.1 — assist 축 가시화. enforcement(block/violation) 는 이미 표시되지만
+     * assist(recall hit, surface, extraction) 는 v0.4.0 에서 8,000+ 번 작동했음에도
+     * 사용자에게 0건 노출되었다. 오늘 기준 숫자로 "지금 학습되고 있다" 를 surface.
+     */
+    assistToday: {
+        recallHits: number;
+        surfaced: number;
+        referenced: number;
+        extractedToday: number;
+    };
+    /**
+     * v0.4.1 철학 고도화 지표 — forge-profile.json 이 실제로 학습됐는지 한눈에.
+     * 값이 있으면 가시화, 없으면 undefined.
+     */
+    philosophy?: {
+        basePacks: string[];
+        trustPolicy: string;
+        axisScores: Record<string, number>;
+        lastReclassification: string | null;
+    };
 }
 export declare function computeStats(): StatsSnapshot;
 export declare function renderStats(s: StatsSnapshot): string;

package/dist/core/stats-cli.js

@@ -6,13 +6,16 @@
  * working between Claude sessions.
  */
 import * as fs from 'node:fs';
-import * as os from 'node:os';
 import * as path from 'node:path';
 import { loadAllRules } from '../store/rule-store.js';
-import { loadRecentEvidence } from '../store/evidence-store.js';
-const ENFORCEMENT_DIR = path.join(os.homedir(), '.forgen', 'state', 'enforcement');
-const LIFECYCLE_DIR = path.join(os.homedir(), '.forgen', 'state', 'lifecycle');
-const STATE_DIR = path.join(os.homedir(), '.forgen', 'state');
+import { loadAllEvidence } from '../store/evidence-store.js';
+import { STATE_DIR, ME_DIR } from './paths.js';
+import { computeFixFeatRatio, formatFixRatio } from './git-stats.js';
+// v0.4.1 격리 fix: 이전에는 os.homedir() 직접 사용해서 FORGEN_HOME env 로
+// 홈 격리해도 이 파일의 경로는 여전히 실 홈 가리켰음. paths.ts 상수 import.
+const ENFORCEMENT_DIR = path.join(STATE_DIR, 'enforcement');
+const LIFECYCLE_DIR = path.join(STATE_DIR, 'lifecycle');
+const SOLUTIONS_DIR = path.join(ME_DIR, 'solutions');
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
 function readJsonl(p) {
     if (!fs.existsSync(p))
@@ -61,12 +64,23 @@ function readLifecycleRetired(days) {
     return n;
 }
 function readLastExtraction() {
-    const p = path.join(STATE_DIR, 'last-extraction.json');
-    if (!fs.existsSync(p))
+    // v0.4.1 파일명 정합: auto-compound-runner 는 last-auto-compound.json 에 기록.
+    // 이전 코드가 last-extraction.json 을 찾아 "never" 가 만성적으로 표시됨 —
+    // 실은 매 auto-compound 세션마다 값이 업데이트되고 있는데도 stats 에 반영 X.
+    const candidates = ['last-auto-compound.json', 'last-extraction.json'];
+    let p = null;
+    for (const name of candidates) {
+        const candidate = path.join(STATE_DIR, name);
+        if (fs.existsSync(candidate)) {
+            p = candidate;
+            break;
+        }
+    }
+    if (!p)
         return 'never';
     try {
         const data = JSON.parse(fs.readFileSync(p, 'utf-8'));
-        const ts = data.timestamp ?? data.date;
+        const ts = data.completedAt ?? data.timestamp ?? data.date;
         if (!ts)
             return 'never';
         const diffDays = Math.floor((Date.now() - Date.parse(ts)) / MS_PER_DAY);
@@ -81,17 +95,90 @@ function readLastExtraction() {
         return 'unknown';
     }
 }
+/** H3: 오늘 (local midnight ~ now) 기준 assist 카운트. */
+function computeAssistToday() {
+    const startOfDay = new Date();
+    startOfDay.setHours(0, 0, 0, 0);
+    const cutoffMs = startOfDay.getTime();
+    // recall hits: match-eval-log 의 오늘 entries
+    const matchLog = readJsonl(path.join(STATE_DIR, 'match-eval-log.jsonl'));
+    let recallHits = 0;
+    for (const e of matchLog) {
+        const ts = typeof e.ts === 'string' ? Date.parse(e.ts) : NaN;
+        if (Number.isFinite(ts) && ts >= cutoffMs)
+            recallHits++;
+    }
+    // surfaced + referenced — 같은 스트림 1회 loop 로.
+    const feedback = readJsonl(path.join(STATE_DIR, 'implicit-feedback.jsonl'));
+    let surfaced = 0;
+    let referenced = 0;
+    for (const e of feedback) {
+        const ts = typeof e.at === 'string' ? Date.parse(e.at) : NaN;
+        if (!Number.isFinite(ts) || ts < cutoffMs)
+            continue;
+        if (e.type === 'recommendation_surfaced')
+            surfaced++;
+        else if (e.type === 'recall_referenced')
+            referenced++;
+    }
+    // extracted today: solutions dir 에서 오늘 mtime 인 .md 파일
+    let extractedToday = 0;
+    try {
+        if (fs.existsSync(SOLUTIONS_DIR)) {
+            for (const f of fs.readdirSync(SOLUTIONS_DIR)) {
+                if (!f.endsWith('.md'))
+                    continue;
+                const stat = fs.statSync(path.join(SOLUTIONS_DIR, f));
+                if (stat.mtimeMs >= cutoffMs)
+                    extractedToday++;
+            }
+        }
+    }
+    catch { /* fail-open */ }
+    return { recallHits, surfaced, referenced, extractedToday };
+}
+/** v0.4.1: forge-profile 에서 고도화 지표 추출. 파일 없거나 깨지면 undefined. */
+function computePhilosophy() {
+    try {
+        const profilePath = path.join(ME_DIR, 'forge-profile.json');
+        if (!fs.existsSync(profilePath))
+            return undefined;
+        const d = JSON.parse(fs.readFileSync(profilePath, 'utf-8'));
+        const axisScores = {};
+        for (const [k, v] of Object.entries(d.axes ?? {})) {
+            if (v && typeof v.score === 'number')
+                axisScores[k] = v.score;
+        }
+        return {
+            basePacks: Object.values(d.base_packs ?? {}),
+            trustPolicy: d.trust_preferences?.desired_policy ?? 'unknown',
+            axisScores,
+            lastReclassification: d.metadata?.last_reclassification_at ?? null,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
 export function computeStats() {
     const rules = loadAllRules();
     const activeRules = rules.filter((r) => r.status === 'active').length;
     const suppressedRules = rules.filter((r) => r.status === 'suppressed').length;
-    const evidence = loadRecentEvidence(500);
+    // v0.4.1 정확도 수정: loadRecentEvidence(500) 제한은 "Corrections (total)"
+    // 라벨과 모순 — 실 behavior 618건 중 118건 누락됐음. 전체 evidence 스캔으로
+    // 교체. explicit_correction 만 filter 이므로 memory overhead 는 N * ~1KB 수준.
+    const evidence = loadAllEvidence();
     const corrections = evidence.filter((e) => e.type === 'explicit_correction');
     const correctionsTotal = corrections.length;
     const cutoff7d = Date.now() - 7 * MS_PER_DAY;
     const corrections7d = corrections.filter((e) => Date.parse(e.timestamp) >= cutoff7d).length;
     const violations = readJsonl(path.join(ENFORCEMENT_DIR, 'violations.jsonl'));
-    const bypass = readJsonl(path.join(ENFORCEMENT_DIR, 'bypass.jsonl'));
+    // v0.4.1 historical false-positive 제거: pre-0.4.1 bypass-detector 가 Write/Edit
+    // content 의 quote 본문까지 raw 매칭해서 bypass 로 오기록. 실 관찰: L1-no-rm-rf
+    // -unconfirmed bypass 20건 중 Write/Edit 15건. stats 표시는 **실 실행 맥락** 인
+    // Bash/Agent/기타만 집계 — 앞으로의 시계열 일관성 + 과거 noise 제거.
+    const bypassRaw = readJsonl(path.join(ENFORCEMENT_DIR, 'bypass.jsonl'));
+    const bypass = bypassRaw.filter((e) => e.tool !== 'Write' && e.tool !== 'Edit');
     const drift = readJsonl(path.join(ENFORCEMENT_DIR, 'drift.jsonl'));
     const acks = readJsonl(path.join(ENFORCEMENT_DIR, 'acknowledgments.jsonl'));
     // R9-PA2: violations 는 'block' (stop-guard/post-tool) + 'deny' (pre-tool Mech-A)
@@ -109,6 +196,8 @@ export function computeStats() {
         drift7d: countWithin(drift, 7),
         retired7d: readLifecycleRetired(7),
         lastExtraction: readLastExtraction(),
+        assistToday: computeAssistToday(),
+        philosophy: computePhilosophy(),
     };
 }
 function padNum(n, width = 4) {
@@ -133,6 +222,40 @@ export function renderStats(s) {
     lines.push(`    Drift events        ${padNum(s.drift7d)}    — stuck-loop force-approves`);
     lines.push(`    Retired rules       ${padNum(s.retired7d)}    — superseded or timed out`);
     lines.push('');
+    // H3: Assist 축 — enforcement 옆에 나란히 가시화.
+    lines.push('  Today (assist)');
+    lines.push(`    Recall hits         ${padNum(s.assistToday.recallHits)}    — compound 매칭 시도 수`);
+    lines.push(`    Surfaced            ${padNum(s.assistToday.surfaced)}    — 실제 주입된 솔루션 수`);
+    const ratio = s.assistToday.surfaced > 0
+        ? ` (${Math.round(100 * s.assistToday.referenced / s.assistToday.surfaced)}% referenced)`
+        : '';
+    lines.push(`    Referenced          ${padNum(s.assistToday.referenced)}    — Claude 응답에 인용됨${ratio}`);
+    lines.push(`    Extracted           ${padNum(s.assistToday.extractedToday)}    — 오늘 새로 저장된 패턴`);
+    lines.push('');
+    // v0.4.1 철학 고도화 단면 — "개인화가 어디까지 학습됐나" 1섹션.
+    if (s.philosophy) {
+        lines.push('  Philosophy (learned)');
+        lines.push(`    Base packs          ${s.philosophy.basePacks.join(' / ')}`);
+        lines.push(`    Trust policy        ${s.philosophy.trustPolicy}`);
+        const scores = Object.entries(s.philosophy.axisScores)
+            .map(([k, v]) => `${k}:${v.toFixed(2)}`)
+            .join('  ');
+        if (scores)
+            lines.push(`    Axis scores         ${scores}`);
+        lines.push(`    Last reclass        ${s.philosophy.lastReclassification ?? 'never'}`);
+        lines.push('');
+    }
+    // P4 셀프 가드 — 최근 30커밋 fix:feat 비율로 회귀 패턴 자가 노출.
+    // 30% 초과 시 "이거 고치면 저거 버그난다" 패턴 의심 → forgen doctor 가 경고.
+    try {
+        const ratio = computeFixFeatRatio();
+        if (ratio.available) {
+            lines.push('  Repo health (last 30 commits)');
+            lines.push(`    ${formatFixRatio(ratio)}`);
+            lines.push('');
+        }
+    }
+    catch { /* fail-open: git 없거나 비-repo 환경 */ }
     lines.push(`  Last extraction: ${s.lastExtraction}`);
     lines.push('');
     return lines.join('\n');

package/dist/core/trust-layer-intent.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Trust Layer Intent — Multi-Host Core Design §9.0 산출물 #1
+ *
+ * forgen 이 host 위에서 보장하는 행동의 enum. spec §9.0 의 7 의도 매트릭스와 1:1.
+ * 각 host adapter 는 이 enum 의 모든 항목에 대해 CapabilityDeclaration 을 선언해야 하며,
+ * 미선언은 컴파일 타임(`Record<TrustLayerIntent, _>`) + 런타임(`assertCapabilitiesComplete`) 양쪽에서 fail.
+ *
+ * 1원칙: Claude semantics 가 reference. 본 enum 의 의미는 Claude Hook schema 의 행동을 그대로 사용한다.
+ */
+export declare const TRUST_LAYER_INTENTS: readonly ["block-completion", "block-tool-use", "inject-context", "observe-only", "secret-filter", "forge-loop-state-inject", "self-evidence-record"];
+export type TrustLayerIntent = (typeof TRUST_LAYER_INTENTS)[number];
+export type CapabilityStatus = 'supported' | 'partial' | 'unsupported';
+export interface CapabilityDeclaration {
+    readonly status: CapabilityStatus;
+    /** host 표면이 이 의도를 표현하는 hook/필드 (예: "Stop + decision:'block' + reason"). */
+    readonly expression: string;
+    /** partial/unsupported 시 등가성 보존을 위한 mitigation 핸들. supported 면 undefined. */
+    readonly mitigation?: string;
+    /** source-of-truth (spec 또는 외부 docs/source 인용). */
+    readonly source?: string;
+}
+export type HostId = 'claude' | 'codex';
+export interface HostCapabilities {
+    readonly hostId: HostId;
+    /**
+     * 모든 TrustLayerIntent 에 대한 선언. `Record<TrustLayerIntent, _>` 타입이
+     * 컴파일 타임에 누락을 차단한다.
+     */
+    readonly intents: Record<TrustLayerIntent, CapabilityDeclaration>;
+}
+/**
+ * 런타임 assertion — host adapter 가 새 의도 추가를 누락한 경우 fail.
+ * 컴파일 타임 가드를 우회하는 동적 생성 코드를 위한 안전망.
+ */
+export declare function assertCapabilitiesComplete(caps: HostCapabilities): void;

package/dist/core/trust-layer-intent.js

@@ -0,0 +1,30 @@
+/**
+ * Trust Layer Intent — Multi-Host Core Design §9.0 산출물 #1
+ *
+ * forgen 이 host 위에서 보장하는 행동의 enum. spec §9.0 의 7 의도 매트릭스와 1:1.
+ * 각 host adapter 는 이 enum 의 모든 항목에 대해 CapabilityDeclaration 을 선언해야 하며,
+ * 미선언은 컴파일 타임(`Record<TrustLayerIntent, _>`) + 런타임(`assertCapabilitiesComplete`) 양쪽에서 fail.
+ *
+ * 1원칙: Claude semantics 가 reference. 본 enum 의 의미는 Claude Hook schema 의 행동을 그대로 사용한다.
+ */
+export const TRUST_LAYER_INTENTS = [
+    'block-completion',
+    'block-tool-use',
+    'inject-context',
+    'observe-only',
+    'secret-filter',
+    'forge-loop-state-inject',
+    'self-evidence-record',
+];
+/**
+ * 런타임 assertion — host adapter 가 새 의도 추가를 누락한 경우 fail.
+ * 컴파일 타임 가드를 우회하는 동적 생성 코드를 위한 안전망.
+ */
+export function assertCapabilitiesComplete(caps) {
+    const declared = new Set(Object.keys(caps.intents));
+    const missing = TRUST_LAYER_INTENTS.filter((i) => !declared.has(i));
+    if (missing.length > 0) {
+        throw new Error(`HostCapabilities for "${caps.hostId}" missing intents: ${missing.join(', ')}. ` +
+            `All TrustLayerIntent values must be declared (spec §9.0).`);
+    }
+}

package/dist/core/types.d.ts

@@ -112,7 +112,7 @@ export type RuntimeHost = 'claude' | 'codex';
 export interface LaunchContext {
     runtime: RuntimeHost;
     args: string[];
-    runtimeSource: 'flag' | 'env' | 'default';
+    runtimeSource: 'flag' | 'env' | 'profile' | 'default';
 }
 /** 훅 입력 이벤트 스키마 (버전 간 상위 호환용 최소 스펙) */
 export interface HookEventInput {

package/dist/core/uninstall.js

@@ -321,7 +321,8 @@ export async function handleUninstall(cwd, options) {
     cleanPluginArtifacts();
     if (options.purge) {
         try {
-            const forgenHome = path.join(os.homedir(), '.forgen');
+            const { FORGEN_HOME } = await import('./paths.js');
+            const forgenHome = FORGEN_HOME;
             if (fs.existsSync(forgenHome)) {
                 fs.rmSync(forgenHome, { recursive: true, force: true });
                 console.log('  ✓ Deleted ~/.forgen/ (all rules, state, solutions, behavior)');

package/dist/engine/compound-cli.js

@@ -65,6 +65,7 @@ export function listSolutions() {
     }
     const order = ['mature', 'verified', 'candidate', 'experiment', 'retired'];
     console.log('\n  Compound Entries\n');
+    console.log('  (inj: 누적 주입, ref: 명시 참조, neg: 부정 피드백 — ref 측정은 v0.4.1+ 부터 시작됨)\n');
     let total = 0;
     for (const status of order) {
         const group = groups[status];

package/dist/engine/compound-export.js

@@ -33,14 +33,19 @@ export function isPathInside(parentWithSep, candidate) {
     return resolved.startsWith(parentWithSep) && resolved !== parentWithSep;
 }
 /**
- * Count .md files in a directory (non-recursive).
- * Returns 0 if the directory does not exist.
+ * Count knowledge files in a directory (non-recursive). `.md` (solutions) + `.json`
+ * (rules, behavior, evidence) 둘 다 포함.
+ *
+ * v0.4.1 (2026-04-24): 이전에는 `.md` 만 세서 rules/*.json 전부가 count=0, export
+ * 대상에서도 제외됐다. 실증: `forgen compound export` 결과 rules 0, behavior 18
+ * (618건의 .json 누락). 사용자 철학의 **핵심**인 rules 가 하네스에서 빠진 상태
+ * 라 "나와 같은 데이터 하네스" 비전이 반쪽이었다.
  */
 function countFiles(dir) {
     try {
         if (!fs.existsSync(dir))
             return 0;
-        return fs.readdirSync(dir).filter(f => f.endsWith('.md')).length;
+        return fs.readdirSync(dir).filter(f => f.endsWith('.md') || f.endsWith('.json')).length;
     }
     catch {
         return 0;

package/dist/engine/compound-extractor.js

@@ -18,6 +18,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { execFileSync } from 'node:child_process';
+import { execHost } from '../host/exec-host.js';
 import { serializeSolutionV3, DEFAULT_EVIDENCE, extractTags } from './solution-format.js';
 import { createLogger } from '../core/logger.js';
 const log = createLogger('compound-extractor');
@@ -655,15 +656,12 @@ function enrichSolutionContent(solution, diffSnippet) {
             '코드 변경 (일부):',
             diffSnippet.slice(0, 2000),
         ].join('\n');
-        const result = execFileSync('claude', ['-p', prompt, '--model', 'haiku'], {
-            timeout: 15000,
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        const enriched = result.trim();
-        if (enriched.length > 30 && enriched.length < 1000) {
-            return enriched;
-        }
+        // feat/codex-support P2-2 — host-aware exec via profile.default_host.
+        // Codex 메인 사용자도 자동 추출 enrichment 가능 (해당 host CLI 호출).
+        // fail-open 정책 유지 — LLM enrichment 실패는 추출 자체를 막지 않음.
+        const { message } = execHost({ prompt, model: 'haiku', timeout: 15000 });
+        if (message.length > 30 && message.length < 1000)
+            return message;
         return null;
     }
     catch {

package/dist/engine/learn-cli.js

@@ -1,14 +1,11 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import * as os from 'node:os';
 import { fixupSolutions } from './solution-fixup.js';
 import { listQuarantined, pruneQuarantine } from './solution-quarantine.js';
 import { computeFitness } from './solution-fitness.js';
 import { buildWeaknessReport, saveWeaknessReport } from './solution-weakness.js';
 import { listCandidates, promoteCandidate, rollbackSince } from './solution-candidate.js';
-const ME_SOLUTIONS = path.join(os.homedir(), '.forgen', 'me', 'solutions');
-const STATE_DIR = path.join(os.homedir(), '.forgen', 'state');
-const OUTCOMES_DIR = path.join(STATE_DIR, 'outcomes');
+import { ME_SOLUTIONS, OUTCOMES_DIR } from '../core/paths.js';
 export async function handleLearn(args) {
     const sub = args[0];
     if (sub === 'fix-up')
@@ -150,10 +147,12 @@ function runEvolve(args) {
     const rollbackIdx = args.indexOf('--rollback');
     const promoteIdx = args.indexOf('--promote');
     if (rollbackIdx >= 0 && args[rollbackIdx + 1]) {
-        return runEvolveRollback(args[rollbackIdx + 1]);
+        runEvolveRollback(args[rollbackIdx + 1]);
+        return;
     }
     if (promoteIdx >= 0 && args[promoteIdx + 1]) {
-        return runEvolvePromote(args[promoteIdx + 1]);
+        runEvolvePromote(args[promoteIdx + 1]);
+        return;
     }
     // Default: generate + optionally save weakness report, print proposer
     // brief so the user can hand it to the ch-solution-evolver agent.

package/dist/engine/lifecycle/bypass-detector.d.ts

@@ -4,12 +4,17 @@
  * Rule.policy 자연어에서 "피해야 할 패턴" 을 추출하고, Write/Edit/Bash 도구
  * 출력에서 해당 패턴을 찾아 BypassEntry 후보로 반환한다.
  *
- * Heuristic:
+ * Heuristic priority (most explicit first):
+ *   0) Parenthesized examples (e.g., "(rm -rf, DROP, force-push)") → tokens inside
  *   1) "use X not Y" / "use X instead of Y" / "X over Y" → bypass = Y
  *   2) "avoid X" / "don't use X" / "never use X" / "do not use X" → bypass = X
  *   3) Korean: "X 말라" / "X 금지" / "X 하지 않" → bypass = X
  *   4) 그 외: 빈 배열 (탐지 불가).
  *
+ * Stop list filter: generic Korean verbs (실행/사용/선언/...) extracted by Korean
+ * heuristic are removed — they cause massive FP (RC5/E9: matched the word "실행"
+ * everywhere instead of "rm -rf"). 64 false-positive bypasses observed before fix.
+ *
  * 반환된 패턴은 escape 된 정규식 문자열 — caller 가 `new RegExp(p)` 로 사용.
  */
 import type { Rule } from '../../store/types.js';

package/dist/engine/lifecycle/bypass-detector.js

@@ -4,12 +4,17 @@
  * Rule.policy 자연어에서 "피해야 할 패턴" 을 추출하고, Write/Edit/Bash 도구
  * 출력에서 해당 패턴을 찾아 BypassEntry 후보로 반환한다.
  *
- * Heuristic:
+ * Heuristic priority (most explicit first):
+ *   0) Parenthesized examples (e.g., "(rm -rf, DROP, force-push)") → tokens inside
  *   1) "use X not Y" / "use X instead of Y" / "X over Y" → bypass = Y
  *   2) "avoid X" / "don't use X" / "never use X" / "do not use X" → bypass = X
  *   3) Korean: "X 말라" / "X 금지" / "X 하지 않" → bypass = X
  *   4) 그 외: 빈 배열 (탐지 불가).
  *
+ * Stop list filter: generic Korean verbs (실행/사용/선언/...) extracted by Korean
+ * heuristic are removed — they cause massive FP (RC5/E9: matched the word "실행"
+ * everywhere instead of "rm -rf"). 64 false-positive bypasses observed before fix.
+ *
  * 반환된 패턴은 escape 된 정규식 문자열 — caller 가 `new RegExp(p)` 로 사용.
  */
 function escapeRegex(s) {
@@ -29,9 +34,50 @@ function trimPunct(s) {
     out = out.replace(/^[,;:!?"'`(]+|[.,;:!?"'`)]+$/g, '');
     return out;
 }
+/**
+ * Generic Korean verbs/words that produce massive false positives if used as
+ * bypass patterns (RC5/E9 fix). Extending requires retro evidence.
+ */
+const KO_GENERIC_STOP_WORDS = new Set([
+    '실행', '사용', '선언', '수행', '처리', '작성', '호출', '적용',
+    '실행하지', '사용하지', '선언하지', '수행하지', '처리하지',
+    // English fallthroughs (already low value as bypass signals)
+    'use', 'do', 'execute',
+]);
+/** Korean markers that signal the parenthesized content is NOT an example list. */
+const KO_NON_EXAMPLE_MARKERS = ['제외', '한정', '예외', '단서', 'except'];
+/** Extract concrete tokens inside parenthesized example list. */
+function extractParenthesizedExamples(p) {
+    const out = [];
+    // Match (...) groups; multiple groups in policy are uncommon but supported
+    const re = /\(([^)]+)\)/g;
+    let m;
+    while ((m = re.exec(p))) {
+        const inside = m[1];
+        // Skip if it looks like a path (contains "/" before any obvious separator commitment)
+        if (/[a-zA-Z]+\/[a-zA-Z]/.test(inside))
+            continue;
+        // Skip if it's an exclusion / scope-restriction note (Korean markers)
+        if (KO_NON_EXAMPLE_MARKERS.some((mk) => inside.includes(mk)))
+            continue;
+        // Skip if any single segment is suspiciously long (full sentence rather than token)
+        const segs = inside.split(/[,]|\s+(?:or|와|및)\s+/i).map((s) => s.trim());
+        if (segs.some((s) => s.length > 30))
+            continue;
+        const tokens = segs
+            .map((t) => trimPunct(t))
+            .filter((t) => t.length >= 2 && !KO_GENERIC_STOP_WORDS.has(t));
+        out.push(...tokens);
+    }
+    return out;
+}
 export function extractBypassPatterns(rule) {
     const patterns = [];
     const p = rule.policy;
+    // 0) Parenthesized examples (highest priority — explicit signal)
+    for (const ex of extractParenthesizedExamples(p)) {
+        patterns.push(escapeRegex(ex));
+    }
     // use X not Y / use X instead of Y / use X over Y
     // X, Y may contain dots (e.g., ".then()", "vi.mock"). Strip trailing punctuation.
     const useNot = p.match(/\b(?:use|prefer|choose)\s+(\S+?)\s+(?:not|instead\s+of|over|rather\s+than)\s+(\S+)/i);
@@ -43,10 +89,16 @@ export function extractBypassPatterns(rule) {
         patterns.push(escapeRegex(trimPunct(avoid[1])));
     // Korean: "X 말라" / "X 금지" / "X 하지 마"
     const ko = p.match(/(\S+)\s*(?:말라|금지|하지\s*마|쓰지\s*마)/);
-    if (ko)
-        patterns.push(escapeRegex(trimPunct(ko[1])));
-    // Dedupe + filter trivial
-    return [...new Set(patterns)].filter((pat) => pat.length >= 2);
+    if (ko) {
+        const candidate = trimPunct(ko[1]);
+        if (!KO_GENERIC_STOP_WORDS.has(candidate)) {
+            patterns.push(escapeRegex(candidate));
+        }
+    }
+    // Dedupe + filter trivial + filter stop-words (defense in depth)
+    return [...new Set(patterns)]
+        .filter((pat) => pat.length >= 2)
+        .filter((pat) => !KO_GENERIC_STOP_WORDS.has(pat.replace(/\\/g, '')));
 }
 /**
  * Pure — rules + tool output 으로 bypass candidates 추출.

package/dist/engine/lifecycle/lifecycle-cli.js

@@ -5,8 +5,8 @@
  * default dry-run, --apply 시 rule 파일에 상태 전이 반영.
  */
 import * as path from 'node:path';
-import * as os from 'node:os';
 import { loadAllRules, saveRule } from '../../store/rule-store.js';
+import { STATE_DIR } from '../../core/paths.js';
 import { collectSignals, readJsonlSafe } from './signals.js';
 import { detect as detectT2 } from './trigger-t2-violation.js';
 import { detect as detectT3 } from './trigger-t3-bypass.js';
@@ -14,7 +14,7 @@ import { detect as detectT4 } from './trigger-t4-decay.js';
 import { detect as detectT5 } from './trigger-t5-conflict.js';
 import { scanDriftForDemotion, applyDemotion, scanSignalsForPromotion, applyPromotion, readDriftEntries, appendLifecycleEvents, } from './meta-reclassifier.js';
 import { foldEvents } from './orchestrator.js';
-const LIFECYCLE_DIR = path.join(os.homedir(), '.forgen', 'state', 'lifecycle');
+const LIFECYCLE_DIR = path.join(STATE_DIR, 'lifecycle');
 export async function handleLifecycleScan(args) {
     const apply = args.includes('--apply');
     const now = Date.now();
@@ -23,8 +23,8 @@ export async function handleLifecycleScan(args) {
         console.log('\n  No rules in ~/.forgen/me/rules. Nothing to scan.\n');
         return;
     }
-    const violations = readJsonlSafe(path.join(os.homedir(), '.forgen', 'state', 'enforcement', 'violations.jsonl'));
-    const bypass = readJsonlSafe(path.join(os.homedir(), '.forgen', 'state', 'enforcement', 'bypass.jsonl'));
+    const violations = readJsonlSafe(path.join(STATE_DIR, 'enforcement', 'violations.jsonl'));
+    const bypass = readJsonlSafe(path.join(STATE_DIR, 'enforcement', 'bypass.jsonl'));
     const drift = readDriftEntries();
     const signals = new Map();
     for (const r of rules)

package/dist/engine/lifecycle/meta-reclassifier.js

@@ -16,12 +16,12 @@
  *   - 30 일 쿨다운.
  */
 import * as fs from 'node:fs';
-import * as os from 'node:os';
 import * as path from 'node:path';
 import { initLifecycle } from '../../store/rule-lifecycle.js';
 import { loadAllRules, saveRule } from '../../store/rule-store.js';
-const DRIFT_LOG_PATH = path.join(os.homedir(), '.forgen', 'state', 'enforcement', 'drift.jsonl');
-const LIFECYCLE_DIR = path.join(os.homedir(), '.forgen', 'state', 'lifecycle');
+import { STATE_DIR } from '../../core/paths.js';
+const DRIFT_LOG_PATH = path.join(STATE_DIR, 'enforcement', 'drift.jsonl');
+const LIFECYCLE_DIR = path.join(STATE_DIR, 'lifecycle');
 const DEFAULT_WINDOW_DAYS = 7;
 const DEFAULT_THRESHOLD = 3;
 /** R8-A1: Meta 재분류 쿨다운 (일). 최근 이 기간 내 변경된 rule 은 다시 재분류 금지. */

package/dist/engine/lifecycle/orchestrator.js

@@ -21,15 +21,15 @@
  *   promote/demote_mech → phase 유지, meta_promotions 는 meta-reclassifier 가 직접 기록
  */
 import * as fs from 'node:fs';
-import * as os from 'node:os';
 import * as path from 'node:path';
+import { STATE_DIR } from '../../core/paths.js';
 /**
  * R5-B1: rule 이 inactive 상태로 전이될 때 block-count 디렉터리의 잔여 파일 정리.
  * phantom stuck-loop (retired 된 rule 이 다시 GC 전까지 counter 에 반영되는 문제) 차단.
  */
 function sweepBlockCountsForRule(ruleId) {
     try {
-        const dir = path.join(os.homedir(), '.forgen', 'state', 'enforcement', 'block-count');
+        const dir = path.join(STATE_DIR, 'enforcement', 'block-count');
         if (!fs.existsSync(dir))
             return;
         const safeRuleId = String(ruleId).replace(/[^a-zA-Z0-9_.-]/g, '_');

package/dist/engine/lifecycle/signals.js

@@ -9,11 +9,11 @@
  * 모든 IO 는 이 파일에 한정. 트리거들은 pure — collectSignals() 결과를 받아 detect().
  */
 import * as fs from 'node:fs';
-import * as os from 'node:os';
 import * as path from 'node:path';
-const STATE_DIR = path.join(os.homedir(), '.forgen', 'state', 'enforcement');
-const VIOLATIONS_PATH = path.join(STATE_DIR, 'violations.jsonl');
-const BYPASS_PATH = path.join(STATE_DIR, 'bypass.jsonl');
+import { STATE_DIR as FORGEN_STATE_DIR } from '../../core/paths.js';
+const ENFORCEMENT_DIR = path.join(FORGEN_STATE_DIR, 'enforcement');
+const VIOLATIONS_PATH = path.join(ENFORCEMENT_DIR, 'violations.jsonl');
+const BYPASS_PATH = path.join(ENFORCEMENT_DIR, 'bypass.jsonl');
 const ROLLING_N = 20;
 const VIOLATION_WINDOW_DAYS = 30;
 const BYPASS_WINDOW_DAYS = 7;
@@ -59,7 +59,7 @@ export function readJsonlSafe(p) {
 }
 export function recordViolation(entry) {
     try {
-        fs.mkdirSync(STATE_DIR, { recursive: true });
+        fs.mkdirSync(ENFORCEMENT_DIR, { recursive: true });
         rotateIfBig(VIOLATIONS_PATH);
         const full = { at: new Date().toISOString(), ...entry };
         fs.appendFileSync(VIOLATIONS_PATH, JSON.stringify(full) + '\n');
@@ -73,7 +73,7 @@ export function recordViolation(entry) {
 }
 export function recordBypass(entry) {
     try {
-        fs.mkdirSync(STATE_DIR, { recursive: true });
+        fs.mkdirSync(ENFORCEMENT_DIR, { recursive: true });
         rotateIfBig(BYPASS_PATH);
         const full = { at: new Date().toISOString(), ...entry };
         fs.appendFileSync(BYPASS_PATH, JSON.stringify(full) + '\n');