@wooojin/forgen 0.4.1 → 0.4.4

package/dist/host/exec-host.js

@@ -0,0 +1,92 @@
+/**
+ * Host-aware exec — feat/codex-support Phase 2 (P2-2/P2-3 공통)
+ *
+ * compound-extractor + auto-compound-runner 가 *어느 host CLI 로 LLM 호출* 할지
+ * 결정. profile.default_host 우선 + override 가능.
+ *
+ * 출력은 단일 string (agent message) 으로 통일 — caller 가 stdout 파싱 안 해도 됨.
+ *
+ * 호환성: 기존 'claude -p prompt --model haiku' 호출은 default_host 가 'claude' 인
+ * 경우 동일 동작. Codex 메인 사용자는 자동으로 codex exec --json 호출.
+ */
+import { execFileSync } from 'node:child_process';
+import { resolveDefaultHost } from '../store/profile-store.js';
+import { parseCodexJsonlOutput } from './codex-output-parser.js';
+/**
+ * Host 별 기본 timeout. Phase 3 deferred fix:
+ *   - claude -p 는 보통 1~5s 응답이라 30s 충분.
+ *   - codex exec --json 은 cold start + reasoning 모드로 60~90s 정상이라
+ *     30s default 가 false-positive ETIMEDOUT 발생. 90s 마진 필요.
+ *   - 명시 timeout 옵션은 그대로 우선.
+ */
+export const DEFAULT_TIMEOUT_BY_HOST = {
+    claude: 30_000,
+    codex: 90_000,
+};
+/**
+ * 실 host CLI 를 호출하여 prompt 응답 받기.
+ * - claude: `claude -p <prompt> --model <model>`
+ * - codex:  `codex exec --json -s read-only -c approval_policy="never" --ephemeral --skip-git-repo-check <prompt>`
+ *
+ * Codex 호출은 sandbox read-only + approval never + ephemeral 로 *자동 추출 안전성*
+ * 보장 (사용자 환경 미오염). compound-extractor / auto-compound-runner 같은
+ * 백그라운드 학습 호출에 적합.
+ */
+export function execHost(opts) {
+    const resolved = resolveDefaultHost(opts.host);
+    // 'ask' 는 자동 호출 컨텍스트라 명시 fallback. 그러나 Codex-only 사용자가 'ask'
+    // 설정 후 claude 가 PATH 에 없으면 ENOENT 발생 → 명시 안내. (Phase 2 critic fix)
+    const host = resolved === 'codex' ? 'codex' : 'claude';
+    if (resolved === 'ask' && opts.host === undefined) {
+        // 자동 호출에서 'ask' 도달 — caller 가 명시 host 안 줬으므로 default fallback 안내.
+        process.stderr.write('[forgen exec-host] default_host="ask" — auto-call falling back to claude. ' +
+            'If claude CLI is missing, set: forgen config default-host {claude|codex}\n');
+    }
+    const timeout = opts.timeout ?? DEFAULT_TIMEOUT_BY_HOST[host];
+    const baseOpts = {
+        encoding: 'utf-8',
+        timeout,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: opts.cwd,
+        env: { ...process.env, ...(opts.env ?? {}) },
+    };
+    if (host === 'claude') {
+        const args = ['-p', opts.prompt];
+        if (opts.model)
+            args.push('--model', opts.model);
+        const stdout = execFileSync('claude', args, baseOpts);
+        return { message: stdout.toString().trim(), host: 'claude', usage: null };
+    }
+    // host === 'codex'
+    // Phase 2 critic fix: -c approval_policy="never" 의 인용부호는 shell 처리 없이
+    // execFileSync 인자라 codex 가 literal `"never"` 로 받을 위험. quote 제거 + 실측 검증.
+    const args = [
+        'exec',
+        '--json',
+        '-s', 'read-only',
+        '-c', 'approval_policy=never',
+        '--ephemeral',
+        '--skip-git-repo-check',
+        opts.prompt,
+    ];
+    const stdout = execFileSync('codex', args, baseOpts);
+    const parsed = parseCodexJsonlOutput(stdout.toString());
+    return {
+        message: parsed.message,
+        host: 'codex',
+        usage: parsed.usage ? { input_tokens: parsed.usage.input_tokens, output_tokens: parsed.usage.output_tokens } : null,
+    };
+}
+/** 1회 retry — transient 에러(ETIMEDOUT 등) 대응. */
+export function execHostRetry(opts) {
+    try {
+        return execHost(opts);
+    }
+    catch (e) {
+        const code = e?.code;
+        if (code === 'ETIMEDOUT' || code === 'ECONNRESET') {
+            return execHost(opts);
+        }
+        throw e;
+    }
+}

