@wooojin/forgen 0.3.1 → 0.4.0

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;
+}

package/dist/engine/lifecycle/trigger-t1-correction.d.ts

@@ -0,0 +1,23 @@
+/**
+ * T1 — 사용자 명시 교정 (explicit_correction).
+ *
+ * 입력: Evidence(type='explicit_correction') + rules[].
+ * 로직:
+ *   1. evidence.axis_refs 에 rule.category 매칭 OR evidence.summary 에 rule.render_key 토큰 포함 → rule 매칭
+ *   2. correction kind 에 따라 suggested_action 결정:
+ *      - 'avoid-this' (이 rule 을 따르지 말아라) → retire
+ *      - 'fix-now'   (이 rule 을 수정해야 한다) → flag (사용자 후속 편집 대기)
+ *      - 'prefer-from-now' (새 선호로 대체) → supersede
+ *
+ * 출력: LifecycleEvent[]. 순수 — IO 없음.
+ */
+import type { Evidence, Rule } from '../../store/types.js';
+import type { LifecycleEvent } from './types.js';
+export interface T1Input {
+    evidence: Evidence;
+    /** 교정의 행동 종류 — 있으면 더 정확한 action 결정. */
+    correction_kind?: 'avoid-this' | 'fix-now' | 'prefer-from-now';
+    rules: Rule[];
+    ts?: number;
+}
+export declare function detect(input: T1Input): LifecycleEvent[];

package/dist/engine/lifecycle/trigger-t1-correction.js

@@ -0,0 +1,78 @@
+/**
+ * T1 — 사용자 명시 교정 (explicit_correction).
+ *
+ * 입력: Evidence(type='explicit_correction') + rules[].
+ * 로직:
+ *   1. evidence.axis_refs 에 rule.category 매칭 OR evidence.summary 에 rule.render_key 토큰 포함 → rule 매칭
+ *   2. correction kind 에 따라 suggested_action 결정:
+ *      - 'avoid-this' (이 rule 을 따르지 말아라) → retire
+ *      - 'fix-now'   (이 rule 을 수정해야 한다) → flag (사용자 후속 편집 대기)
+ *      - 'prefer-from-now' (새 선호로 대체) → supersede
+ *
+ * 출력: LifecycleEvent[]. 순수 — IO 없음.
+ */
+const CATEGORY_AXIS_MAP = {
+    quality: ['quality_safety', 'quality'],
+    autonomy: ['autonomy'],
+    communication: ['communication_style', 'communication'],
+    workflow: ['workflow', 'judgment_philosophy'],
+    safety: ['quality_safety', 'safety'],
+};
+function matchesRule(evidence, rule) {
+    // 가장 강한 신호: 사용자가 명시적으로 rule_id 지목.
+    if (evidence.candidate_rule_refs.includes(rule.rule_id))
+        return true;
+    // 그 외: axis 일치만으로는 과매칭 (예: "typescript-any" correction 이 "early-return"
+    // rule 까지 끌어오는 FP). axis AND 키워드 둘 다 요구.
+    const axes = CATEGORY_AXIS_MAP[rule.category] ?? [];
+    const axisMatch = axes.some((a) => evidence.axis_refs.includes(a));
+    if (!axisMatch)
+        return false;
+    const keyTokens = rule.render_key
+        .split(/[._-]/)
+        .filter((t) => t.length >= 3);
+    if (keyTokens.length === 0)
+        return false;
+    const summaryLower = evidence.summary.toLowerCase();
+    const targetToken = (evidence.raw_payload?.target ?? '')
+        .toString()
+        .toLowerCase();
+    return keyTokens.some((t) => {
+        const tokLower = t.toLowerCase();
+        return summaryLower.includes(tokLower) || (targetToken && targetToken.includes(tokLower));
+    });
+}
+export function detect(input) {
+    const { evidence, rules } = input;
+    if (evidence.type !== 'explicit_correction')
+        return [];
+    const ts = input.ts ?? Date.now();
+    const action = input.correction_kind === 'avoid-this'
+        ? 'retire'
+        : input.correction_kind === 'prefer-from-now'
+            ? 'supersede'
+            : 'flag';
+    const events = [];
+    for (const rule of rules) {
+        if (rule.status !== 'active')
+            continue;
+        if (!matchesRule(evidence, rule))
+            continue;
+        // C2: hard rule 은 retire/supersede 불변. fix-now(flag) 만 허용 — 관찰을 위한 소프트 신호.
+        if (rule.strength === 'hard' && action !== 'flag')
+            continue;
+        events.push({
+            kind: 't1_explicit_correction',
+            rule_id: rule.rule_id,
+            session_id: evidence.session_id,
+            evidence: {
+                source: 'evidence-store',
+                refs: [evidence.evidence_id],
+                metrics: { confidence: evidence.confidence },
+            },
+            suggested_action: action,
+            ts,
+        });
+    }
+    return events;
+}

