@wooojin/forgen 0.5.7 → 0.5.9

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.7",
+  "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.7",
+  "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++;
       }
     }
   }