package/dist/host/host-runtime.d.ts

@@ -0,0 +1,37 @@
+/**
+ * HostRuntime — Multi-Host Core Design Phase 2
+ *
+ * `runtime === 'codex'` 분기를 core 에서 제거하기 위한 host-specific 표면 모듈.
+ * spec §3.3 / §5.3 의 비대칭 경계: core 는 Claude semantics 알아도 됨, Codex 표면만 모름.
+ *
+ * 본 모듈이 노출하는 host-specific 표면:
+ *   - launcher binary 이름 (codex / claude)
+ *   - 사용자 표시 라벨 (Codex / Claude)
+ *   - hook command wrapping (Codex 는 codex-adapter 경유)
+ *   - 미설치 시 에러 메시지 (host 별 안내)
+ *
+ * core 측 코드는 본 모듈의 `getHostRuntime(runtime)` 만 호출하여 동작 분기를 위임.
+ */
+import type { RuntimeHost } from '../core/types.js';
+export interface HostRuntime {
+    readonly id: RuntimeHost;
+    /** 사용자에게 노출되는 표시명 (UI 라벨, 로그). */
+    readonly displayName: string;
+    /** 실 실행 binary 이름 또는 절대경로. PATH 에서 찾으면 됨. */
+    readonly launcher: string;
+    /** 미설치 ENOENT 시 사용자에게 노출할 안내. */
+    readonly missingInstallMessage: string;
+    /**
+     * Hook command 래핑.
+     * Claude: `node "${pluginRoot}/${script}" ${args}`
+     * Codex: `node "${pluginRoot}/host/codex-adapter.js" "${pluginRoot}/${script}" ${args}` (sandbox 호환 + projection)
+     */
+    wrapHookCommand(pluginRoot: string, scriptPath: string, args: string): string;
+    /**
+     * settings hook injection strategy.
+     *   - 'generate': generateHooksJson({runtime}) 호출 (Codex 등, host-aware wrapping 필요)
+     *   - 'pre-baked-file': pkgRoot/hooks/hooks.json 읽고 ${CLAUDE_PLUGIN_ROOT} 치환 (Claude — 빌드 산출물 재사용)
+     */
+    readonly hookInjectionStrategy: 'generate' | 'pre-baked-file';
+}
+export declare function getHostRuntime(runtime: RuntimeHost): HostRuntime;

package/dist/host/host-runtime.js

@@ -0,0 +1,51 @@
+/**
+ * HostRuntime — Multi-Host Core Design Phase 2
+ *
+ * `runtime === 'codex'` 분기를 core 에서 제거하기 위한 host-specific 표면 모듈.
+ * spec §3.3 / §5.3 의 비대칭 경계: core 는 Claude semantics 알아도 됨, Codex 표면만 모름.
+ *
+ * 본 모듈이 노출하는 host-specific 표면:
+ *   - launcher binary 이름 (codex / claude)
+ *   - 사용자 표시 라벨 (Codex / Claude)
+ *   - hook command wrapping (Codex 는 codex-adapter 경유)
+ *   - 미설치 시 에러 메시지 (host 별 안내)
+ *
+ * core 측 코드는 본 모듈의 `getHostRuntime(runtime)` 만 호출하여 동작 분기를 위임.
+ */
+function quoteArg(raw) {
+    return `"${raw.replace(/"/g, '\\"')}"`;
+}
+const claudeRuntime = {
+    id: 'claude',
+    displayName: 'Claude',
+    launcher: 'claude',
+    missingInstallMessage: 'Claude Code is not installed. npm install -g @anthropic-ai/claude-code',
+    wrapHookCommand(pluginRoot, scriptPath, args) {
+        const fullScript = `${pluginRoot}/${scriptPath}`;
+        return args ? `node ${quoteArg(fullScript)} ${args}` : `node ${quoteArg(fullScript)}`;
+    },
+    hookInjectionStrategy: 'pre-baked-file',
+};
+const codexRuntime = {
+    id: 'codex',
+    displayName: 'Codex',
+    launcher: 'codex',
+    missingInstallMessage: 'Codex is not installed.',
+    wrapHookCommand(pluginRoot, scriptPath, args) {
+        const adapterPath = `${pluginRoot}/host/codex-adapter.js`;
+        const fullScript = `${pluginRoot}/${scriptPath}`;
+        const base = `node ${quoteArg(adapterPath)} ${quoteArg(fullScript)}`;
+        return args ? `${base} ${args}` : base;
+    },
+    hookInjectionStrategy: 'generate',
+};
+const RUNTIMES = {
+    claude: claudeRuntime,
+    codex: codexRuntime,
+};
+export function getHostRuntime(runtime) {
+    const r = RUNTIMES[runtime];
+    if (!r)
+        throw new Error(`Unknown runtime host: ${runtime}`);
+    return r;
+}

