@wooojin/forgen 0.4.9 → 0.4.11

package/dist/core/health-cli.js

@@ -0,0 +1,86 @@
+/**
+ * forgen health — single-line health score (0-100).
+ *
+ * Combines:
+ *   - Solution utilization (7d match rate)      30%
+ *   - Block→ack effectiveness                   25%
+ *   - Knowledge growth (extractions this week)   20%
+ *   - Rule coverage (active rules)               15%
+ *   - Profile completeness                       10%
+ */
+import { computeStats } from './stats-cli.js';
+const isTTY = process.stdout.isTTY;
+const C = {
+    reset: isTTY ? '\x1b[0m' : '',
+    bold: isTTY ? '\x1b[1m' : '',
+    dim: isTTY ? '\x1b[2m' : '',
+    green: isTTY ? '\x1b[32m' : '',
+    yellow: isTTY ? '\x1b[33m' : '',
+    red: isTTY ? '\x1b[31m' : '',
+    cyan: isTTY ? '\x1b[36m' : '',
+};
+export function computeHealth() {
+    const s = computeStats();
+    // 1. Utilization (30%): % of solutions matched in last 7d, capped at 100%
+    const utilization = Math.min(1, s.solutionHealth.utilization7d) * 30;
+    // 2. Effectiveness (25%): if blocks happened, what % were acknowledged
+    let effectiveness;
+    if (s.blocks7d === 0) {
+        effectiveness = 25; // no blocks = no problems
+    }
+    else {
+        effectiveness = (s.acks7d / s.blocks7d) * 25;
+    }
+    // 3. Growth (20%): extractions this week (1 extraction = 10pts, cap at 20)
+    const growth = Math.min(20, s.weeklyTrend.extractionsThisWeek * 10);
+    // 4. Coverage (15%): active rules (1 rule = 3pts, cap at 15)
+    const coverage = Math.min(15, s.activeRules * 3);
+    // 5. Profile (10%): has profile + has philosophy + axis scores populated
+    let profile = 0;
+    if (s.philosophy) {
+        profile += 4; // profile exists
+        if (s.philosophy.basePacks.length > 0)
+            profile += 3;
+        if (Object.keys(s.philosophy.axisScores).length >= 4)
+            profile += 3;
+    }
+    const total = Math.round(utilization + effectiveness + growth + coverage + profile);
+    const grade = total >= 80 ? 'A' : total >= 60 ? 'B' : total >= 40 ? 'C' : total >= 20 ? 'D' : 'F';
+    return {
+        total,
+        components: {
+            utilization: Math.round(utilization),
+            effectiveness: Math.round(effectiveness),
+            growth: Math.round(growth),
+            coverage: Math.round(coverage),
+            profile: Math.round(profile),
+        },
+        grade,
+    };
+}
+function gradeColor(grade) {
+    if (grade === 'A')
+        return C.green;
+    if (grade === 'B')
+        return C.cyan;
+    if (grade === 'C')
+        return C.yellow;
+    return C.red;
+}
+function bar(value, max, width = 10) {
+    const filled = Math.round((value / max) * width);
+    return '█'.repeat(Math.max(0, filled)) + '░'.repeat(Math.max(0, width - filled));
+}
+export async function handleHealth() {
+    const h = computeHealth();
+    const gc = gradeColor(h.grade);
+    console.log('');
+    console.log(`  ${C.bold}forgen health${C.reset}  ${gc}${C.bold}${h.grade}${C.reset}  ${gc}${h.total}/100${C.reset}`);
+    console.log('');
+    console.log(`    Utilization    ${bar(h.components.utilization, 30)}  ${h.components.utilization}/30   ${C.dim}solution match rate (7d)${C.reset}`);
+    console.log(`    Effectiveness  ${bar(h.components.effectiveness, 25)}  ${h.components.effectiveness}/25   ${C.dim}block→ack ratio${C.reset}`);
+    console.log(`    Growth         ${bar(h.components.growth, 20)}  ${h.components.growth}/20   ${C.dim}extractions this week${C.reset}`);
+    console.log(`    Coverage       ${bar(h.components.coverage, 15)}  ${h.components.coverage}/15   ${C.dim}active rules${C.reset}`);
+    console.log(`    Profile        ${bar(h.components.profile, 10)}  ${h.components.profile}/10   ${C.dim}personalization depth${C.reset}`);
+    console.log('');
+}

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/probe-workflow-cli.d.ts

