@wooojin/forgen 0.4.13 → 0.5.5

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,23 @@
 import type { V1HarnessContext } from './harness.js';
 import type { RuntimeHost } from './types.js';
+/**
+ * 사용자 메시지 수 카운트 (streaming).
+ *
+ * Audit fix #8 (2026-04-21): 이전에는 `fs.readFileSync(transcript, 'utf-8')`로
+ * 파일 전체를 메모리에 올렸다. 수백 MB 규모 transcript에서는 heap spike가
+ * 발생했고, 카운트 외엔 내용이 필요 없으니 streaming line-by-line로 충분하다.
+ */
+/**
+ * 0.4.6 — claude/codex 양 schema 호환.
+ *
+ * Claude JSONL: {type: 'user' | 'queue-operation', ...}
+ * Codex JSONL: {type: 'response_item', payload: {role: 'user' | 'developer' | 'assistant', ...}}
+ *
+ * 단일 함수에서 둘 다 처리 — schema 자동 감지.
+ */
+export declare function countUserMessages(transcriptPath: string): Promise<number>;
+/** runAutoCompound 결과 — sweep(무인 cron)이 실제 spawn 만 기록하도록 상태 반환. */
+export type AutoCompoundStatus = 'spawned' | 'skipped-inflight' | 'skipped-dedup' | 'failed';
 /**
  * 세션 종료 후 자동 compound 추출을 백그라운드(detached)로 시작.
  *
@@ -12,7 +30,25 @@ 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;
+/**
+ * ~/.forgen/state/auto-compound/<sessionId>.log — 세션별 러너 로그 경로.
+ *
+ * 결함2 관측성 fix (2026-08-18): 이전엔 detached spawn 을 `stdio: 'ignore'` 로
+ * 실행해 러너의 stdout/stderr(진단 메시지 포함)를 통째로 버렸다. 그 결과 solution
+ * extraction 이 98/98 sweep 에서 `extractedSolutions=0` 을 기록해도 원인을 알 방법이
+ * 없었다(완전 무음 실패). 이제 fd 를 파일로 열어 넘겨 러너의 모든 출력을 세션별
+ * 로그로 남긴다 — 다음 실패 모드를 디버그 가능하게 만드는 전제 조건.
+ */
+export declare function autoCompoundLogPath(sessionId: string): string;
+export declare function runAutoCompound(cwd: string, transcriptPath: string, sessionId: string, promptCount?: number): AutoCompoundStatus;
 /**
  * Plan B-1: 세션 transcript 사후 스캔으로 rate-limit 감지.
  *

package/dist/core/spawn.js

@@ -112,7 +112,7 @@ function findSessionTranscript(cwd, sessionStartMs, preSnapshot, runtime = 'clau
  *
  * 단일 함수에서 둘 다 처리 — schema 자동 감지.
  */
