@wooojin/forgen 0.3.2 → 0.4.1

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

@@ -0,0 +1,36 @@
+export interface StatsSnapshot {
+    activeRules: number;
+    suppressedRules: number;
+    correctionsTotal: number;
+    corrections7d: number;
+    blocks7d: number;
+    acks7d: number;
+    bypass7d: number;
+    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;
+    };
+}
+export declare function computeStats(): StatsSnapshot;
+export declare function renderStats(s: StatsSnapshot): string;
+export declare function handleStats(_args: string[]): Promise<void>;

package/dist/core/stats-cli.js

@@ -0,0 +1,254 @@
+/**
+ * R9-PA1: `forgen stats` — 7-number single-screen dashboard.
+ *
+ * Pure aggregation over existing jsonl sources. No new telemetry; surfaces
+ * what forgen is *already* learning so users can verify the trust layer is
+ * working between Claude sessions.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { loadAllRules } from '../store/rule-store.js';
+import { loadAllEvidence } from '../store/evidence-store.js';
+import { STATE_DIR, ME_DIR } from './paths.js';
+// v0.4.1 격리 fix: 이전에는 os.homedir() 직접 사용해서 FORGEN_HOME env 로
+// 홈 격리해도 이 파일의 경로는 여전히 실 홈 가리켰음. paths.ts 상수 import.
+const ENFORCEMENT_DIR = path.join(STATE_DIR, 'enforcement');
+const LIFECYCLE_DIR = path.join(STATE_DIR, 'lifecycle');
+const SOLUTIONS_DIR = path.join(ME_DIR, 'solutions');
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+function readJsonl(p) {
+    if (!fs.existsSync(p))
+        return [];
+    const out = [];
+    for (const line of fs.readFileSync(p, 'utf-8').split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch { /* skip malformed */ }
+    }
+    return out;
+}
+function countWithin(entries, days, tsKey = 'at') {
+    const cutoff = Date.now() - days * MS_PER_DAY;
+    let n = 0;
+    for (const e of entries) {
+        const raw = e[tsKey];
+        if (typeof raw !== 'string')
+            continue;
+        const t = Date.parse(raw);
+        if (Number.isFinite(t) && t >= cutoff)
+            n += 1;
+    }
+    return n;
+}
+function readLifecycleRetired(days) {
+    if (!fs.existsSync(LIFECYCLE_DIR))
+        return 0;
+    const cutoff = Date.now() - days * MS_PER_DAY;
+    let n = 0;
+    for (const f of fs.readdirSync(LIFECYCLE_DIR)) {
+        if (!f.endsWith('.jsonl'))
+            continue;
+        for (const entry of readJsonl(path.join(LIFECYCLE_DIR, f))) {
+            const action = entry.suggested_action;
+            const ts = typeof entry.ts === 'number' ? entry.ts : Date.parse(String(entry.ts ?? ''));
+            if (!Number.isFinite(ts) || ts < cutoff)
+                continue;
+            if (action === 'retire' || action === 'supersede')
+                n += 1;
+        }
+    }
+    return n;
+}
+function readLastExtraction() {
+    // v0.4.1 파일명 정합: auto-compound-runner 는 last-auto-compound.json 에 기록.
+    // 이전 코드가 last-extraction.json 을 찾아 "never" 가 만성적으로 표시됨 —
+    // 실은 매 auto-compound 세션마다 값이 업데이트되고 있는데도 stats 에 반영 X.
+    const candidates = ['last-auto-compound.json', 'last-extraction.json'];
+    let p = null;
+    for (const name of candidates) {
+        const candidate = path.join(STATE_DIR, name);
+        if (fs.existsSync(candidate)) {
+            p = candidate;
+            break;
+        }
+    }
+    if (!p)
+        return 'never';
+    try {
+        const data = JSON.parse(fs.readFileSync(p, 'utf-8'));
+        const ts = data.completedAt ?? data.timestamp ?? data.date;
+        if (!ts)
+            return 'never';
+        const diffDays = Math.floor((Date.now() - Date.parse(ts)) / MS_PER_DAY);
+        const dateStr = new Date(ts).toISOString().slice(0, 10);
+        if (diffDays === 0)
+            return `${dateStr} (today)`;
+        if (diffDays === 1)
+            return `${dateStr} (yesterday)`;
+        return `${dateStr} (${diffDays}d ago)`;
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/** H3: 오늘 (local midnight ~ now) 기준 assist 카운트. */
+function computeAssistToday() {
+    const startOfDay = new Date();
+    startOfDay.setHours(0, 0, 0, 0);
+    const cutoffMs = startOfDay.getTime();
+    // recall hits: match-eval-log 의 오늘 entries
+    const matchLog = readJsonl(path.join(STATE_DIR, 'match-eval-log.jsonl'));
+    let recallHits = 0;
+    for (const e of matchLog) {
+        const ts = typeof e.ts === 'string' ? Date.parse(e.ts) : NaN;
+        if (Number.isFinite(ts) && ts >= cutoffMs)
+            recallHits++;
+    }
+    // surfaced + referenced — 같은 스트림 1회 loop 로.
+    const feedback = readJsonl(path.join(STATE_DIR, 'implicit-feedback.jsonl'));
+    let surfaced = 0;
+    let referenced = 0;
+    for (const e of feedback) {
+        const ts = typeof e.at === 'string' ? Date.parse(e.at) : NaN;
+        if (!Number.isFinite(ts) || ts < cutoffMs)
+            continue;
+        if (e.type === 'recommendation_surfaced')
+            surfaced++;
+        else if (e.type === 'recall_referenced')
+            referenced++;
+    }
+    // extracted today: solutions dir 에서 오늘 mtime 인 .md 파일
+    let extractedToday = 0;
+    try {
+        if (fs.existsSync(SOLUTIONS_DIR)) {
+            for (const f of fs.readdirSync(SOLUTIONS_DIR)) {
+                if (!f.endsWith('.md'))
+                    continue;
+                const stat = fs.statSync(path.join(SOLUTIONS_DIR, f));
+                if (stat.mtimeMs >= cutoffMs)
+                    extractedToday++;
+            }
+        }
+    }
+    catch { /* fail-open */ }
+    return { recallHits, surfaced, referenced, extractedToday };
+}
+/** v0.4.1: forge-profile 에서 고도화 지표 추출. 파일 없거나 깨지면 undefined. */
+function computePhilosophy() {
+    try {
+        const profilePath = path.join(ME_DIR, 'forge-profile.json');
+        if (!fs.existsSync(profilePath))
+            return undefined;
+        const d = JSON.parse(fs.readFileSync(profilePath, 'utf-8'));
+        const axisScores = {};
+        for (const [k, v] of Object.entries(d.axes ?? {})) {
+            if (v && typeof v.score === 'number')
+                axisScores[k] = v.score;
+        }
+        return {
+            basePacks: Object.values(d.base_packs ?? {}),
+            trustPolicy: d.trust_preferences?.desired_policy ?? 'unknown',
+            axisScores,
+            lastReclassification: d.metadata?.last_reclassification_at ?? null,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function computeStats() {
+    const rules = loadAllRules();
+    const activeRules = rules.filter((r) => r.status === 'active').length;
+    const suppressedRules = rules.filter((r) => r.status === 'suppressed').length;
+    // v0.4.1 정확도 수정: loadRecentEvidence(500) 제한은 "Corrections (total)"
+    // 라벨과 모순 — 실 behavior 618건 중 118건 누락됐음. 전체 evidence 스캔으로
+    // 교체. explicit_correction 만 filter 이므로 memory overhead 는 N * ~1KB 수준.
+    const evidence = loadAllEvidence();
+    const corrections = evidence.filter((e) => e.type === 'explicit_correction');
+    const correctionsTotal = corrections.length;
+    const cutoff7d = Date.now() - 7 * MS_PER_DAY;
+    const corrections7d = corrections.filter((e) => Date.parse(e.timestamp) >= cutoff7d).length;
+    const violations = readJsonl(path.join(ENFORCEMENT_DIR, 'violations.jsonl'));
+    // v0.4.1 historical false-positive 제거: pre-0.4.1 bypass-detector 가 Write/Edit
+    // content 의 quote 본문까지 raw 매칭해서 bypass 로 오기록. 실 관찰: L1-no-rm-rf
+    // -unconfirmed bypass 20건 중 Write/Edit 15건. stats 표시는 **실 실행 맥락** 인
+    // Bash/Agent/기타만 집계 — 앞으로의 시계열 일관성 + 과거 noise 제거.
+    const bypassRaw = readJsonl(path.join(ENFORCEMENT_DIR, 'bypass.jsonl'));
+    const bypass = bypassRaw.filter((e) => e.tool !== 'Write' && e.tool !== 'Edit');
+    const drift = readJsonl(path.join(ENFORCEMENT_DIR, 'drift.jsonl'));
+    const acks = readJsonl(path.join(ENFORCEMENT_DIR, 'acknowledgments.jsonl'));
+    // R9-PA2: violations 는 'block' (stop-guard/post-tool) + 'deny' (pre-tool Mech-A)
+    // + 'correction' (user bypass audit) 혼재. 사용자 관점에서 "Block" 은 앞의 2종이며
+    // correction 은 제외해야 ack ratio 가 의미를 갖는다. legacy-undefined 엔트리도 포함.
+    const realBlocks = violations.filter((e) => e.kind === 'block' || e.kind === 'deny' || e.kind === undefined);
+    return {
+        activeRules,
+        suppressedRules,
+        correctionsTotal,
+        corrections7d,
+        blocks7d: countWithin(realBlocks, 7),
+        acks7d: countWithin(acks, 7),
+        bypass7d: countWithin(bypass, 7),
+        drift7d: countWithin(drift, 7),
+        retired7d: readLifecycleRetired(7),
+        lastExtraction: readLastExtraction(),
+        assistToday: computeAssistToday(),
+        philosophy: computePhilosophy(),
+    };
+}
+function padNum(n, width = 4) {
+    return String(n).padStart(width);
+}
+export function renderStats(s) {
+    const lines = [];
+    lines.push('');
+    lines.push('  forgen — trust layer status');
+    lines.push('  ───────────────────────────');
+    lines.push(`  Active rules          ${padNum(s.activeRules)}    (${s.suppressedRules} suppressed)`);
+    lines.push(`  Corrections (total)   ${padNum(s.correctionsTotal)}    (+${s.corrections7d} last 7d)`);
+    lines.push('');
+    lines.push('  Last 7 days');
+    // R9-PA2: ack rate = block→retract→pass 루프가 실제 작동한 비율.
+    const ackRateLabel = s.blocks7d > 0
+        ? `(${Math.round((s.acks7d / s.blocks7d) * 100)}% acknowledged)`
+        : '';
+    lines.push(`    Blocks              ${padNum(s.blocks7d)}    — times Claude was asked to retract ${ackRateLabel}`);
+    lines.push(`    Acknowledgments     ${padNum(s.acks7d)}    — block → retract → pass loops`);
+    lines.push(`    Bypass              ${padNum(s.bypass7d)}    — user overrides`);
+    lines.push(`    Drift events        ${padNum(s.drift7d)}    — stuck-loop force-approves`);
+    lines.push(`    Retired rules       ${padNum(s.retired7d)}    — superseded or timed out`);
+    lines.push('');
+    // H3: Assist 축 — enforcement 옆에 나란히 가시화.
+    lines.push('  Today (assist)');
+    lines.push(`    Recall hits         ${padNum(s.assistToday.recallHits)}    — compound 매칭 시도 수`);
+    lines.push(`    Surfaced            ${padNum(s.assistToday.surfaced)}    — 실제 주입된 솔루션 수`);
+    const ratio = s.assistToday.surfaced > 0
+        ? ` (${Math.round(100 * s.assistToday.referenced / s.assistToday.surfaced)}% referenced)`
+        : '';
+    lines.push(`    Referenced          ${padNum(s.assistToday.referenced)}    — Claude 응답에 인용됨${ratio}`);
+    lines.push(`    Extracted           ${padNum(s.assistToday.extractedToday)}    — 오늘 새로 저장된 패턴`);
+    lines.push('');
+    // v0.4.1 철학 고도화 단면 — "개인화가 어디까지 학습됐나" 1섹션.
+    if (s.philosophy) {
+        lines.push('  Philosophy (learned)');
+        lines.push(`    Base packs          ${s.philosophy.basePacks.join(' / ')}`);
+        lines.push(`    Trust policy        ${s.philosophy.trustPolicy}`);
+        const scores = Object.entries(s.philosophy.axisScores)
+            .map(([k, v]) => `${k}:${v.toFixed(2)}`)
+            .join('  ');
+        if (scores)
+            lines.push(`    Axis scores         ${scores}`);
+        lines.push(`    Last reclass        ${s.philosophy.lastReclassification ?? 'never'}`);
+        lines.push('');
+    }
+    lines.push(`  Last extraction: ${s.lastExtraction}`);
+    lines.push('');
+    return lines.join('\n');
+}
+export async function handleStats(_args) {
+    const snap = computeStats();
+    console.log(renderStats(snap));
+}

package/dist/core/uninstall.d.ts

@@ -1,4 +1,5 @@
 /** forgen uninstall 메인 */
 export declare function handleUninstall(cwd: string, options: {
     force?: boolean;
+    purge?: boolean;
 }): Promise<void>;

package/dist/core/uninstall.js

@@ -291,8 +291,16 @@ export async function handleUninstall(cwd, options) {
     console.log('  4. Remove forgen block from CLAUDE.md');
     console.log('  5. Remove slash commands (~/.claude/commands/forgen/)');
     console.log('  6. Remove plugin artifacts (cache, installed_plugins.json, plugin directory)');
+    if (options.purge) {
+        console.log('  7. --purge: Delete ~/.forgen/ entirely (rules, me/, state/, solutions/, behavior/)');
+        console.log('     WARNING: this erases all accumulated corrections, rules, drift, and lifecycle history.');
+    }
+    else {
+        console.log('');
+        console.log('Note: ~/.forgen/ directory is preserved. Use --purge to also delete it.');
+        console.log('      (manual: rm -rf ~/.forgen)');
+    }
     console.log('');
-    console.log('Note: ~/.forgen/ directory is preserved (manual deletion: rm -rf ~/.forgen)\n');
     if (!options.force) {
         if (!process.stdin.isTTY) {
             console.error('[forgen] Use --force flag in non-interactive environments.');
@@ -311,5 +319,21 @@ export async function handleUninstall(cwd, options) {
     cleanClaudeMd(cwd);
     cleanSlashCommands();
     cleanPluginArtifacts();
+    if (options.purge) {
+        try {
+            const { FORGEN_HOME } = await import('./paths.js');
+            const forgenHome = FORGEN_HOME;
+            if (fs.existsSync(forgenHome)) {
+                fs.rmSync(forgenHome, { recursive: true, force: true });
+                console.log('  ✓ Deleted ~/.forgen/ (all rules, state, solutions, behavior)');
+            }
+            else {
+                console.log('  ✓ ~/.forgen/ already absent');
+            }
+        }
+        catch (e) {
+            console.log(`  ✗ ~/.forgen/ deletion failed: ${e.message}`);
+        }
+    }
     console.log('\n[forgen] Uninstall complete. Restart Claude Code for a clean state.\n');
 }

package/dist/core/v1-bootstrap.js

@@ -19,7 +19,7 @@ import { FORGEN_HOME, ME_DIR, ME_RULES, ME_BEHAVIOR, V1_RECOMMENDATIONS_DIR, V1_
 import { checkLegacyProfile, runLegacyCutover } from './legacy-detector.js';
 import { detectRuntimeCapability } from './runtime-detector.js';
 import { loadProfile, profileExists } from '../store/profile-store.js';
-import { loadActiveRules, cleanupStaleSessionRules } from '../store/rule-store.js';
+import { loadActiveRules, cleanupStaleSessionRules, markRulesInjected } from '../store/rule-store.js';
 import { composeSession } from '../preset/preset-manager.js';
 import { renderRules, DEFAULT_CONTEXT } from '../renderer/rule-renderer.js';
 import { saveSessionState, loadRecentSessions } from '../store/session-state-store.js';
@@ -82,6 +82,14 @@ export function bootstrapV1Session() {
     // 6. Rule 렌더링
     const allRules = [...personalRules];
     const renderedRules = renderRules(allRules, session, profile, DEFAULT_CONTEXT);
+    // 6b. Inject tracking (ADR-002 Meta signal) — rendered rules count as injected.
+    // Fail-open: tracking failure must not block bootstrap.
+    try {
+        const injected = allRules.filter((r) => r.status === 'active').map((r) => r.rule_id);
+        if (injected.length > 0)
+            markRulesInjected(injected);
+    }
+    catch { /* ignore */ }
     // 7. Mismatch 감지 (최근 3세션 rolling)
     let mismatchResult = null;
     try {

package/dist/engine/classify-enforce-cli.d.ts

@@ -0,0 +1,8 @@
+/**
+ * CLI handler for `forgen classify-enforce [--apply] [--force]`.
+ *
+ * 기본: dry-run — 각 rule 의 제안만 출력. 변경 없음.
+ * --apply: 제안을 rule 파일에 저장 (enforce_via 미설정 rule 만).
+ * --force: enforce_via 가 이미 있어도 덮어쓴다.
+ */
+export declare function handleClassifyEnforce(args: string[]): Promise<void>;

package/dist/engine/classify-enforce-cli.js

@@ -0,0 +1,61 @@
+/**
+ * CLI handler for `forgen classify-enforce [--apply] [--force]`.
+ *
+ * 기본: dry-run — 각 rule 의 제안만 출력. 변경 없음.
+ * --apply: 제안을 rule 파일에 저장 (enforce_via 미설정 rule 만).
+ * --force: enforce_via 가 이미 있어도 덮어쓴다.
+ */
+import { loadAllRules, saveRule } from '../store/rule-store.js';
+import { classifyAll, applyProposal } from './enforce-classifier.js';
+export async function handleClassifyEnforce(args) {
+    const apply = args.includes('--apply');
+    const force = args.includes('--force');
+    const rules = loadAllRules();
+    if (rules.length === 0) {
+        console.log('\n  No rules in ~/.forgen/me/rules. Nothing to classify.\n');
+        return;
+    }
+    const proposals = classifyAll(rules);
+    let saved = 0;
+    let skipped = 0;
+    let alreadySet = 0;
+    console.log(`\n  Enforce Classifier — ${rules.length} rule(s) scanned\n`);
+    for (let i = 0; i < proposals.length; i++) {
+        const p = proposals[i];
+        const rule = rules[i];
+        const marker = p.current_enforce_via ? '↻' : '+';
+        console.log(`  ${marker} ${p.rule_id.slice(0, 8)}  "${p.trigger_preview}"`);
+        console.log(`     strength=${rule.strength}  status=${rule.status}`);
+        for (const spec of p.proposed) {
+            const vparts = [spec.verifier?.kind ?? 'none'];
+            if (spec.drift_key)
+                vparts.push(`drift_key=${spec.drift_key}`);
+            console.log(`     → Mech-${spec.mech} @ ${spec.hook}  verifier=${vparts.join(' ')}`);
+        }
+        for (const reason of p.reasoning) {
+            console.log(`       · ${reason}`);
+        }
+        if (apply) {
+            if (p.current_enforce_via && p.current_enforce_via.length > 0 && !force) {
+                alreadySet += 1;
+                console.log('       (skipped — enforce_via already set; use --force to overwrite)');
+            }
+            else {
+                const updated = applyProposal(rule, p, { force });
+                saveRule(updated);
+                saved += 1;
+                console.log('       (saved)');
+            }
+        }
+        else {
+            skipped += 1;
+        }
+        console.log('');
+    }
+    if (apply) {
+        console.log(`  Summary: saved=${saved}  already-set=${alreadySet}  total=${rules.length}\n`);
+    }
+    else {
+        console.log(`  Summary: ${skipped} proposal(s) previewed.  Run with --apply to save.\n`);
+    }
+}

package/dist/engine/compound-cli.js

@@ -65,6 +65,7 @@ export function listSolutions() {
     }
     const order = ['mature', 'verified', 'candidate', 'experiment', 'retired'];
     console.log('\n  Compound Entries\n');
+    console.log('  (inj: 누적 주입, ref: 명시 참조, neg: 부정 피드백 — ref 측정은 v0.4.1+ 부터 시작됨)\n');
     let total = 0;
     for (const status of order) {
         const group = groups[status];

package/dist/engine/compound-export.js

@@ -33,14 +33,19 @@ export function isPathInside(parentWithSep, candidate) {
     return resolved.startsWith(parentWithSep) && resolved !== parentWithSep;
 }
 /**
- * Count .md files in a directory (non-recursive).
- * Returns 0 if the directory does not exist.
+ * Count knowledge files in a directory (non-recursive). `.md` (solutions) + `.json`
+ * (rules, behavior, evidence) 둘 다 포함.
+ *
+ * v0.4.1 (2026-04-24): 이전에는 `.md` 만 세서 rules/*.json 전부가 count=0, export
+ * 대상에서도 제외됐다. 실증: `forgen compound export` 결과 rules 0, behavior 18
+ * (618건의 .json 누락). 사용자 철학의 **핵심**인 rules 가 하네스에서 빠진 상태
+ * 라 "나와 같은 데이터 하네스" 비전이 반쪽이었다.
  */
 function countFiles(dir) {
     try {
         if (!fs.existsSync(dir))
             return 0;
-        return fs.readdirSync(dir).filter(f => f.endsWith('.md')).length;
+        return fs.readdirSync(dir).filter(f => f.endsWith('.md') || f.endsWith('.json')).length;
     }
     catch {
         return 0;

package/dist/engine/enforce-classifier.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Forgen — Enforce Classifier (ADR-001 §Migration)
+ *
+ * 기존 Rule 에 `enforce_via: EnforceSpec[]` 이 없을 때, trigger/policy 자연어
+ * 패턴과 strength 조합으로 mech(A/B/C) 와 hook 을 자동 제안한다.
+ *
+ * 휴리스틱 (ADR-001 §Migration heuristics):
+ *   - trigger/policy 에 `rm|force|DROP|credentials|\.env` → Mech-A PreToolUse + tool_arg_regex
+ *   - trigger/policy 에 `완료|complete|done|e2e|mock|verify` → Mech-A Stop + artifact_check
+ *   - strength ∈ {strong, hard} + 문체/응답 맥락 → Mech-B UserPromptSubmit + self_check_prompt
+ *   - 그 외 soft/default → Mech-C (drift 측정)
+ *
+ * 설계 원칙:
+ *   - pure: classify(rule) 는 부수효과 없음. CLI 에서만 save 가 발생.
+ *   - 미리 존재하는 enforce_via 는 덮어쓰지 않음 (`force=false` 기본).
+ *   - 신규 제안은 reason 주석(문자열) 과 함께 반환해 사용자 리뷰 가능.
+ */
+import type { Rule, EnforceSpec } from '../store/types.js';
+export interface EnforceProposal {
+    rule_id: string;
+    trigger_preview: string;
+    current_enforce_via: EnforceSpec[] | null;
+    proposed: EnforceSpec[];
+    reasoning: string[];
+}
+export declare function classify(rule: Rule): EnforceProposal;
+export declare function classifyAll(rules: Rule[]): EnforceProposal[];
+/** 제안을 적용해 새 Rule 을 반환 (pure). 이미 enforce_via 가 있으면 force=false 에서 건너뜀. */
+export declare function applyProposal(rule: Rule, proposal: EnforceProposal, options?: {
+    force?: boolean;
+}): Rule;

package/dist/engine/enforce-classifier.js

@@ -0,0 +1,123 @@
+/**
+ * Forgen — Enforce Classifier (ADR-001 §Migration)
+ *
+ * 기존 Rule 에 `enforce_via: EnforceSpec[]` 이 없을 때, trigger/policy 자연어
+ * 패턴과 strength 조합으로 mech(A/B/C) 와 hook 을 자동 제안한다.
+ *
+ * 휴리스틱 (ADR-001 §Migration heuristics):
+ *   - trigger/policy 에 `rm|force|DROP|credentials|\.env` → Mech-A PreToolUse + tool_arg_regex
+ *   - trigger/policy 에 `완료|complete|done|e2e|mock|verify` → Mech-A Stop + artifact_check
+ *   - strength ∈ {strong, hard} + 문체/응답 맥락 → Mech-B UserPromptSubmit + self_check_prompt
+ *   - 그 외 soft/default → Mech-C (drift 측정)
+ *
+ * 설계 원칙:
+ *   - pure: classify(rule) 는 부수효과 없음. CLI 에서만 save 가 발생.
+ *   - 미리 존재하는 enforce_via 는 덮어쓰지 않음 (`force=false` 기본).
+ *   - 신규 제안은 reason 주석(문자열) 과 함께 반환해 사용자 리뷰 가능.
+ */
+const DESTRUCTIVE_PATTERN = /\b(rm\s+-rf|rm\s+-fr|force|DROP\s+TABLE|credentials|\.env|sudo|mkfs|dd\s+if=)/i;
+const COMPLETION_PATTERN = /(완료|complete|done|ready|shipped|finished|e2e|mock|verify|검증|배포)/i;
+const STYLE_PATTERN = /(문체|응답|설명|톤|어투|장황|간결|verbose|tone|style)/i;
+// R6-F2: shared single source of truth — stop-guard 와 동일 regex 재사용.
+import { DEFAULT_STOP_TRIGGER_RE as STOP_COMPLETION_TRIGGER, DEFAULT_STOP_EXCLUDE_RE as STOP_COMPLETION_EXCLUDE, MOCK_TRIGGER_RE as STOP_MOCK_TRIGGER, MOCK_EXCLUDE_RE as STOP_MOCK_EXCLUDE, } from '../hooks/shared/stop-triggers.js';
+export function classify(rule) {
+    const reasoning = [];
+    const proposed = [];
+    const text = `${rule.trigger}\n${rule.policy}`;
+    const isDestructive = DESTRUCTIVE_PATTERN.test(text);
+    const isCompletion = COMPLETION_PATTERN.test(text);
+    const isStyle = STYLE_PATTERN.test(text);
+    const isStrong = rule.strength === 'strong' || rule.strength === 'hard';
+    // Mech-A PreToolUse — 파괴적 명령 패턴.
+    // 이전에는 DESTRUCTIVE_PATTERN.source 를 다시 .match() 하여 alternation 의 첫 리터럴
+    // ("credentials") 만 반환하는 버그가 있었음. 이제 rule 텍스트에서 실제 매칭된 구문을
+    // 뽑아 그 구문에 맞는 runtime regex 로 변환.
+    if (isDestructive) {
+        const matched = text.match(DESTRUCTIVE_PATTERN);
+        const matchedLiteral = matched?.[0] ?? '';
+        // 안전을 위해 매칭된 literal 을 공백 보존 + escape 해서 runtime regex 로 재구성.
+        // 예: "rm -rf" → "rm\s+-rf" (공백 유연); "DROP TABLE" → "DROP\s+TABLE"; ".env" → "\.env"
+        const pattern = matchedLiteral
+            ? matchedLiteral
+                .replace(/[.*+?^${}()|[\]\\]/g, '\\$&') // escape regex metachar
+                .replace(/\s+/g, '\\s+') // 공백 하나 이상
+            : 'rm\\s+-rf'; // fallback
+        proposed.push({
+            mech: 'A',
+            hook: 'PreToolUse',
+            verifier: {
+                kind: 'tool_arg_regex',
+                params: { pattern, requires_flag: 'user_confirmed' },
+            },
+            block_message: `${rule.rule_id.slice(0, 8)}: ${rule.policy.slice(0, 80)}`,
+        });
+        reasoning.push(`destructive literal "${matchedLiteral}" → Mech-A PreToolUse+tool_arg_regex ${pattern}`);
+    }
+    // Mech-A Stop — 완료 선언 + 증거 요구 (destructive 와 독립적으로 평가: 하나의 rule 이 둘 다 해당 가능)
+    if (isCompletion) {
+        const mockAsProof = /mock|stub|fake/i.test(text);
+        // 증거 파일 경로는 v0.4.0 최종 구현에서 rule.policy 에서 추출; 지금은 default 사용
+        proposed.push({
+            mech: 'A',
+            hook: 'Stop',
+            verifier: {
+                kind: 'artifact_check',
+                params: { path: '.forgen/state/e2e-result.json', max_age_s: 3600 },
+            },
+            block_message: `${rule.rule_id.slice(0, 8)}: ${rule.policy.slice(0, 120)}`,
+            trigger_keywords_regex: mockAsProof ? STOP_MOCK_TRIGGER : STOP_COMPLETION_TRIGGER,
+            trigger_exclude_regex: mockAsProof ? STOP_MOCK_EXCLUDE : STOP_COMPLETION_EXCLUDE,
+            system_tag: `rule:${rule.rule_id.slice(0, 8)} — ${mockAsProof ? 'no-mock-as-proof' : 'e2e-before-done'}`,
+        });
+        reasoning.push(mockAsProof
+            ? 'completion + mock keyword → Mech-A Stop+artifact_check (mock trigger)'
+            : 'completion keyword → Mech-A Stop+artifact_check (completion trigger)');
+    }
+    // Mech-B — 문체/응답 관련 또는 strong/hard 정책이지만 기계 판정 어려운 경우
+    if ((isStyle || (isStrong && !isDestructive && !isCompletion))) {
+        proposed.push({
+            mech: 'B',
+            hook: 'Stop',
+            verifier: {
+                kind: 'self_check_prompt',
+                params: {
+                    question: `직전 응답이 다음 규칙을 위반했는지 자가점검하라: "${rule.policy.slice(0, 120)}". 위반 시 구체적 근거와 함께 수정해 재응답하라.`,
+                },
+            },
+            trigger_keywords_regex: STOP_COMPLETION_TRIGGER,
+            trigger_exclude_regex: STOP_COMPLETION_EXCLUDE,
+            system_tag: `rule:${rule.rule_id.slice(0, 8)} — style-check`,
+        });
+        reasoning.push(isStyle ? 'style/tone keyword → Mech-B Stop+self_check_prompt' : 'strong/hard strength + non-mechanical → Mech-B Stop+self_check_prompt');
+    }
+    // 잔여 — drift measure only (Mech-C)
+    if (proposed.length === 0) {
+        proposed.push({
+            mech: 'C',
+            hook: 'PostToolUse',
+            drift_key: `rule.${rule.rule_id.slice(0, 8)}`,
+        });
+        reasoning.push('no direct enforcement pattern → Mech-C drift measurement');
+    }
+    return {
+        rule_id: rule.rule_id,
+        trigger_preview: rule.trigger.slice(0, 60),
+        current_enforce_via: rule.enforce_via ?? null,
+        proposed,
+        reasoning,
+    };
+}
+export function classifyAll(rules) {
+    return rules.map(classify);
+}
+/** 제안을 적용해 새 Rule 을 반환 (pure). 이미 enforce_via 가 있으면 force=false 에서 건너뜀. */
+export function applyProposal(rule, proposal, options = {}) {
+    if (rule.enforce_via && rule.enforce_via.length > 0 && !options.force) {
+        return rule;
+    }
+    return {
+        ...rule,
+        enforce_via: proposal.proposed,
+        updated_at: new Date().toISOString(),
+    };
+}

package/dist/engine/learn-cli.js

@@ -1,14 +1,11 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import * as os from 'node:os';
 import { fixupSolutions } from './solution-fixup.js';
 import { listQuarantined, pruneQuarantine } from './solution-quarantine.js';
 import { computeFitness } from './solution-fitness.js';
 import { buildWeaknessReport, saveWeaknessReport } from './solution-weakness.js';
 import { listCandidates, promoteCandidate, rollbackSince } from './solution-candidate.js';
-const ME_SOLUTIONS = path.join(os.homedir(), '.forgen', 'me', 'solutions');
-const STATE_DIR = path.join(os.homedir(), '.forgen', 'state');
-const OUTCOMES_DIR = path.join(STATE_DIR, 'outcomes');
+import { ME_SOLUTIONS, OUTCOMES_DIR } from '../core/paths.js';
 export async function handleLearn(args) {
     const sub = args[0];
     if (sub === 'fix-up')