@wooojin/forgen 0.4.12 → 0.5.0

package/dist/core/migrate-tenetx.js

@@ -0,0 +1,262 @@
+/**
+ * Forgen v0.5.0 — `forgen migrate tenetx` (ADR-010 W1-1, Rule Reclaimer)
+ *
+ * tenetx(forgen 의 레거시 정체성) 및 구버전 forgen 이 ~/.claude/rules/ 와
+ * <cwd>/.claude/rules/ 에 남긴 규칙 파일 스프롤을 provenance 기반으로 회수한다.
+ * 2026-07-16 수동 청소(56K→0, 중복 스킬 21개 제거)의 프로덕트화.
+ *
+ * 판정 3단계 (설계: docs/plans/2026-07-16-v0.5.0-execution-plan.md W1-1):
+ *   (a) content-hash 가 rendered-rules-manifest 와 일치 → 무프롬프트 삭제 (forgen 이 쓴 그대로)
+ *   (b) provenance 마커만 매치 + hash 불일치      → --yes 필요 (사용자 편집 가능성)
+ *   (c) 매치 없음                                  → 불간섭
+ *
+ * 안전장치: 모든 삭제는 백업 이동(가역), --dry-run 지원,
+ * settings.json/installed_plugins.json 편집은 --apply-settings 명시 동의 시에만.
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { loadManifest, matchesManifest } from './rendered-rules-manifest.js';
+import { acquireLock, releaseLock, atomicWriteFileSync } from './settings-lock.js';
+// ── 판정 ──
+/** tenetx / forge 계열 산출물 provenance 마커 (2026-07-16 실물 파일 기준) */
+const PROVENANCE_MARKERS = Object.freeze([
+    /<!--\s*forge-tuned\s*-->/,
+    /^#\s*Tenetx\b/m,
+    /forge-generated v\d/,
+    /^# auto-generated from (observed interactions|profile \+ rule store)/m,
+    /^# Forgen —/m, // 구버전 forgen 이 글로벌에 복제한 project-context 류
+]);
+/**
+ * 현행 렌더 타겟 — 프로젝트 .claude/rules/ 에서 forgen 이 매 세션 관리하는
+ * 파일들. reclaim 범위에서 제외한다 (manifest 생성 전 ⚠ 노이즈 방지;
+ * 삭제해도 다음 렌더에서 재생성되므로 회수의 의미도 없다).
+ * 정리 책임: 렌더(갱신) / uninstall(제거).
+ */
+const CURRENT_RENDER_TARGETS = new Set([
+    'project-context.md', 'v1-rules.md', 'forge-behavioral.md', 'user-profile.md',
+]);
+function listRuleFiles(dir) {
+    try {
+        return fs.readdirSync(dir)
+            // .md 한정: tenetx/forgen 계열 rules 산출물은 전부 마크다운이었다
+            // (2026-07-16 실물 13개 파일 기준). 다른 확장자는 provenance 판단
+            // 근거가 없으므로 건드리지 않는다 — 불간섭이 기본값.
+            .filter(f => f.endsWith('.md'))
+            .map(f => path.join(dir, f));
+    }
+    catch {
+        return [];
+    }
+}
+export function hasProvenanceMarker(content) {
+    return PROVENANCE_MARKERS.some(re => re.test(content));
+}
+/** 스캔만 — 디스크 수정 없음. doctor --reclaim 이 그대로 사용. */
+export function scanReclaimables(cwd, home = os.homedir()) {
+    const manifest = loadManifest(home);
+    const dirs = [
+        path.join(home, '.claude', 'rules'),
+        path.join(cwd, '.claude', 'rules'),
+    ];
+    const removable = [];
+    const needsConfirm = [];
+    const globalDir = dirs[0];
+    for (const dir of dirs) {
+        const isProjectDir = dir !== globalDir;
+        for (const p of listRuleFiles(dir)) {
+            // 프로젝트 스코프의 현행 렌더 타겟은 reclaim 범위 밖 (렌더/uninstall 책임)
+            if (isProjectDir && CURRENT_RENDER_TARGETS.has(path.basename(p)))
+                continue;
+            let content;
+            try {
+                content = fs.readFileSync(p, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            if (matchesManifest(p, content, manifest)) {
+                // (a) forgen 이 쓴 그대로임이 hash 로 증명됨 — 무프롬프트 회수.
+                // NOTE: 현행 harness 는 프로젝트 경로만 기록하므로 글로벌 파일은
+                // 오늘 기준 여기 도달하지 않는다(항상 marker 경로로 폴백). 이 분기는
+                // 미래에 렌더 대상이 바뀌어 특정 파일이 잔재화될 때를 위한 경로다.
+                removable.push({ path: p, reason: 'manifest-hash' });
+                continue;
+            }
+            if (hasProvenanceMarker(content)) {
+                needsConfirm.push({ path: p, reason: 'provenance-marker' });
+            }
+            // (c) 매치 없음 → 불간섭
+        }
+    }
+    return { removable, needsConfirm, settingsFindings: scanSettings(home) };
+}
+// ── settings / registry 탐지 ──
+function scanSettings(home) {
+    const findings = [];
+    const settingsPath = path.join(home, '.claude', 'settings.json');
+    try {
+        const s = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        if (typeof s?.statusLine?.command === 'string' && s.statusLine.command.includes('tenetx')) {
+            findings.push(`settings.json statusLine.command = "${s.statusLine.command}" → "forgen statusline" 권장`);
+        }
+        for (const key of Object.keys(s?.enabledPlugins ?? {})) {
+            if (key.startsWith('tenetx@'))
+                findings.push(`settings.json enabledPlugins["${key}"] 활성 상태`);
+        }
+        if (Array.isArray(s?.plugins)) {
+            for (const p of s.plugins) {
+                if (typeof p === 'string' && p.includes('tenetx'))
+                    findings.push(`settings.json plugins 배열에 ${p}`);
+            }
+        }
+    }
+    catch { /* settings 없음/파손 → 탐지 생략 */ }
+    const registryPath = path.join(home, '.claude', 'plugins', 'installed_plugins.json');
+    try {
+        const r = JSON.parse(fs.readFileSync(registryPath, 'utf-8'));
+        for (const key of Object.keys(r?.plugins ?? {})) {
+            if (key.startsWith('tenetx@'))
+                findings.push(`installed_plugins.json 에 ${key} 등록 잔존`);
+        }
+    }
+    catch { /* ignore */ }
+    const pluginDir = path.join(home, '.claude', 'plugins', 'tenetx');
+    if (fs.existsSync(pluginDir)) {
+        findings.push(`플러그인 디렉토리 잔존: ${pluginDir}`);
+    }
+    return findings;
+}
+function applySettingsRemoval(home, backupDir) {
+    let applied = false;
+    // settings.json 은 코드베이스 불변식대로 settings-lock 하에서만 수정한다
+    // (settings-injector/uninstall 과 동일). 단 lock 은 실제 homedir 의
+    // settings.json 전용이므로, 테스트 주입 home 에서는 lock 을 생략한다.
+    const settingsPath = path.join(home, '.claude', 'settings.json');
+    const useLock = home === os.homedir();
+    if (useLock) {
+        try {
+            acquireLock();
+        }
+        catch {
+            return false; /* 활성 세션과 경합 — 건드리지 않음 */
+        }
+    }
+    try {
+        const raw = fs.readFileSync(settingsPath, 'utf-8');
+        const s = JSON.parse(raw);
+        let changed = false;
+        if (typeof s?.statusLine?.command === 'string' && s.statusLine.command.includes('tenetx')) {
+            s.statusLine.command = 'forgen statusline';
+            changed = true;
+        }
+        for (const key of Object.keys(s?.enabledPlugins ?? {})) {
+            if (key.startsWith('tenetx@')) {
+                delete s.enabledPlugins[key];
+                changed = true;
+            }
+        }
+        if (Array.isArray(s?.plugins)) {
+            const before = s.plugins.length;
+            s.plugins = s.plugins.filter((p) => !(typeof p === 'string' && p.includes('tenetx')));
+            if (s.plugins.length !== before)
+                changed = true;
+        }
+        if (changed) {
+            fs.copyFileSync(settingsPath, path.join(backupDir, 'settings.json.bak'));
+            atomicWriteFileSync(settingsPath, `${JSON.stringify(s, null, 2)}\n`);
+            applied = true;
+        }
+    }
+    catch { /* settings 파손 시 건드리지 않음 */ }
+    finally {
+        if (useLock)
+            releaseLock();
+    }
+    const registryPath = path.join(home, '.claude', 'plugins', 'installed_plugins.json');
+    try {
+        const raw = fs.readFileSync(registryPath, 'utf-8');
+        const r = JSON.parse(raw);
+        const tenetxKeys = Object.keys(r?.plugins ?? {}).filter(k => k.startsWith('tenetx@'));
+        if (tenetxKeys.length > 0) {
+            fs.copyFileSync(registryPath, path.join(backupDir, 'installed_plugins.json.bak'));
+            for (const k of tenetxKeys)
+                delete r.plugins[k];
+            atomicWriteFileSync(registryPath, `${JSON.stringify(r, null, 2)}\n`);
+            applied = true;
+        }
+    }
+    catch { /* ignore */ }
+    return applied;
+}
+// ── 실행 ──
+export function runReclaim(opts) {
+    const home = opts.home ?? os.homedir();
+    const scan = scanReclaimables(opts.cwd, home);
+    const dryRun = opts.dryRun === true;
+    const targets = [
+        ...scan.removable,
+        ...(opts.yes ? scan.needsConfirm : []),
+    ];
+    const skippedNeedsConfirm = opts.yes ? [] : scan.needsConfirm.map(c => c.path);
+    let backupDir = null;
+    const removed = [];
+    if (!dryRun && (targets.length > 0 || opts.applySettings)) {
+        const ts = new Date().toISOString().replace(/[:.]/g, '-');
+        backupDir = path.join(home, '.forgen', 'backups', `reclaim-${ts}`);
+        fs.mkdirSync(backupDir, { recursive: true });
+    }
+    for (const t of targets) {
+        if (dryRun) {
+            removed.push(t.path);
+            continue;
+        }
+        try {
+            // 백업 이동 = 가역 삭제. 파일명 충돌 방지를 위해 dir 구조 평탄화 + 접두.
+            const flat = t.path.replace(/[\\/]/g, '_');
+            fs.copyFileSync(t.path, path.join(backupDir, flat));
+            fs.unlinkSync(t.path);
+            removed.push(t.path);
+        }
+        catch { /* 개별 실패는 건너뜀 — 나머지 회수 계속 */ }
+    }
+    let settingsApplied = false;
+    if (opts.applySettings && !dryRun && backupDir) {
+        settingsApplied = applySettingsRemoval(home, backupDir);
+    }
+    return {
+        removed,
+        skippedNeedsConfirm,
+        settingsFindings: scan.settingsFindings,
+        settingsApplied,
+        backupDir: dryRun ? null : backupDir,
+        dryRun,
+    };
+}
+// ── CLI 출력 ──
+export function printReclaimResult(r) {
+    const mode = r.dryRun ? ' (dry-run — 디스크 미수정)' : '';
+    console.log(`\n  [reclaim] tenetx/legacy 규칙 회수${mode}`);
+    if (r.removed.length === 0 && r.skippedNeedsConfirm.length === 0 && r.settingsFindings.length === 0) {
+        console.log('  ✓ 회수 대상 없음 — 깨끗한 상태');
+        return;
+    }
+    for (const p of r.removed) {
+        console.log(`  ${r.dryRun ? '○ 회수 예정' : '✓ 회수'}: ${p}`);
+    }
+    for (const p of r.skippedNeedsConfirm) {
+        console.log(`  ⚠ 마커는 있으나 forgen 이 쓴 내용과 다름 (사용자 편집 가능성): ${p}`);
+        console.log('    → 확인 후 삭제하려면 --yes 로 재실행');
+    }
+    if (r.settingsFindings.length > 0) {
+        console.log('  [settings] tenetx 흔적:');
+        for (const f of r.settingsFindings)
+            console.log(`    - ${f}`);
+        if (r.settingsApplied)
+            console.log('    ✓ --apply-settings 로 제거 완료 (백업 저장됨)');
+        else
+            console.log('    → 자동 제거: forgen migrate tenetx --apply-settings');
+    }
+    if (r.backupDir)
+        console.log(`  백업: ${r.backupDir}`);
+}

package/dist/core/probe-workflow-cli.d.ts

@@ -1,5 +1,5 @@
 /**
- * forgen probe-workflow — ADR-009 §1 결정적 미확인 변수 실측 도구.
+ * forgen dev probe-workflow — ADR-009 §1 결정적 미확인 변수 실측 도구.
  *
  * 질문: dynamic workflow **내부** 에이전트에 대해 SubagentStart/Stop·PostToolUse
  *       훅이 발화하는가? (워크플로우 런타임은 "대화와 분리된 격리 백그라운드"로
@@ -16,9 +16,9 @@
  *   - (보조) hook-timing.jsonl 의 event 별 엔트리
  *
  * 절차 (2단계 — 런타임이 격리되어 있어 단일 프로세스로는 트리거 불가):
- *   1. `forgen probe-workflow arm`    → baseline 마커 기록 + 안내 출력
+ *   1. `forgen dev probe-workflow arm`    → baseline 마커 기록 + 안내 출력
  *   2. 사용자가 Claude Code 에서 워크플로우 1회 실행 (그 사이 다른 작업 금지)
- *   3. `forgen probe-workflow report` → baseline 이후 신호 수집 → verdict 박제
+ *   3. `forgen dev probe-workflow report` → baseline 이후 신호 수집 → verdict 박제
  *
  * 가정 (detailed-communication): arm~report 사이에 사용자가 **워크플로우만**
  * 실행했다고 전제한다. 일반 Task-tool subagent 를 같이 돌리면 신호가 섞인다.

package/dist/core/probe-workflow-cli.js

@@ -1,5 +1,5 @@
 /**
- * forgen probe-workflow — ADR-009 §1 결정적 미확인 변수 실측 도구.
+ * forgen dev probe-workflow — ADR-009 §1 결정적 미확인 변수 실측 도구.
  *
  * 질문: dynamic workflow **내부** 에이전트에 대해 SubagentStart/Stop·PostToolUse
  *       훅이 발화하는가? (워크플로우 런타임은 "대화와 분리된 격리 백그라운드"로
@@ -16,9 +16,9 @@
  *   - (보조) hook-timing.jsonl 의 event 별 엔트리
  *
  * 절차 (2단계 — 런타임이 격리되어 있어 단일 프로세스로는 트리거 불가):
- *   1. `forgen probe-workflow arm`    → baseline 마커 기록 + 안내 출력
+ *   1. `forgen dev probe-workflow arm`    → baseline 마커 기록 + 안내 출력
  *   2. 사용자가 Claude Code 에서 워크플로우 1회 실행 (그 사이 다른 작업 금지)
- *   3. `forgen probe-workflow report` → baseline 이후 신호 수집 → verdict 박제
+ *   3. `forgen dev probe-workflow report` → baseline 이후 신호 수집 → verdict 박제
  *
  * 가정 (detailed-communication): arm~report 사이에 사용자가 **워크플로우만**
  * 실행했다고 전제한다. 일반 Task-tool subagent 를 같이 돌리면 신호가 섞인다.
@@ -188,14 +188,14 @@ function armProbe() {
     fs.mkdirSync(STATE_DIR, { recursive: true });
     fs.writeFileSync(BASELINE_PATH, JSON.stringify(baseline, null, 2));
     console.log(`
-${C.bold}forgen probe-workflow — armed${C.reset} ${C.dim}(${baseline.armedIso})${C.reset}
+${C.bold}forgen dev probe-workflow — armed${C.reset} ${C.dim}(${baseline.armedIso})${C.reset}
 
 ${C.cyan}다음을 정확히 순서대로 실행하세요:${C.reset}
   1. Claude Code (v2.1.154+, workflows 활성) 세션에서 ${C.bold}워크플로우 1회만${C.reset} 실행
      예: ${C.dim}Run a workflow to list files under src/${C.reset}
      또는: ${C.dim}/deep-research <질문>${C.reset}
   2. ${C.yellow}그 사이 다른 Task/subagent 작업은 돌리지 마세요${C.reset} (신호 오염 방지)
-  3. 워크플로우가 끝나면: ${C.bold}forgen probe-workflow report${C.reset}
+  3. 워크플로우가 끝나면: ${C.bold}forgen dev probe-workflow report${C.reset}
 
 ${C.dim}전제: forgen 의 SubagentStart/Stop·PostToolUse 훅이 설치/활성 상태여야 합니다.
 불확실하면 'forgen config hooks' 로 확인하세요.${C.reset}
@@ -219,7 +219,7 @@ function colorForOutcome(outcome) {
 function reportProbe() {
     const baseline = loadBaseline();
     if (!baseline) {
-        console.log(`\n  ${C.red}✗ armed 상태가 아닙니다.${C.reset} 먼저 ${C.bold}forgen probe-workflow arm${C.reset} 를 실행하세요.\n`);
+        console.log(`\n  ${C.red}✗ armed 상태가 아닙니다.${C.reset} 먼저 ${C.bold}forgen dev probe-workflow arm${C.reset} 를 실행하세요.\n`);
         process.exitCode = 1;
         return;
     }
@@ -228,7 +228,7 @@ function reportProbe() {
     persistResult(baseline, verdict);
     const oc = colorForOutcome(verdict.outcome);
     console.log(`
-${C.bold}forgen probe-workflow — report${C.reset} ${C.dim}(armed ${baseline.armedIso})${C.reset}
+${C.bold}forgen dev probe-workflow — report${C.reset} ${C.dim}(armed ${baseline.armedIso})${C.reset}
 
   SubagentStart/Stop 발화 : ${verdict.subagentStartStopFired ? `${C.green}YES${C.reset}` : `${C.yellow}NO${C.reset}`}
   PostToolUse 발화        : ${verdict.postToolUseFired ? `${C.green}YES${C.reset}` : `${C.yellow}NO${C.reset}`}
@@ -254,8 +254,8 @@ function persistResult(baseline, verdict) {
 function statusProbe() {
     const baseline = loadBaseline();
     console.log(baseline
-        ? `\n  armed: ${C.cyan}${baseline.armedIso}${C.reset}\n  → 워크플로우 실행 후 ${C.bold}forgen probe-workflow report${C.reset}\n`
-        : `\n  ${C.dim}armed 상태 아님.${C.reset} ${C.bold}forgen probe-workflow arm${C.reset} 로 시작하세요.\n`);
+        ? `\n  armed: ${C.cyan}${baseline.armedIso}${C.reset}\n  → 워크플로우 실행 후 ${C.bold}forgen dev probe-workflow report${C.reset}\n`
+        : `\n  ${C.dim}armed 상태 아님.${C.reset} ${C.bold}forgen dev probe-workflow arm${C.reset} 로 시작하세요.\n`);
 }
 export async function handleProbeWorkflow(args) {
     const sub = args[0] ?? 'status';
@@ -271,12 +271,12 @@ export async function handleProbeWorkflow(args) {
             return;
         default:
             console.log(`
-  ${C.bold}forgen probe-workflow${C.reset} — ADR-009 §1: 워크플로우 훅 발화 실측
+  ${C.bold}forgen dev probe-workflow${C.reset} — ADR-009 §1: 워크플로우 훅 발화 실측
 
   Usage:
-    forgen probe-workflow arm       baseline 기록 + 안내 (먼저)
-    forgen probe-workflow report    워크플로우 실행 후 신호 수집 → 판정
-    forgen probe-workflow status    현재 armed 상태 확인
+    forgen dev probe-workflow arm       baseline 기록 + 안내 (먼저)
+    forgen dev probe-workflow report    워크플로우 실행 후 신호 수집 → 판정
+    forgen dev probe-workflow status    현재 armed 상태 확인
 `);
     }
 }

package/dist/core/recall-cli.js

@@ -107,7 +107,7 @@ export async function handleRecall(args) {
         return;
     }
     console.log('');
-    console.log(`  forgen recall — last ${recalls.length} surfaced solution${recalls.length === 1 ? '' : 's'}`);
+    console.log(`  forgen status --compound — last ${recalls.length} surfaced solution${recalls.length === 1 ? '' : 's'}`);
     console.log('  ─────────────────────────────────────────');
     for (const r of recalls) {
         const score = r.match_score !== undefined ? ` @${r.match_score.toFixed(2)}` : '';

package/dist/core/regress-map-cli.js

@@ -27,7 +27,7 @@ export async function handleRegressMap(args = []) {
         console.log('regress-map: git unavailable or no commits in window.');
         return;
     }
-    console.log('  ┌─ forgen regress-map ───────────────────────────────────┐');
+    console.log('  ┌─ forgen dev regress-map ───────────────────────────────────┐');
     console.log(`  │ window: last ${map.windowDays} days · fix commits: ${map.fixCommits}`.padEnd(60) + '│');
     if (ratio.available) {
         console.log(`  │ ${formatFixRatio(ratio)}`.padEnd(60) + '│');

package/dist/core/rendered-rules-manifest.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Forgen v0.5.0 — Rendered Rules Manifest (ADR-010 W1-1)
+ *
+ * harness 가 렌더해 쓴 규칙 파일의 content-hash 원장.
+ * reclaimer(`forgen migrate tenetx`)가 "forgen 이 쓴 그대로인 파일"과
+ * "사용자가 편집했거나 다른 도구가 쓴 파일"을 구분하는 유일한 근거다 —
+ * native /doctor 는 비용만 알지 provenance 를 모른다.
+ *
+ * 성능 (Rev 2): 렌더 시점에 이미 메모리에 있는 내용을 해시하므로
+ * 재읽기/전체 스캔 비용이 없다. 스캔 사이드(reclaimer)만 파일을 읽는다.
+ */
+export interface ManifestEntry {
+    sha256: string;
+    version: string;
+    ts: string;
+}
+export type RulesManifest = Record<string, ManifestEntry>;
+export declare function manifestPath(home?: string): string;
+export declare function sha256Of(content: string): string;
+export declare function loadManifest(home?: string): RulesManifest;
+/**
+ * 렌더 직후 호출 — 쓴 파일들의 해시를 기존 manifest 에 병합 기록.
+ * 같은 경로는 최신 해시로 **덮어쓴다** (history 없음): 같은 경로에 구버전
+ * 내용이 남는 시나리오는 렌더가 즉시 갱신하므로 존재하지 않고, 다른 경로의
+ * 구버전 파일은 marker-only(needs-confirm) 경로로 안전 강등된다.
+ */
+export declare function recordRenderedFiles(files: Record<string, string>, version: string, home?: string): void;
+/** 파일 내용이 manifest 의 어떤 엔트리와도 일치하는가 (경로 키 기준) */
+export declare function matchesManifest(absPath: string, content: string, manifest: RulesManifest): boolean;

package/dist/core/rendered-rules-manifest.js

@@ -0,0 +1,60 @@
+/**
+ * Forgen v0.5.0 — Rendered Rules Manifest (ADR-010 W1-1)
+ *
+ * harness 가 렌더해 쓴 규칙 파일의 content-hash 원장.
+ * reclaimer(`forgen migrate tenetx`)가 "forgen 이 쓴 그대로인 파일"과
+ * "사용자가 편집했거나 다른 도구가 쓴 파일"을 구분하는 유일한 근거다 —
+ * native /doctor 는 비용만 알지 provenance 를 모른다.
+ *
+ * 성능 (Rev 2): 렌더 시점에 이미 메모리에 있는 내용을 해시하므로
+ * 재읽기/전체 스캔 비용이 없다. 스캔 사이드(reclaimer)만 파일을 읽는다.
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { createHash } from 'node:crypto';
+export function manifestPath(home = os.homedir()) {
+    return path.join(home, '.forgen', 'state', 'rendered-rules-manifest.json');
+}
+export function sha256Of(content) {
+    return createHash('sha256').update(content, 'utf-8').digest('hex');
+}
+export function loadManifest(home = os.homedir()) {
+    try {
+        const raw = fs.readFileSync(manifestPath(home), 'utf-8');
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'object' && parsed !== null ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * 렌더 직후 호출 — 쓴 파일들의 해시를 기존 manifest 에 병합 기록.
+ * 같은 경로는 최신 해시로 **덮어쓴다** (history 없음): 같은 경로에 구버전
+ * 내용이 남는 시나리오는 렌더가 즉시 갱신하므로 존재하지 않고, 다른 경로의
+ * 구버전 파일은 marker-only(needs-confirm) 경로로 안전 강등된다.
+ */
+export function recordRenderedFiles(files, version, home = os.homedir()) {
+    try {
+        const p = manifestPath(home);
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        const manifest = loadManifest(home);
+        const ts = new Date().toISOString();
+        for (const [absPath, content] of Object.entries(files)) {
+            manifest[absPath] = { sha256: sha256Of(content), version, ts };
+        }
+        fs.writeFileSync(p, `${JSON.stringify(manifest, null, 2)}\n`);
+    }
+    catch {
+        // manifest 기록 실패는 렌더를 막지 않는다 (fail-open) —
+        // 그 경우 reclaimer 가 marker-only 경로로 폴백한다.
+    }
+}
+/** 파일 내용이 manifest 의 어떤 엔트리와도 일치하는가 (경로 키 기준) */
+export function matchesManifest(absPath, content, manifest) {
+    const entry = manifest[absPath];
+    if (!entry)
+        return false;
+    return entry.sha256 === sha256Of(content);
+}

package/dist/core/session-store.js

@@ -11,6 +11,7 @@ import * as path from 'node:path';
 import { createLogger } from './logger.js';
 import { FORGEN_HOME } from './paths.js';
 import { ensureObservabilitySchema } from './observability-store.js';
+import { stripPrivate } from '../engine/private-filter.js';
 const require = createRequire(import.meta.url);
 // Suppress ExperimentalWarning for node:sqlite (Node.js 22+)
 {
@@ -116,8 +117,13 @@ export async function indexCodexSession(cwd, transcriptPath, sessionId) {
                 const role = entry.payload.role;
                 if (role !== 'user' && role !== 'assistant')
                     continue;
-                const text = extractCodexText(entry.payload.content);
-                if (!text)
+                const rawText = extractCodexText(entry.payload.content);
+                if (!rawText)
+                    continue;
+                // W2-5 (private 태그): FTS 인덱스는 session-search 로 재노출되므로 <private>
+                // 범위를 인덱싱 전에 제거한다. 통째 private 메시지는 인덱싱하지 않는다.
+                const text = stripPrivate(rawText).cleaned;
+                if (!text.trim())
                     continue;
                 const truncated = text.slice(0, 10000);
                 const ts = typeof entry.timestamp === 'string' ? entry.timestamp : '';
@@ -179,7 +185,12 @@ export async function indexSession(cwd, transcriptPath, sessionId) {
                             : '';
                 }
                 if (role && text) {
-                    const truncated = text.slice(0, 10000);
+                    // W2-5 (private 태그): FTS 인덱스가 session-search 로 재노출되므로 <private>
+                    // 범위를 제거 후 인덱싱. 통째 private 메시지는 스킵.
+                    const cleanText = stripPrivate(text).cleaned;
+                    if (!cleanText.trim())
+                        continue;
+                    const truncated = cleanText.slice(0, 10000);
                     const result = insertMsg.run(sessionId, role, truncated, entry.timestamp ?? '');
                     // FTS5 인덱스 동기화
                     if (fts5Available) {

package/dist/core/settings-injector.d.ts

@@ -6,6 +6,9 @@
  */
 import type { RuntimeHost } from './types.js';
 import type { V1BootstrapResult } from './v1-bootstrap.js';
+export declare function stripForgenManagedRules(rules: string[]): string[];
+/** Apply v1 trust policy → permissions (deny/ask lists). */
+export declare function applyTrustPolicyPermissions(settings: Record<string, unknown>, v1Result: V1BootstrapResult): void;
 /**
  * Inject forgen settings into Claude Code settings.json.
  * Coordinates: read/backup → env merge → statusLine → hooks → trust policy → atomic write.

package/dist/core/settings-injector.js

@@ -12,13 +12,20 @@ import { ConfigError } from './errors.js';
 import { createLogger } from './logger.js';
 import { acquireLock, atomicWriteFileSync, CLAUDE_DIR, readSettingsSafely, releaseLock, rollbackSettings, SETTINGS_BACKUP_PATH, SETTINGS_PATH, } from './settings-lock.js';
 const log = createLogger('settings-injector');
+// 주의(2026-08-04 버그수정): '# forgen-managed' 는 **더 이상 주입하지 않는다** — JSON
+// permissions 배열엔 주석이 데이터 원소가 되어 Claude Code 가 malformed deny 룰로 경고했다.
+// strip-set 에는 남겨둬, 이전 버그로 오염된 사용자 settings 가 재주입 시 self-heal 되게 한다.
+// 멱등성은 마커가 아니라 아래 실제 룰 문자열의 정확일치 제거로 이미 보장된다.
 const FORGEN_PERMISSION_RULES = new Set([
-    '# forgen-managed',
+    '# forgen-managed', // legacy 오염 정리용 (신규 주입 안 함)
     'Bash(rm -rf *)',
     'Bash(git push --force*)',
     'Bash(git reset --hard*)',
 ]);
-function stripForgenManagedRules(rules) {
+/** 신규 주입할 forgen deny 룰 (마커 없음). */
+const FORGEN_DENY_RULES = ['Bash(rm -rf *)', 'Bash(git push --force*)', 'Bash(git reset --hard*)'];
+const FORGEN_ASK_RULES = ['Bash(rm -rf *)', 'Bash(git push --force*)'];
+export function stripForgenManagedRules(rules) {
     return rules.filter((r) => !FORGEN_PERMISSION_RULES.has(r));
 }
 /**
@@ -116,29 +123,18 @@ function mergeHooksIntoSettings(settings, runtime, cwd, pkgRoot) {
     }
 }
 /** Apply v1 trust policy → permissions (deny/ask lists). */
-function applyTrustPolicyPermissions(settings, v1Result) {
+export function applyTrustPolicyPermissions(settings, v1Result) {
     if (!v1Result.session)
         return;
     const trust = v1Result.session.effective_trust_policy;
     const permissions = settings.permissions ?? {};
     const existingDeny = stripForgenManagedRules(permissions.deny ?? []);
     if (trust === '가드레일 우선') {
-        permissions.deny = [
-            ...existingDeny,
-            '# forgen-managed',
-            'Bash(rm -rf *)',
-            'Bash(git push --force*)',
-            'Bash(git reset --hard*)',
-        ];
+        permissions.deny = [...existingDeny, ...FORGEN_DENY_RULES];
     }
     else if (trust === '승인 완화') {
         const existingAsk = stripForgenManagedRules(permissions.ask ?? []);
-        permissions.ask = [
-            ...existingAsk,
-            '# forgen-managed',
-            'Bash(rm -rf *)',
-            'Bash(git push --force*)',
-        ];
+        permissions.ask = [...existingAsk, ...FORGEN_ASK_RULES];
         permissions.deny = existingDeny.length > 0 ? existingDeny : undefined;
     }
     // '완전 신뢰 실행': 추가 제한 없음

package/dist/core/spawn.d.ts

@@ -1,5 +1,7 @@
 import type { V1HarnessContext } from './harness.js';
 import type { RuntimeHost } from './types.js';
+/** runAutoCompound 결과 — sweep(무인 cron)이 실제 spawn 만 기록하도록 상태 반환. */
+export type AutoCompoundStatus = 'spawned' | 'skipped-inflight' | 'skipped-dedup' | 'failed';
 /**
  * 세션 종료 후 자동 compound 추출을 백그라운드(detached)로 시작.
  *
@@ -12,7 +14,15 @@ import type { RuntimeHost } from './types.js';
  * dedup: last-auto-compound.json 을 Stop 훅과 공유 — 같은 세션의 최근 run 이 있으면
  * skip 하여 detached spawn 의 double-run 을 방지한다.
  */
-export declare function runAutoCompound(cwd: string, transcriptPath: string, sessionId: string): void;
+/**
+ * per-session in-flight 슬롯 확보 (spawn *전* 표식). 이미 in-flight(TTL 내)면 false 반환 → skip.
+ * runAutoCompound 와 context-guard.maybeSpawnAutoCompound 가 **공유**해 이중 spawn(중복 Haiku
+ * 과금)을 막는다 (리뷰 SEV-2 #3: 완료-게이트 단일슬롯만으로는 부족).
+ */
+export declare function claimAutoCompoundInflight(sessionId: string, now?: number): boolean;
+/** in-flight 슬롯 해제 (spawn 실패 시 재시도 가능하도록). */
+export declare function releaseAutoCompoundInflight(sessionId: string): void;
+export declare function runAutoCompound(cwd: string, transcriptPath: string, sessionId: string, promptCount?: number): AutoCompoundStatus;
 /**
  * Plan B-1: 세션 transcript 사후 스캔으로 rate-limit 감지.
  *