@wooojin/forgen 0.4.10 → 0.4.12

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/spawn.d.ts

@@ -1,5 +1,18 @@
 import type { V1HarnessContext } from './harness.js';
 import type { RuntimeHost } from './types.js';
+/**
+ * 세션 종료 후 자동 compound 추출을 백그라운드(detached)로 시작.
+ *
+ * 과거에는 execFileSync 로 동기 실행하여 세션 종료가 최대 ~210초(haiku LLM 3회
+ * 순차: 솔루션 추출 90s + behavior 60s + 세션 학습 60s) 동안 블록되었다. 같은
+ * 작업을 context-guard Stop 훅(maybeSpawnAutoCompound)과 session-recovery 가 이미
+ * detached 로 spawn 하므로, 여기서도 detached + unref 로 전환해 세션 종료를 막지
+ * 않는다. 결과(추출 솔루션/패턴)는 다음 세션 시작 시 session-recovery 가 surface 한다.
+ *
+ * dedup: last-auto-compound.json 을 Stop 훅과 공유 — 같은 세션의 최근 run 이 있으면
+ * skip 하여 detached spawn 의 double-run 을 방지한다.
+ */
+export declare function runAutoCompound(cwd: string, transcriptPath: string, sessionId: string): void;
 /**
  * Plan B-1: 세션 transcript 사후 스캔으로 rate-limit 감지.
  *

package/dist/core/spawn.js

@@ -223,19 +223,47 @@ async function scanCommitDiffForActedOn(sessionId, cwd, sessionStartTime) {
  * 세션 종료 후 자동 compound 추출 + USER.md 업데이트.
  * auto-compound-runner.ts를 동기 실행하여 솔루션 추출 + 사용자 패턴 관찰.
  */
