@wooojin/forgen 0.3.2 → 0.4.1

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 { loadAllRules, saveRule } from '../../store/rule-store.js';
+import { STATE_DIR } from '../../core/paths.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(STATE_DIR, '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(STATE_DIR, 'enforcement', 'violations.jsonl'));
+    const bypass = readJsonlSafe(path.join(STATE_DIR, '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>;

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

@@ -0,0 +1,351 @@
+/**
+ * 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 * as fs from 'node:fs';
+import * as path from 'node:path';
+import { initLifecycle } from '../../store/rule-lifecycle.js';
+import { loadAllRules, saveRule } from '../../store/rule-store.js';
+import { STATE_DIR } from '../../core/paths.js';
+const DRIFT_LOG_PATH = path.join(STATE_DIR, 'enforcement', 'drift.jsonl');
+const LIFECYCLE_DIR = path.join(STATE_DIR, 'lifecycle');
+const DEFAULT_WINDOW_DAYS = 7;
+const DEFAULT_THRESHOLD = 3;
+/** R8-A1: Meta 재분류 쿨다운 (일). 최근 이 기간 내 변경된 rule 은 다시 재분류 금지. */
+const DEFAULT_COOLDOWN_DAYS = 30;
+/** R8-A1: rule 이 최근 쿨다운 내에 mech 변경됐는지 판정. */
+function isRecentlyClassified(rule, nowMs, cooldownMs) {
+    const promotions = rule.lifecycle?.meta_promotions ?? [];
+    if (promotions.length === 0)
+        return false;
+    const lastAt = promotions[promotions.length - 1].at;
+    const lastMs = Date.parse(lastAt);
+    if (!Number.isFinite(lastMs))
+        return false;
+    return nowMs - lastMs < cooldownMs;
+}
+export function readDriftEntries(driftPath = DRIFT_LOG_PATH) {
+    if (!fs.existsSync(driftPath))
+        return [];
+    try {
+        const raw = fs.readFileSync(driftPath, 'utf-8');
+        return raw
+            .trim()
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((e) => e !== null);
+    }
+    catch {
+        return [];
+    }
+}
+export function scanDriftForDemotion(options = { rules: [] }) {
+    const windowDays = options.windowDays ?? DEFAULT_WINDOW_DAYS;
+    const threshold = options.threshold ?? DEFAULT_THRESHOLD;
+    const now = options.now ?? Date.now();
+    const cutoff = now - windowDays * 24 * 60 * 60 * 1000;
+    const drift = options.drift ?? readDriftEntries();
+    const byRule = new Map();
+    for (const e of drift) {
+        if (e.kind !== 'stuck_loop_force_approve')
+            continue;
+        const t = Date.parse(e.at);
+        if (!Number.isFinite(t) || t < cutoff)
+            continue;
+        const list = byRule.get(e.rule_id) ?? [];
+        list.push(e);
+        byRule.set(e.rule_id, list);
+    }
+    const candidates = [];
+    // R8-A1: Meta oscillation cooldown — 최근 N일 내 mech 변경된 rule 은 재분류 skip.
+    // architect 예측 "A↔B ping-pong" 차단. 기본 30일.
+    const cooldownMs = (options.cooldownDays ?? DEFAULT_COOLDOWN_DAYS) * 24 * 60 * 60 * 1000;
+    for (const [ruleId, entries] of byRule.entries()) {
+        if (entries.length < threshold)
+            continue;
+        // M fix: exact match — 이전에는 startsWith 로 인해 "L1" prefix 로 여러 L1-* rule 이 교차 오염됐음.
+        const rule = options.rules.find((r) => r.rule_id === ruleId);
+        // C2: hard strength rule 은 Meta demote 대상에서 제외 (ADR-002 불변 원칙).
+        if (rule?.strength === 'hard')
+            continue;
+        // R8-A1: cooldown 체크
+        if (rule && isRecentlyClassified(rule, now, cooldownMs))
+            continue;
+        const currentMechs = (rule?.enforce_via ?? [])
+            .map((s) => s.mech)
+            .filter((m, i, arr) => arr.indexOf(m) === i);
+        const sortedTs = entries.map((e) => Date.parse(e.at)).sort((a, b) => a - b);
+        candidates.push({
+            rule_id: ruleId,
+            event_count: entries.length,
+            first_at: new Date(sortedTs[0]).toISOString(),
+            last_at: new Date(sortedTs[sortedTs.length - 1]).toISOString(),
+            sessions: [...new Set(entries.map((e) => e.session_id))],
+            window_days: windowDays,
+            current_mechs: currentMechs,
+        });
+    }
+    return candidates;
+}
+export function demoteMech(from) {
+    if (from === 'A')
+        return 'B';
+    if (from === 'B')
+        return 'C';
+    return null;
+}
+export function promoteMech(from) {
+    if (from === 'B')
+        return 'A';
+    if (from === 'C')
+        return 'B';
+    return null;
+}
+/**
+ * rolling N 개 inject 중 violation 0 → Mech 승급 후보.
+ * inject 추적 인프라가 완비되기 전에는 `rolling_min_injects` (기본 20) 미만이면 skip.
+ */
+export function scanSignalsForPromotion(options) {
+    const minInjects = options.rolling_min_injects ?? 20;
+    const out = [];
+    // R8-A1: promote 도 cooldown 적용. architect 예측대로 promote → demote → promote ping-pong 차단.
+    const cooldownMs = (options.cooldownDays ?? DEFAULT_COOLDOWN_DAYS) * 24 * 60 * 60 * 1000;
+    const nowMs = options.ts ?? Date.now();
+    for (const rule of options.rules) {
+        if (rule.status !== 'active')
+            continue;
+        // C2: hard rule 은 promote 도 불변 (이미 최강이거나 사용자 의도적 고정).
+        if (rule.strength === 'hard')
+            continue;
+        if (isRecentlyClassified(rule, nowMs, cooldownMs))
+            continue;
+        const s = options.signals.get(rule.rule_id);
+        if (!s)
+            continue;
+        if (s.injects_rolling_n < minInjects)
+            continue;
+        if (s.violations_rolling_n > 0)
+            continue;
+        const mechs = (rule.enforce_via ?? []).map((spec) => spec.mech);
+        const hasPromotable = mechs.some((m) => m === 'B' || m === 'C');
+        if (!hasPromotable)
+            continue;
+        out.push({
+            rule_id: rule.rule_id,
+            injects_rolling_n: s.injects_rolling_n,
+            violations_rolling_n: s.violations_rolling_n,
+            current_mechs: [...new Set(mechs)],
+            reason: `rolling ${s.injects_rolling_n} injects, 0 violations — promotion candidate`,
+        });
+    }
+    return out;
+}
+export function applyPromotion(rule, candidate, now = Date.now()) {
+    const specs = rule.enforce_via ?? [];
+    const before = specs.map((s) => s.mech);
+    const events = [];
+    let changed = false;
+    const updatedSpecs = specs.map((spec) => {
+        const to = promoteMech(spec.mech);
+        if (to == null)
+            return spec;
+        changed = true;
+        events.push({
+            kind: 'meta_promote_to_a',
+            rule_id: rule.rule_id,
+            evidence: {
+                source: 'signals',
+                refs: [],
+                metrics: { injects_rolling_n: candidate.injects_rolling_n, violations_rolling_n: candidate.violations_rolling_n },
+            },
+            suggested_action: 'promote_mech',
+            ts: now,
+        });
+        return { ...spec, mech: to };
+    });
+    if (!changed) {
+        return { rule_id: rule.rule_id, before_mech: before, after_mech: before, events: [], applied: false, reason: 'no Mech-B/C to promote' };
+    }
+    const lifecycle = initLifecycle(rule);
+    const promotions = updatedSpecs.map((spec, i) => ({
+        at: new Date(now).toISOString(),
+        from_mech: before[i],
+        to_mech: spec.mech,
+        reason: 'consistent_adherence',
+        trigger_stats: {
+            window_n: candidate.injects_rolling_n,
+            adherence_rate: 1.0,
+        },
+    })).filter((p) => p.from_mech !== p.to_mech);
+    const updatedRule = {
+        ...rule,
+        enforce_via: updatedSpecs,
+        lifecycle: {
+            ...lifecycle,
+            meta_promotions: [...lifecycle.meta_promotions, ...promotions],
+        },
+        updated_at: new Date(now).toISOString(),
+    };
+    saveRule(updatedRule);
+    return {
+        rule_id: rule.rule_id,
+        before_mech: before,
+        after_mech: updatedSpecs.map((s) => s.mech),
+        events,
+        applied: true,
+    };
+}
+export function applyDemotion(rule, candidate, now = Date.now()) {
+    // C2 guard: hard rule 은 demote 불가 — 호출자가 scanDriftForDemotion 을 거치면
+    // 이미 필터되지만, applyDemotion 을 직접 호출하는 경로도 방어.
+    if (rule.strength === 'hard') {
+        return {
+            rule_id: rule.rule_id, before_mech: (rule.enforce_via ?? []).map((s) => s.mech),
+            after_mech: (rule.enforce_via ?? []).map((s) => s.mech), events: [], applied: false,
+            reason: 'hard rule — demotion refused',
+        };
+    }
+    const specs = rule.enforce_via ?? [];
+    const before = specs.map((s) => s.mech);
+    const events = [];
+    let changed = false;
+    const updatedSpecs = specs.map((spec) => {
+        const to = demoteMech(spec.mech);
+        if (to == null)
+            return spec;
+        changed = true;
+        events.push({
+            kind: 'meta_demote_to_b',
+            rule_id: rule.rule_id,
+            evidence: {
+                source: 'drift-log',
+                refs: candidate.sessions,
+                metrics: { event_count: candidate.event_count, window_days: candidate.window_days },
+            },
+            suggested_action: 'demote_mech',
+            ts: now,
+        });
+        return { ...spec, mech: to };
+    });
+    if (!changed) {
+        return { rule_id: rule.rule_id, before_mech: before, after_mech: before, events: [], applied: false, reason: 'no Mech-A/B to demote' };
+    }
+    const lifecycle = initLifecycle(rule);
+    const demotions = updatedSpecs.map((spec, i) => ({
+        at: new Date(now).toISOString(),
+        from_mech: before[i],
+        to_mech: spec.mech,
+        reason: 'stuck_loop_force_approve',
+        trigger_stats: { window_n: candidate.event_count, violation_count: candidate.event_count },
+    })).filter((p) => p.from_mech !== p.to_mech);
+    const after = updatedSpecs.map((s) => s.mech);
+    const updatedRule = {
+        ...rule,
+        enforce_via: updatedSpecs,
+        lifecycle: {
+            ...lifecycle,
+            meta_promotions: [...lifecycle.meta_promotions, ...demotions],
+        },
+        updated_at: new Date(now).toISOString(),
+    };
+    saveRule(updatedRule);
+    return {
+        rule_id: rule.rule_id,
+        before_mech: before,
+        after_mech: after,
+        events,
+        applied: true,
+    };
+}
+const LIFECYCLE_ROTATION_THRESHOLD = 10 * 1024 * 1024; // 10 MB
+export function appendLifecycleEvents(events, now = Date.now()) {
+    if (events.length === 0)
+        return;
+    try {
+        fs.mkdirSync(LIFECYCLE_DIR, { recursive: true });
+        const date = new Date(now).toISOString().slice(0, 10);
+        const logPath = path.join(LIFECYCLE_DIR, `${date}.jsonl`);
+        // H8: size-based rotation
+        try {
+            const st = fs.statSync(logPath);
+            if (st.size > LIFECYCLE_ROTATION_THRESHOLD) {
+                fs.renameSync(logPath, `${logPath}.${Date.now()}`);
+            }
+        }
+        catch { /* missing → no rotate */ }
+        const body = events.map((e) => JSON.stringify(e)).join('\n') + '\n';
+        fs.appendFileSync(logPath, body);
+    }
+    catch (e) {
+        if (process.env.FORGEN_DEBUG_SIGNALS === '1') {
+            console.error(`[forgen:lifecycle] appendLifecycleEvents failed: ${e.message}`);
+        }
+    }
+}
+export async function runMetaScan(args) {
+    const apply = args.includes('--apply');
+    const threshold = Number(args[args.indexOf('--threshold') + 1]) || DEFAULT_THRESHOLD;
+    const windowDays = Number(args[args.indexOf('--window') + 1]) || DEFAULT_WINDOW_DAYS;
+    const rules = loadAllRules();
+    const drift = readDriftEntries();
+    const candidates = scanDriftForDemotion({ rules, drift, windowDays, threshold });
+    console.log(`\n  Meta Reclassifier (Rule Lifecycle)\n`);
+    console.log(`  Window: last ${windowDays} day(s)   Threshold: ${threshold} event(s)\n`);
+    console.log(`  Scanned: drift.jsonl = ${drift.length} entries, rules = ${rules.length}\n`);
+    if (candidates.length === 0) {
+        console.log('  No demotion candidates. System stable.\n');
+        return;
+    }
+    const allEvents = [];
+    for (const c of candidates) {
+        console.log(`  ⚠ Candidate: rule=${c.rule_id} events=${c.event_count} sessions=${c.sessions.length} mechs=[${c.current_mechs.join(',')}]`);
+        console.log(`    window: ${c.first_at} → ${c.last_at}`);
+        // R4-B1: exact match only. 이전 `|| startsWith` 는 "L1-async" drift 로 "L1-async-await"
+        // 까지 demote 시키는 교차 오염을 야기. scanDriftForDemotion 은 이미 exact match.
+        const rule = rules.find((r) => r.rule_id === c.rule_id);
+        if (!rule) {
+            console.log('    (rule not found in store — likely spike scenarios.json; skip)');
+            continue;
+        }
+        if (apply) {
+            const result = applyDemotion(rule, c);
+            if (result.applied) {
+                console.log(`    → APPLIED: ${result.before_mech.join(',')} → ${result.after_mech.join(',')}`);
+                allEvents.push(...result.events);
+            }
+            else {
+                console.log(`    → SKIP: ${result.reason}`);
+            }
+        }
+        else {
+            const proposed = (rule.enforce_via ?? []).map((s) => demoteMech(s.mech) ?? s.mech);
+            console.log(`    → PROPOSE: ${(rule.enforce_via ?? []).map((s) => s.mech).join(',')} → ${proposed.join(',')}  (run with --apply to save)`);
+        }
+        console.log('');
+    }
+    if (apply && allEvents.length > 0) {
+        appendLifecycleEvents(allEvents);
+        console.log(`  Persisted ${allEvents.length} lifecycle event(s) to ~/.forgen/state/lifecycle/\n`);
+    }
+}