@wooojin/forgen 0.4.1 → 0.4.4

package/dist/host/parity-harness.js

@@ -0,0 +1,283 @@
+/**
+ * BehavioralParityScenario harness — Multi-Host Core Design §10 우선순위 4
+ *
+ * "Claude 와 Codex 양쪽에서 같은 입력을 흘려보냈을 때 evidence 가 의미적으로 같다" 를
+ * 검증하는 골격. P4 단계에서는 *projection 사영 후 등가성* 만 검증한다 — 실 모델 호출은
+ * P6 (실 Codex CLI) 트랙.
+ *
+ * 본 harness 가 verify 하는 것:
+ *   1. 같은 forgen hook 입력에 대해 양쪽 host 의 raw 출력을 사영하면 의미 동치한 객체가 된다.
+ *   2. 사영 결과가 1원칙 (Claude reference) 의 행동 의도와 일치한다.
+ *
+ * verify 하지 않는 것 (P6 별도 트랙):
+ *   - 실제 Codex 모델이 같은 prompt 에 같은 행동을 보이는지
+ *   - 실제 Claude 모델과의 동작 동등성
+ */
+import { equal as deepEqual } from 'node:assert/strict';
+import { getProjection } from './projection.js';
+function pickPath(obj, dotted) {
+    const parts = dotted.split('.');
+    let cur = obj;
+    for (const p of parts) {
+        if (cur && typeof cur === 'object' && p in cur) {
+            cur = cur[p];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return cur;
+}
+function valuesSemanticEqual(a, b) {
+    try {
+        deepEqual(a, b);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function runScenario(scenario) {
+    const projected = {
+        claude: getProjection('claude')(scenario.hostRaw.claude, scenario.input),
+        codex: getProjection('codex')(scenario.hostRaw.codex, scenario.input),
+    };
+    const diffs = [];
+    for (const key of scenario.compareKeys) {
+        const cv = pickPath(projected.claude, key);
+        const xv = pickPath(projected.codex, key);
+        if (!valuesSemanticEqual(cv, xv)) {
+            diffs.push({ key, claude: cv, codex: xv });
+        }
+    }
+    return {
+        scenarioId: scenario.id,
+        intent: scenario.intent,
+        passed: diffs.length === 0,
+        diffs,
+        projected,
+    };
+}
+/**
+ * P4 1차 시나리오 corpus — Trust Layer 7 의도 중 hook 출력으로 직접 관측 가능한 5종.
+ * (`forge-loop-state-inject` 는 inject-context 의 특수 케이스, `self-evidence-record` 는
+ * 파일 시스템 사이드이펙트라 본 corpus 가 아닌 별도 e2e 트랙.)
+ *
+ * P4 2차 추가 시나리오 (spec §10 우선순위 4 산출물, 2026-04-27):
+ *   - forge-loop-m1-inject-stale       : §17.1 fact 1 / M1 hook 1KB cap + stale tag
+ *   - block-tool-use-pretool-ask       : §9.0 block-tool-use row — Codex ask 값 동치
+ *   - stop-hook-reentry-guard          : §15 stop_hook_active=true 즉시 approve 경로
+ *   - posttooluse-general-block-only   : §9.0 secret-filter row partial — block decision 만 등가
+ *   - suppress-output-equivalence      : suppressOutput 동치성
+ */
+export const SCENARIO_CORPUS = [
+    {
+        id: 'block-completion-stop',
+        intent: 'block-completion',
+        description: 'Stop hook 이 block + reason 으로 자동 continuation 트리거',
+        input: { hookEventName: 'Stop', stop_hook_active: false },
+        hostRaw: {
+            claude: { decision: 'block', reason: 'tests not yet executed' },
+            codex: { decision: 'block', reason: 'tests not yet executed' },
+        },
+        compareKeys: [
+            'continue',
+            'hookSpecificOutput.permissionDecision',
+        ],
+    },
+    {
+        id: 'block-tool-use-pretool-deny',
+        intent: 'block-tool-use',
+        description: 'PreToolUse 가 permissionDecision:deny + reason 으로 도구 차단',
+        input: { hookEventName: 'PreToolUse', tool_name: 'Bash' },
+        hostRaw: {
+            claude: {
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'deny',
+                    permissionDecisionReason: 'rm -rf / matched',
+                },
+            },
+            codex: {
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'deny',
+                    permissionDecisionReason: 'rm -rf / matched',
+                },
+            },
+        },
+        compareKeys: [
+            'hookSpecificOutput.permissionDecision',
+            'hookSpecificOutput.permissionDecisionReason',
+        ],
+    },
+    {
+        id: 'inject-context-session-start',
+        intent: 'inject-context',
+        description: 'SessionStart 가 additionalContext 로 forge-loop state 주입',
+        input: { hookEventName: 'SessionStart' },
+        hostRaw: {
+            claude: {
+                hookSpecificOutput: {
+                    hookEventName: 'SessionStart',
+                    additionalContext: '<forge-loop-state>...</forge-loop-state>',
+                },
+            },
+            codex: {
+                hookSpecificOutput: {
+                    hookEventName: 'SessionStart',
+                    additionalContext: '<forge-loop-state>...</forge-loop-state>',
+                },
+            },
+        },
+        compareKeys: [
+            'continue',
+            'hookSpecificOutput.additionalContext',
+        ],
+    },
+    {
+        id: 'observe-only-non-allowlist',
+        intent: 'observe-only',
+        description: 'ALLOW-LIST 외 hook 이 deny 시도 시 approve 강등',
+        input: { hookEventName: 'PreToolUse' },
+        hostRaw: {
+            claude: { continue: true },
+            codex: { continue: true },
+        },
+        compareKeys: ['continue'],
+    },
+    {
+        id: 'secret-filter-pretooluse-block',
+        intent: 'secret-filter',
+        description: 'API 키 노출 차단 — PreToolUse 가드 (양쪽 동일 경로)',
+        input: { hookEventName: 'PreToolUse', tool_name: 'Bash' },
+        hostRaw: {
+            claude: {
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'deny',
+                    permissionDecisionReason: 'API_KEY=... matched',
+                },
+            },
+            codex: {
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'deny',
+                    permissionDecisionReason: 'API_KEY=... matched',
+                },
+            },
+        },
+        compareKeys: [
+            'hookSpecificOutput.permissionDecision',
+            'hookSpecificOutput.permissionDecisionReason',
+        ],
+    },
+    // ── P4 2차 추가 시나리오 ────────────────────────────────────────────────────
+    {
+        id: 'forge-loop-m1-inject-stale',
+        intent: 'forge-loop-state-inject',
+        description: 'SessionStart 가 stale="true" 태그 포함 forge-loop-state 를 1KB cap 내에서 inject (spec §17.1 fact 1 / M1 hook)',
+        input: { hookEventName: 'SessionStart' },
+        hostRaw: {
+            claude: {
+                hookSpecificOutput: {
+                    hookEventName: 'SessionStart',
+                    additionalContext: '<forge-loop-state stale="true">{"phase":"M1","lastCompletedAt":"2026-04-26T22:00:00Z"}</forge-loop-state>',
+                },
+            },
+            codex: {
+                hookSpecificOutput: {
+                    hookEventName: 'SessionStart',
+                    additionalContext: '<forge-loop-state stale="true">{"phase":"M1","lastCompletedAt":"2026-04-26T22:00:00Z"}</forge-loop-state>',
+                },
+            },
+        },
+        compareKeys: [
+            'continue',
+            'hookSpecificOutput.additionalContext',
+        ],
+    },
+    {
+        id: 'block-tool-use-pretool-ask',
+        intent: 'block-tool-use',
+        description: 'Codex PreToolUse permissionDecision:"ask" 가 Claude ask 값과 의미 동치 — forgen denyOrObserve 의 ask 의도 (spec §9.0 block-tool-use row 메모)',
+        input: { hookEventName: 'PreToolUse', tool_name: 'Bash' },
+        hostRaw: {
+            claude: {
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'ask',
+                    permissionDecisionReason: 'requires human confirmation',
+                },
+            },
+            codex: {
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'ask',
+                    permissionDecisionReason: 'requires human confirmation',
+                },
+            },
+        },
+        compareKeys: [
+            'hookSpecificOutput.permissionDecision',
+            'hookSpecificOutput.permissionDecisionReason',
+        ],
+    },
+    {
+        id: 'stop-hook-reentry-guard',
+        intent: 'block-completion',
+        description: 'stop_hook_active=true 시 Stop hook 이 즉시 approve(continue:true) 로 빠지는 재진입 가드 (spec §15)',
+        input: { hookEventName: 'Stop', stop_hook_active: true },
+        hostRaw: {
+            claude: { continue: true },
+            codex: { continue: true },
+        },
+        compareKeys: ['continue'],
+    },
+    {
+        id: 'posttooluse-general-block-only',
+        intent: 'secret-filter',
+        description: 'PostToolUse 일반 tool — Codex 는 redact 미보장이므로 block decision 만 양쪽 등가. updatedMCPToolOutput 없음 (spec §9.0 secret-filter row partial / §18.2 fact 4)',
+        input: { hookEventName: 'PostToolUse', tool_name: 'Bash' },
+        hostRaw: {
+            claude: {
+                hookSpecificOutput: {
+                    hookEventName: 'PostToolUse',
+                    permissionDecision: 'deny',
+                    permissionDecisionReason: 'SECRET=... detected in tool output',
+                },
+            },
+            codex: {
+                hookSpecificOutput: {
+                    hookEventName: 'PostToolUse',
+                    permissionDecision: 'deny',
+                    permissionDecisionReason: 'SECRET=... detected in tool output',
+                },
+            },
+        },
+        compareKeys: [
+            'hookSpecificOutput.permissionDecision',
+            'hookSpecificOutput.permissionDecisionReason',
+        ],
+    },
+    {
+        id: 'suppress-output-equivalence',
+        intent: 'observe-only',
+        description: 'PostToolUse suppressOutput=true 가 양쪽 host 에서 동치로 사영됨',
+        input: { hookEventName: 'PostToolUse', tool_name: 'Read' },
+        hostRaw: {
+            claude: {
+                continue: true,
+                suppressOutput: true,
+            },
+            codex: {
+                continue: true,
+                suppressOutput: true,
+            },
+        },
+        compareKeys: [
+            'continue',
+            'suppressOutput',
+        ],
+    },
+];

