@wooojin/forgen 0.4.0 → 0.4.1

package/dist/checks/fact-vs-agreement.js

@@ -0,0 +1,92 @@
+/**
+ * Forgen v0.4.1 — TEST-1: 사실 vs 합의 가드
+ *
+ * 목적: Claude 가 "동작합니다 / 통과했습니다 / 검증됐습니다" 같은 **사실 주장**을
+ *   내놓을 때, 그 턴(또는 최근 N턴)에 실제 측정/검증을 수행한 도구 호출이 있었는가?
+ *   측정 없이 합의(agreement)만으로 사실로 변환된다면 alert.
+ *
+ * 배경 (RC1): v0.4.0 릴리즈 직전 self-assessment 에서 점수가 조금씩 올라가는데
+ *   측정 도구 호출은 0건인 케이스가 반복. 메타 점수 인플레이션 (TEST-2 / US-13)
+ *   의 직전 단계. 여기서는 alert 레벨까지만 — block 은 TEST-2 에서.
+ *
+ * 순수 함수 설계: I/O 없이 텍스트 + 측정 신호 메타데이터만 받아 판정.
+ *   Stop hook / session scorer / CLI 어느 쪽에서도 호출 가능.
+ */
+/**
+ * 측정성 도구 — 실행 결과가 사실 주장을 뒷받침할 수 있는 카테고리.
+ *
+ * v0.4.1 coverage fix: TEST-2 와 같은 논리로, Read/Edit/Write/Grep/Glob 은 파일
+ * 내용 확인/수정이지 "통과/검증/완료" 같은 실 실행 주장을 뒷받침 못 함. 오직
+ * Bash (실 실행) + NotebookEdit (실행 결과) 만 strong measurement.
+ *
+ * 이전 넓은 집합은 신규 사용자 시나리오 (buyer-day1 R4) 에서 Claude 가 Read
+ * 한 번만 해도 alert 회피 → TEST-1 본 의도 훼손.
+ */
+const MEASUREMENT_TOOL_CATEGORIES = new Set([
+    'Bash',
+    'NotebookEdit',
+]);
+/** 사실-주장 키워드 — "측정됐다/검증됐다" 류 강한 확정 언어. */
+const FACT_ASSERTION_PATTERNS = [
+    /\b(pass(es|ed)?|passing)\b/i,
+    /\bverified\b/i,
+    /\bconfirmed\b/i,
+    /\bvalidated\b/i,
+    /\ball tests? pass/i,
+    /(통과(했|됐|함|합니다))/,
+    /(검증(됐|했|됨|완료))/,
+    /(동작(합니다|함|한다))/,
+    /(성공(했|했습니다|적))/,
+    /(완료(했|됐|됨|됐습니다))/,
+];
+/** 합의/추측 표현 — 측정 없이 확언으로 가는 다리. 이 패턴이 많으면 합의→사실 전환 위험. */
+const AGREEMENT_SOFTENERS = [
+    /\b(should|would|might)\s+(work|pass)/i,
+    /\blikely\b/i,
+    /\bprobably\b/i,
+    /(생각합니다|생각함|생각해|봅니다|예상(합니다|돼))/,
+    /(그럴\s*것\s*같|맞을\s*것\s*같)/,
+];
+function findMatches(text, patterns, max = 3) {
+    const out = [];
+    for (const p of patterns) {
+        if (out.length >= max)
+            break;
+        const m = text.match(p);
+        if (m)
+            out.push(m[0]);
+    }
+    return out;
+}
+/**
+ * 핵심 판정 — 텍스트에 사실-주장이 있고 측정 도구가 없으면 alert.
+ * 측정이 있거나 사실-주장이 없으면 alert=false.
+ * 합의 softener 는 참고용 — softener 많을수록 reason 에 경고 추가.
+ */
+export function checkFactVsAgreement(input) {
+    const { text, recentTools } = input;
+    const minMeasurements = input.minMeasurements ?? 1;
+    const factAssertions = findMatches(text, FACT_ASSERTION_PATTERNS);
+    const agreementSofteners = findMatches(text, AGREEMENT_SOFTENERS);
+    const measurementCount = recentTools.filter((t) => MEASUREMENT_TOOL_CATEGORIES.has(t)).length;
+    const hasFactAssertion = factAssertions.length > 0;
+    const measurementMissing = measurementCount < minMeasurements;
+    const alert = hasFactAssertion && measurementMissing;
+    let reason = '';
+    if (alert) {
+        const parts = [];
+        parts.push(`사실-주장 키워드 ${factAssertions.length}건 감지 ("${factAssertions.join('", "')}")`);
+        parts.push(`그러나 최근 측정 도구 호출 ${measurementCount}회 (< ${minMeasurements})`);
+        if (agreementSofteners.length > 0) {
+            parts.push(`합의성 표현 ${agreementSofteners.length}건 (${agreementSofteners.join(', ')})`);
+        }
+        reason = parts.join('. ');
+    }
+    return {
+        alert,
+        factAssertions,
+        agreementSofteners,
+        measurementCount,
+        reason,
+    };
+}

