@wooojin/forgen 0.4.8 → 0.4.9

package/dist/hooks/solution-injector.js

@@ -30,6 +30,9 @@ import { STATE_DIR } from '../core/paths.js';
 import { recordHookTiming } from './shared/hook-timing.js';
 import { appendPending, flushAccept } from '../engine/solution-outcomes.js';
 import { appendImplicitFeedback } from '../store/implicit-feedback-store.js';
+import { emitSolutionEvent, querySurfacedWithin } from '../core/observability-store.js';
+import { parseSolutionV3 } from '../engine/solution-format.js';
+import { ME_SOLUTIONS } from '../core/paths.js';
 const MAX_SOLUTIONS_PER_SESSION = 10;
 /**
  * Minimum relevance thresholds by fitness state (2026-04-21 gate sweep).
@@ -252,6 +255,56 @@ function backfillCacheTagsOnDisk(cachePath, allMatched) {
         }
     }
 }
+/**
+ * 직전 5분 내 surfaced 된 솔루션이 현재 프롬프트와 키워드 매칭 시 acted_on emit.
+ * tags/identifiers 가 없는 솔루션은 skip. fail-open.
+ */
+async function detectActOnFromPriorSurface(sessionId, promptLower) {
+    try {
+        const recentSurfaces = querySurfacedWithin(sessionId, 5);
+        if (recentSurfaces.length === 0)
+            return;
+        const seen = new Set();
+        for (const surf of recentSurfaces) {
+            if (seen.has(surf.solutionId))
+                continue;
+            seen.add(surf.solutionId);
+            // 솔루션 파일 로드 (ME_SOLUTIONS 기준)
+            const filePath = path.join(ME_SOLUTIONS, `${surf.solutionId}.md`);
+            if (!fs.existsSync(filePath))
+                continue;
+            let raw;
+            try {
+                raw = fs.readFileSync(filePath, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            const sol = parseSolutionV3(raw);
+            if (!sol)
+                continue;
+            const tags = sol.frontmatter.tags ?? [];
+            const identifiers = sol.frontmatter.identifiers ?? [];
+            if (tags.length === 0 && identifiers.length === 0)
+                continue;
+            const hit = tags.some(t => promptLower.includes(t.toLowerCase()))
+                || identifiers.some(id => promptLower.includes(id.toLowerCase()));
+            if (!hit)
+                continue;
+            emitSolutionEvent({
+                sessionId,
+                solutionId: surf.solutionId,
+                eventType: 'acted_on',
+                signalSource: 'prompt-keyword',
+                signalScore: 0.20,
+                meta: { surface_ts: surf.ts },
+            });
+        }
+    }
+    catch (e) {
+        log.debug('detectActOnFromPriorSurface 실패', e);
+    }
+}
 async function main() {
     const _hookStart = Date.now();
     try {
@@ -265,6 +318,8 @@ async function main() {
             return;
         }
         const sessionId = input.session_id ?? 'default';
+        // Observability P2: 직전 surfaced 솔루션과 현재 프롬프트 키워드 매칭 → acted_on emit
+        await detectActOnFromPriorSurface(sessionId, input.prompt.toLowerCase());
         // v1: 교정 감지 → correction-record 호출 유도 hint
         const correctionPatterns = /하지\s*마|그렇게\s*말고|앞으로는|이렇게\s*해|stop\s+doing|don'?t\s+do|always\s+do|never\s+do|아니\s*그게\s*아니라/i;
         if (correctionPatterns.test(input.prompt)) {
@@ -294,6 +349,25 @@ async function main() {
         // 다시 매칭되면 그 정보로 cache의 missing tags를 채울 수 있다.
         // matches는 새 주입 후보 (이미 injected는 제외).
         const allMatched = matchSolutions(input.prompt, scope, cwd);
+        // Observability P1: matched emit — top-5 후보 각각 기록
+        try {
+            for (const candidate of allMatched.slice(0, 5)) {
+                emitSolutionEvent({
+                    sessionId,
+                    solutionId: candidate.name,
+                    eventType: 'matched',
+                    signalSource: 'matcher',
+                    signalScore: candidate.relevance,
+                    meta: {
+                        matchedTags: candidate.matchedTags,
+                        matchedIdentifiers: candidate.matchedIdentifiers,
+                    },
+                });
+            }
+        }
+        catch (e) {
+            log.debug('matched emit 실패', e);
+        }
         const matches = allMatched.filter(m => !injected.has(m.name));
         // T3: emit a ranking-decision record for offline analysis. Fail-open —
         // the logger swallows any error so this never blocks hook approval.
@@ -566,6 +640,25 @@ async function main() {
         catch (e) {
             log.debug('recommendation_surfaced emit 실패', e);
         }
+        // Observability P1: surfaced emit — approveWithContext 직전 effectiveToInject 각각 기록
+        try {
+            for (const sol of effectiveToInject) {
+                emitSolutionEvent({
+                    sessionId,
+                    solutionId: sol.name,
+                    eventType: 'surfaced',
+                    signalSource: 'hook-prepend',
+                    signalScore: sol.relevance,
+                    meta: {
+                        surfaceChars: fullInjection.length,
+                        injectionMode: 'context-prepend',
+                    },
+                });
+            }
+        }
+        catch (e) {
+            log.debug('surfaced emit 실패', e);
+        }
         // H1: 사용자 UI 에 recall hit 1줄 노출. additionalContext 는 모델 전용이라
         // v0.4.0 에서 8,000+ 주입이 발생했는데도 사용자는 0건을 봤다. systemMessage
         // 로 "N개 솔루션 참조" 를 surface → 사용자가 어떤 축적 지식이 붙었는지 인식.

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

@@ -1,14 +1,15 @@
 /**
  * Claude InstallPlan — feat/codex-support Phase 1 (P1-2)
  *
- * `npm install` postinstall.js 의 *Claude 측* 4 작업을 module 로 분리.
+ * `npm install` postinstall.js 의 *Claude 측* 5 작업을 module 로 분리.
  * `forgen install claude` CLI 가 호출 + (P1-6 에서) postinstall.js 도 위임.
  *
- * 4 작업:
+ * 5 작업:
  *   1. Plugin cache: ~/.claude/plugins/cache/forgen-local/forgen/<ver>/ 작성 + installed_plugins.json 등록
  *   2. Slash commands: ~/.claude/commands/forgen/*.md 생성 (forgen-managed marker)
  *   3. Settings hooks injection: ~/.claude/settings.json 의 hooks 머지 (forgen entry idempotent)
  *   4. MCP register: ~/.claude.json 에 mcpServers.forgen-compound 추가
+ *   5. Dev-guide skills: ~/.claude/skills/forgen-<stack>-<skill>/ 설치 (forgen-managed only)
  *
  * 사용자 비-forgen 자산 보존 + 재실행 idempotent.
  */
@@ -31,5 +32,8 @@ export interface ClaudeInstallResult {
     hooksInjected: number;
     mcpRegistered: boolean;
     mcpAlreadyPresent: boolean;
+    skillsPath: string;
+    skillsInstalled: number;
+    skillsRemoved: number;
 }
 export declare function planClaudeInstall(opts: ClaudeInstallOptions): ClaudeInstallResult;

package/dist/host/install-claude.js

@@ -1,14 +1,15 @@
 /**
  * Claude InstallPlan — feat/codex-support Phase 1 (P1-2)
  *
- * `npm install` postinstall.js 의 *Claude 측* 4 작업을 module 로 분리.
+ * `npm install` postinstall.js 의 *Claude 측* 5 작업을 module 로 분리.
  * `forgen install claude` CLI 가 호출 + (P1-6 에서) postinstall.js 도 위임.
  *
- * 4 작업:
+ * 5 작업:
  *   1. Plugin cache: ~/.claude/plugins/cache/forgen-local/forgen/<ver>/ 작성 + installed_plugins.json 등록
  *   2. Slash commands: ~/.claude/commands/forgen/*.md 생성 (forgen-managed marker)
  *   3. Settings hooks injection: ~/.claude/settings.json 의 hooks 머지 (forgen entry idempotent)
  *   4. MCP register: ~/.claude.json 에 mcpServers.forgen-compound 추가
+ *   5. Dev-guide skills: ~/.claude/skills/forgen-<stack>-<skill>/ 설치 (forgen-managed only)
  *
  * 사용자 비-forgen 자산 보존 + 재실행 idempotent.
  */
@@ -234,6 +235,72 @@ function registerMcpInClaudeJson(opts) {
     fs.writeFileSync(claudeJsonPath, `${JSON.stringify(claudeJson, null, 2)}\n`);
     return { registered: !alreadyPresent, alreadyPresent };
 }
+// ── 5. Dev-guide skills ────────────────────────────────────────────────
+const FORGEN_SKILL_PREFIX = 'forgen-';
+function installDevGuideSkills(opts) {
+    const { pkgRoot, skillsDir, dryRun } = opts;
+    const devGuideRoot = path.join(pkgRoot, 'assets', 'dev-guide');
+    // Collect all SKILL.md entries: assets/dev-guide/{tier}/skills/{stack}/{skill}/SKILL.md
+    const entries = [];
+    if (fs.existsSync(devGuideRoot)) {
+        for (const tier of fs.readdirSync(devGuideRoot)) {
+            const skillsBase = path.join(devGuideRoot, tier, 'skills');
+            if (!fs.existsSync(skillsBase))
+                continue;
+            for (const stack of fs.readdirSync(skillsBase)) {
+                const stackDir = path.join(skillsBase, stack);
+                if (!fs.statSync(stackDir).isDirectory())
+                    continue;
+                for (const skill of fs.readdirSync(stackDir)) {
+                    const skillMd = path.join(stackDir, skill, 'SKILL.md');
+                    if (fs.existsSync(skillMd)) {
+                        entries.push({ name: `${FORGEN_SKILL_PREFIX}${stack}-${skill}`, src: skillMd });
+                    }
+                }
+            }
+        }
+    }
+    if (dryRun) {
+        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)
+    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;
+    }
+    return { skillsPath: skillsDir, skillsInstalled: installed, skillsRemoved: removed };
+}
 // ── public ─────────────────────────────────────────────────────────────
 export function planClaudeInstall(opts) {
     if (!opts.pkgRoot || !fs.existsSync(opts.pkgRoot)) {
@@ -249,12 +316,14 @@ export function planClaudeInstall(opts) {
     const slashCommandsDir = path.join(claudeDir, 'commands', 'forgen');
     const settingsPath = path.join(claudeDir, 'settings.json');
     const claudeJsonPath = path.join(homeDir, '.claude.json');
+    const skillsDir = path.join(claudeDir, 'skills');
     const pluginCacheWritten = writePluginCache({ pkgRoot: opts.pkgRoot, cacheDir, pluginsDir, version, dryRun });
     const slashCommandsCount = writeSlashCommands({ pkgRoot: opts.pkgRoot, targetDir: slashCommandsDir, dryRun });
     const hooksInjected = injectHooksIntoSettings({ pkgRoot: opts.pkgRoot, settingsPath, dryRun });
     const mcp = registerMcp
         ? registerMcpInClaudeJson({ pkgRoot: opts.pkgRoot, claudeJsonPath, dryRun })
         : { registered: false, alreadyPresent: false };
+    const skills = installDevGuideSkills({ pkgRoot: opts.pkgRoot, skillsDir, dryRun });
     return {
         homeDir,
         pluginCachePath: cacheDir,
@@ -265,5 +334,8 @@ export function planClaudeInstall(opts) {
         hooksInjected,
         mcpRegistered: mcp.registered,
         mcpAlreadyPresent: mcp.alreadyPresent,
+        skillsPath: skills.skillsPath,
+        skillsInstalled: skills.skillsInstalled,
+        skillsRemoved: skills.skillsRemoved,
     };
 }

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

@@ -40,5 +40,9 @@ export interface CodexInstallResult {
     /** P3-3: AGENTS.md (cwd) 에 forgen rule block 인젝션 여부 */
     agentsMdPath: string;
     agentsMdInjected: boolean;
+    /** v0.4.9: dev-guide skills (~/.codex/skills) 설치 결과 */
+    devGuideSkillsPath: string;
+    devGuideSkillsInstalled: number;
+    devGuideSkillsRemoved: number;
 }
 export declare function planCodexInstall(opts: CodexInstallOptions): CodexInstallResult;

package/dist/host/install-codex.js

@@ -150,6 +150,12 @@ 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 });
+    // 8) v0.4.9: dev-guide skills → ~/.codex/skills/forgen-<stack>-<skill>/SKILL.md
+    const devGuideResult = installDevGuideSkillsToCodex({
+        pkgRoot: opts.pkgRoot,
+        codexHome,
+        dryRun: opts.dryRun ?? false,
+    });
     return {
         codexHome,
         hooksPath,
@@ -163,8 +169,73 @@ export function planCodexInstall(opts) {
         skillsPath,
         agentsMdPath,
         agentsMdInjected: agentsResult.injected,
+        devGuideSkillsPath: devGuideResult.devGuideSkillsPath,
+        devGuideSkillsInstalled: devGuideResult.devGuideSkillsInstalled,
+        devGuideSkillsRemoved: devGuideResult.devGuideSkillsRemoved,
     };
 }
+// ── v0.4.9: dev-guide skills → ~/.codex/skills ────────────────────────
+// dev-guide prefix pattern: forgen-<stack>-<skill> (e.g. forgen-react-fe-build)
+// 반드시 stack 이 react|vue|node|go 인 것만 매칭 — forgen 자체 commands 보존
+const DEV_GUIDE_SKILL_PATTERN = /^forgen-(react|vue|node|go)-/;
+function installDevGuideSkillsToCodex(opts) {
+    const devGuideRoot = path.join(opts.pkgRoot, 'assets', 'dev-guide');
+    const codexSkillsDir = path.join(opts.codexHome, 'skills');
+    if (!fs.existsSync(devGuideRoot)) {
+        return { devGuideSkillsPath: codexSkillsDir, devGuideSkillsInstalled: 0, devGuideSkillsRemoved: 0 };
+    }
+    // Collect entries: assets/dev-guide/{tier}/skills/{stack}/{skill}/SKILL.md
+    const entries = [];
+    for (const tier of fs.readdirSync(devGuideRoot)) {
+        const skillsBase = path.join(devGuideRoot, tier, 'skills');
+        if (!fs.existsSync(skillsBase))
+            continue;
+        for (const stack of fs.readdirSync(skillsBase)) {
+            const stackDir = path.join(skillsBase, stack);
+            if (!fs.statSync(stackDir).isDirectory())
+                continue;
+            for (const skill of fs.readdirSync(stackDir)) {
+                const skillMd = path.join(stackDir, skill, 'SKILL.md');
+                if (fs.existsSync(skillMd)) {
+                    entries.push({ name: `forgen-${stack}-${skill}`, src: skillMd });
+                }
+            }
+        }
+    }
+    if (opts.dryRun) {
+        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
+    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++;
+    }
+    return { devGuideSkillsPath: codexSkillsDir, devGuideSkillsInstalled: installed, devGuideSkillsRemoved: removed };
+}
 // ── P3-3: Codex skills install ────────────────────────────────────────
 function installCodexSkills(opts) {
     const { sourceDir, targetDir, dryRun } = opts;

package/dist/host/install-orchestrator.js

@@ -109,6 +109,7 @@ export function renderResult(result, dryRun) {
         lines.push(`    slash commands: ${result.claude.slashCommandsCount} → ${result.claude.slashCommandsPath}`);
         lines.push(`    settings.json hooks: ${result.claude.hooksInjected}`);
         lines.push(`    MCP: ${result.claude.mcpAlreadyPresent ? 'already present' : (result.claude.mcpRegistered ? 'registered' : 'skipped')}`);
+        lines.push(`    skills: ${result.claude.skillsInstalled ?? 0} installed → ${result.claude.skillsPath ?? ''}`);
     }
     if (result.codex) {
         lines.push('');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wooojin/forgen",
-  "version": "0.4.8",
+  "version": "0.4.9",
   "preferGlobal": true,
   "main": "dist/lib.js",
   "types": "./dist/lib.d.ts",
@@ -47,19 +47,19 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/forgen-team/forgen.git"
+    "url": "git+https://github.com/forgen-team/forgen.git"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.0.0"
   },
   "type": "module",
   "workspaces": [
     "packages/*"
   ],
   "bin": {
-    "forgen": "./dist/cli.js",
-    "fgx": "./dist/fgx.js",
-    "forgen-mcp": "./dist/mcp/server.js"
+    "forgen": "dist/cli.js",
+    "fgx": "dist/fgx.js",
+    "forgen-mcp": "dist/mcp/server.js"
   },
   "files": [
     "dist/",

package/plugin.json

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

package/scripts/postinstall.js

@@ -746,6 +746,125 @@ function cleanLegacyMcpFromSettings(settings) {
   }
 }
 
+/**
+ * dev-guide 스킬 14개 자동 설치 — assets/dev-guide/{fe,be}/skills/{stack}/{skill}/SKILL.md
+ *   → ~/.claude/skills/forgen-<stack>-<skill>/SKILL.md
+ *
+ * forgen- prefix 로 사용자 own skills 와 격리. idempotent 재실행 시 forgen-* 만 정리 후 재설치.
+ */
+function installDevGuideSkills(home) {
+  const devGuideRoot = join(PKG_ROOT, 'assets', 'dev-guide');
+  if (!existsSync(devGuideRoot)) {
+    console.log('[forgen] dev-guide assets not found — skipping skill install');
+    return 0;
+  }
+
+  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 */ }
+    }
+  }
+
+  // 2. assets/dev-guide/{side}/skills/{stack}/{skill}/SKILL.md 수집
+  let installed = 0;
+  for (const side of ['fe', 'be']) {
+    const sideSkillsDir = join(devGuideRoot, side, 'skills');
+    if (!existsSync(sideSkillsDir)) continue;
+    for (const stack of readdirSync(sideSkillsDir)) {
+      const stackDir = join(sideSkillsDir, stack);
+      if (!statSync(stackDir).isDirectory()) continue;
+      for (const skill of readdirSync(stackDir)) {
+        const skillSrc = join(stackDir, skill);
+        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++;
+      }
+    }
+  }
+
+  // 3. sudo 케이스 ownership 회복
+  fixOwnership(userSkillsDir);
+
+  console.log(`[forgen] dev-guide skills: ${installed} installed${removed > 0 ? ` (${removed} stale removed)` : ''}`);
+  return installed;
+}
+
+/**
+ * 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 정리.
+ */
+const DEV_GUIDE_SKILL_PATTERN = /^forgen-(react|vue|node|go)-/;
+
+function installDevGuideSkillsToCodex(home) {
+  const devGuideRoot = join(PKG_ROOT, 'assets', 'dev-guide');
+  if (!existsSync(devGuideRoot)) {
+    console.log('[forgen] dev-guide assets not found — codex skill install skipped');
+    return 0;
+  }
+
+  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 */ }
+    }
+  }
+
+  // 2. assets/dev-guide/{tier}/skills/{stack}/{skill}/SKILL.md 수집
+  let installed = 0;
+  for (const tier of readdirSync(devGuideRoot)) {
+    const sideSkillsDir = join(devGuideRoot, tier, 'skills');
+    if (!existsSync(sideSkillsDir)) continue;
+    for (const stack of readdirSync(sideSkillsDir)) {
+      const stackDir = join(sideSkillsDir, stack);
+      if (!statSync(stackDir).isDirectory()) continue;
+      for (const skill of readdirSync(stackDir)) {
+        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++;
+      }
+    }
+  }
+
+  fixOwnership(codexSkillsDir);
+  console.log(`[forgen] codex dev-guide skills: ${installed} installed${removed > 0 ? ` (${removed} stale removed)` : ''}`);
+  return installed;
+}
+
 // ── Main ──
 
 /**
@@ -927,6 +1046,21 @@ async function main() {
     console.error(`[forgen] starter pack failed: ${err?.message ?? err}`);
   }
 
+  // ── 8b. dev-guide 스킬 자동 설치 (claude) ──
+  try {
+    installDevGuideSkills(HOME);
+  } catch (e) {
+    // postinstall 의 "fail-open" 원칙 — npm install 깨뜨리지 않음
+    console.log(`[forgen] dev-guide skills 설치 스킵 (${e?.message ?? e})`);
+  }
+
+  // ── 8c. dev-guide 스킬 자동 설치 (codex) ──
+  try {
+    installDevGuideSkillsToCodex(HOME);
+  } catch (e) {
+    console.log(`[forgen] codex dev-guide skills 설치 스킵 (${e?.message ?? e})`);
+  }
+
   // sudo 실행 시 파일 소유권을 실제 유저로 변경
   fixOwnership(join(HOME, '.claude'), join(HOME, '.forgen'));