@wooojin/forgen 0.4.12 → 0.5.0

package/dist/engine/correction-cluster-runner.js

@@ -0,0 +1,188 @@
+/**
+ * correction-cluster-runner — W3-2 클러스터링 실행 (파일 IO / 룰 저장 / 훅 연결).
+ * 순수 로직은 correction-clustering.ts. 여기서만 rule-store 를 건드린다.
+ *
+ * 흐름 (세션종료 시 auto-compound-runner:promoteSessionCandidates 직후 호출):
+ *   1. me-scope active explicit_correction 룰(비-hard) 로드
+ *   2. 억제목록 로드 → clusterCorrectionRules
+ *   3. 각 클러스터: T5 내부 모순이면 스킵(conflict 우선), 아니면 통합 rule 생성 +
+ *      원본 superseded + clustered_into 링크
+ *   4. 통합 요약 반환(호출측이 알림)
+ *
+ * unmerge: 통합 rule 제거 + 원본 active 복원 + 조합을 억제목록에 추가(재통합 방지).
+ */
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createLogger } from '../core/logger.js';
+import { STATE_DIR } from '../core/paths.js';
+import { atomicWriteJSON, safeReadJSON } from '../hooks/shared/atomic-write.js';
+import { withFileLock } from '../hooks/shared/file-lock.js';
+import { createRule, loadAllRules, loadRule, saveRule } from '../store/rule-store.js';
+import { clusterCorrectionRules, clusterKey, } from './correction-clustering.js';
+const log = createLogger('correction-cluster');
+const SUPPRESSION_PATH = path.join(STATE_DIR, 'cluster-suppression.json');
+/** 동시 세션종료 클러스터링 직렬화용 락 대상 경로(SEV-3 #4). */
+const CLUSTER_LOCK_PATH = path.join(STATE_DIR, 'cluster-run');
+function loadSuppression() {
+    const st = safeReadJSON(SUPPRESSION_PATH, null);
+    return new Set(st?.keys ?? []);
+}
+function saveSuppression(keys) {
+    try {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        atomicWriteJSON(SUPPRESSION_PATH, { keys: [...keys] });
+    }
+    catch (e) {
+        log.debug('cluster-suppression 저장 실패', e);
+    }
+}
+function toClusterable(r) {
+    return {
+        rule_id: r.rule_id,
+        category: r.category,
+        policy: r.policy,
+        strength: r.strength,
+        evidence_refs: r.evidence_refs ?? [],
+    };
+}
+/**
+ * render_key for a merged cluster rule: `category.cluster.<slug>-<hash>`.
+ * 리뷰 SEV-3: slug(30자 접두)만으로는 두 별개 클러스터가 같은 slug 를 가질 때
+ * dedupeByRenderKey 가 하나를 조용히 드롭(교정 소실)할 수 있다. clusterKey 해시를
+ * 접미해 통합룰 render_key 를 무조건 유니크화 → 충돌 원천봉쇄(가독성 유지).
+ */
+function mergedRenderKey(cluster) {
+    const category = cluster.members[0]?.category ?? 'workflow';
+    const slug = cluster.representativePolicy
+        .toLowerCase()
+        .replace(/[^가-힣a-z0-9\s]/g, '')
+        .trim()
+        .replace(/\s+/g, '-')
+        .slice(0, 30);
+    const hash = crypto
+        .createHash('sha1')
+        .update(clusterKey(cluster.members))
+        .digest('hex')
+        .slice(0, 8);
+    return `${category}.cluster.${slug}-${hash}`;
+}
+/** 통합(cluster-merge) 룰인지 — render_key 의 `.cluster.` 인픽스로 식별(내부 생성만 사용). */
+function isClusterMergedRule(r) {
+    return r.render_key.includes('.cluster.');
+}
+/**
+ * 세션종료 클러스터링 실행. 통합 발생 시 각 통합 요약 배열 반환(빈 배열이면 no-op).
+ * 자동 실행이므로 조용하지 않게 — 호출측이 결과를 stderr/알림으로 노출한다.
+ */
+export async function runCorrectionClustering() {
+    // 리뷰 SEV-3 #4: auto-compound 는 세션별 detached 실행이라 두 세션 동시 종료 시
+    // 병렬 진입 가능 → 같은 후보로 각자 통합룰 생성/last-write-wins 불일치. 파일락으로
+    // 클러스터링 임계구역을 직렬화한다. fail-open(락 실패는 예외 → 호출측 catch).
+    fs.mkdirSync(STATE_DIR, { recursive: true }); // 락 파일 생성 전 상태 디렉터리 보장
+    return withFileLock(CLUSTER_LOCK_PATH, () => runCorrectionClusteringLocked());
+}
+async function runCorrectionClusteringLocked() {
+    const all = loadAllRules();
+    const candidates = all.filter((r) => r.scope === 'me' &&
+        r.status === 'active' &&
+        r.source === 'explicit_correction' &&
+        r.strength !== 'hard');
+    if (candidates.length < 2)
+        return [];
+    const suppressed = loadSuppression();
+    const clusters = clusterCorrectionRules(candidates.map(toClusterable), suppressed);
+    if (clusters.length === 0)
+        return [];
+    // T5 내부 모순 확인용 detector (동적 import — 순환 의존 회피).
+    const { detect: detectT5 } = await import('./lifecycle/trigger-t5-conflict.js');
+    const results = [];
+    for (const cluster of clusters) {
+        const memberRules = cluster.members
+            .map((m) => candidates.find((c) => c.rule_id === m.rule_id))
+            .filter((r) => Boolean(r));
+        if (memberRules.length < 2)
+            continue;
+        // 클러스터 내부에 T5 모순(상반 교정)이 있으면 통합하지 않는다 — conflict 해소 우선.
+        const conflicts = detectT5({ rules: memberRules });
+        if (conflicts.length > 0) {
+            log.debug(`클러스터 통합 스킵(T5 모순): ${clusterKey(cluster.members)}`);
+            continue;
+        }
+        const category = memberRules[0].category;
+        // 리뷰 SEV-3 #2: 클러스터에 이미 통합룰이 있으면 새 M2 를 만들지 않고 *기존 통합룰에
+        // 흡수*한다(supersession 체인 방지). evidence/강도/policy 를 갱신하고 신규 멤버만
+        // superseded. 없으면 새 통합룰 생성.
+        const existingMerged = memberRules.filter(isClusterMergedRule);
+        let mergedId;
+        let absorbed;
+        if (existingMerged.length > 0) {
+            const absorber = existingMerged[0];
+            absorber.status = 'active';
+            absorber.clustered_into = undefined;
+            absorber.policy = cluster.representativePolicy;
+            absorber.strength = cluster.strength;
+            absorber.evidence_refs = cluster.evidenceRefs;
+            saveRule(absorber);
+            mergedId = absorber.rule_id;
+            absorbed = memberRules.filter((r) => r.rule_id !== absorber.rule_id);
+        }
+        else {
+            const merged = createRule({
+                category,
+                scope: 'me',
+                trigger: memberRules[0].trigger,
+                policy: cluster.representativePolicy,
+                strength: cluster.strength,
+                source: 'explicit_correction',
+                evidence_refs: cluster.evidenceRefs,
+                render_key: mergedRenderKey(cluster),
+            });
+            saveRule(merged);
+            mergedId = merged.rule_id;
+            absorbed = memberRules;
+        }
+        // 흡수된 원본은 삭제하지 않고 superseded + clustered_into 링크(unmerge 복원 가능).
+        for (const orig of absorbed) {
+            orig.status = 'superseded';
+            orig.clustered_into = mergedId;
+            saveRule(orig);
+        }
+        results.push({
+            mergedRuleId: mergedId,
+            memberIds: absorbed.map((r) => r.rule_id),
+            category,
+            strength: cluster.strength,
+            confidence: cluster.confidence,
+            policy: cluster.representativePolicy,
+        });
+        log.debug(`클러스터 통합: +${absorbed.length}룰 → ${mergedId} (${cluster.strength})`);
+    }
+    return results;
+}
+/**
+ * 통합 취소: 통합 rule 을 removed 처리하고 원본 룰을 active 복원, 조합을 억제목록에 추가.
+ * 억제로 인해 다음 세션종료에 같은 조합이 재통합되지 않는다.
+ */
+export function unmergeCluster(mergedRuleId) {
+    const merged = loadRule(mergedRuleId);
+    if (!merged)
+        return { ok: false, restored: [], reason: `통합 rule 없음: ${mergedRuleId}` };
+    const all = loadAllRules();
+    const members = all.filter((r) => r.clustered_into === mergedRuleId);
+    if (members.length === 0) {
+        return { ok: false, restored: [], reason: '이 통합 rule 에 연결된 원본이 없음' };
+    }
+    for (const orig of members) {
+        orig.status = 'active';
+        orig.clustered_into = undefined;
+        saveRule(orig);
+    }
+    merged.status = 'removed';
+    saveRule(merged);
+    // 이 조합을 억제목록에 추가 → 재통합 방지.
+    const suppressed = loadSuppression();
+    suppressed.add(clusterKey(members));
+    saveSuppression(suppressed);
+    return { ok: true, restored: members.map((r) => r.rule_id) };
+}

