@wooojin/forgen 0.3.2 → 0.4.0

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[];

package/dist/engine/lifecycle/trigger-t5-conflict.js

@@ -0,0 +1,78 @@
+/**
+ * T5 — 규칙 충돌 (conflict_detected).
+ *
+ * 트리거 조건:
+ *   같은 category 인 rule pair 중, policy 자연어가 상반 (negation + 공통 키워드 ≥ 2).
+ *
+ * auto-merge 안 함. conflict_refs 플래그만 설정 → 사용자 수동 해소.
+ */
+const NEGATION_RE = /\b(없|금지|마라|말라|하지\s*않|don'?t|never|not\s+|no\s+|avoid)\b/i;
+function tokens(policy) {
+    return new Set(policy
+        .toLowerCase()
+        .replace(/[.,;:!?()[\]{}"'`~]/g, ' ')
+        .split(/\s+/)
+        .filter((w) => w.length >= 3));
+}
+function sharedTokens(a, b, min) {
+    let count = 0;
+    for (const t of a)
+        if (b.has(t)) {
+            count += 1;
+            if (count >= min)
+                return true;
+        }
+    return false;
+}
+export function detect(input) {
+    const minShared = input.min_shared_tokens ?? 2;
+    const ts = input.ts ?? Date.now();
+    const events = [];
+    const reported = new Set(); // 'a|b' 쌍 중복 방지
+    // M/T5 fix: 짧은 policy 는 토큰 overlap 이 우연히 발생하기 쉬우므로 20자 이상만.
+    // scope 도 같아야 — session-scoped 임시 규칙과 me-scope 영구 규칙이 서로 충돌로 잡히면 노이즈.
+    const active = input.rules.filter((r) => r.status === 'active' && r.policy.length >= 20);
+    for (let i = 0; i < active.length; i++) {
+        const a = active[i];
+        const aTokens = tokens(a.policy);
+        const aNeg = NEGATION_RE.test(a.policy);
+        for (let j = i + 1; j < active.length; j++) {
+            const b = active[j];
+            if (a.category !== b.category)
+                continue;
+            if (a.scope !== b.scope)
+                continue; // M/T5: scope 불일치 시 pair 아님
+            const bTokens = tokens(b.policy);
+            const bNeg = NEGATION_RE.test(b.policy);
+            if (aNeg === bNeg)
+                continue; // 같은 어조 — 충돌 아님
+            if (!sharedTokens(aTokens, bTokens, minShared))
+                continue;
+            const key = [a.rule_id, b.rule_id].sort().join('|');
+            if (reported.has(key))
+                continue;
+            reported.add(key);
+            events.push({
+                kind: 't5_conflict_detected',
+                rule_id: a.rule_id,
+                evidence: {
+                    source: 'rule-pairing',
+                    refs: [a.rule_id, b.rule_id],
+                },
+                suggested_action: 'flag',
+                ts,
+            });
+            events.push({
+                kind: 't5_conflict_detected',
+                rule_id: b.rule_id,
+                evidence: {
+                    source: 'rule-pairing',
+                    refs: [a.rule_id, b.rule_id],
+                },
+                suggested_action: 'flag',
+                ts,
+            });
+        }
+    }
+    return events;
+}

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

@@ -0,0 +1,52 @@
+/**
+ * ADR-002 Lifecycle event model.
+ *
+ * 오케스트레이터가 발행하는 이벤트 — rule 상태 전이의 단위.
+ * 이 파일은 타입만 정의. 실제 이벤트 발행/소비 로직은 각 trigger-*.ts 참조.
+ */
+export type LifecycleEventKind = 't1_explicit_correction' | 't2_repeated_violation' | 't3_user_bypass' | 't4_time_decay' | 't5_conflict_detected' | 'meta_promote_to_a' | 'meta_demote_to_b';
+export type LifecycleSuggestedAction = 'flag' | 'suppress' | 'retire' | 'merge' | 'supersede' | 'promote_mech' | 'demote_mech';
+export interface LifecycleEvent {
+    kind: LifecycleEventKind;
+    rule_id: string;
+    session_id?: string;
+    evidence?: {
+        source: string;
+        refs: string[];
+        metrics?: Record<string, number>;
+    };
+    suggested_action: LifecycleSuggestedAction;
+    /** T5 merge 전용: 흡수 대상 rule_id */
+    merged_into?: string;
+    /** T1 supersede 전용: 교체 rule_id */
+    superseded_by?: string;
+    ts: number;
+}
+/**
+ * 트리거들이 공유하는 rule-level 시그널 집계.
+ * RuleState 는 Rule + signals (pure data). 각 detect() 는 이 상태 배열을 입력으로 받는다.
+ */
+export interface RuleSignals {
+    violations_30d: number;
+    violation_rate_30d: number;
+    bypass_7d: number;
+    last_inject_days_ago: number;
+    injects_rolling_n: number;
+    violations_rolling_n: number;
+    last_updated_days_ago: number;
+}
+export interface ViolationEntry {
+    at: string;
+    rule_id: string;
+    session_id: string;
+    source: 'stop-guard' | 'pre-tool-guard' | 'post-tool-guard' | 'evidence-store' | 'manual';
+    kind: 'block' | 'deny' | 'correction';
+    message_preview?: string;
+}
+export interface BypassEntry {
+    at: string;
+    rule_id: string;
+    session_id: string;
+    tool: string;
+    pattern_preview: string;
+}

package/dist/engine/lifecycle/types.js

@@ -0,0 +1,7 @@
+/**
+ * ADR-002 Lifecycle event model.
+ *
+ * 오케스트레이터가 발행하는 이벤트 — rule 상태 전이의 단위.
+ * 이 파일은 타입만 정의. 실제 이벤트 발행/소비 로직은 각 trigger-*.ts 참조.
+ */
+export {};

package/dist/engine/rule-toggle-cli.d.ts

@@ -0,0 +1,13 @@
+/**
+ * CLI handler for `forgen suppress-rule <id>` / `forgen activate-rule <id>`.
+ *
+ * R7-U2: Day-1 탈출구 — 사용자가 차단 메시지를 보고 JSON 을 손으로 편집하지 않아도
+ * 한 명령으로 규칙을 끄거나 되살릴 수 있도록.
+ *
+ * 구현:
+ *   - prefix-match 지원 (첫 8자만 쳐도 OK).
+ *   - multiple match 이면 목록 출력하고 중단.
+ *   - hard strength rule 은 cli 로도 suppress 불가 (ADR-002 불변 원칙).
+ */
+export declare function handleSuppressRule(args: string[]): Promise<void>;
+export declare function handleActivateRule(args: string[]): Promise<void>;

package/dist/engine/rule-toggle-cli.js

@@ -0,0 +1,76 @@
+/**
+ * CLI handler for `forgen suppress-rule <id>` / `forgen activate-rule <id>`.
+ *
+ * R7-U2: Day-1 탈출구 — 사용자가 차단 메시지를 보고 JSON 을 손으로 편집하지 않아도
+ * 한 명령으로 규칙을 끄거나 되살릴 수 있도록.
+ *
+ * 구현:
+ *   - prefix-match 지원 (첫 8자만 쳐도 OK).
+ *   - multiple match 이면 목록 출력하고 중단.
+ *   - hard strength rule 은 cli 로도 suppress 불가 (ADR-002 불변 원칙).
+ */
+import { loadAllRules, saveRule } from '../store/rule-store.js';
+export async function handleSuppressRule(args) {
+    const partial = args[0];
+    if (!partial) {
+        console.error('Usage: forgen suppress-rule <rule_id | prefix>');
+        process.exit(2);
+    }
+    const all = loadAllRules();
+    const matches = all.filter((r) => r.rule_id === partial || r.rule_id.startsWith(partial));
+    if (matches.length === 0) {
+        console.error(`No rule found matching "${partial}". Try \`forgen inspect rules\`.`);
+        process.exit(1);
+    }
+    if (matches.length > 1) {
+        console.error(`Ambiguous prefix "${partial}" — ${matches.length} rules match:`);
+        for (const r of matches) {
+            console.error(`  ${r.rule_id}  [${r.strength}]  ${r.policy.slice(0, 60)}`);
+        }
+        console.error('Use a longer prefix or the full rule_id.');
+        process.exit(1);
+    }
+    const rule = matches[0];
+    if (rule.strength === 'hard') {
+        console.error(`Refusing to suppress hard rule "${rule.rule_id}" (ADR-002 immutability).`);
+        console.error('  Hard rules require explicit removal from the rule source file.');
+        process.exit(1);
+    }
+    if (rule.status === 'suppressed') {
+        console.log(`Rule ${rule.rule_id} is already suppressed.`);
+        return;
+    }
+    saveRule({ ...rule, status: 'suppressed' });
+    console.log(`✓ Suppressed rule ${rule.rule_id}`);
+    console.log(`  Policy: ${rule.policy.slice(0, 80)}`);
+    console.log(`  Re-activate with: forgen activate-rule ${rule.rule_id}`);
+}
+export async function handleActivateRule(args) {
+    const partial = args[0];
+    if (!partial) {
+        console.error('Usage: forgen activate-rule <rule_id | prefix>');
+        process.exit(2);
+    }
+    const all = loadAllRules();
+    const matches = all.filter((r) => r.rule_id === partial || r.rule_id.startsWith(partial));
+    if (matches.length === 0) {
+        console.error(`No rule found matching "${partial}".`);
+        process.exit(1);
+    }
+    if (matches.length > 1) {
+        console.error(`Ambiguous prefix "${partial}" — ${matches.length} rules. Use longer prefix.`);
+        process.exit(1);
+    }
+    const rule = matches[0];
+    if (rule.status === 'active') {
+        console.log(`Rule ${rule.rule_id} is already active.`);
+        return;
+    }
+    if (rule.status === 'removed' || rule.status === 'superseded') {
+        console.error(`Cannot activate rule with status=${rule.status}. Edit the rule file directly.`);
+        process.exit(1);
+    }
+    saveRule({ ...rule, status: 'active' });
+    console.log(`✓ Activated rule ${rule.rule_id}`);
+    console.log(`  Policy: ${rule.policy.slice(0, 80)}`);
+}

package/dist/forge/evidence-processor.js

@@ -5,8 +5,9 @@
  * Migration Plan §5.4: 이 모듈의 "해석" 계층은 AI(Claude 세션)가 채운다.
  * 여기서는 구조화된 입출력 인터페이스와 알고리즘 적용 함수만 정의.
  */
-import { createEvidence, saveEvidence } from '../store/evidence-store.js';
+import { createEvidence, appendEvidence } from '../store/evidence-store.js';
 import { createRule, saveRule } from '../store/rule-store.js';
+import { classify, applyProposal } from '../engine/enforce-classifier.js';
 // ── Correction → Evidence + Temporary Rule ──
 /**
  * 사용자 교정을 Evidence로 기록하고, 필요 시 temporary rule 생성.
@@ -29,7 +30,7 @@ export function processCorrection(req) {
             direction: req.kind === 'avoid-this' ? 'opposite' : 'same',
         },
     });
-    saveEvidence(evidence);
+    appendEvidence(evidence); // T1 lifecycle trigger fires here for explicit_correction
     // fix-now, avoid-this → temporary session rule
     let temporaryRule = null;
     if (req.kind === 'fix-now' || req.kind === 'avoid-this') {
@@ -45,6 +46,13 @@ export function processCorrection(req) {
             evidence_refs: [evidence.evidence_id],
             render_key: `${req.axis_hint ?? 'workflow'}.${req.target.toLowerCase().replace(/\s+/g, '-').slice(0, 30)}`,
         });
+        // ADR-001 auto-classify on creation — 교정 즉시 enforce_via 가 붙어야 다음 턴부터 Mech-A/B 발화.
+        // 기존 `forgen classify-enforce --apply` 수동 경로를 유지하되, 신규 rule 은 창조 시점에 자동 populate.
+        try {
+            const proposal = classify(temporaryRule);
+            temporaryRule = applyProposal(temporaryRule, proposal);
+        }
+        catch { /* fail-open: classify 실패는 rule 저장 자체를 막지 않음 */ }
         saveRule(temporaryRule);
     }
     return {

package/dist/hooks/context-guard.js

@@ -11,6 +11,7 @@
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import * as os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { createLogger } from '../core/logger.js';
 import { readStdinJSON } from './shared/read-stdin.js';
@@ -129,6 +130,16 @@ export async function main() {
             // 정상 종료 시: 의미 있는 세션이었으면 compound 안내/자동 트리거
             if (input.stop_hook_type === 'user' || input.stop_hook_type === 'end_turn') {
                 const state = loadContextState(sessionId);
+                // ADR-002 T1 — 세션 중간에 교정이 들어와도 session-scoped rule 이 me-scope 으로
+                // 승급되도록 Stop 에서 직접 auto-compound-runner 를 debounced 로 트리거.
+                // 'forgen' CLI 를 통하지 않는 사용자 (claude 직접 실행) 에게도 교정이 유실되지 않는 보장.
+                // dedup: last-auto-compound.json 의 sessionId + 5분 cooldown.
+                try {
+                    await maybeSpawnAutoCompound(sessionId, input.transcript_path, state.promptCount);
+                }
+                catch (e) {
+                    log.debug('auto-compound Stop trigger 실패', e);
+                }
                 if (state.promptCount >= 20) {
                     // 20+ prompts: auto-trigger compound by writing marker
                     try {
@@ -224,6 +235,66 @@ function buildSessionSummary(sessionId, promptCount) {
 }
 // forge-loop 상태 파일 경로
 const FORGE_LOOP_STATE_PATH = path.join(STATE_DIR, 'forge-loop.json');
+/**
+ * Stop hook 에서 auto-compound-runner 를 debounced 로 spawn.
+ *
+ * 호출 조건:
+ *   - promptCount ≥ 10 (의미있는 세션)
+ *   - transcript_path 유효
+ *   - last-auto-compound.json 의 sessionId 가 다르거나 5분 전
+ *
+ * dedup 파일은 session-recovery hook 과 공유되어 double-run 방지.
+ * fire-and-forget (detached) — hook timeout 과 무관.
+ */
+const AUTO_COMPOUND_COOLDOWN_MS = 5 * 60 * 1000; // 5 min
+async function maybeSpawnAutoCompound(sessionId, transcriptPath, promptCount) {
+    if (!transcriptPath || promptCount < 10)
+        return;
+    const markerPath = path.join(STATE_DIR, 'last-auto-compound.json');
+    try {
+        const raw = fs.readFileSync(markerPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed.sessionId === sessionId) {
+            const last = parsed.completedAt ? Date.parse(parsed.completedAt) : 0;
+            if (Number.isFinite(last) && Date.now() - last < AUTO_COMPOUND_COOLDOWN_MS)
+                return;
+        }
+    }
+    catch { /* first time or corrupt — proceed */ }
+    const { spawn: spawnProcess } = await import('node:child_process');
+    const cwd = process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd();
+    // 기본: 번들된 auto-compound-runner. 프로덕션 빌드는 이 경로만 실행.
+    const defaultRunner = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'core', 'auto-compound-runner.js');
+    // 테스트 주입 경로 — FORGEN_TEST=1 게이트 + 경로 containment (~/.forgen 또는 /tmp 하위만 허용).
+    // FORGEN_TEST 없이 FORGEN_AUTO_COMPOUND_RUNNER_PATH 만 설정되어도 무시 → 임의 코드 실행 방지.
+    let runnerPath = defaultRunner;
+    const override = process.env.FORGEN_AUTO_COMPOUND_RUNNER_PATH;
+    if (override && process.env.FORGEN_TEST === '1') {
+        const resolved = path.resolve(override);
+        const homeDir = os.homedir();
+        const allowed = [
+            path.join(homeDir, '.forgen'),
+            os.tmpdir(), // 플랫폼별 /tmp, /var/folders/... 등
+            '/tmp',
+            path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..'),
+        ];
+        if (allowed.some((root) => resolved === root || resolved.startsWith(root + path.sep))) {
+            runnerPath = resolved;
+        }
+        else {
+            log.debug(`FORGEN_AUTO_COMPOUND_RUNNER_PATH 무시 — ${resolved} 가 허용 루트 밖`);
+        }
+    }
+    else if (override) {
+        log.debug('FORGEN_AUTO_COMPOUND_RUNNER_PATH 무시 — FORGEN_TEST=1 가 필요');
+    }
+    const child = spawnProcess('node', [runnerPath, cwd, transcriptPath, sessionId], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    log.debug(`Stop-triggered auto-compound 시작: ${sessionId} (${promptCount} prompts)`);
+}
 // forge-loop 차단 안전 상한 (무한 루프 방지)
 const FORGE_LOOP_MAX_BLOCKS = 30;
 const FORGE_LOOP_STALE_MS = 2 * 60 * 60 * 1000; // 2시간