package/dist/host/projection.d.ts

@@ -0,0 +1,35 @@
+/**
+ * ProjectToClaudeEvent — Multi-Host Core Design §5.2 / §10 우선순위 2
+ *
+ * Codex (또는 미래의 다른 host) 의 hook 출력을 Claude Hook schema 로 사영하는
+ * 정식 계약. spec §17.4 / §18.4 에서 검증되었듯 schema-level 에서 거의 identity 이므로
+ * 본 함수는 *형식 정규화* 만 책임진다.
+ *
+ * - 입력: host-native 출력(JSON object, plaintext, exit-code 등은 별도 layer 에서 처리)
+ * - 출력: Claude HookEventOutput 동치 — `continue`, `hookSpecificOutput.permissionDecision`, etc.
+ * - 실패 정책: parse 실패 / 알 수 없는 형식 → fail-open (`{ continue: true }`)
+ *
+ * 본 모듈은 host 측 표면을 *모르고*, 받은 raw 의 형태만으로 동작한다 (1원칙: core 는 Claude
+ * semantics 알아도 됨, Codex 표면 모름). 즉 Codex CLI 의 stdout 을 받아 코어가 학습 가능한
+ * Claude 형 객체로 변환만 한다.
+ */
+import type { HookEventInput, HookEventOutput } from '../core/types.js';
+import type { HostId } from '../core/trust-layer-intent.js';
+export type ProjectToClaudeEvent = (raw: unknown, input: HookEventInput) => HookEventOutput;
+/**
+ * Codex 출력 → Claude HookEventOutput 정식 사영.
+ *
+ * spec §18.2 fact #3 에 따라 PreToolUse 의 *이중* decision 필드 중 어댑터는
+ * `hookSpecificOutput.permissionDecision` 을 우선한다. 본 함수가 그 규약을 강제.
+ */
+export declare const projectCodexToClaude: ProjectToClaudeEvent;
+/**
+ * Claude 어댑터의 사영. 1원칙(Claude reference) + spec §18.4 (Codex hooks.json schema 동일성)
+ * 에 따라 본 함수는 `projectCodexToClaude` 와 *같은 normalize 로직* 을 공유한다.
+ * 둘 다 같은 canonical Claude HookEventOutput 형식을 만든다.
+ *
+ * (왜 두 함수를 별도 export 하는가: 향후 schema 가 다른 host 가 추가될 때 본 binding 만
+ * 교체하면 되도록 — `getProjection(host)` 가 단일 진입점.)
+ */
+export declare const projectClaudeToClaude: ProjectToClaudeEvent;
+export declare function getProjection(host: HostId): ProjectToClaudeEvent;

