@wooojin/forgen 0.3.2 → 0.4.0

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 os from 'node:os';
+import * as path from 'node:path';
+import { initLifecycle } from '../../store/rule-lifecycle.js';
+import { loadAllRules, saveRule } from '../../store/rule-store.js';
+const DRIFT_LOG_PATH = path.join(os.homedir(), '.forgen', 'state', 'enforcement', 'drift.jsonl');
+const LIFECYCLE_DIR = path.join(os.homedir(), '.forgen', 'state', '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`);
+    }
+}

package/dist/engine/lifecycle/orchestrator.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Lifecycle Orchestrator — 트리거 이벤트 수신 → rule 상태 전이 적용.
+ *
+ * 데이터 플로우:
+ *   [T1~T5 + Meta] ─detect(state)→ LifecycleEvent[]
+ *                                          │
+ *          applyEvent(rule, event) ← ──────┘  (pure)
+ *                  │
+ *         ┌────────┴────────┐
+ *    saveRule(rule)    persistEvent(event)
+ *   (rule-store.ts)   (~/.forgen/state/lifecycle/{date}.jsonl)
+ *
+ * applyEvent 는 pure — rule → rule'. 부수효과는 saveRule / appendLifecycleEvents 에서만.
+ *
+ * 상태 전이 규칙 (ADR-002 §State transitions):
+ *   flag        → phase='flagged'
+ *   suppress    → phase='suppressed'  (+ status='suppressed')
+ *   retire      → phase='retired'     (+ status='removed')
+ *   merge       → phase='merged'      (+ merged_into)
+ *   supersede   → phase='superseded'  (+ superseded_by)
+ *   promote/demote_mech → phase 유지, meta_promotions 는 meta-reclassifier 가 직접 기록
+ */
+import type { Rule, LifecycleState } from '../../store/types.js';
+import type { LifecycleEvent } from './types.js';
+export declare function ensureLifecycle(rule: Rule): LifecycleState;
+/** 순수: rule + event → rule'. Mech 변경은 meta-reclassifier 가 처리하므로 여기서는 제외. */
+export declare function applyEvent(rule: Rule, event: LifecycleEvent, now?: number): Rule;
+/**
+ * 여러 이벤트를 rule 단위로 그룹핑 후 applyEvent 로 순차 접기.
+ * 순수 — 호출자가 저장을 담당.
+ */
+export declare function foldEvents(rules: Rule[], events: LifecycleEvent[], now?: number): Map<string, Rule>;

package/dist/engine/lifecycle/orchestrator.js

