@wooojin/forgen 0.5.5 → 0.5.7

package/dist/host/install-orchestrator.js

@@ -97,10 +97,10 @@ export async function runInstall(opts) {
     const dryRun = opts.dryRun ?? false;
     const registerMcp = opts.registerMcp ?? true;
     if (target === 'claude' || target === 'both') {
-        result.claude = planClaudeInstall({ pkgRoot: opts.pkgRoot, dryRun, registerMcp });
+        result.claude = planClaudeInstall({ pkgRoot: opts.pkgRoot, dryRun, registerMcp, installVerifySkill: opts.installVerifySkill });
     }
     if (target === 'codex' || target === 'both') {
-        result.codex = planCodexInstall({ pkgRoot: opts.pkgRoot, dryRun, registerMcp });
+        result.codex = planCodexInstall({ pkgRoot: opts.pkgRoot, dryRun, registerMcp, registerNotify: opts.registerNotify });
     }
     // W3-3: opencode 는 명시 타겟일 때만 설치('both' 는 claude+codex primary-pair 유지).
     if (target === 'opencode') {
@@ -120,6 +120,12 @@ export function renderResult(result, dryRun) {
         lines.push(`    settings.json hooks: ${result.claude.hooksInjected}`);
         lines.push(`    MCP: ${result.claude.mcpAlreadyPresent ? 'already present' : (result.claude.mcpRegistered ? 'registered' : 'skipped')}`);
         lines.push(`    skills: ${result.claude.skillsInstalled ?? 0} installed → ${result.claude.skillsPath ?? ''}`);
+        const verifyLine = {
+            installed: 'installed → ~/.claude/skills/verify (Claude runs it right before non-docs commits)',
+            'user-owned': 'skipped — you already have your own `verify` skill (kept as is)',
+            skipped: 'skipped (--no-verify-skill)',
+        };
+        lines.push(`    verify skill: ${verifyLine[result.claude.verifySkill]}`);
     }
     if (result.codex) {
         lines.push('');
@@ -135,8 +141,22 @@ export function renderResult(result, dryRun) {
             lines.push(`    hook trust: ${t.trusted}/${t.total} trusted${t.ignoredByCodex.length ? ` (+${t.ignoredByCodex.length} Claude-only event ignored by Codex)` : ''}`);
         }
         else {
-            lines.push(`    hook trust: ${t.trusted}/${t.total} trusted — ${t.untrusted.length} hook(s) need review. Codex skips untrusted hooks: run \`/hooks\` inside codex and trust the forgen entries.`);
+            const pending = [...t.modified.map((k) => `${k} (modified)`), ...t.untrusted.map((k) => `${k} (new)`), ...t.disabled.map((k) => `${k} (disabled)`)];
+            lines.push(`    hook trust: ${t.trusted}/${t.total} trusted — ${pending.length} hook(s) need review: ${pending.slice(0, 6).join(', ')}${pending.length > 6 ? ', …' : ''}`);
+            lines.push('      Codex skips these until approved/enabled: run `/hooks` inside codex and trust the forgen entries.');
+            if (t.modified.some((k) => k.startsWith('session_start:'))) {
+                lines.push('      ⚠ session_start is pending — the <forgen-rules> block is NOT injected into Codex sessions until you approve it.');
+            }
         }
+        const notifyLine = {
+            installed: 'registered (turn-complete fallback — runs even while hooks are untrusted)',
+            'already-present': 'already present',
+            'user-defined': 'skipped — your config.toml already defines `notify` (kept as is). To chain forgen: notify = ["node", "<pkgRoot>/dist/host/codex-notify.js", "--", <your argv…>]',
+            'custom-block': 'left as is — the forgen notify block in config.toml was hand-edited into a form forgen will not rewrite (keep it on one line as a JSON array to let forgen manage it)',
+            skipped: 'skipped (--no-notify)',
+            removed: 'removed (--no-notify)',
+        };
+        lines.push(`    notify: ${notifyLine[result.codex.notify]}`);
     }
     if (result.opencode) {
         lines.push('');

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.5",
+  "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.5",
+  "version": "0.5.7",
   "description": "Claude Code harness — the more you use Claude, the better it gets",
   "author": {
     "name": "jang-ujin",