package/dist/host/projection.js

@@ -0,0 +1,126 @@
+/**
+ * ProjectToClaudeEvent — Multi-Host Core Design §5.2 / §10 우선순위 2
+ *
+ * Codex (또는 미래의 다른 host) 의 hook 출력을 Claude Hook schema 로 사영하는
+ * 정식 계약. spec §17.4 / §18.4 에서 검증되었듯 schema-level 에서 거의 identity 이므로
+ * 본 함수는 *형식 정규화* 만 책임진다.
+ *
+ * - 입력: host-native 출력(JSON object, plaintext, exit-code 등은 별도 layer 에서 처리)
+ * - 출력: Claude HookEventOutput 동치 — `continue`, `hookSpecificOutput.permissionDecision`, etc.
+ * - 실패 정책: parse 실패 / 알 수 없는 형식 → fail-open (`{ continue: true }`)
+ *
+ * 본 모듈은 host 측 표면을 *모르고*, 받은 raw 의 형태만으로 동작한다 (1원칙: core 는 Claude
+ * semantics 알아도 됨, Codex 표면 모름). 즉 Codex CLI 의 stdout 을 받아 코어가 학습 가능한
+ * Claude 형 객체로 변환만 한다.
+ */
+function parseDecision(raw) {
+    if (typeof raw === 'boolean')
+        return { continueFlag: raw };
+    if (typeof raw === 'string') {
+        const normalized = raw.toLowerCase();
+        if (normalized === 'continue')
+            return { continueFlag: true };
+        if (normalized === 'stop' ||
+            normalized === 'deny' ||
+            normalized === 'reject' ||
+            normalized === 'block') {
+            return { continueFlag: false, permissionDecision: normalized };
+        }
+        return { continueFlag: true };
+    }
+    if (typeof raw !== 'object' || raw === null)
+        return { continueFlag: true };
+    const decision = raw.decision;
+    if (typeof decision === 'string') {
+        const normalized = decision.toLowerCase();
+        if (normalized === 'deny' || normalized === 'reject' || normalized === 'block') {
+            return { continueFlag: false, permissionDecision: normalized };
+        }
+        if (normalized === 'ask' || normalized === 'prompt' || normalized === 'confirm') {
+            return { continueFlag: true, permissionDecision: normalized };
+        }
+    }
+    if (typeof raw.approved === 'boolean') {
+        const approved = raw.approved;
+        return approved
+            ? { continueFlag: true, permissionDecision: raw.decision || 'approve' }
+            : { continueFlag: false, permissionDecision: 'deny' };
+    }
+    if (typeof raw.continue === 'boolean') {
+        return { continueFlag: raw.continue };
+    }
+    return { continueFlag: true };
+}
+/**
+ * Codex 출력 → Claude HookEventOutput 정식 사영.
+ *
+ * spec §18.2 fact #3 에 따라 PreToolUse 의 *이중* decision 필드 중 어댑터는
+ * `hookSpecificOutput.permissionDecision` 을 우선한다. 본 함수가 그 규약을 강제.
+ */
+export const projectCodexToClaude = (raw, input) => {
+    const result = { continue: true };
+    const decision = parseDecision(raw);
+    result.continue = decision.continueFlag;
+    if (typeof raw === 'object' && raw !== null) {
+        const payload = raw;
+        if (typeof payload.continue === 'boolean')
+            result.continue = payload.continue;
+        if (typeof payload.systemMessage === 'string')
+            result.systemMessage = payload.systemMessage;
+        if (typeof payload.suppressOutput === 'boolean')
+            result.suppressOutput = payload.suppressOutput;
+        if (typeof payload.hookSpecificOutput === 'object' && payload.hookSpecificOutput !== null) {
+            result.hookSpecificOutput = { ...payload.hookSpecificOutput };
+        }
+        // top-level decision (Codex 의 PreToolUse 이중 decision 중 legacy 측 또는 Stop/Post 의 단일 측)
+        // 이 있고, hookSpecificOutput.permissionDecision 이 비었을 때만 보존.
+        if (typeof payload.decision === 'string' &&
+            !(result.hookSpecificOutput && 'permissionDecision' in result.hookSpecificOutput)) {
+            result.hookSpecificOutput = {
+                ...(result.hookSpecificOutput ?? {}),
+                permissionDecision: payload.decision,
+            };
+        }
+    }
+    const eventName = result.hookSpecificOutput?.hookEventName ?? input.hookEventName ?? input.event;
+    if (eventName) {
+        result.hookSpecificOutput = {
+            hookEventName: eventName,
+            ...(result.hookSpecificOutput ?? {}),
+        };
+    }
+    if (!result.continue && !result.hookSpecificOutput?.permissionDecision) {
+        if (decision.permissionDecision) {
+            result.hookSpecificOutput = {
+                ...(result.hookSpecificOutput ?? {}),
+                permissionDecision: decision.permissionDecision,
+            };
+        }
+        else {
+            result.hookSpecificOutput = {
+                ...(result.hookSpecificOutput ?? {}),
+                permissionDecision: 'deny',
+            };
+        }
+    }
+    return result;
+};
+/**
+ * Claude 어댑터의 사영. 1원칙(Claude reference) + spec §18.4 (Codex hooks.json schema 동일성)
+ * 에 따라 본 함수는 `projectCodexToClaude` 와 *같은 normalize 로직* 을 공유한다.
+ * 둘 다 같은 canonical Claude HookEventOutput 형식을 만든다.
+ *
+ * (왜 두 함수를 별도 export 하는가: 향후 schema 가 다른 host 가 추가될 때 본 binding 만
+ * 교체하면 되도록 — `getProjection(host)` 가 단일 진입점.)
+ */
+export const projectClaudeToClaude = (raw, input) => projectCodexToClaude(raw, input);
+const PROJECTIONS = {
+    claude: projectClaudeToClaude,
+    codex: projectCodexToClaude,
+};
+export function getProjection(host) {
+    const fn = PROJECTIONS[host];
+    if (!fn)
+        throw new Error(`No ProjectToClaudeEvent registered for host: ${host}`);
+    return fn;
+}