package/dist/checks/self-score-deflation.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Forgen v0.4.1 — TEST-2: 자가 점수 인플레이션 가드
+ *
+ * Claude 가 자신의 작업 품질/확신도/완성도를 **숫자**로 상향 선언하면서 해당
+ * 턴(또는 세션)에 측정 도구 호출이 0 건이면 block. TEST-1 (사실 vs 합의) 보다
+ * 강한 신호 — 구체적 숫자 인플레이션은 합의-기반 자기-아부(sycophancy)의
+ * 가장 또렷한 표식.
+ *
+ * 배경 (RC2): v0.4.0 self-interview 에서 "8/10", "신뢰도 90%", "0.85 → 0.95"
+ *   같은 자가 점수가 턴마다 올라갔지만 `npm test` / `curl` / `Read` 등 실제
+ *   측정 호출은 0건. TEST-1 이 서술체 사실 주장을 잡았다면, TEST-2 는 **숫자**
+ *   점수의 인플레이션에 초점을 맞춘다.
+ *
+ * 순수 함수 — Stop hook block 경로에 붙는다.
+ */
+export interface SelfScoreCheckInput {
+    text: string;
+    /** 이번 턴(또는 윈도우) 내 실행된 도구 이름 목록. */
+    recentTools: string[];
+    /** score delta 임계 — 이 이상의 증가를 인플레이션으로 간주. 기본 0 (모든 상승). */
+    minDelta?: number;
+    /** 측정 도구 최소 호출 수 — 기본 1. */
+    minMeasurements?: number;
+}
+export interface SelfScoreCheckResult {
+    /** true = 자가 점수 인플레이션 감지 (측정 없이 숫자 증가 선언). block 대상. */
+    block: boolean;
+    /** 매칭된 점수 표현 raw 스트링 (최대 3개). */
+    scoreSignals: string[];
+    /** 감지된 positive delta 목록 (from → to). */
+    deltas: Array<{
+        from: number;
+        to: number;
+    }>;
+    measurementCount: number;
+    reason: string;
+}
+export declare function checkSelfScoreInflation(input: SelfScoreCheckInput): SelfScoreCheckResult;

package/dist/checks/self-score-deflation.js

