@wooojin/forgen 0.5.6 → 0.5.7

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://claude.ai/schemas/claude-plugin.json",
   "name": "forgen",
-  "version": "0.5.6",
+  "version": "0.5.7",
   "description": "Claude Code harness — the more you use Claude, the better it gets",
   "author": {
     "name": "jang-ujin",

package/CHANGELOG.md

@@ -7,6 +7,66 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.7] — 2026-10-02 — `forgen uninstall` 의 Codex 정리 · 의존성 메이저 업그레이드
+
+### Added
+- **`forgen uninstall` 이 Codex 등록분도 되돌린다 (ADR-016 D4).** hooks.json 의 forgen 훅, config.toml 의 MCP/notify 블록,
+  forgen-managed `skills/` · `agents/ch-*.toml`, cwd 의 AGENTS.md 블록을 제거한다. 이전엔 Codex 쪽이 그대로 남아
+  패키지를 지우면 Codex 가 매 훅 이벤트마다 사라진 스크립트를 실행하려 했다.
+  - **다른 도구의 훅 신뢰를 지킨다.** Codex 의 trust 키는 그룹 인덱스 기반이라 forgen 그룹을 지워 인덱스가 당겨지면
+    뒤따르는 훅이 재승인 전까지 조용히 skip 된다. 그런 위치에는 빈 그룹(`{"hooks": []}`)을 남겨 인덱스를 유지한다
+    (Codex 0.153.4 `hooks/list` 로 확인: 경고 없음, 뒤 그룹 trusted 유지). forgen 은 `[hooks.state]` 를 고쳐 쓰지 않는다.
+  - 사용자가 만든 스킬/에이전트/마커 없는 MCP 테이블/자기 `notify`, Codex 가 블록 사이에 써 넣은 설정은 보존.
+    forgen notify 뒤에 체인해 둔 사용자 notifier 는 그 argv 만으로 `notify` 를 되돌려 놓는다.
+  - uninstall 후 재설치하면 빈 그룹 자리를 다시 채워 forgen 훅이 원래 인덱스(= 이미 승인된 trust 키)로 돌아간다.
+  - 각 단계는 독립 — 하나가 실패(읽기 전용 파일, 깨진 hooks.json)해도 나머지는 진행하고 실패를 출력한다.
+  - 한계: 다른 프로젝트의 AGENTS.md 블록(실행한 cwd 것만 정리), `forgen install opencode` 산출물, 낡은 `[hooks.state]`
+    항목, 빈 디렉토리/빈 config.toml 은 남는다.
+- `forgen uninstall` 의 Claude 쪽 누락 보강: `~/.claude.json` 의 `forgen-compound` MCP 등록(install 은 여기에 쓰는데 uninstall 은
+  settings.json 만 정리했다), 패키지가 제공한 dev-guide 스킬(`~/.claude/skills/forgen-<stack>-<skill>`).
+
+### Fixed
+- **손으로 여러 줄로 고친 forgen notify 블록을 제거(`--no-notify`, uninstall)하면 config.toml 이 깨지던 결함 (0.5.6).**
+  배열의 첫 줄만 지우고 나머지를 남겨 Codex 가 기동하지 못했다. 이제 그런 블록은 건드리지 않고 알린다.
+- **훅 소유 판정이 너무 넓던 것.** command 에 `dist/hooks/<아무이름>.js` 가 있거나 forgen 설치 경로를 *부분문자열* 로
+  포함하면 forgen 훅으로 봤다 — 다른 프로젝트의 `…/dist/hooks/pre-commit.js` 나 `<pkgRoot>-fork/…` 가 재설치 시 교체
+  대상이 될 수 있었다. 이제 forgen 설치 경로의 `dist/` 아래, codex-adapter 경유, registry 에 있는 forgen 훅 이름일 때만.
+- 소유 마커 판정 강화: SKILL.md 는 frontmatter *바로 뒤* 의 마커만 인정(본문의 `---` 뒤 마커 인용을 오인하던 것),
+  agent TOML 은 첫 줄이 정확히 `# forgen-managed` 일 때만.
+- `~/.claude.json` / settings.json 을 다시 쓸 때 기존 파일 권한(0600)과 심링크를 보존 (이전엔 0644 로 넓어지고 심링크가
+  일반 파일로 바뀌었다).
+- `forgen status` 점수: 총점을 표시되는 항목 점수의 합으로 계산 (반올림 순서 때문에 항목 합과 총점이 1 어긋날 수 있었다).
+
+### Changed — dependencies
+- **js-yaml 4 → 5** (런타임 의존성). v5 ESM 빌드는 default export 가 없어 namespace import 로 전환, dump 옵션
+  `quotingType` → `quoteStyle`, 타입 내장으로 `@types/js-yaml` 제거. **스키마를 `JSON_SCHEMA` → `CORE_SCHEMA` 로 변경**:
+  v5 의 `JSON_SCHEMA` 는 strict JSON 이라 v4 가 읽던 `confidence: .5`, `supersedes: ~`, `True` 등을 문자열로 읽어
+  솔루션이 조용히 탈락한다. `CORE_SCHEMA` 가 v4 와 같은 해석을 준다 (회귀 테스트 추가). 실 솔루션/룰 frontmatter 87개에서
+  v4 와 파싱·직렬화 결과 바이트 동일. 남는 차이: `1_000`, `0b11` 형태는 v5 에서 문자열로 읽히고 따옴표 없이 직렬화된다
+  (forgen 이 쓰는 값에는 나타나지 않는 형태).
+- **TypeScript 5.9 → 7.0** (dev). TS 6+ 는 `@types/*` 를 자동 포함하지 않아 tsconfig 에 `"types": ["node"]` 명시.
+  TS 7 의 `tsc` 는 Node 20.0 에서 실행되지 않으므로 CI 의 훅 포터빌리티 잡을 "Node 22 로 빌드 → 대상 Node 로 로드" 로 분리
+  (배포물은 빌드된 dist 이므로 사용자 영향 없음).
+- **vitest 4 → 5** + `@vitest/coverage-v8` 5 (dev, 함께 올려야 함).
+- `@modelcontextprotocol/sdk` 1.31.0, `zod` 4.6.5, `@types/node` 26.6.4, `@biomejs/biome` 2.5.15, `npm audit fix`
+  (advisory 13 → 0), `actions/setup-node` v7.
+
+### Docs
+- `packages/forgen-eval/reports/persistence/` 원시 리포트 6건 커밋 — `docs/release/v0.5.0-persistence-delta.md` 가 재현
+  근거로 인용하던 파일이 저장소에 없었다.
+
+### Verified
+- vitest 3204 통과 (신규: Codex uninstall 왕복·신뢰 인덱스 보존·config 보존·소유 판정 오탐·손편집 notify 블록,
+  Claude 쪽 MCP/dev-guide 정리·권한/심링크 보존, js-yaml 스칼라 해석).
+- 격리 `HOME` 에서 CLI `install both` → `uninstall --force` 왕복: forgen 이 등록한 훅/블록/스킬/에이전트가 제거되고, 다른
+  도구 훅은 실 Codex `hooks/list` 에서 uninstall 후에도 `trusted`, `codex mcp list` 가 config 를 정상 파싱 (손편집된
+  여러 줄 notify 블록이 있는 경우 포함).
+- fresh-context critic 리뷰: MAJOR 2 · MINOR 12 → 위 Fixed/Changed 에 반영 또는 한계로 명시. 리뷰어가 확인한 것: TS 7 빌드의
+  `.js` 227개가 TS 5.9 빌드와 바이트 동일, 실 `~/.codex` 사본에서 uninstall 후 다른 도구 훅 8개 trusted 유지.
+- CI: ubuntu/macOS/arm 테스트 + Node 20.0.0~22 훅 로드 14개 검사 통과.
+- 0.5.6 을 이 머신의 실 `~/.codex` 에 설치한 뒤 실 Codex 세션 1회: Stop 훅 발화·alive 마커 갱신, silent 플래그 없음.
+
+
 ## [0.5.6] — 2026-10-02 — Codex notify 폴백 · 훅 번들(재승인 2건) · Claude verify 스킬 (ADR-016)
 
 > **Codex 사용자 — 재승인 필요**: 업그레이드 후 `forgen install codex` 를 다시 실행하면 훅 2개

