@wooojin/forgen 0.4.1 → 0.4.4

package/dist/core/host-detect.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Host detection — feat/codex-support Phase 1
+ *
+ * `forgen install` interactive 의 prerequisite — 사용자 환경에 어떤 host (Claude/Codex)
+ * 가 가용한지 탐지. spec §10 Phase 1 + interview R3.
+ *
+ * 탐지 신호 (각 host 별):
+ *   - binary 가 PATH 에 있음 (`which claude` / `which codex`)
+ *   - host 디렉토리 존재 (~/.claude/ / ~/.codex/)
+ *   - (Codex 만) `~/.codex/auth.json` 존재 (로그인 흔적)
+ *
+ * detect 결과는 *추론* 만. install 강제 안 함.
+ */
+import type { HostId } from './trust-layer-intent.js';
+export interface HostAvailability {
+    readonly host: HostId;
+    /** binary 가 PATH 에 있음. */
+    readonly binaryFound: boolean;
+    /** binary 절대경로 (없으면 null). */
+    readonly binaryPath: string | null;
+    /** host home 디렉토리 존재 (~/.claude/ 또는 ~/.codex/). */
+    readonly homeExists: boolean;
+    /** host home 절대경로. */
+    readonly homePath: string;
+    /** Codex 의 경우 auth.json 존재 (로그인 흔적). Claude 는 항상 null. */
+    readonly authPresent: boolean | null;
+    /**
+     * 종합 판단 — *install 후보로 적합한가*.
+     * - binaryFound 또는 homeExists 중 하나 이상이면 true.
+     * - 둘 다 없으면 false (사용자가 host 를 안 쓸 가능성 높음).
+     */
+    readonly available: boolean;
+}
+export interface HostDetectionResult {
+    readonly claude: HostAvailability;
+    readonly codex: HostAvailability;
+    /** 둘 다 사용 가능. */
+    readonly bothAvailable: boolean;
+    /** 하나도 사용 가능하지 않음 (warn). */
+    readonly noneAvailable: boolean;
+}
+export declare function detectAvailableHosts(): HostDetectionResult;

package/dist/core/host-detect.js