package/dist/host/install-claude.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Claude InstallPlan — feat/codex-support Phase 1 (P1-2)
+ *
+ * `npm install` postinstall.js 의 *Claude 측* 4 작업을 module 로 분리.
+ * `forgen install claude` CLI 가 호출 + (P1-6 에서) postinstall.js 도 위임.
+ *
+ * 4 작업:
+ *   1. Plugin cache: ~/.claude/plugins/cache/forgen-local/forgen/<ver>/ 작성 + installed_plugins.json 등록
+ *   2. Slash commands: ~/.claude/commands/forgen/*.md 생성 (forgen-managed marker)
+ *   3. Settings hooks injection: ~/.claude/settings.json 의 hooks 머지 (forgen entry idempotent)
+ *   4. MCP register: ~/.claude.json 에 mcpServers.forgen-compound 추가
+ *
+ * 사용자 비-forgen 자산 보존 + 재실행 idempotent.
+ */
+export interface ClaudeInstallOptions {
+    pkgRoot: string;
+    /** Override home dir (default: os.homedir()). 격리 테스트용. */
+    homeDir?: string;
+    /** Dry-run: 파일 미작성, 결과만 반환. */
+    dryRun?: boolean;
+    /** MCP forgen-compound 등록 여부 (default true). */
+    registerMcp?: boolean;
+}
+export interface ClaudeInstallResult {
+    homeDir: string;
+    pluginCachePath: string;
+    pluginCacheWritten: boolean;
+    slashCommandsPath: string;
+    slashCommandsCount: number;
+    settingsPath: string;
+    hooksInjected: number;
+    mcpRegistered: boolean;
+    mcpAlreadyPresent: boolean;
+}
+export declare function planClaudeInstall(opts: ClaudeInstallOptions): ClaudeInstallResult;

package/dist/host/install-claude.js

