@wooojin/forgen 0.4.13 → 0.5.0

package/dist/core/spawn.js

@@ -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,77 @@ 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 {
+        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 {
-        const parsed = JSON.parse(fs.readFileSync(markerPath, 'utf-8'));
+        fs.rmSync(inflightPathFor(sessionId), { force: true });
+    }
+    catch {
+        /* noop */
+    }
+}
+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');
     try {
-        const child = spawn('node', [runnerPath, cwd, transcriptPath, sessionId], {
+        const child = spawn('node', [runnerPath, cwd, transcriptPath, sessionId, String(promptCount)], {
             cwd,
             detached: true,
             stdio: 'ignore',
         });
         child.unref();
         console.log('\n[forgen] 세션 분석을 백그라운드로 시작했습니다 (자동 compound) — 결과는 다음 세션 시작 시 반영됩니다.\n');
+        return 'spawned';
     }
     catch (e) {
         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`;
+}

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

@@ -10,4 +10,11 @@
  * Line 4: (TODO: tool counts — 추적 인프라 없음)
  * Line 5: (TODO: active task — 추적 인프라 없음)
  */
+/**
+ * W1-2 (feature-audit 2026-07-21): forgen 가치 카운터 라인 — invisible 가치 가시화.
+ * native 플랜/토큰 usage(→ /usage, W2에서 물러남)가 아니라 forgen *자체 활동량*을
+ * 노출한다: recall 주입·surfaced·교정 캡처·ROI 강등·차단. 전부 computeStats()가 이미
+ * 실측 중인 카운터라 조작 위험 0. computeStats 실패 시 라인 생략(fail-open).
+ */
+export declare function buildValueLine(): string | null;
 export declare function handleStatusline(): Promise<void>;

package/dist/core/statusline-cli.js

@@ -15,9 +15,10 @@ import * as path from 'node:path';
 import * as os from 'node:os';
 import { execSync } from 'node:child_process';
 import { loadActiveRules } from '../store/rule-store.js';
-import { getUsageStats } from './usage-telemetry.js';
 import { STATE_DIR } from './paths.js';
 import { classifySolutions } from './lifecycle-classifier.js';
+import { computeStats } from './stats-cli.js';
+import { loadRoiDemotions } from '../engine/roi-demotion.js';
 // 0.4.6 perf #13 — statusline 출력을 5초 캐싱.
 // claude statusLine 은 짧은 간격으로 재호출되는데 매번 git/find/rule-store 를
 // 실행하면 ~100ms 누적. CACHE_TTL_MS 동안 동일 출력 재사용.
@@ -148,18 +149,48 @@ function buildLifecycleLine() {
         return null;
     }
 }
-/** Build usage line: "📊 87/5h · 412/wk (claude)" — 0.4.6 신설 */
+/**
+ * ADR-010 W2-2: 사용량 세그먼트("📊 N/5h · N/wk") 제거 — native /usage 가
+ * plan limit 를 정확히 분해한다. 이관 사실을 딱 1회만 공지 (state flag).
+ */
 function buildUsageLine() {
     try {
-        const stats = getUsageStats();
-        if (stats.week.total === 0)
-            return null;
-        const dominant = stats.week.codex > stats.week.claude ? 'codex' : 'claude';
-        return [
-            `${YELLOW}📊 ${stats.hour5.total}/5h${RESET}`,
-            `${YELLOW}${stats.week.total}/wk${RESET}`,
-            `${DIM}(${dominant})${RESET}`,
-        ].join(`  ${DIM}·${RESET}  `);
+        const noticeFlag = path.join(STATE_DIR, 'usage-notice-shown');
+        if (!fs.existsSync(noticeFlag)) {
+            fs.mkdirSync(STATE_DIR, { recursive: true });
+            fs.writeFileSync(noticeFlag, new Date().toISOString());
+            return `${DIM}ℹ 사용량 표시는 native /usage 로 이동했습니다 (이 안내는 1회만 표시)${RESET}`;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * W1-2 (feature-audit 2026-07-21): forgen 가치 카운터 라인 — invisible 가치 가시화.
+ * native 플랜/토큰 usage(→ /usage, W2에서 물러남)가 아니라 forgen *자체 활동량*을
+ * 노출한다: recall 주입·surfaced·교정 캡처·ROI 강등·차단. 전부 computeStats()가 이미
+ * 실측 중인 카운터라 조작 위험 0. computeStats 실패 시 라인 생략(fail-open).
+ */
+export function buildValueLine() {
+    try {
+        let roiDemoted = 0;
+        try {
+            roiDemoted = Object.keys(loadRoiDemotions()).length;
+        }
+        catch { /* roi store 없음 → 0 */ }
+        const s = computeStats();
+        const a = s.assistToday;
+        const parts = [
+            `${YELLOW}✦${RESET}`,
+            `${DIM}recall${RESET} ${a.recallHits}`,
+            `${DIM}surfaced${RESET} ${a.surfaced}`,
+            `${DIM}교정${RESET} +${s.corrections7d}${DIM}(7d)${RESET}`,
+            `${DIM}ROI↓${RESET} ${roiDemoted}`,
+            `${DIM}차단${RESET} ${s.blocks7d}${DIM}(7d)${RESET}`,
+        ];
+        return parts.join(`  ${DIM}·${RESET}  `);
     }
     catch {
         return null;
@@ -204,7 +235,19 @@ function writeCache(content) {
     catch { /* fail-open */ }
 }
 export async function handleStatusline() {
-    // 캐시 hit 시 stdin payload 무시하고 바로 출력 (5초 윈도우 내 동일 출력 가정).
+    // W4-3 (ADR-010): hook stdin 엔 모델 필드가 없으므로 statusline 이 세션별
+    // 모델을 캐시 → Stop/SubagentStop 가드가 per-model 프로필 조회에 사용.
+    // 리뷰 SEV-2: 이 기록은 반드시 5초 표시-캐시 early-return **앞**에 있어야
+    // 한다 — /model 로 세션 중 모델을 바꾸면 cache-hit 렌더가 payload 를 아예
+    // 안 읽어 stale 모델(잘못된 가드 모드)이 유지되는 창이 생긴다.
+    // 필드 부재(구버전 CC 등) 시 기록 안 함 = 가드는 'unknown' → block 유지.
+    const payload = readStdinJson();
+    if (payload.session_id && payload.model?.id) {
+        const { cacheSessionModel } = await import('../checks/_shared/model-profile.js');
+        const { sanitizeId } = await import('../hooks/shared/sanitize-id.js');
+        cacheSessionModel(sanitizeId(payload.session_id), payload.model.id);
+    }
+    // 캐시 hit 시 표시만 캐시에서 (5초 윈도우 내 동일 출력 가정).
     // 라인 단위 cache → console.log 라인별 (테스트 호환).
     const cached = readCacheIfFresh();
     if (cached !== null) {
@@ -212,27 +255,28 @@ export async function handleStatusline() {
             console.log(line);
         return;
     }
-    const payload = readStdinJson();
     const cwd = payload.workspace?.current_dir ?? process.cwd();
     const claudeDir = path.join(os.homedir(), '.claude');
     const line1 = buildLine1(payload, cwd);
     const line3 = buildLine3(claudeDir, cwd);
     const usageLine = buildUsageLine();
+    const valueLine = buildValueLine(); // W1-2: forgen 가치 카운터
     const lifecycleLine = buildLifecycleLine();
-    // Line 2 (context/usage): stdin JSON spec 미확인으로 생략 — TODO
-    // Line 4 (tool counts): 추적 인프라 없음 — TODO
-    // Line 5 (active task): 추적 인프라 없음 — TODO
     console.log(line1);
     console.log(line3);
     if (usageLine)
         console.log(usageLine);
+    if (valueLine)
+        console.log(valueLine);
     if (lifecycleLine)
         console.log(lifecycleLine);
+    // W2-2: 1회 공지(usageLine)는 캐시에 넣지 않는다 — 캐시 재생 시
+    // "1회만" 약속이 5초 창 동안 반복 위반되는 실측 버그 방지.
     const cacheLines = [line1, line3];
-    if (usageLine)
-        cacheLines.push(usageLine);
+    if (valueLine)
+        cacheLines.push(valueLine);
     if (lifecycleLine)
         cacheLines.push(lifecycleLine);
-    const cacheBody = cacheLines.join('\n') + '\n';
+    const cacheBody = `${cacheLines.join('\n')}\n`;
     writeCache(cacheBody);
 }

package/dist/core/transcript-summary.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Transcript → 요약 텍스트 (순수, IO 없음 — 테스트 가능).
+ *
+ * auto-compound-runner 의 extractSummary 에서 분리(2026-08-04). 분리 이유: 실 Claude
+ * transcript 스키마 버그(text 가 `entry.message.content` 에 있는데 top-level `entry.content`
+ * 만 읽어 전 user/assistant 턴 누락 → auto-compound 가 실데이터에서 dead)를 회귀 테스트로
+ * 고정하기 위함. 러너 본문은 process.argv 실행부와 묶여 있어 직접 unit-test 불가였다.
+ *
+ * 스키마:
+ *   Claude: {type:'user'|'assistant', message:{role, content: string | [{type:'text',text}]}}
+ *           (일부 queue-operation 등은 top-level `content` 에 저장 → fallback)
+ *   Codex:  {type:'response_item', payload:{role, content:[{type:'input_text', text}]}}
+ */
+export declare function extractText(c: unknown): string;
+/** Codex content array → flat string. content: [{type:'input_text', text}] */
+export declare function extractCodexText(content: unknown): string;
+/** JSONL 원문 → `[User]/[Assistant]` 요약. maxChars 초과 시 조기 종료. */
+export declare function summarizeTranscript(rawText: string, maxChars?: number): string;

package/dist/core/transcript-summary.js

@@ -0,0 +1,81 @@
+/**
+ * Transcript → 요약 텍스트 (순수, IO 없음 — 테스트 가능).
+ *
+ * auto-compound-runner 의 extractSummary 에서 분리(2026-08-04). 분리 이유: 실 Claude
+ * transcript 스키마 버그(text 가 `entry.message.content` 에 있는데 top-level `entry.content`
+ * 만 읽어 전 user/assistant 턴 누락 → auto-compound 가 실데이터에서 dead)를 회귀 테스트로
+ * 고정하기 위함. 러너 본문은 process.argv 실행부와 묶여 있어 직접 unit-test 불가였다.
+ *
+ * 스키마:
+ *   Claude: {type:'user'|'assistant', message:{role, content: string | [{type:'text',text}]}}
+ *           (일부 queue-operation 등은 top-level `content` 에 저장 → fallback)
+ *   Codex:  {type:'response_item', payload:{role, content:[{type:'input_text', text}]}}
+ */
+export function extractText(c) {
+    if (typeof c === 'string')
+        return c;
+    if (Array.isArray(c)) {
+        return c
+            .filter((x) => typeof x === 'object' && x !== null && x.type === 'text')
+            .map((x) => (typeof x.text === 'string' ? x.text : ''))
+            .join('\n');
+    }
+    return '';
+}
+/** Codex content array → flat string. content: [{type:'input_text', text}] */
+export function extractCodexText(content) {
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const item of content) {
+        if (item && typeof item === 'object' && 'text' in item && typeof item.text === 'string') {
+            parts.push(item.text);
+        }
+    }
+    return parts.join('\n');
+}
+/** JSONL 원문 → `[User]/[Assistant]` 요약. maxChars 초과 시 조기 종료. */
+export function summarizeTranscript(rawText, maxChars = 8000) {
+    const lines = rawText.split('\n').filter(Boolean);
+    const messages = [];
+    let totalChars = 0;
+    for (const line of lines) {
+        try {
+            const entry = JSON.parse(line);
+            // Claude schema — text 는 message.content 우선(실버그 수정), top-level 은 fallback.
+            if (entry.type === 'user' || entry.type === 'queue-operation') {
+                const text = extractText(entry.message?.content ?? entry.content);
+                if (text) {
+                    messages.push(`[User] ${text.slice(0, 500)}`);
+                    totalChars += text.length;
+                }
+            }
+            else if (entry.type === 'assistant') {
+                const text = extractText(entry.message?.content ?? entry.content);
+                if (text) {
+                    messages.push(`[Assistant] ${text.slice(0, 500)}`);
+                    totalChars += text.length;
+                }
+            }
+            // Codex schema
+            else if (entry.type === 'response_item' && entry.payload?.role === 'user') {
+                const text = extractCodexText(entry.payload.content);
+                if (text) {
+                    messages.push(`[User] ${text.slice(0, 500)}`);
+                    totalChars += text.length;
+                }
+            }
+            else if (entry.type === 'response_item' && entry.payload?.role === 'assistant') {
+                const text = extractCodexText(entry.payload.content);
+                if (text) {
+                    messages.push(`[Assistant] ${text.slice(0, 500)}`);
+                    totalChars += text.length;
+                }
+            }
+        }
+        catch { /* skip malformed line */ }
+        if (totalChars > maxChars)
+            break;
+    }
+    return messages.join('\n\n');
+}

package/dist/core/trust-layer-intent.d.ts

@@ -19,9 +19,29 @@ export interface CapabilityDeclaration {
     /** source-of-truth (spec 또는 외부 docs/source 인용). */
     readonly source?: string;
 }
-export type HostId = 'claude' | 'codex';
+/**
+ * 지원 host 의 정준 런타임 목록(단일 소스). `HostId` 는 여기서 파생되므로 새 host 추가 시
+ * 이 배열만 넓히면 타입·런타임이 함께 확장된다. 자유형 `host === 'claude'` 이진 비교 대신
+ * `(HOST_IDS as readonly string[]).includes(host)` 로 "유효 host 인지" 를 판정하라
+ * (W3-3 리뷰 SEV-3 #5: Record<HostId> 는 Record 리터럴만 강제, 자유비교는 미포착).
+ */
+export declare const HOST_IDS: readonly ["claude", "codex", "opencode"];
+export type HostId = (typeof HOST_IDS)[number];
+/**
+ * 능력 선언의 검증 수준 (W3-3 리뷰 SEV-3 #1).
+ *   - 'runtime': forgen 이 이 host 에서 실제로 강제/실행함(레퍼런스 host — claude).
+ *   - 'source' : host 의 hook schema 소스로 검증했고 forgen 배선 완료(codex).
+ *   - 'docs'   : host 문서 기반 선언이나 **forgen 배선 미완**(opencode P1 — plugin 슬림 전).
+ *
+ * status='supported' 의 의미가 host 마다 다른 문제를 구조화한다: 'runtime'/'source' 의
+ * supported 는 "forgen 이 강제함", 'docs' 의 supported 는 "플랫폼이 가능하나 forgen 미배선".
+ * 프로그램 소비자는 verificationLevel 로 둘을 게이트해야 한다(intentEnforced 참조).
+ */
+export type CapabilityVerificationLevel = 'runtime' | 'source' | 'docs';
 export interface HostCapabilities {
     readonly hostId: HostId;
+    /** 이 host 선언 전체의 검증 수준. 'docs' 면 아래 status 는 "플랫폼-가능"이지 "forgen-배선"이 아니다. */
+    readonly verificationLevel: CapabilityVerificationLevel;
     /**
      * 모든 TrustLayerIntent 에 대한 선언. `Record<TrustLayerIntent, _>` 타입이
      * 컴파일 타임에 누락을 차단한다.

package/dist/core/trust-layer-intent.js

@@ -16,6 +16,13 @@ export const TRUST_LAYER_INTENTS = [
     'forge-loop-state-inject',
     'self-evidence-record',
 ];
+/**
+ * 지원 host 의 정준 런타임 목록(단일 소스). `HostId` 는 여기서 파생되므로 새 host 추가 시
+ * 이 배열만 넓히면 타입·런타임이 함께 확장된다. 자유형 `host === 'claude'` 이진 비교 대신
+ * `(HOST_IDS as readonly string[]).includes(host)` 로 "유효 host 인지" 를 판정하라
+ * (W3-3 리뷰 SEV-3 #5: Record<HostId> 는 Record 리터럴만 강제, 자유비교는 미포착).
+ */
+export const HOST_IDS = ['claude', 'codex', 'opencode'];
 /**
  * 런타임 assertion — host adapter 가 새 의도 추가를 누락한 경우 fail.
  * 컴파일 타임 가드를 우회하는 동적 생성 코드를 위한 안전망.

package/dist/core/types.d.ts

@@ -1,3 +1,4 @@
+import type { HostId } from './trust-layer-intent.js';
 export interface Principle {
     belief: string;
     /**
@@ -106,8 +107,8 @@ export interface HarnessContext {
     /** 모델 라우팅 프리셋 (default, cost-saving, max-quality) */
     routingPreset?: string;
 }
-/** 런타임 Host */
-export type RuntimeHost = 'claude' | 'codex';
+/** 런타임 Host — 정식 정의는 `trust-layer-intent.ts` 의 HostId (Multi-Harness Adapter Plan P0). */
+export type RuntimeHost = HostId;
 /** 런칭 컨텍스트 — CLI에서 runtime/args 결정을 모델화 */
 export interface LaunchContext {
     runtime: RuntimeHost;

package/dist/core/uninstall.js

@@ -236,6 +236,10 @@ function cleanCompoundRules(cwd) {
         // v4.1+ consolidated
         'project-context.md',
         'routing.md',
+        // v0.5.0+ project-scoped (ADR-010 W1-3)
+        'v1-rules.md',
+        'forge-behavioral.md',
+        'user-profile.md',
         // legacy (v4.0 and earlier)
         'security.md',
         'golden-principles.md',
@@ -257,6 +261,14 @@ function cleanCompoundRules(cwd) {
         fs.unlinkSync(legacyPath);
         removedCount++;
     }
+    // 레거시 글로벌 사이드채널 (ADR-010 W1-3 이전 버전이 ~/.claude/rules/ 에 씀).
+    // 새 세션이 열리기 전에 uninstall 하는 경우 harness 마이그레이션이 못 지우므로
+    // 여기서도 회수한다 — 방치 시 언인스톨 후에도 전 세션에 주입된다.
+    const legacyGlobalBehavioral = path.join(os.homedir(), '.claude', 'rules', 'forge-behavioral.md');
+    if (fs.existsSync(legacyGlobalBehavioral)) {
+        fs.unlinkSync(legacyGlobalBehavioral);
+        removedCount++;
+    }
     if (removedCount > 0) {
         console.log(`  ✓ Removed ${removedCount} rule file(s)`);
     }

package/dist/core/usage-telemetry.d.ts

@@ -13,6 +13,7 @@
  * 0.4.6 신설. limit prediction 은 의도적으로 제외 — Anthropic 의 실제 limit 가
  * 계정/플랜별 가변이라 hard-code 부정확. raw count 만 노출하고 사용자가 판단.
  */
+import type { HostId } from './trust-layer-intent.js';
 export interface UsageStats {
     hour5: {
         claude: number;
@@ -25,7 +26,12 @@ export interface UsageStats {
         total: number;
     };
 }
-export declare function recordToolCall(runtime?: 'claude' | 'codex'): void;
+/**
+ * @deprecated ADR-010 W2-2 (2026-07-16): native `/usage` 가 plan limit 를
+ * skill/subagent/plugin/MCP 별로 정확히 분해하므로 forgen 의 raw count 는
+ * 중복 표면. 기록 중단(no-op shim — API 만 유지), v0.6.0 에서 모듈 삭제 예정.
+ */
+export declare function recordToolCall(_runtime?: HostId): void;
 /**
  * sliding window count. fail-open: 파일 미존재/parse 실패는 0 반환.
  *

package/dist/core/usage-telemetry.js

@@ -22,15 +22,13 @@ const TELEMETRY_PATH = path.join(STATE_DIR, 'usage-telemetry.jsonl');
 const HOUR5_MS = 5 * 60 * 60 * 1000;
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
 const PRUNE_THRESHOLD = 10_000; // 10K lines 누적 시 prune
-export function recordToolCall(runtime = 'claude') {
-    try {
-        fs.mkdirSync(STATE_DIR, { recursive: true });
-        const entry = { ts: Date.now(), rt: runtime };
-        fs.appendFileSync(TELEMETRY_PATH, `${JSON.stringify(entry)}\n`);
-    }
-    catch (e) {
-        log.debug('telemetry append 실패', e);
-    }
+/**
+ * @deprecated ADR-010 W2-2 (2026-07-16): native `/usage` 가 plan limit 를
+ * skill/subagent/plugin/MCP 별로 정확히 분해하므로 forgen 의 raw count 는
+ * 중복 표면. 기록 중단(no-op shim — API 만 유지), v0.6.0 에서 모듈 삭제 예정.
+ */
+export function recordToolCall(_runtime = 'claude') {
+    // no-op — 사용량 추적은 native /usage 로 이관됨.
 }
 /**
  * sliding window count. fail-open: 파일 미존재/parse 실패는 0 반환.

package/dist/core/v1-bootstrap.js

@@ -129,7 +129,7 @@ export function bootstrapV1Session() {
                 mismatchResult = detectMismatch(allSignals);
                 // mismatch 감지 시 재추천 생성
                 if (mismatchResult.quality_mismatch || mismatchResult.autonomy_mismatch) {
-                    session.warnings.push(`Pack mismatch 감지: quality=${mismatchResult.quality_score}, autonomy=${mismatchResult.autonomy_score}. forgen forge --reset soft 로 재설정하거나 forgen onboarding 으로 재추천을 받으세요.`);
+                    session.warnings.push(`Pack mismatch 감지: quality=${mismatchResult.quality_score}, autonomy=${mismatchResult.autonomy_score}. forgen forge --reset soft 로 재설정하거나 forgen forge --onboarding 으로 재추천을 받으세요.`);
                     const rec = createRecommendation({
                         source: 'mismatch_recommendation',
                         quality_pack: mismatchResult.quality_mismatch

package/dist/core/watch-cli.js

@@ -136,7 +136,7 @@ export async function handleWatch() {
             format: formatMatchEval,
         },
     ];
-    console.log(`\n  ${C.cyan}forgen watch${C.reset} — real-time event stream`);
+    console.log(`\n  ${C.cyan}forgen status --live${C.reset} — real-time event stream`);
     console.log(`  ${C.dim}Watching: hook-timing, violations, match-eval-log${C.reset}`);
     console.log(`  ${C.dim}Press Ctrl+C to stop${C.reset}\n`);
     // Show recent events (last 10 per source)