package/dist/mcp/server.js

@@ -12,6 +12,17 @@ if (!process.env.FORGEN_CWD && !process.env.COMPOUND_CWD) {
     process.env.FORGEN_CWD = process.cwd();
     process.env.COMPOUND_CWD = process.cwd(); // legacy compat
 }
+// Multi-host evidence attribution (spec §10-5):
+// 호출 host 가 spawn 시 `--host=<claude|codex>` 인자를 넘기면 본 process 의
+// FORGEN_HOST env 를 set 한다. evidence-store 의 detectHost() 가 이 env 를 읽어
+// correction-record 가 정확한 host 로 박제되게 한다. 미지정 시 기존 fallback
+// (FORGEN_HOST > CODEX_HOME 추론 > 'claude') 그대로.
+const hostArg = process.argv
+    .find((a) => a === '--host=claude' || a === '--host=codex')
+    ?.split('=')[1];
+if (hostArg === 'claude' || hostArg === 'codex') {
+    process.env.FORGEN_HOST = hostArg;
+}
 const INSTRUCTIONS = [
     'Forgen compound knowledge — accumulated patterns and solutions from past sessions.',
     '',

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` +
@@ -441,4 +445,51 @@ export function registerTools(server) {
                 }],
         };
     });
+    // ── invoke-agent (P3-4/P3-5) ─────────────────────────────────────────
+    //
+    // forgen 의 13 sub-agents (assets/claude/agents/*.md) 를 MCP 도구로 노출.
+    // Claude 의 Task tool 동치를 host 무관 형태로 제공:
+    //   - Claude main agent: Task tool 우선 사용 (native, faster)
+    //   - Codex main agent: invoke-agent MCP 도구가 codex exec --json 으로 child spawn
+    // 실 작업: assets/claude/agents/<name>.md 의 system prompt 를 prefix 로,
+    // 사용자 task 를 prompt 로 child host CLI 호출 → 응답 반환.
+    server.registerTool('invoke-agent', {
+        description: [
+            'Invoke a forgen sub-agent (specialized prompt) on a task and return its summary.',
+            'Use when delegation is helpful — e.g., focused exploration (ch-explore), implementation (ch-executor),',
+            'critical review (ch-critic), test writing (ch-test-engineer).',
+            'The sub-agent runs in a separate child process with isolated context and returns just the result.',
+            'Available agent names match files under assets/claude/agents/ (e.g., ch-explore, ch-executor, ch-critic).',
+        ].join('\n'),
+        inputSchema: {
+            agent_name: z.string().describe('Sub-agent identifier (e.g., "ch-explore", "ch-executor")'),
+            task: z.string().describe('What you want the sub-agent to do — natural language task description'),
+            timeout_ms: z.number().int().positive().max(300000).optional()
+                .describe('Child timeout in ms (default 60s, max 5m)'),
+        },
+        annotations: { readOnlyHint: false },
+    }, async ({ agent_name, task, timeout_ms }) => {
+        try {
+            const { invokeAgent } = await import('../host/invoke-agent.js');
+            const result = await invokeAgent({ agentName: agent_name, task, timeoutMs: timeout_ms });
+            const lines = [
+                `[invoke-agent] ${agent_name} (${result.host}, ${result.durationMs}ms)`,
+                '',
+                result.summary,
+            ];
+            if (result.usage) {
+                lines.push('', `Usage: input=${result.usage.input_tokens ?? '?'} output=${result.usage.output_tokens ?? '?'}`);
+            }
+            return {
+                content: [{ type: 'text', text: lines.join('\n') }],
+            };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return {
+                content: [{ type: 'text', text: `[invoke-agent] error: ${msg}` }],
+                isError: true,
+            };
+        }
+    });
 }

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 = [];

package/dist/services/session.d.ts

@@ -10,10 +10,13 @@
  * - launch context(런타임 + 정제된 args)를 단일 타입으로 통일
  * - CLI/fgx에서 수집한 런타임 값을 Harness, Spawn, Hook Generator에 일관되게 전달
  */
-import { type LaunchContext } from '../core/types.js';
+import type { LaunchContext } from '../core/types.js';
 /**
  * CLI 인자를 파싱해 런타임 결정 + 런타임 플래그 제거
- * - --runtime codex
- * - --runtime=codex
+ * 우선순위 (높음→낮음):
+ *   1. --runtime <claude|codex> flag
+ *   2. FORGEN_RUNTIME env
+ *   3. profile.default_host (P1-4)
+ *   4. 'claude' fallback (legacy 호환)
  */
 export declare function resolveLaunchContext(args: string[]): LaunchContext;