@@ -0,0 +1,72 @@
+/**
+ * forgen probe-workflow — ADR-009 §1 결정적 미확인 변수 실측 도구.
+ *
+ * 질문: dynamic workflow **내부** 에이전트에 대해 SubagentStart/Stop·PostToolUse
+ *       훅이 발화하는가? (워크플로우 런타임은 "대화와 분리된 격리 백그라운드"로
+ *       명시되어 있어 발화 여부가 문서로 미확인.)
+ *
+ * 이 답이 ADR-009 §2(훅 라우트로 워크플로우까지 검증 가능) vs §3(워크플로우
+ * 품질은 템플릿 라우트로만 도달)의 선택을 가른다. forgen 프로젝트 룰상 가정
+ * 위에 §2 를 구현할 수 없으므로, 실제 실행 증거를 먼저 수집한다.
+ *
+ * 신호원 (훅이 부작용으로 남기는 state 파일 — forgen 자체 timing 계측의 공백과
+ * 무관하게 직접 관측 가능):
+ *   - SubagentStart/Stop → ~/.forgen/state/active-agents-*.json (agents[])
+ *   - PostToolUse        → ~/.forgen/state/modified-files-*.json (mtime)
+ *   - (보조) hook-timing.jsonl 의 event 별 엔트리
+ *
+ * 절차 (2단계 — 런타임이 격리되어 있어 단일 프로세스로는 트리거 불가):
+ *   1. `forgen probe-workflow arm`    → baseline 마커 기록 + 안내 출력
+ *   2. 사용자가 Claude Code 에서 워크플로우 1회 실행 (그 사이 다른 작업 금지)
+ *   3. `forgen probe-workflow report` → baseline 이후 신호 수집 → verdict 박제
+ *
+ * 가정 (detailed-communication): arm~report 사이에 사용자가 **워크플로우만**
+ * 실행했다고 전제한다. 일반 Task-tool subagent 를 같이 돌리면 신호가 섞인다.
+ */
+export interface ProbeBaseline {
+    armedAtMs: number;
+    armedIso: string;
+}
+export interface AgentObservation {
+    agentId: string;
+    agentType?: string;
+    model?: string;
+    startedAtMs: number;
+    stoppedAtMs?: number;
+}
+export interface ProbeObservations {
+    agents: AgentObservation[];
+    /** baseline 이후 modified-files-*.json 이 갱신됨 (PostToolUse 발화 신호). */
+    postToolUseFired: boolean;
+    /** hook-timing.jsonl 에서 baseline 이후 관측된 event 이름들. */
+    hookEvents: string[];
+}
+export type ProbeOutcome = 'workflow-hooks-fire' | 'workflow-hooks-absent' | 'inconclusive';
+export interface ProbeVerdict {
+    subagentStartStopFired: boolean;
+    postToolUseFired: boolean;
+    agentCount: number;
+    maxConcurrency: number;
+    agentTypes: string[];
+    outcome: ProbeOutcome;
+    recommendation: string;
+}
+/**
+ * 구간 [start, stop) 들의 최대 동시 겹침 수. stoppedAt 미지정(진행 중) 은 +∞ 로 간주.
+ * sweep-line: start 이벤트 +1, stop 이벤트 -1 을 시간순 정렬 후 누적 최대.
+ * 동일 시각에서는 start(+1) 를 stop(-1) 보다 먼저 처리해 겹침을 과소평가하지 않는다.
+ */
+export declare function maxConcurrency(agents: AgentObservation[]): number;
+/**
+ * Pure core — baseline + 관측치 → verdict. IO 없음 (단위 테스트 대상).
+ *
+ * 판정:
+ *   - 에이전트 0 → 'workflow-hooks-absent' (단 "워크플로우를 실제로 띄웠는가"
+ *     확인 전제 — recommendation 에 명시). §2 는 워크플로우 내부에 도달 못 함.
+ *   - 에이전트 >0 → 'workflow-hooks-fire'. 동시 ≥11 이면 워크플로우 강한 신호.
+ *     §2(SubagentStop 검증)가 워크플로우까지 커버 가능.
+ */
+export declare function analyzeProbe(obs: ProbeObservations): ProbeVerdict;
+/** baseline 이후 신호 수집 (IO 셸). */
+export declare function collectObservations(baselineMs: number): ProbeObservations;
+export declare function handleProbeWorkflow(args: string[]): Promise<void>;