package/dist/engine/correction-clustering.d.ts

@@ -0,0 +1,80 @@
+/**
+ * correction-clustering — 교정 룰 클러스터링 → 통합 승급 (Wave 3 W3-2).
+ * 설계: reports/feature-audit/w3-2-design.md
+ *
+ * 문제: 같은 원칙을 문구·target 만 바꿔 N회 교정하면, promoteSessionCandidates 가
+ * render_key(정확 중복)만 dedup 하므로 N개 별도 `default` 룰로 흩어진다. "사용자가
+ * N번 교정했다"는 강한 개인화 신호(강도↑)가 소실된다.
+ *
+ * 델타 (기존 파이프라인엔 없는 2개만):
+ *   D1. 의미 클러스터링 — 같은 axis 내 교정 룰을 유사도로 묶는다.
+ *   D2. 반복 → 강도 — 클러스터 크기 N 을 Laplace 계승법칙 confidence 로 환산해 강도 tier 결정.
+ *
+ * 근거 (임의 상수 아님):
+ *   - τ=0.3: `solution-injector.MIN_INJECT_RELEVANCE`(동일 relevance-scorer 표현에 2026-04-21
+ *     gate sweep 으로 실측 튜닝된 게이트)을 상속.
+ *   - confidence=(s+1)/(s+f+2): Laplace 계승법칙(1814) / Beta-Bernoulli 사후평균.
+ *
+ * 이 모듈은 *순수 로직*만 담는다 — 파일 IO/룰 저장/훅 연결은 호출측(correction-cluster-runner).
+ */
+import type { RuleStrength } from '../store/types.js';
+/** τ — 클러스터 편입 유사도 임계. 정준 게이트(RELEVANCE_MATCH_GATE=0.3)를 코드로 상속. */
+export declare const CLUSTER_SIMILARITY_TAU = 0.3;
+/** 클러스터링 입력: 룰의 최소 표현(순수 로직이 파일/스토어에 의존하지 않도록). */
+export interface ClusterableRule {
+    rule_id: string;
+    /** 클러스터는 같은 category(=axis) 안에서만 형성된다. */
+    category: string;
+    policy: string;
+    strength: RuleStrength;
+    evidence_refs: string[];
+}
+export interface CorrectionCluster {
+    /** 통합 대상 룰들(크기 ≥ 2). */
+    members: ClusterableRule[];
+    /** 대표 정책(가장 긴 policy — 보통 가장 서술적). 통합 룰의 policy 후보. */
+    representativePolicy: string;
+    /** Laplace 계승법칙 confidence = (N+1)/(N+2). */
+    confidence: number;
+    /** confidence → 강도 tier. hard 로는 절대 자동 도달하지 않는다. */
+    strength: RuleStrength;
+    /** 통합 룰의 evidence_refs(멤버 union). */
+    evidenceRefs: string[];
+}
+/**
+ * 두 정책 텍스트의 대칭 유사도. calculateRelevance 는 비대칭(prompt→solution)이라
+ * 양방향 평균으로 대칭화한다. confidence 인자는 1(순수 태그 매치만 보고 싶음).
+ */
+export declare function policySimilarity(a: string, b: string): number;
+/**
+ * Laplace 계승법칙 (rule of succession, 1814).
+ * s = 일관 교정 횟수, f = 모순(반박) 횟수. 지속 선호일 사후평균 = (s+1)/(s+f+2).
+ * N회 일관·모순0 → (N+1)/(N+2): N=1→0.67, N=2→0.75, N=3→0.80, N=5→0.86.
+ */
+export declare function laplaceConfidence(successes: number, failures?: number): number;
+/**
+ * confidence → 강도 tier. statusConfidence 밴드(verified=0.75)에 매핑.
+ * confidence ≥ 0.75 (= N≥2 일관교정) → strong. 그 미만 → default.
+ * hard 는 confidence 로 자동 도달하지 않는다 — L1 안전룰 전용(오탐 시 세션 차단 위험).
+ */
+export declare function strengthForConfidence(confidence: number): RuleStrength;
+/**
+ * 같은 category(axis) 내 룰들을 유사도 그래프의 connected component 로 클러스터링.
+ * 크기 ≥ 2 인 클러스터만 반환. hard 룰은 후보에서 제외(안전룰은 통합 대상 아님).
+ *
+ * @param rules 후보 룰들(호출측이 me-scope active explicit_correction 로 필터해서 전달)
+ * @param suppressed 억제 조합 키 집합(unmerge 된 조합 재통합 방지) — 정렬된 rule_id join
+ */
+export declare function clusterCorrectionRules(rules: ClusterableRule[], suppressed?: ReadonlySet<string>): CorrectionCluster[];
+/** 클러스터 멤버 집합의 안정 키(정렬된 rule_id join) — 억제 목록/식별용. */
+export declare function clusterKey(members: Array<{
+    rule_id: string;
+}>): string;
+/**
+ * 이 클러스터가 억제 대상인지 — 정확 일치뿐 아니라 부분집합/상위집합 관계도 억제한다.
+ * 사용자가 거부한 조합(억제키)이 현재 클러스터에 포함(S⊆cur)되거나 현재 클러스터가
+ * 거부 조합의 일부(cur⊆S)면 재통합하지 않는다. 데이터 손실 없음(안 묶으면 흩어진 채 유지).
+ */
+export declare function isSuppressedCluster(members: Array<{
+    rule_id: string;
+}>, suppressed: ReadonlySet<string>): boolean;

