@wooojin/forgen 0.3.2 → 0.4.0

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,20 @@ export async function handleUninstall(cwd, options) {
     cleanClaudeMd(cwd);
     cleanSlashCommands();
     cleanPluginArtifacts();
+    if (options.purge) {
+        try {
+            const forgenHome = path.join(os.homedir(), '.forgen');
+            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/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/lifecycle/bypass-detector.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Bypass detector — T3 signal source.
+ *
+ * Rule.policy 자연어에서 "피해야 할 패턴" 을 추출하고, Write/Edit/Bash 도구
+ * 출력에서 해당 패턴을 찾아 BypassEntry 후보로 반환한다.
+ *
+ * Heuristic:
+ *   1) "use X not Y" / "use X instead of Y" / "X over Y" → bypass = Y
+ *   2) "avoid X" / "don't use X" / "never use X" / "do not use X" → bypass = X
+ *   3) Korean: "X 말라" / "X 금지" / "X 하지 않" → bypass = X
+ *   4) 그 외: 빈 배열 (탐지 불가).
+ *
+ * 반환된 패턴은 escape 된 정규식 문자열 — caller 가 `new RegExp(p)` 로 사용.
+ */
+import type { Rule } from '../../store/types.js';
+export declare function extractBypassPatterns(rule: Rule): string[];
+export interface BypassScanInput {
+    rules: Rule[];
+    tool_name: string;
+    tool_output: string;
+    session_id: string;
+}
+export interface BypassCandidate {
+    rule_id: string;
+    session_id: string;
+    tool: string;
+    pattern_preview: string;
+    matched: string;
+}
+/**
+ * Pure — rules + tool output 으로 bypass candidates 추출.
+ * 같은 rule/pattern 이 여러 번 매칭돼도 한 번만 기록.
+ */
+export declare function scanForBypass(input: BypassScanInput): BypassCandidate[];

package/dist/engine/lifecycle/bypass-detector.js

