@wooojin/forgen 0.5.7 → 0.5.9

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';
@@ -69,32 +69,177 @@ export function readJsonFile(p) {
         return null;
     }
 }
-function splitManagedSpan(lines, begin, end) {
-    const b = lines.findIndex((l) => l.trim() === begin);
-    if (b === -1)
-        return null;
-    const rel = lines.slice(b + 1).findIndex((l) => l.trim() === end);
-    if (rel === -1)
-        return null;
-    const e = b + 1 + rel;
-    return { before: lines.slice(0, b), inner: lines.slice(b + 1, e), after: lines.slice(e + 1) };
-}
-function trimBlankEdges(lines) {
-    let a = 0;
-    let z = lines.length;
-    while (a < z && lines[a].trim() === '')
-        a += 1;
-    while (z > a && lines[z - 1].trim() === '')
-        z -= 1;
-    return lines.slice(a, z);
+// ── config.toml managed blocks ─────────────────────────────────────────
+//
+// Codex 는 config.toml 을 스스로 다시 쓴다 (toml_edit): `/hooks` 승인은 `[hooks.state."…"]` 테이블을,
+// 모델 변경 등은 root 키를 추가한다. 주석은 "다음 항목의 장식" 으로 취급되므로 forgen 의 마커 주석은
+// **제자리에 있지 않는다**:
+//   - END 마커가 파일 끝/첫 테이블 앞에 있으면 Codex 가 쓴 내용이 BEGIN…END 사이에 끼어든다
+//     (0.5.6 critic — 블록을 통째로 교체하면 훅 신뢰 22건과 사용자 설정이 사라졌다).
+//   - Codex 0.160 은 테이블을 재배치한다: BEGIN 은 forgen 테이블과 함께 파일 끝으로 가고 END 는 앞쪽에
+//     고아로 남는다 (2026-10-02 실머신).
+//   - `codex mcp add <다른 서버>` 는 mcp_servers 를 통째로 다시 써서 BEGIN 마커를 **없앤다** (0.5.8 critic).
+// 그래서 마커를 범위로도, 유일한 소유 근거로도 쓰지 않는다. 범위는 TOML 구조(테이블 헤더 ~ 다음 헤더, notify 한 줄),
+// 소유는 "마커가 있거나, forgen 만 쓰는 내용 시그니처가 있다" 로 판정한다. forgen 이 쓴 줄만 고치고 나머지는 그대로 둔다.
+const FORGEN_SERVER_KEY = `(?:forgen-compound|"forgen-compound"|'forgen-compound')`;
+/** `[mcp_servers.forgen-compound]` — 따옴표/공백 표기도 같은 테이블이다 */
+const MCP_HEADER_RE = new RegExp(`^\\[\\s*mcp_servers\\s*\\.\\s*${FORGEN_SERVER_KEY}\\s*\\]\\s*(#.*)?$`);
+/** forgen 서버의 하위 테이블 (`[mcp_servers.forgen-compound.env]`, `[[…things]]`) */
+const MCP_SUBTABLE_RE = new RegExp(`^\\[{1,2}\\s*mcp_servers\\s*\\.\\s*${FORGEN_SERVER_KEY}\\s*\\.`);
+/** 같은 서버를 헤더가 아닌 형태로 정의한 줄 (inline table / dotted key) — 손으로 쓴 설정 */
+const MCP_ALT_FORM_RE = new RegExp(`^\\s*(?:mcp_servers\\s*\\.\\s*)?${FORGEN_SERVER_KEY}\\s*(?:=|\\.)`);
+/** forgen 이 쓰는 args 의 시그니처: `…/dist/mcp/server.js` + `--host=codex` (이 플래그는 forgen 전용) */
+const MCP_SIGNATURE_RE = /[\\/]dist[\\/]mcp[\\/]server\.js["'][\s\S]*--host=codex/;
+const MCP_TABLE_HEADER = '[mcp_servers.forgen-compound]';
+const MCP_OWN_KEY_RE = /^\s*(command|args)\s*=/;
+const TOML_KEY = `(?:[A-Za-z0-9_-]+|"[^"]*"|'[^']*')`;
+/** 테이블 헤더 한 줄: `[a.b]`, `[[a.b]]`, `[a."b c"] # 주석`. 배열 값의 한 줄(`["x", "y"],`)과 구분한다. */
+const TABLE_HEADER_RE = new RegExp(`^\\s*\\[\\[?\\s*${TOML_KEY}(?:\\s*\\.\\s*${TOML_KEY})*\\s*\\]\\]?\\s*(#.*)?$`);
+/**
+ * 줄을 구조적으로 분류한다. 여러 줄 문자열(`"""`/`'''`)이나 여러 줄 배열의 이어지는 줄(`cont`)은 값의 일부이므로
+ * 그 안의 `[` 로 시작하는 줄을 헤더로, 마커처럼 보이는 줄을 마커로 오인하면 안 된다 (0.5.8 critic m6).
+ * 완전한 TOML 파서는 아니다 — 문자열 밖의 대괄호 균형과 삼중따옴표 열림/닫힘만 추적한다.
+ */
+function classifyLines(lines) {
+    const kinds = [];
+    let inString = null;
+    let depth = 0;
+    const stripInline = (l) => l.replace(/"(?:[^"\\\\]|\\\\.)*"|'[^']*'/g, '""').replace(/#.*$/, '');
+    const balance = (l) => (l.match(/\[/g)?.length ?? 0) - (l.match(/\]/g)?.length ?? 0);
+    for (const raw of lines) {
+        const line = raw.replace(/\r$/, '');
+        if (inString !== null) {
+            kinds.push('cont');
+            if (line.includes(inString))
+                inString = null;
+            continue;
+        }
+        if (depth > 0) {
+            kinds.push('cont');
+            depth = Math.max(0, depth + balance(stripInline(line)));
+            continue;
+        }
+        if (TABLE_HEADER_RE.test(line)) {
+            kinds.push('header');
+            continue;
+        }
+        kinds.push('other');
+        const t = line.trim();
+        if (t === '' || t.startsWith('#'))
+            continue;
+        const triple = line.match(/"""|'''/g) ?? [];
+        if (triple.length % 2 === 1) {
+            inString = triple[triple.length - 1];
+            continue;
+        }
+        depth = Math.max(0, balance(stripInline(line)));
+    }
+    return kinds;
 }
 /** BOM 은 파일 맨 앞에 있어야 한다 — 떼어 두었다가 결과 맨 앞에 다시 붙인다. 줄 끝(CRLF)도 보존. */
 function tomlShape(toml) {
     const bom = toml.startsWith('') ? '' : '';
     return { bom, body: toml.slice(bom.length), cr: /\r\n/.test(toml) ? '\r' : '' };
 }
-const MCP_TABLE_HEADER = '[mcp_servers.forgen-compound]';
-const MCP_OWN_KEY_RE = /^\s*(command|args)\s*=/;
+/** 줄 배열 → 파일 내용. CRLF 파일의 마지막 줄이 `\r` 로만 끝나면(개행 없음) Codex 가 거부하므로 `\n` 을 붙인다. */
+function joinToml(bom, lines) {
+    const text = lines.join('\n');
+    return bom + (text.endsWith('\r') ? `${text}\n` : text);
+}
+/**
+ * 지정한 줄들을 지운다. 지운 자리 양옆이 모두 빈 줄(또는 파일 시작)이면 빈 줄 하나도 함께 지워
+ * 제거/재설치를 반복해도 빈 줄이 쌓이지 않게 한다. 지우지 않은 구간의 서식은 건드리지 않는다.
+ */
+function deleteLines(lines, drop) {
+    const out = [];
+    let justDropped = false;
+    for (let i = 0; i < lines.length; i += 1) {
+        if (drop.has(i)) {
+            justDropped = true;
+            continue;
+        }
+        const blank = lines[i].trim() === '';
+        if (justDropped && blank && (out.length === 0 || out[out.length - 1].trim() === '')) {
+            // 마지막 요소('' = 파일 끝 개행)는 남기고 앞의 빈 줄을 대신 버린다. CRLF 파일에서 앞의 빈 줄은 '\r' 이라
+            // 그것을 마지막에 남기면 bare CR 로 끝나 Codex 가 로드하지 못한다 (0.5.8 critic C1).
+            if (i === lines.length - 1) {
+                if (out.length > 0)
+                    out[out.length - 1] = lines[i];
+                else
+                    out.push(lines[i]);
+            }
+            continue;
+        }
+        justDropped = false;
+        out.push(lines[i]);
+    }
+    return out;
+}
+/**
+ * 제거 뒤 파일 끝을 정리한다: 끝의 빈 줄은 걷어내고, 내용이 있으면 개행 하나로 끝나게 한다.
+ * 설치↔제거를 반복해도 결과가 같아지게 하기 위함 (설치는 블록을 개행으로 끝내므로).
+ */
+function trimEofBlankLines(lines) {
+    const out = [...lines];
+    while (out.length > 1 && out[out.length - 1] === '' && out[out.length - 2].trim() === '')
+        out.splice(out.length - 2, 1);
+    if (out.length > 0 && out[out.length - 1] !== '' && out.some((l) => l.trim() !== '')) {
+        // CRLF 파일이면 마지막 줄도 CRLF 로 끝낸다
+        if (out.some((l) => l.endsWith('\r')) && !out[out.length - 1].endsWith('\r'))
+            out[out.length - 1] += '\r';
+        out.push('');
+    }
+    return out;
+}
+/** 테이블 본문의 끝: 다음 헤더/마커 직전. 끝의 빈 줄과 주석은 *다음 항목의 장식* 이므로 본문이 아니다. */
+function tableBodyEnd(lines, kinds, header, isMarker) {
+    let end = header + 1;
+    while (end < lines.length) {
+        if (kinds[end] === 'header' || (kinds[end] === 'other' && isMarker(lines[end].trim())))
+            break;
+        end += 1;
+    }
+    while (end > header + 1) {
+        const t = lines[end - 1].trim();
+        if (kinds[end - 1] === 'other' && (t === '' || t.startsWith('#')))
+            end -= 1;
+        else
+            break;
+    }
+    return end;
+}
+const isMcpMarker = (t) => t === MCP_MARKER_BEGIN || t === MCP_MARKER_END;
+function locateMcp(lines) {
+    const kinds = classifyLines(lines);
+    const beginIdx = [];
+    const endIdx = [];
+    let header = -1;
+    lines.forEach((l, i) => {
+        if (kinds[i] === 'cont')
+            return; // 여러 줄 값 안의 텍스트
+        const t = l.trim();
+        if (t === MCP_MARKER_BEGIN)
+            beginIdx.push(i);
+        else if (t === MCP_MARKER_END)
+            endIdx.push(i);
+        else if (header === -1 && kinds[i] === 'header' && MCP_HEADER_RE.test(t))
+            header = i;
+    });
+    const bodyEnd = header === -1 ? 0 : tableBodyEnd(lines, kinds, header, isMcpMarker);
+    // 헤더 바로 위(빈 줄과 forgen 의 다른 마커/주석은 건너뛴다)에 BEGIN 이 있는가
+    let above = header - 1;
+    while (above >= 0) {
+        const t = lines[above].trim();
+        if (t === '' || t === MCP_MARKER_END || isNotifyMarker(t) || isNotifyOwnComment(t))
+            above -= 1;
+        else
+            break;
+    }
+    const beginAdjacent = above >= 0 && beginIdx.includes(above);
+    const owned = header !== -1
+        && (beginAdjacent || MCP_SIGNATURE_RE.test(lines.slice(header + 1, bodyEnd).join('\n')));
+    return { kinds, beginIdx, endIdx, header, bodyEnd, owned };
+}
 function upsertMcpBlock(currentToml, pkgRoot) {
     const { bom, body, cr } = tomlShape(currentToml);
     const serverPath = path.join(pkgRoot, 'dist', 'mcp', 'server.js');
@@ -103,67 +248,72 @@ function upsertMcpBlock(currentToml, pkgRoot) {
     // correction-record evidence 박제 시 host:"codex" 로 정확히 태깅되게 한다 (spec §10-5).
     const ownKeys = ['command = "node"', `args = [${JSON.stringify(serverPath)}, "--host=codex"]`];
     const lines = body.split('\n');
-    const span = splitManagedSpan(lines, MCP_MARKER_BEGIN, MCP_MARKER_END);
-    if (!span) {
-        // 마커 없이 같은 테이블이 있으면(사용자 직접 작성 / 마커 손상) append 하지 않는다 — 중복 테이블 = 파싱 실패.
-        if (lines.some((l) => l.trim() === MCP_TABLE_HEADER))
+    const at = locateMcp(lines);
+    if (at.header === -1) {
+        // 헤더가 아닌 형태(inline table / dotted key)로 같은 서버가 정의돼 있으면 append 하지 않는다 —
+        // 중복 정의는 Codex 가 config 를 로드하지 못하게 한다.
+        if (lines.some((l, i) => at.kinds[i] === 'other' && MCP_ALT_FORM_RE.test(l)))
             return { content: currentToml, alreadyPresent: true };
+        // 테이블이 없다 → 끝에 새 블록. 고아 마커(테이블만 지워진 흔적)는 걷어낸다.
+        const cleaned = deleteLines(lines, new Set([...at.beginIdx, ...at.endIdx])).join('\n');
         const block = [MCP_MARKER_BEGIN, MCP_TABLE_HEADER, ...ownKeys, MCP_MARKER_END].map((l) => l + cr).join('\n');
-        const trimmed = body.replace(/\s+$/, '');
+        const trimmed = cleaned.replace(/\s+$/, '');
         const sep = trimmed.length > 0 ? `${cr}\n${cr}\n` : '';
         return { content: `${bom}${trimmed}${sep}${block}\n`, alreadyPresent: false };
     }
-    const h = span.inner.findIndex((l) => l.trim() === MCP_TABLE_HEADER);
-    let extraKeys = [];
-    let foreign = span.inner;
-    if (h !== -1) {
-        const afterHeader = span.inner.slice(h + 1);
-        const next = afterHeader.findIndex((l) => /^\s*\[/.test(l));
-        const tableBody = next === -1 ? afterHeader : afterHeader.slice(0, next);
-        // 손으로 고쳐 여러 줄이 된 command/args 는 안전하게 다시 쓸 수 없다 — 블록을 그대로 둔다.
-        const own = tableBody.filter((l) => MCP_OWN_KEY_RE.test(l));
-        if (own.some((l) => !/(["'\]])\s*(#.*)?$/.test(l.trim())))
-            return { content: currentToml, alreadyPresent: true };
-        // 사용자가 Codex 로 이 서버에 붙인 설정(enabled, startup_timeout_sec …)은 테이블 안에 유지.
-        extraKeys = tableBody.filter((l) => l.trim() !== '' && !MCP_OWN_KEY_RE.test(l)).map((l) => l.replace(/\r$/, ''));
-        foreign = [...span.inner.slice(0, h), ...(next === -1 ? [] : afterHeader.slice(next))];
-    }
-    const block = [MCP_MARKER_BEGIN, MCP_TABLE_HEADER, ...ownKeys, ...extraKeys, MCP_MARKER_END].map((l) => l + cr);
-    const moved = trimBlankEdges(foreign);
-    const out = [...span.before, ...block, ...(moved.length > 0 ? [cr, ...moved] : []), ...span.after];
-    const content = bom + out.join('\n');
+    // 마커도 forgen 시그니처도 없는 같은 이름의 테이블 = 사용자가 직접 관리. 건드리지도, append 하지도 않는다.
+    if (!at.owned)
+        return { content: currentToml, alreadyPresent: true };
+    const tableBody = lines.slice(at.header + 1, at.bodyEnd);
+    // 손으로 고쳐 여러 줄이 된 command/args 는 안전하게 다시 쓸 수 없다 — 그대로 둔다.
+    const own = tableBody.filter((l) => MCP_OWN_KEY_RE.test(l));
+    if (own.some((l) => !/(["'\]])\s*(#.*)?$/.test(l.trim())))
+        return { content: currentToml, alreadyPresent: true };
+    // 사용자가 Codex 로 이 서버에 붙인 설정(enabled, startup_timeout_sec …)은 테이블 안에 유지.
+    const extraKeys = tableBody.filter((l) => l.trim() !== '' && !MCP_OWN_KEY_RE.test(l)).map((l) => l.replace(/\r$/, ''));
+    const block = [MCP_MARKER_BEGIN, lines[at.header].replace(/\r$/, ''), ...ownKeys, ...extraKeys, MCP_MARKER_END].map((l) => l + cr);
+    // 마커는 어디에 있든 전부 걷어내고, 테이블 바로 위/아래에 다시 둔다 (재배치/소실된 마커 정규화).
+    const SENTINEL = '\u0000forgen-mcp-block\u0000';
+    const drop = new Set([...at.beginIdx, ...at.endIdx]);
+    for (let i = at.header + 1; i < at.bodyEnd; i += 1)
+        drop.add(i);
+    const kept = deleteLines(lines.map((l, i) => (i === at.header ? SENTINEL : l)), drop);
+    const pos = kept.indexOf(SENTINEL);
+    const next = kept[pos + 1];
+    // 블록 뒤에 다른 내용이 바로 붙으면 빈 줄로 구분
+    const needsGap = next !== undefined && next.trim() !== '';
+    kept.splice(pos, 1, ...block, ...(needsGap ? [cr] : []));
+    const content = joinToml(bom, kept);
     return { content, alreadyPresent: content === currentToml };
 }
 /**
- * forgen MCP 블록 제거 (uninstall, ADR-016 D4). forgen 테이블(본문 + `[mcp_servers.forgen-compound.*]` 하위
- * 테이블)과 마커만 걷어내고, 블록 사이에 Codex 가 끼워 넣은 다른 내용은 그 자리에 보존한다.
- * 마커 없는 사용자 관리 테이블은 건드리지 않는다.
+ * forgen MCP 블록 제거 (uninstall, ADR-016 D4). forgen 테이블(본문 + 하위 테이블)과 마커 줄만 걷어낸다.
+ * 마커도 시그니처도 없는 같은 이름의 테이블(사용자 관리)은 건드리지 않는다.
+ * `removed` 는 테이블을 실제로 지웠을 때만 true — 고아 마커만 치운 경우는 false.
  */
 export function removeMcpBlock(currentToml) {
     const { bom, body } = tomlShape(currentToml);
-    const span = splitManagedSpan(body.split('\n'), MCP_MARKER_BEGIN, MCP_MARKER_END);
-    if (!span)
+    const lines = body.split('\n');
+    const at = locateMcp(lines);
+    if (at.beginIdx.length === 0 && at.endIdx.length === 0 && !at.owned)
         return { content: currentToml, removed: false };
-    const kept = [];
-    let dropping = false;
-    for (const line of span.inner) {
-        const t = line.trim();
-        // 헤더 줄에서만 상태를 바꾼다: forgen 테이블 본체, 그 하위 테이블/배열 테이블은 버리고 나머지는 보존.
-        if (/^\[/.test(t))
-            dropping = /^\[{1,2}mcp_servers\.forgen-compound(\]{1,2}|\.)/.test(t);
-        if (!dropping)
-            kept.push(line);
-    }
-    const foreign = trimBlankEdges(kept);
-    const before = [...span.before];
-    // 블록 앞의 구분용 빈 줄은 블록과 함께 정리 (재설치/제거를 반복해도 빈 줄이 쌓이지 않게)
-    if (foreign.length === 0)
-        while (before.length > 0 && before[before.length - 1].trim() === '')
-            before.pop();
-    const out = [...before, ...foreign, ...span.after];
+    const drop = new Set([...at.beginIdx, ...at.endIdx]);
+    if (at.owned) {
+        for (let i = at.header; i < at.bodyEnd; i += 1)
+            drop.add(i);
+        // 하위 테이블은 Codex 가 어디로 옮겼든 함께 제거 (command 없는 서버 정의가 남지 않게).
+        // 각 하위 테이블도 끝의 빈 줄/주석(다음 항목의 장식)은 남긴다.
+        lines.forEach((l, i) => {
+            if (at.kinds[i] !== 'header' || !MCP_SUBTABLE_RE.test(l.trim()))
+                return;
+            for (let k = i; k < tableBodyEnd(lines, at.kinds, i, isMcpMarker); k += 1)
+                drop.add(k);
+        });
+    }
+    const out = trimEofBlankLines(deleteLines(lines, drop));
     while (out.length > 1 && out[0].trim() === '')
         out.shift(); // 파일 맨 앞 빈 줄
-    return { content: bom + out.join('\n'), removed: true };
+    return { content: joinToml(bom, out), removed: at.owned };
 }
 // ── ADR-016 D1: notify 폴백 (config.toml top-level `notify`) ───────────
 /** forgen notify 바이너리 argv 접두 (`--` 뒤는 사용자가 수동으로 붙인 체인 프로그램). */
@@ -174,87 +324,128 @@ const NOTIFY_OWN_COMMENTS = [
     '# forgen turn-complete fallback (ADR-016): works even while forgen hooks are untrusted.',
     '# To chain your own notifier, append:  "--", "<program>", "<args…>"  (kept across re-install).',
 ];
+const isNotifyOwnComment = (t) => t.startsWith('# forgen turn-complete fallback') || t.startsWith('# To chain your own notifier');
+const isNotifyMarker = (t) => t === NOTIFY_MARKER_BEGIN || t === NOTIFY_MARKER_END;
 /** `notify`, `"notify"`, `'notify'` 키 (dotted `notify.x` 포함) — 어느 것이든 forgen 의 notify 와 충돌한다. */
 const NOTIFY_KEY_RE = /^[ \t]*(?:notify|"notify"|'notify')[ \t]*[.=]/;
+/** forgen notify argv 의 시그니처: `…/dist/host/codex-notify.js` */
+const NOTIFY_SIGNATURE_RE = /[\\/]dist[\\/]host[\\/]codex-notify\.js$/;
+/** `notify = ["a","b"]` 한 줄을 argv 로. 여러 줄 배열·홑따옴표·뒤 주석 등 JSON 으로 못 읽으면 null. */
+function parseNotifyArgvLine(line) {
+    const value = line.trim().match(/^(?:notify|"notify"|'notify')[ \t]*=[ \t]*(\[.*\])$/)?.[1];
+    if (!value)
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) && parsed.every((a) => typeof a === 'string') ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * forgen notify 줄은 **argv 시그니처**(`…/dist/host/codex-notify.js`)로 찾는다. 마커는 Codex 가 옮기거나
+ * 없앨 수 있고, Codex 가 `notify` 값을 직접 바꾸면 forgen 블록 안에 사용자의 값이 들어앉기도 한다
+ * (그때 그 줄은 forgen 것이 아니다 — 마커/주석만 걷어내고 값은 보존).
+ */
 function parseNotifyBlock(lines) {
-    const span = splitManagedSpan(lines, NOTIFY_MARKER_BEGIN, NOTIFY_MARKER_END);
-    if (!span)
-        return { span: null, foreign: [], argv: null };
-    const idx = span.inner.findIndex((l) => NOTIFY_KEY_RE.test(l));
+    const kinds = classifyLines(lines);
+    const own = new Set();
+    lines.forEach((l, i) => {
+        if (kinds[i] === 'cont')
+            return; // 여러 줄 값 안의 텍스트는 건드리지 않는다
+        const t = l.trim();
+        if (isNotifyMarker(t) || isNotifyOwnComment(t))
+            own.add(i);
+    });
     let argv = null;
-    if (idx !== -1) {
-        argv = 'unparseable';
-        const value = span.inner[idx].trim().match(/^notify[ \t]*=[ \t]*(\[.*\])$/)?.[1];
-        try {
-            const parsed = value ? JSON.parse(value) : null;
-            if (Array.isArray(parsed) && parsed.every((a) => typeof a === 'string'))
-                argv = parsed;
-        }
-        catch { /* multi-line / single-quoted / trailing comment — 아래에서 블록을 그대로 둔다 */ }
+    const forgenIdx = lines.findIndex((l, i) => {
+        if (kinds[i] !== 'other' || !NOTIFY_KEY_RE.test(l))
+            return false;
+        const parsed = parseNotifyArgvLine(l);
+        if (!parsed?.some((a) => NOTIFY_SIGNATURE_RE.test(a)))
+            return false;
+        argv = parsed;
+        return true;
+    });
+    if (forgenIdx !== -1)
+        own.add(forgenIdx);
+    // BEGIN 바로 아래(forgen 주석만 사이)의 notify 키가 한 줄 JSON 이 아니면 손편집된 블록 — 호출부가 그대로 둔다.
+    let custom = false;
+    const begin = lines.findIndex((l) => l.trim() === NOTIFY_MARKER_BEGIN);
+    if (begin !== -1) {
+        let i = begin + 1;
+        while (i < lines.length && isNotifyOwnComment(lines[i].trim()))
+            i += 1;
+        if (i < lines.length && NOTIFY_KEY_RE.test(lines[i]) && parseNotifyArgvLine(lines[i]) === null)
+            custom = true;
     }
-    const foreign = span.inner.filter((l, i) => i !== idx && l.trim() !== '' && !l.trim().startsWith('# forgen turn-complete fallback') && !l.trim().startsWith('# To chain your own notifier'));
-    return { span, foreign, argv };
+    return {
+        touched: own.size > 0,
+        hasForgenLine: forgenIdx !== -1,
+        argv,
+        custom,
+        rest: deleteLines(lines, own),
+        userNotifyKey: lines.some((l, i) => !own.has(i) && kinds[i] === 'other' && NOTIFY_KEY_RE.test(l)),
+    };
 }
 /**
  * config.toml 에 forgen notify 블록을 upsert.
  *
  * - Codex 의 `notify` 는 top-level 단일 argv 다. 사용자가 이미 정의했으면 **건드리지 않는다** — 그리고
- *   forgen 블록이 남아 있으면 제거한다 (중복 키 = config.toml 파싱 실패 → Codex 기동 불가).
+ *   forgen 줄이 남아 있으면 제거한다 (중복 키 = config.toml 파싱 실패 → Codex 기동 불가).
  * - top-level 키는 첫 테이블 헤더 앞에 와야 하므로 블록은 항상 파일 최상단(BOM 뒤)에 둔다.
- * - 사용자가 forgen 블록의 argv 뒤에 `"--", "<prog>", …` 로 자기 notifier 를 체인해 뒀으면 그 꼬리를 보존.
+ * - 사용자가 forgen argv 뒤에 `"--", "<prog>", …` 로 자기 notifier 를 체인해 뒀으면 그 꼬리를 보존.
  *   블록의 notify 줄을 한 줄 JSON 으로 읽을 수 없으면(여러 줄 배열 등 손편집) 아무것도 바꾸지 않는다.
- * - 블록 사이에 Codex 가 끼워 넣은 줄(root 키)은 블록 바로 뒤로 옮겨 보존한다.
+ * - forgen 이 쓴 줄 외에는 원래 순서 그대로 둔다 (Codex 가 사이에 끼워 넣은 root 키 포함).
  */
 export function upsertNotifyBlock(currentToml, pkgRoot) {
     const { bom, body, cr } = tomlShape(currentToml);
     const lines = body.split('\n');
-    const { span, foreign, argv: existingArgv } = parseNotifyBlock(lines);
-    const outside = span ? [...span.before, ...span.after] : lines;
-    // 보수적 판정: 블록 밖 어디든 `notify =` 줄이 있으면 사용자 정의로 본다 (프로필 테이블 안이어도 skip —
+    const { touched, rest, argv: existingArgv, custom, userNotifyKey } = parseNotifyBlock(lines);
+    if (custom)
+        return { content: currentToml, status: 'custom-block' };
+    // 보수적 판정: forgen 줄 밖 어디든 `notify =` 줄이 있으면 사용자 정의로 본다 (프로필 테이블 안이어도 skip —
     // 폴백을 못 넣는 쪽이 config 를 깨뜨리는 쪽보다 낫다).
-    if (outside.some((l) => NOTIFY_KEY_RE.test(l))) {
-        if (!span)
-            return { content: currentToml, status: 'user-defined' };
-        return { content: bom + [...span.before, ...foreign, ...span.after].join('\n'), status: 'user-defined' };
+    if (userNotifyKey) {
+        return { content: touched ? joinToml(bom, rest) : currentToml, status: 'user-defined' };
     }
-    if (existingArgv === 'unparseable')
-        return { content: currentToml, status: 'custom-block' };
     const sep = existingArgv ? existingArgv.indexOf('--') : -1;
     const chainTail = existingArgv && sep !== -1 ? existingArgv.slice(sep) : [];
     const argv = [...forgenNotifyArgv(pkgRoot), ...chainTail];
     const block = [NOTIFY_MARKER_BEGIN, ...NOTIFY_OWN_COMMENTS, `notify = ${JSON.stringify(argv)}`, NOTIFY_MARKER_END].map((l) => l + cr);
-    const rest = span ? [...span.before, ...foreign, ...span.after] : lines;
     let start = 0;
     while (start < rest.length && rest[start].trim() === '')
         start += 1;
     const tail = rest.slice(start);
-    const content = bom + (tail.length > 0 ? [...block, cr, ...tail] : [...block, '']).join('\n');
+    const content = joinToml(bom, tail.length > 0 ? [...block, cr, ...tail] : [...block, '']);
     return { content, status: content === currentToml ? 'already-present' : 'installed' };
 }
 /**
- * forgen notify 블록 제거 (`--no-notify`, uninstall). 블록 사이에 끼어든 다른 줄은 보존.
+ * forgen notify 블록 제거 (`--no-notify`, uninstall).
  *
  * - 사용자가 블록의 notify 줄을 여러 줄 배열 등으로 손편집했으면(`custom`) **건드리지 않는다** — 첫 줄만
  *   지우면 남은 줄이 깨진 TOML 이 되어 Codex 가 기동하지 못한다 (critic 2026-10-02).
  * - `"--"` 뒤에 사용자가 체인해 둔 자기 notifier 가 있으면 그 argv 만으로 `notify` 를 되돌려 놓는다.
+ * - `removed` 는 forgen notify 줄을 실제로 지웠을 때만 true. 고아 마커/주석만 치운 경우는 false
+ *   (내용은 정리된 것을 돌려준다).
  */
 export function removeNotifyBlock(currentToml) {
     const { bom, body, cr } = tomlShape(currentToml);
-    const { span, foreign, argv } = parseNotifyBlock(body.split('\n'));
-    if (!span)
-        return { content: currentToml, removed: false, custom: false, restoredChain: [] };
-    if (argv === 'unparseable')
+    const { touched, hasForgenLine, rest, argv, custom } = parseNotifyBlock(body.split('\n'));
+    if (custom)
         return { content: currentToml, removed: false, custom: true, restoredChain: [] };
+    if (!touched)
+        return { content: currentToml, removed: false, custom: false, restoredChain: [] };
     const sep = argv ? argv.indexOf('--') : -1;
     const restoredChain = argv && sep !== -1 ? argv.slice(sep + 1) : [];
-    const restored = restoredChain.length > 0 ? [`notify = ${JSON.stringify(restoredChain)}${cr}`] : [];
-    const rest = [...span.before, ...restored, ...foreign, ...span.after];
     let start = 0;
-    if (span.before.every((l) => l.trim() === '') && restored.length === 0 && foreign.length === 0) {
-        while (start < rest.length && rest[start].trim() === '')
-            start += 1;
-    }
-    return { content: bom + rest.slice(start).join('\n'), removed: true, custom: false, restoredChain };
+    while (start < rest.length - 1 && rest[start].trim() === '')
+        start += 1;
+    const tail = trimEofBlankLines(rest.slice(start));
+    const hasContent = tail.some((l) => l.trim() !== '');
+    const restored = restoredChain.length > 0 ? [`notify = ${JSON.stringify(restoredChain)}${cr}`, ...(hasContent ? [cr] : [])] : [];
+    return { content: joinToml(bom, [...restored, ...tail]), removed: hasForgenLine, custom: false, restoredChain };
 }
 export function planCodexInstall(opts) {
     const codexHome = resolveCodexHome(opts);
@@ -336,10 +527,9 @@ export function planCodexInstall(opts) {
     else {
         // opt-out 은 "더 이상 등록하지 않음" 이 아니라 "없앰" 이어야 한다 (이전 설치의 블록이 남지 않게).
         const r = removeNotifyBlock(configToml);
-        if (r.removed) {
+        configToml = r.content; // 고아 마커만 정리된 경우도 반영
+        if (r.removed)
             notify = 'removed';
-            configToml = r.content;
-        }
         else if (r.custom)
             notify = 'custom-block';
     }
@@ -363,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,
@@ -757,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 };
 }
@@ -891,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)
@@ -919,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 {
@@ -928,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();
@@ -940,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, '\\$&');
-}