-async function runAutoCompound(cwd, transcriptPath, sessionId) {
-    console.log('\n[forgen] 세션 분석 중... (자동 compound)');
+// Stop 훅(maybeSpawnAutoCompound)/session-recovery 와 공유하는 dedup cooldown.
+const AUTO_COMPOUND_DEDUP_COOLDOWN_MS = 5 * 60 * 1000; // 5min
+/**
+ * 세션 종료 후 자동 compound 추출을 백그라운드(detached)로 시작.
+ *
+ * 과거에는 execFileSync 로 동기 실행하여 세션 종료가 최대 ~210초(haiku LLM 3회
+ * 순차: 솔루션 추출 90s + behavior 60s + 세션 학습 60s) 동안 블록되었다. 같은
+ * 작업을 context-guard Stop 훅(maybeSpawnAutoCompound)과 session-recovery 가 이미
+ * detached 로 spawn 하므로, 여기서도 detached + unref 로 전환해 세션 종료를 막지
+ * 않는다. 결과(추출 솔루션/패턴)는 다음 세션 시작 시 session-recovery 가 surface 한다.
+ *
+ * dedup: last-auto-compound.json 을 Stop 훅과 공유 — 같은 세션의 최근 run 이 있으면
+ * skip 하여 detached spawn 의 double-run 을 방지한다.
+ */
+export function runAutoCompound(cwd, transcriptPath, sessionId) {
+    const markerPath = path.join(STATE_DIR, 'last-auto-compound.json');
+    try {
+        const parsed = JSON.parse(fs.readFileSync(markerPath, 'utf-8'));
+        if (parsed.sessionId === sessionId) {
+            const last = parsed.completedAt ? Date.parse(parsed.completedAt) : 0;
+            if (Number.isFinite(last) && Date.now() - last < AUTO_COMPOUND_DEDUP_COOLDOWN_MS) {
+                log.debug('auto-compound skip: 최근 동일 세션 run 존재 (dedup)');
+                return;
+            }
+        }
+    }
+    catch {
+        // 마커 없음(최초)/손상 — 진행 (fail-open).
+    }
     const runnerPath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'auto-compound-runner.js');
     try {
-        execFileSync('node', [runnerPath, cwd, transcriptPath, sessionId], {
+        const child = spawn('node', [runnerPath, cwd, transcriptPath, sessionId], {
             cwd,
-            timeout: 120_000,
-            stdio: ['pipe', 'inherit', 'inherit'],
+            detached: true,
+            stdio: 'ignore',
         });
-        console.log('[forgen] 자동 compound 완료\n');
+        child.unref();
+        console.log('\n[forgen] 세션 분석을 백그라운드로 시작했습니다 (자동 compound) — 결과는 다음 세션 시작 시 반영됩니다.\n');
     }
     catch (e) {
-        log.debug('auto-compound 실패', e);
+        log.debug('auto-compound 시작 실패', e);
     }
 }
 /**
@@ -415,7 +443,7 @@ export async function spawnClaude(args, context, runtime = 'claude') {
                     // 4. 자동 compound (10+ user 메시지인 경우만) — 양 runtime 호환
                     const userMsgCount = await countUserMessages(transcript);
                     if (userMsgCount >= 10) {
-                        await runAutoCompound(context.cwd, transcript, sessionId);
+                        runAutoCompound(context.cwd, transcript, sessionId);
                     }
                     else {
                         console.log(`[forgen] 세션이 짧아 auto-compound 생략 (${userMsgCount} messages)`);

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;

package/dist/core/stats-cli.js

@@ -198,8 +198,125 @@ export function computeStats() {
         lastExtraction: readLastExtraction(),
         assistToday: computeAssistToday(),
         philosophy: computePhilosophy(),
+        solutionHealth: computeSolutionHealth(),
+        topRules7d: computeTopRules7d(realBlocks),
+        weeklyTrend: computeWeeklyTrend(realBlocks),
     };
 }
+function computeSolutionHealth() {
+    const byStatus = {};
+    let total = 0;
+    let confidenceSum = 0;
+    const localNames = new Set();
+    try {
+        if (!fs.existsSync(SOLUTIONS_DIR))
+            return { total: 0, byStatus: {}, avgConfidence: 0, utilization7d: 0 };
+        const files = fs.readdirSync(SOLUTIONS_DIR).filter(f => f.endsWith('.md'));
+        for (const f of files) {
+            try {
+                const content = fs.readFileSync(path.join(SOLUTIONS_DIR, f), 'utf-8');
+                const statusMatch = content.match(/status:\s*"?([a-z]+)"?/);
+                const confMatch = content.match(/confidence:\s*([0-9.]+)/);
+                const st = statusMatch?.[1] ?? 'unknown';
+                byStatus[st] = (byStatus[st] ?? 0) + 1;
+                confidenceSum += parseFloat(confMatch?.[1] ?? '0');
+                localNames.add(f.replace(/\.md$/, ''));
+                total++;
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* fail-open */ }
+    const cutoff7d = Date.now() - 7 * MS_PER_DAY;
+    const matchLog = readJsonl(path.join(STATE_DIR, 'match-eval-log.jsonl'));
+    const matchedLocalNames = new Set();
+    for (const e of matchLog) {
+        const ts = typeof e.ts === 'string' ? Date.parse(e.ts) : NaN;
+        if (!Number.isFinite(ts) || ts < cutoff7d)
+            continue;
+        const ranked = e.rankedTopN;
+        if (Array.isArray(ranked)) {
+            for (const r of ranked) {
+                let name = null;
+                if (typeof r === 'string')
+                    name = r;
+                else if (typeof r === 'object' && r !== null && typeof r.name === 'string') {
+                    name = r.name;
+                }
+                // Only count matches against LOCAL solutions to avoid skew from
+                // starter-pack/team-pack matches that aren't in this user's me/solutions/.
+                if (name && localNames.has(name)) {
+                    matchedLocalNames.add(name);
+                }
+            }
+        }
+    }
+    return {
+        total,
+        byStatus,
+        avgConfidence: total > 0 ? confidenceSum / total : 0,
+        utilization7d: total > 0 ? matchedLocalNames.size / total : 0,
+    };
+}
+function computeTopRules7d(violations) {
+    const cutoff = Date.now() - 7 * MS_PER_DAY;
+    const counts = new Map();
+    for (const v of violations) {
+        const ts = typeof v.at === 'string' ? Date.parse(v.at) : NaN;
+        if (!Number.isFinite(ts) || ts < cutoff)
+            continue;
+        const rule = typeof v.rule === 'string' ? v.rule
+            : typeof v.guard === 'string' ? v.guard
+                : typeof v.source === 'string' ? v.source
+                    : 'unknown';
+        counts.set(rule, (counts.get(rule) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3)
+        .map(([name, count]) => ({ name, count }));
+}
+function computeWeeklyTrend(violations) {
+    const now = Date.now();
+    const thisWeekStart = now - 7 * MS_PER_DAY;
+    const lastWeekStart = now - 14 * MS_PER_DAY;
+    const blocksThisWeek = countWithin(violations, 7);
+    let blocksLastWeek = 0;
+    for (const v of violations) {
+        const ts = typeof v.at === 'string' ? Date.parse(v.at) : NaN;
+        if (Number.isFinite(ts) && ts >= lastWeekStart && ts < thisWeekStart)
+            blocksLastWeek++;
+    }
+    const matchLog = readJsonl(path.join(STATE_DIR, 'match-eval-log.jsonl'));
+    let recallsThisWeek = 0;
+    let recallsLastWeek = 0;
+    for (const e of matchLog) {
+        const ts = typeof e.ts === 'string' ? Date.parse(e.ts) : NaN;
+        if (!Number.isFinite(ts))
+            continue;
+        if (ts >= thisWeekStart)
+            recallsThisWeek++;
+        else if (ts >= lastWeekStart)
+            recallsLastWeek++;
+    }
+    let extractionsThisWeek = 0;
+    let extractionsLastWeek = 0;
+    try {
+        if (fs.existsSync(SOLUTIONS_DIR)) {
+            for (const f of fs.readdirSync(SOLUTIONS_DIR)) {
+                if (!f.endsWith('.md'))
+                    continue;
+                const mtime = fs.statSync(path.join(SOLUTIONS_DIR, f)).mtimeMs;
+                if (mtime >= thisWeekStart)
+                    extractionsThisWeek++;
+                else if (mtime >= lastWeekStart)
+                    extractionsLastWeek++;
+            }
+        }
+    }
+    catch { /* fail-open */ }
+    return { blocksThisWeek, blocksLastWeek, recallsThisWeek, recallsLastWeek, extractionsThisWeek, extractionsLastWeek };
+}
 function padNum(n, width = 4) {
     return String(n).padStart(width);
 }
@@ -256,6 +373,38 @@ export function renderStats(s) {
         }
     }
     catch { /* fail-open: git 없거나 비-repo 환경 */ }
+    // v0.5.0: Solution health
+    if (s.solutionHealth.total > 0) {
+        const sh = s.solutionHealth;
+        const statusParts = Object.entries(sh.byStatus).map(([k, v]) => `${k}:${v}`).join(' ');
+        lines.push('  Solutions');
+        lines.push(`    Total               ${padNum(sh.total)}    ${statusParts}`);
+        lines.push(`    Avg confidence      ${sh.avgConfidence.toFixed(2)}`);
+        lines.push(`    Utilization (7d)    ${Math.round(sh.utilization7d * 100)}%   — matched at least once`);
+        lines.push('');
+    }
+    // v0.5.0: Top rules (7d)
+    if (s.topRules7d.length > 0) {
+        lines.push('  Top rules (7d)');
+        for (const r of s.topRules7d) {
+            lines.push(`    ${padNum(r.count)}x  ${r.name}`);
+        }
+        lines.push('');
+    }
+    // v0.5.0: Weekly trend
+    const wt = s.weeklyTrend;
+    const trendArrow = (curr, prev) => {
+        if (curr > prev)
+            return `+${curr - prev}`;
+        if (curr < prev)
+            return `${curr - prev}`;
+        return '=';
+    };
+    lines.push('  Weekly trend (this vs last)');
+    lines.push(`    Blocks       ${padNum(wt.blocksThisWeek)} → ${padNum(wt.blocksLastWeek, 2)} prev   (${trendArrow(wt.blocksThisWeek, wt.blocksLastWeek)})`);
+    lines.push(`    Recalls      ${padNum(wt.recallsThisWeek)} → ${padNum(wt.recallsLastWeek, 2)} prev   (${trendArrow(wt.recallsThisWeek, wt.recallsLastWeek)})`);
+    lines.push(`    Extractions  ${padNum(wt.extractionsThisWeek)} → ${padNum(wt.extractionsLastWeek, 2)} prev   (${trendArrow(wt.extractionsThisWeek, wt.extractionsLastWeek)})`);
+    lines.push('');
     lines.push(`  Last extraction: ${s.lastExtraction}`);
     lines.push('');
     return lines.join('\n');

package/dist/core/watch-cli.d.ts

@@ -0,0 +1,7 @@
+/**
+ * forgen watch — real-time hook event stream.
+ *
+ * Tails hook-timing.jsonl, enforcement/violations.jsonl, and
+ * match-eval-log.jsonl to show live forgen activity in a terminal pane.
+ */
+export declare function handleWatch(): Promise<void>;