@wooojin/forgen 0.4.13 → 0.5.5

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;
 };
 /**
@@ -114,9 +165,20 @@ export const projectCodexToClaude = (raw, input) => {
  * 교체하면 되도록 — `getProjection(host)` 가 단일 진입점.)
  */
 export const projectClaudeToClaude = (raw, input) => projectCodexToClaude(raw, input);
+/**
+ * OpenCode projection — P1 파운데이션 fail-loud 스텁.
+ * OpenCode 는 in-process plugin(throw/return)이라 subprocess stdout projection 과 형태가
+ * 다르다(plan §5 blocker 1). 실제 translation 은 plugin 슬림이 착지할 때 구현한다. 그 전까지
+ * 이 함수는 도달 불가(install-opencode 미구현 → getProjection('opencode') 미호출)이며,
+ * 혹시 호출되면 조용히 잘못된 결과를 내는 대신 명시적으로 실패한다.
+ */
+const projectOpencodeToClaude = () => {
+    throw new Error('[forgen] OpenCode projection 미구현 — P1 plugin 슬림 착지 후 구현 예정 (plan §4.1 in-process-plugin binding).');
+};
 const PROJECTIONS = {
     claude: projectClaudeToClaude,
     codex: projectCodexToClaude,
+    opencode: projectOpencodeToClaude,
 };
 export function getProjection(host) {
     const fn = PROJECTIONS[host];

package/dist/mcp/tools.js

@@ -278,11 +278,24 @@ export function registerTools(server) {
         try {
             // v1 session_id를 환경변수에서 가져옴 (하네스가 설정)
             const effectiveSessionId = session_id || process.env.FORGEN_SESSION_ID || 'unknown';
+            // W2-5 (private 태그): 교정 텍스트에서 <private>…</private>/forgen:private 범위
+            // 제거 후 저장. 교정 message 가 통째로 private 이면 저장 자체를 skip (학습
+            // 코퍼스에 남기지 않겠다는 사용자 의도). 조용히 하지 않고 공지한다.
+            const { stripPrivate, isFullyPrivate } = await import('../engine/private-filter.js');
+            if (isFullyPrivate(message)) {
+                return { content: [{ type: 'text', text: '✓ [forgen] correction skipped — message was fully <private> (not stored).' }] };
+            }
+            const cleanMessage = stripPrivate(message).cleaned;
+            const strippedTarget = stripPrivate(target);
+            const cleanTarget = strippedTarget.cleaned;
+            const privateNote = (strippedTarget.hadPrivate || cleanMessage !== message)
+                ? '\n(참고: <private> 범위는 기록에서 제외됨)'
+                : '';
             const result = processCorrection({
                 session_id: effectiveSessionId,
                 kind: kind,
-                message,
-                target,
+                message: cleanMessage,
+                target: cleanTarget,
                 axis_hint: axis_hint,
             });
             // Outcome tracking (Phase 1): attribute this correction to any
@@ -320,7 +333,7 @@ export function registerTools(server) {
             return {
                 content: [{
                         type: 'text',
-                        text: lines.join('\n'),
+                        text: lines.join('\n') + privateNote,
                     }],
             };
         }
@@ -343,7 +356,7 @@ export function registerTools(server) {
             return {
                 content: [{
                         type: 'text',
-                        text: 'No profile configured. Run forgen onboarding.',
+                        text: 'No profile configured. Run forgen forge --onboarding.',
                     }],
             };
         }

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

@@ -5,6 +5,7 @@
  * Authoritative schema: docs/plans/2026-04-03-forgen-data-model-storage-spec.md §4
  */
 import type { Evidence, EvidenceType } from './types.js';
+import { type HostId } from '../core/trust-layer-intent.js';
 export declare function createEvidence(params: {
     type: EvidenceType;
     session_id: string;
@@ -14,7 +15,7 @@ export declare function createEvidence(params: {
     candidate_rule_refs?: string[];
     confidence: number;
     raw_payload?: Record<string, unknown>;
-    host?: 'claude' | 'codex';
+    host?: HostId;
 }): Evidence;
 export declare function saveEvidence(evidence: Evidence): void;
 /**
@@ -39,9 +40,4 @@ export declare function loadEvidenceByType(type: EvidenceType): Evidence[];
 export declare function loadRecentEvidence(limit?: number): Evidence[];
 /** prefer-from-now / avoid-this 교정 evidence를 모두 반환 (규칙 승격 후보) */
 export declare function loadPromotionCandidates(): Evidence[];
-/**
- * 특정 세션의 promotion 후보를 scope:'me' 영구 규칙으로 승격.
- * 동일 render_key를 가진 scope:'me' 규칙이 이미 있으면 건너뜀.
- * @returns 승격된 규칙 수
- */
 export declare function promoteSessionCandidates(sessionId: string): number;

package/dist/store/evidence-store.js

@@ -7,13 +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 { createRule, saveRule, loadActiveRules } from './rule-store.js';
+import { HOST_IDS } from '../core/trust-layer-intent.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`);
 }
@@ -32,11 +35,13 @@ function evidencePath(evidenceId) {
 function detectHost(explicit) {
     if (explicit)
         return explicit;
+    // W3-3 리뷰 SEV-3 #5: 이진비교(=== 'claude' || === 'codex') 대신 HOST_IDS 정준목록으로
+    // 유효 host 를 해소해 FORGEN_HOST/FORGEN_RUNTIME='opencode' 도 보존(self-evidence-record 일관).
     const fromEnv = process.env.FORGEN_HOST;
-    if (fromEnv === 'claude' || fromEnv === 'codex')
+    if (fromEnv && HOST_IDS.includes(fromEnv))
         return fromEnv;
     const fromRuntime = process.env.FORGEN_RUNTIME;
-    if (fromRuntime === 'claude' || fromRuntime === 'codex')
+    if (fromRuntime && HOST_IDS.includes(fromRuntime))
         return fromRuntime;
     if (process.env.CODEX_HOME || process.env.CODEX_SANDBOX_NETWORK_DISABLED)
         return 'codex';
@@ -111,13 +116,17 @@ export function appendEvidence(evidence) {
     }
 }
 /**
- * 기존 evidence 에 host 필드가 없으면 'claude' 로 backfill (Multi-Host §4.2 마이그레이션 정책).
- * 새 multi-host 도입 이전 데이터는 모두 Claude 에서 발생했음 — 이 backfill 은 무손실.
+ * 기존 evidence 에 host 필드가 없거나 유효하지 않으면 'claude' 로 backfill
+ * (Multi-Host §4.2 마이그레이션 정책). 새 multi-host 도입 이전 데이터는 모두 Claude 발생.
+ *
+ * W3-3 리뷰 SEV-3 #5: 이전엔 `!== 'claude' && !== 'codex'` 라 **유효한 'opencode' 태그도
+ * claude 로 clobber** → self-evidence-record='supported'(host:"opencode") 선언과 정면 모순.
+ * 이제 HOST_IDS 정준 목록으로 "유효 host" 를 판정해 opencode 등 모든 유효 태그를 보존한다.
  */
 function backfillHost(ev) {
     if (!ev)
         return ev;
-    if (ev.host === 'claude' || ev.host === 'codex')
+    if (ev.host && HOST_IDS.includes(ev.host))
         return ev;
     return { ...ev, host: 'claude' };
 }
@@ -163,45 +172,154 @@ export function loadPromotionCandidates() {
  * 동일 render_key를 가진 scope:'me' 규칙이 이미 있으면 건너뜀.
  * @returns 승격된 규칙 수
  */
-export function promoteSessionCandidates(sessionId) {
-    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;
-        if (!target)
-            continue;
-        const renderKey = `${axisHint ?? 'workflow'}.${target.toLowerCase().replace(/\s+/g, '-').slice(0, 30)}`;
-        if (existingRenderKeys.has(renderKey))
-            continue;
-        const category = axisHint === 'quality_safety' ? 'quality'
-            : axisHint === 'autonomy' ? 'autonomy'
-                : 'workflow';
-        let rule = createRule({
-            category,
-            scope: 'me',
-            trigger: target,
-            policy: candidate.summary,
-            strength: kind === 'avoid-this' ? 'strong' : 'default',
-            source: 'explicit_correction',
-            evidence_refs: [candidate.evidence_id],
-            render_key: renderKey,
-        });
-        // ADR-001 auto-classify — 승격되는 rule 에도 enforce_via 자동 주입.
-        try {
-            const proposal = classify(rule);
-            rule = applyProposal(rule, proposal);
+/**
+ * ADR-013 채굴 교정 안전 파라미터 (리뷰 SEV-1 대응):
+ * - 채굴 룰은 "auto:" render_key 네임스페이스로 분리 → 실시간 명시 교정과 절대 충돌/억제 안 함.
+ * - advisory-only: enforce_via=[] (차단 메커니즘 미부여). 환각 교정이 차단 룰이 되는 것 근절.
+ * - 생성나이 은퇴: TTL 지난 미확인 채굴 룰 retire (me-scope 룰이 매 세션 주입돼 ROI/T4 로는
+ *   은퇴 안 되던 문제의 실제 해소). + 라이브 채굴 룰 총량 상한.
+ */
+const AUTO_MINED_PREFIX = 'auto:';
+const AUTO_MINED_TTL_MS = 21 * 24 * 60 * 60 * 1000; // 21일
+const AUTO_MINED_MAX_LIVE = 30;
+/** 채굴(behavior_inference) 룰 은퇴: TTL 초과 + 총량 상한 초과분(오래된 순). */
+function retireStaleAutoMinedRules(now) {
+    const auto = loadActiveRules().filter((r) => r.scope === 'me' && r.source === 'behavior_inference' && r.render_key?.startsWith(AUTO_MINED_PREFIX));
+    const byAge = auto
+        .map((r) => ({ r, age: now - Date.parse(r.created_at) }))
+        .sort((a, b) => b.age - a.age); // 오래된 순
+    const keep = [];
+    for (const item of byAge) {
+        if (item.age >= AUTO_MINED_TTL_MS) {
+            updateRuleStatus(item.r.rule_id, 'removed'); // TTL 초과 → 은퇴
+        }
+        else {
+            keep.push(item);
         }
-        catch { /* fail-open */ }
-        saveRule(rule);
-        existingRenderKeys.add(renderKey);
-        promoted++;
     }
-    return promoted;
+    // 총량 상한 초과분(가장 오래된 것부터) 은퇴.
+    const excess = keep.length - AUTO_MINED_MAX_LIVE;
+    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) {
+    // 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 = [];
+            }
+            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++;
+        }
+        return promoted;
+    }, { timeoutMs: 8000, staleMs: 15000 });
 }

package/dist/store/host-mismatch.d.ts

@@ -11,7 +11,7 @@
  *   - drift_event_count_by_host
  * 위 3 종 metric 을 evidence_id → host 매핑으로 집계.
  */
-export type HostId = 'claude' | 'codex';
+import type { HostId } from '../core/trust-layer-intent.js';
 export interface HostMismatchSummary {
     readonly byHost: Record<HostId, number>;
     readonly total: number;
@@ -33,6 +33,7 @@ export declare function summarizeNegativeSignalsForRef(refId: string): HostMisma
 export declare function summarizeAllByHost(): {
     claude: number;
     codex: number;
+    opencode: number;
     total: number;
 };
 /** 테스트 노출용 — 임계값이 변경되면 회귀 즉시 감지. */