@@ -0,0 +1,68 @@
+/**
+ * Host detection — feat/codex-support Phase 1
+ *
+ * `forgen install` interactive 의 prerequisite — 사용자 환경에 어떤 host (Claude/Codex)
+ * 가 가용한지 탐지. spec §10 Phase 1 + interview R3.
+ *
+ * 탐지 신호 (각 host 별):
+ *   - binary 가 PATH 에 있음 (`which claude` / `which codex`)
+ *   - host 디렉토리 존재 (~/.claude/ / ~/.codex/)
+ *   - (Codex 만) `~/.codex/auth.json` 존재 (로그인 흔적)
+ *
+ * detect 결과는 *추론* 만. install 강제 안 함.
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { execFileSync } from 'node:child_process';
+function which(binary) {
+    try {
+        const out = execFileSync('which', [binary], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+        const trimmed = out.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function detectClaude() {
+    const binaryPath = which('claude');
+    const homePath = path.join(os.homedir(), '.claude');
+    const homeExists = fs.existsSync(homePath);
+    const binaryFound = binaryPath !== null;
+    return {
+        host: 'claude',
+        binaryFound,
+        binaryPath,
+        homeExists,
+        homePath,
+        authPresent: null, // Claude 는 별도 auth.json 패턴이 없음 (subscription 통합)
+        available: binaryFound || homeExists,
+    };
+}
+function detectCodex() {
+    const binaryPath = which('codex');
+    const codexHome = process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex');
+    const homeExists = fs.existsSync(codexHome);
+    const binaryFound = binaryPath !== null;
+    const authPresent = fs.existsSync(path.join(codexHome, 'auth.json'));
+    return {
+        host: 'codex',
+        binaryFound,
+        binaryPath,
+        homeExists,
+        homePath: codexHome,
+        authPresent,
+        available: binaryFound || homeExists,
+    };
+}
+export function detectAvailableHosts() {
+    const claude = detectClaude();
+    const codex = detectCodex();
+    return {
+        claude,
+        codex,
+        bothAvailable: claude.available && codex.available,
+        noneAvailable: !claude.available && !codex.available,
+    };
+}

package/dist/core/installer.js

@@ -111,7 +111,7 @@ export function installAgents(cwd, pkgRoot) {
     const targetDir = path.join(cwd, '.claude', 'agents');
     fs.mkdirSync(targetDir, { recursive: true });
     const hashes = loadAgentHashes();
-    const sourceDir = path.join(pkgRoot, 'agents');
+    const sourceDir = path.join(pkgRoot, 'assets', 'claude', 'agents');
     try {
         installAgentsFromDir(sourceDir, targetDir, 'ch-', hashes);
         cleanupStaleAgents(sourceDir, targetDir, 'ch-', hashes);
@@ -159,7 +159,7 @@ function cleanupStaleCommands(commandsDir, validFiles) {
 }
 /** 스킬을 Claude Code 슬래시 명령으로 설치 (패키지 내장만) */
 export function installSlashCommands(_cwd, pkgRoot) {
-    let skillsDir = path.join(pkgRoot, 'commands');
+    let skillsDir = path.join(pkgRoot, 'assets', 'claude', 'commands');
     if (!fs.existsSync(skillsDir)) {
         skillsDir = path.join(pkgRoot, 'skills');
     }

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

@@ -6,5 +6,6 @@
  *   - implicit-feedback: TEST-5 category 필드 백필 (type → category inference).
  *     기본은 lazy (read 시점 백필) 이지만 집계/외부 도구가 raw jsonl 을 읽는
  *     경우 영구 재기록이 필요.
+ *   - evidence-host: ~/.forgen/me/behavior/*.json 에 host 필드가 없는 파일 백필.
  */
 export declare function handleMigrate(args: string[]): Promise<void>;

package/dist/core/migrate-cli.js

@@ -6,14 +6,19 @@
  *   - implicit-feedback: TEST-5 category 필드 백필 (type → category inference).
  *     기본은 lazy (read 시점 백필) 이지만 집계/외부 도구가 raw jsonl 을 읽는
  *     경우 영구 재기록이 필요.
+ *   - evidence-host: ~/.forgen/me/behavior/*.json 에 host 필드가 없는 파일 백필.
  */
 import { migrateImplicitFeedbackLog } from '../store/implicit-feedback-store.js';
+import { migrateEvidenceHost } from './migrate-evidence-host.js';
 const HELP = `
   forgen migrate — one-shot schema migrations
 
   Usage:
     forgen migrate implicit-feedback   category 필드가 없는 레거시 엔트리 백필 + 재기록
     forgen migrate all                 (현재는 implicit-feedback 과 동일)
+    forgen migrate evidence-host       behavior/*.json 에 host 필드 백필
+      --dry-run                          디스크 미수정, 카운트만 출력
+      --default-host <claude|codex>      host 기본값 (default: claude)
     forgen migrate --help              이 도움말
 `;
 export async function handleMigrate(args) {
@@ -28,6 +33,20 @@ export async function handleMigrate(args) {
         console.log(`[forgen migrate] 백필 ${migrated}건, 드롭 ${dropped}건 — 재기록 완료.`);
         return;
     }
+    if (sub === 'evidence-host') {
+        const dryRun = args.includes('--dry-run');
+        const hostFlagIdx = args.indexOf('--default-host');
+        const rawHost = hostFlagIdx !== -1 ? args[hostFlagIdx + 1] : 'claude';
+        if (rawHost !== 'claude' && rawHost !== 'codex') {
+            console.error(`[forgen migrate] --default-host 는 'claude' 또는 'codex' 여야 합니다. 받은 값: ${rawHost}`);
+            process.exit(1);
+        }
+        const defaultHost = rawHost;
+        const result = migrateEvidenceHost({ defaultHost, dryRun });
+        const label = dryRun ? ' (dry-run)' : '';
+        console.log(`[forgen] migrated: ${result.migrated} (skipped: ${result.skipped}, total: ${result.total})${label}`);
+        return;
+    }
     console.error(`[forgen migrate] unknown target: ${sub}`);
     console.error(HELP);
     process.exit(1);

package/dist/core/migrate-evidence-host.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Forgen — Evidence Host Backfill Migration
+ *
+ * spec §10 우선순위 5 + §4.2:
+ * 사용자가 명시적으로 디스크의 evidence 파일에 host 필드를 박제하고 싶을 때 사용.
+ * (마이그레이션 박제, audit 목적)
+ *
+ * loadEvidence 의 자동 backfill (evidence-store.ts::backfillHost) 과는 독립.
+ * 이 모듈은 디스크 파일을 직접 수정하는 명시적 경로.
+ */
+export interface MigrateEvidenceHostOptions {
+    /** backfill 할 host 값 (host 필드 없는 파일에만 적용) */
+    defaultHost: 'claude' | 'codex';
+    /**
+     * true 이면 디스크를 수정하지 않고 카운트만 반환.
+     * @default false
+     */
+    dryRun?: boolean;
+}
+export interface MigrateEvidenceHostResult {
+    /** host 필드를 새로 추가한 파일 수 */
+    migrated: number;
+    /** 처리 대상 전체 .json 파일 수 */
+    total: number;
+    /** 이미 host 필드가 있어 건너뛴 파일 수 */
+    skipped: number;
+}
+/**
+ * `~/.forgen/me/behavior/*.json` 을 순회하여 host 필드가 없는 파일에
+ * `defaultHost` 를 추가한다.
+ *
+ * - dryRun=true 이면 디스크 미수정, 카운트만 반환.
+ * - 이미 host 필드가 있는 파일은 건너뜀 (idempotent).
+ * - 파싱 실패 / host 필드가 아닌 값인 파일도 건너뜀 (안전).
+ */
+export declare function migrateEvidenceHost(options: MigrateEvidenceHostOptions): MigrateEvidenceHostResult;

package/dist/core/migrate-evidence-host.js

@@ -0,0 +1,49 @@
+/**
+ * Forgen — Evidence Host Backfill Migration
+ *
+ * spec §10 우선순위 5 + §4.2:
+ * 사용자가 명시적으로 디스크의 evidence 파일에 host 필드를 박제하고 싶을 때 사용.
+ * (마이그레이션 박제, audit 목적)
+ *
+ * loadEvidence 의 자동 backfill (evidence-store.ts::backfillHost) 과는 독립.
+ * 이 모듈은 디스크 파일을 직접 수정하는 명시적 경로.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ME_BEHAVIOR } from './paths.js';
+import { atomicWriteJSON, safeReadJSON } from '../hooks/shared/atomic-write.js';
+/**
+ * `~/.forgen/me/behavior/*.json` 을 순회하여 host 필드가 없는 파일에
+ * `defaultHost` 를 추가한다.
+ *
+ * - dryRun=true 이면 디스크 미수정, 카운트만 반환.
+ * - 이미 host 필드가 있는 파일은 건너뜀 (idempotent).
+ * - 파싱 실패 / host 필드가 아닌 값인 파일도 건너뜀 (안전).
+ */
+export function migrateEvidenceHost(options) {
+    const { defaultHost, dryRun = false } = options;
+    if (!fs.existsSync(ME_BEHAVIOR)) {
+        return { migrated: 0, total: 0, skipped: 0 };
+    }
+    const files = fs.readdirSync(ME_BEHAVIOR).filter((f) => f.endsWith('.json'));
+    let migrated = 0;
+    let skipped = 0;
+    for (const file of files) {
+        const filePath = path.join(ME_BEHAVIOR, file);
+        const data = safeReadJSON(filePath, null);
+        if (data === null || typeof data !== 'object') {
+            skipped++;
+            continue;
+        }
+        const host = data['host'];
+        if (host === 'claude' || host === 'codex') {
+            skipped++;
+            continue;
+        }
+        if (!dryRun) {
+            atomicWriteJSON(filePath, { ...data, host: defaultHost }, { pretty: true });
+        }
+        migrated++;
+    }
+    return { migrated, total: files.length, skipped };
+}

package/dist/core/settings-injector.js

@@ -7,6 +7,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { generateHooksJson } from '../hooks/hooks-generator.js';
+import { getHostRuntime } from '../host/host-runtime.js';
 import { ConfigError } from './errors.js';
 import { createLogger } from './logger.js';
 import { acquireLock, atomicWriteFileSync, CLAUDE_DIR, readSettingsSafely, releaseLock, rollbackSettings, SETTINGS_BACKUP_PATH, SETTINGS_PATH, } from './settings-lock.js';
@@ -74,7 +75,8 @@ function mergeHooksIntoSettings(settings, runtime, cwd, pkgRoot) {
             hooksConfig[event] = filtered;
     }
     try {
-        if (runtime === 'codex') {
+        const host = getHostRuntime(runtime);
+        if (host.hookInjectionStrategy === 'generate') {
             const generated = generateHooksJson({ cwd, runtime, pluginRoot: path.join(pkgRoot, 'dist') });
             for (const [event, handlers] of Object.entries(generated.hooks)) {
                 if (!hooksConfig[event])
@@ -83,7 +85,7 @@ function mergeHooksIntoSettings(settings, runtime, cwd, pkgRoot) {
             }
         }
         else {
-            // Read hooks.json and inject, replacing ${CLAUDE_PLUGIN_ROOT}
+            // 'pre-baked-file': pkgRoot/hooks/hooks.json 읽고 ${CLAUDE_PLUGIN_ROOT} 치환
             const hooksJsonPath = path.join(pkgRoot, 'hooks', 'hooks.json');
             if (fs.existsSync(hooksJsonPath)) {
                 const hooksJson = JSON.parse(fs.readFileSync(hooksJsonPath, 'utf-8'));

package/dist/core/spawn.d.ts

@@ -1,5 +1,5 @@
 import type { V1HarnessContext } from './harness.js';
-import { type RuntimeHost } from './types.js';
+import type { RuntimeHost } from './types.js';
 /** Claude Code를 하네스 환경으로 실행. exit code를 반환. */
 export declare function spawnClaude(args: string[], context: V1HarnessContext, runtime?: RuntimeHost): Promise<number>;
 /**

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

@@ -10,6 +10,7 @@ import * as path from 'node:path';
 import { loadAllRules } from '../store/rule-store.js';
 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');
@@ -244,6 +245,17 @@ export function renderStats(s) {
         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/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

@@ -147,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/fgx.js

@@ -6,6 +6,7 @@
 import { resolveLaunchContext } from './services/session.js';
 import { prepareHarness, isFirstRun } from './core/harness.js';
 import { spawnClaude } from './core/spawn.js';
+import { getHostRuntime } from './host/host-runtime.js';
 const args = process.argv.slice(2);
 // 이미 포함되어 있으면 중복 추가하지 않음
 const launchContext = resolveLaunchContext(args);
@@ -43,7 +44,7 @@ async function main() {
         console.log(`[forgen] Trust: ${v1.session.effective_trust_policy}`);
     }
     console.log('[forgen] Mode: dangerously-skip-permissions');
-    const runtimeLabel = runtime === 'codex' ? 'Codex' : 'Claude';
+    const runtimeLabel = getHostRuntime(runtime).displayName;
     console.log(`[forgen] Starting ${runtimeLabel}...\n`);
     await spawnClaude(launchArgs, context, runtime);
 }

package/dist/forge/evidence-processor.js

@@ -8,6 +8,7 @@
 import { createEvidence, appendEvidence } from '../store/evidence-store.js';
 import { createRule, saveRule } from '../store/rule-store.js';
 import { classify, applyProposal } from '../engine/enforce-classifier.js';
+import { bumpAxisConfidence } from '../store/profile-store.js';
 // ── Correction → Evidence + Temporary Rule ──
 /**
  * 사용자 교정을 Evidence로 기록하고, 필요 시 temporary rule 생성.
@@ -31,6 +32,17 @@ export function processCorrection(req) {
         },
     });
     appendEvidence(evidence); // T1 lifecycle trigger fires here for explicit_correction
+    // D2 fix (2026-04-27): explicit_correction 의 axis_hint 가 axes confidence 에
+    // 직접 반영되도록 bump. autonomy 6건이 score 못 움직였던 결함 해결.
+    // 회귀 안전: facet 값은 안 건드리고 confidence 만 +0.02 (avoid-this 는 +0.04
+    // 로 더 강한 신호). docs/issues/D2-autonomy-facet-stuck.md 참조.
+    if (req.axis_hint) {
+        const bump = req.kind === 'avoid-this' ? 0.04 : 0.02;
+        try {
+            bumpAxisConfidence(req.axis_hint, bump);
+        }
+        catch { /* fail-open */ }
+    }
     // fix-now, avoid-this → temporary session rule
     let temporaryRule = null;
     if (req.kind === 'fix-now' || req.kind === 'avoid-this') {

package/dist/forge/onboarding.d.ts

@@ -1,8 +1,9 @@
 /**
  * Forgen v1 — Onboarding
  *
- * 2문항 온보딩, 점수 계산, pack 추천.
- * Authoritative spec: docs/plans/2026-04-03-forgen-onboarding-adaptation-spec.md §3-4
+ * 4문항 온보딩 (quality / autonomy / judgment / communication 4축), 점수 계산, pack 추천.
+ * Authoritative spec: docs/history/2026-04-03-tenetx-onboarding-adaptation-spec.md
+ *   (spec §3 은 v0.1 시점 2문항 기준 — v0.4 부터 4문항으로 확장됨, src/forge/onboarding-cli.ts:69-75 참조)
  */
 import type { QualityPack, AutonomyPack, JudgmentPack, CommunicationPack, TrustPolicy, PackRecommendation } from '../store/types.js';
 export type ChoiceId = 'A' | 'B' | 'C';