@@ -0,0 +1,238 @@
+/**
+ * Claude InstallPlan — feat/codex-support Phase 1 (P1-2)
+ *
+ * `npm install` postinstall.js 의 *Claude 측* 4 작업을 module 로 분리.
+ * `forgen install claude` CLI 가 호출 + (P1-6 에서) postinstall.js 도 위임.
+ *
+ * 4 작업:
+ *   1. Plugin cache: ~/.claude/plugins/cache/forgen-local/forgen/<ver>/ 작성 + installed_plugins.json 등록
+ *   2. Slash commands: ~/.claude/commands/forgen/*.md 생성 (forgen-managed marker)
+ *   3. Settings hooks injection: ~/.claude/settings.json 의 hooks 머지 (forgen entry idempotent)
+ *   4. MCP register: ~/.claude.json 에 mcpServers.forgen-compound 추가
+ *
+ * 사용자 비-forgen 자산 보존 + 재실행 idempotent.
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { generateHooksJson } from '../hooks/hooks-generator.js';
+const PLUGIN_KEY = 'forgen@forgen-local';
+const FORGEN_MANAGED_MARKER = '<!-- forgen-managed -->';
+function readPkgVersion(pkgRoot) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(pkgRoot, 'package.json'), 'utf-8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+// ── 1. Plugin cache ────────────────────────────────────────────────────
+function writePluginCache(opts) {
+    const { pkgRoot, cacheDir, pluginsDir, version, dryRun } = opts;
+    if (dryRun)
+        return false;
+    const cacheParent = path.dirname(cacheDir);
+    // 이전 잔재 제거 + 디렉토리 작성
+    try {
+        fs.rmSync(cacheParent, { recursive: true, force: true });
+    }
+    catch { /* ignore */ }
+    fs.mkdirSync(cacheParent, { recursive: true });
+    // 1차: symlink 시도 (개발 환경)
+    let linked = false;
+    try {
+        fs.symlinkSync(pkgRoot, cacheDir, 'dir');
+        linked = true;
+    }
+    catch {
+        // symlink 실패 → cp fallback
+    }
+    if (!linked) {
+        fs.mkdirSync(cacheDir, { recursive: true });
+        const copyDirs = ['.claude-plugin', 'hooks', 'skills', 'assets'];
+        for (const dir of copyDirs) {
+            const src = path.join(pkgRoot, dir);
+            if (fs.existsSync(src))
+                fs.cpSync(src, path.join(cacheDir, dir), { recursive: true });
+        }
+        if (fs.existsSync(path.join(pkgRoot, 'dist'))) {
+            fs.cpSync(path.join(pkgRoot, 'dist'), path.join(cacheDir, 'dist'), { recursive: true });
+        }
+        // core deps
+        const coreDeps = ['js-yaml', '@modelcontextprotocol', 'zod'];
+        fs.mkdirSync(path.join(cacheDir, 'node_modules'), { recursive: true });
+        for (const dep of coreDeps) {
+            const depSrc = path.join(pkgRoot, 'node_modules', dep);
+            if (fs.existsSync(depSrc)) {
+                fs.cpSync(depSrc, path.join(cacheDir, 'node_modules', dep), { recursive: true });
+            }
+        }
+    }
+    // installed_plugins.json 등록
+    const installedPath = path.join(pluginsDir, 'installed_plugins.json');
+    let installed = { version: 2, plugins: {} };
+    if (fs.existsSync(installedPath)) {
+        try {
+            installed = JSON.parse(fs.readFileSync(installedPath, 'utf-8'));
+        }
+        catch { /* ignore */ }
+    }
+    installed.plugins = installed.plugins ?? {};
+    installed.plugins[PLUGIN_KEY] = [{
+            scope: 'user',
+            installPath: cacheDir,
+            version,
+            installedAt: new Date().toISOString(),
+            lastUpdated: new Date().toISOString(),
+        }];
+    fs.mkdirSync(pluginsDir, { recursive: true });
+    fs.writeFileSync(installedPath, `${JSON.stringify(installed, null, 2)}\n`);
+    return true;
+}
+// ── 2. Slash commands ──────────────────────────────────────────────────
+function writeSlashCommands(opts) {
+    const { pkgRoot, targetDir, dryRun } = opts;
+    const sourceDir = path.join(pkgRoot, 'assets', 'claude', 'commands');
+    if (!fs.existsSync(sourceDir))
+        return 0;
+    if (dryRun) {
+        return fs.readdirSync(sourceDir).filter((f) => f.endsWith('.md')).length;
+    }
+    fs.mkdirSync(targetDir, { recursive: true });
+    let count = 0;
+    for (const file of fs.readdirSync(sourceDir).filter((f) => f.endsWith('.md'))) {
+        const skillContent = fs.readFileSync(path.join(sourceDir, file), 'utf-8');
+        const descMatch = skillContent.match(/description:\s*(.+)/);
+        const desc = descMatch?.[1]?.trim() ?? file.replace(/\.md$/, '');
+        const skillName = file.replace(/\.md$/, '');
+        const out = `# ${desc}\n\n${FORGEN_MANAGED_MARKER}\n\nActivate Forgen "${skillName}" mode for the task: $ARGUMENTS\n\n${skillContent}`;
+        const target = path.join(targetDir, file);
+        if (fs.existsSync(target)) {
+            const existing = fs.readFileSync(target, 'utf-8');
+            if (!existing.includes(FORGEN_MANAGED_MARKER))
+                continue; // 사용자 작성 — skip
+        }
+        fs.writeFileSync(target, out);
+        count += 1;
+    }
+    return count;
+}
+// ── 3. Settings hooks injection ────────────────────────────────────────
+function injectHooksIntoSettings(opts) {
+    const { pkgRoot, settingsPath, dryRun } = opts;
+    // settings.json 컨텍스트는 ${CLAUDE_PLUGIN_ROOT} 미해석 — 절대 경로 박제 (postinstall.js 와 동일 노하우)
+    const generated = generateHooksJson({
+        pluginRoot: path.join(pkgRoot, 'dist'),
+        runtime: 'claude',
+        releaseMode: true,
+    });
+    let count = 0;
+    for (const events of Object.values(generated.hooks)) {
+        for (const group of events) {
+            const g = group;
+            if (Array.isArray(g.hooks))
+                count += g.hooks.length;
+        }
+    }
+    if (dryRun)
+        return count;
+    let settings = {};
+    if (fs.existsSync(settingsPath)) {
+        try {
+            settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        }
+        catch { /* fallthrough */ }
+    }
+    const hooksConfig = settings.hooks ?? {};
+    // 기존 forgen hook 제거 (path 에 pkgRoot 또는 CLAUDE_PLUGIN_ROOT 포함된 entry)
+    for (const [event, entries] of Object.entries(hooksConfig)) {
+        if (!Array.isArray(entries))
+            continue;
+        const filtered = entries.filter((entry) => {
+            const e = entry;
+            if (!Array.isArray(e.hooks))
+                return true;
+            // forgen-managed entry 식별: pkgRoot 또는 CLAUDE_PLUGIN_ROOT 또는 'forgen' 포함
+            return !e.hooks.some((h) => typeof h.command === 'string' &&
+                (h.command.includes(pkgRoot) || h.command.includes('CLAUDE_PLUGIN_ROOT') || h.command.includes('/forgen-local/forgen/')));
+        });
+        if (filtered.length === 0)
+            delete hooksConfig[event];
+        else
+            hooksConfig[event] = filtered;
+    }
+    // forgen 측 entry 추가
+    for (const [event, entries] of Object.entries(generated.hooks)) {
+        if (!hooksConfig[event])
+            hooksConfig[event] = [];
+        hooksConfig[event].push(...entries);
+    }
+    settings.hooks = hooksConfig;
+    // enabledPlugins 등록
+    const enabled = settings.enabledPlugins ?? {};
+    enabled[PLUGIN_KEY] = true;
+    settings.enabledPlugins = enabled;
+    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+    fs.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
+    return count;
+}
+function registerMcpInClaudeJson(opts) {
+    const { pkgRoot, claudeJsonPath, dryRun } = opts;
+    const serverPath = path.join(pkgRoot, 'dist', 'mcp', 'server.js');
+    const desired = { command: 'node', args: [serverPath] };
+    let claudeJson = {};
+    if (fs.existsSync(claudeJsonPath)) {
+        try {
+            claudeJson = JSON.parse(fs.readFileSync(claudeJsonPath, 'utf-8'));
+        }
+        catch { /* ignore */ }
+    }
+    const mcpServers = claudeJson.mcpServers ?? {};
+    const existing = mcpServers['forgen-compound'];
+    const alreadyPresent = existing !== undefined &&
+        existing.command === 'node' &&
+        Array.isArray(existing.args) &&
+        JSON.stringify(existing.args) === JSON.stringify(desired.args);
+    if (dryRun) {
+        return { registered: !alreadyPresent, alreadyPresent };
+    }
+    mcpServers['forgen-compound'] = desired;
+    claudeJson.mcpServers = mcpServers;
+    fs.mkdirSync(path.dirname(claudeJsonPath), { recursive: true });
+    fs.writeFileSync(claudeJsonPath, `${JSON.stringify(claudeJson, null, 2)}\n`);
+    return { registered: !alreadyPresent, alreadyPresent };
+}
+// ── public ─────────────────────────────────────────────────────────────
+export function planClaudeInstall(opts) {
+    if (!opts.pkgRoot || !fs.existsSync(opts.pkgRoot)) {
+        throw new Error(`planClaudeInstall: invalid pkgRoot ${opts.pkgRoot}`);
+    }
+    const homeDir = opts.homeDir ?? os.homedir();
+    const dryRun = opts.dryRun ?? false;
+    const registerMcp = opts.registerMcp ?? true;
+    const version = readPkgVersion(opts.pkgRoot);
+    const claudeDir = path.join(homeDir, '.claude');
+    const pluginsDir = path.join(claudeDir, 'plugins');
+    const cacheDir = path.join(pluginsDir, 'cache', 'forgen-local', 'forgen', version);
+    const slashCommandsDir = path.join(claudeDir, 'commands', 'forgen');
+    const settingsPath = path.join(claudeDir, 'settings.json');
+    const claudeJsonPath = path.join(homeDir, '.claude.json');
+    const pluginCacheWritten = writePluginCache({ pkgRoot: opts.pkgRoot, cacheDir, pluginsDir, version, dryRun });
+    const slashCommandsCount = writeSlashCommands({ pkgRoot: opts.pkgRoot, targetDir: slashCommandsDir, dryRun });
+    const hooksInjected = injectHooksIntoSettings({ pkgRoot: opts.pkgRoot, settingsPath, dryRun });
+    const mcp = registerMcp
+        ? registerMcpInClaudeJson({ pkgRoot: opts.pkgRoot, claudeJsonPath, dryRun })
+        : { registered: false, alreadyPresent: false };
+    return {
+        homeDir,
+        pluginCachePath: cacheDir,
+        pluginCacheWritten,
+        slashCommandsPath: slashCommandsDir,
+        slashCommandsCount,
+        settingsPath,
+        hooksInjected,
+        mcpRegistered: mcp.registered,
+        mcpAlreadyPresent: mcp.alreadyPresent,
+    };
+}