package/README.ja.md

@@ -564,7 +564,7 @@ forgen mcp list                 # インストール済み MCP サーバーを
 forgen mcp add <名前>           # テンプレートから MCP サーバーを追加
 forgen mcp templates            # 利用可能なテンプレートを表示
 forgen notepad show             # セッションノートパッドを表示
-forgen uninstall                # forgen をきれいに削除
+forgen uninstall                # forgen をきれいに削除 (Claude Code + Codex の登録分)
 ```
 
 ### MCP ツール（セッション中に Claude が使用可能）

package/README.ko.md

@@ -549,7 +549,7 @@ forgen mcp list                 # 설치된 MCP 서버 목록
 forgen mcp add <이름>           # 템플릿에서 MCP 서버 추가
 forgen mcp templates            # 사용 가능한 템플릿 목록
 forgen notepad show             # 세션 노트패드 보기
-forgen uninstall                # forgen 깔끔하게 제거
+forgen uninstall                # forgen 깔끔하게 제거 (Claude Code + Codex 등록분)
 ```
 
 ### MCP 도구 (세션 중 Claude가 사용)

package/README.md

@@ -750,7 +750,7 @@ forgen mcp list                 # List installed MCP servers
 forgen mcp add <name>           # Add MCP server from template
 forgen mcp templates            # Show available templates
 forgen notepad show             # View session notepad
-forgen uninstall                # Remove forgen cleanly
+forgen uninstall                # Remove forgen cleanly (Claude Code + Codex registrations)
 ```
 
 ### Rule lifecycle (v0.4.0, ADR-001/002)

package/README.zh.md

@@ -533,7 +533,7 @@ forgen mcp list                 # 列出已安装的 MCP 服务器
 forgen mcp add <名称>           # 从模板添加 MCP 服务器
 forgen mcp templates            # 显示可用模板
 forgen notepad show             # 查看会话记事本
-forgen uninstall                # 干净地卸载 forgen
+forgen uninstall                # 干净地卸载 forgen (Claude Code + Codex 的注册项)
 ```
 
 ### MCP 工具（会话中 Claude 可使用）

package/dist/core/health-cli.js

@@ -44,19 +44,18 @@ export function computeHealth() {
         if (Object.keys(s.philosophy.axisScores).length >= 4)
             profile += 3;
     }
-    const total = Math.round(utilization + effectiveness + growth + coverage + profile);
-    const grade = total >= 80 ? 'A' : total >= 60 ? 'B' : total >= 40 ? 'C' : total >= 20 ? 'D' : 'F';
-    return {
-        total,
-        components: {
-            utilization: Math.round(utilization),
-            effectiveness: Math.round(effectiveness),
-            growth: Math.round(growth),
-            coverage: Math.round(coverage),
-            profile: Math.round(profile),
-        },
-        grade,
+    // 총점은 *표시되는* 항목 점수의 합이어야 한다. 이전엔 합을 반올림(round(Σ))하고 항목은 따로 반올림해서
+    // 실 상태에 따라 "항목 합 60 ≠ 총점 61" 이 나왔다 (tests/health-cli 가 머신 상태에 따라 간헐 실패).
+    const components = {
+        utilization: Math.round(utilization),
+        effectiveness: Math.round(effectiveness),
+        growth: Math.round(growth),
+        coverage: Math.round(coverage),
+        profile: Math.round(profile),
     };
+    const total = components.utilization + components.effectiveness + components.growth + components.coverage + components.profile;
+    const grade = total >= 80 ? 'A' : total >= 60 ? 'B' : total >= 40 ? 'C' : total >= 20 ? 'D' : 'F';
+    return { total, components, grade };
 }
 function gradeColor(grade) {
     if (grade === 'A')

package/dist/core/paths.d.ts

@@ -91,7 +91,7 @@ export declare const V1_SESSIONS_DIR: string;
 /** ~/.forgen/state/raw-logs/ — Raw Log */
 export declare const V1_RAW_LOGS_DIR: string;
 /** 모든 실행 모드 이름 (cancel/recovery 시 사용) */
-export declare const ALL_MODES: readonly ["ralph", "autopilot", "ultrawork", "team", "pipeline", "ccg", "ralplan", "deep-interview", "forge-loop", "ship", "retro", "learn", "calibrate"];
+export declare const ALL_MODES: readonly ['ralph', 'autopilot', 'ultrawork', 'team', 'pipeline', 'ccg', 'ralplan', 'deep-interview', 'forge-loop', 'ship', 'retro', 'learn', 'calibrate'];
 /** {repo}/.compound/ — 프로젝트 로컬 디렉토리 */
 export declare function projectDir(cwd: string): string;
 /** {repo}/.compound/pack.link — 팀 팩 연결 파일 */

package/dist/core/settings-lock.d.ts

@@ -26,7 +26,13 @@ export declare function acquireLock(): void;
  * 다른 프로세스의 lock을 존중한다.
  */
 export declare function releaseLock(): void;
-/** 임시파일에 쓴 후 rename으로 원자적 교체 */
+/**
+ * 임시파일에 쓴 후 rename으로 원자적 교체.
+ *
+ * 0.5.7 (critic): 기존 파일의 권한과 심링크를 보존한다. 이전엔 새 파일을 기본 mode(0644)로 만들어 rename 해서
+ * 0600 이던 `~/.claude.json`(MCP env 에 비밀값이 들어갈 수 있다)이 0644 로 넓어졌고, 심링크였으면 링크가
+ * 일반 파일로 바뀌고 원본은 갱신되지 않았다.
+ */
 export declare function atomicWriteFileSync(targetPath: string, data: string): void;
 /**
  * settings.json 안전 읽기.

package/dist/core/settings-lock.js

@@ -96,11 +96,26 @@ export function releaseLock() {
     }
     catch { /* 이미 없으면 무시 */ }
 }
-/** 임시파일에 쓴 후 rename으로 원자적 교체 */
+/**
+ * 임시파일에 쓴 후 rename으로 원자적 교체.
+ *
+ * 0.5.7 (critic): 기존 파일의 권한과 심링크를 보존한다. 이전엔 새 파일을 기본 mode(0644)로 만들어 rename 해서
+ * 0600 이던 `~/.claude.json`(MCP env 에 비밀값이 들어갈 수 있다)이 0644 로 넓어졌고, 심링크였으면 링크가
+ * 일반 파일로 바뀌고 원본은 갱신되지 않았다.
+ */
 export function atomicWriteFileSync(targetPath, data) {
-    const tmpPath = `${targetPath}.tmp.${process.pid}`;
-    fs.writeFileSync(tmpPath, data);
-    fs.renameSync(tmpPath, targetPath);
+    let realTarget = targetPath;
+    let mode;
+    try {
+        realTarget = fs.realpathSync(targetPath);
+        mode = fs.statSync(realTarget).mode & 0o777;
+    }
+    catch { /* 새 파일 — 기본 mode */ }
+    const tmpPath = `${realTarget}.tmp.${process.pid}`;
+    fs.writeFileSync(tmpPath, data, mode !== undefined ? { mode } : undefined);
+    if (mode !== undefined)
+        fs.chmodSync(tmpPath, mode); // umask 로 깎였을 수 있어 명시
+    fs.renameSync(tmpPath, realTarget);
 }
 /**
  * settings.json 안전 읽기.

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

@@ -13,7 +13,7 @@
  *   forgen status --blocks [N] 최근 차단 N건 (rule·사유·해결)
  *   forgen status --live       실시간 훅 이벤트 스트림
  */
-declare const VIEWS: readonly ["--compound", "--profile", "--rules", "--blocks", "--live", "--overview"];
+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>;

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

@@ -7,7 +7,7 @@
  *
  * 1원칙: Claude semantics 가 reference. 본 enum 의 의미는 Claude Hook schema 의 행동을 그대로 사용한다.
  */