@@ -0,0 +1,131 @@
+/**
+ * Lifecycle Orchestrator — 트리거 이벤트 수신 → rule 상태 전이 적용.
+ *
+ * 데이터 플로우:
+ *   [T1~T5 + Meta] ─detect(state)→ LifecycleEvent[]
+ *                                          │
+ *          applyEvent(rule, event) ← ──────┘  (pure)
+ *                  │
+ *         ┌────────┴────────┐
+ *    saveRule(rule)    persistEvent(event)
+ *   (rule-store.ts)   (~/.forgen/state/lifecycle/{date}.jsonl)
+ *
+ * applyEvent 는 pure — rule → rule'. 부수효과는 saveRule / appendLifecycleEvents 에서만.
+ *
+ * 상태 전이 규칙 (ADR-002 §State transitions):
+ *   flag        → phase='flagged'
+ *   suppress    → phase='suppressed'  (+ status='suppressed')
+ *   retire      → phase='retired'     (+ status='removed')
+ *   merge       → phase='merged'      (+ merged_into)
+ *   supersede   → phase='superseded'  (+ superseded_by)
+ *   promote/demote_mech → phase 유지, meta_promotions 는 meta-reclassifier 가 직접 기록
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+/**
+ * R5-B1: rule 이 inactive 상태로 전이될 때 block-count 디렉터리의 잔여 파일 정리.
+ * phantom stuck-loop (retired 된 rule 이 다시 GC 전까지 counter 에 반영되는 문제) 차단.
+ */
+function sweepBlockCountsForRule(ruleId) {
+    try {
+        const dir = path.join(os.homedir(), '.forgen', 'state', 'enforcement', 'block-count');
+        if (!fs.existsSync(dir))
+            return;
+        const safeRuleId = String(ruleId).replace(/[^a-zA-Z0-9_.-]/g, '_');
+        for (const file of fs.readdirSync(dir)) {
+            if (file.endsWith(`__${safeRuleId}.json`)) {
+                try {
+                    fs.unlinkSync(path.join(dir, file));
+                }
+                catch { /* best-effort */ }
+            }
+        }
+    }
+    catch { /* fail-open */ }
+}
+const INACTIVE_STATUSES = new Set(['removed', 'suppressed', 'superseded']);
+export function ensureLifecycle(rule) {
+    return rule.lifecycle ?? {
+        phase: 'active',
+        first_active_at: rule.created_at,
+        inject_count: 0,
+        accept_count: 0,
+        violation_count: 0,
+        bypass_count: 0,
+        conflict_refs: [],
+        meta_promotions: [],
+    };
+}
+const ACTION_TO_PHASE = {
+    flag: 'flagged',
+    suppress: 'suppressed',
+    retire: 'retired',
+    merge: 'merged',
+    supersede: 'superseded',
+};
+const ACTION_TO_STATUS = {
+    suppress: 'suppressed',
+    retire: 'removed',
+    supersede: 'superseded',
+};
+/** 순수: rule + event → rule'. Mech 변경은 meta-reclassifier 가 처리하므로 여기서는 제외. */
+export function applyEvent(rule, event, now = Date.now()) {
+    if (event.suggested_action === 'promote_mech' || event.suggested_action === 'demote_mech') {
+        // meta-reclassifier 가 rule 을 직접 변경. orchestrator 는 meta_promotions 이력만 유지.
+        return rule;
+    }
+    const lifecycle = ensureLifecycle(rule);
+    const nextPhase = ACTION_TO_PHASE[event.suggested_action];
+    const nextStatus = ACTION_TO_STATUS[event.suggested_action];
+    const updatedLifecycle = {
+        ...lifecycle,
+        phase: nextPhase ?? lifecycle.phase,
+    };
+    // R5-B2: phase 전이 시 상호 배타적 포인터 정리.
+    if (event.suggested_action === 'merge' && event.merged_into) {
+        updatedLifecycle.merged_into = event.merged_into;
+        delete updatedLifecycle.superseded_by;
+    }
+    if (event.suggested_action === 'supersede' && event.superseded_by) {
+        updatedLifecycle.superseded_by = event.superseded_by;
+        delete updatedLifecycle.merged_into;
+    }
+    if (event.kind === 't5_conflict_detected' && event.evidence?.refs) {
+        const refs = event.evidence.refs.filter((r) => r !== rule.rule_id);
+        updatedLifecycle.conflict_refs = [
+            ...new Set([...lifecycle.conflict_refs, ...refs]),
+        ];
+    }
+    // retired rule 은 더 이상 의미 있는 conflict 가 없으므로 정리.
+    if (event.suggested_action === 'retire') {
+        updatedLifecycle.conflict_refs = [];
+    }
+    const nextStatusValue = nextStatus ?? rule.status;
+    // R5-B1: inactive 전이 시 block-count orphan 파일 정리.
+    if (INACTIVE_STATUSES.has(nextStatusValue) && !INACTIVE_STATUSES.has(rule.status)) {
+        sweepBlockCountsForRule(rule.rule_id);
+    }
+    return {
+        ...rule,
+        status: nextStatusValue,
+        lifecycle: updatedLifecycle,
+        updated_at: new Date(now).toISOString(),
+    };
+}
+/**
+ * 여러 이벤트를 rule 단위로 그룹핑 후 applyEvent 로 순차 접기.
+ * 순수 — 호출자가 저장을 담당.
+ */
+export function foldEvents(rules, events, now = Date.now()) {
+    const byId = new Map();
+    for (const r of rules)
+        byId.set(r.rule_id, r);
+    for (const ev of events) {
+        const current = byId.get(ev.rule_id);
+        if (!current)
+            continue;
+        byId.set(ev.rule_id, applyEvent(current, ev, now));
+    }
+    return byId;
+}