@@ -0,0 +1,108 @@
+/**
+ * Forgen v0.4.1 — TEST-2: 자가 점수 인플레이션 가드
+ *
+ * Claude 가 자신의 작업 품질/확신도/완성도를 **숫자**로 상향 선언하면서 해당
+ * 턴(또는 세션)에 측정 도구 호출이 0 건이면 block. TEST-1 (사실 vs 합의) 보다
+ * 강한 신호 — 구체적 숫자 인플레이션은 합의-기반 자기-아부(sycophancy)의
+ * 가장 또렷한 표식.
+ *
+ * 배경 (RC2): v0.4.0 self-interview 에서 "8/10", "신뢰도 90%", "0.85 → 0.95"
+ *   같은 자가 점수가 턴마다 올라갔지만 `npm test` / `curl` / `Read` 등 실제
+ *   측정 호출은 0건. TEST-1 이 서술체 사실 주장을 잡았다면, TEST-2 는 **숫자**
+ *   점수의 인플레이션에 초점을 맞춘다.
+ *
+ * 순수 함수 — Stop hook block 경로에 붙는다.
+ */
+/**
+ * 측정성 도구 — **숫자 점수**를 뒷받침할 수 있는 실 **실행** 범주.
+ *
+ * v0.4.1 coverage fix (2026-04-24 buyer-day1 R4 관찰): 이전에는 Read/Edit/Write/
+ * Grep/Glob 도 측정으로 간주했으나, 파일 "읽기/수정" 은 "신뢰도 95/100" 같은
+ * 수치 판정을 뒷받침 못 함. Read 1회면 minMeasurements=1 충족되어 block 회피.
+ * 실제 구매자 시나리오: Claude 가 자가평가 전에 대상 파일 한 번 Read 하면
+ * TEST-2 무력화 — 가드의 본 의도 훼손.
+ *
+ * 새 기준: **실행 결과** 만 측정 — `Bash` (npm test / curl / node --check 등)
+ * 와 `NotebookEdit` (cell 실행). 읽기 전용 도구는 수치 점수의 근거가 될 수 없음.
+ */
+const MEASUREMENT_TOOLS = new Set([
+    'Bash',
+    'NotebookEdit',
+]);
+/**
+ * "자가 점수" 신호 — 숫자 + 품질/완성도/확신도 컨텍스트.
+ *  - "신뢰도 90%", "품질 점수 85/100", "확신도 0.9", "8/10", "90점"
+ *  - "0.7 → 0.9" 같은 증감 표기
+ *
+ * 이 regex 들은 *숫자 그 자체* 만 매칭하지 않고 품질-관련 명사와 같이 나타날 때만
+ * 매칭하도록 좁힘 (false positive 방지).
+ */
+const SELF_SCORE_PATTERNS = [
+    // "신뢰도 90%" / "quality 85%" / "확신도 0.9"
+    /(신뢰도|확신도|완성도|품질|자신감|confidence|quality|completeness)[\s:：]*(\d+(?:\.\d+)?)\s*(%|점|\/\s*\d+|\/100|\/10)?/gi,
+    // "0.85 → 0.95" / "7 -> 9" score delta
+    /(\d+(?:\.\d+)?)\s*(?:→|->|–>|~>)\s*(\d+(?:\.\d+)?)/g,
+    // "8/10", "85/100" — 단독 분수 점수 (앞뒤 품질 컨텍스트 확인은 하지 않지만 보수적 매칭)
+    /\b(\d+(?:\.\d+)?)\s*\/\s*(10|100)\b/g,
+    // 별 점수 "⭐⭐⭐⭐" 4개 이상
+    /⭐{4,}/g,
+];
+function extractDeltas(text) {
+    const re = /(\d+(?:\.\d+)?)\s*(?:→|->|–>|~>)\s*(\d+(?:\.\d+)?)/g;
+    const out = [];
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        const from = Number(m[1]);
+        const to = Number(m[2]);
+        if (Number.isFinite(from) && Number.isFinite(to))
+            out.push({ from, to });
+    }
+    return out;
+}
+function findScoreSignals(text, max = 3) {
+    const out = [];
+    for (const p of SELF_SCORE_PATTERNS) {
+        if (out.length >= max)
+            break;
+        // 각 호출마다 lastIndex 초기화를 위해 새 RegExp 생성
+        const re = new RegExp(p.source, p.flags);
+        let m;
+        while ((m = re.exec(text)) !== null && out.length < max) {
+            out.push(m[0]);
+        }
+    }
+    return out;
+}
+export function checkSelfScoreInflation(input) {
+    const minDelta = input.minDelta ?? 0;
+    const minMeasurements = input.minMeasurements ?? 1;
+    const scoreSignals = findScoreSignals(input.text);
+    const allDeltas = extractDeltas(input.text);
+    const positiveDeltas = allDeltas.filter((d) => d.to - d.from > minDelta);
+    const measurementCount = input.recentTools.filter((t) => MEASUREMENT_TOOLS.has(t)).length;
+    const measurementMissing = measurementCount < minMeasurements;
+    // 인플레이션 신호가 하나라도 있고 측정이 없으면 block
+    const hasInflationSignal = scoreSignals.length > 0 || positiveDeltas.length > 0;
+    const block = hasInflationSignal && measurementMissing;
+    let reason = '';
+    if (block) {
+        const parts = [];
+        if (positiveDeltas.length > 0) {
+            const sample = positiveDeltas.slice(0, 2).map((d) => `${d.from}→${d.to}`).join(', ');
+            parts.push(`자가 점수 상승 선언 ${positiveDeltas.length}건 (${sample})`);
+        }
+        if (scoreSignals.length > 0) {
+            parts.push(`점수 표현 ${scoreSignals.length}건 ("${scoreSignals[0]}")`);
+        }
+        parts.push(`측정 도구 호출 ${measurementCount}회 (< ${minMeasurements}) — 숫자 변동을 뒷받침할 실행/확인 증거 없음`);
+        parts.push('block: 테스트/빌드/curl 실행 결과를 턴에 포함하여 재응답');
+        reason = parts.join('. ');
+    }
+    return {
+        block,
+        scoreSignals,
+        deltas: positiveDeltas,
+        measurementCount,
+        reason,
+    };
+}