package/dist/core/probe-workflow-cli.js

@@ -0,0 +1,282 @@
+/**
+ * forgen probe-workflow — ADR-009 §1 결정적 미확인 변수 실측 도구.
+ *
+ * 질문: dynamic workflow **내부** 에이전트에 대해 SubagentStart/Stop·PostToolUse
+ *       훅이 발화하는가? (워크플로우 런타임은 "대화와 분리된 격리 백그라운드"로
+ *       명시되어 있어 발화 여부가 문서로 미확인.)
+ *
+ * 이 답이 ADR-009 §2(훅 라우트로 워크플로우까지 검증 가능) vs §3(워크플로우
+ * 품질은 템플릿 라우트로만 도달)의 선택을 가른다. forgen 프로젝트 룰상 가정
+ * 위에 §2 를 구현할 수 없으므로, 실제 실행 증거를 먼저 수집한다.
+ *
+ * 신호원 (훅이 부작용으로 남기는 state 파일 — forgen 자체 timing 계측의 공백과
+ * 무관하게 직접 관측 가능):
+ *   - SubagentStart/Stop → ~/.forgen/state/active-agents-*.json (agents[])
+ *   - PostToolUse        → ~/.forgen/state/modified-files-*.json (mtime)
+ *   - (보조) hook-timing.jsonl 의 event 별 엔트리
+ *
+ * 절차 (2단계 — 런타임이 격리되어 있어 단일 프로세스로는 트리거 불가):
+ *   1. `forgen probe-workflow arm`    → baseline 마커 기록 + 안내 출력
+ *   2. 사용자가 Claude Code 에서 워크플로우 1회 실행 (그 사이 다른 작업 금지)
+ *   3. `forgen probe-workflow report` → baseline 이후 신호 수집 → verdict 박제
+ *
+ * 가정 (detailed-communication): arm~report 사이에 사용자가 **워크플로우만**
+ * 실행했다고 전제한다. 일반 Task-tool subagent 를 같이 돌리면 신호가 섞인다.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { STATE_DIR } from './paths.js';
+const isTTY = process.stdout.isTTY;
+const C = {
+    reset: isTTY ? '\x1b[0m' : '',
+    bold: isTTY ? '\x1b[1m' : '',
+    dim: isTTY ? '\x1b[2m' : '',
+    green: isTTY ? '\x1b[32m' : '',
+    yellow: isTTY ? '\x1b[33m' : '',
+    red: isTTY ? '\x1b[31m' : '',
+    cyan: isTTY ? '\x1b[36m' : '',
+};
+const BASELINE_PATH = path.join(STATE_DIR, 'probe-workflow.json');
+const RESULT_PATH = path.join(STATE_DIR, 'probe-workflow-result.json');
+/** 일반 subagent 동시 실행 상한(MAX_CONCURRENT_AGENTS=10) 초과 → 워크플로우 강한 신호. */
+const WORKFLOW_CONCURRENCY_HINT = 11;
+/**
+ * 구간 [start, stop) 들의 최대 동시 겹침 수. stoppedAt 미지정(진행 중) 은 +∞ 로 간주.
+ * sweep-line: start 이벤트 +1, stop 이벤트 -1 을 시간순 정렬 후 누적 최대.
+ * 동일 시각에서는 start(+1) 를 stop(-1) 보다 먼저 처리해 겹침을 과소평가하지 않는다.
+ */
+export function maxConcurrency(agents) {
+    const events = [];
+    for (const a of agents) {
+        events.push({ t: a.startedAtMs, delta: 1 });
+        events.push({ t: a.stoppedAtMs ?? Number.POSITIVE_INFINITY, delta: -1 });
+    }
+    events.sort((x, y) => (x.t === y.t ? y.delta - x.delta : x.t - y.t));
+    let cur = 0;
+    let peak = 0;
+    for (const e of events) {
+        cur += e.delta;
+        if (cur > peak)
+            peak = cur;
+    }
+    return peak;
+}
+/**
+ * Pure core — baseline + 관측치 → verdict. IO 없음 (단위 테스트 대상).
+ *
+ * 판정:
+ *   - 에이전트 0 → 'workflow-hooks-absent' (단 "워크플로우를 실제로 띄웠는가"
+ *     확인 전제 — recommendation 에 명시). §2 는 워크플로우 내부에 도달 못 함.
+ *   - 에이전트 >0 → 'workflow-hooks-fire'. 동시 ≥11 이면 워크플로우 강한 신호.
+ *     §2(SubagentStop 검증)가 워크플로우까지 커버 가능.
+ */
+export function analyzeProbe(obs) {
+    const agentCount = obs.agents.length;
+    const conc = maxConcurrency(obs.agents);
+    const types = [...new Set(obs.agents.map((a) => a.agentType).filter((t) => !!t))];
+    const subagentFired = agentCount > 0;
+    let outcome;
+    let recommendation;
+    if (!subagentFired) {
+        outcome = 'workflow-hooks-absent';
+        recommendation =
+            'SubagentStart/Stop 신호 0건. 워크플로우를 실제로 실행했다면 → 워크플로우 ' +
+                '내부 에이전트는 forgen 훅을 거치지 않음. ADR-009 §2 는 Task-tool/team/swarm ' +
+                'subagent 한정으로 제한하고, 워크플로우 품질은 §3 템플릿 라우트로만 달성한다. ' +
+                '(워크플로우를 안 띄웠다면 arm 후 재시도 — inconclusive.)';
+    }
+    else {
+        outcome = 'workflow-hooks-fire';
+        const strong = conc >= WORKFLOW_CONCURRENCY_HINT;
+        recommendation =
+            `SubagentStart/Stop 발화 확인(에이전트 ${agentCount}, 최대 동시 ${conc}` +
+                `${strong ? ', 워크플로우 동시성 신호 강함' : ', 동시성 낮음 — 일반 subagent 가능성 검토'}). ` +
+                `ADR-009 §2(SubagentStop 검증)가 워크플로우 내부까지 커버 가능. ` +
+                `PostToolUse=${obs.postToolUseFired ? '발화(§2d per-agent tool 추적 가능)' : '미관측(§2d 거짓양성 리스크 — 추가 확인 필요)'}.`;
+    }
+    return {
+        subagentStartStopFired: subagentFired,
+        postToolUseFired: obs.postToolUseFired,
+        agentCount,
+        maxConcurrency: conc,
+        agentTypes: types,
+        outcome,
+        recommendation,
+    };
+}
+function parseIsoMs(iso) {
+    if (!iso)
+        return undefined;
+    const ms = Date.parse(iso);
+    return Number.isFinite(ms) ? ms : undefined;
+}
+/** STATE_DIR 의 prefix-*.json 파일 경로 목록. 실패 시 []. */
+function listStateFiles(prefix) {
+    try {
+        return fs
+            .readdirSync(STATE_DIR)
+            .filter((f) => f.startsWith(prefix) && f.endsWith('.json'))
+            .map((f) => path.join(STATE_DIR, f));
+    }
+    catch {
+        return [];
+    }
+}
+/** baseline 이후 신호 수집 (IO 셸). */
+export function collectObservations(baselineMs) {
+    const agents = [];
+    for (const file of listStateFiles('active-agents-')) {
+        try {
+            const data = JSON.parse(fs.readFileSync(file, 'utf-8'));
+            for (const a of data.agents ?? []) {
+                const startedAtMs = parseIsoMs(a.startedAt);
+                if (startedAtMs === undefined || startedAtMs < baselineMs)
+                    continue;
+                agents.push({
+                    agentId: a.agentId ?? 'unknown',
+                    agentType: a.agentType,
+                    model: a.model,
+                    startedAtMs,
+                    stoppedAtMs: parseIsoMs(a.stoppedAt),
+                });
+            }
+        }
+        catch {
+            /* skip malformed */
+        }
+    }
+    let postToolUseFired = false;
+    for (const file of listStateFiles('modified-files-')) {
+        try {
+            if (fs.statSync(file).mtimeMs >= baselineMs) {
+                postToolUseFired = true;
+                break;
+            }
+        }
+        catch {
+            /* skip */
+        }
+    }
+    const hookEvents = collectHookEvents(baselineMs);
+    return { agents, postToolUseFired, hookEvents };
+}
+/** hook-timing.jsonl 에서 baseline 이후 관측된 distinct event 이름 (보조 신호). */
+function collectHookEvents(baselineMs) {
+    const p = path.join(STATE_DIR, 'hook-timing.jsonl');
+    try {
+        const lines = fs.readFileSync(p, 'utf-8').trim().split('\n');
+        const set = new Set();
+        for (const line of lines) {
+            try {
+                const e = JSON.parse(line);
+                if (typeof e.at === 'number' && e.at >= baselineMs && e.event)
+                    set.add(e.event);
+            }
+            catch {
+                /* skip */
+            }
+        }
+        return [...set];
+    }
+    catch {
+        return [];
+    }
+}
+function armProbe() {
+    const now = Date.now();
+    const baseline = { armedAtMs: now, armedIso: new Date(now).toISOString() };
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+    fs.writeFileSync(BASELINE_PATH, JSON.stringify(baseline, null, 2));
+    console.log(`
+${C.bold}forgen probe-workflow — armed${C.reset} ${C.dim}(${baseline.armedIso})${C.reset}
+
+${C.cyan}다음을 정확히 순서대로 실행하세요:${C.reset}
+  1. Claude Code (v2.1.154+, workflows 활성) 세션에서 ${C.bold}워크플로우 1회만${C.reset} 실행
+     예: ${C.dim}Run a workflow to list files under src/${C.reset}
+     또는: ${C.dim}/deep-research <질문>${C.reset}
+  2. ${C.yellow}그 사이 다른 Task/subagent 작업은 돌리지 마세요${C.reset} (신호 오염 방지)
+  3. 워크플로우가 끝나면: ${C.bold}forgen probe-workflow report${C.reset}
+
+${C.dim}전제: forgen 의 SubagentStart/Stop·PostToolUse 훅이 설치/활성 상태여야 합니다.
+불확실하면 'forgen config hooks' 로 확인하세요.${C.reset}
+`);
+}
+function loadBaseline() {
+    try {
+        return JSON.parse(fs.readFileSync(BASELINE_PATH, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function colorForOutcome(outcome) {
+    if (outcome === 'workflow-hooks-fire')
+        return C.green;
+    if (outcome === 'workflow-hooks-absent')
+        return C.yellow;
+    return C.dim;
+}
+function reportProbe() {
+    const baseline = loadBaseline();
+    if (!baseline) {
+        console.log(`\n  ${C.red}✗ armed 상태가 아닙니다.${C.reset} 먼저 ${C.bold}forgen probe-workflow arm${C.reset} 를 실행하세요.\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const obs = collectObservations(baseline.armedAtMs);
+    const verdict = analyzeProbe(obs);
+    persistResult(baseline, verdict);
+    const oc = colorForOutcome(verdict.outcome);
+    console.log(`
+${C.bold}forgen probe-workflow — report${C.reset} ${C.dim}(armed ${baseline.armedIso})${C.reset}
+
+  SubagentStart/Stop 발화 : ${verdict.subagentStartStopFired ? `${C.green}YES${C.reset}` : `${C.yellow}NO${C.reset}`}
+  PostToolUse 발화        : ${verdict.postToolUseFired ? `${C.green}YES${C.reset}` : `${C.yellow}NO${C.reset}`}
+  관측 에이전트           : ${verdict.agentCount}  (최대 동시 ${verdict.maxConcurrency})
+  agentType               : ${verdict.agentTypes.length ? verdict.agentTypes.join(', ') : `${C.dim}(없음)${C.reset}`}
+  보조 hook 이벤트        : ${obs.hookEvents.length ? obs.hookEvents.join(', ') : `${C.dim}(없음)${C.reset}`}
+
+  ${C.bold}판정:${C.reset} ${oc}${verdict.outcome}${C.reset}
+  ${verdict.recommendation}
+
+${C.dim}결과 박제: ${RESULT_PATH}${C.reset}
+`);
+}
+function persistResult(baseline, verdict) {
+    try {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        fs.writeFileSync(RESULT_PATH, JSON.stringify({ at: new Date().toISOString(), armedIso: baseline.armedIso, verdict }, null, 2));
+    }
+    catch {
+        /* best-effort */
+    }
+}
+function statusProbe() {
+    const baseline = loadBaseline();
+    console.log(baseline
+        ? `\n  armed: ${C.cyan}${baseline.armedIso}${C.reset}\n  → 워크플로우 실행 후 ${C.bold}forgen probe-workflow report${C.reset}\n`
+        : `\n  ${C.dim}armed 상태 아님.${C.reset} ${C.bold}forgen probe-workflow arm${C.reset} 로 시작하세요.\n`);
+}
+export async function handleProbeWorkflow(args) {
+    const sub = args[0] ?? 'status';
+    switch (sub) {
+        case 'arm':
+            armProbe();
+            return;
+        case 'report':
+            reportProbe();
+            return;
+        case 'status':
+            statusProbe();
+            return;
+        default:
+            console.log(`
+  ${C.bold}forgen probe-workflow${C.reset} — ADR-009 §1: 워크플로우 훅 발화 실측
+
+  Usage:
+    forgen probe-workflow arm       baseline 기록 + 안내 (먼저)
+    forgen probe-workflow report    워크플로우 실행 후 신호 수집 → 판정
+    forgen probe-workflow status    현재 armed 상태 확인
+`);
+    }
+}

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/core/stats-cli.d.ts

@@ -9,27 +9,40 @@ export interface StatsSnapshot {
     drift7d: number;
     retired7d: number;
     lastExtraction: string;
-    /**
-     * H3 / v0.4.1 — assist 축 가시화. enforcement(block/violation) 는 이미 표시되지만
-     * assist(recall hit, surface, extraction) 는 v0.4.0 에서 8,000+ 번 작동했음에도
-     * 사용자에게 0건 노출되었다. 오늘 기준 숫자로 "지금 학습되고 있다" 를 surface.
-     */
     assistToday: {
         recallHits: number;
         surfaced: number;
         referenced: number;
         extractedToday: number;
     };
-    /**
-     * v0.4.1 철학 고도화 지표 — forge-profile.json 이 실제로 학습됐는지 한눈에.
-     * 값이 있으면 가시화, 없으면 undefined.
-     */
     philosophy?: {
         basePacks: string[];
         trustPolicy: string;
         axisScores: Record<string, number>;
         lastReclassification: string | null;
     };
+    /** v0.5.0: solution health — status 분포, 활용률 */
+    solutionHealth: {
+        total: number;
+        byStatus: Record<string, number>;
+        avgConfidence: number;
+        /** 지난 7일간 match-eval-log에서 한 번이라도 매칭된 솔루션 비율 */
+        utilization7d: number;
+    };
+    /** v0.5.0: 7일간 가장 많이 발동된 규칙 top-3 */
+    topRules7d: Array<{
+        name: string;
+        count: number;
+    }>;
+    /** v0.5.0: 이번주 vs 지난주 변화량 */
+    weeklyTrend: {
+        blocksThisWeek: number;
+        blocksLastWeek: number;
+        recallsThisWeek: number;
+        recallsLastWeek: number;
+        extractionsThisWeek: number;
+        extractionsLastWeek: number;
+    };
 }
 export declare function computeStats(): StatsSnapshot;
 export declare function renderStats(s: StatsSnapshot): string;