@wooojin/forgen 0.5.5 → 0.5.7

package/dist/core/uninstall.js

@@ -2,6 +2,8 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import * as readline from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import { hasManagedSkillMarker, listDevGuideSkillNames, removeSkillFile } from '../host/managed-marker.js';
 import { SETTINGS_PATH, acquireLock, releaseLock, atomicWriteFileSync, } from './settings-lock.js';
 /** 플러그인 제거 (plugin-installer.ts 삭제 후 인라인) */
 function uninstallPlugin() {
@@ -96,6 +98,65 @@ function cleanSlashCommands() {
         console.log('  - No forgen-managed slash commands found');
     }
 }
+/** ADR-016 D3 — ~/.claude/skills/verify 제거 (forgen-managed 마커가 있는 것만; 사용자 스킬은 보존) */
+export function cleanVerifySkill(homeDir = os.homedir()) {
+    const dir = path.join(homeDir, '.claude', 'skills', 'verify');
+    const file = path.join(dir, 'SKILL.md');
+    try {
+        if (fs.lstatSync(dir).isSymbolicLink() || fs.lstatSync(file).isSymbolicLink())
+            return false;
+        if (!hasManagedSkillMarker(fs.readFileSync(file, 'utf-8')))
+            return false;
+        fs.unlinkSync(file);
+        try {
+            if (fs.readdirSync(dir).length === 0)
+                fs.rmdirSync(dir);
+        }
+        catch { /* ignore */ }
+        return true;
+    }
+    catch {
+        return false; // 없음
+    }
+}
+/**
+ * ADR-016 D4 — `~/.claude/skills/forgen-<stack>-<skill>/` dev-guide 스킬 제거.
+ * 패키지가 실제로 제공하는 이름만 지운다 (사용자가 만든 `forgen-react-mine` 같은 스킬은 보존).
+ */
+export function cleanDevGuideSkills(pkgRoot, homeDir = os.homedir()) {
+    const skillsDir = path.join(homeDir, '.claude', 'skills');
+    let removed = 0;
+    for (const name of listDevGuideSkillNames(pkgRoot)) {
+        if (removeSkillFile(skillsDir, name, false))
+            removed += 1;
+    }
+    return removed;
+}
+/**
+ * ADR-016 D4 — `~/.claude.json` 의 `mcpServers["forgen-compound"]` 제거. install 은 settings.json 이 아니라
+ * 여기에 등록하는데 uninstall 은 settings.json 만 정리하고 있었다. forgen 서버 경로를 가리킬 때만 지운다.
+ */
+export function cleanClaudeJsonMcp(homeDir = os.homedir()) {
+    const claudeJsonPath = path.join(homeDir, '.claude.json');
+    try {
+        const data = JSON.parse(fs.readFileSync(claudeJsonPath, 'utf-8'));
+        const entry = data.mcpServers?.['forgen-compound'];
+        if (!entry)
+            return false;
+        const args = Array.isArray(entry.args) ? entry.args : [];
+        const isForgenServer = args.some((a) => typeof a === 'string' && /[\\/]dist[\\/]mcp[\\/]server\.js$/.test(a));
+        if (!isForgenServer)
+            return false; // 사용자가 같은 이름으로 다른 서버를 등록
+        delete data.mcpServers?.['forgen-compound'];
+        if (data.mcpServers && Object.keys(data.mcpServers).length === 0)
+            delete data.mcpServers;
+        atomicWriteFileSync(claudeJsonPath, `${JSON.stringify(data, null, 2)}\n`);
+        return true;
+    }
+    catch {
+        return false; // 파일 없음 / 파싱 실패 — 건드리지 않는다
+    }
+}
 /** 사용자에게 y/n 확인 */
 function confirm(message) {
     return new Promise((resolve) => {
@@ -301,10 +362,11 @@ export async function handleUninstall(cwd, options) {
     console.log('  2. Delete .claude/agents/ch-*.md agent files');
     console.log('  3. Delete .claude/rules/ rule files (project-context, routing, forge-*)');
     console.log('  4. Remove forgen block from CLAUDE.md');
-    console.log('  5. Remove slash commands (~/.claude/commands/forgen/)');
-    console.log('  6. Remove plugin artifacts (cache, installed_plugins.json, plugin directory)');
+    console.log('  5. Remove slash commands (~/.claude/commands/forgen/) and the forgen-managed verify skill (~/.claude/skills/verify/)');
+    console.log('  6. Remove plugin artifacts (cache, installed_plugins.json, plugin directory), dev-guide skills, and the forgen-compound MCP entry in ~/.claude.json');
+    console.log('  7. Codex (if $CODEX_HOME or ~/.codex exists): forgen hooks in hooks.json, the MCP/notify blocks in config.toml, forgen skills, ch-*.toml agents, and the AGENTS.md block — hooks and files from other tools are kept');
     if (options.purge) {
-        console.log('  7. --purge: Delete ~/.forgen/ entirely (rules, me/, state/, solutions/, behavior/)');
+        console.log('  8. --purge: Delete ~/.forgen/ entirely (rules, me/, state/, solutions/, behavior/)');
         console.log('     WARNING: this erases all accumulated corrections, rules, drift, and lifecycle history.');
     }
     else {
@@ -330,6 +392,23 @@ export async function handleUninstall(cwd, options) {
     cleanCompoundRules(cwd);
     cleanClaudeMd(cwd);
     cleanSlashCommands();
+    if (cleanVerifySkill())
+        console.log('  ✓ Removed forgen verify skill (~/.claude/skills/verify/)');
+    const pkgRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+    const devGuide = cleanDevGuideSkills(pkgRoot);
+    if (devGuide > 0)
+        console.log(`  ✓ Removed ${devGuide} dev-guide skill(s) (~/.claude/skills/forgen-*)`);
+    if (cleanClaudeJsonMcp())
+        console.log('  ✓ Removed forgen-compound MCP server from ~/.claude.json');
+    // ADR-016 D4 — Codex 에 등록한 것도 되돌린다 (다른 도구의 훅과 그 신뢰는 보존)
+    try {
+        const { planCodexUninstall, renderCodexUninstall } = await import('../host/uninstall-codex.js');
+        for (const line of renderCodexUninstall(planCodexUninstall({ pkgRoot })))
+            console.log(line);
+    }
+    catch (e) {
+        console.error('  ✗ Codex cleanup failed:', e instanceof Error ? e.message : String(e));
+    }
     cleanPluginArtifacts();
     if (options.purge) {
         try {
@@ -347,5 +426,5 @@ export async function handleUninstall(cwd, options) {
             console.log(`  ✗ ~/.forgen/ deletion failed: ${e.message}`);
         }
     }
-    console.log('\n[forgen] Uninstall complete. Restart Claude Code for a clean state.\n');
+    console.log('\n[forgen] Uninstall complete. Restart Claude Code (and Codex) for a clean state.\n');
 }

package/dist/engine/solution-fixup.js

@@ -1,6 +1,6 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import yaml from 'js-yaml';
+import * as yaml from 'js-yaml';
 import { DEFAULT_EVIDENCE } from './solution-format.js';
 import { diagnoseFromRawContent } from './solution-quarantine.js';
 import { createLogger } from '../core/logger.js';
@@ -83,7 +83,7 @@ function tryFix(content, initialErrors) {
     const body = trimmed.slice(endIdx + 3);
     let fm;
     try {
-        const parsed = yaml.load(fmRaw, { schema: yaml.JSON_SCHEMA });
+        const parsed = yaml.load(fmRaw, { schema: yaml.CORE_SCHEMA });
         if (parsed == null || typeof parsed !== 'object') {
             return { changed: false, added, remaining: initialErrors, content };
         }

package/dist/engine/solution-format.js

@@ -1,4 +1,4 @@
-import yaml from 'js-yaml';
+import * as yaml from 'js-yaml';
 export const DEFAULT_EVIDENCE = {
     injected: 0,
     reflected: 0,
@@ -106,7 +106,7 @@ export function parseFrontmatterOnly(content) {
         const anchorCount = (raw.match(/(?<=\s|^)&\w+/g) ?? []).length;
         if (anchorCount > 3)
             return null;
-        const parsed = yaml.load(raw, { schema: yaml.JSON_SCHEMA });
+        const parsed = yaml.load(raw, { schema: yaml.CORE_SCHEMA });
         if (!validateFrontmatter(parsed))
             return null;
         return parsed;
@@ -156,8 +156,8 @@ export function parseSolutionV3(content) {
 export function serializeSolutionV3(solution) {
     const yamlStr = yaml.dump(solution.frontmatter, {
         lineWidth: -1,
-        quotingType: '"',
-        schema: yaml.JSON_SCHEMA,
+        quoteStyle: 'double',
+        schema: yaml.CORE_SCHEMA,
     });
     return `---\n${yamlStr}---\n\n## Context\n${solution.context}\n\n## Content\n${solution.content}\n`;
 }

package/dist/engine/solution-quarantine.js

@@ -1,6 +1,6 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import yaml from 'js-yaml';
+import * as yaml from 'js-yaml';
 import { SOLUTION_QUARANTINE_PATH, STATE_DIR } from '../core/paths.js';
 import { diagnoseFrontmatter } from './solution-format.js';
 import { createLogger } from '../core/logger.js';
@@ -24,7 +24,7 @@ export function diagnoseFromRawContent(content) {
         return ['frontmatter too large (>5000 chars — YAML bomb guard)'];
     let parsed;
     try {
-        parsed = yaml.load(raw, { schema: yaml.JSON_SCHEMA });
+        parsed = yaml.load(raw, { schema: yaml.CORE_SCHEMA });
     }
     catch (e) {
         return [`YAML parse error: ${e instanceof Error ? e.message : String(e)}`];

package/dist/hooks/context-guard.d.ts

@@ -57,6 +57,9 @@ export declare function effectiveCooldownMs(parsed: {
     userPatternFound?: boolean;
     promptCount?: number;
 }, currentPromptCount?: number): number;
+export declare function maybeSpawnAutoCompound(sessionId: string, transcriptPath: string | undefined, promptCount: number, 
+/** ADR-016 D1: notify 폴백은 훅 env(FORGEN_CWD) 없이 돌므로 페이로드의 cwd 를 넘긴다. */
+cwdOverride?: string): Promise<boolean>;
 /**
  * forge-loop 활성 시 미완료 스토리가 있으면 Stop을 차단하고 지속 메시지 주입.
  * OMC의 persistent-mode.cjs 패턴 참고.

package/dist/hooks/context-guard.js

@@ -439,9 +439,11 @@ export function effectiveCooldownMs(parsed, currentPromptCount = 0) {
     const grew = currentPromptCount - (parsed.promptCount ?? 0) >= AUTO_COMPOUND_GROWTH_THRESHOLD;
     return grew ? AUTO_COMPOUND_COOLDOWN_MS : AUTO_COMPOUND_BARREN_COOLDOWN_MS;
 }
-async function maybeSpawnAutoCompound(sessionId, transcriptPath, promptCount) {
+export async function maybeSpawnAutoCompound(sessionId, transcriptPath, promptCount, 
+/** ADR-016 D1: notify 폴백은 훅 env(FORGEN_CWD) 없이 돌므로 페이로드의 cwd 를 넘긴다. */
+cwdOverride) {
     if (!transcriptPath || promptCount < 10)
-        return;
+        return false;
     const markerPath = path.join(STATE_DIR, 'last-auto-compound.json');
     try {
         const raw = fs.readFileSync(markerPath, 'utf-8');
@@ -450,12 +452,12 @@ async function maybeSpawnAutoCompound(sessionId, transcriptPath, promptCount) {
             const last = parsed.completedAt ? Date.parse(parsed.completedAt) : 0;
             const cooldown = effectiveCooldownMs(parsed, promptCount);
             if (Number.isFinite(last) && Date.now() - last < cooldown)
-                return;
+                return false;
         }
     }
     catch { /* first time or corrupt — proceed */ }
     const { spawn: spawnProcess } = await import('node:child_process');
-    const cwd = process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd();
+    const cwd = cwdOverride ?? process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd();
     // 기본: 번들된 auto-compound-runner. 프로덕션 빌드는 이 경로만 실행.
     const defaultRunner = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'core', 'auto-compound-runner.js');
     // 테스트 주입 경로 — FORGEN_TEST=1 게이트 + 경로 containment (~/.forgen 또는 /tmp 하위만 허용).
@@ -486,7 +488,7 @@ async function maybeSpawnAutoCompound(sessionId, transcriptPath, promptCount) {
     const { claimAutoCompoundInflight, releaseAutoCompoundInflight } = await import('../core/spawn.js');
     if (!claimAutoCompoundInflight(sessionId)) {
         log.debug('Stop-triggered auto-compound skip: 세션 in-flight');
-        return;
+        return false;
     }
     try {
         const child = spawnProcess('node', [runnerPath, cwd, transcriptPath, sessionId, String(promptCount)], {
@@ -495,10 +497,12 @@ async function maybeSpawnAutoCompound(sessionId, transcriptPath, promptCount) {
         });
         child.unref();
         log.debug(`Stop-triggered auto-compound 시작: ${sessionId} (${promptCount} prompts)`);
+        return true;
     }
     catch (e) {
         releaseAutoCompoundInflight(sessionId); // spawn 실패 → 재시도 가능
         log.debug('Stop-triggered auto-compound spawn 실패', e);
+        return false;
     }
 }
 // forge-loop 차단 안전 상한 (무한 루프 방지)

package/dist/hooks/hook-registry.d.ts

@@ -32,6 +32,17 @@ export interface HookEntry {
      * 훅 신뢰(trust) 와 묶여 있으므로, Claude 에만 추가하는 이벤트는 `["claude"]` 로 한정한다.
      */
     hosts?: Array<'claude' | 'codex' | 'opencode'>;
+    /**
+     * ADR-016 D2: Codex hooks.json 핸들러에만 붙는 필드. Codex 의 trust 해시는 핸들러 단위라
+     * 여기 값을 바꾸면 *그 핸들러만* `/hooks` 재승인이 필요하다 (다른 핸들러는 영향 없음).
+     */
+    codex?: {
+        /**
+         * `additionalContext` 를 임시 파일로 스필하는 임계(근사 토큰, 기본 2500 ≈ 10KB). 0 = 스필 안 함.
+         * Codex 는 PreToolUse/PostToolUse/SessionStart/UserPromptSubmit/SubagentStart 에서만 인정한다.
+         */
+        additionalContextLimit?: number;
+    };
 }
 export declare const HOOK_REGISTRY: HookEntry[];
 /** 티어별 훅 목록 조회 */

package/dist/hooks/hooks-generator.d.ts

@@ -14,6 +14,8 @@ interface HookCommand {
     type: 'command';
     command: string;
     timeout: number;
+    /** Codex 전용 (ADR-016 D2). Claude 산출물에는 넣지 않는다. */
+    additionalContextLimit?: number;
 }
 interface HookMatcher {
     matcher: string;

package/dist/hooks/hooks-generator.js

@@ -92,7 +92,11 @@ export function generateHooksJson(options) {
             matcher,
             hooks: matcherEntries.map(h => {
                 const command = buildHookCommand(pluginRoot, h.script, runtime);
-                return { type: 'command', command, timeout: h.timeout };
+                const handler = { type: 'command', command, timeout: h.timeout };
+                if (runtime === 'codex' && typeof h.codex?.additionalContextLimit === 'number') {
+                    handler.additionalContextLimit = h.codex.additionalContextLimit;
+                }
+                return handler;
             }),
         }));
     }

package/dist/hooks/session-end.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * Forgen — SessionEnd Hook (ADR-015 C-G6, Claude Code 전용)
+ * Forgen — SessionEnd Hook (ADR-015 C-G6 Claude, ADR-016 D2 Codex)
  *
  * Claude Code `SessionEnd` (reason: clear|resume|logout|prompt_input_exit|other, 기본 예산 1.5s)
  * 에서 이전 세션 transcript 를 auto-compound 러너에 넘긴다. 기존 트리거(Stop / PreCompact /
@@ -10,8 +10,10 @@
  *
  * - 예산(기본 1.5s, registry timeout 3s 로 상향) 안에 끝나야 하므로: stdin 파싱 → user 메시지 수
  *   (앞 200KB 만 읽음, 대용량 transcript 보호) → detached spawn.
- * - Codex 에는 등록하지 않는다 (hooks.json 바이트 동일성 = 훅 신뢰 유지). Codex 의 SessionEnd 는
- *   hooks.json 변경이 필요한 다음 메이저에서 함께 추가.
+ * - Codex 0.153+ 에도 등록한다 (ADR-016 D2). Codex 의 SessionEnd 는 stdin 이
+ *   `session_id`/`transcript_path`/`cwd`/`reason`(항상 "other") 이고 stdout 을 무시하며 타임아웃을 1~3s 로
+ *   clamp 한다 — 같은 "bounded count → detached spawn" 경로가 그대로 맞는다. trust 해시가 핸들러 단위라
+ *   새 이벤트 추가는 기존 훅의 신뢰를 깨지 않는다 (이 훅 1개만 `/hooks` 승인 필요).
  * - fail-open: 어떤 실패도 종료를 막지 않는다.
  */
 /** session-recovery 와 동일 임계값 — 짧은 세션은 compound 가치가 없다. */
@@ -29,6 +31,11 @@ export declare const COUNT_SCAN_BYTES: number;
  * 임계값(MIN_USER_MESSAGES) 판정에만 쓰이므로 하한 추정으로 충분하다. 큰 transcript 에서도 O(200KB).
  */
 export declare function countUserMessagesBounded(transcriptPath: string, maxBytes?: number): number;
+/**
+ * host 별 user 메시지 수. Codex rollout 은 스키마가 달라 전용 카운터를 쓴다 (ADR-016 D2 — 실제 사용자
+ * 프롬프트만, raw 바이트 스캔). codex-adapter 가 delegate 훅에 FORGEN_RUNTIME=codex 를 주입한다.
+ */
+export declare function countSessionUserMessages(transcriptPath: string, runtime?: string | undefined): Promise<number>;
 /** 순수 판정: 이 입력으로 auto-compound 를 띄울지. (테스트 대상) */
 export declare function shouldRunSessionEndCompound(input: SessionEndInput | null, userMessageCount: number): boolean;
 export declare function main(): Promise<void>;

package/dist/hooks/session-end.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * Forgen — SessionEnd Hook (ADR-015 C-G6, Claude Code 전용)
+ * Forgen — SessionEnd Hook (ADR-015 C-G6 Claude, ADR-016 D2 Codex)
  *
  * Claude Code `SessionEnd` (reason: clear|resume|logout|prompt_input_exit|other, 기본 예산 1.5s)
  * 에서 이전 세션 transcript 를 auto-compound 러너에 넘긴다. 기존 트리거(Stop / PreCompact /
@@ -10,8 +10,10 @@
  *
  * - 예산(기본 1.5s, registry timeout 3s 로 상향) 안에 끝나야 하므로: stdin 파싱 → user 메시지 수
  *   (앞 200KB 만 읽음, 대용량 transcript 보호) → detached spawn.
- * - Codex 에는 등록하지 않는다 (hooks.json 바이트 동일성 = 훅 신뢰 유지). Codex 의 SessionEnd 는
- *   hooks.json 변경이 필요한 다음 메이저에서 함께 추가.
+ * - Codex 0.153+ 에도 등록한다 (ADR-016 D2). Codex 의 SessionEnd 는 stdin 이
+ *   `session_id`/`transcript_path`/`cwd`/`reason`(항상 "other") 이고 stdout 을 무시하며 타임아웃을 1~3s 로
+ *   clamp 한다 — 같은 "bounded count → detached spawn" 경로가 그대로 맞는다. trust 해시가 핸들러 단위라
+ *   새 이벤트 추가는 기존 훅의 신뢰를 깨지 않는다 (이 훅 1개만 `/hooks` 승인 필요).
  * - fail-open: 어떤 실패도 종료를 막지 않는다.
  */
 import * as fs from 'node:fs';
@@ -52,6 +54,17 @@ export function countUserMessagesBounded(transcriptPath, maxBytes = COUNT_SCAN_B
         fs.closeSync(fd);
     }
 }
+/**
+ * host 별 user 메시지 수. Codex rollout 은 스키마가 달라 전용 카운터를 쓴다 (ADR-016 D2 — 실제 사용자
+ * 프롬프트만, raw 바이트 스캔). codex-adapter 가 delegate 훅에 FORGEN_RUNTIME=codex 를 주입한다.
+ */
+export async function countSessionUserMessages(transcriptPath, runtime = process.env.FORGEN_RUNTIME) {
+    if (runtime === 'codex') {
+        const { countCodexUserPrompts } = await import('../host/codex-rollout.js');
+        return countCodexUserPrompts(transcriptPath);
+    }
+    return countUserMessagesBounded(transcriptPath);
+}
 /** 순수 판정: 이 입력으로 auto-compound 를 띄울지. (테스트 대상) */
 export function shouldRunSessionEndCompound(input, userMessageCount) {
     if (!input || typeof input.transcript_path !== 'string' || input.transcript_path.length === 0)
@@ -71,7 +84,7 @@ export async function main() {
         let count = 0;
         if (transcript && fs.existsSync(transcript)) {
             try {
-                count = countUserMessagesBounded(transcript);
+                count = await countSessionUserMessages(transcript);
             }
             catch (e) {
                 log.debug('user message count 실패', e);

package/dist/host/codex-adapter.js

@@ -12,6 +12,7 @@
  */
 import { spawnSync } from 'node:child_process';
 import { projectCodexToClaude } from './projection.js';
+import { markCodexHookAlive } from './codex-hook-alive.js';
 function lastJSONObjectFromText(raw) {
     const lines = raw.split('\n').map((line) => line.trim()).filter(Boolean);
     for (let i = lines.length - 1; i >= 0; i -= 1) {
@@ -54,6 +55,10 @@ async function main() {
             return {};
         }
     })();
+    // ADR-016 D1 — "Codex 가 forgen 훅을 실제로 실행 중" 마커 (notify 폴백이 신선도를 본다).
+    // forgen 자신의 추출용 중첩 실행은 사용자 세션이 아니므로 제외.
+    if (process.env.FORGEN_NESTED_RUN !== '1')
+        markCodexHookAlive(input);
     try {
         // 0.4.6 fix — delegate hook 이 자기가 codex runtime context 인지 알 수 있게
         // FORGEN_RUNTIME=codex 명시 주입. 이전엔 buildEnv (forgen wrapper) 경로로만

package/dist/host/codex-hook-alive.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Codex 훅 생존 마커 — ADR-016 D1
+ *
+ * Codex 는 미승인(untrusted)/변경된(modified) 훅을 조용히 skip 한다. "forgen 훅이 실제로 실행되고 있는가"
+ * 를 관측하는 유일한 choke point 는 codex-adapter 다 (Codex 가 forgen 훅을 실행하면 반드시 거친다).
+ * 어댑터가 턴 경계 이벤트에서 전역 마커를 갱신하고, notify 폴백(codex-notify)이 그 신선도를 본다.
+ *
+ * 훅 신뢰 상태는 hooks.json 단위로 모든 세션이 공유하므로 마커는 세션별이 아니라 전역 1개다.
+ * 어댑터가 매 훅마다 import 하므로 의존성은 node 내장 + paths 만 둔다.
+ */
+export declare const CODEX_HOOK_ALIVE_PATH: string;
+/** notify 는 Stop 훅 직후 발화한다. Stop 훅 타임아웃(10s) 대비 넉넉한 창. */
+export declare const CODEX_HOOK_ALIVE_WINDOW_MS = 120000;
+export interface CodexHookAliveMarker {
+    at: number;
+    event: string;
+    sessionId?: string;
+}
+/** 어댑터 입력(stdin JSON)으로 마커 갱신. 대상 이벤트가 아니면 no-op. 실패는 삼킨다 (fail-open). */
+export declare function markCodexHookAlive(input: unknown, now?: number): boolean;
+export declare function readCodexHookAlive(): CodexHookAliveMarker | null;
+/** 최근 window 안에 forgen 훅이 Codex 에서 실행됐는가. */
+export declare function isCodexHookAlive(now?: number, windowMs?: number): boolean;

package/dist/host/codex-hook-alive.js

@@ -0,0 +1,51 @@
+/**
+ * Codex 훅 생존 마커 — ADR-016 D1
+ *
+ * Codex 는 미승인(untrusted)/변경된(modified) 훅을 조용히 skip 한다. "forgen 훅이 실제로 실행되고 있는가"
+ * 를 관측하는 유일한 choke point 는 codex-adapter 다 (Codex 가 forgen 훅을 실행하면 반드시 거친다).
+ * 어댑터가 턴 경계 이벤트에서 전역 마커를 갱신하고, notify 폴백(codex-notify)이 그 신선도를 본다.
+ *
+ * 훅 신뢰 상태는 hooks.json 단위로 모든 세션이 공유하므로 마커는 세션별이 아니라 전역 1개다.
+ * 어댑터가 매 훅마다 import 하므로 의존성은 node 내장 + paths 만 둔다.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { STATE_DIR } from '../core/paths.js';
+export const CODEX_HOOK_ALIVE_PATH = path.join(STATE_DIR, 'codex-hook-alive.json');
+/** notify 는 Stop 훅 직후 발화한다. Stop 훅 타임아웃(10s) 대비 넉넉한 창. */
+export const CODEX_HOOK_ALIVE_WINDOW_MS = 120_000;
+/** 턴 경계 이벤트만 기록 — PreToolUse/PostToolUse 마다 쓰지 않는다. */
+const ALIVE_EVENTS = new Set(['Stop', 'SubagentStop', 'UserPromptSubmit']);
+/** 어댑터 입력(stdin JSON)으로 마커 갱신. 대상 이벤트가 아니면 no-op. 실패는 삼킨다 (fail-open). */
+export function markCodexHookAlive(input, now = Date.now()) {
+    try {
+        const i = (input ?? {});
+        const event = typeof i.hook_event_name === 'string' ? i.hook_event_name
+            : typeof i.hookEventName === 'string' ? i.hookEventName : '';
+        if (!ALIVE_EVENTS.has(event))
+            return false;
+        const marker = { at: now, event };
+        if (typeof i.session_id === 'string')
+            marker.sessionId = i.session_id;
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        fs.writeFileSync(CODEX_HOOK_ALIVE_PATH, JSON.stringify(marker));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function readCodexHookAlive() {
+    try {
+        const m = JSON.parse(fs.readFileSync(CODEX_HOOK_ALIVE_PATH, 'utf-8'));
+        return typeof m.at === 'number' && Number.isFinite(m.at) ? m : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** 최근 window 안에 forgen 훅이 Codex 에서 실행됐는가. */
+export function isCodexHookAlive(now = Date.now(), windowMs = CODEX_HOOK_ALIVE_WINDOW_MS) {
+    const m = readCodexHookAlive();
+    return m !== null && now - m.at >= 0 && now - m.at < windowMs;
+}

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

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+/**
+ * Codex `notify` 폴백 — ADR-016 D1
+ *
+ * Codex 는 config.toml 의 top-level `notify = [argv…]` 프로그램을 **턴 완료마다**(Stop 훅 뒤) detached 로
+ * 실행하고, JSON 페이로드를 마지막 argv 로 넘긴다. 훅과 달리 **신뢰(trust) 승인과 무관**하게 돈다.
+ * forgen 은 이것을 "훅이 조용히 skip 되는 동안의 안전망" 으로만 쓴다:
+ *
+ *   1. forgen 훅이 살아 있으면(codex-adapter 가 방금 alive 마커를 갱신) 아무것도 하지 않는다 —
+ *      auto-compound 는 Stop 훅(context-guard) 소관이다.
+ *   2. 훅이 돌지 않았으면 silent 플래그를 남기고(`forgen doctor` 가 노출), 세션이 충분히 길면 Stop 훅과
+ *      같은 디바운스 경로로 auto-compound 를 띄운다.
+ *
+ * 페이로드 (codex-rs/hooks/src/legacy_notify.rs, 0.153.4):
+ *   { "type":"agent-turn-complete", "thread-id", "turn-id", "cwd", "client"?, "input-messages":[…],
+ *     "last-assistant-message" }  — transcript 경로는 없다. `thread-id` 로 rollout 파일을 찾는다.
+ *
+ * argv: `codex-notify.js [-- <chain program> <args…>] <payload JSON>`
+ *   `--` 뒤는 사용자가 수동으로 체인한 자기 notifier (단일 argv 제약 우회). 페이로드를 붙여 먼저 전달한다.
+ *
+ * 실패 정책: 모든 단계 fail-open. stdout/stderr 는 Codex 가 /dev/null 로 버린다.
+ */
+export declare const CODEX_HOOKS_SILENT_PATH: string;
+export interface CodexNotifyPayload {
+    type?: string;
+    'thread-id'?: string;
+    'turn-id'?: string;
+    cwd?: string;
+    client?: string;
+}
+export interface CodexHooksSilent {
+    detectedAt: string;
+    sessionId: string;
+    cwd: string;
+    /** 연속으로 관측된 silent 턴 수 */
+    count: number;
+}
+export type NotifyOutcome = 'nested-run' | 'no-payload' | 'ignored-event' | 'hooks-alive' | 'silent-recorded' | 'silent-compound-spawned';
+/** argv(스크립트 뒤) → 체인 프로그램 + 페이로드. 페이로드는 항상 마지막 argv. */
+export declare function parseNotifyArgv(argv: string[]): {
+    chain: string[];
+    payloadRaw: string | null;
+    payload: CodexNotifyPayload | null;
+};
+/** doctor 용 — 유효(24h 이내)한 silent 관측만 반환. */
+export declare function readCodexHooksSilent(now?: number): CodexHooksSilent | null;
+export interface NotifyDeps {
+    now?: number;
+    env?: NodeJS.ProcessEnv;
+    /** 테스트 주입: auto-compound 디바운스 트리거 */
+    spawnCompound?: (sessionId: string, transcriptPath: string, promptCount: number, cwd: string) => Promise<boolean>;
+    /** 테스트 주입: forgen hook-config 조회 */
+    isHookEnabled?: (name: string) => boolean;
+}
+export declare function handleNotify(argv: string[], deps?: NotifyDeps): Promise<NotifyOutcome>;