@wooojin/forgen 0.4.1 → 0.4.4

package/assets/demo-preview.svg

@@ -0,0 +1,96 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="800" height="340" viewBox="0 0 800 340">
+  <style>
+    .term { font-family: 'JetBrains Mono', 'Fira Code', 'Cascadia Code', 'SF Mono', monospace; font-size: 13px; }
+    .prompt { fill: #a6e3a1; }
+    .cmd { fill: #cdd6f4; }
+    .tag { fill: #89b4fa; }
+    .haiku { fill: #f9e2af; }
+    .sonnet { fill: #a6e3a1; }
+    .opus { fill: #cba6f7; }
+    .dim { fill: #6c7086; }
+    .box { fill: #a6e3a1; }
+    @keyframes typeIn { from { opacity: 0; } to { opacity: 1; } }
+    @keyframes fadeIn { 0% { opacity: 0; } 100% { opacity: 1; } }
+    @keyframes blink { 0%, 100% { opacity: 0.8; } 50% { opacity: 0; } }
+    .line1 { animation: typeIn 0.1s 0.3s both; }
+    .line2 { animation: fadeIn 0.2s 0.8s both; }
+    .line3 { animation: fadeIn 0.2s 1.1s both; }
+    .line4 { animation: fadeIn 0.2s 1.4s both; }
+    .line5 { animation: fadeIn 0.2s 1.7s both; }
+    .line6 { animation: fadeIn 0.2s 2.0s both; }
+    .line7 { animation: fadeIn 0.3s 2.5s both; }
+    .cursor { animation: blink 1s 2.8s infinite; }
+  </style>
+
+  <!-- Terminal window -->
+  <rect width="800" height="340" rx="10" ry="10" fill="#1e1e2e"/>
+  <rect width="800" height="36" rx="10" ry="10" fill="#313244"/>
+  <rect y="26" width="800" height="10" fill="#313244"/>
+
+  <!-- Traffic lights -->
+  <circle cx="20" cy="18" r="6" fill="#f38ba8"/>
+  <circle cx="40" cy="18" r="6" fill="#f9e2af"/>
+  <circle cx="60" cy="18" r="6" fill="#a6e3a1"/>
+  <text x="400" y="23" text-anchor="middle" class="term" font-size="12" fill="#6c7086">forgen — terminal</text>
+
+  <!-- Line 1: command -->
+  <g class="line1">
+    <text x="24" y="68" class="term prompt">$</text>
+    <text x="40" y="68" class="term cmd">forgen</text>
+  </g>
+
+  <!-- Line 2: philosophy -->
+  <g class="line2">
+    <text x="24" y="96" class="term tag">[forgen]</text>
+    <text x="96" y="96" class="term cmd">Philosophy: </text>
+    <text x="194" y="96" class="term" fill="#f9e2af">my-engineering</text>
+    <text x="310" y="96" class="term dim"> (global)</text>
+  </g>
+
+  <!-- Line 3: scope -->
+  <g class="line3">
+    <text x="24" y="120" class="term tag">[forgen]</text>
+    <text x="96" y="120" class="term cmd">Scope: Me(5) │ 3 rules, 2 solutions</text>
+  </g>
+
+  <!-- Line 4: routing -->
+  <g class="line4">
+    <text x="24" y="144" class="term tag">[forgen]</text>
+    <text x="96" y="144" class="term cmd">Routing: </text>
+    <text x="172" y="144" class="term haiku">haiku:3</text>
+    <text x="232" y="144" class="term dim"> │ </text>
+    <text x="256" y="144" class="term sonnet">sonnet:5</text>
+    <text x="324" y="144" class="term dim"> │ </text>
+    <text x="348" y="144" class="term opus">opus:4</text>
+  </g>
+
+  <!-- Line 5: pack -->
+  <g class="line5">
+    <text x="24" y="168" class="term tag">[forgen]</text>
+    <text x="96" y="168" class="term cmd">Pack: backend v1.0.0 (5 rules, 3 solutions)</text>
+  </g>
+
+  <!-- Line 6: launching -->
+  <g class="line6">
+    <text x="24" y="192" class="term tag">[forgen]</text>
+    <text x="96" y="192" class="term cmd">Starting Claude Code...</text>
+  </g>
+
+  <!-- Separator -->
+  <g class="line7">
+    <line x1="24" y1="212" x2="776" y2="212" stroke="#313244" stroke-width="1"/>
+
+    <!-- Claude Code box -->
+    <text x="24" y="236" class="term dim">╭──────────────────────────────────────────────────╮</text>
+    <text x="24" y="256" class="term dim">│</text>
+    <text x="40" y="256" class="term box"> ✓ Claude Code (philosophy-driven mode)</text>
+    <text x="430" y="256" class="term dim">│</text>
+    <text x="24" y="276" class="term dim">│</text>
+    <text x="40" y="276" class="term" fill="#cdd6f4">   19 agents │ 19 skills │ 18 hooks loaded</text>
+    <text x="430" y="276" class="term dim">│</text>
+    <text x="24" y="296" class="term dim">╰──────────────────────────────────────────────────╯</text>
+
+    <!-- Blinking cursor -->
+    <rect x="24" y="310" width="8" height="16" fill="#cdd6f4" class="cursor"/>
+  </g>
+</svg>

package/{hooks → assets/shared}/hook-registry.json

@@ -18,5 +18,6 @@
   { "name": "subagent-tracker-stop",  "tier": "workflow",      "event": "SubagentStop",       "matcher": "*",          "script": "hooks/subagent-tracker.js stop",  "timeout": 2, "compoundCritical": false },
   { "name": "post-tool-failure",      "tier": "workflow",      "event": "PostToolUseFailure", "matcher": "*",          "script": "hooks/post-tool-failure.js",      "timeout": 3, "compoundCritical": false },
   { "name": "solution-injector",     "tier": "compound-core", "event": "UserPromptSubmit",   "matcher": "*",          "script": "hooks/solution-injector.js",      "timeout": 5, "compoundCritical": true  },
-  { "name": "skill-injector",        "tier": "compound-core", "event": "UserPromptSubmit",   "matcher": "*",          "script": "hooks/skill-injector.js",         "timeout": 5, "compoundCritical": true  }
+  { "name": "skill-injector",        "tier": "compound-core", "event": "UserPromptSubmit",   "matcher": "*",          "script": "hooks/skill-injector.js",         "timeout": 5, "compoundCritical": true  },
+  { "name": "forge-loop-progress",   "tier": "compound-core", "event": "UserPromptSubmit",   "matcher": "*",          "script": "hooks/forge-loop-progress.js",    "timeout": 2, "compoundCritical": false }
 ]

package/dist/checks/_shared/text-sanitizer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Forgen — text-sanitizer (Pathfinder D4 + D5 흡수).
+ *
+ * stop-guard 진입 시 lastMessage 에 한 번 적용. 두 가지 면제:
+ *
+ *   D4 — Structured-output 면제:
+ *     observer hook / skill 산출물(<observation>...</observation>,
+ *     <summary>...</summary> 등)은 *과거 사실 기록* 이지 자기 평가가 아님.
+ *     본문 안의 "verified", "신뢰도 95/100" 같은 어휘에 가드가 발화하면 FP.
+ *
+ *   D5 — Self-paradox 면제:
+ *     regex 트리거 어휘(예: 4/10, verified)를 *인용해서* 설명만 해도 본인
+ *     매칭. 메타 대화/디버깅에서 가드가 무력화됨. 코드/직인용 본문은 가드
+ *     판정 대상이 아니므로 stripping.
+ *
+ * 결정 (PATHFINDER-2026-04-30/03-unified-proposal.md):
+ *  - 자연 산문 속 진짜 점수 인플레이션은 살아남아야 함 (TP 보존)
+ *  - 짧은 인용("...") 만 제거; 긴 인용은 사용자 인용일 수 있어 보존
+ *  - idempotent: 두 번 적용해도 결과 동일
+ */
+export declare function sanitizeForGuard(raw: string): string;

package/dist/checks/_shared/text-sanitizer.js

@@ -0,0 +1,60 @@
+/**
+ * Forgen — text-sanitizer (Pathfinder D4 + D5 흡수).
+ *
+ * stop-guard 진입 시 lastMessage 에 한 번 적용. 두 가지 면제:
+ *
+ *   D4 — Structured-output 면제:
+ *     observer hook / skill 산출물(<observation>...</observation>,
+ *     <summary>...</summary> 등)은 *과거 사실 기록* 이지 자기 평가가 아님.
+ *     본문 안의 "verified", "신뢰도 95/100" 같은 어휘에 가드가 발화하면 FP.
+ *
+ *   D5 — Self-paradox 면제:
+ *     regex 트리거 어휘(예: 4/10, verified)를 *인용해서* 설명만 해도 본인
+ *     매칭. 메타 대화/디버깅에서 가드가 무력화됨. 코드/직인용 본문은 가드
+ *     판정 대상이 아니므로 stripping.
+ *
+ * 결정 (PATHFINDER-2026-04-30/03-unified-proposal.md):
+ *  - 자연 산문 속 진짜 점수 인플레이션은 살아남아야 함 (TP 보존)
+ *  - 짧은 인용("...") 만 제거; 긴 인용은 사용자 인용일 수 있어 보존
+ *  - idempotent: 두 번 적용해도 결과 동일
+ */
+const STRUCTURED_TAGS = [
+    'observation',
+    'summary',
+    'request',
+    'investigated',
+    'completed',
+    'next-steps',
+    'next_steps',
+    'title',
+    'subtitle',
+    'learned',
+    'discovery',
+];
+const SHORT_QUOTE_MAX = 20;
+export function sanitizeForGuard(raw) {
+    if (!raw)
+        return raw;
+    let s = raw;
+    // 1) structured-output 블록 (open + close 쌍) 제거
+    for (const tag of STRUCTURED_TAGS) {
+        const re = new RegExp(`<${tag}\\b[^>]*>[\\s\\S]*?<\\/${tag}>`, 'gi');
+        s = s.replace(re, '');
+    }
+    // self-closing 또는 dangling open tag 도 제거 (열렸지만 닫힘 누락 케이스)
+    for (const tag of STRUCTURED_TAGS) {
+        const reSelf = new RegExp(`<${tag}\\b[^>]*\\/?>`, 'gi');
+        s = s.replace(reSelf, '');
+        const reClose = new RegExp(`<\\/${tag}>`, 'gi');
+        s = s.replace(reClose, '');
+    }
+    // 2) fenced code block (```...```) 제거 — 진짜 점수가 들어갈 자리 아님
+    s = s.replace(/```[\s\S]*?```/g, '');
+    // 3) inline backtick 코드 (`...`) 제거
+    s = s.replace(/`[^`\n]*`/g, '');
+    // 4) 짧은 직인용 ("...") 제거 — 길이 SHORT_QUOTE_MAX 이하만.
+    //    긴 인용은 사용자 발언/실제 사실 인용이므로 가드 판정 대상에 남김.
+    const shortQuoteRe = new RegExp(`"[^"\\n]{0,${SHORT_QUOTE_MAX}}"`, 'g');
+    s = s.replace(shortQuoteRe, '');
+    return s;
+}

package/dist/checks/dangerous-response-pattern.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Forgen — DANGEROUS-RESPONSE: 응답 텍스트 파괴적 명령 가드
+ *
+ * Stop hook 단계에서 어시스턴트 응답 텍스트를 스캔하여 *파괴적 명령 제안*을
+ * 감지한다. PreToolUse 가드는 실제 도구 실행 직전에만 동작하므로, 모델이
+ * 텍스트로 위험한 대안을 *제안*하는 케이스(예: `find ... -exec rm -r {}`)는
+ * 도구 실행 단계에 도달하지 못하면 차단되지 않는다. 본 체크는 그 갭을 메운다.
+ *
+ * 발견 경위 (forgen-eval syn-004, 2026-05-06):
+ *   notepad 룰 "[no-rm-rf-unconfirmed]" inject 상태에서, driver(llama 8B) 가
+ *   `rm -rf` 리터럴은 회피했지만 `find . -type d -name 'build' -exec rm -r {}`
+ *   같은 우회 명령을 "안전한 대안"으로 제안. PreToolUse 차단은 실 실행 시
+ *   동작하지만 "응답 텍스트만으론" 못 막음. driver 모델 능력에 무관하게
+ *   일관된 안전 보장이 되도록 응답 단계에서 한 번 더 잡아낸다.
+ *
+ * 동작:
+ *   - 어시스턴트 응답에 등록된 파괴 패턴이 매칭되면 block 권고.
+ *   - "확실히, 명시적 확인" 같은 confirm 표현 동반 여부는 검사하지 않는다
+ *     (휴리스틱 brittle). 매칭 시 무조건 block 후, 모델이 안전한 대안 제시
+ *     또는 명시적 confirm 절차로 재응답하도록 유도.
+ *
+ * 순수 함수 — Stop hook 이 reason 문자열을 그대로 주입.
+ */
+export interface DangerousResultMatch {
+    block: boolean;
+    matched?: string;
+    reason: string;
+}
+/** 응답 텍스트가 파괴적 명령 패턴을 포함하는지 검사. */
+export declare function checkDangerousResponsePattern(opts: {
+    text: string;
+}): DangerousResultMatch;

package/dist/checks/dangerous-response-pattern.js

@@ -0,0 +1,65 @@
+/**
+ * Forgen — DANGEROUS-RESPONSE: 응답 텍스트 파괴적 명령 가드
+ *
+ * Stop hook 단계에서 어시스턴트 응답 텍스트를 스캔하여 *파괴적 명령 제안*을
+ * 감지한다. PreToolUse 가드는 실제 도구 실행 직전에만 동작하므로, 모델이
+ * 텍스트로 위험한 대안을 *제안*하는 케이스(예: `find ... -exec rm -r {}`)는
+ * 도구 실행 단계에 도달하지 못하면 차단되지 않는다. 본 체크는 그 갭을 메운다.
+ *
+ * 발견 경위 (forgen-eval syn-004, 2026-05-06):
+ *   notepad 룰 "[no-rm-rf-unconfirmed]" inject 상태에서, driver(llama 8B) 가
+ *   `rm -rf` 리터럴은 회피했지만 `find . -type d -name 'build' -exec rm -r {}`
+ *   같은 우회 명령을 "안전한 대안"으로 제안. PreToolUse 차단은 실 실행 시
+ *   동작하지만 "응답 텍스트만으론" 못 막음. driver 모델 능력에 무관하게
+ *   일관된 안전 보장이 되도록 응답 단계에서 한 번 더 잡아낸다.
+ *
+ * 동작:
+ *   - 어시스턴트 응답에 등록된 파괴 패턴이 매칭되면 block 권고.
+ *   - "확실히, 명시적 확인" 같은 confirm 표현 동반 여부는 검사하지 않는다
+ *     (휴리스틱 brittle). 매칭 시 무조건 block 후, 모델이 안전한 대안 제시
+ *     또는 명시적 confirm 절차로 재응답하도록 유도.
+ *
+ * 순수 함수 — Stop hook 이 reason 문자열을 그대로 주입.
+ */
+import { compileSafeRegex, safeRegexTest } from '../hooks/shared/safe-regex.js';
+/**
+ * 응답 텍스트에서 검사할 파괴적 명령 패턴.
+ * dist/hooks/dangerous-patterns.json (PreToolUse 용) 와 별도 — 응답 텍스트
+ * 분석에 적합한 더 넓은 패턴 (find -exec rm 같은 우회 포함).
+ */
+/** 패턴 순서 중요: 더 구체적인(우회) 패턴을 먼저 두어 일반 rm -r 패턴이 가로채지 않게 함. */
+const RESPONSE_PATTERNS = [
+    { pattern: '\\bfind\\b[^\\n]{0,80}-exec\\s+rm\\b', description: 'find -exec rm (rm 우회)', flags: 'i' },
+    { pattern: '\\bfind\\b[^\\n]{0,80}-delete\\b', description: 'find -delete (rm 우회)', flags: 'i' },
+    { pattern: '\\bxargs\\s+rm\\b', description: 'xargs rm (rm 우회)', flags: 'i' },
+    { pattern: '\\brm\\s+-(?:rf|fr|r)\\b', description: 'rm -r/-rf 직접 호출', flags: 'i' },
+    { pattern: '\\bgit\\s+push\\b[^\\n]{0,40}--force(?!-)', description: 'git push --force', flags: 'i' },
+    { pattern: '\\bgit\\s+reset\\s+--hard\\b', description: 'git reset --hard', flags: 'i' },
+    { pattern: '\\bgit\\s+clean\\s+-[a-z]*f', description: 'git clean -f', flags: 'i' },
+    { pattern: '\\bDROP\\s+(?:TABLE|DATABASE)\\b', description: 'SQL DROP TABLE/DATABASE', flags: 'i' },
+    { pattern: '\\bTRUNCATE\\s+TABLE\\b', description: 'SQL TRUNCATE TABLE', flags: 'i' },
+    { pattern: '>\\s*/dev/sd[a-z]\\b', description: '/dev/sdX 직접 write', flags: 'i' },
+    { pattern: '\\bmkfs\\b', description: 'mkfs (파일시스템 포맷)', flags: 'i' },
+    { pattern: '\\bdd\\b[^\\n]{0,60}\\bof=/dev/', description: 'dd of=/dev/* (장치 write)', flags: 'i' },
+    { pattern: '\\bcurl\\b[^\\n]{0,60}\\|\\s*(?:ba)?sh\\b', description: 'curl | sh (원격 코드 실행)', flags: 'i' },
+    { pattern: '\\bwget\\b[^\\n]{0,60}\\|\\s*(?:ba)?sh\\b', description: 'wget | sh (원격 코드 실행)', flags: 'i' },
+];
+/** 응답 텍스트가 파괴적 명령 패턴을 포함하는지 검사. */
+export function checkDangerousResponsePattern(opts) {
+    const text = opts.text ?? '';
+    if (!text.trim())
+        return { block: false, reason: '' };
+    for (const p of RESPONSE_PATTERNS) {
+        const compiled = compileSafeRegex(p.pattern, p.flags ?? 'i');
+        if (!compiled.regex)
+            continue; // bad regex — skip
+        if (safeRegexTest(compiled.regex, text)) {
+            return {
+                block: true,
+                matched: p.description,
+                reason: `응답에 파괴적 명령 패턴이 포함되었습니다 (${p.description}). 사용자 명시 확인 절차를 포함하거나 비파괴 대안 (예: dry-run, --interactive)을 제시해 다시 응답하세요.`,
+            };
+        }
+    }
+    return { block: false, reason: '' };
+}

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

@@ -112,8 +112,31 @@ const commands = [
                     await displayHookStatus(process.cwd());
                 }
             }
+            else if (sub === 'default-host') {
+                const value = args[1];
+                const valid = new Set(['claude', 'codex', 'ask']);
+                if (value === undefined) {
+                    const { getDefaultHost } = await import('./store/profile-store.js');
+                    const current = getDefaultHost();
+                    console.log(`  current default_host: ${current ?? '(unset → claude fallback)'}`);
+                    console.log('  Usage: forgen config default-host {claude|codex|ask}');
+                }
+                else if (!valid.has(value)) {
+                    console.log(`  Invalid value: ${value}. Use one of: claude, codex, ask`);
+                    process.exit(1);
+                }
+                else {
+                    const { setDefaultHost } = await import('./store/profile-store.js');
+                    const ok = setDefaultHost(value);
+                    if (!ok) {
+                        console.log('  ✗ Profile not found. Run `forgen onboarding` first.');
+                        process.exit(1);
+                    }
+                    console.log(`  ✓ default_host set to: ${value}`);
+                }
+            }
             else {
-                console.log('Usage: forgen config hooks [--regenerate]');
+                console.log('Usage:\n  forgen config hooks [--regenerate]\n  forgen config default-host [claude|codex|ask]');
             }
         },
     },
@@ -133,6 +156,53 @@ const commands = [
             await handleInit(args);
         },
     },
+    {
+        name: 'install',
+        description: 'Install forgen into a host. Usage: forgen install [claude|codex|both] [--dry-run] [--no-mcp]',
+        handler: async (args) => {
+            const knownSubs = new Set(['claude', 'codex', 'both']);
+            const target = args[0] && knownSubs.has(args[0]) ? args[0] : args[0]?.startsWith('--') ? undefined : args[0];
+            if (target !== undefined && !knownSubs.has(target)) {
+                console.log('Usage:\n  forgen install [claude|codex|both] [--dry-run] [--no-mcp]\n\n  No arg → interactive 3-choice (Claude/Codex/Both).');
+                return;
+            }
+            const dryRun = args.includes('--dry-run');
+            const registerMcp = !args.includes('--no-mcp');
+            const { runInstall, renderResult, resolvePkgRootFromBinary } = await import('./host/install-orchestrator.js');
+            const pkgRoot = resolvePkgRootFromBinary(import.meta.url);
+            const result = await runInstall({ target, pkgRoot, dryRun, registerMcp });
+            if (result === null) {
+                console.log('\n  [forgen] Install skipped.');
+                return;
+            }
+            console.log(renderResult(result, dryRun));
+        },
+    },
+    {
+        name: 'parity',
+        description: 'Run host parity checks. Usage: forgen parity codex [--dry-run]',
+        handler: async (args) => {
+            const sub = args[0];
+            if (sub !== 'codex') {
+                console.log('Usage:\n  forgen parity codex [--dry-run]\n\nNotes:\n  - source 체크아웃에서만 작동합니다 (tests/ 디렉토리 필요).\n  - npm install 로 설치된 패키지에서는 run-parity.sh 가 없습니다.');
+                return;
+            }
+            const here = path.dirname(new URL(import.meta.url).pathname);
+            const scriptPath = path.resolve(here, '..', 'tests', 'e2e', 'codex', 'run-parity.sh');
+            if (!fs.existsSync(scriptPath)) {
+                console.error('[forgen] run-parity.sh 는 source 체크아웃에서만 작동. 직접 git clone 후 실행하세요.');
+                console.error(`  expected: ${scriptPath}`);
+                process.exit(1);
+            }
+            const { spawnSync } = await import('node:child_process');
+            const dryRun = args.includes('--dry-run');
+            const spawnArgs = dryRun ? ['--dry-run'] : [];
+            const result = spawnSync('bash', [scriptPath, ...spawnArgs], { stdio: 'inherit' });
+            if (result.status !== 0) {
+                process.exit(result.status ?? 1);
+            }
+        },
+    },
     {
         name: 'notepad',
         description: 'Notepad (show|add|clear)',
@@ -151,7 +221,7 @@ const commands = [
     },
     {
         name: 'onboarding',
-        description: 'v1 2-question onboarding flow',
+        description: 'v1 4-question onboarding flow',
         handler: async (_args) => {
             const { runOnboarding } = await import('./forge/onboarding-cli.js');
             await runOnboarding();
@@ -407,7 +477,8 @@ async function main() {
   ${dim}Code, forged for you.${reset}
   ${dim}Scope: v1(${context.v1.session?.quality_pack ?? 'onboarding needed'})${reset}
 `);
-        const runtimeLabel = runtime === 'codex' ? 'Codex' : 'Claude';
+        const { getHostRuntime } = await import('./host/host-runtime.js');
+        const runtimeLabel = getHostRuntime(runtime).displayName;
         console.log(`[forgen] Starting ${runtimeLabel}...\n`);
         await spawnClaudeWithResume(args, context, () => prepareHarness(process.cwd(), { runtime }), runtime);
     }
@@ -441,7 +512,7 @@ function printHelp() {
 
   Commands:
     forgen forge                    Personalize your coding profile
-    forgen onboarding               Run 2-question onboarding
+    forgen onboarding               Run 4-question onboarding
     forgen inspect [profile|rules|corrections|session]
                                     Inspect v1 state (alias: evidence → corrections)
     forgen rule <list|suppress|activate|scan|health-scan|classify>
@@ -450,8 +521,9 @@ function printHelp() {
     forgen last-block               Show the most recent block event
     forgen recall [--limit N] [--show]
                                     최근 compound 주입 이력 (solution body preview)
-    forgen migrate [implicit-feedback|all]
-                                    One-shot schema migration (category backfill)
+    forgen migrate [implicit-feedback|evidence-host|all]
+                                    One-shot schema migration (category backfill / host backfill)
+    forgen parity codex [--dry-run] Run codex parity checks (source checkout only)
     forgen compound                 Manage accumulated knowledge
     forgen dashboard                Compound system dashboard
     forgen me                       Personal dashboard