package/dist/engine/correction-clustering.js

@@ -0,0 +1,167 @@
+/**
+ * correction-clustering — 교정 룰 클러스터링 → 통합 승급 (Wave 3 W3-2).
+ * 설계: reports/feature-audit/w3-2-design.md
+ *
+ * 문제: 같은 원칙을 문구·target 만 바꿔 N회 교정하면, promoteSessionCandidates 가
+ * render_key(정확 중복)만 dedup 하므로 N개 별도 `default` 룰로 흩어진다. "사용자가
+ * N번 교정했다"는 강한 개인화 신호(강도↑)가 소실된다.
+ *
+ * 델타 (기존 파이프라인엔 없는 2개만):
+ *   D1. 의미 클러스터링 — 같은 axis 내 교정 룰을 유사도로 묶는다.
+ *   D2. 반복 → 강도 — 클러스터 크기 N 을 Laplace 계승법칙 confidence 로 환산해 강도 tier 결정.
+ *
+ * 근거 (임의 상수 아님):
+ *   - τ=0.3: `solution-injector.MIN_INJECT_RELEVANCE`(동일 relevance-scorer 표현에 2026-04-21
+ *     gate sweep 으로 실측 튜닝된 게이트)을 상속.
+ *   - confidence=(s+1)/(s+f+2): Laplace 계승법칙(1814) / Beta-Bernoulli 사후평균.
+ *
+ * 이 모듈은 *순수 로직*만 담는다 — 파일 IO/룰 저장/훅 연결은 호출측(correction-cluster-runner).
+ */
+import { statusConfidence } from './compound-lifecycle.js';
+import { RELEVANCE_MATCH_GATE } from './relevance-gate.js';
+import { calculateRelevance } from './relevance-scorer.js';
+import { extractTags } from './solution-format.js';
+/** τ — 클러스터 편입 유사도 임계. 정준 게이트(RELEVANCE_MATCH_GATE=0.3)를 코드로 상속. */
+export const CLUSTER_SIMILARITY_TAU = RELEVANCE_MATCH_GATE;
+/** 강도 승급 컷오프 — statusConfidence('verified')=0.75 를 코드로 상속(리터럴 복제 아님). */
+const STRONG_CONFIDENCE_CUTOFF = statusConfidence('verified');
+/** 클러스터 대상이 되는 최소 정책 텍스트 길이(너무 짧으면 tag 신호 부족). */
+const MIN_POLICY_LEN = 10;
+/**
+ * 두 정책 텍스트의 대칭 유사도. calculateRelevance 는 비대칭(prompt→solution)이라
+ * 양방향 평균으로 대칭화한다. confidence 인자는 1(순수 태그 매치만 보고 싶음).
+ */
+export function policySimilarity(a, b) {
+    const tagsA = extractTags(a);
+    const tagsB = extractTags(b);
+    if (tagsA.length === 0 || tagsB.length === 0)
+        return 0;
+    const ab = calculateRelevance(tagsA, tagsB, 1);
+    const ba = calculateRelevance(tagsB, tagsA, 1);
+    return (ab.relevance + ba.relevance) / 2;
+}
+/**
+ * Laplace 계승법칙 (rule of succession, 1814).
+ * s = 일관 교정 횟수, f = 모순(반박) 횟수. 지속 선호일 사후평균 = (s+1)/(s+f+2).
+ * N회 일관·모순0 → (N+1)/(N+2): N=1→0.67, N=2→0.75, N=3→0.80, N=5→0.86.
+ */
+export function laplaceConfidence(successes, failures = 0) {
+    return (successes + 1) / (successes + failures + 2);
+}
+/**
+ * confidence → 강도 tier. statusConfidence 밴드(verified=0.75)에 매핑.
+ * confidence ≥ 0.75 (= N≥2 일관교정) → strong. 그 미만 → default.
+ * hard 는 confidence 로 자동 도달하지 않는다 — L1 안전룰 전용(오탐 시 세션 차단 위험).
+ */
+export function strengthForConfidence(confidence) {
+    return confidence >= STRONG_CONFIDENCE_CUTOFF ? 'strong' : 'default';
+}
+/**
+ * 같은 category(axis) 내 룰들을 유사도 그래프의 connected component 로 클러스터링.
+ * 크기 ≥ 2 인 클러스터만 반환. hard 룰은 후보에서 제외(안전룰은 통합 대상 아님).
+ *
+ * @param rules 후보 룰들(호출측이 me-scope active explicit_correction 로 필터해서 전달)
+ * @param suppressed 억제 조합 키 집합(unmerge 된 조합 재통합 방지) — 정렬된 rule_id join
+ */
+export function clusterCorrectionRules(rules, suppressed = new Set()) {
+    const eligible = rules.filter((r) => r.strength !== 'hard' && (r.policy?.length ?? 0) >= MIN_POLICY_LEN);
+    // category 별 그룹핑 — 클러스터는 axis 경계를 넘지 않는다.
+    const byCategory = new Map();
+    for (const r of eligible) {
+        const arr = byCategory.get(r.category) ?? [];
+        arr.push(r);
+        byCategory.set(r.category, arr);
+    }
+    const clusters = [];
+    for (const group of byCategory.values()) {
+        if (group.length < 2)
+            continue;
+        // Union-Find over the group by pairwise similarity ≥ τ.
+        const parent = group.map((_, i) => i);
+        const find = (x) => {
+            while (parent[x] !== x) {
+                parent[x] = parent[parent[x]];
+                x = parent[x];
+            }
+            return x;
+        };
+        const union = (a, b) => {
+            const ra = find(a);
+            const rb = find(b);
+            if (ra !== rb)
+                parent[ra] = rb;
+        };
+        for (let i = 0; i < group.length; i++) {
+            for (let j = i + 1; j < group.length; j++) {
+                if (policySimilarity(group[i].policy, group[j].policy) >= CLUSTER_SIMILARITY_TAU) {
+                    union(i, j);
+                }
+            }
+        }
+        // component 수집
+        const components = new Map();
+        for (let i = 0; i < group.length; i++) {
+            const root = find(i);
+            const arr = components.get(root) ?? [];
+            arr.push(group[i]);
+            components.set(root, arr);
+        }
+        for (const members of components.values()) {
+            if (members.length < 2)
+                continue;
+            // 억제된 조합이면 스킵. 정확 일치뿐 아니라 *부분집합/상위집합*도 억제 —
+            // {a,b,c} 를 unmerge 했는데 유사교정 d 도착으로 {a,b,c,d} 가 재통합되는
+            // whack-a-mole 방지 (리뷰 SEV-3 #3).
+            if (isSuppressedCluster(members, suppressed))
+                continue;
+            const representativePolicy = members
+                .map((m) => m.policy)
+                .reduce((a, b) => (b.length > a.length ? b : a));
+            const evidenceRefs = Array.from(new Set(members.flatMap((m) => m.evidence_refs ?? [])));
+            // Laplace 의 N = *교정 관측 횟수* = 고유 evidence 수 (룰 객체 수가 아님).
+            // raw 교정 룰은 evidence 1개씩이라 base case 는 members.length 와 동일하지만,
+            // 이미 통합된 룰이 재-클러스터될 때(evidence 다수 보유) 반복 횟수를 정확히 누적한다.
+            const observationCount = Math.max(evidenceRefs.length, members.length);
+            const confidence = laplaceConfidence(observationCount);
+            clusters.push({
+                members,
+                representativePolicy,
+                confidence,
+                strength: strengthForConfidence(confidence),
+                evidenceRefs,
+            });
+        }
+    }
+    return clusters;
+}
+/** 클러스터 멤버 집합의 안정 키(정렬된 rule_id join) — 억제 목록/식별용. */
+export function clusterKey(members) {
+    return members
+        .map((m) => m.rule_id)
+        .sort()
+        .join('|');
+}
+function isSubset(a, b) {
+    for (const x of a)
+        if (!b.has(x))
+            return false;
+    return true;
+}
+/**
+ * 이 클러스터가 억제 대상인지 — 정확 일치뿐 아니라 부분집합/상위집합 관계도 억제한다.
+ * 사용자가 거부한 조합(억제키)이 현재 클러스터에 포함(S⊆cur)되거나 현재 클러스터가
+ * 거부 조합의 일부(cur⊆S)면 재통합하지 않는다. 데이터 손실 없음(안 묶으면 흩어진 채 유지).
+ */
+export function isSuppressedCluster(members, suppressed) {
+    if (suppressed.size === 0)
+        return false;
+    const cur = new Set(members.map((m) => m.rule_id));
+    for (const key of suppressed) {
+        if (!key)
+            continue;
+        const s = new Set(key.split('|'));
+        if (isSubset(s, cur) || isSubset(cur, s))
+            return true;
+    }
+    return false;
+}

