@wooojin/forgen 0.5.8 → 0.5.9

package/.claude-plugin/plugin.json

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

package/CHANGELOG.md

@@ -7,6 +7,45 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.9] — 2026-10-02 — 남겨 둔 한계 정리: 사용자 스킬 보존 · AGENTS.md 전체 정리 · OpenCode uninstall · claude-mem 13.28
+
+### Fixed
+- **`forgen install` / npm postinstall 이 사용자가 만든 `forgen-*` 스킬을 지우던 것.** dev-guide 스킬의 stale 정리가 이름만 보고
+  디렉토리를 재귀 삭제했다 (`install claude` 는 `forgen-*` 전부, `install codex`/postinstall 은 `forgen-(react|vue|node|go)-*`).
+  이제 forgen 소유만 정리한다: 패키지가 현재 제공하는 이름, 또는 `SKILL.md` 가 `…/assets/dev-guide/…` 를 가리키는 심링크(이전
+  버전이 설치한 것). 삭제도 `SKILL.md` 한 파일과 빈 디렉토리만. 설치는 이미 있는 것을 덮어쓰지 않는다 — 심링크된 스킬
+  디렉토리(dotfiles 등)를 따라 들어가 쓰지 않고, 한 스킬 자리가 막혀 있어도 나머지 설치는 계속한다.
+- AGENTS.md 블록 처리: 마커가 한 줄을 통째로 차지할 때만 블록 경계로 본다. 본문에 마커 문자열을 인용한 문서에서 인용 줄부터
+  실제 블록 끝까지를 덮어쓰거나 지울 수 있었다.
+- **forgen-eval**: `workerStatus()` 가 "Worker is not running" 을 실행 중으로 판정하던 것. claude-mem recall 이 `sqlite3` CLI 에만
+  의존해 CLI 가 없는 머신에서는 조용히 비어 있던 것(forgen+mem arm 이 forgen-only 와 같아짐) — `node:sqlite` 우선 + CLI 폴백,
+  둘 다 없으면 run 경고. `CLAUDE_MEM_TESTED_VERSION` 이 12.4.8 에 머물러 매 실행 version-mismatch 경고가 나던 것.
+
+### Added
+- **`forgen uninstall` 이 다른 프로젝트의 AGENTS.md 블록도 정리한다.** `forgen install codex|opencode` 가 블록을 쓴 경로를 host
+  설정 디렉토리의 `forgen-agents-md.json` 에 기록하고, uninstall 이 기록된 경로 전부 + 실행한 cwd 를 정리한 뒤 기록을 지운다.
+  (0.5.9 이전 설치분은 기록이 없어 여전히 cwd 만 정리된다.)
+- **OpenCode uninstall.** forgen-managed plugin 제거(설치 때 백업한 사용자 plugin 이 있으면 되돌림), config(JSONC) 의
+  `mcp.forgen-compound` 를 forgen 시그니처일 때만 제거(다른 키·서버의 값은 보존, 인접 주석/포맷은 바뀔 수 있음; 파싱 불가면
+  건드리지 않음), AGENTS.md 블록. plugin 소유는 첫 줄의 `// forgen-managed` 로만 판정한다.
+- uninstall 이 쓰지 못한 AGENTS.md(읽기 전용 등)는 오류로 알리고 기록에 남겨 다음 실행에서 다시 시도한다.
+
+### Changed
+- **claude-mem 13.12.4 → 13.28.0** (forgen-eval 테스트베드 핀, Dependabot #136). 0.5.7 에서 "재측정 필요" 로 보류했으나 근거가
+  약했다 — 저장소의 측정 리포트는 claude-mem 버전에 묶여 있지 않고 forgen-eval 이 의존하는 것은 CLI 계약이다. 격리 HOME 에 두
+  버전을 설치해 계약이 동일함을 실측: `version`/`start`/`status`/`stop`, `search` 출력(JSON + `| #N |` 표), DB 컬럼, 비매칭
+  쿼리 동작.
+
+### Verified
+- fresh-context critic 리뷰: MAJOR 2 · MINOR 10 → 반영 또는 한계로 명시(ADR-016). 리뷰어의 재현 환경(심링크된 스킬 디렉토리)을
+  CLI `install both` 와 postinstall 에 다시 돌려 사용자 파일이 그대로임을 확인.
+- vitest 3242 통과 + forgen-eval 72 통과 (신규: 실 SQLite DB 로 recall 계약, worker 판정, 핀 일치 강제; 사용자 스킬 보존;
+  AGENTS.md 기록/정리; OpenCode uninstall).
+- 격리 HOME 실행: 실 claude-mem 13.28.0 워커에 대해 빌드된 recall 경로가 시드한 observation 본문을 돌려주고, 워커 on/off 판정이
+  맞음. CLI `install both` + `install opencode` 를 두 프로젝트에서 실행한 뒤 다른 디렉토리에서 `uninstall --force` —
+  두 AGENTS.md 블록·OpenCode plugin/MCP·Codex 등록분 제거, 사용자 스킬과 사용자 AGENTS.md 내용 보존.
+
+
 ## [0.5.8] — 2026-10-02 — Codex 가 재배치한 마커에서도 설치·제거가 정확하게 (Codex 0.160 확인)
 
 ### Fixed

package/dist/core/uninstall.js

@@ -364,7 +364,8 @@ export async function handleUninstall(cwd, options) {
     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), 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');
+    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 blocks (every project recorded at install time) — hooks and files from other tools are kept');
+    console.log('     OpenCode (if its config dir exists): the forgen plugin, the forgen-compound MCP entry, AGENTS.md blocks');
     if (options.purge) {
         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.');
@@ -409,6 +410,14 @@ export async function handleUninstall(cwd, options) {
     catch (e) {
         console.error('  ✗ Codex cleanup failed:', e instanceof Error ? e.message : String(e));
     }
+    try {
+        const { planOpencodeUninstall, renderOpencodeUninstall } = await import('../host/uninstall-opencode.js');
+        for (const line of renderOpencodeUninstall(planOpencodeUninstall({ pkgRoot })))
+            console.log(line);
+    }
+    catch (e) {
+        console.error('  ✗ OpenCode cleanup failed:', e instanceof Error ? e.message : String(e));
+    }
     cleanPluginArtifacts();
     if (options.purge) {
         try {

package/dist/host/install-claude.js

@@ -18,7 +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';
+import { hasManagedSkillMarker, installSkillFile, removeOwnedDevGuideSkills } from './managed-marker.js';
 const PLUGIN_KEY = 'forgen@forgen-local';
 const FORGEN_MANAGED_MARKER = '<!-- forgen-managed -->';
 function readPkgVersion(pkgRoot) {
@@ -266,40 +266,14 @@ function installDevGuideSkills(opts) {
         return { skillsPath: skillsDir, skillsInstalled: entries.length, skillsRemoved: 0 };
     }
     fs.mkdirSync(skillsDir, { recursive: true });
-    // Remove stale forgen-* skill dirs (idempotent re-install, do not touch user's own skills)
-    let removed = 0;
-    for (const entry of fs.readdirSync(skillsDir)) {
-        if (!entry.startsWith(FORGEN_SKILL_PREFIX))
-            continue;
-        const fullPath = path.join(skillsDir, entry);
-        if (fs.statSync(fullPath).isDirectory()) {
-            fs.rmSync(fullPath, { recursive: true, force: true });
-            removed += 1;
-        }
-    }
-    // Install each skill via symlink → cpSync fallback (mirrors plugin cache pattern)
+    // stale 정리 — forgen 이 설치한 dev-guide 스킬만 (패키지가 제공하는 이름 / dev-guide 를 가리키는 심링크).
+    // 이전엔 `forgen-*` 디렉토리를 이름만 보고 재귀 삭제해 사용자가 만든 스킬까지 지웠다 (ADR-016 0.5.9).
+    const removed = removeOwnedDevGuideSkills(skillsDir, pkgRoot);
+    // 설치 — 이미 있는 것(사용자 심링크 디렉토리, 남아 있는 SKILL.md)은 덮어쓰지 않는다.
     let installed = 0;
     for (const { name, src } of entries) {
-        const targetDir = path.join(skillsDir, name);
-        fs.mkdirSync(targetDir, { recursive: true });
-        const targetFile = path.join(targetDir, 'SKILL.md');
-        let linked = false;
-        let symlinkErr = null;
-        try {
-            fs.symlinkSync(src, targetFile, 'file');
-            linked = true;
-        }
-        catch (e) {
-            symlinkErr = e;
-        }
-        if (!linked && symlinkErr) {
-            const code = symlinkErr.code ?? 'UNKNOWN';
-            process.stderr.write(`[forgen] symlink ${src} → ${targetFile} failed (${code}); falling back to copyFile.\n`);
-        }
-        if (!linked) {
-            fs.copyFileSync(src, targetFile);
-        }
-        installed += 1;
+        if (installSkillFile(src, skillsDir, name))
+            installed += 1;
     }
     return { skillsPath: skillsDir, skillsInstalled: installed, skillsRemoved: removed };
 }

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

@@ -199,7 +199,29 @@ export declare function upsertForgenRulesInAgentsMd(opts: {
 }): {
     injected: boolean;
 };
-/** AGENTS.md 의 forgen 블록 제거 (uninstall). 블록뿐이던 파일은 삭제한다. */
+export declare function readAgentsMdInstalls(hostDir: string): string[];
+export declare function recordAgentsMdInstall(hostDir: string, agentsMdPath: string): void;
+export declare function clearAgentsMdInstalls(hostDir: string): void;
+/**
+ * 기록된 경로 + 지금의 cwd 경로에서 forgen 블록을 걷어낸다.
+ * 쓰지 못한 경로(읽기 전용 등)는 `failed` 로 돌려주고 **기록에 남긴다** — 다음 uninstall 이 다시 시도할 수 있게.
+ */
+export declare function removeForgenRulesEverywhere(opts: {
+    hostDir: string;
+    cwdAgentsMdPath: string;
+    dryRun: boolean;
+}): {
+    cleaned: string[];
+    failed: Array<{
+        path: string;
+        error: string;
+    }>;
+};
+/**
+ * AGENTS.md 의 forgen 블록 제거 (uninstall). 블록뿐이던 파일은 삭제한다.
+ * BEGIN/END 마커가 각각 한 줄로, 순서대로 있을 때만 동작한다 (블록이 여러 개면 전부 제거).
+ * 읽을 수 없으면 no-op, 쓸 수 없으면 throw — 호출부가 보고한다.
+ */
 export declare function removeForgenRulesFromAgentsMd(opts: {
     agentsMdPath: string;
     dryRun: boolean;

package/dist/host/install-codex.js

@@ -17,7 +17,7 @@ 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';
+import { hasManagedSkillMarker, installSkillFile, isManagedAgentToml, removeOwnedDevGuideSkills } 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';
@@ -553,6 +553,8 @@ export function planCodexInstall(opts) {
     //    pkgRoot 의 git repo root 의 AGENTS.md, 또는 explicit override.
     const agentsMdPath = opts.agentsMdPath ?? resolveAgentsMdPath(opts.pkgRoot);
     const agentsResult = upsertForgenRulesInAgentsMd({ agentsMdPath, pkgRoot: opts.pkgRoot, dryRun: opts.dryRun ?? false });
+    if (!opts.dryRun)
+        recordAgentsMdInstall(codexHome, agentsMdPath);
     // 8) v0.4.9: dev-guide skills → ~/.codex/skills/forgen-<stack>-<skill>/SKILL.md
     const devGuideResult = installDevGuideSkillsToCodex({
         pkgRoot: opts.pkgRoot,
@@ -947,33 +949,13 @@ function installDevGuideSkillsToCodex(opts) {
         return { devGuideSkillsPath: codexSkillsDir, devGuideSkillsInstalled: entries.length, devGuideSkillsRemoved: 0 };
     }
     fs.mkdirSync(codexSkillsDir, { recursive: true });
-    // Stale cleanup: dev-guide pattern 만 정리 (forgen 자체 commands 보존)
-    let removed = 0;
-    for (const entry of fs.readdirSync(codexSkillsDir)) {
-        if (DEV_GUIDE_SKILL_PATTERN.test(entry)) {
-            try {
-                fs.rmSync(path.join(codexSkillsDir, entry), { recursive: true, force: true });
-                removed++;
-            }
-            catch { /* best-effort */ }
-        }
-    }
-    // Install via symlink → copyFileSync fallback
+    // stale 정리 — forgen 이 설치한 dev-guide 스킬만 (사용자가 만든 `forgen-<stack>-*` 스킬은 보존, ADR-016 0.5.9)
+    const removed = removeOwnedDevGuideSkills(codexSkillsDir, opts.pkgRoot);
+    // 설치 — 이미 있는 것(사용자 심링크 디렉토리, 남아 있는 SKILL.md)은 덮어쓰지 않는다.
     let installed = 0;
     for (const { name, src } of entries) {
-        const dstDir = path.join(codexSkillsDir, name);
-        fs.mkdirSync(dstDir, { recursive: true });
-        const dst = path.join(dstDir, 'SKILL.md');
-        let linked = false;
-        try {
-            fs.symlinkSync(src, dst, 'file');
-            linked = true;
-        }
-        catch { /* fallback */ }
-        if (!linked) {
-            fs.copyFileSync(src, dst);
-        }
-        installed++;
+        if (installSkillFile(src, codexSkillsDir, name))
+            installed++;
     }
     return { devGuideSkillsPath: codexSkillsDir, devGuideSkillsInstalled: installed, devGuideSkillsRemoved: removed };
 }
@@ -1081,26 +1063,36 @@ export function upsertForgenRulesInAgentsMd(opts) {
     if (fs.existsSync(agentsMdPath)) {
         current = fs.readFileSync(agentsMdPath, 'utf-8');
     }
-    // Phase 3 critic fix #1: RegExp lastIndex 위험 회피 — g flag 제거 + 매번 새 RegExp.
-    const reMarker = new RegExp(`${escapeRegex(AGENTS_MD_BEGIN)}[\\s\\S]*?${escapeRegex(AGENTS_MD_END)}`);
-    const hasBlock = reMarker.test(current);
-    // Phase 3 critic fix #2: AGENTS.md self-heal — begin marker 만 있고 end 손상 시
-    // 누적 방지. begin 부터 파일 끝까지 + AGENTS_MD_END 미존재 = 손상으로 판단,
-    // begin 부터 파일 끝까지를 *전부* 새 block 으로 교체.
+    // 블록 경계는 마커가 한 줄을 통째로 차지할 때만 인정한다 (본문에 마커 문자열을 인용한 줄과 구분 —
+    // 이전의 문자열 정규식은 인용된 BEGIN 부터 실제 END 까지를 블록으로 보고 그 사이의 사용자 글을 덮어썼다).
+    const lines = current.split('\n');
+    const blocks = findAgentsBlocks(lines);
+    const blockLines = block.split('\n');
     let newContent;
-    if (hasBlock) {
-        newContent = current.replace(reMarker, block);
+    if (blocks.length > 0) {
+        // 첫 블록 자리에 새 블록, 나머지 중복 블록은 제거
+        const drop = new Set();
+        for (const b of blocks)
+            for (let i = b.begin; i <= b.end; i += 1)
+                drop.add(i);
+        const out = [];
+        lines.forEach((l, i) => {
+            if (i === blocks[0].begin)
+                out.push(...blockLines);
+            if (!drop.has(i))
+                out.push(l);
+        });
+        newContent = out.join('\n');
     }
     else {
-        const beginIdx = current.indexOf(AGENTS_MD_BEGIN);
-        const endIdx = current.indexOf(AGENTS_MD_END);
-        if (beginIdx !== -1 && endIdx === -1) {
-            // 손상: begin 만 있음 → begin 부터 끝까지 교체 (self-heal)
-            newContent = `${current.slice(0, beginIdx).replace(/\s+$/, '')}\n\n${block}\n`;
+        // self-heal: BEGIN 줄만 있고 END 가 없으면(손상) BEGIN 부터 파일 끝까지를 새 블록으로 교체 — 누적 방지.
+        const beginIdx = lines.findIndex((l) => l.trim() === AGENTS_MD_BEGIN);
+        if (beginIdx !== -1) {
+            newContent = `${lines.slice(0, beginIdx).join('\n').replace(/\s+$/, '')}\n\n${block}\n`.replace(/^\n+/, '');
         }
         else {
-            // 깨끗한 신규 또는 둘 다 없음 → 끝에 append
-            newContent = `${current.replace(/\s+$/, '')}${current.length > 0 ? '\n\n' : ''}${block}\n`;
+            // 깨끗한 신규 → 끝에 append
+            newContent = `${current.replace(/\s+$/, '')}${current.trim().length > 0 ? '\n\n' : ''}${block}\n`;
         }
     }
     if (dryRun)
@@ -1109,7 +1101,89 @@ export function upsertForgenRulesInAgentsMd(opts) {
     fs.writeFileSync(agentsMdPath, newContent, 'utf-8');
     return { injected: newContent !== current };
 }
-/** AGENTS.md 의 forgen 블록 제거 (uninstall). 블록뿐이던 파일은 삭제한다. */
+// ── AGENTS.md 설치 위치 기록 (ADR-016 0.5.9) ────────────────────────────
+//
+// `forgen install codex|opencode` 는 실행한 cwd 의 AGENTS.md 에 블록을 쓴다. 어디에 썼는지 남기지 않으면
+// uninstall 은 그때의 cwd 것만 지울 수 있다. host 설정 디렉토리에 경로 목록을 둔다 (전역 forgen state 가
+// 아니라 host 디렉토리 — 그 host 설치의 흔적이고, 격리 설치끼리 기록이 섞이지 않는다).
+const AGENTS_MD_REGISTRY = 'forgen-agents-md.json';
+export function readAgentsMdInstalls(hostDir) {
+    try {
+        const data = JSON.parse(fs.readFileSync(path.join(hostDir, AGENTS_MD_REGISTRY), 'utf-8'));
+        return Array.isArray(data.paths) ? data.paths.filter((p) => typeof p === 'string') : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function recordAgentsMdInstall(hostDir, agentsMdPath) {
+    try {
+        const abs = path.resolve(agentsMdPath);
+        const paths = readAgentsMdInstalls(hostDir);
+        if (paths.includes(abs))
+            return;
+        fs.mkdirSync(hostDir, { recursive: true });
+        fs.writeFileSync(path.join(hostDir, AGENTS_MD_REGISTRY), `${JSON.stringify({ paths: [...paths, abs] }, null, 2)}\n`, 'utf-8');
+    }
+    catch { /* 기록 실패는 설치를 막지 않는다 */ }
+}
+export function clearAgentsMdInstalls(hostDir) {
+    try {
+        fs.unlinkSync(path.join(hostDir, AGENTS_MD_REGISTRY));
+    }
+    catch { /* 없음 */ }
+}
+/**
+ * 기록된 경로 + 지금의 cwd 경로에서 forgen 블록을 걷어낸다.
+ * 쓰지 못한 경로(읽기 전용 등)는 `failed` 로 돌려주고 **기록에 남긴다** — 다음 uninstall 이 다시 시도할 수 있게.
+ */
+export function removeForgenRulesEverywhere(opts) {
+    const recorded = readAgentsMdInstalls(opts.hostDir);
+    const candidates = [...new Set([...recorded, path.resolve(opts.cwdAgentsMdPath)])];
+    const cleaned = [];
+    const failed = [];
+    for (const p of candidates) {
+        try {
+            if (removeForgenRulesFromAgentsMd({ agentsMdPath: p, dryRun: opts.dryRun }).removed)
+                cleaned.push(p);
+        }
+        catch (e) {
+            failed.push({ path: p, error: e instanceof Error ? e.message : String(e) });
+        }
+    }
+    if (!opts.dryRun) {
+        const keep = recorded.filter((p) => failed.some((f) => f.path === p));
+        if (keep.length === 0)
+            clearAgentsMdInstalls(opts.hostDir);
+        else {
+            try {
+                fs.writeFileSync(path.join(opts.hostDir, AGENTS_MD_REGISTRY), `${JSON.stringify({ paths: keep }, null, 2)}\n`, 'utf-8');
+            }
+            catch { /* best-effort */ }
+        }
+    }
+    return { cleaned, failed };
+}
+/** 마커가 *한 줄을 통째로* 차지할 때만 블록 경계로 본다 — 본문에 마커 문자열을 인용한 줄과 구분. */
+function findAgentsBlocks(lines) {
+    const blocks = [];
+    let begin = -1;
+    lines.forEach((l, i) => {
+        const t = l.trim();
+        if (t === AGENTS_MD_BEGIN && begin === -1)
+            begin = i;
+        else if (t === AGENTS_MD_END && begin !== -1) {
+            blocks.push({ begin, end: i });
+            begin = -1;
+        }
+    });
+    return blocks;
+}
+/**
+ * AGENTS.md 의 forgen 블록 제거 (uninstall). 블록뿐이던 파일은 삭제한다.
+ * BEGIN/END 마커가 각각 한 줄로, 순서대로 있을 때만 동작한다 (블록이 여러 개면 전부 제거).
+ * 읽을 수 없으면 no-op, 쓸 수 없으면 throw — 호출부가 보고한다.
+ */
 export function removeForgenRulesFromAgentsMd(opts) {
     let current;
     try {
@@ -1118,10 +1192,18 @@ export function removeForgenRulesFromAgentsMd(opts) {
     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))
+    const lines = current.split('\n');
+    const blocks = findAgentsBlocks(lines);
+    if (blocks.length === 0)
         return { removed: false, fileDeleted: false };
-    const rest = current.replace(re, '\n').replace(/^\n+/, '');
+    const drop = new Set();
+    for (const b of blocks)
+        for (let i = b.begin; i <= b.end; i += 1)
+            drop.add(i);
+    const kept = trimEofBlankLines(deleteLines(lines, drop));
+    while (kept.length > 1 && kept[0].trim() === '')
+        kept.shift();
+    const rest = kept.join('\n');
     const empty = rest.trim().length === 0;
     // 심링크면 링크를 지우지 않고 대상 파일에 써 넣는다 (링크만 지우면 대상에 블록이 남는다).
     const isLink = fs.lstatSync(opts.agentsMdPath).isSymbolicLink();
@@ -1130,10 +1212,7 @@ export function removeForgenRulesFromAgentsMd(opts) {
         if (deleteFile)
             fs.unlinkSync(opts.agentsMdPath);
         else
-            fs.writeFileSync(opts.agentsMdPath, empty ? '' : (rest.endsWith('\n') ? rest : `${rest}\n`), 'utf-8');
+            fs.writeFileSync(opts.agentsMdPath, empty ? '' : rest, 'utf-8');
     }
     return { removed: true, fileDeleted: deleteFile };
 }
-function escapeRegex(s) {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}

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

@@ -9,6 +9,9 @@
  *      (리뷰 HIGH: JSON.parse 가 공식 JSONC 를 clobber 하던 데이터 손실 수정).
  *   3. AGENTS.md: cwd 의 forgen rules block (Codex 헬퍼 재사용).
  */
+export declare const PLUGIN_FILENAME = "forgen.ts";
+export declare const PLUGIN_MARKER = "forgen-managed";
+export declare const MCP_SERVER_NAME = "forgen-compound";
 export interface OpencodeInstallOptions {
     pkgRoot: string;
     dryRun?: boolean;
@@ -35,4 +38,6 @@ export interface OpencodeInstallResult {
     agentsMdInjected: boolean;
 }
 export declare function resolveOpencodeConfigDir(opts: OpencodeInstallOptions): string;
+/** 기존 config 파일 경로 감지 — opencode.jsonc 우선, 없으면 opencode.json (둘 다 없으면 .json 신규). */
+export declare function resolveConfigFilePath(configDir: string): string;
 export declare function planOpencodeInstall(opts: OpencodeInstallOptions): OpencodeInstallResult;

package/dist/host/install-opencode.js

@@ -14,11 +14,11 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { applyEdits, modify, parse as parseJsonc } from 'jsonc-parser';
 import { createLogger } from '../core/logger.js';
-import { resolveAgentsMdPath, upsertForgenRulesInAgentsMd } from './install-codex.js';
+import { recordAgentsMdInstall, resolveAgentsMdPath, upsertForgenRulesInAgentsMd } from './install-codex.js';
 const log = createLogger('install-opencode');
-const PLUGIN_FILENAME = 'forgen.ts';
-const PLUGIN_MARKER = 'forgen-managed';
-const MCP_SERVER_NAME = 'forgen-compound';
+export const PLUGIN_FILENAME = 'forgen.ts';
+export const PLUGIN_MARKER = 'forgen-managed';
+export const MCP_SERVER_NAME = 'forgen-compound';
 export function resolveOpencodeConfigDir(opts) {
     if (opts.opencodeConfigDir)
         return opts.opencodeConfigDir;
@@ -29,7 +29,7 @@ export function resolveOpencodeConfigDir(opts) {
     return path.join(base, 'opencode');
 }
 /** 기존 config 파일 경로 감지 — opencode.jsonc 우선, 없으면 opencode.json (둘 다 없으면 .json 신규). */
-function resolveConfigFilePath(configDir) {
+export function resolveConfigFilePath(configDir) {
     const jsonc = path.join(configDir, 'opencode.jsonc');
     if (fs.existsSync(jsonc))
         return jsonc;
@@ -104,7 +104,8 @@ export function planOpencodeInstall(opts) {
         // 기존 plugin 이 forgen-managed 가 아니면(사용자 소유) 백업.
         if (!dryRun && fs.existsSync(pluginPath)) {
             const existing = fs.readFileSync(pluginPath, 'utf-8');
-            if (!existing.includes(PLUGIN_MARKER)) {
+            // 첫 줄이 `// forgen-managed` 인 것만 forgen 소유 (본문에 문자열이 있다는 것만으로는 아님) — 그 외는 백업.
+            if (!existing.split('\n', 1)[0].trimStart().startsWith(`// ${PLUGIN_MARKER}`)) {
                 const bak = `${pluginPath}.bak`;
                 fs.copyFileSync(pluginPath, bak);
                 result.pluginBackupPath = bak;
@@ -144,5 +145,7 @@ export function planOpencodeInstall(opts) {
     const agentsMdPath = opts.agentsMdPath ?? resolveAgentsMdPath(opts.pkgRoot);
     const agentsResult = upsertForgenRulesInAgentsMd({ agentsMdPath, pkgRoot: opts.pkgRoot, dryRun });
     result.agentsMdInjected = agentsResult.injected;
+    if (!dryRun)
+        recordAgentsMdInstall(configDir, agentsMdPath);
     return result;
 }

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

@@ -21,3 +21,25 @@ export declare function listDevGuideSkillNames(pkgRoot: string): Set<string>;
  * 사용자가 그 디렉토리에 다른 파일을 넣어 뒀으면 디렉토리는 남는다. 실제로 SKILL.md 를 지웠을 때만 true.
  */
 export declare function removeSkillFile(skillsDir: string, name: string, dryRun: boolean): boolean;
+/**
+ * `<skillsDir>` 아래에서 forgen 이 설치한 dev-guide 스킬 디렉토리 이름을 고른다 (ADR-016 0.5.9).
+ *
+ * 이전의 stale 정리는 이름 패턴(`forgen-*`)만 보고 디렉토리를 재귀 삭제해 사용자가 만든 `forgen-notes`,
+ * `forgen-react-mine` 까지 지웠다. 소유 근거는 둘 중 하나여야 한다:
+ *   (a) 패키지가 현재 제공하는 이름, 또는
+ *   (b) SKILL.md 가 `…/assets/dev-guide/…` 를 가리키는 심링크 — 이전 버전이 설치한 것 (대상이 사라진
+ *       dangling 링크여도 링크 문자열로 판정).
+ */
+export declare function listOwnedDevGuideSkillDirs(skillsDir: string, pkgRoot: string): string[];
+/** install 의 stale 정리: forgen 소유 dev-guide 스킬의 SKILL.md 만 지운다. 반환: 지운 수. */
+export declare function removeOwnedDevGuideSkills(skillsDir: string, pkgRoot: string, dryRun?: boolean): number;
+/**
+ * dev-guide 스킬 한 개를 `<skillsDir>/<name>/SKILL.md` 로 설치 (심링크 → 복사 폴백).
+ *
+ * **이미 있는 것은 절대 덮어쓰지 않는다.** stale 정리가 지나간 뒤에도 남아 있는 것은 forgen 소유가 아니다:
+ *   - `<name>` 디렉토리가 심링크면(사용자 dotfiles 등) 그 안으로 따라 들어가 쓰지 않는다.
+ *   - `SKILL.md` 가 남아 있으면(지울 수 없던 것, 디렉토리 등) 건드리지 않는다 — 특히 `copyFileSync` 는
+ *     심링크를 따라가 스킬 디렉토리 *밖* 의 사용자 파일까지 덮어쓴다 (0.5.9 critic M1).
+ * 한 스킬의 실패가 나머지 설치를 막지 않는다. 반환: 실제로 설치했는가.
+ */
+export declare function installSkillFile(src: string, skillsDir: string, name: string): boolean;

package/dist/host/managed-marker.js

@@ -76,3 +76,82 @@ export function removeSkillFile(skillsDir, name, dryRun) {
         return false;
     }
 }
+/**
+ * `<skillsDir>` 아래에서 forgen 이 설치한 dev-guide 스킬 디렉토리 이름을 고른다 (ADR-016 0.5.9).
+ *
+ * 이전의 stale 정리는 이름 패턴(`forgen-*`)만 보고 디렉토리를 재귀 삭제해 사용자가 만든 `forgen-notes`,
+ * `forgen-react-mine` 까지 지웠다. 소유 근거는 둘 중 하나여야 한다:
+ *   (a) 패키지가 현재 제공하는 이름, 또는
+ *   (b) SKILL.md 가 `…/assets/dev-guide/…` 를 가리키는 심링크 — 이전 버전이 설치한 것 (대상이 사라진
+ *       dangling 링크여도 링크 문자열로 판정).
+ */
+export function listOwnedDevGuideSkillDirs(skillsDir, pkgRoot) {
+    const known = listDevGuideSkillNames(pkgRoot);
+    let entries;
+    try {
+        entries = fs.readdirSync(skillsDir);
+    }
+    catch {
+        return [];
+    }
+    return entries.filter((name) => {
+        if (!name.startsWith('forgen-'))
+            return false;
+        if (known.has(name))
+            return true;
+        try {
+            const target = fs.readlinkSync(path.join(skillsDir, name, 'SKILL.md'));
+            return /[\\/]assets[\\/]dev-guide[\\/]/.test(target);
+        }
+        catch {
+            return false; // 심링크가 아님 = 사용자가 쓴 파일이거나 없음
+        }
+    });
+}
+/** install 의 stale 정리: forgen 소유 dev-guide 스킬의 SKILL.md 만 지운다. 반환: 지운 수. */
+export function removeOwnedDevGuideSkills(skillsDir, pkgRoot, dryRun = false) {
+    let removed = 0;
+    for (const name of listOwnedDevGuideSkillDirs(skillsDir, pkgRoot)) {
+        if (removeSkillFile(skillsDir, name, dryRun))
+            removed += 1;
+    }
+    return removed;
+}
+/**
+ * dev-guide 스킬 한 개를 `<skillsDir>/<name>/SKILL.md` 로 설치 (심링크 → 복사 폴백).
+ *
+ * **이미 있는 것은 절대 덮어쓰지 않는다.** stale 정리가 지나간 뒤에도 남아 있는 것은 forgen 소유가 아니다:
+ *   - `<name>` 디렉토리가 심링크면(사용자 dotfiles 등) 그 안으로 따라 들어가 쓰지 않는다.
+ *   - `SKILL.md` 가 남아 있으면(지울 수 없던 것, 디렉토리 등) 건드리지 않는다 — 특히 `copyFileSync` 는
+ *     심링크를 따라가 스킬 디렉토리 *밖* 의 사용자 파일까지 덮어쓴다 (0.5.9 critic M1).
+ * 한 스킬의 실패가 나머지 설치를 막지 않는다. 반환: 실제로 설치했는가.
+ */
+export function installSkillFile(src, skillsDir, name) {
+    const dir = path.join(skillsDir, name);
+    const file = path.join(dir, 'SKILL.md');
+    try {
+        try {
+            if (fs.lstatSync(dir).isSymbolicLink())
+                return false;
+        }
+        catch { /* 없음 — 새로 만든다 */ }
+        fs.mkdirSync(dir, { recursive: true });
+        try {
+            fs.lstatSync(file);
+            return false; // 남아 있음 — 덮어쓰지 않는다
+        }
+        catch { /* 없음 — 설치 */ }
+        try {
+            fs.symlinkSync(src, file, 'file');
+        }
+        catch (e) {
+            const code = e.code ?? 'UNKNOWN';
+            process.stderr.write(`[forgen] symlink ${src} → ${file} failed (${code}); falling back to copyFile.\n`);
+            fs.copyFileSync(src, file, fs.constants.COPYFILE_EXCL);
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -42,6 +42,8 @@ export interface CodexUninstallResult {
     skillsRemoved: number;
     agentsRemoved: number;
     agentsMdCleaned: boolean;
+    /** forgen 블록을 걷어낸 AGENTS.md 경로 (설치 시 기록된 프로젝트들 + 지금의 cwd) */
+    agentsMdCleanedPaths: string[];
     /** 단계별 실패 (한 단계가 실패해도 나머지는 진행한다) */
     errors: string[];
 }

package/dist/host/uninstall-codex.js

@@ -13,7 +13,7 @@
 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 { AGENT_NAME_PREFIX, codexHookEventKey, isForgenHookCommand, removeForgenRulesEverywhere, 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) {
@@ -139,6 +139,7 @@ export function planCodexUninstall(opts) {
         skillsRemoved: 0,
         agentsRemoved: 0,
         agentsMdCleaned: false,
+        agentsMdCleanedPaths: [],
         errors: [],
     };
     if (!result.present)
@@ -200,10 +201,14 @@ export function planCodexUninstall(opts) {
     // 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)
+    // 4) AGENTS.md — 설치 때 기록된 프로젝트 전부 + 지금의 cwd (0.5.9 이전 설치분은 기록이 없어 cwd 만)
     step('AGENTS.md', () => {
-        const agentsMdPath = opts.agentsMdPath ?? resolveAgentsMdPath(opts.pkgRoot);
-        result.agentsMdCleaned = removeForgenRulesFromAgentsMd({ agentsMdPath, dryRun }).removed;
+        const cwdAgentsMdPath = opts.agentsMdPath ?? resolveAgentsMdPath(opts.pkgRoot);
+        const r = removeForgenRulesEverywhere({ hostDir: codexHome, cwdAgentsMdPath, dryRun });
+        result.agentsMdCleanedPaths = r.cleaned;
+        result.agentsMdCleaned = r.cleaned.length > 0;
+        for (const f of r.failed)
+            result.errors.push(`AGENTS.md ${f.path}: ${f.error} (kept in the install record — fix and re-run uninstall)`);
     });
     return result;
 }
@@ -235,12 +240,10 @@ export function renderCodexUninstall(r) {
         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');
+    if (r.agentsMdCleaned) {
+        lines.push(`  ✓ Removed forgen block from ${r.agentsMdCleanedPaths.length} AGENTS.md file(s): ${r.agentsMdCleanedPaths.slice(0, 4).join(', ')}${r.agentsMdCleanedPaths.length > 4 ? ', …' : ''}`);
+    }
     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/dist/host/uninstall-opencode.d.ts

@@ -0,0 +1,36 @@
+/**
+ * OpenCode uninstall — ADR-016 0.5.9
+ *
+ * `forgen install opencode` 가 쓴 것을 되돌린다: `plugins/forgen.ts`, config(JSONC) 의 `mcp.forgen-compound`,
+ * AGENTS.md 블록. 사용자 소유물(마커 없는 plugin, 같은 이름의 다른 MCP 서버, 파싱 불가 config)은 건드리지 않는다.
+ * MCP 제거는 다른 키와 값을 보존하지만, forgen 항목에 붙어 있던 주석과 주변 포맷은 바뀔 수 있다.
+ */
+export interface OpencodeUninstallOptions {
+    pkgRoot: string;
+    /** ~/.config/opencode override (격리 테스트용). */
+    opencodeConfigDir?: string;
+    /** AGENTS.md 위치 override (격리 테스트용). */
+    agentsMdPath?: string;
+    dryRun?: boolean;
+}
+export interface OpencodeUninstallResult {
+    configDir: string;
+    /** config 디렉토리가 없으면 false — 나머지는 전부 false/빈 값 */
+    present: boolean;
+    pluginRemoved: boolean;
+    /** 설치 때 백업해 둔 사용자 plugin(`forgen.ts.bak`)을 되돌렸는가 */
+    pluginRestoredFromBackup: boolean;
+    mcpRemoved: boolean;
+    /** config 가 유효한 JSONC 가 아니라 건드리지 않음 */
+    mcpSkippedUnparseable: boolean;
+    agentsMdCleanedPaths: string[];
+    errors: string[];
+}
+/** config 텍스트에서 `mcp.forgen-compound` 를 제거. 다른 키·서버는 보존, `mcp` 가 비면 그 키도 제거. */
+export declare function removeOpencodeMcp(currentText: string): {
+    content: string;
+    removed: boolean;
+    unparseable: boolean;
+};
+export declare function planOpencodeUninstall(opts: OpencodeUninstallOptions): OpencodeUninstallResult;
+export declare function renderOpencodeUninstall(r: OpencodeUninstallResult): string[];

package/dist/host/uninstall-opencode.js

@@ -0,0 +1,141 @@
+/**
+ * OpenCode uninstall — ADR-016 0.5.9
+ *
+ * `forgen install opencode` 가 쓴 것을 되돌린다: `plugins/forgen.ts`, config(JSONC) 의 `mcp.forgen-compound`,
+ * AGENTS.md 블록. 사용자 소유물(마커 없는 plugin, 같은 이름의 다른 MCP 서버, 파싱 불가 config)은 건드리지 않는다.
+ * MCP 제거는 다른 키와 값을 보존하지만, forgen 항목에 붙어 있던 주석과 주변 포맷은 바뀔 수 있다.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { applyEdits, modify, parse as parseJsonc } from 'jsonc-parser';
+import { removeForgenRulesEverywhere, resolveAgentsMdPath } from './install-codex.js';
+import { MCP_SERVER_NAME, PLUGIN_FILENAME, PLUGIN_MARKER, resolveOpencodeConfigDir } from './install-opencode.js';
+/** forgen 이 등록한 MCP 항목인가: command 에 `…/dist/mcp/server.js` 와 `--host=opencode` 가 있다. */
+function isForgenMcpEntry(entry) {
+    const command = entry?.command;
+    if (!Array.isArray(command))
+        return false;
+    return command.some((a) => typeof a === 'string' && /[\\/]dist[\\/]mcp[\\/]server\.js$/.test(a))
+        && command.includes('--host=opencode');
+}
+/** config 텍스트에서 `mcp.forgen-compound` 를 제거. 다른 키·서버는 보존, `mcp` 가 비면 그 키도 제거. */
+export function removeOpencodeMcp(currentText) {
+    if (currentText.trim().length === 0)
+        return { content: currentText, removed: false, unparseable: false };
+    const errors = [];
+    const parsed = parseJsonc(currentText, errors, { allowTrailingComma: true });
+    if (errors.length > 0 || parsed === undefined || parsed === null || typeof parsed !== 'object') {
+        return { content: currentText, removed: false, unparseable: true };
+    }
+    if (!isForgenMcpEntry(parsed.mcp?.[MCP_SERVER_NAME]))
+        return { content: currentText, removed: false, unparseable: false };
+    const opts = { formattingOptions: { insertSpaces: true, tabSize: 2 } };
+    let out = applyEdits(currentText, modify(currentText, ['mcp', MCP_SERVER_NAME], undefined, opts));
+    if (Object.keys(parsed.mcp ?? {}).length === 1)
+        out = applyEdits(out, modify(out, ['mcp'], undefined, opts));
+    // 쓰기 전 검증: forgen 항목만 사라지고 다른 키/서버는 그대로여야 한다. (중복 `mcp` 키 같은 퇴화 입력에서
+    // 편집기가 다른 객체를 건드릴 수 있다 — 그러면 아무것도 쓰지 않는다.)
+    const after = parseJsonc(out, [], { allowTrailingComma: true });
+    const expected = JSON.parse(JSON.stringify(parsed));
+    if (expected.mcp) {
+        delete expected.mcp[MCP_SERVER_NAME];
+        if (Object.keys(expected.mcp).length === 0)
+            delete expected.mcp;
+    }
+    if (JSON.stringify(after) !== JSON.stringify(expected))
+        return { content: currentText, removed: false, unparseable: true };
+    return { content: out, removed: true, unparseable: false };
+}
+/**
+ * plugin 파일이 forgen 것인가: **첫 줄**이 `// forgen-managed` 로 시작해야 한다 (배포 자산의 형태).
+ * 본문 어딘가에 문자열이 있다는 것만으로는 소유로 보지 않는다 (`// NOT forgen-managed: my fork` 같은 사용자 파일 보호).
+ */
+function isManagedPlugin(content) {
+    return content.split('\n', 1)[0].trimStart().startsWith(`// ${PLUGIN_MARKER}`);
+}
+export function planOpencodeUninstall(opts) {
+    const configDir = resolveOpencodeConfigDir({ pkgRoot: opts.pkgRoot, opencodeConfigDir: opts.opencodeConfigDir });
+    const dryRun = opts.dryRun ?? false;
+    const result = {
+        configDir,
+        present: fs.existsSync(configDir),
+        pluginRemoved: false,
+        pluginRestoredFromBackup: false,
+        mcpRemoved: false,
+        mcpSkippedUnparseable: false,
+        agentsMdCleanedPaths: [],
+        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) plugin — forgen-managed 마커가 있는 것만. 설치가 백업한 사용자 plugin 이 있으면 되돌린다.
+    step('plugin', () => {
+        const pluginPath = path.join(configDir, 'plugins', PLUGIN_FILENAME);
+        if (!fs.existsSync(pluginPath))
+            return;
+        if (fs.lstatSync(pluginPath).isSymbolicLink() || !isManagedPlugin(fs.readFileSync(pluginPath, 'utf-8')))
+            return;
+        const bak = `${pluginPath}.bak`;
+        result.pluginRemoved = true;
+        // `.bak` 은 설치가 사용자 plugin 을 백업한 것일 때만 되돌린다 — forgen-managed 내용이면 사용자 원본이 아니다.
+        result.pluginRestoredFromBackup = fs.existsSync(bak) && !isManagedPlugin(fs.readFileSync(bak, 'utf-8'));
+        if (dryRun)
+            return;
+        if (result.pluginRestoredFromBackup)
+            fs.renameSync(bak, pluginPath);
+        else
+            fs.unlinkSync(pluginPath);
+    });
+    // 2) MCP — opencode.jsonc 와 opencode.json 둘 다 본다 (설치 후에 .jsonc 가 생겼을 수 있다)
+    for (const name of ['opencode.jsonc', 'opencode.json']) {
+        step(name, () => {
+            const configPath = path.join(configDir, name);
+            if (!fs.existsSync(configPath))
+                return;
+            const current = fs.readFileSync(configPath, 'utf-8');
+            const r = removeOpencodeMcp(current);
+            if (r.removed)
+                result.mcpRemoved = true;
+            if (r.unparseable)
+                result.mcpSkippedUnparseable = true;
+            if (!dryRun && r.removed)
+                fs.writeFileSync(configPath, r.content, 'utf-8');
+        });
+    }
+    // 3) AGENTS.md — 설치 때 기록된 프로젝트 전부 + 지금의 cwd
+    step('AGENTS.md', () => {
+        const cwdAgentsMdPath = opts.agentsMdPath ?? resolveAgentsMdPath(opts.pkgRoot);
+        const r = removeForgenRulesEverywhere({ hostDir: configDir, cwdAgentsMdPath, dryRun });
+        result.agentsMdCleanedPaths = r.cleaned;
+        for (const f of r.failed)
+            result.errors.push(`AGENTS.md ${f.path}: ${f.error} (kept in the install record — fix and re-run uninstall)`);
+    });
+    return result;
+}
+export function renderOpencodeUninstall(r) {
+    if (!r.present)
+        return [];
+    const lines = [];
+    if (r.pluginRemoved) {
+        lines.push(r.pluginRestoredFromBackup
+            ? '  ✓ Removed forgen OpenCode plugin and restored your original plugins/forgen.ts from the install-time backup'
+            : '  ✓ Removed forgen OpenCode plugin (plugins/forgen.ts)');
+    }
+    if (r.mcpRemoved)
+        lines.push('  ✓ Removed forgen-compound MCP entry from the OpenCode config');
+    if (r.mcpSkippedUnparseable)
+        lines.push('  ⚠ OpenCode config is not valid JSONC — left untouched (remove mcp.forgen-compound by hand)');
+    if (r.agentsMdCleanedPaths.length > 0)
+        lines.push(`  ✓ Removed forgen block from ${r.agentsMdCleanedPaths.length} AGENTS.md file(s) (OpenCode installs)`);
+    for (const e of r.errors)
+        lines.push(`  ✗ OpenCode cleanup — ${e}`);
+    return lines;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wooojin/forgen",
-  "version": "0.5.8",
+  "version": "0.5.9",
   "preferGlobal": true,
   "main": "dist/lib.js",
   "types": "./dist/lib.d.ts",

package/plugin.json

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

package/scripts/postinstall.js

@@ -15,7 +15,7 @@
  *   - 실패해도 npm install을 깨뜨리지 않음 (silent failure)
  */
 
-import { readFileSync, readdirSync, writeFileSync, mkdirSync, existsSync, rmSync, symlinkSync, cpSync, lstatSync, statSync, copyFileSync, renameSync } from 'node:fs';
+import { readFileSync, readdirSync, writeFileSync, mkdirSync, existsSync, rmSync, symlinkSync, cpSync, lstatSync, statSync, copyFileSync, renameSync, readlinkSync, unlinkSync, rmdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { homedir, platform } from 'node:os';
 import { execFileSync } from 'node:child_process';
@@ -752,6 +752,72 @@ function cleanLegacyMcpFromSettings(settings) {
  *
  * forgen- prefix 로 사용자 own skills 와 격리. idempotent 재실행 시 forgen-* 만 정리 후 재설치.
  */
+/**
+ * forgen 이 설치한 dev-guide 스킬만 정리한다 (src/host/managed-marker.ts 의 removeOwnedDevGuideSkills 와 같은 규칙).
+ *
+ * 이전엔 `forgen-*` 디렉토리를 이름만 보고 재귀 삭제해, 사용자가 만든 `forgen-notes` / `forgen-react-mine`
+ * 같은 스킬이 npm install 때마다 사라졌다. 소유 근거: (a) 패키지가 현재 제공하는 이름, 또는
+ * (b) SKILL.md 가 `…/assets/dev-guide/…` 를 가리키는 심링크(이전 버전이 설치한 것).
+ * SKILL.md 한 파일과 빈 디렉토리만 지운다.
+ */
+function removeOwnedDevGuideSkills(skillsDir, devGuideRoot) {
+  const known = new Set();
+  try {
+    for (const tier of readdirSync(devGuideRoot)) {
+      const base = join(devGuideRoot, tier, 'skills');
+      if (!existsSync(base)) continue;
+      for (const stack of readdirSync(base)) {
+        const stackDir = join(base, stack);
+        if (!statSync(stackDir).isDirectory()) continue;
+        for (const skill of readdirSync(stackDir)) {
+          if (existsSync(join(stackDir, skill, 'SKILL.md'))) known.add(`forgen-${stack}-${skill}`);
+        }
+      }
+    }
+  } catch { /* 자산 없음 */ }
+
+  let removed = 0;
+  let entries = [];
+  try { entries = readdirSync(skillsDir); } catch { return 0; }
+  for (const name of entries) {
+    if (!name.startsWith('forgen-')) continue;
+    const dir = join(skillsDir, name);
+    const file = join(dir, 'SKILL.md');
+    let owned = known.has(name);
+    if (!owned) {
+      try { owned = /[\\/]assets[\\/]dev-guide[\\/]/.test(readlinkSync(file)); } catch { owned = false; }
+    }
+    if (!owned) continue;
+    try {
+      if (lstatSync(dir).isSymbolicLink()) continue;
+      lstatSync(file); // 없으면 throw
+      unlinkSync(file);
+      try { if (readdirSync(dir).length === 0) rmdirSync(dir); } catch { /* ignore */ }
+      removed++;
+    } catch { /* best-effort */ }
+  }
+  return removed;
+}
+
+/**
+ * dev-guide 스킬 한 개 설치 (src/host/managed-marker.ts installSkillFile 과 같은 규칙).
+ * 이미 있는 것은 덮어쓰지 않는다: 심링크된 스킬 디렉토리는 따라 들어가지 않고, 남아 있는 SKILL.md 는 건드리지 않는다
+ * (rmSync/cpSync 는 심링크를 관통해 사용자 dotfiles 의 파일을 지우거나 덮어쓴다). 반환: 설치했는가.
+ */
+function installSkillFile(src, skillsDir, name) {
+  const dir = join(skillsDir, name);
+  const file = join(dir, 'SKILL.md');
+  try {
+    try { if (lstatSync(dir).isSymbolicLink()) return false; } catch { /* 없음 */ }
+    mkdirSync(dir, { recursive: true });
+    try { lstatSync(file); return false; } catch { /* 없음 — 설치 */ }
+    try { symlinkSync(src, file, 'file'); } catch { copyFileSync(src, file); }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function installDevGuideSkills(home) {
   const devGuideRoot = join(PKG_ROOT, 'assets', 'dev-guide');
   if (!existsSync(devGuideRoot)) {
@@ -762,13 +828,8 @@ function installDevGuideSkills(home) {
   const userSkillsDir = join(home, '.claude', 'skills');
   mkdirSync(userSkillsDir, { recursive: true });
 
-  // 1. 기존 forgen-* 디렉토리 정리 (사용자 own 보존)
-  let removed = 0;
-  for (const entry of readdirSync(userSkillsDir)) {
-    if (entry.startsWith('forgen-')) {
-      try { rmSync(join(userSkillsDir, entry), { recursive: true, force: true }); removed++; } catch { /* best-effort */ }
-    }
-  }
+  // 1. forgen 이 설치한 dev-guide 스킬 정리 (사용자가 만든 forgen-* 스킬은 보존)
+  const removed = removeOwnedDevGuideSkills(userSkillsDir, devGuideRoot);
 
   // 2. assets/dev-guide/{side}/skills/{stack}/{skill}/SKILL.md 수집
   let installed = 0;
@@ -783,19 +844,8 @@ function installDevGuideSkills(home) {
         const skillFile = join(skillSrc, 'SKILL.md');
         if (!existsSync(skillFile)) continue;
 
-        // 대상: ~/.claude/skills/forgen-<stack>-<skill>/SKILL.md
-        const dstDir = join(userSkillsDir, `forgen-${stack}-${skill}`);
-        mkdirSync(dstDir, { recursive: true });
-        const dst = join(dstDir, 'SKILL.md');
-
-        // symlink → fallback cpSync
-        try {
-          if (existsSync(dst)) rmSync(dst);
-          symlinkSync(skillFile, dst, 'file');
-        } catch {
-          cpSync(skillFile, dst);
-        }
-        installed++;
+        // 대상: ~/.claude/skills/forgen-<stack>-<skill>/SKILL.md (이미 있는 사용자 것은 덮어쓰지 않는다)
+        if (installSkillFile(skillFile, userSkillsDir, `forgen-${stack}-${skill}`)) installed++;
       }
     }
   }
@@ -810,9 +860,8 @@ function installDevGuideSkills(home) {
 /**
  * v0.4.9: dev-guide 14 skills → ~/.codex/skills/forgen-<stack>-<skill>/SKILL.md
  * forgen 자체 commands(forgen-compound 등) 와 prefix 겹치지 않도록
- * DEV_GUIDE_SKILL_PATTERN(/^forgen-(react|vue|node|go)-/) 으로 stale 정리.
+ * stale 정리는 removeOwnedDevGuideSkills (forgen 소유만).
  */
-const DEV_GUIDE_SKILL_PATTERN = /^forgen-(react|vue|node|go)-/;
 
 function installDevGuideSkillsToCodex(home) {
   const devGuideRoot = join(PKG_ROOT, 'assets', 'dev-guide');
@@ -824,13 +873,8 @@ function installDevGuideSkillsToCodex(home) {
   const codexSkillsDir = join(home, '.codex', 'skills');
   mkdirSync(codexSkillsDir, { recursive: true });
 
-  // 1. stale forgen-<stack>-<skill> 정리 (forgen 자체 commands 보존)
-  let removed = 0;
-  for (const entry of readdirSync(codexSkillsDir)) {
-    if (DEV_GUIDE_SKILL_PATTERN.test(entry)) {
-      try { rmSync(join(codexSkillsDir, entry), { recursive: true, force: true }); removed++; } catch { /* best-effort */ }
-    }
-  }
+  // 1. forgen 이 설치한 dev-guide 스킬 정리 (forgen 자체 commands 와 사용자 스킬은 보존)
+  const removed = removeOwnedDevGuideSkills(codexSkillsDir, devGuideRoot);
 
   // 2. assets/dev-guide/{tier}/skills/{stack}/{skill}/SKILL.md 수집
   let installed = 0;
@@ -844,18 +888,8 @@ function installDevGuideSkillsToCodex(home) {
         const skillFile = join(stackDir, skill, 'SKILL.md');
         if (!existsSync(skillFile)) continue;
 
-        const dstDir = join(codexSkillsDir, `forgen-${stack}-${skill}`);
-        mkdirSync(dstDir, { recursive: true });
-        const dst = join(dstDir, 'SKILL.md');
-
-        // symlink → fallback cpSync
-        try {
-          if (existsSync(dst)) rmSync(dst);
-          symlinkSync(skillFile, dst, 'file');
-        } catch {
-          cpSync(skillFile, dst);
-        }
-        installed++;
+        // 이미 있는 사용자 것은 덮어쓰지 않는다
+        if (installSkillFile(skillFile, codexSkillsDir, `forgen-${stack}-${skill}`)) installed++;
       }
     }
   }