@@ -0,0 +1,82 @@
+/**
+ * Bypass detector — T3 signal source.
+ *
+ * Rule.policy 자연어에서 "피해야 할 패턴" 을 추출하고, Write/Edit/Bash 도구
+ * 출력에서 해당 패턴을 찾아 BypassEntry 후보로 반환한다.
+ *
+ * Heuristic:
+ *   1) "use X not Y" / "use X instead of Y" / "X over Y" → bypass = Y
+ *   2) "avoid X" / "don't use X" / "never use X" / "do not use X" → bypass = X
+ *   3) Korean: "X 말라" / "X 금지" / "X 하지 않" → bypass = X
+ *   4) 그 외: 빈 배열 (탐지 불가).
+ *
+ * 반환된 패턴은 escape 된 정규식 문자열 — caller 가 `new RegExp(p)` 로 사용.
+ */
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Trim punctuation 많이 붙은 자연어 표현을 "검색용 토큰" 으로 정규화.
+ * Leading `.` 는 유지 — `.then`, `.mock` 같은 메서드 참조가 의도된 매칭 대상.
+ * Trailing `()` 는 제거 — `.then()` 을 `.then` 으로 정규화해 `.then(x=>...)` 에 매치.
+ */
+function trimPunct(s) {
+    let out = s;
+    // Strip trailing "()" once (natural-language shorthand for method calls)
+    if (out.endsWith('()'))
+        out = out.slice(0, -2);
+    // Strip other leading/trailing punctuation, preserving leading `.`
+    out = out.replace(/^[,;:!?"'`(]+|[.,;:!?"'`)]+$/g, '');
+    return out;
+}
+export function extractBypassPatterns(rule) {
+    const patterns = [];
+    const p = rule.policy;
+    // use X not Y / use X instead of Y / use X over Y
+    // X, Y may contain dots (e.g., ".then()", "vi.mock"). Strip trailing punctuation.
+    const useNot = p.match(/\b(?:use|prefer|choose)\s+(\S+?)\s+(?:not|instead\s+of|over|rather\s+than)\s+(\S+)/i);
+    if (useNot)
+        patterns.push(escapeRegex(trimPunct(useNot[2])));
+    // avoid X / don't use X / never use X / do not use X
+    const avoid = p.match(/\b(?:avoid|don'?t\s+use|never\s+use|do\s+not\s+use)\s+(\S+)/i);
+    if (avoid)
+        patterns.push(escapeRegex(trimPunct(avoid[1])));
+    // Korean: "X 말라" / "X 금지" / "X 하지 마"
+    const ko = p.match(/(\S+)\s*(?:말라|금지|하지\s*마|쓰지\s*마)/);
+    if (ko)
+        patterns.push(escapeRegex(trimPunct(ko[1])));
+    // Dedupe + filter trivial
+    return [...new Set(patterns)].filter((pat) => pat.length >= 2);
+}
+/**
+ * Pure — rules + tool output 으로 bypass candidates 추출.
+ * 같은 rule/pattern 이 여러 번 매칭돼도 한 번만 기록.
+ */
+export function scanForBypass(input) {
+    const { rules, tool_name, tool_output, session_id } = input;
+    const candidates = [];
+    const reported = new Set(); // rule_id|pattern
+    for (const rule of rules) {
+        if (rule.status !== 'active')
+            continue;
+        const patterns = extractBypassPatterns(rule);
+        for (const pat of patterns) {
+            const re = new RegExp(pat, 'i');
+            const m = tool_output.match(re);
+            if (!m)
+                continue;
+            const key = `${rule.rule_id}|${pat}`;
+            if (reported.has(key))
+                continue;
+            reported.add(key);
+            candidates.push({
+                rule_id: rule.rule_id,
+                session_id,
+                tool: tool_name,
+                pattern_preview: pat.slice(0, 40),
+                matched: m[0].slice(0, 40),
+            });
+        }
+    }
+    return candidates;
+}

package/dist/engine/lifecycle/lifecycle-cli.d.ts

@@ -0,0 +1,7 @@
+/**
+ * CLI handler for `forgen lifecycle-scan`.
+ *
+ * 전체 lifecycle 트리거(T1~T5 + Meta) 를 쓴 집계 데이터 기반으로 실행.
+ * default dry-run, --apply 시 rule 파일에 상태 전이 반영.
+ */
+export declare function handleLifecycleScan(args: string[]): Promise<void>;

package/dist/engine/lifecycle/lifecycle-cli.js

@@ -0,0 +1,102 @@
+/**
+ * CLI handler for `forgen lifecycle-scan`.
+ *
+ * 전체 lifecycle 트리거(T1~T5 + Meta) 를 쓴 집계 데이터 기반으로 실행.
+ * default dry-run, --apply 시 rule 파일에 상태 전이 반영.
+ */
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { loadAllRules, saveRule } from '../../store/rule-store.js';
+import { collectSignals, readJsonlSafe } from './signals.js';
+import { detect as detectT2 } from './trigger-t2-violation.js';
+import { detect as detectT3 } from './trigger-t3-bypass.js';
+import { detect as detectT4 } from './trigger-t4-decay.js';
+import { detect as detectT5 } from './trigger-t5-conflict.js';
+import { scanDriftForDemotion, applyDemotion, scanSignalsForPromotion, applyPromotion, readDriftEntries, appendLifecycleEvents, } from './meta-reclassifier.js';
+import { foldEvents } from './orchestrator.js';
+const LIFECYCLE_DIR = path.join(os.homedir(), '.forgen', 'state', 'lifecycle');
+export async function handleLifecycleScan(args) {
+    const apply = args.includes('--apply');
+    const now = Date.now();
+    const rules = loadAllRules();
+    if (rules.length === 0) {
+        console.log('\n  No rules in ~/.forgen/me/rules. Nothing to scan.\n');
+        return;
+    }
+    const violations = readJsonlSafe(path.join(os.homedir(), '.forgen', 'state', 'enforcement', 'violations.jsonl'));
+    const bypass = readJsonlSafe(path.join(os.homedir(), '.forgen', 'state', 'enforcement', 'bypass.jsonl'));
+    const drift = readDriftEntries();
+    const signals = new Map();
+    for (const r of rules)
+        signals.set(r.rule_id, collectSignals(r, { violations, bypass, now }));
+    const events = [
+        ...detectT2({ rules, signals, ts: now }),
+        ...detectT3({ rules, signals, ts: now }),
+        ...detectT4({ rules, signals, ts: now }),
+        ...detectT5({ rules, ts: now }),
+    ];
+    const demotionCandidates = scanDriftForDemotion({ rules, drift, now });
+    const promotionCandidates = scanSignalsForPromotion({ rules, signals, ts: now });
+    console.log(`\n  Lifecycle Scan — ${rules.length} rule(s)  (${apply ? 'APPLY' : 'dry-run'})\n`);
+    console.log(`  Signals: violations.jsonl=${violations.length}  bypass.jsonl=${bypass.length}  drift.jsonl=${drift.length}\n`);
+    if (events.length === 0 && demotionCandidates.length === 0 && promotionCandidates.length === 0) {
+        console.log('  No lifecycle events. System stable.\n');
+        return;
+    }
+    console.log(`  Rule health events: ${events.length}`);
+    const byKind = new Map();
+    for (const e of events)
+        byKind.set(e.kind, (byKind.get(e.kind) ?? 0) + 1);
+    for (const [k, n] of byKind.entries())
+        console.log(`    ${k}: ${n}`);
+    console.log(`\n  Meta candidates: promote=${promotionCandidates.length}  demote=${demotionCandidates.length}`);
+    if (!apply) {
+        for (const e of events) {
+            console.log(`    → ${e.kind.padEnd(24)} rule=${e.rule_id.slice(0, 8)} action=${e.suggested_action}`);
+        }
+        for (const c of demotionCandidates) {
+            console.log(`    → meta_demote              rule=${c.rule_id.slice(0, 8)} events=${c.event_count}`);
+        }
+        for (const c of promotionCandidates) {
+            console.log(`    → meta_promote             rule=${c.rule_id.slice(0, 8)} injects=${c.injects_rolling_n}`);
+        }
+        console.log('\n  Run with --apply to persist.\n');
+        return;
+    }
+    // APPLY path: fold T2~T5 events into rules, save, then do Meta.
+    const byId = foldEvents(rules, events, now);
+    let saved = 0;
+    for (const [ruleId, updated] of byId.entries()) {
+        const original = rules.find((r) => r.rule_id === ruleId);
+        if (!original)
+            continue;
+        if (updated === original)
+            continue;
+        saveRule(updated);
+        saved += 1;
+    }
+    if (events.length > 0)
+        appendLifecycleEvents(events, now);
+    // Meta apply
+    const metaEvents = [];
+    for (const c of demotionCandidates) {
+        const rule = rules.find((r) => r.rule_id === c.rule_id);
+        if (!rule)
+            continue;
+        const result = applyDemotion(rule, c, now);
+        if (result.applied)
+            metaEvents.push(...result.events);
+    }
+    for (const c of promotionCandidates) {
+        const rule = rules.find((r) => r.rule_id === c.rule_id);
+        if (!rule)
+            continue;
+        const result = applyPromotion(rule, c, now);
+        if (result.applied)
+            metaEvents.push(...result.events);
+    }
+    if (metaEvents.length > 0)
+        appendLifecycleEvents(metaEvents, now);
+    console.log(`\n  Applied: ${saved} rule(s) updated, ${metaEvents.length} health event(s).`);
+    console.log(`  Log: ${LIFECYCLE_DIR}/${new Date(now).toISOString().slice(0, 10)}.jsonl\n`);
+}

package/dist/engine/lifecycle/meta-cli.d.ts

@@ -0,0 +1,4 @@
+/**
+ * CLI handler stub for `forgen rule-meta-scan`. Full implementation in Phase 5.
+ */
+export declare function handleRuleMetaScan(args: string[]): Promise<void>;

package/dist/engine/lifecycle/meta-cli.js

@@ -0,0 +1,7 @@
+/**
+ * CLI handler stub for `forgen rule-meta-scan`. Full implementation in Phase 5.
+ */
+export async function handleRuleMetaScan(args) {
+    const { runMetaScan } = await import('./meta-reclassifier.js');
+    await runMetaScan(args);
+}

package/dist/engine/lifecycle/meta-reclassifier.d.ts

@@ -0,0 +1,78 @@
+/**
+ * ADR-002 Meta trigger — drift.jsonl 누적을 읽어 rule 의 mech 재분류 후보를 산출.
+ *
+ * 현 스코프 (v0.4.0 follow-up):
+ *   - `stuck_loop_force_approve` 이벤트를 recent window(기본 7 일) 에서 집계.
+ *   - 같은 rule_id 에서 임계치(기본 3) 이상 발생 시 **Mech demotion 후보** 로 분류.
+ *   - demotion 은 Mech-A/B → 한 단계 완화:
+ *       - A (block 강제) → B (self-check 권고)
+ *       - B (self-check) → C (drift 측정)
+ *       - C 는 그대로 (더 강등 불가)
+ *   - dry-run 기본. `--apply` 시 rule 파일의 enforce_via[].mech 갱신 + meta_promotions 추가.
+ *
+ * v0.4.1+ 확장 여지 (본 파일에는 미구현):
+ *   - Mech promotion (B → A): rolling 20 injects 중 violation 0 → 승급.
+ *     이 경로는 별도 evidence source (solution-outcomes) 필요.
+ *   - 30 일 쿨다운.
+ */
+import type { LifecycleEvent } from './types.js';
+import type { EnforcementMech, Rule } from '../../store/types.js';
+export interface DriftEntry {
+    at: string;
+    kind: string;
+    session_id: string;
+    rule_id: string;
+    count: number;
+    reason_preview?: string;
+    message_preview?: string;
+}
+export interface DemotionCandidate {
+    rule_id: string;
+    event_count: number;
+    first_at: string;
+    last_at: string;
+    sessions: string[];
+    window_days: number;
+    current_mechs: EnforcementMech[];
+}
+export declare function readDriftEntries(driftPath?: string): DriftEntry[];
+export declare function scanDriftForDemotion(options?: {
+    rules: Rule[];
+    drift?: DriftEntry[];
+    windowDays?: number;
+    threshold?: number;
+    cooldownDays?: number;
+    now?: number;
+}): DemotionCandidate[];
+export declare function demoteMech(from: EnforcementMech): EnforcementMech | null;
+export declare function promoteMech(from: EnforcementMech): EnforcementMech | null;
+export interface PromotionCandidate {
+    rule_id: string;
+    injects_rolling_n: number;
+    violations_rolling_n: number;
+    current_mechs: EnforcementMech[];
+    reason: string;
+}
+/**
+ * rolling N 개 inject 중 violation 0 → Mech 승급 후보.
+ * inject 추적 인프라가 완비되기 전에는 `rolling_min_injects` (기본 20) 미만이면 skip.
+ */
+export declare function scanSignalsForPromotion(options: {
+    rules: Rule[];
+    rolling_min_injects?: number;
+    cooldownDays?: number;
+    ts?: number;
+    signals: Map<string, import('./types.js').RuleSignals>;
+}): PromotionCandidate[];
+export declare function applyPromotion(rule: Rule, candidate: PromotionCandidate, now?: number): ApplyResult;
+export interface ApplyResult {
+    rule_id: string;
+    before_mech: EnforcementMech[];
+    after_mech: EnforcementMech[];
+    events: LifecycleEvent[];
+    applied: boolean;
+    reason?: string;
+}
+export declare function applyDemotion(rule: Rule, candidate: DemotionCandidate, now?: number): ApplyResult;
+export declare function appendLifecycleEvents(events: LifecycleEvent[], now?: number): void;
+export declare function runMetaScan(args: string[]): Promise<void>;