package/dist/engine/enforce-classifier.d.ts

@@ -6,7 +6,10 @@
  *
  * 휴리스틱 (ADR-001 §Migration heuristics):
  *   - trigger/policy 에 `rm|force|DROP|credentials|\.env` → Mech-A PreToolUse + tool_arg_regex
- *   - trigger/policy 에 `완료|complete|done|e2e|mock|verify` → Mech-A Stop + artifact_check
+ *   - trigger/policy 에 `완료|complete|done|e2e|mock|verify` + 명시적 증거 경로(*.json)
+ *     → Mech-A Stop + artifact_check. 경로 미명시 → Mech-B self_check_prompt
+ *     (무경로 디폴트 .forgen/state/e2e-result.json 은 e2e 게이트 폐지(ADR-010 W0) 후
+ *     죽은 경로가 되어 완료 선언을 영구 차단하는 룰을 재생산했다 — 리뷰 발견)
  *   - strength ∈ {strong, hard} + 문체/응답 맥락 → Mech-B UserPromptSubmit + self_check_prompt
  *   - 그 외 soft/default → Mech-C (drift 측정)
  *
@@ -25,6 +28,12 @@ export interface EnforceProposal {
 }
 export declare function classify(rule: Rule): EnforceProposal;
 export declare function classifyAll(rules: Rule[]): EnforceProposal[];