package/dist/engine/lifecycle/trigger-t2-violation.d.ts

@@ -0,0 +1,18 @@
+/**
+ * T2 — 반복 Mech 위반.
+ *
+ * 트리거 조건 (ADR-002):
+ *   violations_30d ≥ 3 AND violation_rate_30d > 0.3 → flag (재검토 대기)
+ *
+ * rolling 30d 는 collectSignals 가 계산. 여기는 임계 체크와 event 생성만.
+ */
+import type { Rule } from '../../store/types.js';
+import type { LifecycleEvent, RuleSignals } from './types.js';
+export interface T2Input {
+    rules: Rule[];
+    signals: Map<string, RuleSignals>;
+    threshold_count?: number;
+    threshold_rate?: number;
+    ts?: number;
+}
+export declare function detect(input: T2Input): LifecycleEvent[];

package/dist/engine/lifecycle/trigger-t2-violation.js

@@ -0,0 +1,42 @@
+/**
+ * T2 — 반복 Mech 위반.
+ *
+ * 트리거 조건 (ADR-002):
+ *   violations_30d ≥ 3 AND violation_rate_30d > 0.3 → flag (재검토 대기)
+ *
+ * rolling 30d 는 collectSignals 가 계산. 여기는 임계 체크와 event 생성만.
+ */
+export function detect(input) {
+    const thresholdCount = input.threshold_count ?? 3;
+    const thresholdRate = input.threshold_rate ?? 0.3;
+    const ts = input.ts ?? Date.now();
+    const events = [];
+    for (const rule of input.rules) {
+        if (rule.status !== 'active')
+            continue;
+        if (rule.lifecycle?.phase === 'flagged')
+            continue; // 이미 flagged — 중복 이벤트 방지
+        const s = input.signals.get(rule.rule_id);
+        if (!s)
+            continue;
+        if (s.violations_30d < thresholdCount)
+            continue;
+        if (s.violation_rate_30d <= thresholdRate)
+            continue;
+        events.push({
+            kind: 't2_repeated_violation',
+            rule_id: rule.rule_id,
+            evidence: {
+                source: 'violations-log',
+                refs: [],
+                metrics: {
+                    violations_30d: s.violations_30d,
+                    violation_rate_30d: Number(s.violation_rate_30d.toFixed(3)),
+                },
+            },
+            suggested_action: 'flag',
+            ts,
+        });
+    }
+    return events;
+}

package/dist/engine/lifecycle/trigger-t3-bypass.d.ts

@@ -0,0 +1,17 @@
+/**
+ * T3 — 사용자 반복 우회 (user_bypass).
+ *
+ * 트리거 조건 (ADR-002):
+ *   7d 내 bypass_count ≥ 5 → suppress (일시 비활성 + 7일 후 자동 재활성)
+ *
+ * bypass 기록은 post-tool-use 측 확장이 bypass.jsonl 에 append (별도 wiring).
+ */
+import type { Rule } from '../../store/types.js';
+import type { LifecycleEvent, RuleSignals } from './types.js';
+export interface T3Input {
+    rules: Rule[];
+    signals: Map<string, RuleSignals>;
+    threshold_count?: number;
+    ts?: number;
+}
+export declare function detect(input: T3Input): LifecycleEvent[];

package/dist/engine/lifecycle/trigger-t3-bypass.js

