@wooojin/forgen 0.4.3 → 0.4.5

package/dist/checks/fact-vs-agreement.js

@@ -47,6 +47,26 @@ const AGREEMENT_SOFTENERS = [
     /(생각합니다|생각함|생각해|봅니다|예상(합니다|돼))/,
     /(그럴\s*것\s*같|맞을\s*것\s*같)/,
 ];
+/**
+ * 측정-증거 지표 — 실제 실행/측정 결과가 응답에 *paste 되어 있다*는 신호.
+ *
+ * v0.4.4 (2026-05-06): FP 감소. "Docker e2e 77/77 PASS" 같은 *정량 사실 보고*
+ * 가 recentTools 윈도우 밖 측정 (예: 이전 turn Bash 결과, 사용자 paste, CI 로그
+ * 인용)이라 Bash 카운트가 0이지만 본질적으로 measurement-backed 응답.
+ *
+ * 임계: 본 패턴이 2+ 매칭되면 alert 억제 (응답이 측정 증거를 *제시*하고 있다고 본다).
+ */
+const EVIDENCE_INDICATORS = [
+    /\b\d+\/\d+\b/, // test counts: "77/77", "22/22"
+    /\bexit\s*code\s*[:=]?\s*\d+/i, // exit code
+    /\b\d+(\.\d+)?\s*(ms|s|sec|seconds)\b/i, // timings: "232s", "1.5ms"
+    /\b(?:Test|Spec)s?\s*Files?\s+\d+/i, // vitest "Test Files 218"
+    /\b(?:Tests?:?\s+)?\d+\s+passed?\b/i, // "2382 passed"
+    /\b(?:CI|HEAD|sha|commit)\s*[:=]?\s*[a-f0-9]{7,}/i, // commit ref
+    /^[+-]{3}\s/m, // diff hunks
+    /\bcoverage\s*[:=]?\s*\d+(\.\d+)?%/i, // coverage %
+    /^\s*✓\s|^\s*✗\s|^\s*PASS\b|^\s*FAIL\b/m, // test runner output markers
+];
 function findMatches(text, patterns, max = 3) {
     const out = [];
     for (const p of patterns) {
@@ -69,8 +89,12 @@ export function checkFactVsAgreement(input) {
     const factAssertions = findMatches(text, FACT_ASSERTION_PATTERNS);
     const agreementSofteners = findMatches(text, AGREEMENT_SOFTENERS);
     const measurementCount = recentTools.filter((t) => MEASUREMENT_TOOL_CATEGORIES.has(t)).length;
+    // Evidence indicator suppression — 응답에 측정 결과가 *paste* 되어 있으면
+    // recentTools 윈도우 밖 측정으로 보고 alert 억제 (FP 감소).
+    const evidenceIndicators = findMatches(text, EVIDENCE_INDICATORS, 99);
+    const hasMeasurementEvidence = evidenceIndicators.length >= 2;
     const hasFactAssertion = factAssertions.length > 0;
-    const measurementMissing = measurementCount < minMeasurements;
+    const measurementMissing = measurementCount < minMeasurements && !hasMeasurementEvidence;
     const alert = hasFactAssertion && measurementMissing;
     let reason = '';
     if (alert) {

package/dist/cli.js

@@ -95,6 +95,14 @@ const commands = [
             await handleInspect(['profile']);
         },
     },
+    {
+        name: 'statusline',
+        description: 'Compact HUD for Claude Code statusLine (reads stdin JSON)',
+        handler: async (_args) => {
+            const { handleStatusline } = await import('./core/statusline-cli.js');
+            await handleStatusline();
+        },
+    },
     {
         name: 'config',
         description: 'Configuration (hooks [--regenerate])',

package/dist/core/auto-compound-runner.js

@@ -40,17 +40,22 @@ function execClaudeRetry(args, opts) {
     if (host === 'claude') {
         // Claude 측은 기존 보안 hardening 보존: --allowedTools 등 args 그대로 전달.
         const TRANSIENT = /ETIMEDOUT|ECONNRESET|ECONNREFUSED|EPIPE/;
-        for (let attempt = 0; attempt < 2; attempt++) {
+        const MAX_ATTEMPTS = 2;
+        for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
             try {
                 return execFileSync('claude', args, opts);
             }
             catch (e) {
                 const msg = e instanceof Error ? e.message : String(e);
-                if (attempt === 0 && TRANSIENT.test(msg)) {
-                    process.stderr.write(`[forgen-auto-compound] transient error, retrying in 3s...\n`);
+                const match = msg.match(TRANSIENT);
+                if (attempt < MAX_ATTEMPTS && match) {
+                    process.stderr.write(`[forgen-auto-compound] ${match[0]} on attempt ${attempt}/${MAX_ATTEMPTS}, retrying in 3s (auto-recovery)...\n`);
                     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 3000);
                     continue;
                 }
+                if (match) {
+                    process.stderr.write(`[forgen-auto-compound] ${match[0]} after ${attempt}/${MAX_ATTEMPTS} attempts — giving up (fail-open)\n`);
+                }
                 throw e;
             }
         }
@@ -425,7 +430,9 @@ ${profileContext}
   "pack_direction": null 또는 "opposite_quality" 또는 "opposite_autonomy",
   "profile_delta": {
     "quality_safety": { "verification_depth": 0.0, "stop_threshold": 0.0, "change_conservatism": 0.0 },
-    "autonomy": { "confirmation_independence": 0.0, "assumption_tolerance": 0.0, "scope_expansion_tolerance": 0.0, "approval_threshold": 0.0 }
+    "autonomy": { "confirmation_independence": 0.0, "assumption_tolerance": 0.0, "scope_expansion_tolerance": 0.0, "approval_threshold": 0.0 },
+    "judgment_philosophy": { "minimal_change_bias": 0.0, "abstraction_bias": 0.0, "evidence_first_bias": 0.0 },
+    "communication_style": { "verbosity": 0.0, "structure": 0.0, "teaching_bias": 0.0 }
   }
 }
 
@@ -493,6 +500,26 @@ ${sanitizedSummary.slice(0, 4000)}
                             }
                         }
                     }
+                    if (parsed.profile_delta.judgment_philosophy) {
+                        const d = parsed.profile_delta.judgment_philosophy;
+                        const f = profile.axes.judgment_philosophy.facets;
+                        for (const [k, v] of Object.entries(d)) {
+                            if (typeof v === 'number' && Math.abs(v) > 0.001 && k in f) {
+                                f[k] = clamp(f[k] + v);
+                                changed = true;
+                            }
+                        }
+                    }
+                    if (parsed.profile_delta.communication_style) {
+                        const d = parsed.profile_delta.communication_style;
+                        const f = profile.axes.communication_style.facets;
+                        for (const [k, v] of Object.entries(d)) {
+                            if (typeof v === 'number' && Math.abs(v) > 0.001 && k in f) {
+                                f[k] = clamp(f[k] + v);
+                                changed = true;
+                            }
+                        }
+                    }
                     if (changed) {
                         profile.metadata.updated_at = new Date().toISOString();
                         fs.writeFileSync(V1_PROFILE, JSON.stringify(profile, null, 2));

package/dist/core/settings-injector.js

@@ -43,12 +43,18 @@ function readSettingsWithBackup() {
     }
     return settings;
 }
-/** Apply forgen statusLine only if user hasn't set a custom one. */
+/** Apply forgen statusLine only if user hasn't set a custom one.
+ *  Migration: 'forgen me' → 'forgen statusline' (multi-line dump → compact HUD). */
 function applyStatusLine(settings) {
     const existing = settings.statusLine;
+    // 기존에 'forgen me'로 주입된 경우 → 'forgen statusline'으로 자동 마이그레이션
+    if (existing?.command === 'forgen me') {
+        settings.statusLine = { type: 'command', command: 'forgen statusline' };
+        return;
+    }
     const isForgenOwned = !existing || !existing.command || existing.command.startsWith('forgen');
     if (isForgenOwned) {
-        settings.statusLine = { type: 'command', command: 'forgen me' };
+        settings.statusLine = { type: 'command', command: 'forgen statusline' };
     }
 }
 /** Check if a settings.json hook entry was installed by forgen. */

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

@@ -0,0 +1,13 @@
+/**
+ * forgen statusline — Claude Code statusLine 명령
+ *
+ * Claude Code는 statusLine.command를 주기적으로 호출하고 stdin에 JSON을 전달함.
+ * 이 명령은 compact multi-line 형식으로 HUD 정보를 출력함.
+ *
+ * Line 1: 모델 | cwd | git branch
+ * Line 2: (TODO: context/usage — stdin spec 미확인으로 생략)
+ * Line 3: CLAUDE.md count | rules count | MCPs count | hooks count
+ * Line 4: (TODO: tool counts — 추적 인프라 없음)
+ * Line 5: (TODO: active task — 추적 인프라 없음)
+ */
+export declare function handleStatusline(): Promise<void>;

package/dist/core/statusline-cli.js

@@ -0,0 +1,150 @@
+/**
+ * forgen statusline — Claude Code statusLine 명령
+ *
+ * Claude Code는 statusLine.command를 주기적으로 호출하고 stdin에 JSON을 전달함.
+ * 이 명령은 compact multi-line 형식으로 HUD 정보를 출력함.
+ *
+ * Line 1: 모델 | cwd | git branch
+ * Line 2: (TODO: context/usage — stdin spec 미확인으로 생략)
+ * Line 3: CLAUDE.md count | rules count | MCPs count | hooks count
+ * Line 4: (TODO: tool counts — 추적 인프라 없음)
+ * Line 5: (TODO: active task — 추적 인프라 없음)
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { execSync } from 'node:child_process';
+import { loadActiveRules } from '../store/rule-store.js';
+// ANSI codes
+const DIM = '\x1b[2m';
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const BOLD = '\x1b[1m';
+const RESET = '\x1b[0m';
+function readStdinJson() {
+    // stdin이 TTY면 파이프 입력 없음 → 빈 payload로 fallback
+    if (process.stdin.isTTY)
+        return {};
+    try {
+        const raw = fs.readFileSync('/dev/stdin', 'utf-8').trim();
+        if (!raw)
+            return {};
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+function getGitBranch(cwd) {
+    try {
+        const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+            cwd,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 2000,
+        })
+            .toString()
+            .trim();
+        const isDirty = (() => {
+            try {
+                const status = execSync('git status --porcelain', {
+                    cwd,
+                    stdio: ['ignore', 'pipe', 'ignore'],
+                    timeout: 2000,
+                }).toString().trim();
+                return status.length > 0;
+            }
+            catch {
+                return false;
+            }
+        })();
+        return `git:(${branch}${isDirty ? '*' : ''})`;
+    }
+    catch {
+        return '';
+    }
+}
+function getSettingsJson(claudeDir) {
+    const settingsPath = path.join(claudeDir, 'settings.json');
+    if (!fs.existsSync(settingsPath))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function countMcps(settings) {
+    const mcpServers = settings.mcpServers;
+    if (!mcpServers || typeof mcpServers !== 'object')
+        return 0;
+    return Object.keys(mcpServers).length;
+}
+function countHooks(settings) {
+    const hooks = settings.hooks;
+    if (!hooks || typeof hooks !== 'object')
+        return 0;
+    return Object.values(hooks).reduce((acc, matchers) => {
+        if (!Array.isArray(matchers))
+            return acc;
+        return acc + matchers.length;
+    }, 0);
+}
+function countClaudeMd(cwd) {
+    try {
+        const result = execSync('find . -maxdepth 2 -name CLAUDE.md', {
+            cwd,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 3000,
+        }).toString().trim();
+        if (!result)
+            return 0;
+        return result.split('\n').filter(Boolean).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function buildLine1(payload, cwd) {
+    const modelName = payload.model?.display_name ?? 'Claude';
+    const gitBranch = getGitBranch(cwd);
+    const cwdDisplay = cwd.replace(os.homedir(), '~');
+    const parts = [`${BOLD}${CYAN}${modelName}${RESET}`];
+    parts.push(`${DIM}${cwdDisplay}${RESET}`);
+    if (gitBranch)
+        parts.push(`${GREEN}${gitBranch}${RESET}`);
+    return parts.join(`  ${DIM}|${RESET}  `);
+}
+function buildLine3(claudeDir, cwd) {
+    const settings = getSettingsJson(claudeDir);
+    const claudeMdCount = countClaudeMd(cwd);
+    const rulesCount = (() => {
+        try {
+            return loadActiveRules().length;
+        }
+        catch {
+            return 0;
+        }
+    })();
+    const mcpCount = countMcps(settings);
+    const hookCount = countHooks(settings);
+    return [
+        `${YELLOW}${claudeMdCount} CLAUDE.md${RESET}`,
+        `${YELLOW}${rulesCount} rules${RESET}`,
+        `${YELLOW}${mcpCount} MCPs${RESET}`,
+        `${YELLOW}${hookCount} hooks${RESET}`,
+    ].join(`  ${DIM}|${RESET}  `);
+}
+export async function handleStatusline() {
+    const payload = readStdinJson();
+    const cwd = payload.workspace?.current_dir ?? process.cwd();
+    const claudeDir = path.join(os.homedir(), '.claude');
+    const line1 = buildLine1(payload, cwd);
+    const line3 = buildLine3(claudeDir, cwd);
+    // Line 2 (context/usage): stdin JSON spec 미확인으로 생략 — TODO
+    // Line 4 (tool counts): 추적 인프라 없음 — TODO
+    // Line 5 (active task): 추적 인프라 없음 — TODO
+    console.log(line1);
+    console.log(line3);
+}

package/dist/hooks/hook-registry.js

@@ -10,8 +10,9 @@
  *   - safety: 범용 안전 훅 (기본 활성, 개별 비활성 가능)
  *   - workflow: 워크플로우 스킬 훅 (다른 플러그인 감지 시 자동 비활성)
  */
-import { createRequire } from 'node:module';
-const require = createRequire(import.meta.url);
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
 /**
  * 단일 소스 오브 트루스: hooks/hook-registry.json
  *
@@ -19,9 +20,13 @@ const require = createRequire(import.meta.url);
  *   - pre-tool-use는 db-guard/rate-limiter보다 앞에 위치
  *     (Code Reflection + permission hints 주입 타이밍)
  *   - 같은 이벤트 내 훅은 배열 순서대로 실행됨
+ *
+ * Why readFileSync (not `import ... with { type: 'json' }`):
+ *   Import attributes는 Node 20.10+에서만 파싱됨. 20.0-20.9 사용자가 npm i -g
+ *   이후 모든 훅이 SyntaxError로 깨지는 것을 방지하기 위해 fs.readFileSync 사용.
  */
-import registryData from '../../assets/shared/hook-registry.json' with { type: 'json' };
-export const HOOK_REGISTRY = registryData;
+const REGISTRY_PATH = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'assets', 'shared', 'hook-registry.json');
+export const HOOK_REGISTRY = JSON.parse(readFileSync(REGISTRY_PATH, 'utf-8'));
 /** 티어별 훅 목록 조회 */
 export function getHooksByTier(tier) {
     return HOOK_REGISTRY.filter(h => h.tier === tier);

package/dist/hooks/stop-guard.js

@@ -27,6 +27,8 @@ import { takeLastExtractionNotice } from '../core/extraction-notice.js';
 import { checkConclusionVerificationRatio } from '../checks/conclusion-verification-ratio.js';
 import { checkSelfScoreInflation } from '../checks/self-score-deflation.js';
 import { checkFactVsAgreement } from '../checks/fact-vs-agreement.js';
+import { checkDangerousResponsePattern } from '../checks/dangerous-response-pattern.js';
+import { sanitizeForGuard } from '../checks/_shared/text-sanitizer.js';
 import { STATE_DIR } from '../core/paths.js';
 import { sanitizeId } from './shared/sanitize-id.js';
 import { detectRecallReferences } from '../core/recall-reference-detector.js';
@@ -496,58 +498,73 @@ export async function main() {
         // block/approve 어느 경로이든 동일하게 기록 (참조는 응답 내용이 결정).
         const sessionIdForRef = input?.session_id ?? 'unknown';
         emitRecallReferencesFailOpen(sessionIdForRef, lastMessage);
-        // TEST-2/3: rule-free meta guards — FORGEN_USER_CONFIRMED=1 우회 공통.
+        // TEST-1/2/3: rule-free meta guards — FORGEN_USER_CONFIRMED=1 우회 공통.
+        // Pathfinder D7: 3중 보일러플레이트를 CHECKS 배열 + for-loop 디스패처로 통합.
+        // Pathfinder D4/D5: sanitizeForGuard 가 모든 체크 입력 단계에 일괄 적용.
         if (process.env.FORGEN_USER_CONFIRMED !== '1') {
             const sessionId = input?.session_id ?? 'unknown';
-            // TEST-2 (자가 점수 인플레이션): 숫자 점수 상승 선언 + 측정 도구 0회 → block.
-            // TEST-3 보다 강한 신호라 먼저 평가.
             const recentTools = loadRecentToolNames(sessionId);
-            const score = checkSelfScoreInflation({ text: lastMessage, recentTools });
-            if (score.block) {
-                recordViolation({
-                    rule_id: 'builtin:self-score-inflation',
-                    session_id: sessionId,
-                    source: 'stop-guard',
+            const sanitized = sanitizeForGuard(lastMessage);
+            // 평가 순서: DANGEROUS-RESPONSE (즉시 차단 — 안전 우선) → TEST-2 (강한 신호) → TEST-3 (텍스트 비율) → TEST-1 (alert-only).
+            const checks = [
+                {
+                    shortId: 'dangerous-response-pattern',
+                    ruleSlug: 'rule:DANGEROUS-RESPONSE — destructive command suggestion',
                     kind: 'block',
-                    message_preview: lastMessage.slice(0, 120),
-                });
-                const reasonText = `[forgen:stop-guard/self-score-inflation] ${score.reason}
-
-(Override this turn: set FORGEN_USER_CONFIRMED=1 (audited).)`;
-                console.log(blockStop(reasonText, 'rule:TEST-2 — self-score inflation'));
-                return;
-            }
-            // TEST-3: 결론/검증 비율 — Claude 가 실제 측정 도구는 돌렸지만 서술이
-            // 결론-편향이면 여전히 block.
-            const ratio = checkConclusionVerificationRatio({ text: lastMessage });
-            if (ratio.block) {
+                    // 주의: sanitizer 가 백틱/코드블록을 제거하므로 raw lastMessage 를 전달.
+                    // 위험 명령은 코드 fence 안에 있어도 동등하게 위험함.
+                    run: () => {
+                        const r = checkDangerousResponsePattern({ text: lastMessage });
+                        return { triggered: r.block, reason: r.reason };
+                    },
+                },
+                {
+                    shortId: 'self-score-inflation',
+                    ruleSlug: 'rule:TEST-2 — self-score inflation',
+                    kind: 'block',
+                    run: () => {
+                        const r = checkSelfScoreInflation({ text: sanitized, recentTools });
+                        return { triggered: r.block, reason: r.reason };
+                    },
+                },
+                {
+                    shortId: 'conclusion-ratio',
+                    ruleSlug: 'rule:TEST-3 — conclusion/verification ratio',
+                    kind: 'block',
+                    run: () => {
+                        const r = checkConclusionVerificationRatio({ text: sanitized });
+                        return { triggered: r.block, reason: r.reason };
+                    },
+                },
+                {
+                    shortId: 'fact-vs-agreement',
+                    ruleSlug: 'rule:TEST-1 — fact vs agreement',
+                    kind: 'correction', // alert-level only per fact-vs-agreement.ts design
+                    run: () => {
+                        const r = checkFactVsAgreement({ text: sanitized, recentTools, minMeasurements: 1 });
+                        return { triggered: r.alert, reason: r.reason };
+                    },
+                },
+            ];
+            for (const c of checks) {
+                const out = c.run();
+                if (!out.triggered)
+                    continue;
                 recordViolation({
-                    rule_id: 'builtin:conclusion-verification-ratio',
+                    rule_id: `builtin:${c.shortId}`,
                     session_id: sessionId,
                     source: 'stop-guard',
-                    kind: 'block',
+                    kind: c.kind,
                     message_preview: lastMessage.slice(0, 120),
                 });
-                const reasonText = `[forgen:stop-guard/conclusion-ratio] ${ratio.reason}
+                if (c.kind !== 'block')
+                    continue;
+                const reasonText = `[forgen:stop-guard/${c.shortId}] ${out.reason}
 
 (Override this turn: set FORGEN_USER_CONFIRMED=1 (audited).)`;
-                console.log(blockStop(reasonText, 'rule:TEST-3 — conclusion/verification ratio'));
+                console.log(blockStop(reasonText, c.ruleSlug));
                 return;
             }
-            // TEST-1: 사실 vs 합의 — fact assertion 키워드가 있으나 측정 도구 호출 0건.
-            // 원 design intent (per fact-vs-agreement.ts): alert level only — block 은 TEST-2/3.
-            // 여기서는 measurement 신호를 violations.jsonl 에 'alert' kind 로 기록만 (block 안 함).
-            // wiring gap 발견 (forgen-eval introspect) → 측정 가능하게 wired up.
-            const fva = checkFactVsAgreement({ text: lastMessage, recentTools, minMeasurements: 1 });
-            if (fva.alert) {
-                recordViolation({
-                    rule_id: 'builtin:fact-vs-agreement',
-                    session_id: sessionId,
-                    source: 'stop-guard',
-                    kind: 'correction', // alert-level signal (not block) per fact-vs-agreement.ts design
-                    message_preview: lastMessage.slice(0, 120),
-                });
-            }
         }
         const rules = loadStopRules();
         if (rules.length === 0) {

package/dist/host/install-claude.js

@@ -40,13 +40,21 @@ function writePluginCache(opts) {
     catch { /* ignore */ }
     fs.mkdirSync(cacheParent, { recursive: true });
     // 1차: symlink 시도 (개발 환경)
+    // Why warn on fallback: Windows 비관리자 / macOS SIP 환경에서 symlink 가 EPERM
+    //   으로 거부되면 조용히 cpSync 폴백을 탔는데, 사용자는 "왜 install 이 느리지"
+    //   를 알 길이 없었다. 폴백 진입을 stderr 로 알려서 진단성 확보.
     let linked = false;
+    let symlinkErr = null;
     try {
         fs.symlinkSync(pkgRoot, cacheDir, 'dir');
         linked = true;
     }
-    catch {
-        // symlink 실패 → cp fallback
+    catch (e) {
+        symlinkErr = e;
+    }
+    if (!linked && symlinkErr) {
+        const code = symlinkErr.code ?? 'UNKNOWN';
+        process.stderr.write(`[forgen] symlink ${pkgRoot} → ${cacheDir} failed (${code}); falling back to cpSync.\n`);
     }
     if (!linked) {
         fs.mkdirSync(cacheDir, { recursive: true });
@@ -91,6 +99,29 @@ function writePluginCache(opts) {
     return true;
 }
 // ── 2. Slash commands ──────────────────────────────────────────────────
+/** Build-time injected --with-codex shared snippet. Mirror of scripts/copy-assets.js. */
+const WITH_CODEX_SNIPPET = `
+
+---
+
+## \`--with-codex\` flag (cross-model review)
+
+If \`$ARGUMENTS\` contains any of \`--with-codex\`, \`--코덱스\`, \`with codex\`, \`코덱스 검토\`, \`코덱스로 검토\`,
+then after completing the primary skill work, perform a cross-model review pass:
+
+1. Save your primary output text to a temp file (e.g., \`/tmp/forgen-with-codex-$(date +%s).md\`).
+2. Invoke codex via Bash:
+   \`\`\`bash
+   codex exec --json --ignore-user-config --ignore-rules --ephemeral \\
+     -s read-only -c approval_policy="never" --skip-git-repo-check \\
+     "$(printf 'You are a second-opinion reviewer for another AI assistant\\\\u0027s output. Read the work product below and report ONLY:\\n1. Defects, gaps, or risks the original work missed\\n2. Specific disagreements with the original\\n3. Topics that should have been covered but were not\\n\\nOutput format: prioritized bullet list (max 15 items, severity-sorted, no prose intro). If you find nothing material, say "No critical issues found."\\n\\n<work>\\n%s\\n</work>' "$(cat /tmp/forgen-with-codex-*.md)")"
+   \`\`\`
+3. Append the codex output under heading \`## Codex Cross-Review (--with-codex)\` in your final response.
+4. If codex flags critical issues, briefly acknowledge + suggest follow-up.
+5. If \`codex: command not found\`, note in response and skip the review pass (do not fail).
+
+OPT-IN per invocation. Without the flag, skip this entire section.
+`;
 function writeSlashCommands(opts) {
     const { pkgRoot, targetDir, dryRun } = opts;
     const sourceDir = path.join(pkgRoot, 'assets', 'claude', 'commands');
@@ -106,7 +137,7 @@ function writeSlashCommands(opts) {
         const descMatch = skillContent.match(/description:\s*(.+)/);
         const desc = descMatch?.[1]?.trim() ?? file.replace(/\.md$/, '');
         const skillName = file.replace(/\.md$/, '');
-        const out = `# ${desc}\n\n${FORGEN_MANAGED_MARKER}\n\nActivate Forgen "${skillName}" mode for the task: $ARGUMENTS\n\n${skillContent}`;
+        const out = `# ${desc}\n\n${FORGEN_MANAGED_MARKER}\n\nActivate Forgen "${skillName}" mode for the task: $ARGUMENTS\n\n${skillContent}${WITH_CODEX_SNIPPET}`;
         const target = path.join(targetDir, file);
         if (fs.existsSync(target)) {
             const existing = fs.readFileSync(target, 'utf-8');

package/dist/mcp/tools.js

@@ -136,6 +136,10 @@ export function registerTools(server) {
                     }],
             };
         }
+        // D11 — compound usage signal: 사용자 reuse 신호를 한 줄 기록.
+        // mature 승격 정책의 입력 데이터 (정책은 별도 사이클).
+        const usageMod = await import('../store/compound-usage-store.js');
+        usageMod.recordUsage(result.name, 'mcp');
         const header = `# ${result.name}\n` +
             `Status: ${result.status} | Confidence: ${result.confidence.toFixed(2)} | Type: ${result.type} | Scope: ${result.scope}\n` +
             `Tags: ${result.tags.join(', ')}\n` +

package/dist/renderer/rule-renderer.d.ts

@@ -15,4 +15,4 @@ export interface RenderContext {
     include_pack_summary: boolean;
 }
 export declare const DEFAULT_CONTEXT: RenderContext;
-export declare function renderRules(rules: Rule[], state: SessionEffectiveState, _profile: Profile, ctx?: RenderContext): string;
+export declare function renderRules(rules: Rule[], state: SessionEffectiveState, profile: Profile, ctx?: RenderContext): string;

package/dist/renderer/rule-renderer.js

@@ -91,8 +91,74 @@ function communicationPackRules(pack) {
         case '균형형': return s.commBalanced;
     }
 }
+// ── Facet-driven rules ──
+// 4축 facet 값의 양 극단(≤0.15, ≥0.85)에서만 추가 규칙을 emit. 중간 값은
+// pack 기본 규칙으로 충분하다고 본다 — 12-bucket pack lookup 위에 *연속 값
+// 차별화*를 얇게 얹는 설계.
+//
+// Threshold 정당화: 0.5 가 default 이고 자동 갱신은 ±0.1 단위 (auto-compound-runner).
+// 0.15/0.85 = 3 단계 강한 신호 누적 후에야 발화 → 노이즈에 둔감.
+const FACET_HIGH = 0.85;
+const FACET_LOW = 0.15;
+function facetDrivenRules(profile) {
+    const out = [];
+    const q = profile.axes.quality_safety.facets;
+    const a = profile.axes.autonomy.facets;
+    const j = profile.axes.judgment_philosophy.facets;
+    const c = profile.axes.communication_style.facets;
+    // Quality
+    if (q.verification_depth >= FACET_HIGH) {
+        out.push({ section: 'How To Validate', rule: '완료 선언 전 실행 로그 / 테스트 결과 / e2e 증거를 응답에 첨부' });
+    }
+    if (q.stop_threshold >= FACET_HIGH) {
+        out.push({ section: 'Working Defaults', rule: '첫 실패 시 즉시 멈추고 진단 — 무진단 재시도 금지' });
+    }
+    if (q.change_conservatism >= FACET_HIGH) {
+        out.push({ section: 'Working Defaults', rule: '의뢰 범위 외 리팩토링/일반화 금지 — 최소 diff 우선' });
+    }
+    else if (q.change_conservatism <= FACET_LOW) {
+        out.push({ section: 'Working Defaults', rule: '명확성을 위한 리팩토링은 허용 — 디버그 중 발견된 인접 결함도 같은 PR 가능' });
+    }
+    // Autonomy
+    if (a.confirmation_independence >= FACET_HIGH) {
+        out.push({ section: 'When To Ask', rule: '목표 합의 후 단계별 재확인 생략 — 마무리 시점 한 번만 보고' });
+    }
+    else if (a.confirmation_independence <= FACET_LOW) {
+        out.push({ section: 'When To Ask', rule: '비-사소한 단계마다 사용자 확인을 받고 진행' });
+    }
+    if (a.approval_threshold >= FACET_HIGH) {
+        out.push({ section: 'When To Ask', rule: '비가역 작업(force push, 데이터 삭제, 외부 broadcast) 전 명시 승인 필수' });
+    }
+    // Judgment
+    if (j.minimal_change_bias >= FACET_HIGH) {
+        out.push({ section: 'Working Defaults', rule: '직면한 문제만 해결 — 인접 개선/추상화 제안은 별도 보고' });
+    }
+    if (j.abstraction_bias >= FACET_HIGH) {
+        out.push({ section: 'Working Defaults', rule: '반복 패턴 발견 시 재사용 가능한 추상화로 통합 제안' });
+    }
+    else if (j.abstraction_bias <= FACET_LOW) {
+        out.push({ section: 'Working Defaults', rule: '명확성을 해치는 추상화 금지 — 인라인 중복 허용' });
+    }
+    if (j.evidence_first_bias >= FACET_HIGH) {
+        out.push({ section: 'How To Report', rule: '결론·가설 명시 전 근거(파일:라인, 로그, 측정값)를 먼저 표면화' });
+    }
+    // Communication
+    if (c.verbosity <= FACET_LOW) {
+        out.push({ section: 'How To Report', rule: '코드 표시가 필요하지 않으면 답변은 3문장 이내' });
+    }
+    else if (c.verbosity >= FACET_HIGH) {
+        out.push({ section: 'How To Report', rule: '결정 배경·대안·tradeoff 를 답변에 포함' });
+    }
+    if (c.structure >= FACET_HIGH) {
+        out.push({ section: 'How To Report', rule: '다중 포인트 답변은 헤더/표/리스트로 구조화' });
+    }
+    if (c.teaching_bias >= FACET_HIGH) {
+        out.push({ section: 'How To Report', rule: 'why/how 를 함께 설명 — what 만 답하지 말 것' });
+    }
+    return out;
+}
 // ── Main Render ──
-export function renderRules(rules, state, _profile, ctx = DEFAULT_CONTEXT) {
+export function renderRules(rules, state, profile, ctx = DEFAULT_CONTEXT) {
     // 1. active만 수집
     const active = rules.filter(r => r.status === 'active');
     // 2. dedupe by render_key
@@ -122,6 +188,12 @@ export function renderRules(rules, state, _profile, ctx = DEFAULT_CONTEXT) {
         for (const rule of communicationPackRules(state.communication_pack)) {
             sections.get('How To Report').push(rule);
         }
+        // 4축 facet 극단값 → 추가 규칙 (12-bucket pack 위에 연속 값 차별화).
+        // 각 facet 0.5 default 이고 자동 갱신 ±0.1 단위이므로, 0.85/0.15 임계값은
+        // 여러 세션에 걸친 강한 신호 누적 후에만 발화한다.
+        for (const fr of facetDrivenRules(profile)) {
+            sections.get(fr.section).push(fr.rule);
+        }
     }
     // 6. 섹션 조립 (AI-optimized: 간결한 태그 형식)
     const parts = [];