@wooojin/forgen 0.4.9 → 0.4.10

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://claude.ai/schemas/claude-plugin.json",
   "name": "forgen",
-  "version": "0.4.9",
+  "version": "0.4.10",
   "description": "Claude Code harness — the more you use Claude, the better it gets",
   "author": {
     "name": "jang-ujin",

package/dist/cli.js

@@ -365,6 +365,14 @@ const commands = [
             await handleMigrate(args);
         },
     },
+    {
+        name: 'regress-map',
+        description: 'Top fix-touched files in the last N days (--days 30 --top 10 --json).',
+        handler: async (args) => {
+            const { handleRegressMap } = await import('./core/regress-map-cli.js');
+            await handleRegressMap(args);
+        },
+    },
     {
         name: 'suppress-rule',
         description: '[alias: rule suppress] Disable a rule by id/prefix. Hard rules refused.',

package/dist/core/doctor.js

@@ -491,12 +491,18 @@ export async function runDoctor(opts = {}) {
     }
     // P4 셀프 가드: fix:feat 비율 30% 초과 시 회귀 패턴 의심 경고.
     try {
-        const { computeFixFeatRatio, formatFixRatio } = await import('./git-stats.js');
+        const { computeFixFeatRatio, formatFixRatio, computeRegressMap } = await import('./git-stats.js');
         const ratio = computeFixFeatRatio();
         if (ratio.available) {
             console.log(`  ${formatFixRatio(ratio)}`);
             if (ratio.exceedsThreshold) {
                 console.log('  ⚠ fix:feat 비율이 임계값을 초과했습니다. "이거 고치면 저거 버그난다" 패턴 의심 — 검증 레이어 invariant 점검 권장.');
+                const map = computeRegressMap(process.cwd(), 30, 3);
+                if (map.available && map.hotspots.length > 0) {
+                    const top = map.hotspots.map((h) => `${h.path} (${h.fixHits})`).join(', ');
+                    console.log(`  → 진앙 후보 top 3: ${top}`);
+                    console.log('  → 전체 보기: forgen regress-map');
+                }
             }
         }
     }
@@ -529,6 +535,36 @@ export async function runDoctor(opts = {}) {
     // [Codex Parity] — parity-result.json 신선도 검사 (v0.4.2 패턴 확장)
     renderCodexParity();
     console.log();
+    // [ψ-long] — within-conversation compound 효과 측정 (v0.4.10)
+    // 측정 시간이 길어 ship-gate 는 advisory. 신선도(<= 14d) + psiLong > 0 만 확인.
+    console.log('  [ψ-long compound]');
+    try {
+        const psiLongPath = path.join(STATE_DIR, 'psi-long-result.json');
+        if (!fs.existsSync(psiLongPath)) {
+            console.log('  ○ no measurement yet — `pnpm --filter @wooojin/forgen-eval psi:long` 권장');
+        }
+        else {
+            const raw = fs.readFileSync(psiLongPath, 'utf-8');
+            const data = JSON.parse(raw);
+            const ageMs = data.at ? Date.now() - new Date(data.at).getTime() : Number.POSITIVE_INFINITY;
+            const ageDays = Math.floor(ageMs / (24 * 60 * 60 * 1000));
+            const psiLong = data.psiLong ?? 0;
+            const passed = !!data.passed;
+            const freshTag = ageDays <= 14 ? 'fresh' : `${ageDays}d stale`;
+            const gateLabel = passed ? '✓ PASS' : '✗ FAIL';
+            console.log(`  ${gateLabel}  ψ_long=${psiLong.toFixed(3)}  N=${data.N ?? '?'}  (${freshTag})`);
+            if (!passed) {
+                console.log('  ⚠ within-session compound 효과 미관측 — correction injection / rule trigger 경로 점검');
+            }
+            else if (ageDays > 14) {
+                console.log('  △ 측정 14일 초과 — 재측정 권장 (`pnpm --filter @wooojin/forgen-eval psi:long`)');
+            }
+        }
+    }
+    catch (e) {
+        console.log(`  Unable to read psi-long state: ${e instanceof Error ? e.message : 'unknown'}`);
+    }
+    console.log();
     // [Summary] — 최종 상태 요약과 복구 액션을 한눈에 보이게
     console.log('  [Summary]');
     if (failedChecks.length === 0) {

package/dist/core/git-stats.d.ts

@@ -34,3 +34,26 @@ export declare function computeFixFeatRatio(cwd?: string, windowSize?: number, t
 export declare function parseGitLog(rawLog: string, windowSize?: number, threshold?: number): FixRatioStats;
 /** 사람용 한 줄 라벨. */
 export declare function formatFixRatio(s: FixRatioStats): string;
+export interface RegressHotspot {
+    path: string;
+    fixHits: number;
+    lastFixSha: string;
+    lastFixDate: string;
+}
+export interface RegressMap {
+    windowDays: number;
+    fixCommits: number;
+    hotspots: RegressHotspot[];
+    available: boolean;
+}
+/**
+ * 지난 N일 동안 fix 커밋이 닿은 파일 hot-list.
+ *
+ * doctor 가 fix:feat 비율로 "회귀 패턴 의심" 시그널은 주지만, 진앙은 안 보여준다.
+ * regress-map 은 fix 커밋의 changed-files 를 카운트해 top-N hotspot 을 추출 →
+ * "이거 고치면 저거 깨진다" 의 *저거* 후보를 한 화면에 노출.
+ *
+ * 제외 scope (fix:feat 와 동일): fix(test|tests|docs|doc) — 노이즈.
+ */
+export declare function computeRegressMap(cwd?: string, windowDays?: number, topN?: number): RegressMap;
+export declare function parseRegressLog(raw: string, windowDays: number, topN: number): RegressMap;

package/dist/core/git-stats.js

@@ -77,3 +77,53 @@ export function formatFixRatio(s) {
     const flag = s.exceedsThreshold ? `  ⚠ over ${thresholdPct}%` : '';
     return `fix:feat ratio    ${pct}%   (${s.fixCount}/${s.fixCount + s.featCount} in last ${s.windowSize})${flag}`;
 }
+/**
+ * 지난 N일 동안 fix 커밋이 닿은 파일 hot-list.
+ *
+ * doctor 가 fix:feat 비율로 "회귀 패턴 의심" 시그널은 주지만, 진앙은 안 보여준다.
+ * regress-map 은 fix 커밋의 changed-files 를 카운트해 top-N hotspot 을 추출 →
+ * "이거 고치면 저거 깨진다" 의 *저거* 후보를 한 화면에 노출.
+ *
+ * 제외 scope (fix:feat 와 동일): fix(test|tests|docs|doc) — 노이즈.
+ */
+export function computeRegressMap(cwd = process.cwd(), windowDays = 30, topN = 10) {
+    try {
+        const since = `--since=${windowDays}.days.ago`;
+        const out = execFileSync('git', ['log', '--no-merges', since, '--name-only', '--pretty=format:%x1fCOMMIT%x1f%h%x1f%cs%x1f%s'], { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 32 * 1024 * 1024 });
+        return parseRegressLog(out, windowDays, topN);
+    }
+    catch {
+        return { windowDays, fixCommits: 0, hotspots: [], available: false };
+    }
+}
+export function parseRegressLog(raw, windowDays, topN) {
+    const blocks = raw.split('\x1fCOMMIT\x1f').slice(1);
+    const counter = new Map();
+    let fixCommits = 0;
+    for (const block of blocks) {
+        const [sha, date, rest = ''] = block.split('\x1f');
+        const nl = rest.indexOf('\n');
+        const subject = nl === -1 ? rest : rest.slice(0, nl);
+        const files = nl === -1 ? [] : rest.slice(nl + 1).split('\n').map((s) => s.trim()).filter(Boolean);
+        const m = subject.match(/^(fix|feat)(?:\(([^)]+)\))?:/);
+        if (!m || m[1] !== 'fix')
+            continue;
+        const scope = (m[2] ?? '').toLowerCase().trim();
+        if (SCOPE_EXCLUSIONS.has(scope))
+            continue;
+        fixCommits++;
+        for (const f of files) {
+            const existing = counter.get(f);
+            if (existing) {
+                existing.fixHits++;
+            }
+            else {
+                counter.set(f, { path: f, fixHits: 1, lastFixSha: sha, lastFixDate: date });
+            }
+        }
+    }
+    const hotspots = Array.from(counter.values())
+        .sort((a, b) => b.fixHits - a.fixHits || a.path.localeCompare(b.path))
+        .slice(0, topN);
+    return { windowDays, fixCommits, hotspots, available: true };
+}

package/dist/core/inspect-cli.js

@@ -8,7 +8,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { loadProfile } from '../store/profile-store.js';
 import { loadAllRules, loadActiveRules } from '../store/rule-store.js';
-import { loadRecentEvidence } from '../store/evidence-store.js';
+import { loadRecentEvidence, loadAllEvidence } from '../store/evidence-store.js';
 import { loadRecentSessions } from '../store/session-state-store.js';
 import * as inspect from '../renderer/inspect-renderer.js';
 import { ME_BEHAVIOR, ME_SOLUTIONS, STATE_DIR } from './paths.js';
@@ -71,6 +71,10 @@ export async function handleInspect(args) {
             }
             console.log('');
         }
+        // ── Receipts: correction → rule → inject ── (v0.4.10)
+        // "내가 forgen 으로 무엇을 얻었나" 한 화면. correction 이 만들어낸 rule 의 lifecycle 을
+        // 묶어 표시 — 주입(inject_count), 마지막 주입 시각, host 분포.
+        await renderReceipts();
         return;
     }
     if (sub === 'rules') {
@@ -157,3 +161,58 @@ export async function handleInspect(args) {
     forgen inspect bypass     [--last N] — 사용자 우회 기록
     forgen inspect drift      [--last N] — stuck-loop force-approve 기록`);
 }
+/**
+ * v0.4.10 Receipts: correction → rule → inject 트리플.
+ *
+ * 사용자 가치 명제("the more you use, the better it knows") 의 receipt.
+ * 1) Top-injected rules (실제로 Claude 에 주입된 룰 N회)
+ * 2) Recent rule births (correction → 새 룰 생성된 이력)
+ * 3) Host 균형 (claude vs codex)
+ */
+async function renderReceipts() {
+    const rules = loadAllRules();
+    const evidence = loadAllEvidence();
+    const injected = rules
+        .filter((r) => r.lifecycle && (r.lifecycle.inject_count ?? 0) > 0)
+        .sort((a, b) => (b.lifecycle?.inject_count ?? 0) - (a.lifecycle?.inject_count ?? 0))
+        .slice(0, 5);
+    console.log('── Receipts (correction → rule → inject) ──');
+    if (injected.length === 0) {
+        console.log('  No injected rules yet. Trigger a session to start the loop.');
+    }
+    else {
+        console.log('  Top injected rules:');
+        for (const r of injected) {
+            const count = r.lifecycle?.inject_count ?? 0;
+            const last = (r.lifecycle?.last_inject_at ?? '').slice(0, 10) || 'never';
+            const trigger = (r.trigger ?? '').slice(0, 48);
+            console.log(`    ${String(count).padStart(3)}×  [${r.category}] ${trigger} (last ${last})`);
+        }
+    }
+    // Recent rule births: 마지막 7일 내 created_at 인 룰 (T = correction → rule)
+    const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
+    const recentRules = rules
+        .filter((r) => new Date(r.created_at).getTime() >= sevenDaysAgo)
+        .sort((a, b) => b.created_at.localeCompare(a.created_at))
+        .slice(0, 3);
+    if (recentRules.length > 0) {
+        console.log('  New rules (last 7 days):');
+        for (const r of recentRules) {
+            const dateStr = r.created_at.slice(0, 10);
+            console.log(`    + [${r.category}/${r.strength}] ${(r.trigger ?? '').slice(0, 48)}  (${dateStr})`);
+        }
+    }
+    // Host 균형 — multi-host 가치 명제의 receipt
+    const hostCount = { claude: 0, codex: 0 };
+    for (const e of evidence) {
+        const h = (e.host ?? 'claude');
+        hostCount[h] = (hostCount[h] ?? 0) + 1;
+    }
+    const total = hostCount.claude + hostCount.codex;
+    if (total > 0) {
+        const cpct = Math.round((hostCount.claude / total) * 100);
+        const xpct = 100 - cpct;
+        console.log(`  Host balance: claude ${cpct}% · codex ${xpct}% (n=${total})`);
+    }
+    console.log('');
+}

package/dist/core/regress-map-cli.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `forgen regress-map` — fix:feat 비율 워닝을 actionable 로.
+ *
+ * doctor 의 36% 시그널을 받아 "어느 파일이 진앙인가" 를 한 화면에 보여준다.
+ * `--days N` (기본 30), `--top N` (기본 10), `--json` 지원.
+ */
+export declare function handleRegressMap(args?: string[]): Promise<void>;

package/dist/core/regress-map-cli.js

@@ -0,0 +1,59 @@
+/**
+ * `forgen regress-map` — fix:feat 비율 워닝을 actionable 로.
+ *
+ * doctor 의 36% 시그널을 받아 "어느 파일이 진앙인가" 를 한 화면에 보여준다.
+ * `--days N` (기본 30), `--top N` (기본 10), `--json` 지원.
+ */
+import { computeRegressMap, formatFixRatio, computeFixFeatRatio } from './git-stats.js';
+function parseIntArg(args, flag, fallback) {
+    const i = args.indexOf(flag);
+    if (i === -1)
+        return fallback;
+    const v = Number.parseInt(args[i + 1] ?? '', 10);
+    return Number.isFinite(v) && v > 0 ? v : fallback;
+}
+export async function handleRegressMap(args = []) {
+    const days = parseIntArg(args, '--days', 30);
+    const top = parseIntArg(args, '--top', 10);
+    const asJson = args.includes('--json');
+    const map = computeRegressMap(process.cwd(), days, top);
+    const ratio = computeFixFeatRatio(process.cwd(), 30);
+    if (asJson) {
+        process.stdout.write(JSON.stringify({ fixFeat: ratio, regress: map }, null, 2));
+        process.stdout.write('\n');
+        return;
+    }
+    if (!map.available) {
+        console.log('regress-map: git unavailable or no commits in window.');
+        return;
+    }
+    console.log('  ┌─ forgen regress-map ───────────────────────────────────┐');
+    console.log(`  │ window: last ${map.windowDays} days · fix commits: ${map.fixCommits}`.padEnd(60) + '│');
+    if (ratio.available) {
+        console.log(`  │ ${formatFixRatio(ratio)}`.padEnd(60) + '│');
+    }
+    console.log('  ├────────────────────────────────────────────────────────┤');
+    if (map.hotspots.length === 0) {
+        console.log('  │ No fix-touched files in window.'.padEnd(60) + '│');
+    }
+    else {
+        console.log('  │ rank  hits  file (last fix · sha)'.padEnd(60) + '│');
+        map.hotspots.forEach((h, i) => {
+            const rank = String(i + 1).padStart(2, ' ');
+            const hits = String(h.fixHits).padStart(3, ' ');
+            const meta = `${h.lastFixDate} ${h.lastFixSha}`;
+            const pathBudget = 56 - 4 - 4 - meta.length - 3;
+            const shownPath = h.path.length > pathBudget
+                ? '…' + h.path.slice(-(pathBudget - 1))
+                : h.path;
+            const line = `  ${rank}    ${hits}  ${shownPath}  (${meta})`;
+            console.log(`  │ ${line}`.padEnd(60) + '│');
+        });
+    }
+    console.log('  └────────────────────────────────────────────────────────┘');
+    if (ratio.available && ratio.exceedsThreshold) {
+        console.log('');
+        console.log('  ⚠ fix:feat 비율 초과 — 상위 파일의 invariant/테스트 보강 권장.');
+        console.log('  → 같은 파일이 3회 이상 fix 닿았다면 책임 분리 또는 회귀 테스트 우선.');
+    }
+}

package/dist/fgx.d.ts

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 /**
  * fgx — forgen --dangerously-skip-permissions 의 단축 명령
- * 모든 인자를 그대로 전달하되, --dangerously-skip-permissions 를 자동 주입
+ *
+ * 기본 동작: 모든 인자를 Claude(또는 Codex) 로 그대로 전달 + 권한 우회 플래그 자동 주입.
+ * v0.4.10: forgen 서브커맨드(status/init/install/maintenance/compound 등)는
+ *          Claude 로 안 넘기고 cli.js 로 라우팅 (사용자 혼동 갭 해소).
  */
 export {};

package/dist/fgx.js

@@ -1,22 +1,51 @@
 #!/usr/bin/env node
 /**
  * fgx — forgen --dangerously-skip-permissions 의 단축 명령
- * 모든 인자를 그대로 전달하되, --dangerously-skip-permissions 를 자동 주입
+ *
+ * 기본 동작: 모든 인자를 Claude(또는 Codex) 로 그대로 전달 + 권한 우회 플래그 자동 주입.
+ * v0.4.10: forgen 서브커맨드(status/init/install/maintenance/compound 등)는
+ *          Claude 로 안 넘기고 cli.js 로 라우팅 (사용자 혼동 갭 해소).
  */
 import { resolveLaunchContext } from './services/session.js';
 import { prepareHarness, isFirstRun } from './core/harness.js';
 import { spawnClaude } from './core/spawn.js';
 import { getHostRuntime } from './host/host-runtime.js';
 const args = process.argv.slice(2);
-// 이미 포함되어 있으면 중복 추가하지 않음
-const launchContext = resolveLaunchContext(args);
-const runtime = launchContext.runtime;
-const skipFlag = getHostRuntime(runtime).dangerousSkipFlag;
-const launchArgs = [...launchContext.args];
-if (!launchArgs.includes(skipFlag)) {
-    launchArgs.unshift(skipFlag);
+// v0.4.10: forgen 서브커맨드 인벤토리. src/cli.ts 의 commands[] 와 sync 유지.
+// 첫 비-플래그 인자가 이 집합에 들어가면 forgen cli 로 라우팅.
+const FORGEN_SUBCOMMANDS = new Set([
+    'forge', 'compound', 'skill', 'dashboard', 'learn', 'me', 'statusline',
+    'config', 'mcp', 'init', 'install', 'status', 'maintenance', 'parity',
+    'notepad', 'inspect', 'onboarding', 'doctor', 'uninstall', 'rule',
+    'classify-enforce', 'rule-meta-scan', 'lifecycle-scan',
+    'stats', 'last-block', 'recall', 'migrate', 'suppress-rule', 'activate-rule',
+    'regress-map',
+    // 메타 명령도 cli.ts 가 처리 (fgx claude spawn 으로는 의미 없음)
+    'help', '--help', '-h', '--version', '-V',
+]);
+function findFirstSubcommand(rawArgs) {
+    for (const a of rawArgs) {
+        if (FORGEN_SUBCOMMANDS.has(a))
+            return a;
+        // 첫 비-플래그 인자를 보면 더 이상 후보 X (e.g. ['my-prompt', 'status'] → null)
+        if (!a.startsWith('-'))
+            return null;
+    }
+    return null;
 }
-async function main() {
+async function routeToCli() {
+    // cli.js 가 process.argv.slice(2) 를 직접 사용. fgx 가 받은 args 그대로 전달됨.
+    // top-level main() 이 모듈 로드 시 실행 + process.exit 처리.
+    await import('./cli.js');
+}
+async function runClaudeLauncher() {
+    const launchContext = resolveLaunchContext(args);
+    const runtime = launchContext.runtime;
+    const skipFlag = getHostRuntime(runtime).dangerousSkipFlag;
+    const launchArgs = [...launchContext.args];
+    if (!launchArgs.includes(skipFlag)) {
+        launchArgs.unshift(skipFlag);
+    }
     // Security warning — fgx bypasses all Claude Code permission checks.
     //
     // Audit fix #3 (2026-04-21): The warning banner is shown regardless of
@@ -28,7 +57,6 @@ async function main() {
     console.warn(`  ⚠  ${getHostRuntime(runtime).displayName} will execute tools without asking for confirmation.`);
     console.warn('  ⚠  Use only in trusted environments. If your profile trust policy is');
     console.warn('  ⚠  "가드레일 우선" or "승인 완화", consider `forgen` (no flag) instead.\n');
-    // fgx는 서브커맨드 없이 바로 Claude Code 실행 전용
     const firstRun = isFirstRun();
     if (firstRun) {
         console.log('\n  Forgen — Setting up for the first time.\n');
@@ -49,6 +77,14 @@ async function main() {
     console.log(`[forgen] Starting ${runtimeLabel}...\n`);
     await spawnClaude(launchArgs, context, runtime);
 }
+async function main() {
+    const sub = findFirstSubcommand(args);
+    if (sub !== null) {
+        await routeToCli();
+        return;
+    }
+    await runClaudeLauncher();
+}
 main().catch((err) => {
     console.error('[forgen] Error:', err instanceof Error ? err.message : err);
     process.exit(1);

package/dist/store/evidence-store.js

@@ -20,10 +20,14 @@ function evidencePath(evidenceId) {
 /**
  * 현재 세션이 어느 host 에서 실행되는지 추론 (Multi-Host §4.2).
  * 1) explicit `params.host`
- * 2) env var `FORGEN_HOST` (e2e 격리용)
- * 3) `runtime` env hint
+ * 2) env var `FORGEN_HOST` (e2e 격리용 / MCP server 가 --host=codex 받으면 set)
+ * 3) `FORGEN_RUNTIME` env (config-injector.ts:479 가 harness spawn 시 주입)
  * 4) Codex CLI 흔적 (`CODEX_HOME` 또는 `CODEX_SANDBOX_NETWORK_DISABLED`)
  * 5) default 'claude' (1원칙)
+ *
+ * v0.4.10 fix: 3번 fallback 이 주석에만 있고 코드에 없어서 Codex harness 세션의
+ * auto-compound-runner 가 생성하는 behavior_observation evidence 가 전부 'claude'
+ * 로 잘못 태깅 → doctor 가 98/2 격차 경고. FORGEN_RUNTIME 을 직접 읽도록 추가.
  */
 function detectHost(explicit) {
     if (explicit)
@@ -31,6 +35,9 @@ function detectHost(explicit) {
     const fromEnv = process.env.FORGEN_HOST;
     if (fromEnv === 'claude' || fromEnv === 'codex')
         return fromEnv;
+    const fromRuntime = process.env.FORGEN_RUNTIME;
+    if (fromRuntime === 'claude' || fromRuntime === 'codex')
+        return fromRuntime;
     if (process.env.CODEX_HOME || process.env.CODEX_SANDBOX_NETWORK_DISABLED)
         return 'codex';
     return 'claude';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wooojin/forgen",
-  "version": "0.4.9",
+  "version": "0.4.10",
   "preferGlobal": true,
   "main": "dist/lib.js",
   "types": "./dist/lib.d.ts",

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://claude.ai/schemas/claude-plugin.json",
   "name": "forgen",
-  "version": "0.4.9",
+  "version": "0.4.10",
   "description": "Claude Code harness — the more you use Claude, the better it gets",
   "author": {
     "name": "jang-ujin",