package/dist/engine/lifecycle/signals.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Signal collector — 각 rule 에 대해 트리거들이 필요로 하는 집계 수치를 계산.
+ *
+ * 입력 소스 (on-disk):
+ *   - ~/.forgen/state/enforcement/drift.jsonl         (stuck-loop 이벤트)
+ *   - ~/.forgen/state/enforcement/violations.jsonl    (rule 위반 기록)
+ *   - ~/.forgen/state/enforcement/bypass.jsonl        (T3: 사용자 우회 기록)
+ *
+ * 모든 IO 는 이 파일에 한정. 트리거들은 pure — collectSignals() 결과를 받아 detect().
+ */
+import type { Rule } from '../../store/types.js';
+import type { RuleSignals, ViolationEntry, BypassEntry } from './types.js';
+/**
+ * Best-effort size-based rotation. When `p` exceeds 10MB, renames to
+ * `<p>.<timestamp>` so the next write starts fresh. Missing file or rename
+ * failures are swallowed — the caller's append will still succeed or fail
+ * on its own merits. Exported so enforcement-path jsonl writers outside
+ * this file (drift.jsonl, acknowledgments.jsonl) reuse the same policy.
+ */
+export declare function rotateIfBig(p: string): void;
+export declare function readJsonlSafe<T>(p: string): T[];
+export declare function recordViolation(entry: Omit<ViolationEntry, 'at'>): void;
+export declare function recordBypass(entry: Omit<BypassEntry, 'at'>): void;
+export interface SignalInputs {
+    violations?: ViolationEntry[];
+    bypass?: BypassEntry[];
+    now?: number;
+}
+export declare function collectSignals(rule: Rule, inputs?: SignalInputs): RuleSignals;
+export declare function collectAllSignals(rules: Rule[], inputs?: SignalInputs): Map<string, RuleSignals>;

package/dist/engine/lifecycle/signals.js

