@wooojin/forgen 0.4.13 → 0.5.0

package/dist/core/drift-score.d.ts

@@ -20,6 +20,8 @@ export interface DriftState {
     lastWarningAt: number;
     lastCriticalAt: number;
     hardCapReached: boolean;
+    /** 최근 hardcap 발화 timestamp (쿨다운용, ADR-013). */
+    lastHardcapAt?: number;
 }
 export interface DriftResult {
     level: 'normal' | 'warning' | 'critical' | 'hardcap';

package/dist/core/drift-score.js

@@ -54,9 +54,17 @@ export function evaluateDrift(state, isEdit, isRevert, thresholds = {}) {
     // Calculate drift score: edit rate 65% + revert rate 35%
     const rawScore = (state.ewmaEditRate * 65) + (state.ewmaRevertRate * 35);
     const score = Math.min(100, Math.max(0, Math.round(rawScore)));
-    // Hard cap
+    // Hard cap — ADR-013 버그수정: 이전엔 cooldown 이 없어 50편집 넘으면 **매 편집마다**
+    // hardcap(=drift_critical) 을 발화 → drift_critical 이 세션길이 카운터로 전락(2067/2100
+    // 이벤트가 score100). critical 처럼 cooldown 게이트를 둬 반복 발화를 억제. 상태
+    // (hardCapReached)는 항상 갱신하되, message 는 쿨다운 밖에서만 낸다(null=emitter skip).
     if (state.totalEdits >= t.hardCapEdits) {
         state.hardCapReached = true;
+        const withinCooldown = now - (state.lastHardcapAt ?? 0) <= t.criticalCooldownMs;
+        if (withinCooldown) {
+            return { level: 'hardcap', score: 100, message: null };
+        }
+        state.lastHardcapAt = now;
         return {
             level: 'hardcap',
             score: 100,

package/dist/core/harness.js

@@ -17,10 +17,13 @@ import { buildEnv, generateClaudeRuleFiles, registerTmuxBindings } from './confi
 import { createLogger } from './logger.js';
 import { HANDOFFS_DIR, ME_BEHAVIOR, ME_DIR, ME_RULES, ME_SKILLS, ME_SOLUTIONS, SESSIONS_DIR, STATE_DIR, FORGEN_HOME } from './paths.js';
 import { RULE_FILE_CAPS } from '../hooks/shared/injection-caps.js';
+import { recordRenderedFiles } from './rendered-rules-manifest.js';
 import { rollbackSettings, } from './settings-lock.js';
 import { bootstrapV1Session, ensureV1Directories } from './v1-bootstrap.js';
 import { injectSettings } from './settings-injector.js';
 import { installAgents, installSlashCommands } from './installer.js';
+import { getHostCapabilities } from '../host/capabilities-registry.js';
+import { getProjection } from '../host/projection.js';
 const log = createLogger('harness');
 /**
  * 0.4.6 — Codex hooks fast staleness check + auto-reconcile.
@@ -108,11 +111,10 @@ export { rollbackSettings };
 function injectClaudeRuleFiles(cwd, ruleFiles) {
     const PER_RULE_CAP = RULE_FILE_CAPS.perRuleFile;
     const TOTAL_CAP = RULE_FILE_CAPS.totalRuleFiles;
-    const globalRulesDir = path.join(os.homedir(), '.claude', 'rules');
     const projectRulesDir = path.join(cwd, '.claude', 'rules');
-    fs.mkdirSync(globalRulesDir, { recursive: true });
     fs.mkdirSync(projectRulesDir, { recursive: true });
     let totalWritten = 0;
+    const writtenForManifest = {};
     for (const [filename, content] of Object.entries(ruleFiles)) {
         const capped = content.length > PER_RULE_CAP
             ? `${content.slice(0, PER_RULE_CAP)}\n... (capped at rule file limit)\n`
@@ -121,11 +123,35 @@ function injectClaudeRuleFiles(cwd, ruleFiles) {
             log.debug(`rules/ 총량 캡 도달, ${filename} 생략`);
             break;
         }
-        const isUserPreference = filename.startsWith('forge-');
-        const targetDir = isUserPreference ? globalRulesDir : projectRulesDir;
-        fs.writeFileSync(path.join(targetDir, filename), capped);
+        // ADR-010 W1-3 (F6 수정): 모든 규칙 파일은 프로젝트 스코프로만 주입한다.
+        // 이전에는 `forge-*` 파일명이 글로벌 ~/.claude/rules/ 로 라우팅되어
+        // 프로젝트 맥락의 behavioral 패턴이 전 프로젝트 세션에 주입됐다.
+        // 목표 상태: 글로벌 rules 디렉토리에 forgen 산출물 0개.
+        const target = path.join(projectRulesDir, filename);
+        fs.writeFileSync(target, capped);
+        writtenForManifest[target] = capped;
         totalWritten += capped.length;
     }
+    // ADR-010 W1-1: 쓴 그대로의 content-hash 를 manifest 에 기록 —
+    // reclaimer 가 "forgen 산출물 그대로"와 "사용자 편집본"을 구분하는 근거.
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(getPackageRoot(), 'package.json'), 'utf-8'));
+        recordRenderedFiles(writtenForManifest, String(pkg.version ?? '0.0.0'));
+    }
+    catch (e) {
+        log.debug('rendered-rules manifest 기록 실패 (fail-open)', e);
+    }
+    // 마이그레이션 (W1-3): 구버전이 글로벌에 쓴 forge-behavioral.md 회수.
+    // (tenetx 계열 글로벌 잔재는 W1-1 reclaimer 의 영역)
+    const legacyGlobalBehavioral = path.join(os.homedir(), '.claude', 'rules', 'forge-behavioral.md');
+    if (fs.existsSync(legacyGlobalBehavioral)) {
+        try {
+            fs.unlinkSync(legacyGlobalBehavioral);
+        }
+        catch (e) {
+            log.debug('레거시 글로벌 behavioral 삭제 실패', e);
+        }
+    }
     // 마이그레이션: 이전 위치 파일 제거
     const legacyPath = path.join(cwd, '.claude', 'compound-rules.md');
     if (fs.existsSync(legacyPath)) {
@@ -333,6 +359,81 @@ function checkCompoundStaleness() {
         log.debug('Staleness check failed (non-fatal)', e);
     }
 }
+// ── Host Bindings (Multi-Harness Adapter Plan P0 — 구 if-ladder 대체) ──
+/**
+ * Claude 세션 준비: settings.json 인젝션 + 에이전트 설치 + 규칙 파일 생성/주입 +
+ * 슬래시 명령 설치. (구 `if (runtime === 'claude')` 분기, 동작 동일.)
+ */
+async function prepareClaudeSession(ctx) {
+    const { cwd, pkgRoot, env, v1Result } = ctx;
+    try {
+        injectSettings(env, v1Result, 'claude', cwd, pkgRoot);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (msg.includes('settings.json lock') || msg.includes('SettingsLockError')) {
+            console.error(`[forgen] ${msg} — settings 갱신 스킵, 이전 값 유지`);
+        }
+        else {
+            throw e;
+        }
+    }
+    installAgents(cwd, pkgRoot);
+    const ruleFiles = generateClaudeRuleFiles(cwd, v1Result.renderedRules);
+    injectClaudeRuleFiles(cwd, ruleFiles);
+    installSlashCommands(cwd, pkgRoot);
+}
+/**
+ * Codex 세션 준비: hooks.json 자동 reconcile-on-launch.
+ * (구 `else if (runtime === 'codex')` 분기, 동작 동일.)
+ */
+async function prepareCodexSession(ctx) {
+    try {
+        await ensureCodexHooksFresh(ctx.pkgRoot);
+    }
+    catch (e) {
+        log.debug('Codex hooks reconcile 실패 (fail-open)', e);
+    }
+}
+/**
+ * OpenCode 세션 준비. OpenCode 는 in-process plugin 형태라, 세션 준비 시점의 host-specific
+ * artifact wiring 이 없다 — plugin 배포는 `forgen install opencode`(install-opencode)가
+ * 수행하고, OpenCode 가 세션마다 plugin 을 자동 로드한다. 따라서 여기선 no-op.
+ * (subprocess projection 은 OpenCode 의 plugin 모델과 무관 — projection.ts 스텁 유지.)
+ */
+async function prepareOpencodeSession(_ctx) {
+    // no-op: plugin 은 install-opencode 가 배포, OpenCode 가 자동 로드.
+}
+/**
+ * capabilities 선언 + projection 함수 + 세션 준비(hook-surface wiring)를 host 별로
+ * 묶은 registry. `Record<HostId, HostBinding>` 이 완전성을 강제하므로 새 host 추가 시
+ * (예: OpenCode, P1) 엔트리 누락은 컴파일 타임에 걸린다.
+ *
+ * capabilities/projection 은 현재 prepareHarness 자체가 소비하지 않지만(각각
+ * capabilities-registry.ts / parity-harness.ts 가 독립 소비), HostBinding 계약의
+ * 일부로 함께 선언해 두어 향후 확장(§4.1 P1) 시 registry 엔트리 하나만 추가하면
+ * 되는 형태를 만든다.
+ */
+const HOST_BINDINGS = {
+    claude: {
+        id: 'claude',
+        capabilities: getHostCapabilities('claude'),
+        projection: getProjection('claude'),
+        prepareSession: prepareClaudeSession,
+    },
+    codex: {
+        id: 'codex',
+        capabilities: getHostCapabilities('codex'),
+        projection: getProjection('codex'),
+        prepareSession: prepareCodexSession,
+    },
+    opencode: {
+        id: 'opencode',
+        capabilities: getHostCapabilities('opencode'),
+        projection: getProjection('opencode'),
+        prepareSession: prepareOpencodeSession,
+    },
+};
 export async function prepareHarness(cwd, options = {}) {
     const runtime = options.runtime ?? 'claude';
     try {
@@ -343,7 +444,7 @@ export async function prepareHarness(cwd, options = {}) {
         // 2. v1 Session Bootstrap (legacy 감지 → profile 로드 → preset 합성 → rule 렌더)
         const v1Result = bootstrapV1Session();
         if (v1Result.needsOnboarding) {
-            log.debug('v1: 온보딩 필요 — forgen onboarding 실행 안내');
+            log.debug('v1: 온보딩 필요 — forgen forge --onboarding 실행 안내');
         }
         if (v1Result.legacyBackupPath) {
             log.debug(`v1: 레거시 프로필 백업 완료 → ${v1Result.legacyBackupPath}`);
@@ -378,48 +479,19 @@ export async function prepareHarness(cwd, options = {}) {
         }
         // 3. 환경 확인
         const inTmux = !!process.env.TMUX;
-        // 4-7. Claude artifact 작업 (settings.json + agents + rules + slash commands).
+        // 4-7. Host artifact 작업 (Claude: settings.json + agents + rules + slash commands.
+        // Codex: hooks.json reconcile). HOST_BINDINGS 로 dispatch — host 별 구체 동작은
+        // prepareClaudeSession / prepareCodexSession 참조.
         //
         // feat/codex-support P1-7 (2026-04-27): runtime === 'codex' 시 *.claude/* 계열
         // 작업은 *no-op*. Codex 측 동치 prep 은 Phase 3 (install-codex.ts 의 prompts +
-        // AGENTS.md inject) 에서 처리. 본 분기는 *Claude artifact 가 Codex 환경을
-        // 오염시키지 않도록* 보호하는 비대칭 게이트.
+        // AGENTS.md inject) 에서 처리. 본 dispatch 는 *Claude artifact 가 Codex 환경을
+        // 오염시키지 않도록* 보호하는 비대칭 게이트를 그대로 보존한다.
         const pkgRoot = getPackageRoot();
         const env = buildEnv(cwd, v1Result.session?.session_id, runtime);
-        if (runtime === 'claude') {
-            // 4. settings.json 인젝션
-            try {
-                injectSettings(env, v1Result, runtime, cwd, pkgRoot);
-            }
-            catch (e) {
-                const msg = e instanceof Error ? e.message : String(e);
-                if (msg.includes('settings.json lock') || msg.includes('SettingsLockError')) {
-                    console.error(`[forgen] ${msg} — settings 갱신 스킵, 이전 값 유지`);
-                }
-                else {
-                    throw e;
-                }
-            }
-            // 5. 에이전트 설치
-            installAgents(cwd, pkgRoot);
-            // 6. 규칙 파일 생성 + 주입
-            const ruleFiles = generateClaudeRuleFiles(cwd, v1Result.renderedRules);
-            injectClaudeRuleFiles(cwd, ruleFiles);
-            // 7. 슬래시 명령 설치
-            installSlashCommands(cwd, pkgRoot);
-        }
-        else if (runtime === 'codex') {
-            // 0.4.6 — Codex hooks 자동 reconcile-on-launch.
-            // 매 fgx --codex / forgen --runtime codex 호출 시 hooks.json 의 forgen entry 가
-            // 현재 pkgRoot 와 일치하는지 fast check. 불일치 (다른 머신/버전 install,
-            // pkg path 변경, 신규 설치) → silent reinstall.
-            // 사용자가 `forgen install codex` 를 명시 호출 안 해도 매번 정합성 보장.
-            try {
-                await ensureCodexHooksFresh(pkgRoot);
-            }
-            catch (e) {
-                log.debug('Codex hooks reconcile 실패 (fail-open)', e);
-            }
+        const binding = HOST_BINDINGS[runtime];
+        if (binding) {
+            await binding.prepareSession({ cwd, pkgRoot, env, v1Result });
         }
         else {
             log.debug(`prepareHarness: runtime=${runtime} — artifact prep skipped`);

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

@@ -20,4 +20,6 @@ export interface HealthScore {
     grade: 'A' | 'B' | 'C' | 'D' | 'F';
 }
 export declare function computeHealth(): HealthScore;
+/** 한 줄 health 요약 — `forgen status` 요약 헤더에서 재사용. */
+export declare function renderHealthLine(h: HealthScore): string;
 export declare function handleHealth(): Promise<void>;

package/dist/core/health-cli.js

@@ -71,11 +71,16 @@ function bar(value, max, width = 10) {
     const filled = Math.round((value / max) * width);
     return '█'.repeat(Math.max(0, filled)) + '░'.repeat(Math.max(0, width - filled));
 }
+/** 한 줄 health 요약 — `forgen status` 요약 헤더에서 재사용. */
+export function renderHealthLine(h) {
+    const gc = gradeColor(h.grade);
+    return `\n  ${C.bold}forgen status${C.reset}  ${gc}${C.bold}${h.grade}${C.reset}  ${gc}${h.total}/100${C.reset}`;
+}
 export async function handleHealth() {
     const h = computeHealth();
     const gc = gradeColor(h.grade);
     console.log('');
-    console.log(`  ${C.bold}forgen health${C.reset}  ${gc}${C.bold}${h.grade}${C.reset}  ${gc}${h.total}/100${C.reset}`);
+    console.log(`  ${C.bold}forgen status${C.reset}  ${gc}${C.bold}${h.grade}${C.reset}  ${gc}${h.total}/100${C.reset}`);
     console.log('');
     console.log(`    Utilization    ${bar(h.components.utilization, 30)}  ${h.components.utilization}/30   ${C.dim}solution match rate (7d)${C.reset}`);
     console.log(`    Effectiveness  ${bar(h.components.effectiveness, 25)}  ${h.components.effectiveness}/25   ${C.dim}block→ack ratio${C.reset}`);

package/dist/core/host-detect.d.ts

@@ -34,7 +34,9 @@ export interface HostAvailability {
 export interface HostDetectionResult {
     readonly claude: HostAvailability;
     readonly codex: HostAvailability;
-    /** 둘 다 사용 가능. */
+    /** OpenCode (W3-3 P1) — 감지 전용. 설치는 plugin 슬림 착지 후. */
+    readonly opencode: HostAvailability;
+    /** claude+codex 둘 다 사용 가능 (기존 primary-pair 계약). */
     readonly bothAvailable: boolean;
     /** 하나도 사용 가능하지 않음 (warn). */
     readonly noneAvailable: boolean;

package/dist/core/host-detect.js

@@ -56,13 +56,38 @@ function detectCodex() {
         available: binaryFound || homeExists,
     };
 }
+/**
+ * OpenCode 감지 (W3-3 P1 파운데이션). OpenCode 는 XDG 관습을 따라 `~/.config/opencode/`
+ * 를 쓴다(`~/.opencode` 아님). binary 는 `opencode`. auth 패턴은 별도 확인 안 함.
+ * 감지만 — 설치(plugin 슬림)는 P1 후속이라 install-orchestrator 에서 "detected, install pending"
+ * 로만 표기한다.
+ */
+function detectOpencode() {
+    const binaryPath = which('opencode');
+    const homePath = path.join(os.homedir(), '.config', 'opencode');
+    const homeExists = fs.existsSync(homePath);
+    const binaryFound = binaryPath !== null;
+    return {
+        host: 'opencode',
+        binaryFound,
+        binaryPath,
+        homeExists,
+        homePath,
+        authPresent: null,
+        available: binaryFound || homeExists,
+    };
+}
 export function detectAvailableHosts() {
     const claude = detectClaude();
     const codex = detectCodex();
+    const opencode = detectOpencode();
     return {
         claude,
         codex,
+        opencode,
+        // bothAvailable 는 기존 계약(claude+codex primary pair) 유지. noneAvailable 은
+        // opencode 까지 포함해 "어떤 host 도 없음" 을 정확히 반영.
         bothAvailable: claude.available && codex.available,
-        noneAvailable: !claude.available && !codex.available,
+        noneAvailable: !claude.available && !codex.available && !opencode.available,
     };
 }

package/dist/core/migrate-cli.js

@@ -19,6 +19,10 @@ const HELP = `
     forgen migrate evidence-host       behavior/*.json 에 host 필드 백필
       --dry-run                          디스크 미수정, 카운트만 출력
       --default-host <claude|codex>      host 기본값 (default: claude)
+    forgen migrate tenetx              tenetx/legacy 규칙 스프롤 회수 (ADR-010 W1-1)
+      --dry-run                          회수 대상만 표시
+      --yes                              marker-only(사용자 편집 가능성) 파일도 회수
+      --apply-settings                   settings.json/registry 의 tenetx 항목 제거
     forgen migrate --help              이 도움말
 `;
 export async function handleMigrate(args) {
@@ -47,6 +51,17 @@ export async function handleMigrate(args) {
         console.log(`[forgen] migrated: ${result.migrated} (skipped: ${result.skipped}, total: ${result.total})${label}`);
         return;
     }
+    if (sub === 'tenetx') {
+        const { runReclaim, printReclaimResult } = await import('./migrate-tenetx.js');
+        const result = runReclaim({
+            cwd: process.cwd(),
+            dryRun: args.includes('--dry-run'),
+            yes: args.includes('--yes'),
+            applySettings: args.includes('--apply-settings'),
+        });
+        printReclaimResult(result);
+        return;
+    }
     console.error(`[forgen migrate] unknown target: ${sub}`);
     console.error(HELP);
     process.exit(1);

package/dist/core/migrate-evidence-host.d.ts

@@ -8,9 +8,10 @@
  * loadEvidence 의 자동 backfill (evidence-store.ts::backfillHost) 과는 독립.
  * 이 모듈은 디스크 파일을 직접 수정하는 명시적 경로.
  */
+import type { HostId } from './trust-layer-intent.js';
 export interface MigrateEvidenceHostOptions {
     /** backfill 할 host 값 (host 필드 없는 파일에만 적용) */
-    defaultHost: 'claude' | 'codex';
+    defaultHost: HostId;
     /**
      * true 이면 디스크를 수정하지 않고 카운트만 반환.
      * @default false

package/dist/core/migrate-tenetx.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 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 명시 동의 시에만.
+ */
+export type ReclaimReason = 'manifest-hash' | 'provenance-marker';
+export interface ReclaimCandidate {
+    path: string;
+    reason: ReclaimReason;
+}
+export interface ReclaimScan {
+    /** (a) 무프롬프트 삭제 가능 — forgen 이 쓴 그대로 */
+    removable: ReclaimCandidate[];
+    /** (b) 마커는 있으나 hash 불일치 — --yes 필요 */
+    needsConfirm: ReclaimCandidate[];
+    /** settings/registry 의 tenetx 흔적 (사람이 읽는 설명) */
+    settingsFindings: string[];
+}
+export interface ReclaimOptions {
+    cwd: string;
+    home?: string;
+    dryRun?: boolean;
+    /** marker-only(b) 항목도 삭제에 포함 */
+    yes?: boolean;
+    /** settings.json / installed_plugins.json 에서 tenetx 항목 직접 제거 */
+    applySettings?: boolean;
+}
+export interface ReclaimResult {
+    removed: string[];
+    skippedNeedsConfirm: string[];
+    settingsFindings: string[];
+    settingsApplied: boolean;
+    backupDir: string | null;
+    dryRun: boolean;
+}
+export declare function hasProvenanceMarker(content: string): boolean;
+/** 스캔만 — 디스크 수정 없음. doctor --reclaim 이 그대로 사용. */
+export declare function scanReclaimables(cwd: string, home?: string): ReclaimScan;
+export declare function runReclaim(opts: ReclaimOptions): ReclaimResult;
+export declare function printReclaimResult(r: ReclaimResult): void;