-async function countUserMessages(transcriptPath) {
+export async function countUserMessages(transcriptPath) {
     const { createInterface } = await import('node:readline');
     const stream = fs.createReadStream(transcriptPath, { encoding: 'utf-8' });
     const rl = createInterface({ input: stream, crlfDelay: Infinity });
@@ -225,6 +225,34 @@ async function scanCommitDiffForActedOn(sessionId, cwd, sessionStartTime) {
  */
 // Stop 훅(maybeSpawnAutoCompound)/session-recovery 와 공유하는 dedup cooldown.
 const AUTO_COMPOUND_DEDUP_COOLDOWN_MS = 5 * 60 * 1000; // 5min
+// per-session in-flight start-gate TTL — 러너 최대 실행(~210s)+마진. ADR-011 리뷰 SEV-1:
+// 완료-게이트 단일슬롯 마커는 sweep↔Stop 훅 / 다중세션 double-spawn 을 못 막는다.
+// 세션별 start-gate 로 spawn 전에 표식해 이중실행(중복 Haiku 과금)을 차단.
+const AUTO_COMPOUND_INFLIGHT_TTL_MS = 10 * 60 * 1000; // 10min
+/** 세션별 in-flight 마커 경로 (파일명 안전화). */
+function inflightPathFor(sessionId) {
+    return path.join(STATE_DIR, 'compound-inflight', `${sessionId.replace(/[^a-zA-Z0-9_-]/g, '_')}.json`);
+}
+/** TTL 지난 in-flight 마커 정리 (무한 증가 방지). */
+function cleanupStaleInflight(dir, now) {
+    try {
+        for (const f of fs.readdirSync(dir)) {
+            const fp = path.join(dir, f);
+            try {
+                const { startedAt } = JSON.parse(fs.readFileSync(fp, 'utf-8'));
+                if (!Number.isFinite(startedAt) || now - startedAt >= AUTO_COMPOUND_INFLIGHT_TTL_MS) {
+                    fs.rmSync(fp, { force: true });
+                }
+            }
+            catch {
+                fs.rmSync(fp, { force: true }); // 손상 마커 제거
+            }
+        }
+    }
+    catch {
+        /* dir 없음 — noop */
+    }
+}
 /**
  * 세션 종료 후 자동 compound 추출을 백그라운드(detached)로 시작.
  *
@@ -237,33 +265,112 @@ const AUTO_COMPOUND_DEDUP_COOLDOWN_MS = 5 * 60 * 1000; // 5min
  * dedup: last-auto-compound.json 을 Stop 훅과 공유 — 같은 세션의 최근 run 이 있으면
  * skip 하여 detached spawn 의 double-run 을 방지한다.
  */
-export function runAutoCompound(cwd, transcriptPath, sessionId) {
-    const markerPath = path.join(STATE_DIR, 'last-auto-compound.json');
+/**
+ * per-session in-flight 슬롯 확보 (spawn *전* 표식). 이미 in-flight(TTL 내)면 false 반환 → skip.
+ * runAutoCompound 와 context-guard.maybeSpawnAutoCompound 가 **공유**해 이중 spawn(중복 Haiku
+ * 과금)을 막는다 (리뷰 SEV-2 #3: 완료-게이트 단일슬롯만으로는 부족).
+ */
+export function claimAutoCompoundInflight(sessionId, now = Date.now()) {
+    const inflightPath = inflightPathFor(sessionId);
+    try {
+        const { startedAt } = JSON.parse(fs.readFileSync(inflightPath, 'utf-8'));
+        if (Number.isFinite(startedAt) && now - startedAt < AUTO_COMPOUND_INFLIGHT_TTL_MS)
+            return false;
+    }
+    catch {
+        /* 마커 없음/손상 — 진행 */
+    }
+    const dir = path.dirname(inflightPath);
+    cleanupStaleInflight(dir, now);
     try {
-        const parsed = JSON.parse(fs.readFileSync(markerPath, 'utf-8'));
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(inflightPath, JSON.stringify({ startedAt: now, sessionId }));
+    }
+    catch (e) {
+        log.debug('in-flight 마커 기록 실패 (계속)', e);
+    }
+    return true;
+}
+/** in-flight 슬롯 해제 (spawn 실패 시 재시도 가능하도록). */
+export function releaseAutoCompoundInflight(sessionId) {
+    try {
+        fs.rmSync(inflightPathFor(sessionId), { force: true });
+    }
+    catch {
+        /* noop */
+    }
+}
+/**
+ * ~/.forgen/state/auto-compound/<sessionId>.log — 세션별 러너 로그 경로.
+ *
+ * 결함2 관측성 fix (2026-08-18): 이전엔 detached spawn 을 `stdio: 'ignore'` 로
+ * 실행해 러너의 stdout/stderr(진단 메시지 포함)를 통째로 버렸다. 그 결과 solution
+ * extraction 이 98/98 sweep 에서 `extractedSolutions=0` 을 기록해도 원인을 알 방법이
+ * 없었다(완전 무음 실패). 이제 fd 를 파일로 열어 넘겨 러너의 모든 출력을 세션별
+ * 로그로 남긴다 — 다음 실패 모드를 디버그 가능하게 만드는 전제 조건.
+ */
+export function autoCompoundLogPath(sessionId) {
+    return path.join(STATE_DIR, 'auto-compound', `${sessionId.replace(/[^a-zA-Z0-9_-]/g, '_')}.log`);
+}
+export function runAutoCompound(cwd, transcriptPath, sessionId, promptCount = 0) {
+    const now = Date.now();
+    // 1. 완료 마커 cooldown (secondary, 단일슬롯 — 값싼 read 먼저).
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(STATE_DIR, 'last-auto-compound.json'), 'utf-8'));
         if (parsed.sessionId === sessionId) {
             const last = parsed.completedAt ? Date.parse(parsed.completedAt) : 0;
-            if (Number.isFinite(last) && Date.now() - last < AUTO_COMPOUND_DEDUP_COOLDOWN_MS) {
+            if (Number.isFinite(last) && now - last < AUTO_COMPOUND_DEDUP_COOLDOWN_MS) {
                 log.debug('auto-compound skip: 최근 동일 세션 run 존재 (dedup)');
-                return;
+                return 'skipped-dedup';
             }
         }
     }
     catch {
-        // 마커 없음(최초)/손상 — 진행 (fail-open).
+        /* 마커 없음(최초)/손상 — 진행 (fail-open). */
+    }
+    // 2. per-session in-flight start-gate (공유 헬퍼).
+    if (!claimAutoCompoundInflight(sessionId, now)) {
+        log.debug('auto-compound skip: 세션 in-flight (start-gate)');
+        return 'skipped-inflight';
     }
     const runnerPath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'auto-compound-runner.js');
+    // 로그 파일 fd 열기 — 실패(디스크 문제 등)해도 fail-open 으로 'ignore' 폴백.
+    const logPath = autoCompoundLogPath(sessionId);
+    let logFd;
+    try {
+        fs.mkdirSync(path.dirname(logPath), { recursive: true });
+        logFd = fs.openSync(logPath, 'a');
+    }
+    catch (e) {
+        log.debug('auto-compound 로그 파일 열기 실패 — stdio ignore로 폴백', e);
+    }
     try {
-        const child = spawn('node', [runnerPath, cwd, transcriptPath, sessionId], {
+        // 결함2 corrected fix (2026-08-19): 리터럴 'node' 대신 process.execPath 로 spawn.
+        // 실 cron 은 절대 nvm node 경로로 sweep 를 돌리는데, 러너를 'node' 로 spawn 하면
+        // cron sparse PATH 의 /bin/node 로 해석돼 러너의 process.execPath 가 달라지고,
+        // 러너가 forgen(nvm 형제 바이너리)을 절대경로로 못 찾아 solution write 가 ENOENT 로
+        // 실패한다. execPath 를 물려주면 러너가 sweep 과 같은 node(=forgen 형제)를 상속한다.
+        const child = spawn(process.execPath, [runnerPath, cwd, transcriptPath, sessionId, String(promptCount)], {
             cwd,
             detached: true,
-            stdio: 'ignore',
+            stdio: logFd !== undefined ? ['ignore', logFd, logFd] : 'ignore',
         });
         child.unref();
+        if (logFd !== undefined)
+            fs.closeSync(logFd); // child가 dup — 부모 측 fd는 닫아도 안전
         console.log('\n[forgen] 세션 분석을 백그라운드로 시작했습니다 (자동 compound) — 결과는 다음 세션 시작 시 반영됩니다.\n');
+        return 'spawned';
     }
     catch (e) {
+        if (logFd !== undefined) {
+            try {
+                fs.closeSync(logFd);
+            }
+            catch { /* noop */ }
+        }
         log.debug('auto-compound 시작 실패', e);
+        releaseAutoCompoundInflight(sessionId); // spawn 실패 시 표식 제거 → 재시도 가능
+        return 'failed';
     }
 }
 /**

package/dist/core/state-gc.js

@@ -31,6 +31,7 @@ const SESSION_SCOPED_PREFIXES = [
     'reminder-',
     'context-',
     'last-',
+    'current-model-', // W4-3 per-model 가드 프로필의 세션별 모델 캐시
 ];
 const DEFAULT_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
 function hasSessionPrefix(name) {

package/dist/core/status-cli.d.ts

@@ -0,0 +1,20 @@
+/**
+ * forgen status — 통합 상태 명령 (Wave 1, feature-audit 2026-07-21).
+ *
+ * 이전에는 "내 상태를 보여줘"가 stats/health/dashboard/me/recall/explain/
+ * last-block/watch/inspect 9개 명령으로 파편화돼 있었다(~1800줄). 이 하나로
+ * 통합해 표면을 줄이고 진입점을 일원화한다. 기존 render/compute 함수는 재사용만
+ * 하고 재작성하지 않는다.
+ *
+ *   forgen status              요약 (health 헤더 + one-screen stats)
+ *   forgen status --compound   compound 상태 + 최근 회상 이력
+ *   forgen status --profile    4축 프로필 + 최근 교정
+ *   forgen status --rules      활성 룰
+ *   forgen status --blocks [N] 최근 차단 N건 (rule·사유·해결)
+ *   forgen status --live       실시간 훅 이벤트 스트림
+ */
+declare const VIEWS: readonly ["--compound", "--profile", "--rules", "--blocks", "--live", "--overview"];
+type View = (typeof VIEWS)[number];
+export declare function resolveView(args: string[]): View | null;
+export declare function handleStatus(args: string[]): Promise<void>;
+export {};

package/dist/core/status-cli.js

@@ -0,0 +1,100 @@
+/**
+ * forgen status — 통합 상태 명령 (Wave 1, feature-audit 2026-07-21).
+ *
+ * 이전에는 "내 상태를 보여줘"가 stats/health/dashboard/me/recall/explain/
+ * last-block/watch/inspect 9개 명령으로 파편화돼 있었다(~1800줄). 이 하나로
+ * 통합해 표면을 줄이고 진입점을 일원화한다. 기존 render/compute 함수는 재사용만
+ * 하고 재작성하지 않는다.
+ *
+ *   forgen status              요약 (health 헤더 + one-screen stats)
+ *   forgen status --compound   compound 상태 + 최근 회상 이력
+ *   forgen status --profile    4축 프로필 + 최근 교정
+ *   forgen status --rules      활성 룰
+ *   forgen status --blocks [N] 최근 차단 N건 (rule·사유·해결)
+ *   forgen status --live       실시간 훅 이벤트 스트림
+ */
+const VIEWS = ['--compound', '--profile', '--rules', '--blocks', '--live', '--overview'];
+const ALIASES = {
+    '-c': '--compound',
+    '-p': '--profile',
+    '-r': '--rules',
+    '-b': '--blocks',
+    '-l': '--live',
+    '-o': '--overview',
+};
+export function resolveView(args) {
+    for (const a of args) {
+        const flag = a.split('=')[0]; // --blocks=1 → --blocks
+        if (VIEWS.includes(flag))
+            return flag;
+        if (ALIASES[flag])
+            return ALIASES[flag];
+    }
+    return null;
+}
+export async function handleStatus(args) {
+    // 하위호환: 구 `forgen status --watch|--json|--interval N`(observability dashboard)
+    // 은 통합 status 의 observability 모드로 계속 지원. 통합 전 별도 status 였음.
+    if (args.includes('--watch') || args.includes('--json') || args.includes('--interval')) {
+        const { runDashboard } = await import('./dashboard-cli.js');
+        const intervalIdx = args.indexOf('--interval');
+        await runDashboard({
+            watch: args.includes('--watch'),
+            json: args.includes('--json'),
+            intervalSec: intervalIdx !== -1 ? Number(args[intervalIdx + 1]) || 5 : 5,
+        });
+        return;
+    }
+    const view = resolveView(args);
+    switch (view) {
+        case '--compound': {
+            const { runDashboard } = await import('./dashboard-cli.js');
+            await runDashboard({});
+            const { handleRecall } = await import('./recall-cli.js');
+            await handleRecall(args.filter((a) => a !== '--compound' && a !== '-c'));
+            return;
+        }
+        case '--profile': {
+            const { handleInspect } = await import('./inspect-cli.js');
+            await handleInspect(['profile']);
+            await handleInspect(['corrections']);
+            return;
+        }
+        case '--rules': {
+            const { handleInspect } = await import('./inspect-cli.js');
+            await handleInspect(['rules']);
+            return;
+        }
+        case '--blocks': {
+            // 남은 positional(숫자)이 있으면 explain N, 없으면 최근 1건.
+            const { handleExplain } = await import('./explain-cli.js');
+            await handleExplain(args.filter((a) => a !== '--blocks' && a !== '-b'));
+            return;
+        }
+        case '--live': {
+            const { handleWatch } = await import('./watch-cli.js');
+            await handleWatch();
+            return;
+        }
+        case '--overview': {
+            // 리치 운영 대시보드(hook health·session history·learning curve·multi-host).
+            // 구 `forgen dashboard`의 고유 콘텐츠 — --compound(ROI/compound)와 다른 축이라
+            // 별도 뷰로 보존 (Wave 1 리뷰: 콘텐츠 손실 방지).
+            const { handleDashboard } = await import('./dashboard.js');
+            await handleDashboard();
+            return;
+        }
+        default: {
+            // 요약: health 헤더 + one-screen stats (둘 다 computeStats() 기반).
+            const { computeHealth, renderHealthLine } = await import('./health-cli.js');
+            const { computeStats, renderStats } = await import('./stats-cli.js');
+            console.log(renderHealthLine(computeHealth()));
+            console.log(renderStats(computeStats()));
+            console.log(`  ${dim('views:')} forgen status --compound | --profile | --rules | --blocks [N] | --live`);
+            return;
+        }
+    }
+}
+function dim(s) {
+    return `\x1b[2m${s}\x1b[0m`;
+}