@wooojin/forgen 0.3.2 → 0.4.1

package/dist/store/evidence-store.d.ts

@@ -16,6 +16,21 @@ export declare function createEvidence(params: {
     raw_payload?: Record<string, unknown>;
 }): Evidence;
 export declare function saveEvidence(evidence: Evidence): void;
+/**
+ * ADR-002 T1 — explicit_correction evidence 저장 + orchestrator 호출.
+ *
+ * saveEvidence 와의 차이:
+ *   - type='explicit_correction' 인 경우 T1 detect 실행 → 매칭된 rule 상태 전이 적용.
+ *   - orchestrator 호출은 best-effort (실패해도 evidence 저장은 유지).
+ *   - correction_kind 는 raw_payload.kind 에서 추론 (CorrectionRequest 와 호환).
+ *
+ * 기존 saveEvidence 를 호출하는 코드는 그대로 둬도 됨 (하위 호환). T1 emission 이 필요한
+ * 호출지(correction-record MCP, evidence-processor)만 이 함수로 전환.
+ */
+export declare function appendEvidence(evidence: Evidence): {
+    saved: true;
+    t1_events: number;
+};
 export declare function loadEvidence(evidenceId: string): Evidence | null;
 export declare function loadAllEvidence(): Evidence[];
 export declare function loadEvidenceBySession(sessionId: string): Evidence[];

package/dist/store/evidence-store.js

@@ -10,6 +10,10 @@ import * as crypto from 'node:crypto';
 import { ME_BEHAVIOR } from '../core/paths.js';
 import { atomicWriteJSON, safeReadJSON } from '../hooks/shared/atomic-write.js';
 import { createRule, saveRule, loadActiveRules } from './rule-store.js';
+import { classify, applyProposal } from '../engine/enforce-classifier.js';
+import { detect as detectT1 } from '../engine/lifecycle/trigger-t1-correction.js';
+import { foldEvents } from '../engine/lifecycle/orchestrator.js';
+import { appendLifecycleEvents } from '../engine/lifecycle/meta-reclassifier.js';
 function evidencePath(evidenceId) {
     return path.join(ME_BEHAVIOR, `${evidenceId}.json`);
 }
@@ -27,9 +31,59 @@ export function createEvidence(params) {
         raw_payload: params.raw_payload ?? {},
     };
 }
+/** TEST-4 / RC4: behavior_observation 의 summary 가 의미있는 내용을 담아야 분석 가능. */
+const MIN_BEHAVIOR_OBSERVATION_LEN = 20;
 export function saveEvidence(evidence) {
+    // TEST-4 / RC4: 빈/짧은 behavior_observation 은 저장 거부.
+    // 결함: ~/.forgen/me/behavior/*.json 다수에 summary="" 가 누적되어 학습 데이터가
+    // 분석 불가능한 형태로 쌓임. saveEvidence 가 마지막 게이트라 여기서 거른다.
+    // 다른 evidence type (explicit_correction, session_summary) 은 backward compat.
+    if (evidence.type === 'behavior_observation') {
+        const len = (evidence.summary ?? '').trim().length;
+        if (len < MIN_BEHAVIOR_OBSERVATION_LEN)
+            return;
+    }
     atomicWriteJSON(evidencePath(evidence.evidence_id), evidence, { pretty: true });
 }