@@ -0,0 +1,39 @@
+/**
+ * T3 — 사용자 반복 우회 (user_bypass).
+ *
+ * 트리거 조건 (ADR-002):
+ *   7d 내 bypass_count ≥ 5 → suppress (일시 비활성 + 7일 후 자동 재활성)
+ *
+ * bypass 기록은 post-tool-use 측 확장이 bypass.jsonl 에 append (별도 wiring).
+ */
+export function detect(input) {
+    const threshold = input.threshold_count ?? 5;
+    const ts = input.ts ?? Date.now();
+    const events = [];
+    for (const rule of input.rules) {
+        if (rule.status !== 'active')
+            continue;
+        if (rule.lifecycle?.phase === 'flagged' || rule.lifecycle?.phase === 'suppressed')
+            continue; // 이미 주의 환기됨
+        const s = input.signals.get(rule.rule_id);
+        if (!s)
+            continue;
+        if (s.bypass_7d < threshold)
+            continue;
+        // R6-P1: PM 지적 — "우회할수록 규칙이 약해진다" 는 Trust Restoration 미션과 역방향.
+        // T3 는 이제 자동 suppress 대신 flag 만 (사용자 주의 환기). 실제 suppress 는 사용자가
+        // 명시적으로 결정하도록 `forgen inspect rules --conflicts` + 수동 편집 경로 유지.
+        events.push({
+            kind: 't3_user_bypass',
+            rule_id: rule.rule_id,
+            evidence: {
+                source: 'bypass-log',
+                refs: [],
+                metrics: { bypass_7d: s.bypass_7d },
+            },
+            suggested_action: 'flag',
+            ts,
+        });
+    }
+    return events;
+}

package/dist/engine/lifecycle/trigger-t4-decay.d.ts

@@ -0,0 +1,18 @@
+/**
+ * T4 — 시간 경과 retire (time_decay).
+ *
+ * 트리거 조건 (ADR-002):
+ *   last_inject_at < now - 90d → retire 후보.
+ *   inject 추적 인프라 완비 전에는 updated_at 을 proxy 로 사용 (signals 가 이미 폴백).
+ *
+ * retired 는 파일 삭제가 아니라 phase 변경 — N개월 후 별도 GC.
+ */
+import type { Rule } from '../../store/types.js';
+import type { LifecycleEvent, RuleSignals } from './types.js';
+export interface T4Input {
+    rules: Rule[];
+    signals: Map<string, RuleSignals>;
+    decay_days?: number;
+    ts?: number;
+}
+export declare function detect(input: T4Input): LifecycleEvent[];

package/dist/engine/lifecycle/trigger-t4-decay.js

@@ -0,0 +1,40 @@
+/**
+ * T4 — 시간 경과 retire (time_decay).
+ *
+ * 트리거 조건 (ADR-002):
+ *   last_inject_at < now - 90d → retire 후보.
+ *   inject 추적 인프라 완비 전에는 updated_at 을 proxy 로 사용 (signals 가 이미 폴백).
+ *
+ * retired 는 파일 삭제가 아니라 phase 변경 — N개월 후 별도 GC.
+ */
+export function detect(input) {
+    const decayDays = input.decay_days ?? 90;
+    const ts = input.ts ?? Date.now();
+    const events = [];
+    for (const rule of input.rules) {
+        if (rule.status !== 'active')
+            continue;
+        if (rule.lifecycle?.phase === 'retired')
+            continue;
+        // C2: hard rule 은 time decay 로도 retire 불가.
+        if (rule.strength === 'hard')
+            continue;
+        const s = input.signals.get(rule.rule_id);
+        if (!s)
+            continue;
+        if (s.last_inject_days_ago < decayDays)
+            continue;
+        events.push({
+            kind: 't4_time_decay',
+            rule_id: rule.rule_id,
+            evidence: {
+                source: 'rule-store',
+                refs: [],
+                metrics: { last_inject_days_ago: s.last_inject_days_ago, threshold: decayDays },
+            },
+            suggested_action: 'retire',
+            ts,
+        });
+    }
+    return events;
+}

package/dist/engine/lifecycle/trigger-t5-conflict.d.ts

@@ -0,0 +1,16 @@
+/**
+ * T5 — 규칙 충돌 (conflict_detected).
+ *
+ * 트리거 조건:
+ *   같은 category 인 rule pair 중, policy 자연어가 상반 (negation + 공통 키워드 ≥ 2).
+ *
+ * auto-merge 안 함. conflict_refs 플래그만 설정 → 사용자 수동 해소.
+ */
+import type { Rule } from '../../store/types.js';
+import type { LifecycleEvent } from './types.js';
+export interface T5Input {
+    rules: Rule[];
+    min_shared_tokens?: number;
+    ts?: number;
+}
+export declare function detect(input: T5Input): LifecycleEvent[];