package/dist/cli.js

@@ -226,6 +226,22 @@ const commands = [
             await handleInspect(['violations', '--last', '1']);
         },
     },
+    {
+        name: 'recall',
+        description: 'Show recent compound recalls (matched solutions) with optional body preview.',
+        handler: async (args) => {
+            const { handleRecall } = await import('./core/recall-cli.js');
+            await handleRecall(args);
+        },
+    },
+    {
+        name: 'migrate',
+        description: 'One-shot schema migrations (implicit-feedback category backfill).',
+        handler: async (args) => {
+            const { handleMigrate } = await import('./core/migrate-cli.js');
+            await handleMigrate(args);
+        },
+    },
     {
         name: 'suppress-rule',
         description: '[alias: rule suppress] Disable a rule by id/prefix. Hard rules refused.',
@@ -430,12 +446,16 @@ function printHelp() {
                                     Inspect v1 state (alias: evidence → corrections)
     forgen rule <list|suppress|activate|scan|health-scan|classify>
                                     Rule management (see: forgen rule help)
-    forgen stats                    One-screen trust-layer dashboard
+    forgen stats                    One-screen trust-layer dashboard (+ philosophy)
     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 compound                 Manage accumulated knowledge
     forgen dashboard                Compound system dashboard
     forgen me                       Personal dashboard
-    forgen init                     Initialize project
+    forgen init                     Initialize project (+ starter-pack solutions)
     forgen config hooks             Hook management
     forgen mcp                      MCP server management
     forgen skill promote|list       Skill management

package/dist/core/auto-compound-runner.js

@@ -11,12 +11,12 @@
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import * as os from 'node:os';
 import { execFileSync } from 'node:child_process';
 import { containsPromptInjection, filterSolutionContent } from '../hooks/prompt-injection-filter.js';
 import { redactSecrets } from '../hooks/secret-filter.js';
 import { createEvidence, saveEvidence, promoteSessionCandidates } from '../store/evidence-store.js';
 import { loadProfile } from '../store/profile-store.js';
+import { FORGEN_HOME, ME_DIR } from './paths.js';
 /** Auto-compound에 사용할 모델 — background 추출이므로 haiku로 충분 */
 const COMPOUND_MODEL = 'haiku';
 /** execFileSync wrapper: transient 에러(ETIMEDOUT 등) 시 1회 재시도 */
@@ -49,9 +49,8 @@ const [, , cwd, transcriptPath, sessionId] = process.argv;
 if (!cwd || !transcriptPath || !sessionId) {
     process.exit(1);
 }
-const FORGEN_HOME = path.join(os.homedir(), '.forgen');
-const SOLUTIONS_DIR = path.join(FORGEN_HOME, 'me', 'solutions');
-const BEHAVIOR_DIR = path.join(FORGEN_HOME, 'me', 'behavior');
+const SOLUTIONS_DIR = path.join(ME_DIR, 'solutions');
+const BEHAVIOR_DIR = path.join(ME_DIR, 'behavior');
 /** Lightweight quality gate for auto-extracted solution files */
 /** Toxicity patterns — code-context only to avoid false positives on prose */
 const SOLUTION_TOXICITY_PATTERNS = [/@ts-ignore/i, /:\s*any\b/, /\/\/\s*TODO\b/];
@@ -383,10 +382,8 @@ ${sanitizedSummary.slice(0, 4000)}
     }
     // 3단계: 세션 학습 요약 (SessionLearningSummary) 생성
     try {
-        const FORGEN_HOME = path.join(os.homedir(), '.forgen');
-        const V1_ME_DIR = path.join(FORGEN_HOME, 'me');
-        const V1_PROFILE = path.join(V1_ME_DIR, 'forge-profile.json');
-        const V1_EVIDENCE_DIR = path.join(V1_ME_DIR, 'behavior');
+        const V1_PROFILE = path.join(ME_DIR, 'forge-profile.json');
+        const V1_EVIDENCE_DIR = path.join(ME_DIR, 'behavior');
         if (fs.existsSync(V1_PROFILE)) {
             const currentProfile = loadProfile();
             let profileContext = '';
@@ -485,8 +482,9 @@ ${sanitizedSummary.slice(0, 4000)}
         process.stderr.write(`[forgen-auto-compound] session learning: ${e instanceof Error ? e.message : String(e)}\n`);
     }
     // Step 4: prefer-from-now / avoid-this 교정 → scope:'me' 영구 규칙 승격
+    let promotedCount = 0;
     try {
-        const promotedCount = promoteSessionCandidates(sessionId);
+        promotedCount = promoteSessionCandidates(sessionId);
         if (promotedCount > 0) {
             process.stderr.write(`[forgen-auto-compound] promoted ${promotedCount} correction(s) to permanent rules\n`);
         }
@@ -494,6 +492,21 @@ ${sanitizedSummary.slice(0, 4000)}
     catch (e) {
         process.stderr.write(`[forgen-auto-compound] rule promotion: ${e instanceof Error ? e.message : String(e)}\n`);
     }
+    // H2: count newly extracted solutions (post-quality-gate) for Stop hook 알림.
+    // solutionsBefore 스냅샷 vs 현재 디스크 상태 차분 → "N개 패턴 학습됨" 1줄.
+    let extractedSolutionsCount = 0;
+    try {
+        if (fs.existsSync(SOLUTIONS_DIR)) {
+            const current = fs.readdirSync(SOLUTIONS_DIR).filter((f) => f.endsWith('.md'));
+            for (const f of current) {
+                if (!solutionsBefore.has(f))
+                    extractedSolutionsCount++;
+            }
+        }
+    }
+    catch (e) {
+        process.stderr.write(`[forgen-auto-compound] solution count failed: ${e instanceof Error ? e.message : String(e)}\n`);
+    }
     // Step 5: meta-learning (HyperAgents-inspired self-tuning)
     try {
         const { runMetaLearning } = await import('../engine/meta-learning/runner.js');
@@ -508,10 +521,61 @@ ${sanitizedSummary.slice(0, 4000)}
     catch (e) {
         process.stderr.write(`[forgen-meta] ${e instanceof Error ? e.message : String(e)}\n`);
     }
-    // 완료 기록
+    // Step 5.5 (v0.4.1): state hygiene — 세션 스코프 ephemeral 파일 7일 retention
+    // 자동 정리. 이전에는 `forgen doctor --prune-state` 수동만 있어서 injection-cache
+    // 2343 / modified-files 431 처럼 수천 파일 누적. 몇 달 사용하면 10만+ 파일 → stat
+    // 호출 느려지고 디스크 낭비. auto-compound 마다 호출되면 자연스레 정돈.
+    try {
+        const { pruneState } = await import('./state-gc.js');
+        const report = pruneState({ dryRun: false });
+        if (report.pruned > 0) {
+            const mb = (report.bytesFreed / 1024 / 1024).toFixed(2);
+            process.stderr.write(`[forgen-gc] pruned ${report.pruned} stale state files (${mb} MB freed)\n`);
+        }
+    }
+    catch (e) {
+        process.stderr.write(`[forgen-gc] state prune failed: ${e instanceof Error ? e.message : String(e)}\n`);
+    }
+    // Step 6 (v0.4.1): rule lifecycle 자동 실행 — rule 의 violations/bypass/drift
+    // 신호에 따른 자동 강등/승격. 이전에는 CLI (`forgen rule scan --apply`) 수동
+    // 호출만 있어서 구매자가 몇 주 써도 rule 정비 안 됨 → 쓸모없는 rule 이 계속
+    // active. 판매 관점 심각한 "자동 학습 단절". auto-compound-runner 끝에 자동
+    // 실행해 세션마다 rule 품질 유지.
+    try {
+        const { handleLifecycleScan } = await import('../engine/lifecycle/lifecycle-cli.js');
+        // silent mode 로 돌리기 위해 stdout 을 임시 리다이렉트 (내부가 console.log 씀)
+        const origLog = console.log;
+        let applied = 0;
+        console.log = (...args) => {
+            const msg = args.join(' ');
+            const match = msg.match(/apply(?:ied)?\s+(\d+)/i);
+            if (match)
+                applied = Number(match[1]);
+        };
+        try {
+            await handleLifecycleScan(['--apply']);
+        }
+        finally {
+            console.log = origLog;
+        }
+        if (applied > 0) {
+            process.stderr.write(`[forgen-meta] rule lifecycle: ${applied} event(s) applied\n`);
+        }
+    }
+    catch (e) {
+        process.stderr.write(`[forgen-meta] lifecycle scan failed: ${e instanceof Error ? e.message : String(e)}\n`);
+    }
+    // 완료 기록 — H2: Stop hook 알림용으로 extractedSolutions / promotedRules 포함.
+    // noticeShown=false 로 시작해서 Stop hook 가 최초 1회만 surface.
     const statePath = path.join(FORGEN_HOME, 'state', 'last-auto-compound.json');
     fs.mkdirSync(path.dirname(statePath), { recursive: true });
-    fs.writeFileSync(statePath, JSON.stringify({ sessionId, completedAt: new Date().toISOString() }));
+    fs.writeFileSync(statePath, JSON.stringify({
+        sessionId,
+        completedAt: new Date().toISOString(),
+        extractedSolutions: extractedSolutionsCount,
+        promotedRules: promotedCount,
+        noticeShown: false,
+    }));
 }
 catch (e) {
     process.stderr.write(`[forgen-auto-compound] ${e instanceof Error ? e.message : String(e)}\n`);

package/dist/core/dashboard.js

@@ -372,9 +372,15 @@ export function collectLearningCurve() {
             const files = fs.readdirSync(ME_BEHAVIOR).filter(f => f.endsWith('.json'));
             for (const f of files) {
                 try {
+                    // v0.4.1 정확도 수정: "교정 추이" 라벨은 explicit_correction evidence 만 포함.
+                    // 이전에는 behavior_observation + session_summary 까지 전부 "교정" 으로
+                    // 카운트되어 실측 488건 중 ~1건만 실제 교정인데 신뢰도 훼손. axis_hint 는
+                    // raw_payload 에도 저장되므로 fallback 체크.
                     const data = JSON.parse(fs.readFileSync(path.join(ME_BEHAVIOR, f), 'utf-8'));
                     if (!data.timestamp)
                         continue;
+                    if (data.type && data.type !== 'explicit_correction')
+                        continue;
                     const ts = new Date(data.timestamp).getTime();
                     if (!Number.isFinite(ts))
                         continue;
@@ -383,8 +389,9 @@ export function collectLearningCurve() {
                         correctionsLast7d++;
                     else if (age < 2 * SEVEN_DAYS_MS)
                         correctionsPrev7d++;
-                    if (data.axis_hint) {
-                        axisCounts.set(data.axis_hint, (axisCounts.get(data.axis_hint) ?? 0) + 1);
+                    const axisHint = data.axis_hint ?? data.raw_payload?.axis_hint;
+                    if (axisHint) {
+                        axisCounts.set(axisHint, (axisCounts.get(axisHint) ?? 0) + 1);
                     }
                     uniqueDays.add(new Date(ts).toISOString().slice(0, 10));
                 }

package/dist/core/doctor.js

@@ -105,18 +105,39 @@ export async function runDoctor(opts = {}) {
     check('Inside tmux session', !!process.env.TMUX, 'FORGEN auto-compound relies on tmux. Launch: tmux new -s forgen');
     check('FORGEN_HARNESS env var', (process.env.FORGEN_HARNESS ?? process.env.COMPOUND_HARNESS) === '1', 'Set by `forgen` / `fgx` launcher. Hooks assume harness mode is active.');
     console.log();
-    // 솔루션/규칙 수
+    // v0.4.1 파일 확장자 버그 수정: rules 는 .json, behavior 도 대부분 .json 포맷.
+    // 이전에 .md 만 count 해서 실 rules 4개인데 0 으로 표시되는 incident 관찰.
+    // (compound-export countFiles 와 동일 결함 — 일관된 수정).
+    const isKnowledgeFile = (f) => f.endsWith('.md') || f.endsWith('.json');
     if (exists(ME_SOLUTIONS)) {
-        const solutions = fs.readdirSync(ME_SOLUTIONS).filter((f) => f.endsWith('.md')).length;
+        const solutions = fs.readdirSync(ME_SOLUTIONS).filter(isKnowledgeFile).length;
         console.log(`  Personal solutions: ${solutions}`);
     }
     if (exists(ME_BEHAVIOR)) {
-        const behavior = fs.readdirSync(ME_BEHAVIOR).filter((f) => f.endsWith('.md')).length;
+        const behavior = fs.readdirSync(ME_BEHAVIOR).filter(isKnowledgeFile).length;
         console.log(`  Behavioral patterns: ${behavior}`);
     }
     if (exists(ME_RULES)) {
-        const rules = fs.readdirSync(ME_RULES).filter((f) => f.endsWith('.md')).length;
-        console.log(`  Personal rules: ${rules}`);
+        // v0.4.1 정확도: removed 상태 rule 은 "학습된 규칙" 에서 제외하고 별도 표시.
+        // 이전에는 디렉터리 파일 수만 세어 이미 제거된 rule 도 count 되어 판매 관점
+        // "살아있는 규칙" 수치가 부풀려짐. 실제 구매자 가치는 active + suppressed.
+        const ruleFiles = fs.readdirSync(ME_RULES).filter(isKnowledgeFile);
+        let active = 0, suppressed = 0, removed = 0;
+        for (const f of ruleFiles) {
+            try {
+                const d = JSON.parse(fs.readFileSync(path.join(ME_RULES, f), 'utf-8'));
+                if (d.status === 'active')
+                    active++;
+                else if (d.status === 'suppressed')
+                    suppressed++;
+                else if (d.status === 'removed' || d.status === 'superseded')
+                    removed++;
+            }
+            catch { /* skip */ }
+        }
+        const live = active + suppressed;
+        const removedTag = removed > 0 ? ` (${removed} removed/superseded)` : '';
+        console.log(`  Personal rules: ${live}  [active:${active} suppressed:${suppressed}]${removedTag}`);
     }
     console.log();
     console.log('  [Log Locations]');

package/dist/core/extraction-notice.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Forgen v0.4.1 — Extraction Notice (H2)
+ *
+ * `~/.forgen/state/last-auto-compound.json` 에 기록된 이전 세션의 추출 결과를
+ * Stop hook 에서 1회 surface. noticeShown 플래그로 한번 보여주면 다시 안뜸.
+ *
+ * 목적: v0.4.0 에서 auto-compound 가 8,000+ 번 돌았는데 사용자는 0건 노출. 추출이
+ *   실제로 일어났는지 사용자가 확인할 수 없었다. H2 는 "세션 종료 시 N개 패턴
+ *   학습됨" 1줄을 Stop hook UI (systemMessage) 로 밀어넣는다.
+ */
+/**
+ * Stop hook approve 경로에서 호출. 보여줄 알림이 있으면 1줄 문자열 반환하고
+ * noticeShown=true 로 파일 업데이트 (한 번만 surface). 없으면 null.
+ *
+ * 신선도 컷오프: completedAt 이 30분 이상 지나면 stale 로 간주하고 surface 안함.
+ * 이미 다른 세션에서 본 알림이 튀어나오는 걸 방지.
+ */
+export declare function takeLastExtractionNotice(nowMs?: number): string | null;

package/dist/core/extraction-notice.js

@@ -0,0 +1,64 @@
+/**
+ * Forgen v0.4.1 — Extraction Notice (H2)
+ *
+ * `~/.forgen/state/last-auto-compound.json` 에 기록된 이전 세션의 추출 결과를
+ * Stop hook 에서 1회 surface. noticeShown 플래그로 한번 보여주면 다시 안뜸.
+ *
+ * 목적: v0.4.0 에서 auto-compound 가 8,000+ 번 돌았는데 사용자는 0건 노출. 추출이
+ *   실제로 일어났는지 사용자가 확인할 수 없었다. H2 는 "세션 종료 시 N개 패턴
+ *   학습됨" 1줄을 Stop hook UI (systemMessage) 로 밀어넣는다.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { STATE_DIR } from './paths.js';
+const LAST_AUTO_COMPOUND_PATH = path.join(STATE_DIR, 'last-auto-compound.json');
+/** 정상 실행이면 건너뛰기 좋게 fail-open. */
+function readRecord() {
+    try {
+        if (!fs.existsSync(LAST_AUTO_COMPOUND_PATH))
+            return null;
+        return JSON.parse(fs.readFileSync(LAST_AUTO_COMPOUND_PATH, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Stop hook approve 경로에서 호출. 보여줄 알림이 있으면 1줄 문자열 반환하고
+ * noticeShown=true 로 파일 업데이트 (한 번만 surface). 없으면 null.
+ *
+ * 신선도 컷오프: completedAt 이 30분 이상 지나면 stale 로 간주하고 surface 안함.
+ * 이미 다른 세션에서 본 알림이 튀어나오는 걸 방지.
+ */
+export function takeLastExtractionNotice(nowMs = Date.now()) {
+    const record = readRecord();
+    if (!record || record.noticeShown)
+        return null;
+    const completed = Date.parse(record.completedAt);
+    if (!Number.isFinite(completed))
+        return null;
+    const ageMs = nowMs - completed;
+    if (ageMs > 30 * 60 * 1000)
+        return null; // stale
+    const extracted = record.extractedSolutions ?? 0;
+    const promoted = record.promotedRules ?? 0;
+    if (extracted === 0 && promoted === 0) {
+        // 아무것도 학습되지 않았으면 노이즈. 알림을 소비한 상태로만 마킹.
+        try {
+            fs.writeFileSync(LAST_AUTO_COMPOUND_PATH, JSON.stringify({ ...record, noticeShown: true }));
+        }
+        catch { /* fail-open */ }
+        return null;
+    }
+    // 마킹 — race 는 있으나 double-notice 가 치명적이지 않음 (fail-open).
+    try {
+        fs.writeFileSync(LAST_AUTO_COMPOUND_PATH, JSON.stringify({ ...record, noticeShown: true }));
+    }
+    catch { /* fail-open */ }
+    const parts = [];
+    if (extracted > 0)
+        parts.push(`${extracted}개 패턴 추출`);
+    if (promoted > 0)
+        parts.push(`${promoted}개 규칙 승격`);
+    return `[Forgen] 🧠 세션 학습 완료 — ${parts.join(', ')}`;
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Forgen v0.4.1 — `forgen init` CLI
+ *
+ * 빈 FORGEN_HOME (또는 기존에 starter 미설치 홈) 에 starter-pack 솔루션을
+ * 프로비저닝. npm install-g 시의 postinstall 이 하던 starter 배포 로직을 런타임
+ * CLI 로 노출해 다음 시나리오 지원:
+ *   - `FORGEN_HOME=/tmp/fresh forgen init` — 격리 테스트 환경
+ *   - CI pipeline 신규 컨테이너 프로비저닝
+ *   - 사용자가 실수로 me/solutions 전부 삭제한 뒤 복구
+ *
+ * 보수적 정책: me/solutions 에 **≥5개 파일**이 이미 있으면 건너뜀 (사용자
+ * 실 축적물 보호). `--force` 플래그로 우회 가능. postinstall 의 installStarterPack
+ * 과 동일 규칙.
+ */
+export interface InitResult {
+    solutionsInstalled: number;
+    solutionsSkippedExisting: number;
+    solutionsDir: string;
+    starterDir: string | null;
+    skipped: boolean;
+    skipReason?: string;
+}
+export declare function initializeForgenHome(options?: {
+    force?: boolean;
+}): InitResult;
+export declare function handleInit(args: string[]): Promise<void>;