+/**
+ * ADR-002 T1 — explicit_correction evidence 저장 + orchestrator 호출.
+ *
+ * saveEvidence 와의 차이:
+ *   - type='explicit_correction' 인 경우 T1 detect 실행 → 매칭된 rule 상태 전이 적용.
+ *   - orchestrator 호출은 best-effort (실패해도 evidence 저장은 유지).
+ *   - correction_kind 는 raw_payload.kind 에서 추론 (CorrectionRequest 와 호환).
+ *
+ * 기존 saveEvidence 를 호출하는 코드는 그대로 둬도 됨 (하위 호환). T1 emission 이 필요한
+ * 호출지(correction-record MCP, evidence-processor)만 이 함수로 전환.
+ */
+export function appendEvidence(evidence) {
+    saveEvidence(evidence);
+    if (evidence.type !== 'explicit_correction')
+        return { saved: true, t1_events: 0 };
+    try {
+        const rawKind = evidence.raw_payload?.kind;
+        const correctionKind = rawKind === 'avoid-this' || rawKind === 'fix-now' || rawKind === 'prefer-from-now'
+            ? rawKind
+            : undefined;
+        const rules = loadActiveRules();
+        const events = detectT1({ evidence, correction_kind: correctionKind, rules });
+        if (events.length === 0)
+            return { saved: true, t1_events: 0 };
+        const folded = foldEvents(rules, events);
+        for (const [ruleId, updated] of folded.entries()) {
+            const original = rules.find((r) => r.rule_id === ruleId);
+            if (!original || updated === original)
+                continue;
+            saveRule(updated);
+        }
+        appendLifecycleEvents(events);
+        return { saved: true, t1_events: events.length };
+    }
+    catch {
+        // best-effort: orchestrator 실패는 evidence 저장 자체를 막지 않는다.
+        return { saved: true, t1_events: 0 };
+    }
+}
 export function loadEvidence(evidenceId) {
     return safeReadJSON(evidencePath(evidenceId), null);
 }