@@ -0,0 +1,142 @@
+/**
+ * Signal collector — 각 rule 에 대해 트리거들이 필요로 하는 집계 수치를 계산.
+ *
+ * 입력 소스 (on-disk):
+ *   - ~/.forgen/state/enforcement/drift.jsonl         (stuck-loop 이벤트)
+ *   - ~/.forgen/state/enforcement/violations.jsonl    (rule 위반 기록)
+ *   - ~/.forgen/state/enforcement/bypass.jsonl        (T3: 사용자 우회 기록)
+ *
+ * 모든 IO 는 이 파일에 한정. 트리거들은 pure — collectSignals() 결과를 받아 detect().
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+const STATE_DIR = path.join(os.homedir(), '.forgen', 'state', 'enforcement');
+const VIOLATIONS_PATH = path.join(STATE_DIR, 'violations.jsonl');
+const BYPASS_PATH = path.join(STATE_DIR, 'bypass.jsonl');
+const ROLLING_N = 20;
+const VIOLATION_WINDOW_DAYS = 30;
+const BYPASS_WINDOW_DAYS = 7;
+/** H8: jsonl rotation threshold — append 시점마다 체크. */
+const ROTATION_THRESHOLD_BYTES = 10 * 1024 * 1024; // 10 MB
+/**
+ * Best-effort size-based rotation. When `p` exceeds 10MB, renames to
+ * `<p>.<timestamp>` so the next write starts fresh. Missing file or rename
+ * failures are swallowed — the caller's append will still succeed or fail
+ * on its own merits. Exported so enforcement-path jsonl writers outside
+ * this file (drift.jsonl, acknowledgments.jsonl) reuse the same policy.
+ */
+export function rotateIfBig(p) {
+    try {
+        const st = fs.statSync(p);
+        if (st.size > ROTATION_THRESHOLD_BYTES) {
+            fs.renameSync(p, `${p}.${Date.now()}`);
+        }
+    }
+    catch { /* missing → no rotate */ }
+}
+export function readJsonlSafe(p) {
+    if (!fs.existsSync(p))
+        return [];
+    try {
+        return fs.readFileSync(p, 'utf-8')
+            .trim()
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((e) => e !== null);
+    }
+    catch {
+        return [];
+    }
+}
+export function recordViolation(entry) {
+    try {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        rotateIfBig(VIOLATIONS_PATH);
+        const full = { at: new Date().toISOString(), ...entry };
+        fs.appendFileSync(VIOLATIONS_PATH, JSON.stringify(full) + '\n');
+    }
+    catch (e) {
+        // best-effort, 실패 시 debug 로그 (silent swallow 방지)
+        if (process.env.FORGEN_DEBUG_SIGNALS === '1') {
+            console.error(`[forgen:signals] recordViolation failed: ${e.message}`);
+        }
+    }
+}
+export function recordBypass(entry) {
+    try {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        rotateIfBig(BYPASS_PATH);
+        const full = { at: new Date().toISOString(), ...entry };
+        fs.appendFileSync(BYPASS_PATH, JSON.stringify(full) + '\n');
+    }
+    catch (e) {
+        if (process.env.FORGEN_DEBUG_SIGNALS === '1') {
+            console.error(`[forgen:signals] recordBypass failed: ${e.message}`);
+        }
+    }
+}
+export function collectSignals(rule, inputs = {}) {
+    const now = inputs.now ?? Date.now();
+    const violations = inputs.violations ?? readJsonlSafe(VIOLATIONS_PATH);
+    const bypass = inputs.bypass ?? readJsonlSafe(BYPASS_PATH);
+    // exact match only — M fix: startsWith 으로 prefix 교차 오염되던 부분 제거.
+    const matchesRule = (ruleId) => ruleId === rule.rule_id;
+    const vCutoff30 = now - VIOLATION_WINDOW_DAYS * 24 * 3600 * 1000;
+    const recent30 = violations.filter((v) => {
+        if (!matchesRule(v.rule_id))
+            return false;
+        const t = Date.parse(v.at);
+        return Number.isFinite(t) && t >= vCutoff30;
+    });
+    const bCutoff = now - BYPASS_WINDOW_DAYS * 24 * 3600 * 1000;
+    const recentBypass = bypass.filter((b) => {
+        if (!matchesRule(b.rule_id))
+            return false;
+        const t = Date.parse(b.at);
+        return Number.isFinite(t) && t >= bCutoff;
+    });
+    // Rolling N: take last N entries (violations + injections aggregate).
+    // Inject 추적 인프라가 완비되기 전까지는 violations.jsonl 길이 * proxy 사용.
+    // lifecycle.inject_count 필드가 채워지기 시작하면 그 값을 우선.
+    const injectsRolling = rule.lifecycle?.inject_count ?? 0;
+    const lastN = violations
+        .filter((v) => matchesRule(v.rule_id))
+        .slice(-ROLLING_N);
+    const violationsRolling = lastN.length;
+    const lastInjectTs = rule.lifecycle?.last_inject_at
+        ? Date.parse(rule.lifecycle.last_inject_at)
+        : null;
+    const lastInjectDays = lastInjectTs
+        ? Math.floor((now - lastInjectTs) / (24 * 3600 * 1000))
+        : Math.floor((now - Date.parse(rule.updated_at)) / (24 * 3600 * 1000));
+    const lastUpdatedDays = Math.floor((now - Date.parse(rule.updated_at)) / (24 * 3600 * 1000));
+    const injectCount = rule.lifecycle?.inject_count ?? 0;
+    const violationRate30 = injectCount > 0
+        ? recent30.length / injectCount
+        : (recent30.length >= 1 ? 1 : 0); // no inject tracking → treat each violation as high rate
+    return {
+        violations_30d: recent30.length,
+        violation_rate_30d: violationRate30,
+        bypass_7d: recentBypass.length,
+        last_inject_days_ago: lastInjectDays,
+        injects_rolling_n: injectsRolling,
+        violations_rolling_n: violationsRolling,
+        last_updated_days_ago: lastUpdatedDays,
+    };
+}
+export function collectAllSignals(rules, inputs = {}) {
+    const map = new Map();
+    for (const r of rules) {
+        map.set(r.rule_id, collectSignals(r, inputs));
+    }
+    return map;
+}