+/**
+ * critic-review 룰인데 baked Stop 트리거가 skip-review 시그널을 안 가지는지 (리뷰 SEV-3 (c)).
+ * true 면 `forgen rule classify --apply --force` 재-bake 로 갱신해야 갭이 닫힌다.
+ * doctor nudge 용 — "고쳤는데 기존 유저에겐 안 닿는" 상태를 발견 가능하게 한다.
+ */
+export declare function needsCriticTriggerMigration(rule: Rule): boolean;
 /** 제안을 적용해 새 Rule 을 반환 (pure). 이미 enforce_via 가 있으면 force=false 에서 건너뜀. */
 export declare function applyProposal(rule: Rule, proposal: EnforceProposal, options?: {
     force?: boolean;

package/dist/engine/enforce-classifier.js

@@ -6,7 +6,10 @@
  *
  * 휴리스틱 (ADR-001 §Migration heuristics):
  *   - trigger/policy 에 `rm|force|DROP|credentials|\.env` → Mech-A PreToolUse + tool_arg_regex
- *   - trigger/policy 에 `완료|complete|done|e2e|mock|verify` → Mech-A Stop + artifact_check
+ *   - trigger/policy 에 `완료|complete|done|e2e|mock|verify` + 명시적 증거 경로(*.json)
+ *     → Mech-A Stop + artifact_check. 경로 미명시 → Mech-B self_check_prompt
+ *     (무경로 디폴트 .forgen/state/e2e-result.json 은 e2e 게이트 폐지(ADR-010 W0) 후
+ *     죽은 경로가 되어 완료 선언을 영구 차단하는 룰을 재생산했다 — 리뷰 발견)
  *   - strength ∈ {strong, hard} + 문체/응답 맥락 → Mech-B UserPromptSubmit + self_check_prompt
  *   - 그 외 soft/default → Mech-C (drift 측정)
  *
@@ -18,11 +21,49 @@
 const DESTRUCTIVE_PATTERN = /\b(rm\s+-rf|rm\s+-fr|force|DROP\s+TABLE|credentials|\.env|sudo|mkfs|dd\s+if=)/i;
 const COMPLETION_PATTERN = /(완료|complete|done|ready|shipped|finished|e2e|mock|verify|검증|배포)/i;
 const STYLE_PATTERN = /(문체|응답|설명|톤|어투|장황|간결|verbose|tone|style)/i;
+/** rule 텍스트에 명시된 증거 파일 경로 (예: ~/.forgen/state/e2e-result.json). */
+const ARTIFACT_PATH_PATTERN = /(?:~\/)?[\w.-]+(?:\/[\w.-]+)*\.json/;
+/**
+ * 폐지/완화 성격의 룰 감지 — "X를 더 이상 요구하지 않는다" 류 교정은 기존 게이트를
+ * *해제*하는 룰인데, 텍스트에 완료 키워드+경로가 남아 있어 완료 게이트로 오분류됐다
+ * (실사례: e2e 게이트 폐지 교정 룰이 폐지 대상 게이트를 스스로 강제).
+ * 금지문("~하지 마라")이 함께 있으면 폐지가 아니라 강제 룰이다 — 금지문이 우선한다
+ * (리뷰 #9: "완화 없이 검증 완료를 선언하지 마라"가 repeal 로 오탐되던 케이스).
+ */
+const REPEAL_PATTERN = /(더\s*이상.{0,60}(않는다|않음|안\s*한다)|폐지|완화|선택\s*사항|필요\s*없|optional|no\s+longer\s+require)/i;
+const PROHIBITION_PATTERN = /(하지\s*마라|하지\s*말|말\s*것|금지)/;
+/**
+ * 증거 맥락 감지 — artifact_check 는 경로가 증거 아티팩트로 보일 때만 부착한다.
+ * 부수적 .json 언급(package.json 버전 확인 등)에 게이트를 걸면 ~/.forgen 상대해석
+ * 으로 파일이 영원히 부재 → 완료 영구 차단 (리뷰 #9 구성 실증).
+ */
+const EVIDENCE_CONTEXT_PATTERN = /(증거|evidence|검증\s*결과|e2e-result|smoke-report)/i;
 // R6-F2: shared single source of truth — stop-guard 와 동일 regex 재사용.
-import { DEFAULT_STOP_TRIGGER_RE as STOP_COMPLETION_TRIGGER, DEFAULT_STOP_EXCLUDE_RE as STOP_COMPLETION_EXCLUDE, MOCK_TRIGGER_RE as STOP_MOCK_TRIGGER, MOCK_EXCLUDE_RE as STOP_MOCK_EXCLUDE, } from '../hooks/shared/stop-triggers.js';
+import { DEFAULT_STOP_TRIGGER_RE as STOP_COMPLETION_TRIGGER, DEFAULT_STOP_EXCLUDE_RE as STOP_COMPLETION_EXCLUDE, MOCK_TRIGGER_RE as STOP_MOCK_TRIGGER, MOCK_EXCLUDE_RE as STOP_MOCK_EXCLUDE, CRITIC_STOP_TRIGGER_RE, CRITIC_STOP_EXCLUDE_RE, } from '../hooks/shared/stop-triggers.js';
+/**
+ * critic-review 룰 감지 (2026-07-22, 리뷰 SEV-2 #3): "비판 리뷰/critic 을 돌리고 다음으로
+ * 넘어감" 정책만 skip-review 트리거를 받는다. e2e·mock 등 다른 완료룰은 DEFAULT(완료 전용)
+ * 유지 → semantic 오염 방지.
+ */
+// 검토 동사목록을 리뷰와 대칭화(진행|수행|돌리 추가) — 리뷰 SEV-3 (b): "검토를 진행하라" 미탐 수정.
+const CRITIC_REVIEW_PATTERN = /(비판\s*리뷰|fresh-context|critic|리뷰를?\s*(돌리|수행|진행|후)|검토를?\s*(하고|후|없이|생략|진행|수행|돌리))/i;
 export function classify(rule) {
     const reasoning = [];
     const proposed = [];
+    // ADR-013 (critic 재검증 #2): 채굴 교정(behavior_inference)은 **data-level invariant** 로
+    // advisory-only. classify 자체가 여기서 빈 proposal 을 반환하므로, promote 든
+    // `forgen classify-enforce --apply` 든 어떤 경로로도 채굴 룰이 Mech-A 차단을 얻지 못한다.
+    // (enforce_via=[] 를 "미분류"로 보고 재분류하던 CLI 우회 경로 근절.)
+    if (rule.source === 'behavior_inference') {
+        reasoning.push('behavior_inference (auto-mined) → advisory-only, no enforcement (ADR-013)');
+        return {
+            rule_id: rule.rule_id,
+            trigger_preview: rule.trigger.slice(0, 60),
+            current_enforce_via: rule.enforce_via ?? null,
+            proposed: [],
+            reasoning,
+        };
+    }
     const text = `${rule.trigger}\n${rule.policy}`;
     const isDestructive = DESTRUCTIVE_PATTERN.test(text);
     const isCompletion = COMPLETION_PATTERN.test(text);
@@ -53,28 +94,62 @@ export function classify(rule) {
         });
         reasoning.push(`destructive literal "${matchedLiteral}" → Mech-A PreToolUse+tool_arg_regex ${pattern}`);
     }
-    // Mech-A Stop — 완료 선언 + 증거 요구 (destructive 와 독립적으로 평가: 하나의 rule 이 둘 다 해당 가능)
-    if (isCompletion) {
+    // Mech-A Stop — 완료 선언 + 증거 요구 (destructive 와 독립적으로 평가: 하나의 rule 이 둘 다 해당 가능).
+    // artifact_check 는 rule 텍스트가 증거 경로를 명시했을 때만 제안한다. 과거의 무경로
+    // 디폴트(.forgen/state/e2e-result.json)는 e2e 게이트 폐지 후 죽은 경로가 되어,
+    // "완료" 키워드가 있는 모든 신규 룰이 영구 차단 게이트를 물려받는 버그를 낳았다.
+    let completionSelfCheck = false;
+    const isRepeal = REPEAL_PATTERN.test(text) && !PROHIBITION_PATTERN.test(text);
+    if (isRepeal && isCompletion) {
+        reasoning.push('repeal/relaxation phrasing → 완료 게이트 제안 생략 (게이트 해제 룰이 게이트를 강제하는 오분류 방지)');
+    }
+    if (isCompletion && !isRepeal) {
         const mockAsProof = /mock|stub|fake/i.test(text);
-        // 증거 파일 경로는 v0.4.0 최종 구현에서 rule.policy 에서 추출; 지금은 default 사용
-        proposed.push({
-            mech: 'A',
-            hook: 'Stop',
-            verifier: {
-                kind: 'artifact_check',
-                params: { path: '.forgen/state/e2e-result.json', max_age_s: 3600 },
-            },
-            block_message: `${rule.rule_id.slice(0, 8)}: ${rule.policy.slice(0, 120)}`,
-            trigger_keywords_regex: mockAsProof ? STOP_MOCK_TRIGGER : STOP_COMPLETION_TRIGGER,
-            trigger_exclude_regex: mockAsProof ? STOP_MOCK_EXCLUDE : STOP_COMPLETION_EXCLUDE,
-            system_tag: `rule:${rule.rule_id.slice(0, 8)} — ${mockAsProof ? 'no-mock-as-proof' : 'e2e-before-done'}`,
-        });
-        reasoning.push(mockAsProof
-            ? 'completion + mock keyword → Mech-A Stop+artifact_check (mock trigger)'
-            : 'completion keyword → Mech-A Stop+artifact_check (completion trigger)');
+        const criticReview = CRITIC_REVIEW_PATTERN.test(text);
+        // 트리거 선택: mock > critic-review > 완료-전용. critic 만 skip-review 시그널 포함.
+        const stopTrigger = mockAsProof ? STOP_MOCK_TRIGGER : criticReview ? CRITIC_STOP_TRIGGER_RE : STOP_COMPLETION_TRIGGER;
+        const stopExclude = mockAsProof ? STOP_MOCK_EXCLUDE : criticReview ? CRITIC_STOP_EXCLUDE_RE : STOP_COMPLETION_EXCLUDE;
+        const pathMatch = text.match(ARTIFACT_PATH_PATTERN)?.[0];
+        // 증거로 보이는 경로만 게이트화: .forgen/ 하위이거나 텍스트에 증거 맥락어가 있을 때.
+        const explicitArtifact = pathMatch && (pathMatch.includes('.forgen/') || EVIDENCE_CONTEXT_PATTERN.test(text))
+            ? pathMatch : undefined;
+        if (explicitArtifact) {
+            proposed.push({
+                mech: 'A',
+                hook: 'Stop',
+                verifier: {
+                    kind: 'artifact_check',
+                    // stop-guard 는 home 기준 상대경로로 평가 — `~/` 접두는 벗겨서 저장
+                    params: { path: explicitArtifact.replace(/^~\//, ''), max_age_s: 3600 },
+                },
+                block_message: `${rule.rule_id.slice(0, 8)}: ${rule.policy.slice(0, 120)}`,
+                trigger_keywords_regex: stopTrigger,
+                trigger_exclude_regex: stopExclude,
+                system_tag: `rule:${rule.rule_id.slice(0, 8)} — ${mockAsProof ? 'no-mock-as-proof' : 'evidence-before-done'}`,
+            });
+            reasoning.push(`completion + explicit artifact "${explicitArtifact}" → Mech-A Stop+artifact_check`);
+        }
+        else {
+            completionSelfCheck = true;
+            proposed.push({
+                mech: 'B',
+                hook: 'Stop',
+                verifier: {
+                    kind: 'self_check_prompt',
+                    params: {
+                        question: `직전 응답이 다음 규칙을 위반했는지 자가점검하라: "${rule.policy.slice(0, 120)}". 위반 시 구체적 근거와 함께 수정해 재응답하라.`,
+                    },
+                },
+                trigger_keywords_regex: stopTrigger,
+                trigger_exclude_regex: stopExclude,
+                system_tag: `rule:${rule.rule_id.slice(0, 8)} — completion-self-check`,
+            });
+            reasoning.push('completion keyword, no explicit artifact path → Mech-B Stop+self_check_prompt (dead e2e default removed)');
+        }
     }
-    // Mech-B — 문체/응답 관련 또는 strong/hard 정책이지만 기계 판정 어려운 경우
-    if ((isStyle || (isStrong && !isDestructive && !isCompletion))) {
+    // Mech-B — 문체/응답 관련 또는 strong/hard 정책이지만 기계 판정 어려운 경우.
+    // completion self-check 를 이미 제안했다면 동일 훅에 중복 self-check 를 얹지 않는다.
+    if (((isStyle && !completionSelfCheck) || (isStrong && !isDestructive && !isCompletion))) {
         proposed.push({
             mech: 'B',
             hook: 'Stop',
@@ -110,6 +185,20 @@ export function classify(rule) {
 export function classifyAll(rules) {
     return rules.map(classify);
 }
+/**
+ * critic-review 룰인데 baked Stop 트리거가 skip-review 시그널을 안 가지는지 (리뷰 SEV-3 (c)).
+ * true 면 `forgen rule classify --apply --force` 재-bake 로 갱신해야 갭이 닫힌다.
+ * doctor nudge 용 — "고쳤는데 기존 유저에겐 안 닿는" 상태를 발견 가능하게 한다.
+ */
+export function needsCriticTriggerMigration(rule) {
+    const text = `${rule.trigger}\n${rule.policy}`;
+    if (!CRITIC_REVIEW_PATTERN.test(text))
+        return false;
+    const stopSpec = rule.enforce_via?.find((s) => s.hook === 'Stop');
+    if (!stopSpec)
+        return false;
+    return !/생략|넘어가|스킵|패스/.test(stopSpec.trigger_keywords_regex ?? '');
+}
 /** 제안을 적용해 새 Rule 을 반환 (pure). 이미 enforce_via 가 있으면 force=false 에서 건너뜀. */
 export function applyProposal(rule, proposal, options = {}) {
     if (rule.enforce_via && rule.enforce_via.length > 0 && !options.force) {