@@ -91,7 +145,7 @@ export function promoteSessionCandidates(sessionId) {
         const category = axisHint === 'quality_safety' ? 'quality'
             : axisHint === 'autonomy' ? 'autonomy'
                 : 'workflow';
-        const rule = createRule({
+        let rule = createRule({
             category,
             scope: 'me',
             trigger: target,
@@ -101,6 +155,12 @@ export function promoteSessionCandidates(sessionId) {
             evidence_refs: [candidate.evidence_id],
             render_key: renderKey,
         });
+        // ADR-001 auto-classify — 승격되는 rule 에도 enforce_via 자동 주입.
+        try {
+            const proposal = classify(rule);
+            rule = applyProposal(rule, proposal);
+        }
+        catch { /* fail-open */ }
         saveRule(rule);
         existingRenderKeys.add(renderKey);
         promoted++;

package/dist/store/implicit-feedback-store.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Forgen v0.4.1 — Implicit Feedback Store (TEST-5)
+ *
+ * `~/.forgen/state/implicit-feedback.jsonl` 의 append/read.
+ *
+ * TEST-5 / RC5: 누적된 엔트리들이 `type` 문자열만 가지고 category 없이 섞여 있어
+ *   - drift_critical / drift_warning / revert_detected / repeated_edit / agent_* 가 한 스트림에 섞여
+ *   - 집계/쿼리 시 카테고리 enum 부재로 휴리스틱 문자열 매칭에 의존
+ *   - 스키마 검증이 없어 빈/잘못된 필드로 쓰여도 나중에 분석 불가
+ * 이 모듈은 category 필드를 **필수화**하고, 기존 레거시 라인은 read 시 `type→category`
+ * 백필로 보정한다. 새 write 는 category 없으면 drift/revert 계열은 **거부**한다.
+ */
+export declare const IMPLICIT_FEEDBACK_LOG: string;
+/**
+ * TEST-5/H4: 카테고리 enum.
+ *  - drift / revert: 네거티브 signal (schema 강제)
+ *  - edit / agent: 네거티브-ish signal (휴리스틱)
+ *  - positive: H4 양수 신호 — assist (recommendation_surfaced, recall_referenced)
+ */
+export type ImplicitFeedbackCategory = 'drift' | 'revert' | 'edit' | 'agent' | 'positive';
+export interface ImplicitFeedbackEntry {
+    type: string;
+    category: ImplicitFeedbackCategory;
+    sessionId?: string;
+    at: string;
+    [key: string]: unknown;
+}
+/** 호출지 입력 — category 선택적 (schema 가 허용하면 inference 로 채움). */
+export interface ImplicitFeedbackInput {
+    type: string;
+    category?: ImplicitFeedbackCategory;
+    sessionId?: string;
+    at: string;
+    [key: string]: unknown;
+}
+/** type → category 추론. 레거시 엔트리 마이그레이션과 호출지 기본값 계산에 공용. */
+export declare function inferCategoryFromType(type: string): ImplicitFeedbackCategory | null;
+/**
+ * TEST-5 메인 라이터. 내부에서 스키마 검증 후 append.
+ * drift/revert 스키마 위반 시 silent drop (hot path 에서 throw 금지).
+ * 반환값: 실제로 기록되었는지 (테스트 검증용).
+ */
+export declare function appendImplicitFeedback(entry: ImplicitFeedbackInput): boolean;
+/**
+ * TEST-5 리더. 세션 필터링 + 레거시 라인에 대한 lazy 마이그레이션 (category 백필).
+ * 디스크 상 파일은 건드리지 않고 읽기 시점에만 category 를 보정한다 — atomic-write
+ * 없이 append-only 로그를 rewrite 하면 race 위험이 있기 때문.
+ * 영구 백필은 `migrateImplicitFeedbackLog()` 를 명시적으로 호출한다.
+ */
+export declare function loadImplicitFeedback(sessionId: string): ImplicitFeedbackEntry[];
+/**
+ * 영구 마이그레이션 — 레거시 로그 파일을 읽어 category 백필 후 원자적으로 재기록.
+ * 마이그레이션 불가 라인 (type 도 category 도 없거나 inference 실패) 은 drop.
+ * 반환: { migrated: 백필된 라인 수, dropped: 버려진 라인 수 }
+ */
+export declare function migrateImplicitFeedbackLog(): {
+    migrated: number;
+    dropped: number;
+};

package/dist/store/implicit-feedback-store.js

@@ -0,0 +1,153 @@
+/**
+ * Forgen v0.4.1 — Implicit Feedback Store (TEST-5)
+ *
+ * `~/.forgen/state/implicit-feedback.jsonl` 의 append/read.
+ *
+ * TEST-5 / RC5: 누적된 엔트리들이 `type` 문자열만 가지고 category 없이 섞여 있어
+ *   - drift_critical / drift_warning / revert_detected / repeated_edit / agent_* 가 한 스트림에 섞여
+ *   - 집계/쿼리 시 카테고리 enum 부재로 휴리스틱 문자열 매칭에 의존
+ *   - 스키마 검증이 없어 빈/잘못된 필드로 쓰여도 나중에 분석 불가
+ * 이 모듈은 category 필드를 **필수화**하고, 기존 레거시 라인은 read 시 `type→category`
+ * 백필로 보정한다. 새 write 는 category 없으면 drift/revert 계열은 **거부**한다.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { STATE_DIR } from '../core/paths.js';
+export const IMPLICIT_FEEDBACK_LOG = path.join(STATE_DIR, 'implicit-feedback.jsonl');
+/** type → category 추론. 레거시 엔트리 마이그레이션과 호출지 기본값 계산에 공용. */
+export function inferCategoryFromType(type) {
+    if (type === 'drift_critical' || type === 'drift_warning')
+        return 'drift';
+    if (type === 'revert_detected')
+        return 'revert';
+    if (type === 'repeated_edit')
+        return 'edit';
+    if (type.startsWith('agent_'))
+        return 'agent';
+    // H4: 양수 assist 신호 — 솔루션이 사용자에게 노출/참조되었음을 기록.
+    if (type === 'recommendation_surfaced' || type === 'recall_referenced')
+        return 'positive';
+    return null;
+}
+/**
+ * TEST-5 스키마 검증 — drift/revert 계열은 category 누락 시 쓰기 거부.
+ * agent/edit 은 fail-open (기존 호출지가 빠뜨려도 로깅 자체는 보존), 대신 inference
+ * 가 가능하면 자동 보정.
+ */
+function validateAndNormalize(entry) {
+    if (!entry.type || !entry.at)
+        return null;
+    const inferred = inferCategoryFromType(entry.type);
+    const category = entry.category ?? inferred;
+    // drift/revert/positive 는 schema 강제: 명시든 추론이든 올바른 카테고리여야 함.
+    if (entry.type === 'drift_critical' || entry.type === 'drift_warning') {
+        if (category !== 'drift')
+            return null;
+    }
+    if (entry.type === 'revert_detected') {
+        if (category !== 'revert')
+            return null;
+    }
+    if (entry.type === 'recommendation_surfaced' || entry.type === 'recall_referenced') {
+        if (category !== 'positive')
+            return null;
+    }
+    if (!category)
+        return null;
+    return { ...entry, category };
+}
+/**
+ * TEST-5 메인 라이터. 내부에서 스키마 검증 후 append.
+ * drift/revert 스키마 위반 시 silent drop (hot path 에서 throw 금지).
+ * 반환값: 실제로 기록되었는지 (테스트 검증용).
+ */
+export function appendImplicitFeedback(entry) {
+    const normalized = validateAndNormalize(entry);
+    if (!normalized)
+        return false;
+    try {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        fs.appendFileSync(IMPLICIT_FEEDBACK_LOG, JSON.stringify(normalized) + '\n');
+        return true;
+    }
+    catch {
+        // fail-open: implicit feedback recording must not throw.
+        return false;
+    }
+}
+/**
+ * TEST-5 리더. 세션 필터링 + 레거시 라인에 대한 lazy 마이그레이션 (category 백필).
+ * 디스크 상 파일은 건드리지 않고 읽기 시점에만 category 를 보정한다 — atomic-write
+ * 없이 append-only 로그를 rewrite 하면 race 위험이 있기 때문.
+ * 영구 백필은 `migrateImplicitFeedbackLog()` 를 명시적으로 호출한다.
+ */
+export function loadImplicitFeedback(sessionId) {
+    try {
+        if (!fs.existsSync(IMPLICIT_FEEDBACK_LOG))
+            return [];
+        const lines = fs.readFileSync(IMPLICIT_FEEDBACK_LOG, 'utf-8').split('\n').filter(Boolean);
+        const entries = [];
+        for (const line of lines) {
+            try {
+                const raw = JSON.parse(line);
+                if (raw.sessionId !== sessionId)
+                    continue;
+                if (!raw.type || !raw.at)
+                    continue;
+                const category = raw.category ?? inferCategoryFromType(raw.type);
+                if (!category)
+                    continue;
+                entries.push({ ...raw, category });
+            }
+            catch {
+                /* skip malformed lines */
+            }
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * 영구 마이그레이션 — 레거시 로그 파일을 읽어 category 백필 후 원자적으로 재기록.
+ * 마이그레이션 불가 라인 (type 도 category 도 없거나 inference 실패) 은 drop.
+ * 반환: { migrated: 백필된 라인 수, dropped: 버려진 라인 수 }
+ */
+export function migrateImplicitFeedbackLog() {
+    if (!fs.existsSync(IMPLICIT_FEEDBACK_LOG))
+        return { migrated: 0, dropped: 0 };
+    const lines = fs.readFileSync(IMPLICIT_FEEDBACK_LOG, 'utf-8').split('\n').filter(Boolean);
+    const out = [];
+    let migrated = 0;
+    let dropped = 0;
+    for (const line of lines) {
+        try {
+            const raw = JSON.parse(line);
+            if (!raw.type || !raw.at) {
+                dropped++;
+                continue;
+            }
+            if (raw.category) {
+                out.push(JSON.stringify(raw));
+                continue;
+            }
+            const inferred = inferCategoryFromType(raw.type);
+            if (!inferred) {
+                dropped++;
+                continue;
+            }
+            const repaired = { ...raw, category: inferred };
+            out.push(JSON.stringify(repaired));
+            migrated++;
+        }
+        catch {
+            dropped++;
+        }
+    }
+    // atomic replace via temp file
+    const tmp = `${IMPLICIT_FEEDBACK_LOG}.migrate.${process.pid}`;
+    fs.writeFileSync(tmp, out.length > 0 ? out.join('\n') + '\n' : '');
+    fs.renameSync(tmp, IMPLICIT_FEEDBACK_LOG);
+    return { migrated, dropped };
+}

package/dist/store/rule-lifecycle.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Rule lifecycle factory + helpers — single source of truth for defaults/normalization.
+ *
+ * R6-F1 (2026-04-22): 이전에는 `rule.lifecycle ?? { phase: 'active', inject_count: 0, ... }`
+ * 리터럴이 rule-store, orchestrator, meta-reclassifier 등 5곳에 복제되어 필드 추가 시 동시
+ * 수정 필수였다. 한 곳에서 불변식을 걸고 모든 호출자가 이 함수를 통해 lifecycle 을 얻도록 통합.
+ *
+ * root-cause-analyst (R6) 분석: "Rule 이 data file + state machine 이중 정체성을 가지면서
+ * 기본값 재합성이 N 군데에 분산" 이 R4-B2(음수 corruption)/R5-B1(orphan)/R5-B2(mutex)/api-H1
+ * 등 버그 클러스터의 공통 뿌리. 이 factory 가 그 뿌리를 차단.
+ */
+import type { Rule, LifecycleState, MetaPromotion } from './types.js';
+/** safe non-negative integer normalization — 파일 corruption / 다중 writer race 방어. */
+export declare function safeCount(n: unknown): number;
+/**
+ * Rule 에 대해 정규화된 LifecycleState 반환 (pure — rule 을 변경하지 않음).
+ * 기존 lifecycle 이 있으면 카운터를 safeCount 로 정규화한 사본, 없으면 초기 상태.
+ */
+export declare function initLifecycle(rule: Rule): LifecycleState;
+/** inject count + last_inject_at 을 한 단계 증가 — markRulesInjected 의 공통 로직. */
+export declare function bumpInject(lifecycle: LifecycleState, nowIso: string): LifecycleState;
+/** meta_promotions 에 새 entry append (immutable). */
+export declare function appendMetaPromotion(lifecycle: LifecycleState, promotion: MetaPromotion): LifecycleState;

package/dist/store/rule-lifecycle.js

@@ -0,0 +1,63 @@
+/**
+ * Rule lifecycle factory + helpers — single source of truth for defaults/normalization.
+ *
+ * R6-F1 (2026-04-22): 이전에는 `rule.lifecycle ?? { phase: 'active', inject_count: 0, ... }`
+ * 리터럴이 rule-store, orchestrator, meta-reclassifier 등 5곳에 복제되어 필드 추가 시 동시
+ * 수정 필수였다. 한 곳에서 불변식을 걸고 모든 호출자가 이 함수를 통해 lifecycle 을 얻도록 통합.
+ *
+ * root-cause-analyst (R6) 분석: "Rule 이 data file + state machine 이중 정체성을 가지면서
+ * 기본값 재합성이 N 군데에 분산" 이 R4-B2(음수 corruption)/R5-B1(orphan)/R5-B2(mutex)/api-H1
+ * 등 버그 클러스터의 공통 뿌리. 이 factory 가 그 뿌리를 차단.
+ */
+/** safe non-negative integer normalization — 파일 corruption / 다중 writer race 방어. */
+export function safeCount(n) {
+    return typeof n === 'number' && Number.isFinite(n) && n >= 0 ? n : 0;
+}
+/**
+ * Rule 에 대해 정규화된 LifecycleState 반환 (pure — rule 을 변경하지 않음).
+ * 기존 lifecycle 이 있으면 카운터를 safeCount 로 정규화한 사본, 없으면 초기 상태.
+ */
+export function initLifecycle(rule) {
+    const existing = rule.lifecycle;
+    if (existing) {
+        return {
+            phase: existing.phase,
+            first_active_at: existing.first_active_at,
+            last_inject_at: existing.last_inject_at,
+            last_violation_at: existing.last_violation_at,
+            inject_count: safeCount(existing.inject_count),
+            accept_count: safeCount(existing.accept_count),
+            violation_count: safeCount(existing.violation_count),
+            bypass_count: safeCount(existing.bypass_count),
+            conflict_refs: Array.isArray(existing.conflict_refs) ? [...existing.conflict_refs] : [],
+            merged_into: existing.merged_into,
+            superseded_by: existing.superseded_by,
+            meta_promotions: Array.isArray(existing.meta_promotions) ? [...existing.meta_promotions] : [],
+        };
+    }
+    return {
+        phase: 'active',
+        first_active_at: rule.created_at,
+        inject_count: 0,
+        accept_count: 0,
+        violation_count: 0,
+        bypass_count: 0,
+        conflict_refs: [],
+        meta_promotions: [],
+    };
+}
+/** inject count + last_inject_at 을 한 단계 증가 — markRulesInjected 의 공통 로직. */
+export function bumpInject(lifecycle, nowIso) {
+    return {
+        ...lifecycle,
+        inject_count: lifecycle.inject_count + 1,
+        last_inject_at: nowIso,
+    };
+}
+/** meta_promotions 에 새 entry append (immutable). */
+export function appendMetaPromotion(lifecycle, promotion) {
+    return {
+        ...lifecycle,
+        meta_promotions: [...lifecycle.meta_promotions, promotion],
+    };
+}

package/dist/store/rule-store.d.ts

@@ -16,9 +16,30 @@ export declare function createRule(params: {
     render_key: string;
 }): Rule;
 export declare function saveRule(rule: Rule): void;
+/**
+ * ADR-002 T5 — rule 저장 + 기존 active rules 와 자연어 충돌 감지 + 양쪽 conflict_refs 기록.
+ *
+ * saveRule 과의 차이:
+ *   - 저장 직후 T5 detect 실행 → 충돌 발견 시 신규 rule + 반대편 rule 모두 conflict_refs 업데이트.
+ *   - auto-merge 안 함 (ADR-002 §Risks — 사용자 수동 해소).
+ *   - T5 감지 실패는 저장 자체를 막지 않음 (fail-open).
+ *
+ * 반환: 저장된 rule + 감지된 충돌 rule_id 목록.
+ */
+export declare function appendRule(rule: Rule): Promise<{
+    saved: true;
+    conflicts_with: string[];
+}>;
 export declare function loadRule(ruleId: string): Rule | null;
 export declare function loadAllRules(): Rule[];
 export declare function loadActiveRules(): Rule[];
+/**
+ * ADR-002 Meta signal — rule 들이 프롬프트에 inject 되었음을 기록.
+ * rule.lifecycle.inject_count +1, last_inject_at = now.
+ * lifecycle 없던 rule 은 auto-init 하고 phase='active'.
+ * Meta promotion (B→A) 의 rolling window 집계가 이 카운터를 소비한다.
+ */
+export declare function markRulesInjected(ruleIds: string[], nowIso?: string): void;
 export declare function updateRuleStatus(ruleId: string, status: RuleStatus): boolean;
 /**
  * 현재 세션 ID와 다른 scope:'session' 규칙을 비활성화.

package/dist/store/rule-store.js

@@ -9,6 +9,8 @@ import * as path from 'node:path';
 import * as crypto from 'node:crypto';
 import { ME_RULES } from '../core/paths.js';
 import { atomicWriteJSON, safeReadJSON } from '../hooks/shared/atomic-write.js';
+import { CURRENT_RULE_SCHEMA_VERSION } from './types.js';
+import { initLifecycle, bumpInject } from './rule-lifecycle.js';
 function rulePath(ruleId) {
     return path.join(ME_RULES, `${ruleId}.json`);
 }
@@ -31,27 +33,153 @@ export function createRule(params) {
 }
 export function saveRule(rule) {
     rule.updated_at = new Date().toISOString();
+    // v0.4.1 audit-trail 불변식: rule 저장 시 lifecycle state 가 null/undefined 이면
+    // active phase 기본값 주입. 이전에는 old rule 파일이 lifecycle 없이 존재해 쌤 이후
+    // audit trail (phase/violation_count/meta_promotions) 추적 불가 — 이번 세션에서
+    // suppressed rule 의 lifecycle=null 발견. initLifecycle 은 기존 값이 있으면 normalize,
+    // 없으면 phase='active' + counters=0 초기화.
+    if (!rule.lifecycle) {
+        rule.lifecycle = initLifecycle(rule);
+    }
     atomicWriteJSON(rulePath(rule.rule_id), rule, { pretty: true });
 }
+/**
+ * ADR-002 T5 — rule 저장 + 기존 active rules 와 자연어 충돌 감지 + 양쪽 conflict_refs 기록.
+ *
+ * saveRule 과의 차이:
+ *   - 저장 직후 T5 detect 실행 → 충돌 발견 시 신규 rule + 반대편 rule 모두 conflict_refs 업데이트.
+ *   - auto-merge 안 함 (ADR-002 §Risks — 사용자 수동 해소).
+ *   - T5 감지 실패는 저장 자체를 막지 않음 (fail-open).
+ *
+ * 반환: 저장된 rule + 감지된 충돌 rule_id 목록.
+ */
+export async function appendRule(rule) {
+    saveRule(rule);
+    try {
+        const [{ detect: detectT5 }, { appendLifecycleEvents }] = await Promise.all([
+            import('../engine/lifecycle/trigger-t5-conflict.js'),
+            import('../engine/lifecycle/meta-reclassifier.js'),
+        ]);
+        const all = loadAllRules();
+        const events = detectT5({ rules: all });
+        const relevant = events.filter((e) => e.evidence?.refs?.includes(rule.rule_id));
+        if (relevant.length === 0)
+            return { saved: true, conflicts_with: [] };
+        // conflict_refs 양방향 업데이트
+        const affected = new Set();
+        for (const ev of relevant)
+            affected.add(ev.rule_id);
+        for (const id of affected) {
+            const target = all.find((r) => r.rule_id === id);
+            if (!target)
+                continue;
+            const refs = relevant
+                .filter((ev) => ev.rule_id === id)
+                .flatMap((ev) => (ev.evidence?.refs ?? []).filter((r) => r !== id));
+            const currentConflicts = target.lifecycle?.conflict_refs ?? [];
+            const merged = [...new Set([...currentConflicts, ...refs])];
+            const lifecycle = target.lifecycle ?? {
+                phase: 'active',
+                first_active_at: target.created_at,
+                inject_count: 0, accept_count: 0, violation_count: 0, bypass_count: 0,
+                conflict_refs: [], meta_promotions: [],
+            };
+            saveRule({ ...target, lifecycle: { ...lifecycle, conflict_refs: merged } });
+        }
+        appendLifecycleEvents(relevant);
+        const conflicts_with = [
+            ...new Set(relevant
+                .filter((e) => e.rule_id === rule.rule_id)
+                .flatMap((e) => (e.evidence?.refs ?? []).filter((r) => r !== rule.rule_id))),
+        ];
+        return { saved: true, conflicts_with };
+    }
+    catch {
+        return { saved: true, conflicts_with: [] };
+    }
+}
 export function loadRule(ruleId) {
     return safeReadJSON(rulePath(ruleId), null);
 }
 export function loadAllRules() {
-    if (!fs.existsSync(ME_RULES))
-        return [];
     const rules = [];
-    for (const file of fs.readdirSync(ME_RULES)) {
-        if (!file.endsWith('.json'))
-            continue;
-        const rule = safeReadJSON(path.join(ME_RULES, file), null);
-        if (rule)
-            rules.push(rule);
+    // 1) 사용자 개인 rules: ~/.forgen/me/rules
+    if (fs.existsSync(ME_RULES)) {
+        for (const file of fs.readdirSync(ME_RULES)) {
+            if (!file.endsWith('.json'))
+                continue;
+            const rule = safeReadJSON(path.join(ME_RULES, file), null);
+            if (rule && isCompatibleSchema(rule, file))
+                rules.push(rule);
+        }
+    }
+    // 2) 프로젝트 로컬 rules: <cwd>/.forgen/rules
+    // ADR-003 Phase 1 Dogfood — 팀/프로젝트가 git 에 committed 한 L1 정책을 자동 로드.
+    // 같은 rule_id 가 me 와 project 양쪽에 있으면 project 가 우선 (git 소스가 정책 진실).
+    const projectRulesDir = resolveProjectRulesDir();
+    if (projectRulesDir && fs.existsSync(projectRulesDir)) {
+        for (const file of fs.readdirSync(projectRulesDir)) {
+            if (!file.endsWith('.json'))
+                continue;
+            const rule = safeReadJSON(path.join(projectRulesDir, file), null);
+            if (!rule || !isCompatibleSchema(rule, file))
+                continue;
+            const existingIdx = rules.findIndex((r) => r.rule_id === rule.rule_id);
+            if (existingIdx >= 0)
+                rules[existingIdx] = rule; // project override
+            else
+                rules.push(rule);
+        }
     }
     return rules;
 }
+/**
+ * R5-B3: schema_version 호환성 체크.
+ * - undefined / 0 / CURRENT_RULE_SCHEMA_VERSION: OK
+ * - > CURRENT: 상위 버전 → graceful skip (downgrade 시 silent corruption 방지)
+ */
+function isCompatibleSchema(rule, filename) {
+    const v = rule.schema_version;
+    if (v == null || v <= CURRENT_RULE_SCHEMA_VERSION)
+        return true;
+    if (process.env.FORGEN_DEBUG_SIGNALS === '1') {
+        process.stderr.write(`[forgen:rule-store] ${filename} schema_version=${v} > supported ${CURRENT_RULE_SCHEMA_VERSION} — skipped\n`);
+    }
+    return false;
+}
+/**
+ * 현재 프로젝트 cwd 의 `.forgen/rules/` 경로. FORGEN_CWD/COMPOUND_CWD 우선.
+ * 테스트 / CI 에서 프로젝트 스코프 로딩을 비활성화하려면 FORGEN_DISABLE_PROJECT_RULES=1.
+ */
+function resolveProjectRulesDir() {
+    if (process.env.FORGEN_DISABLE_PROJECT_RULES === '1')
+        return null;
+    const cwd = process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd();
+    return path.join(cwd, '.forgen', 'rules');
+}
 export function loadActiveRules() {
     return loadAllRules().filter(r => r.status === 'active');
 }
+/**
+ * ADR-002 Meta signal — rule 들이 프롬프트에 inject 되었음을 기록.
+ * rule.lifecycle.inject_count +1, last_inject_at = now.
+ * lifecycle 없던 rule 은 auto-init 하고 phase='active'.
+ * Meta promotion (B→A) 의 rolling window 집계가 이 카운터를 소비한다.
+ */
+export function markRulesInjected(ruleIds, nowIso = new Date().toISOString()) {
+    for (const id of ruleIds) {
+        const rule = loadRule(id);
+        if (!rule)
+            continue;
+        // R6-F1: initLifecycle 이 정규화(카운터 ≥0, 배열 보장) 까지 포함.
+        const lifecycle = initLifecycle(rule);
+        const updated = {
+            ...rule,
+            lifecycle: bumpInject(lifecycle, nowIso),
+        };
+        atomicWriteJSON(rulePath(rule.rule_id), updated, { pretty: true });
+    }
+}
 export function updateRuleStatus(ruleId, status) {
     const rule = loadRule(ruleId);
     if (!rule)