@wooojin/forgen 0.5.0 → 0.5.6

package/dist/host/install-orchestrator.d.ts

@@ -22,6 +22,10 @@ export interface OrchestratorOptions {
     pkgRoot: string;
     dryRun?: boolean;
     registerMcp?: boolean;
+    /** ADR-016 D1: Codex config.toml notify 폴백 등록 (default true). */
+    registerNotify?: boolean;
+    /** ADR-016 D3: Claude user-level `verify` 스킬 설치 (default true). */
+    installVerifySkill?: boolean;
 }
 export interface OrchestratorResult {
     target: InstallTarget;

package/dist/host/install-orchestrator.js

@@ -97,10 +97,10 @@ export async function runInstall(opts) {
     const dryRun = opts.dryRun ?? false;
     const registerMcp = opts.registerMcp ?? true;
     if (target === 'claude' || target === 'both') {
-        result.claude = planClaudeInstall({ pkgRoot: opts.pkgRoot, dryRun, registerMcp });
+        result.claude = planClaudeInstall({ pkgRoot: opts.pkgRoot, dryRun, registerMcp, installVerifySkill: opts.installVerifySkill });
     }
     if (target === 'codex' || target === 'both') {
-        result.codex = planCodexInstall({ pkgRoot: opts.pkgRoot, dryRun, registerMcp });
+        result.codex = planCodexInstall({ pkgRoot: opts.pkgRoot, dryRun, registerMcp, registerNotify: opts.registerNotify });
     }
     // W3-3: opencode 는 명시 타겟일 때만 설치('both' 는 claude+codex primary-pair 유지).
     if (target === 'opencode') {
@@ -120,6 +120,12 @@ export function renderResult(result, dryRun) {
         lines.push(`    settings.json hooks: ${result.claude.hooksInjected}`);
         lines.push(`    MCP: ${result.claude.mcpAlreadyPresent ? 'already present' : (result.claude.mcpRegistered ? 'registered' : 'skipped')}`);
         lines.push(`    skills: ${result.claude.skillsInstalled ?? 0} installed → ${result.claude.skillsPath ?? ''}`);
+        const verifyLine = {
+            installed: 'installed → ~/.claude/skills/verify (Claude runs it right before non-docs commits)',
+            'user-owned': 'skipped — you already have your own `verify` skill (kept as is)',
+            skipped: 'skipped (--no-verify-skill)',
+        };
+        lines.push(`    verify skill: ${verifyLine[result.claude.verifySkill]}`);
     }
     if (result.codex) {
         lines.push('');
@@ -127,6 +133,30 @@ export function renderResult(result, dryRun) {
         lines.push(`    CODEX_HOME: ${result.codex.codexHome}`);
         lines.push(`    hooks.json: ${result.codex.hooksCount} forgen hooks (preserved user: ${result.codex.preservedUserHookCount})`);
         lines.push(`    MCP: ${result.codex.mcpAlreadyPresent ? 'already present' : (result.codex.mcpRegistered ? 'registered' : 'skipped')}`);
+        lines.push(`    skills: ${result.codex.skillsInstalled} commands + ${result.codex.devGuideSkillsInstalled} dev-guide → ${result.codex.skillsPath}`);
+        lines.push(`    agents: ${result.codex.agentsInstalled} ch-*.toml → ${result.codex.agentsPath}${result.codex.multiAgentEnabled ? '' : '  (⚠ config.toml 에 [features] multi_agent = true 가 없어 Codex 가 spawn 하지 못함 — 추가 권장)'}`);
+        lines.push(`    rules: injected per session via SessionStart hook (<forgen-rules host="codex">)`);
+        const t = result.codex.hookTrust;
+        if (t.total > 0 && t.trusted === t.total) {
+            lines.push(`    hook trust: ${t.trusted}/${t.total} trusted${t.ignoredByCodex.length ? ` (+${t.ignoredByCodex.length} Claude-only event ignored by Codex)` : ''}`);
+        }
+        else {
+            const pending = [...t.modified.map((k) => `${k} (modified)`), ...t.untrusted.map((k) => `${k} (new)`), ...t.disabled.map((k) => `${k} (disabled)`)];
+            lines.push(`    hook trust: ${t.trusted}/${t.total} trusted — ${pending.length} hook(s) need review: ${pending.slice(0, 6).join(', ')}${pending.length > 6 ? ', …' : ''}`);
+            lines.push('      Codex skips these until approved/enabled: run `/hooks` inside codex and trust the forgen entries.');
+            if (t.modified.some((k) => k.startsWith('session_start:'))) {
+                lines.push('      ⚠ session_start is pending — the <forgen-rules> block is NOT injected into Codex sessions until you approve it.');
+            }
+        }
+        const notifyLine = {
+            installed: 'registered (turn-complete fallback — runs even while hooks are untrusted)',
+            'already-present': 'already present',
+            'user-defined': 'skipped — your config.toml already defines `notify` (kept as is). To chain forgen: notify = ["node", "<pkgRoot>/dist/host/codex-notify.js", "--", <your argv…>]',
+            'custom-block': 'left as is — the forgen notify block in config.toml was hand-edited into a form forgen will not rewrite (keep it on one line as a JSON array to let forgen manage it)',
+            skipped: 'skipped (--no-notify)',
+            removed: 'removed (--no-notify)',
+        };
+        lines.push(`    notify: ${notifyLine[result.codex.notify]}`);
     }
     if (result.opencode) {
         lines.push('');

package/dist/host/invoke-agent.js

@@ -95,6 +95,7 @@ export async function invokeAgent(opts) {
         // Phase 3 critic fix: default timeout 60s → 90s (codex sandbox startup +
         // 인증 + LLM 응답까지 60s 부족할 수 있음. tail latency 안전마진).
         const result = execHost({
+            nestedRun: false, // 위임 에이전트는 forgen 훅(안전 tier 포함)이 살아 있어야 한다 (ADR-015 critic #3)
             prompt,
             timeout: opts.timeoutMs ?? 90000,
             host: opts.host,

package/dist/host/parity-harness.js

@@ -80,9 +80,11 @@ export const SCENARIO_CORPUS = [
             claude: { decision: 'block', reason: 'tests not yet executed' },
             codex: { decision: 'block', reason: 'tests not yet executed' },
         },
+        // ADR-015 G1: Stop block 은 top-level decision/reason 으로 전달된다 (양 host 동일 스키마).
         compareKeys: [
             'continue',
-            'hookSpecificOutput.permissionDecision',
+            'decision',
+            'reason',
         ],
     },
     {
@@ -106,9 +108,11 @@ export const SCENARIO_CORPUS = [
                 },
             },
         },
+        // 0.5.4: Codex PostToolUse 스키마는 hookSpecificOutput.permissionDecision 을 모른다 —
+        // 사영이 top-level decision:"block" + reason 으로 번역하므로 그 키로 동치 비교.
         compareKeys: [
-            'hookSpecificOutput.permissionDecision',
-            'hookSpecificOutput.permissionDecisionReason',
+            'decision',
+            'reason',
         ],
     },
     {

package/dist/host/projection.d.ts

@@ -16,12 +16,45 @@
 import type { HookEventInput, HookEventOutput } from '../core/types.js';
 import type { HostId } from '../core/trust-layer-intent.js';
 export type ProjectToClaudeEvent = (raw: unknown, input: HookEventInput) => HookEventOutput;
+interface DecisionView {
+    continueFlag: boolean;
+    permissionDecision?: string;
+}
+export declare function parseDecision(raw: unknown): DecisionView;
 /**
- * Codex 출력 → Claude HookEventOutput 정식 사영.
+ * Codex 출력 정규화 — **Codex 0.153.4 hook 출력 스키마 준수** (ADR-015 G1 + 0.5.4 수정).
  *
- * spec §18.2 fact #3 에 따라 PreToolUse 의 *이중* decision 필드 중 어댑터는
- * `hookSpecificOutput.permissionDecision` 을 우선한다. 본 함수가 그 규약을 강제.
+ * 이 함수의 출력은 *Codex 가 읽는다* (codex-adapter 가 stdout 으로 내보냄). Codex 는 이벤트별 출력
+ * 스키마가 `additionalProperties:false` 라서 **허용되지 않은 키가 하나라도 있으면 출력 전체를 버리고
+ * "hook returned invalid ... JSON output" → Failed** 로 처리한다 (codex-rs/hooks/src/engine/
+ * output_parser.rs `parse_json` + events/stop.rs `parse_completed`; 스키마 사본은
+ * tests/fixtures/codex-hook-schemas/). 특히 Stop/SubagentStop 은 `hookSpecificOutput` 자체를
+ * 허용하지 않는다 — 0.5.3 의 사영이 모든 출력에 `hookSpecificOutput.hookEventName` 을 붙여 실환경에서
+ * Stop 훅 2개가 매 턴 Failed 로 떨어졌다 (0.5.4 에서 수정, 실세션 재현 후).
+ *
+ * 규칙 (이벤트별 allowlist — CODEX_OUTPUT_SCHEMA):
+ *   1. 객체가 아니면 fail-open `{ continue: true }`.
+ *   2. universal 키(`continue`/`stopReason`/`suppressOutput`/`systemMessage`) 보존 (Interrupt 는
+ *      systemMessage 만).
+ *   3. `decision`/`reason` 은 PreToolUse/PostToolUse/UserPromptSubmit/Stop/SubagentStop 에서만 보존.
+ *      `decision:"block"` 인데 reason 이 비면 systemMessage → 고정 문구로 보강 (Codex 가 거부).
+ *   4. `hookSpecificOutput` 은 허용 이벤트에서만, 허용 하위 키만 남기고 `hookEventName` 을 이벤트명으로
+ *      고정한다. Stop/SubagentStop/PreCompact/PostCompact/Interrupt 에서는 통째로 제거. 절대 새로
+ *      만들어 붙이지 않는다.
+ *   5. PostToolUse 에 forgen 이 `permissionDecision:"deny"` (PreToolUse 형) 를 냈으면 Codex 의
+ *      PostToolUse block 형(top-level `decision:"block"` + `reason`) 으로 번역.
+ *   6. PreToolUse: `permissionDecision` 이 있으면 `continue:false` 제거 (Codex "unsupported").
+ *   7. legacy `approved:false` → `hookSpecificOutput.permissionDecision:"deny"` (PreToolUse 한정).
+ *   8. 이벤트명을 모르면(입력에 없음) 키를 깎지 않고 pass-through 한다 — 모르면 건드리지 않는다.
  */
+interface EventOutputPolicy {
+    universal: ReadonlyArray<string>;
+    decision: boolean;
+    /** hookSpecificOutput 허용 하위 키. undefined = hookSpecificOutput 자체 불허. */
+    hso?: ReadonlyArray<string>;
+}
+/** codex-rs/hooks/schema/generated/*.command.output.schema.json (rust-v0.153.4) 요약. */
+export declare const CODEX_OUTPUT_SCHEMA: Readonly<Record<string, EventOutputPolicy>>;
 export declare const projectCodexToClaude: ProjectToClaudeEvent;
 /**
  * Claude 어댑터의 사영. 1원칙(Claude reference) + spec §18.4 (Codex hooks.json schema 동일성)
@@ -33,3 +66,4 @@ export declare const projectCodexToClaude: ProjectToClaudeEvent;
  */
 export declare const projectClaudeToClaude: ProjectToClaudeEvent;
 export declare function getProjection(host: HostId): ProjectToClaudeEvent;
+export {};

package/dist/host/projection.js

@@ -13,7 +13,9 @@
  * semantics 알아도 됨, Codex 표면 모름). 즉 Codex CLI 의 stdout 을 받아 코어가 학습 가능한
  * Claude 형 객체로 변환만 한다.
  */
-function parseDecision(raw) {
+// parseDecision 은 구 사영(결정 → continue:false 변환) 의 잔재. ADR-015 G1 이후 Codex 사영은
+// 호스트 스키마를 보존하므로 사용하지 않는다. 다른 host binding 이 참고할 수 있어 export 만 유지.
+export function parseDecision(raw) {
     if (typeof raw === 'boolean')
         return { continueFlag: raw };
     if (typeof raw === 'string') {
@@ -51,58 +53,107 @@ function parseDecision(raw) {
     }
     return { continueFlag: true };
 }
-/**
- * Codex 출력 → Claude HookEventOutput 정식 사영.
- *
- * spec §18.2 fact #3 에 따라 PreToolUse 의 *이중* decision 필드 중 어댑터는
- * `hookSpecificOutput.permissionDecision` 을 우선한다. 본 함수가 그 규약을 강제.
- */
+const UNIVERSAL = ['continue', 'stopReason', 'suppressOutput', 'systemMessage'];
+/** codex-rs/hooks/schema/generated/*.command.output.schema.json (rust-v0.153.4) 요약. */
+export const CODEX_OUTPUT_SCHEMA = {
+    SessionStart: { universal: UNIVERSAL, decision: false, hso: ['hookEventName', 'additionalContext'] },
+    SubagentStart: { universal: UNIVERSAL, decision: false, hso: ['hookEventName', 'additionalContext'] },
+    UserPromptSubmit: { universal: UNIVERSAL, decision: true, hso: ['hookEventName', 'additionalContext'] },
+    PreToolUse: {
+        universal: UNIVERSAL,
+        decision: true,
+        hso: ['hookEventName', 'additionalContext', 'permissionDecision', 'permissionDecisionReason', 'updatedInput'],
+    },
+    PostToolUse: { universal: UNIVERSAL, decision: true, hso: ['hookEventName', 'additionalContext', 'updatedMCPToolOutput'] },
+    PermissionRequest: { universal: UNIVERSAL, decision: false, hso: ['hookEventName', 'decision'] },
+    Stop: { universal: UNIVERSAL, decision: true },
+    SubagentStop: { universal: UNIVERSAL, decision: true },
+    PreCompact: { universal: UNIVERSAL, decision: false },
+    PostCompact: { universal: UNIVERSAL, decision: false },
+    Interrupt: { universal: ['systemMessage'], decision: false },
+};
+function resolveEventName(raw, input) {
+    const hso = raw.hookSpecificOutput;
+    const fromOutput = hso && typeof hso === 'object' ? hso.hookEventName : undefined;
+    const candidate = input.hookEventName
+        ?? input.hook_event_name // 실 stdin 은 snake_case
+        ?? input.event
+        ?? (typeof fromOutput === 'string' ? fromOutput : undefined);
+    return typeof candidate === 'string' && candidate.length > 0 ? candidate : undefined;
+}
 export const projectCodexToClaude = (raw, input) => {
-    const result = { continue: true };
-    const decision = parseDecision(raw);
-    result.continue = decision.continueFlag;
-    if (typeof raw === 'object' && raw !== null) {
-        const payload = raw;
-        if (typeof payload.continue === 'boolean')
-            result.continue = payload.continue;
-        if (typeof payload.systemMessage === 'string')
-            result.systemMessage = payload.systemMessage;
-        if (typeof payload.suppressOutput === 'boolean')
-            result.suppressOutput = payload.suppressOutput;
-        if (typeof payload.hookSpecificOutput === 'object' && payload.hookSpecificOutput !== null) {
-            result.hookSpecificOutput = { ...payload.hookSpecificOutput };
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        return { continue: true };
+    const payload = raw;
+    const eventName = resolveEventName(payload, input);
+    const policy = eventName ? CODEX_OUTPUT_SCHEMA[eventName] : undefined;
+    // 8. 모르는 이벤트 → pass-through (continue 기본값만 보장)
+    if (!policy) {
+        const out = { ...payload };
+        if (typeof out.continue !== 'boolean')
+            out.continue = true;
+        return out;
+    }
+    const result = {};
+    // 2. universal
+    for (const k of policy.universal) {
+        const v = payload[k];
+        if (v !== undefined && v !== null)
+            result[k] = v;
+    }
+    if (policy.universal.includes('continue') && typeof result.continue !== 'boolean')
+        result.continue = true;
+    // 3. decision / reason
+    if (policy.decision) {
+        if (typeof payload.decision === 'string')
+            result.decision = payload.decision;
+        if (typeof payload.reason === 'string')
+            result.reason = payload.reason;
+    }
+    // 4. hookSpecificOutput — 허용 이벤트 + 허용 키만
+    const rawHso = payload.hookSpecificOutput;
+    if (policy.hso && rawHso && typeof rawHso === 'object') {
+        const filtered = { hookEventName: eventName };
+        for (const k of policy.hso) {
+            if (k === 'hookEventName')
+                continue;
+            const v = rawHso[k];
+            if (v !== undefined && v !== null)
+                filtered[k] = v;
         }
-        // top-level decision (Codex 의 PreToolUse 이중 decision 중 legacy 측 또는 Stop/Post 의 단일 측)
-        // 이 있고, hookSpecificOutput.permissionDecision 이 비었을 때만 보존.
-        if (typeof payload.decision === 'string' &&
-            !(result.hookSpecificOutput && 'permissionDecision' in result.hookSpecificOutput)) {
-            result.hookSpecificOutput = {
-                ...(result.hookSpecificOutput ?? {}),
-                permissionDecision: payload.decision,
-            };
+        // 5. PostToolUse: PreToolUse 형 deny → Codex PostToolUse block 형으로 번역
+        if (eventName === 'PostToolUse') {
+            const pd = rawHso.permissionDecision;
+            if (pd === 'deny' || pd === 'block') {
+                result.decision = 'block';
+                const pdr = rawHso.permissionDecisionReason;
+                if (typeof result.reason !== 'string' && typeof pdr === 'string')
+                    result.reason = pdr;
+            }
         }
+        result.hookSpecificOutput = filtered;
     }
-    const eventName = result.hookSpecificOutput?.hookEventName ?? input.hookEventName ?? input.event;
-    if (eventName) {
+    // 7. legacy approved boolean (PreToolUse 한정)
+    if (eventName === 'PreToolUse' && typeof payload.approved === 'boolean' && !result.hookSpecificOutput?.permissionDecision) {
         result.hookSpecificOutput = {
             hookEventName: eventName,
             ...(result.hookSpecificOutput ?? {}),
+            permissionDecision: payload.approved ? 'allow' : 'deny',
         };
     }
-    if (!result.continue && !result.hookSpecificOutput?.permissionDecision) {
-        if (decision.permissionDecision) {
-            result.hookSpecificOutput = {
-                ...(result.hookSpecificOutput ?? {}),
-                permissionDecision: decision.permissionDecision,
-            };
-        }
-        else {
-            result.hookSpecificOutput = {
-                ...(result.hookSpecificOutput ?? {}),
-                permissionDecision: 'deny',
-            };
+    // 3b. block 은 non-empty reason 필수
+    if (typeof result.decision === 'string' && result.decision.toLowerCase() === 'block') {
+        const reason = typeof result.reason === 'string' ? result.reason.trim() : '';
+        if (!reason) {
+            result.reason = typeof result.systemMessage === 'string' && result.systemMessage.trim()
+                ? result.systemMessage
+                : '[forgen] hook blocked this step; re-check the rule that fired before continuing.';
         }
     }
+    // 6. PreToolUse: continue:false 는 Codex 미지원 — permissionDecision 이 차단을 표현
+    if (eventName === 'PreToolUse' && result.continue === false && typeof result.hookSpecificOutput?.permissionDecision === 'string') {
+        result.continue = true;
+    }
     return result;
 };
 /**

package/dist/store/evidence-store.js

@@ -7,14 +7,16 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as crypto from 'node:crypto';
-import { ME_BEHAVIOR } from '../core/paths.js';
+import { ME_BEHAVIOR, ME_RULES } from '../core/paths.js';
 import { atomicWriteJSON, safeReadJSON } from '../hooks/shared/atomic-write.js';
 import { HOST_IDS } from '../core/trust-layer-intent.js';
-import { createRule, saveRule, loadActiveRules, updateRuleStatus } from './rule-store.js';
+import { createRule, saveRule, loadActiveRules, updateRuleStatus, findRuleByRenderKey } 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';
+import { laplaceConfidence, strengthForConfidence } from '../engine/correction-clustering.js';
+import { withFileLockSync } from '../hooks/shared/file-lock.js';
 function evidencePath(evidenceId) {
     return path.join(ME_BEHAVIOR, `${evidenceId}.json`);
 }
@@ -200,62 +202,124 @@ function retireStaleAutoMinedRules(now) {
     for (let i = 0; i < excess; i++)
         updateRuleStatus(keep[i].r.rule_id, 'removed');
 }
+/**
+ * retire+dedupe+create 시퀀스 전체를 잠그는 lock 타깃. 실제 파일은 만들지 않고
+ * (`${target}.lock`) 파생 lock 파일만 생성 — withFileLockSync 관례.
+ * RCA (C): 여러 detached auto-compound-runner 가 동시에 이 함수를 돌리면 각자
+ * "render_key 없음" 스냅샷을 보고 중복 rule 을 만들 수 있었다(TOCTOU). retire ~
+ * create 를 하나의 critical section 으로 묶어 그 창을 없앤다.
+ */
+const RULE_STORE_MUTATE_LOCK = path.join(ME_RULES, '.rule-store-mutate');
 export function promoteSessionCandidates(sessionId) {
-    // 채굴 룰 TTL 은퇴는 **early-return 앞에서** 실행 (critic 재검증 #1): 승급 후보가 없는
-    // 조용한 세션에서도 wall-clock TTL 이 실제로 강제되도록. (auto-compound-runner 는 매
-    // 세션 종료 시 promoteSessionCandidates 를 호출하므로 이 경로가 세션당 1회 보장된다.)
-    retireStaleAutoMinedRules(Date.now());
-    const candidates = loadPromotionCandidates().filter(e => e.session_id === sessionId);
-    if (candidates.length === 0)
-        return 0;
-    const activeRules = loadActiveRules();
-    const existingRenderKeys = new Set(activeRules.filter(r => r.scope === 'me').map(r => r.render_key));
-    let promoted = 0;
-    for (const candidate of candidates) {
-        const payload = candidate.raw_payload;
-        const axisHint = payload?.axis_hint;
-        const target = payload?.target;
-        const kind = payload?.kind;
-        const autoMined = payload?.auto_mined === true;
-        if (!target)
-            continue;
-        // 채굴 룰은 "auto:" 네임스페이스 — 실시간 교정 render_key 와 절대 충돌 안 함 (SEV-2 #4).
-        const baseKey = `${axisHint ?? 'workflow'}.${target.toLowerCase().replace(/\s+/g, '-').slice(0, 30)}`;
-        const renderKey = autoMined ? `${AUTO_MINED_PREFIX}${baseKey}` : baseKey;
-        if (existingRenderKeys.has(renderKey))
-            continue;
-        const category = axisHint === 'quality_safety' ? 'quality'
-            : axisHint === 'autonomy' ? 'autonomy'
-                : 'workflow';
-        // ADR-013: 채굴 교정(auto_mined)은 실시간 명시 교정과 엄격 차등 — provenance
-        // =behavior_inference, strength 절대 strong 아님(default).
-        let rule = createRule({
-            category,
-            scope: 'me',
-            trigger: target,
-            policy: candidate.summary,
-            strength: autoMined ? 'default' : kind === 'avoid-this' ? 'strong' : 'default',
-            source: autoMined ? 'behavior_inference' : 'explicit_correction',
-            evidence_refs: [candidate.evidence_id],
-            render_key: renderKey,
-        });
-        if (autoMined) {
-            // advisory-only (SEV-1 #2): classify() 를 돌리지 않고 enforce_via 를 비워, 채굴 룰이
-            // 절대 Mech-A 차단(PreToolUse/Stop block)을 얻지 못하게 한다. 컨텍스트 주입만 되고
-            // 어떤 훅도 강제하지 않음 — 환각 교정이 영구 차단 룰이 되는 위험 근절.
-            rule.enforce_via = [];
-        }
-        else {
-            // ADR-001 auto-classify — 실시간 승격 rule 에만 enforce_via 자동 주입.
-            try {
-                const proposal = classify(rule);
-                rule = applyProposal(rule, proposal);
+    // withFileLockSync 는 O_CREAT 로 lock 파일을 만들 뿐 부모 디렉터리는 만들지 않는다 —
+    // 첫 rule 승급 이전(=아직 ME_RULES 없음)에도 락을 잡을 수 있어야 하므로 선행 mkdir.
+    fs.mkdirSync(ME_RULES, { recursive: true });
+    // 락 타임아웃/보수 시간은 이 critical section 이 짧다는 전제(디렉터리 스캔 + 파일
+    // 몇 개 쓰기, 초 단위 아님) 로 file-lock.ts 기본값(2s/30s)보다 넉넉히 잡되, 죽은
+    // holder 를 오래 방치하지 않도록 stale 은 짧게 유지한다.
+    return withFileLockSync(RULE_STORE_MUTATE_LOCK, () => {
+        // 채굴 룰 TTL 은퇴는 **early-return 앞에서** 실행 (critic 재검증 #1): 승급 후보가 없는
+        // 조용한 세션에서도 wall-clock TTL 이 실제로 강제되도록. (auto-compound-runner 는 매
+        // 세션 종료 시 promoteSessionCandidates 를 호출하므로 이 경로가 세션당 1회 보장된다.)
+        retireStaleAutoMinedRules(Date.now());
+        const candidates = loadPromotionCandidates().filter(e => e.session_id === sessionId);
+        if (candidates.length === 0)
+            return 0;
+        let promoted = 0;
+        for (const candidate of candidates) {
+            const payload = candidate.raw_payload;
+            const axisHint = payload?.axis_hint;
+            const target = payload?.target;
+            const kind = payload?.kind;
+            const autoMined = payload?.auto_mined === true;
+            if (!target)
+                continue;
+            // 채굴 룰은 "auto:" 네임스페이스 — 실시간 교정 render_key 와 절대 충돌 안 함 (SEV-2 #4).
+            const baseKey = `${axisHint ?? 'workflow'}.${target.toLowerCase().replace(/\s+/g, '-').slice(0, 30)}`;
+            const renderKey = autoMined ? `${AUTO_MINED_PREFIX}${baseKey}` : baseKey;
+            const source = autoMined ? 'behavior_inference' : 'explicit_correction';
+            // (B) 이 evidence 가 과거 어떤 rule 로든 이미 소비됐는가 — candidate_rule_refs 를
+            // "승급 완료" 마커로 재사용한다(T1 이 rule_id 매칭에 쓰는 필드와 동일 필드,
+            // 의미상 호환: "이 evidence 가 가리키는 rule"). loadPromotionCandidates() 는
+            // evidence 를 영구히 반환하므로, 이 마커가 없으면 재-sweep 마다 같은 evidence 가
+            // 무한 재처리된다.
+            const alreadyConsumed = (candidate.candidate_rule_refs ?? []).length > 0;
+            // (A) render_key upsert identity — status 무관 기존 rule 조회. TTL/cap 로
+            // retire(status='removed')된 render_key 도 여기서 발견되어 "재생성"이 아니라
+            // "재활성화"된다 — 새 rule_id/created_at 을 절대 새로 만들지 않는다.
+            // scope:'me' 로 한정 — processCorrection() 이 fix-now/avoid-this 에 대해 만드는
+            // scope:'session' 임시 rule 은 같은 render_key 공식을 쓰지만 별개 개체다(승격 대상 아님).
+            const existingRule = findRuleByRenderKey(renderKey, source, 'me');
+            if (existingRule) {
+                if (alreadyConsumed)
+                    continue; // 같은 evidence 의 sweep 재관측 — no-op.
+                const evidenceRefs = existingRule.evidence_refs.includes(candidate.evidence_id)
+                    ? existingRule.evidence_refs
+                    : [...existingRule.evidence_refs, candidate.evidence_id];
+                // (D1) confidence 재계산 — correction-clustering.ts 의 Laplace 계승법칙을 그대로
+                // 상속(리터럴 복제 아님). N=evidence_refs.length(=관측 반복 횟수). auto_mined 은
+                // ADR-013 불변식(advisory-only, strong 절대 자동 도달 금지)을 유지하기 위해
+                // 몇 번을 재확인해도 'default' 를 벗어나지 않는다. hard 는 confidence 로 낮추지
+                // 않는다(안전 룰은 강도 하락이 없어야 함).
+                const strength = autoMined
+                    ? 'default'
+                    : existingRule.strength === 'hard'
+                        ? 'hard'
+                        : strengthForConfidence(laplaceConfidence(evidenceRefs.length));
+                // TTL-on-reactivation 결정: created_at 은 절대 now 로 리셋하지 않는다(carry-forward).
+                // 이유 — AUTO_MINED_TTL_MS 는 "이 개념이 처음 채굴된 이후 최대 수명"을 뜻하는
+                // 하드 상한이지, "마지막으로 확인된 이후 경과 시간"이 아니다. created_at 을
+                // 리셋하면 반복 채굴(같은 세션이 오래 지속되며 매 sweep 마다 재-mine)로 TTL 을
+                // 무한 연장할 수 있어 은퇴 메커니즘 자체가 무력화된다(원 결함의 재발). 대신
+                // rule_id/created_at 은 그대로 두고 status 만 'active' 로 되돌린다 — 재활성화된
+                // rule 은 다음 retireStaleAutoMinedRules() 호출 때 기존 나이 기준으로 다시
+                // 은퇴 여부가 평가된다(의도된 동작, thrash 아님: 최소 1세션은 유효하게 주입됨).
+                saveRule({ ...existingRule, status: 'active', evidence_refs: evidenceRefs, strength });
+                saveEvidence({
+                    ...candidate,
+                    candidate_rule_refs: [...(candidate.candidate_rule_refs ?? []), existingRule.rule_id],
+                });
+                promoted++;
+                continue;
+            }
+            if (alreadyConsumed)
+                continue; // 소비 마킹된 evidence 인데 매칭 rule 없음(이례) — 재생성 금지.
+            const category = axisHint === 'quality_safety' ? 'quality'
+                : axisHint === 'autonomy' ? 'autonomy'
+                    : 'workflow';
+            // ADR-013: 채굴 교정(auto_mined)은 실시간 명시 교정과 엄격 차등 — provenance
+            // =behavior_inference, strength 절대 strong 아님(default).
+            let rule = createRule({
+                category,
+                scope: 'me',
+                trigger: target,
+                policy: candidate.summary,
+                strength: autoMined ? 'default' : kind === 'avoid-this' ? 'strong' : 'default',
+                source,
+                evidence_refs: [candidate.evidence_id],
+                render_key: renderKey,
+            });
+            if (autoMined) {
+                // advisory-only (SEV-1 #2): classify() 를 돌리지 않고 enforce_via 를 비워, 채굴 룰이
+                // 절대 Mech-A 차단(PreToolUse/Stop block)을 얻지 못하게 한다. 컨텍스트 주입만 되고
+                // 어떤 훅도 강제하지 않음 — 환각 교정이 영구 차단 룰이 되는 위험 근절.
+                rule.enforce_via = [];
             }
-            catch { /* fail-open */ }
+            else {
+                // ADR-001 auto-classify — 실시간 승격 rule 에만 enforce_via 자동 주입.
+                try {
+                    const proposal = classify(rule);
+                    rule = applyProposal(rule, proposal);
+                }
+                catch { /* fail-open */ }
+            }
+            saveRule(rule);
+            saveEvidence({
+                ...candidate,
+                candidate_rule_refs: [...(candidate.candidate_rule_refs ?? []), rule.rule_id],
+            });
+            promoted++;
         }
-        saveRule(rule);
-        existingRenderKeys.add(renderKey);
-        promoted++;
-    }
-    return promoted;
+        return promoted;
+    }, { timeoutMs: 8000, staleMs: 15000 });
 }

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

@@ -33,6 +33,23 @@ export declare function appendRule(rule: Rule): Promise<{
 export declare function loadRule(ruleId: string): Rule | null;
 export declare function loadAllRules(): Rule[];
 export declare function loadActiveRules(): Rule[];
+/**
+ * render_key(+source, +scope)로 기존 rule을 찾는다 — status 무관(active/suppressed/removed/
+ * superseded 전부 포함). ADR-013 채굴 룰 재생성 결함 수정(RCA): promoteSessionCandidates가
+ * loadActiveRules() 로만 dedup 하다 보니 TTL/cap 로 은퇴(removed)된 render_key가 재차 채굴되면
+ * "없음" 으로 오판해 매번 새 rule_id + created_at=now 로 재생성 — 이게 6,701개 파일 중
+ * 6,525개가 removed 로 죽어 쌓인 근본 원인. 이 함수로 upsert identity 를 render_key 로
+ * 고정한다: 있으면 재활성화, 없을 때만 신규 생성.
+ *
+ * scope 필터가 필요한 이유: processCorrection()(evidence-processor.ts)이 fix-now/avoid-this
+ * 에 대해 scope:'session' 임시 rule 을 만들 때 *같은 render_key 공식*(`${axis}.${target-slug}`)
+ * 을 쓴다. scope 를 안 걸면 promoteSessionCandidates 가 그 임시 rule 을 "기존 me rule" 로
+ * 오인해 재활성화해버려 영구 승격이 아예 안 되는 회귀가 생긴다(실측: 회귀 테스트로 발견).
+ *
+ * 동일 render_key 매칭이 여럿(레거시 데이터 등 이례적 상황)이면 active 우선, 그다음
+ * updated_at 최신순으로 하나만 반환.
+ */
+export declare function findRuleByRenderKey(renderKey: string, source?: RuleSource, scope?: RuleScope): Rule | null;
 /**
  * ADR-002 Meta signal — rule 들이 프롬프트에 inject 되었음을 기록.
  * rule.lifecycle.inject_count +1, last_inject_at = now.
@@ -45,4 +62,28 @@ export declare function updateRuleStatus(ruleId: string, status: RuleStatus): bo
  * 현재 세션 ID와 다른 scope:'session' 규칙을 비활성화.
  * 이전 세션의 임시 규칙이 새 세션에서 영향을 미치지 않도록 정리.
  */
+/** status:'removed' rule 파일 정리 결과. */
+export interface PruneResult {
+    /** retention 기간을 지나 삭제 대상인 rule_id (dry-run/apply 공통). */
+    candidates: string[];
+    /** apply=true 일 때 실제 unlink 된 rule_id (dry-run 이면 항상 빈 배열). */
+    deleted: string[];
+}
+/** removed 룰 보관 기간 기본값 — 7일. TTL 로 은퇴된 지 이만큼 지나면 prune 대상. */
+export declare const DEFAULT_PRUNE_RETENTION_MS: number;
+/**
+ * status:'removed' 파일을 retention 기간이 지난 것만 실제 unlink.
+ * RCA: retire(updateRuleStatus)는 status flip만 하고 파일을 지우지 않아 6,525개 죽은
+ * 파일이 ~/.forgen/me/rules 에 쌓여 loadAllRules() linear scan 비용을 키우고
+ * cross-process race 창을 넓혔다. status 전이 시각(updated_at) 기준으로 retention을
+ * 재는 이유: removed 직후 즉시 지우면 (a) findRuleByRenderKey 가 재활성화할 기회를
+ * 없애고 (b) 오탐 은퇴를 되돌릴 유예가 사라진다.
+ *
+ * 기본 dry-run(apply=false) — 프로덕션 데이터 삭제는 호출측이 명시적으로 apply:true
+ * 를 넘길 때만. (compound-sweep-cli 의 `--prune-removed`는 `--apply` 없으면 dry-run.)
+ */
+export declare function pruneRemovedRules(opts?: {
+    retentionMs?: number;
+    apply?: boolean;
+}): PruneResult;
 export declare function cleanupStaleSessionRules(_currentSessionId: string): number;