package/dist/host/install-codex.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Codex InstallPlan — Multi-Host Core Design §10 우선순위 3
+ *
+ * `~/.codex/hooks.json` 에 forgen hook 등록(절대경로, idempotent), `~/.codex/config.toml`
+ * 에 forgen-compound MCP 등록(managed marker block). $CODEX_HOME 환경변수 존중.
+ *
+ * 동작 원칙:
+ * - hook 등록은 generateHooksJson({runtime:'codex', pluginRoot, releaseMode}) 결과를 그대로 사용
+ *   — 이미 codex-adapter wrapper + 절대경로 적용됨 (spec §18.5 결정 옵션 1).
+ * - 사용자가 직접 작성한 비-forgen hook 은 보존 (`isForgenHookEntry` pattern).
+ * - MCP 등록은 TOML 라이브러리 없이 marker block 으로 idempotent 관리.
+ * - dryRun 시 파일을 쓰지 않고 결과만 반환 (테스트 + preview 용).
+ */
+export interface CodexInstallOptions {
+    /** forgen package root (build 산출물 dist/ 의 부모). 기본: 호출 시 process.cwd(). */
+    pkgRoot: string;
+    /** codex home (default: $CODEX_HOME ?? ~/.codex). */
+    codexHome?: string;
+    /** dry-run: 파일 미작성, 결과만 반환. */
+    dryRun?: boolean;
+    /** MCP 서버 등록 여부 (default true). */
+    registerMcp?: boolean;
+    /** hooks-generator releaseMode (default true: 환경 독립). */
+    releaseMode?: boolean;
+    /** AGENTS.md 위치 override (default: pkgRoot 기준 자동 resolve). 격리 테스트용. */
+    agentsMdPath?: string;
+}
+export interface CodexInstallResult {
+    codexHome: string;
+    hooksPath: string;
+    hooksWritten: boolean;
+    hooksCount: number;
+    preservedUserHookCount: number;
+    configTomlPath: string;
+    mcpRegistered: boolean;
+    mcpAlreadyPresent: boolean;
+    /** P3-3 (US-013): Codex skills/ 에 install 된 forgen 명령 수 */
+    skillsInstalled: number;
+    skillsPath: string;
+    /** P3-3: AGENTS.md (cwd) 에 forgen rule block 인젝션 여부 */
+    agentsMdPath: string;
+    agentsMdInjected: boolean;
+}
+export declare function planCodexInstall(opts: CodexInstallOptions): CodexInstallResult;