@wooojin/forgen 0.4.1 → 0.4.3

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

@@ -441,4 +441,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/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;

package/dist/services/session.js

@@ -10,6 +10,8 @@
  * - launch context(런타임 + 정제된 args)를 단일 타입으로 통일
  * - CLI/fgx에서 수집한 런타임 값을 Harness, Spawn, Hook Generator에 일관되게 전달
  */
+import { createRequire } from 'node:module';
+const localRequire = createRequire(import.meta.url);
 /** 런타임 정규화: 외부 문자열을 내부 enum으로 변환 */
 function parseRuntime(raw) {
     if (!raw)
@@ -24,17 +26,44 @@ function parseRuntime(raw) {
     }
 }
 const DEFAULT_RUNTIME = 'claude';
+/**
+ * profile.default_host 를 읽어 runtime 결정.
+ * 'ask' 면 별도 prompt 책임 — 본 함수는 default 'claude' 로 fallback (caller 가 --ask 처리).
+ * profile-store import 가 cycle 위험이라 require 로 lazy.
+ */
+function readProfileDefaultRuntime() {
+    try {
+        const mod = localRequire('../store/profile-store.js');
+        const stored = mod.getDefaultHost?.();
+        if (stored === 'claude' || stored === 'codex')
+            return stored;
+        return null; // 'ask' 또는 미설정
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * 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 function resolveLaunchContext(args) {
     const runtimeFromEnv = parseRuntime(process.env.FORGEN_RUNTIME);
+    const runtimeFromProfile = runtimeFromEnv ? null : readProfileDefaultRuntime();
+    const initial = runtimeFromEnv ?? runtimeFromProfile ?? DEFAULT_RUNTIME;
+    const initialSource = runtimeFromEnv
+        ? 'env'
+        : runtimeFromProfile
+            ? 'profile'
+            : 'default';
     const result = {
-        runtime: runtimeFromEnv ?? DEFAULT_RUNTIME,
+        runtime: initial,
         args: [],
-        runtimeSource: runtimeFromEnv ? 'env' : 'default',
+        runtimeSource: initialSource,
     };
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];

package/dist/store/evidence-store.d.ts

@@ -14,6 +14,7 @@ export declare function createEvidence(params: {
     candidate_rule_refs?: string[];
     confidence: number;
     raw_payload?: Record<string, unknown>;
+    host?: 'claude' | 'codex';
 }): Evidence;
 export declare function saveEvidence(evidence: Evidence): void;
 /**

package/dist/store/evidence-store.js

@@ -17,6 +17,24 @@ import { appendLifecycleEvents } from '../engine/lifecycle/meta-reclassifier.js'
 function evidencePath(evidenceId) {
     return path.join(ME_BEHAVIOR, `${evidenceId}.json`);
 }
+/**
+ * 현재 세션이 어느 host 에서 실행되는지 추론 (Multi-Host §4.2).
+ * 1) explicit `params.host`
+ * 2) env var `FORGEN_HOST` (e2e 격리용)
+ * 3) `runtime` env hint
+ * 4) Codex CLI 흔적 (`CODEX_HOME` 또는 `CODEX_SANDBOX_NETWORK_DISABLED`)
+ * 5) default 'claude' (1원칙)
+ */
+function detectHost(explicit) {
+    if (explicit)
+        return explicit;
+    const fromEnv = process.env.FORGEN_HOST;
+    if (fromEnv === 'claude' || fromEnv === 'codex')
+        return fromEnv;
+    if (process.env.CODEX_HOME || process.env.CODEX_SANDBOX_NETWORK_DISABLED)
+        return 'codex';
+    return 'claude';
+}
 export function createEvidence(params) {
     return {
         evidence_id: crypto.randomUUID(),
@@ -29,6 +47,7 @@ export function createEvidence(params) {
         candidate_rule_refs: params.candidate_rule_refs ?? [],
         confidence: params.confidence,
         raw_payload: params.raw_payload ?? {},
+        host: detectHost(params.host),
     };
 }
 /** TEST-4 / RC4: behavior_observation 의 summary 가 의미있는 내용을 담아야 분석 가능. */
@@ -84,8 +103,19 @@ export function appendEvidence(evidence) {
         return { saved: true, t1_events: 0 };
     }
 }
+/**
+ * 기존 evidence 에 host 필드가 없으면 'claude' 로 backfill (Multi-Host §4.2 마이그레이션 정책).
+ * 새 multi-host 도입 이전 데이터는 모두 Claude 에서 발생했음 — 이 backfill 은 무손실.
+ */
+function backfillHost(ev) {
+    if (!ev)
+        return ev;
+    if (ev.host === 'claude' || ev.host === 'codex')
+        return ev;
+    return { ...ev, host: 'claude' };
+}
 export function loadEvidence(evidenceId) {
-    return safeReadJSON(evidencePath(evidenceId), null);
+    return backfillHost(safeReadJSON(evidencePath(evidenceId), null));
 }
 export function loadAllEvidence() {
     if (!fs.existsSync(ME_BEHAVIOR))
@@ -95,8 +125,9 @@ export function loadAllEvidence() {
         if (!file.endsWith('.json'))
             continue;
         const ev = safeReadJSON(path.join(ME_BEHAVIOR, file), null);
-        if (ev)
-            items.push(ev);
+        const filled = backfillHost(ev);
+        if (filled)
+            items.push(filled);
     }
     return items;
 }