-export declare const TRUST_LAYER_INTENTS: readonly ["block-completion", "block-tool-use", "inject-context", "observe-only", "secret-filter", "forge-loop-state-inject", "self-evidence-record"];
+export declare const TRUST_LAYER_INTENTS: readonly ['block-completion', 'block-tool-use', 'inject-context', 'observe-only', 'secret-filter', 'forge-loop-state-inject', 'self-evidence-record'];
 export type TrustLayerIntent = (typeof TRUST_LAYER_INTENTS)[number];
 export type CapabilityStatus = 'supported' | 'partial' | 'unsupported';
 export interface CapabilityDeclaration {
@@ -25,7 +25,7 @@ export interface CapabilityDeclaration {
  * `(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 declare const HOST_IDS: readonly ['claude', 'codex', 'opencode'];
 export type HostId = (typeof HOST_IDS)[number];
 /**
  * 능력 선언의 검증 수준 (W3-3 리뷰 SEV-3 #1).

package/dist/core/uninstall.d.ts

@@ -1,10 +1,15 @@
 /** ADR-016 D3 — ~/.claude/skills/verify 제거 (forgen-managed 마커가 있는 것만; 사용자 스킬은 보존) */
 export declare function cleanVerifySkill(homeDir?: string): boolean;
 /**
- * ADR-016 D1 — Codex config.toml 의 forgen notify 블록 제거. 남겨 두면 Codex 가 매 턴 사라진 스크립트를
- * spawn 한다. (Codex hooks.json / MCP 블록 정리는 아직 uninstall 범위 밖 — 알려진 갭.)
+ * ADR-016 D4 — `~/.claude/skills/forgen-<stack>-<skill>/` dev-guide 스킬 제거.
+ * 패키지가 실제로 제공하는 이름만 지운다 (사용자가 만든 `forgen-react-mine` 같은 스킬은 보존).
  */
-export declare function cleanCodexNotify(codexHome?: string): Promise<boolean>;
+export declare function cleanDevGuideSkills(pkgRoot: string, homeDir?: string): number;
+/**
+ * ADR-016 D4 — `~/.claude.json` 의 `mcpServers["forgen-compound"]` 제거. install 은 settings.json 이 아니라
+ * 여기에 등록하는데 uninstall 은 settings.json 만 정리하고 있었다. forgen 서버 경로를 가리킬 때만 지운다.
+ */
+export declare function cleanClaudeJsonMcp(homeDir?: string): boolean;
 /** forgen uninstall 메인 */
 export declare function handleUninstall(cwd: string, options: {
     force?: boolean;

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() {
@@ -103,8 +105,7 @@ export function cleanVerifySkill(homeDir = os.homedir()) {
     try {
         if (fs.lstatSync(dir).isSymbolicLink() || fs.lstatSync(file).isSymbolicLink())
             return false;
-        const content = fs.readFileSync(file, 'utf-8');
-        if (!/^---\n[\s\S]*?\n---\n\s*<!-- forgen-managed -->/.test(content))
+        if (!hasManagedSkillMarker(fs.readFileSync(file, 'utf-8')))
             return false;
         fs.unlinkSync(file);
         try {
@@ -119,22 +120,41 @@ export function cleanVerifySkill(homeDir = os.homedir()) {
     }
 }
 /**
- * ADR-016 D1 — Codex config.toml 의 forgen notify 블록 제거. 남겨 두면 Codex 가 매 턴 사라진 스크립트를
- * spawn 한다. (Codex hooks.json / MCP 블록 정리는 아직 uninstall 범위 밖 — 알려진 갭.)
+ * ADR-016 D4 — `~/.claude/skills/forgen-<stack>-<skill>/` dev-guide 스킬 제거.
+ * 패키지가 실제로 제공하는 이름만 지운다 (사용자가 만든 `forgen-react-mine` 같은 스킬은 보존).
  */
-export async function cleanCodexNotify(codexHome = process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex')) {
-    const configPath = path.join(codexHome, 'config.toml');
+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 current = fs.readFileSync(configPath, 'utf-8');
-        const { removeNotifyBlock } = await import('../host/install-codex.js');
-        const r = removeNotifyBlock(current);
-        if (!r.removed)
+        const data = JSON.parse(fs.readFileSync(claudeJsonPath, 'utf-8'));
+        const entry = data.mcpServers?.['forgen-compound'];
+        if (!entry)
             return false;
-        fs.writeFileSync(configPath, r.content, 'utf-8');
+        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; // Codex 미사용
+        return false; // 파일 없음 / 파싱 실패 — 건드리지 않는다
     }
 }
 /** 사용자에게 y/n 확인 */
@@ -343,9 +363,10 @@ export async function handleUninstall(cwd, options) {
     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/) and the forgen-managed verify skill (~/.claude/skills/verify/)');
-    console.log('  6. Remove plugin artifacts (cache, installed_plugins.json, plugin directory)');
+    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 {
@@ -373,8 +394,21 @@ export async function handleUninstall(cwd, options) {
     cleanSlashCommands();
     if (cleanVerifySkill())
         console.log('  ✓ Removed forgen verify skill (~/.claude/skills/verify/)');
-    if (await cleanCodexNotify())
-        console.log('  ✓ Removed forgen notify block from Codex config.toml');
+    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 {
@@ -392,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/host/install-claude.js

@@ -18,6 +18,7 @@ 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';
+import { hasManagedSkillMarker } from './managed-marker.js';
 const PLUGIN_KEY = 'forgen@forgen-local';
 const FORGEN_MANAGED_MARKER = '<!-- forgen-managed -->';
 function readPkgVersion(pkgRoot) {
@@ -303,8 +304,6 @@ function installDevGuideSkills(opts) {
     return { skillsPath: skillsDir, skillsInstalled: installed, skillsRemoved: removed };
 }
 // ── 6. verify skill (ADR-016 D3) ───────────────────────────────────────
-/** frontmatter 직후에 forgen-managed 마커가 있는 SKILL.md 만 forgen 소유로 본다. */
-const MANAGED_SKILL_RE = /^---\n[\s\S]*?\n---\n\s*<!-- forgen-managed -->/;
 /** `<skillsDir>/verify` 가 사용자 소유인가 (심링크 / 마커 없는 SKILL.md / SKILL.md 없이 다른 파일만 있음). */
 export function isUserOwnedVerifySkill(skillsDir) {
     const dir = path.join(skillsDir, 'verify');
@@ -319,7 +318,7 @@ export function isUserOwnedVerifySkill(skillsDir) {
     try {
         if (fs.lstatSync(file).isSymbolicLink())
             return true;
-        return !MANAGED_SKILL_RE.test(fs.readFileSync(file, 'utf-8'));
+        return !hasManagedSkillMarker(fs.readFileSync(file, 'utf-8'));
     }
     catch {
         // SKILL.md 없음 — 디렉토리에 다른 것이 있으면 사용자가 만들던 것

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

@@ -90,6 +90,19 @@ export interface CodexHookTrustAudit {
     /** config.toml 자체가 없거나 hooks.state 가 전혀 없으면 true (Codex 가 아직 한 번도 훅을 review 안 함) */
     noStateRecorded: boolean;
 }
+export declare const FORGEN_SKILL_MARKER = "<!-- forgen-managed -->";
+/** 훅 command 문자열이 forgen 소유인가. */
+export declare function isForgenHookCommand(command: unknown, pkgRoot: string): boolean;
+export declare function readJsonFile<T>(p: string): T | null;
+/**
+ * forgen MCP 블록 제거 (uninstall, ADR-016 D4). forgen 테이블(본문 + `[mcp_servers.forgen-compound.*]` 하위
+ * 테이블)과 마커만 걷어내고, 블록 사이에 Codex 가 끼워 넣은 다른 내용은 그 자리에 보존한다.
+ * 마커 없는 사용자 관리 테이블은 건드리지 않는다.
+ */
+export declare function removeMcpBlock(currentToml: string): {
+    content: string;
+    removed: boolean;
+};
 /**
  * config.toml 에 forgen notify 블록을 upsert.
  *
@@ -104,12 +117,20 @@ export declare function upsertNotifyBlock(currentToml: string, pkgRoot: string):
     content: string;
     status: CodexNotifyStatus;
 };
-/** forgen notify 블록 제거 (`--no-notify`, uninstall). 블록 사이에 끼어든 다른 줄은 보존. */
+/**
+ * forgen notify 블록 제거 (`--no-notify`, uninstall). 블록 사이에 끼어든 다른 줄은 보존.
+ *
+ * - 사용자가 블록의 notify 줄을 여러 줄 배열 등으로 손편집했으면(`custom`) **건드리지 않는다** — 첫 줄만
+ *   지우면 남은 줄이 깨진 TOML 이 되어 Codex 가 기동하지 못한다 (critic 2026-10-02).
+ * - `"--"` 뒤에 사용자가 체인해 둔 자기 notifier 가 있으면 그 argv 만으로 `notify` 를 되돌려 놓는다.
+ */
 export declare function removeNotifyBlock(currentToml: string): {
     content: string;
     removed: boolean;
+    custom: boolean;
+    restoredChain: string[];
 };
-interface HooksFile {
+export interface HooksFile {
     description?: string;
     hooks: Record<string, Array<unknown>>;
 }
@@ -154,6 +175,8 @@ export declare function auditCodexHookTrust(opts: {
     hooksFile?: HooksFile | null;
     configToml?: string;
 }): CodexHookTrustAudit;
+export declare const AGENT_TOML_MARKER = "# forgen-managed";
+export declare const AGENT_NAME_PREFIX = "ch-";
 /**
  * Claude agent .md → Codex agent role TOML.
  * 공식 스키마(필수 name/description/developer_instructions, 선택 model_reasoning_effort/sandbox_mode)
@@ -163,6 +186,7 @@ export declare function renderCodexAgentToml(file: string, raw: string): {
     name: string;
     toml: string;
 } | null;
+export declare const DEV_GUIDE_SKILL_PATTERN: RegExp;
 /** ADR-014 D3 — Codex 스킬에는 `$ARGUMENTS` 치환 변수가 없다. */
 export declare function adaptSkillBodyForCodex(body: string): string;
 export declare function resolveAgentsMdPath(_pkgRoot: string): string;
@@ -173,4 +197,11 @@ export declare function upsertForgenRulesInAgentsMd(opts: {
 }): {
     injected: boolean;
 };
-export {};
+/** AGENTS.md 의 forgen 블록 제거 (uninstall). 블록뿐이던 파일은 삭제한다. */
+export declare function removeForgenRulesFromAgentsMd(opts: {
+    agentsMdPath: string;
+    dryRun: boolean;
+}): {
+    removed: boolean;
+    fileDeleted: boolean;
+};

package/dist/host/install-codex.js

@@ -16,11 +16,13 @@ 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';
+import { HOOK_REGISTRY } from '../hooks/hook-registry.js';
+import { hasManagedSkillMarker, isManagedAgentToml } from './managed-marker.js';
 const MCP_MARKER_BEGIN = '# >>> forgen-managed-mcp';
 const MCP_MARKER_END = '# <<< forgen-managed-mcp';
 const NOTIFY_MARKER_BEGIN = '# >>> forgen-managed-notify';
 const NOTIFY_MARKER_END = '# <<< forgen-managed-notify';
-const FORGEN_SKILL_MARKER = '<!-- forgen-managed -->';
+export const FORGEN_SKILL_MARKER = '<!-- forgen-managed -->';
 const AGENTS_MD_BEGIN = '<!-- >>> forgen-managed-rules -->';
 const AGENTS_MD_END = '<!-- <<< forgen-managed-rules -->';
 function resolveCodexHome(opts) {
@@ -29,18 +31,35 @@ function resolveCodexHome(opts) {
 // 0.4.6 fix — pkgRoot match 외에 script-marker fallback 추가.
 // Stale install path (예: 다른 머신에서 install 한 hooks.json 마운트, 또는
 // node_modules path 변경) 의 forgen entry 를 "user entry" 로 오분류 → 중복 누적
-// 하던 버그. forgen hook 의 시그니처는 dist/host/codex-adapter.js 또는
-// dist/hooks/<name>.js — 사용자 custom hook 과 충돌 가능성 거의 없음.
-const FORGEN_HOOK_SCRIPT_MARKER = /\bdist\/(host\/codex-adapter|hooks\/[a-z][a-z0-9-]+)\.js\b/;
+// 하던 버그.
+//
+// 0.5.7 (critic): fallback 이 `dist/hooks/<아무이름>.js` 전부와 pkgRoot *부분문자열* 을 forgen 으로 봐서
+// 다른 프로젝트의 `…/dist/hooks/pre-commit.js` 나 `<pkgRoot>-fork/hook.sh` 까지 forgen 소유로 분류했다
+// (uninstall 이 그것을 지운다). 이제: (1) pkgRoot 의 dist/ 아래, (2) codex-adapter 경유, (3) registry 에
+// 있는 forgen 훅 스크립트 이름 — 셋 중 하나일 때만.
+const FORGEN_ADAPTER_RE = /[\\/]dist[\\/]host[\\/]codex-adapter\.js(?![\w-])/;
+const FORGEN_HOOK_SCRIPT_RE = /[\\/]dist[\\/]hooks[\\/]([a-z][a-z0-9-]*)\.js(?![\w-])/;
+const FORGEN_HOOK_SCRIPT_NAMES = new Set(HOOK_REGISTRY.map((h) => h.script.split(' ')[0].replace(/^hooks\//, '').replace(/\.js$/, '')));
+/** 훅 command 문자열이 forgen 소유인가. */
+export function isForgenHookCommand(command, pkgRoot) {
+    if (typeof command !== 'string')
+        return false;
+    if (command.includes(`${pkgRoot}/dist/`) || command.includes(`${pkgRoot}\\dist\\`))
+        return true;
+    if (FORGEN_ADAPTER_RE.test(command))
+        return true;
+    const script = command.match(FORGEN_HOOK_SCRIPT_RE)?.[1];
+    return script !== undefined && FORGEN_HOOK_SCRIPT_NAMES.has(script);
+}
 function isForgenManagedHook(entry, pkgRoot) {
     if (!entry || typeof entry !== 'object')
         return false;
     const e = entry;
     if (!Array.isArray(e.hooks))
         return false;
-    return e.hooks.some((h) => typeof h.command === 'string' && (h.command.includes(pkgRoot) || FORGEN_HOOK_SCRIPT_MARKER.test(h.command)));
+    return e.hooks.some((h) => isForgenHookCommand(h.command, pkgRoot));
 }
-function readJsonFile(p) {
+export function readJsonFile(p) {
     try {
         if (!fs.existsSync(p))
             return null;
@@ -115,6 +134,37 @@ function upsertMcpBlock(currentToml, pkgRoot) {
     const content = bom + out.join('\n');
     return { content, alreadyPresent: content === currentToml };
 }
+/**
+ * forgen MCP 블록 제거 (uninstall, ADR-016 D4). forgen 테이블(본문 + `[mcp_servers.forgen-compound.*]` 하위
+ * 테이블)과 마커만 걷어내고, 블록 사이에 Codex 가 끼워 넣은 다른 내용은 그 자리에 보존한다.
+ * 마커 없는 사용자 관리 테이블은 건드리지 않는다.
+ */
+export function removeMcpBlock(currentToml) {
+    const { bom, body } = tomlShape(currentToml);
+    const span = splitManagedSpan(body.split('\n'), MCP_MARKER_BEGIN, MCP_MARKER_END);
+    if (!span)
+        return { content: currentToml, removed: false };
+    const kept = [];
+    let dropping = false;
+    for (const line of span.inner) {
+        const t = line.trim();
+        // 헤더 줄에서만 상태를 바꾼다: forgen 테이블 본체, 그 하위 테이블/배열 테이블은 버리고 나머지는 보존.
+        if (/^\[/.test(t))
+            dropping = /^\[{1,2}mcp_servers\.forgen-compound(\]{1,2}|\.)/.test(t);
+        if (!dropping)
+            kept.push(line);
+    }
+    const foreign = trimBlankEdges(kept);
+    const before = [...span.before];
+    // 블록 앞의 구분용 빈 줄은 블록과 함께 정리 (재설치/제거를 반복해도 빈 줄이 쌓이지 않게)
+    if (foreign.length === 0)
+        while (before.length > 0 && before[before.length - 1].trim() === '')
+            before.pop();
+    const out = [...before, ...foreign, ...span.after];
+    while (out.length > 1 && out[0].trim() === '')
+        out.shift(); // 파일 맨 앞 빈 줄
+    return { content: bom + out.join('\n'), removed: true };
+}
 // ── ADR-016 D1: notify 폴백 (config.toml top-level `notify`) ───────────
 /** forgen notify 바이너리 argv 접두 (`--` 뒤는 사용자가 수동으로 붙인 체인 프로그램). */
 function forgenNotifyArgv(pkgRoot) {
@@ -181,19 +231,30 @@ export function upsertNotifyBlock(currentToml, pkgRoot) {
     const content = bom + (tail.length > 0 ? [...block, cr, ...tail] : [...block, '']).join('\n');
     return { content, status: content === currentToml ? 'already-present' : 'installed' };
 }
-/** forgen notify 블록 제거 (`--no-notify`, uninstall). 블록 사이에 끼어든 다른 줄은 보존. */
+/**
+ * forgen notify 블록 제거 (`--no-notify`, uninstall). 블록 사이에 끼어든 다른 줄은 보존.
+ *
+ * - 사용자가 블록의 notify 줄을 여러 줄 배열 등으로 손편집했으면(`custom`) **건드리지 않는다** — 첫 줄만
+ *   지우면 남은 줄이 깨진 TOML 이 되어 Codex 가 기동하지 못한다 (critic 2026-10-02).
+ * - `"--"` 뒤에 사용자가 체인해 둔 자기 notifier 가 있으면 그 argv 만으로 `notify` 를 되돌려 놓는다.
+ */
 export function removeNotifyBlock(currentToml) {
-    const { bom, body } = tomlShape(currentToml);
-    const { span, foreign } = parseNotifyBlock(body.split('\n'));
+    const { bom, body, cr } = tomlShape(currentToml);
+    const { span, foreign, argv } = parseNotifyBlock(body.split('\n'));
     if (!span)
-        return { content: currentToml, removed: false };
-    const rest = [...span.before, ...foreign, ...span.after];
+        return { content: currentToml, removed: false, custom: false, restoredChain: [] };
+    if (argv === 'unparseable')
+        return { content: currentToml, removed: false, custom: true, restoredChain: [] };
+    const sep = argv ? argv.indexOf('--') : -1;
+    const restoredChain = argv && sep !== -1 ? argv.slice(sep + 1) : [];
+    const restored = restoredChain.length > 0 ? [`notify = ${JSON.stringify(restoredChain)}${cr}`] : [];
+    const rest = [...span.before, ...restored, ...foreign, ...span.after];
     let start = 0;
-    if (span.before.every((l) => l.trim() === '') && foreign.length === 0) {
+    if (span.before.every((l) => l.trim() === '') && restored.length === 0 && foreign.length === 0) {
         while (start < rest.length && rest[start].trim() === '')
             start += 1;
     }
-    return { content: bom + rest.slice(start).join('\n'), removed: true };
+    return { content: bom + rest.slice(start).join('\n'), removed: true, custom: false, restoredChain };
 }
 export function planCodexInstall(opts) {
     const codexHome = resolveCodexHome(opts);
@@ -223,7 +284,11 @@ export function planCodexInstall(opts) {
         const out = [];
         let inserted = false;
         for (const group of existingGroups) {
-            if (isForgenManagedHook(group, opts.pkgRoot)) {
+            // 빈 그룹(`{"hooks": []}`)은 uninstall 이 다른 도구 훅의 trust 인덱스를 지키려고 남긴 자리표시다 —
+            // 재설치 시 그 자리를 다시 채워 forgen 훅이 원래 인덱스(= 이미 승인된 trust 키)로 돌아가게 한다.
+            const isPlaceholder = Array.isArray(group?.hooks)
+                && (group.hooks.length === 0);
+            if (isForgenManagedHook(group, opts.pkgRoot) || isPlaceholder) {
                 if (!inserted) {
                     out.push(...generatedGroups);
                     inserted = true;
@@ -275,6 +340,8 @@ export function planCodexInstall(opts) {
             notify = 'removed';
             configToml = r.content;
         }
+        else if (r.custom)
+            notify = 'custom-block';
     }
     const configTomlToWrite = configToml !== currentToml ? configToml : null;
     // 5) 실제 쓰기 (dryRun 이면 skip) — hooks.json + config.toml
@@ -483,9 +550,7 @@ export function auditCodexHookTrust(opts) {
             if (!Array.isArray(g.hooks))
                 return;
             g.hooks.forEach((h, hi) => {
-                const isForgen = typeof h.command === 'string' &&
-                    (h.command.includes(opts.pkgRoot) || FORGEN_HOOK_SCRIPT_MARKER.test(h.command));
-                if (!isForgen)
+                if (!isForgenHookCommand(h.command, opts.pkgRoot))
                     return;
                 const key = `${codexHookEventKey(event)}:${gi}:${hi}`;
                 if (!CODEX_SUPPORTED_HOOK_EVENTS.has(event)) {
@@ -513,8 +578,8 @@ export function auditCodexHookTrust(opts) {
     return { total, trusted, untrusted, modified, disabled, ignoredByCodex, noStateRecorded: state.size === 0 };
 }
 // ── ADR-014 D2: Codex custom agents (~/.codex/agents/ch-*.toml) ──────
-const AGENT_TOML_MARKER = '# forgen-managed';
-const AGENT_NAME_PREFIX = 'ch-';
+export const AGENT_TOML_MARKER = '# forgen-managed';
+export const AGENT_NAME_PREFIX = 'ch-';
 function parseAgentMarkdown(raw) {
     const fm = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
     if (!fm)
@@ -615,7 +680,7 @@ function installCodexAgents(opts) {
             const st = fs.lstatSync(p);
             if (st.isSymbolicLink())
                 return true; // 사용자 심링크 (dangling 포함) — 건드리지 않음
-            return !fs.readFileSync(p, 'utf-8').slice(0, 64).startsWith(AGENT_TOML_MARKER);
+            return !isManagedAgentToml(fs.readFileSync(p, 'utf-8'));
         }
         catch {
             return false; // 없음
@@ -638,8 +703,7 @@ function installCodexAgents(opts) {
         try {
             if (fs.lstatSync(p).isSymbolicLink())
                 continue;
-            const head = fs.readFileSync(p, 'utf-8').slice(0, 64);
-            if (!head.startsWith(AGENT_TOML_MARKER))
+            if (!isManagedAgentToml(fs.readFileSync(p, 'utf-8')))
                 continue;
             fs.unlinkSync(p);
             removed += 1;
@@ -664,7 +728,7 @@ function installCodexAgents(opts) {
 // ── v0.4.9: dev-guide skills → ~/.codex/skills ────────────────────────
 // dev-guide prefix pattern: forgen-<stack>-<skill> (e.g. forgen-react-fe-build)
 // 반드시 stack 이 react|vue|node|go 인 것만 매칭 — forgen 자체 commands 보존
-const DEV_GUIDE_SKILL_PATTERN = /^forgen-(react|vue|node|go)-/;
+export const DEV_GUIDE_SKILL_PATTERN = /^forgen-(react|vue|node|go)-/;
 function installDevGuideSkillsToCodex(opts) {
     const devGuideRoot = path.join(opts.pkgRoot, 'assets', 'dev-guide');
     const codexSkillsDir = path.join(opts.codexHome, 'skills');
@@ -764,8 +828,7 @@ function installCodexSkills(opts) {
             // 사용자가 forgen 문서를 인용해 본문 안에 marker 가 우연히 포함될 수 있어
             // includes() 만으론 안전 X. 정규식으로 frontmatter 종결(`---\n`) 다음 빈 줄 다음
             // 첫 non-blank 줄에 marker 가 있는지 확인.
-            const fmMarkerRe = /^---\n[\s\S]*?\n---\n\s*<!-- forgen-managed -->/;
-            if (!fmMarkerRe.test(existing))
+            if (!hasManagedSkillMarker(existing))
                 continue; // 사용자 작성 또는 손상 — skip
         }
         const raw = fs.readFileSync(path.join(sourceDir, file), 'utf-8');
@@ -856,6 +919,31 @@ export function upsertForgenRulesInAgentsMd(opts) {
     fs.writeFileSync(agentsMdPath, newContent, 'utf-8');
     return { injected: newContent !== current };
 }
+/** AGENTS.md 의 forgen 블록 제거 (uninstall). 블록뿐이던 파일은 삭제한다. */
+export function removeForgenRulesFromAgentsMd(opts) {
+    let current;
+    try {
+        current = fs.readFileSync(opts.agentsMdPath, 'utf-8');
+    }
+    catch {
+        return { removed: false, fileDeleted: false };
+    }
+    const re = new RegExp(`\\n*${escapeRegex(AGENTS_MD_BEGIN)}[\\s\\S]*?${escapeRegex(AGENTS_MD_END)}\\n?`);
+    if (!re.test(current))
+        return { removed: false, fileDeleted: false };
+    const rest = current.replace(re, '\n').replace(/^\n+/, '');
+    const empty = rest.trim().length === 0;
+    // 심링크면 링크를 지우지 않고 대상 파일에 써 넣는다 (링크만 지우면 대상에 블록이 남는다).
+    const isLink = fs.lstatSync(opts.agentsMdPath).isSymbolicLink();
+    const deleteFile = empty && !isLink;
+    if (!opts.dryRun) {
+        if (deleteFile)
+            fs.unlinkSync(opts.agentsMdPath);
+        else
+            fs.writeFileSync(opts.agentsMdPath, empty ? '' : (rest.endsWith('\n') ? rest : `${rest}\n`), 'utf-8');
+    }
+    return { removed: true, fileDeleted: deleteFile };
+}
 function escapeRegex(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }

package/dist/host/managed-marker.d.ts

@@ -0,0 +1,23 @@
+/**
+ * forgen-managed 소유 판정 — install/uninstall 공용.
+ *
+ * "이 파일을 forgen 이 썼는가" 를 잘못 판정하면 사용자 파일을 덮어쓰거나 지운다. 그래서 마커가 *정해진
+ * 위치* 에 있을 때만 forgen 소유로 본다 (본문에 마커 문자열을 인용한 사용자 파일과 구분).
+ */
+/**
+ * SKILL.md: frontmatter(`---` … 첫 번째 닫는 `---`) **바로 뒤** 에 마커가 있어야 한다.
+ * (이전의 lazy 정규식은 본문의 `---` 구분선 뒤에 나오는 마커까지 매치했다 — critic 2026-10-02.)
+ */
+export declare function hasManagedSkillMarker(content: string): boolean;
+/** Codex agent TOML: 첫 줄이 정확히 마커여야 한다 (`# forgen-managed-by-me` 같은 접두 일치는 사용자 파일). */
+export declare function isManagedAgentToml(content: string): boolean;
+/**
+ * 패키지가 실제로 제공하는 dev-guide 스킬 이름 (`forgen-<stack>-<skill>`).
+ * uninstall 은 이름 패턴이 아니라 이 목록으로 소유를 판정한다 — 사용자가 만든 `forgen-react-mine` 을 지우지 않게.
+ */
+export declare function listDevGuideSkillNames(pkgRoot: string): Set<string>;
+/**
+ * `<skillsDir>/<name>/SKILL.md` 한 개를 제거하고 디렉토리가 비면 디렉토리도 지운다.
+ * 사용자가 그 디렉토리에 다른 파일을 넣어 뒀으면 디렉토리는 남는다. 실제로 SKILL.md 를 지웠을 때만 true.
+ */
+export declare function removeSkillFile(skillsDir: string, name: string, dryRun: boolean): boolean;

package/dist/host/managed-marker.js

@@ -0,0 +1,78 @@
+/**
+ * forgen-managed 소유 판정 — install/uninstall 공용.
+ *
+ * "이 파일을 forgen 이 썼는가" 를 잘못 판정하면 사용자 파일을 덮어쓰거나 지운다. 그래서 마커가 *정해진
+ * 위치* 에 있을 때만 forgen 소유로 본다 (본문에 마커 문자열을 인용한 사용자 파일과 구분).
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+const SKILL_MARKER = '<!-- forgen-managed -->';
+const AGENT_TOML_MARKER = '# forgen-managed';
+/**
+ * SKILL.md: frontmatter(`---` … 첫 번째 닫는 `---`) **바로 뒤** 에 마커가 있어야 한다.
+ * (이전의 lazy 정규식은 본문의 `---` 구분선 뒤에 나오는 마커까지 매치했다 — critic 2026-10-02.)
+ */
+export function hasManagedSkillMarker(content) {
+    const text = content.replace(/\r\n/g, '\n');
+    if (!text.startsWith('---\n'))
+        return false;
+    const close = text.indexOf('\n---\n', 3);
+    if (close === -1)
+        return false;
+    return text.slice(close + 5).trimStart().startsWith(SKILL_MARKER);
+}
+/** Codex agent TOML: 첫 줄이 정확히 마커여야 한다 (`# forgen-managed-by-me` 같은 접두 일치는 사용자 파일). */
+export function isManagedAgentToml(content) {
+    return content.split('\n', 1)[0].replace(/\r$/, '') === AGENT_TOML_MARKER;
+}
+/**
+ * 패키지가 실제로 제공하는 dev-guide 스킬 이름 (`forgen-<stack>-<skill>`).
+ * uninstall 은 이름 패턴이 아니라 이 목록으로 소유를 판정한다 — 사용자가 만든 `forgen-react-mine` 을 지우지 않게.
+ */
+export function listDevGuideSkillNames(pkgRoot) {
+    const names = new Set();
+    const root = path.join(pkgRoot, 'assets', 'dev-guide');
+    try {
+        for (const tier of fs.readdirSync(root)) {
+            const skillsBase = path.join(root, tier, 'skills');
+            if (!fs.existsSync(skillsBase))
+                continue;
+            for (const stack of fs.readdirSync(skillsBase)) {
+                const stackDir = path.join(skillsBase, stack);
+                if (!fs.statSync(stackDir).isDirectory())
+                    continue;
+                for (const skill of fs.readdirSync(stackDir)) {
+                    if (fs.existsSync(path.join(stackDir, skill, 'SKILL.md')))
+                        names.add(`forgen-${stack}-${skill}`);
+                }
+            }
+        }
+    }
+    catch { /* 자산 없음 */ }
+    return names;
+}
+/**
+ * `<skillsDir>/<name>/SKILL.md` 한 개를 제거하고 디렉토리가 비면 디렉토리도 지운다.
+ * 사용자가 그 디렉토리에 다른 파일을 넣어 뒀으면 디렉토리는 남는다. 실제로 SKILL.md 를 지웠을 때만 true.
+ */
+export function removeSkillFile(skillsDir, name, dryRun) {
+    const dir = path.join(skillsDir, name);
+    const file = path.join(dir, 'SKILL.md');
+    try {
+        if (fs.lstatSync(dir).isSymbolicLink() || !fs.statSync(dir).isDirectory())
+            return false;
+        fs.lstatSync(file); // 없으면 throw
+        if (dryRun)
+            return true;
+        fs.unlinkSync(file);
+        try {
+            if (fs.readdirSync(dir).length === 0)
+                fs.rmdirSync(dir);
+        }
+        catch { /* ignore */ }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/host/opencode/plugin/forgen.d.ts

@@ -14,7 +14,7 @@
  */
 import { type ClaudePreToolInput, type OpencodeToolDecision } from '../translate.js';
 /** PreToolUse 가드 순서: pre-tool-use(룰+위험명령 디스패처) → db-guard(rm -rf/위험 SQL). */
-export declare const PRE_TOOL_GUARDS: readonly ["pre-tool-use.js", "db-guard.js"];
+export declare const PRE_TOOL_GUARDS: readonly ['pre-tool-use.js', 'db-guard.js'];
 export interface GuardRunOptions {
     /** forgen hook 바이너리 디렉터리. guard-cli 가 forgen dist/hooks 를 주입. */
     hookDir?: string;

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

@@ -0,0 +1,58 @@
+/**
+ * Codex uninstall — ADR-016 D4
+ *
+ * `forgen install codex` 가 쓴 것을 되돌린다: hooks.json 의 forgen 훅, config.toml 의 MCP/notify 블록,
+ * `skills/`, `agents/ch-*.toml`, cwd 의 AGENTS.md 블록. 사용자 소유물(마커 없는 파일, 심링크, 다른 도구의
+ * 훅)은 보존한다.
+ *
+ * 훅 신뢰 보존: Codex 의 trust 키는 `<event>:<groupIdx>:<hookIdx>` 다. forgen 그룹을 지워 뒤따르는
+ * 사용자 그룹의 인덱스가 당겨지면 **다른 도구의 훅이 재승인 전까지 조용히 skip** 된다. 그래서 뒤에 사용자
+ * 그룹이 남는 위치의 forgen 그룹은 빈 그룹(`{"hooks": []}`)으로 남겨 인덱스를 유지한다 (Codex 0.153.4 는
+ * 빈 그룹을 경고 없이 받아들인다 — `hooks/list` 로 확인). forgen 은 `[hooks.state]` 를 고쳐 쓰지 않는다.
+ */
+import { type HooksFile } from './install-codex.js';
+export interface CodexUninstallOptions {
+    /** forgen package root — 훅 command 소유 판정에 쓴다 (스크립트 시그니처 fallback 이 있어 정확도 비의존). */
+    pkgRoot: string;
+    /** codex home (default: $CODEX_HOME ?? ~/.codex). */
+    codexHome?: string;
+    /** AGENTS.md 위치 override (default: cwd 의 git root). 격리 테스트용. */
+    agentsMdPath?: string;
+    dryRun?: boolean;
+}
+export interface CodexUninstallResult {
+    codexHome: string;
+    /** $CODEX_HOME 자체가 없으면 false — 나머지 필드는 전부 0/false */
+    present: boolean;
+    /** 제거한 forgen 훅 핸들러 수 */
+    hooksRemoved: number;
+    /** 보존한 사용자(다른 도구) 훅 핸들러 수 */
+    userHooksPreserved: number;
+    /** 뒤따르는 사용자 그룹의 trust 인덱스를 지키려고 남긴 빈 그룹 수 */
+    placeholderGroups: number;
+    /** 같은 그룹 안에서 forgen 핸들러가 빠져 인덱스가 바뀐 사용자 훅 (`<event>:<group>:<old>→<new>`) — `/hooks` 재승인 필요 */
+    userHooksReindexed: string[];
+    hooksFileDeleted: boolean;
+    mcpRemoved: boolean;
+    notifyRemoved: boolean;
+    /** forgen notify 블록이 손편집돼(여러 줄 배열 등) 안전하게 지울 수 없어 그대로 둠 */
+    notifyCustomLeft: boolean;
+    /** 블록에 체인돼 있던 사용자 notifier argv — 그것만으로 `notify` 를 되돌려 놓았다 */
+    notifyChainRestored: string[];
+    skillsRemoved: number;
+    agentsRemoved: number;
+    agentsMdCleaned: boolean;
+    /** 단계별 실패 (한 단계가 실패해도 나머지는 진행한다) */
+    errors: string[];
+}
+/** hooks.json 에서 forgen 핸들러 제거 (순수 함수 — 파일을 쓰지 않는다). */
+export declare function stripForgenHooks(file: HooksFile, pkgRoot: string): {
+    next: HooksFile | null;
+    removed: number;
+    preserved: number;
+    placeholders: number;
+    reindexed: string[];
+};
+export declare function planCodexUninstall(opts: CodexUninstallOptions): CodexUninstallResult;
+/** CLI 출력 — 무엇을 지웠고 무엇을 남겼는지. */
+export declare function renderCodexUninstall(r: CodexUninstallResult): string[];

package/dist/host/uninstall-codex.js

@@ -0,0 +1,246 @@
+/**
+ * Codex uninstall — ADR-016 D4
+ *
+ * `forgen install codex` 가 쓴 것을 되돌린다: hooks.json 의 forgen 훅, config.toml 의 MCP/notify 블록,
+ * `skills/`, `agents/ch-*.toml`, cwd 의 AGENTS.md 블록. 사용자 소유물(마커 없는 파일, 심링크, 다른 도구의
+ * 훅)은 보존한다.
+ *
+ * 훅 신뢰 보존: Codex 의 trust 키는 `<event>:<groupIdx>:<hookIdx>` 다. forgen 그룹을 지워 뒤따르는
+ * 사용자 그룹의 인덱스가 당겨지면 **다른 도구의 훅이 재승인 전까지 조용히 skip** 된다. 그래서 뒤에 사용자
+ * 그룹이 남는 위치의 forgen 그룹은 빈 그룹(`{"hooks": []}`)으로 남겨 인덱스를 유지한다 (Codex 0.153.4 는
+ * 빈 그룹을 경고 없이 받아들인다 — `hooks/list` 로 확인). forgen 은 `[hooks.state]` 를 고쳐 쓰지 않는다.
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { AGENT_NAME_PREFIX, codexHookEventKey, isForgenHookCommand, removeForgenRulesFromAgentsMd, removeMcpBlock, removeNotifyBlock, resolveAgentsMdPath, } from './install-codex.js';
+import { hasManagedSkillMarker, isManagedAgentToml, listDevGuideSkillNames, removeSkillFile } from './managed-marker.js';
+const FORGEN_HOOKS_DESCRIPTION_RE = /^forgen Codex hooks \(managed/;
+function isEmptyGroup(g) {
+    const hooks = g?.hooks;
+    return Array.isArray(hooks) && hooks.length === 0;
+}
+/** hooks.json 에서 forgen 핸들러 제거 (순수 함수 — 파일을 쓰지 않는다). */
+export function stripForgenHooks(file, pkgRoot) {
+    let removed = 0;
+    let preserved = 0;
+    let placeholders = 0;
+    const reindexed = [];
+    const nextHooks = {};
+    for (const [event, rawGroups] of Object.entries(file.hooks ?? {})) {
+        if (!Array.isArray(rawGroups)) {
+            nextHooks[event] = rawGroups;
+            continue;
+        }
+        const groups = rawGroups.map((group, gi) => {
+            const g = group;
+            if (!Array.isArray(g?.hooks))
+                return group; // 모르는 형태 — 건드리지 않는다
+            const kept = [];
+            g.hooks.forEach((h, hi) => {
+                if (isForgenHookCommand(h?.command, pkgRoot)) {
+                    removed += 1;
+                    return;
+                }
+                if (kept.length !== hi)
+                    reindexed.push(`${codexHookEventKey(event)}:${gi}:${hi}→${kept.length}`);
+                kept.push(h);
+                preserved += 1;
+            });
+            if (kept.length === g.hooks.length)
+                return group; // forgen 핸들러 없음 — 원본 그대로
+            // forgen 전용 그룹은 자리표시용 빈 그룹으로 (matcher 는 의미가 없어 뺀다)
+            return kept.length === 0 ? { hooks: [] } : { ...g, hooks: kept };
+        });
+        // 뒤에서부터 빈 그룹을 걷어낸다 — 뒤따르는 그룹이 없으면 인덱스를 지킬 이유가 없다.
+        while (groups.length > 0 && isEmptyGroup(groups[groups.length - 1]))
+            groups.pop();
+        if (groups.length === 0)
+            continue;
+        placeholders += groups.filter(isEmptyGroup).length;
+        nextHooks[event] = groups;
+    }
+    const { description, hooks: _hooks, ...rest } = file;
+    const keepDescription = typeof description === 'string' && !FORGEN_HOOKS_DESCRIPTION_RE.test(description);
+    const nothingLeft = Object.keys(nextHooks).length === 0 && Object.keys(rest).length === 0 && !keepDescription;
+    if (nothingLeft)
+        return { next: null, removed, preserved, placeholders, reindexed };
+    const next = { ...(keepDescription ? { description } : {}), ...rest, hooks: nextHooks };
+    return { next, removed, preserved, placeholders, reindexed };
+}
+function removeManagedSkills(skillsDir, pkgRoot, dryRun) {
+    let removed = 0;
+    let entries;
+    try {
+        entries = fs.readdirSync(skillsDir);
+    }
+    catch {
+        return 0;
+    }
+    // dev-guide 스킬은 이름 패턴이 아니라 패키지가 실제로 제공하는 이름으로 소유를 판정한다.
+    const devGuideNames = listDevGuideSkillNames(pkgRoot);
+    for (const name of entries) {
+        const skillFile = path.join(skillsDir, name, 'SKILL.md');
+        let owned = devGuideNames.has(name);
+        if (!owned) {
+            try {
+                owned = !fs.lstatSync(skillFile).isSymbolicLink() && hasManagedSkillMarker(fs.readFileSync(skillFile, 'utf-8'));
+            }
+            catch {
+                owned = false;
+            }
+        }
+        if (owned && removeSkillFile(skillsDir, name, dryRun))
+            removed += 1;
+    }
+    return removed;
+}
+function removeManagedAgents(agentsDir, dryRun) {
+    let removed = 0;
+    let entries;
+    try {
+        entries = fs.readdirSync(agentsDir);
+    }
+    catch {
+        return 0;
+    }
+    for (const entry of entries) {
+        if (!entry.startsWith(AGENT_NAME_PREFIX) || !entry.endsWith('.toml'))
+            continue;
+        const p = path.join(agentsDir, entry);
+        try {
+            if (fs.lstatSync(p).isSymbolicLink())
+                continue;
+            if (!isManagedAgentToml(fs.readFileSync(p, 'utf-8')))
+                continue;
+            if (!dryRun)
+                fs.unlinkSync(p);
+            removed += 1;
+        }
+        catch { /* best-effort */ }
+    }
+    return removed;
+}
+export function planCodexUninstall(opts) {
+    const codexHome = opts.codexHome ?? process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex');
+    const dryRun = opts.dryRun ?? false;
+    const result = {
+        codexHome,
+        present: fs.existsSync(codexHome),
+        hooksRemoved: 0,
+        userHooksPreserved: 0,
+        placeholderGroups: 0,
+        userHooksReindexed: [],
+        hooksFileDeleted: false,
+        mcpRemoved: false,
+        notifyRemoved: false,
+        notifyCustomLeft: false,
+        notifyChainRestored: [],
+        skillsRemoved: 0,
+        agentsRemoved: 0,
+        agentsMdCleaned: false,
+        errors: [],
+    };
+    if (!result.present)
+        return result;
+    // 각 단계는 독립이다 — 하나가 실패(읽기 전용 파일 등)해도 나머지 정리는 계속한다.
+    const step = (label, fn) => {
+        try {
+            fn();
+        }
+        catch (e) {
+            result.errors.push(`${label}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    };
+    // 1) hooks.json
+    step('hooks.json', () => {
+        const hooksPath = path.join(codexHome, 'hooks.json');
+        if (!fs.existsSync(hooksPath))
+            return;
+        let hooksFile;
+        try {
+            hooksFile = JSON.parse(fs.readFileSync(hooksPath, 'utf-8'));
+        }
+        catch {
+            throw new Error('not valid JSON — left untouched (remove forgen entries by hand)');
+        }
+        const hooks = hooksFile?.hooks;
+        if (!hooks || typeof hooks !== 'object' || Array.isArray(hooks))
+            return;
+        const stripped = stripForgenHooks(hooksFile, opts.pkgRoot);
+        result.hooksRemoved = stripped.removed;
+        result.userHooksPreserved = stripped.preserved;
+        result.placeholderGroups = stripped.placeholders;
+        result.userHooksReindexed = stripped.reindexed;
+        if (stripped.removed === 0)
+            return;
+        result.hooksFileDeleted = stripped.next === null;
+        if (dryRun)
+            return;
+        if (stripped.next === null)
+            fs.unlinkSync(hooksPath);
+        else
+            fs.writeFileSync(hooksPath, `${JSON.stringify(stripped.next, null, 2)}\n`, 'utf-8');
+    });
+    // 2) config.toml — MCP / notify 블록
+    step('config.toml', () => {
+        const configTomlPath = path.join(codexHome, 'config.toml');
+        if (!fs.existsSync(configTomlPath))
+            return;
+        const current = fs.readFileSync(configTomlPath, 'utf-8');
+        const mcp = removeMcpBlock(current);
+        const notify = removeNotifyBlock(mcp.content);
+        result.mcpRemoved = mcp.removed;
+        result.notifyRemoved = notify.removed;
+        result.notifyCustomLeft = notify.custom;
+        result.notifyChainRestored = notify.restoredChain;
+        if (!dryRun && notify.content !== current)
+            fs.writeFileSync(configTomlPath, notify.content, 'utf-8');
+    });
+    // 3) skills / agents
+    step('skills', () => { result.skillsRemoved = removeManagedSkills(path.join(codexHome, 'skills'), opts.pkgRoot, dryRun); });
+    step('agents', () => { result.agentsRemoved = removeManagedAgents(path.join(codexHome, 'agents'), dryRun); });
+    // 4) AGENTS.md (cwd 의 git root)
+    step('AGENTS.md', () => {
+        const agentsMdPath = opts.agentsMdPath ?? resolveAgentsMdPath(opts.pkgRoot);
+        result.agentsMdCleaned = removeForgenRulesFromAgentsMd({ agentsMdPath, dryRun }).removed;
+    });
+    return result;
+}
+/** CLI 출력 — 무엇을 지웠고 무엇을 남겼는지. */
+export function renderCodexUninstall(r) {
+    if (!r.present)
+        return [];
+    const lines = [];
+    if (r.hooksRemoved > 0) {
+        lines.push(`  ✓ Removed ${r.hooksRemoved} forgen hook(s) from Codex hooks.json${r.hooksFileDeleted ? ' (file deleted — nothing else was in it)' : ` (kept ${r.userHooksPreserved} hook(s) from other tools)`}`);
+        if (r.placeholderGroups > 0) {
+            lines.push(`    ↳ left ${r.placeholderGroups} empty group(s) so the hooks after them keep their Codex trust (deleting them means re-approving those hooks in /hooks)`);
+        }
+        if (r.userHooksReindexed.length > 0) {
+            lines.push(`    ⚠ ${r.userHooksReindexed.length} hook(s) shared a group with forgen and moved (${r.userHooksReindexed.slice(0, 3).join(', ')}) — re-approve them in codex /hooks`);
+        }
+    }
+    if (r.mcpRemoved)
+        lines.push('  ✓ Removed forgen-compound MCP block from Codex config.toml');
+    if (r.notifyRemoved) {
+        lines.push(r.notifyChainRestored.length > 0
+            ? `  ✓ Removed forgen notify wrapper from Codex config.toml — your chained notifier is kept: notify = ${JSON.stringify(r.notifyChainRestored)}`
+            : '  ✓ Removed forgen notify block from Codex config.toml');
+    }
+    if (r.notifyCustomLeft) {
+        lines.push('  ⚠ The forgen notify block in Codex config.toml was hand-edited (multi-line) — left in place. Remove the lines between the forgen-managed-notify markers yourself.');
+    }
+    if (r.skillsRemoved > 0)
+        lines.push(`  ✓ Removed ${r.skillsRemoved} forgen skill(s) from ${path.join(r.codexHome, 'skills')}`);
+    if (r.agentsRemoved > 0)
+        lines.push(`  ✓ Removed ${r.agentsRemoved} ch-*.toml agent(s) from ${path.join(r.codexHome, 'agents')}`);
+    if (r.agentsMdCleaned)
+        lines.push('  ✓ Removed forgen block from AGENTS.md');
+    for (const e of r.errors)
+        lines.push(`  ✗ Codex cleanup — ${e}`);
+    if (lines.length > 0) {
+        lines.push('    note: AGENTS.md blocks in other projects where you ran `forgen install codex` are not touched — run `forgen uninstall` there or delete the forgen-managed-rules block.');
+    }
+    return lines;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wooojin/forgen",
-  "version": "0.5.6",
+  "version": "0.5.7",
   "preferGlobal": true,
   "main": "dist/lib.js",
   "types": "./dist/lib.d.ts",
@@ -78,15 +78,14 @@
   ],
   "devDependencies": {
     "@biomejs/biome": "^2.4.16",
-    "@types/js-yaml": "^4.0.9",
     "@types/node": "^26.1.1",
-    "@vitest/coverage-v8": "^4.1.7",
-    "typescript": "^5.9.3",
-    "vitest": "^4.1.7"
+    "@vitest/coverage-v8": "^5.0.2",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.2"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.28.0",
-    "js-yaml": "^4.1.1",
+    "js-yaml": "^5.4.2",
     "jsonc-parser": "^3.3.1",
     "zod": "^4.4.3"
   },

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://claude.ai/schemas/claude-plugin.json",
   "name": "forgen",
-  "version": "0.5.6",
+  "version": "0.5.7",
   "description": "Claude Code harness — the more you use Claude, the better it gets",
   "author": {
     "name": "jang-ujin",