@wooojin/forgen 0.1.0

package/dist/hooks/shared/injection-caps.js

@@ -0,0 +1,52 @@
+/**
+ * Forgen — Injection Caps
+ *
+ * 컨텍스트 주입 하드캡 상수. 다른 플러그인과 공존 시 컨텍스트 윈도우를
+ * 과도하게 점유하지 않도록 각 훅의 최대 주입량을 제한합니다.
+ *
+ * 이 값들은 어댑티브 버짓 시스템의 "절대 상한"이며,
+ * 실제 주입량은 context-budget.ts에서 동적으로 조절됩니다.
+ */
+export const INJECTION_CAPS = {
+    /** notepad-injector: 노트패드 최대 주입 글자 수 (현재: 무제한 → 2000) */
+    notepadMax: 2000,
+    /** skill-injector: 스킬 파일 하나당 최대 글자 수 (현재: 무제한 → 3000) */
+    skillContentMax: 3000,
+    /** solution-injector: 솔루션 하나당 최대 글자 수 (기존 값 유지) */
+    solutionMax: 1500,
+    /** solution-injector: 세션 전체 주입 상한 (기존 값 유지) */
+    solutionSessionMax: 8000,
+};
+/**
+ * .claude/rules/ 자동생성 파일의 사이즈 하드캡.
+ * rules 파일은 Claude Code가 세션 시작 시 전부 로드하므로
+ * 무제한 성장을 방지해야 합니다.
+ *
+ * 근거: Claude Code 공식 권장 — "CLAUDE.md 파일당 200줄 이하",
+ * "길수록 지시 준수율 저하". 3000자 ≈ 60~80줄.
+ */
+export const RULE_FILE_CAPS = {
+    /** .claude/rules/ 파일 1개당 최대 글자 수 */
+    perRuleFile: 3000,
+    /** .claude/rules/에 forgen가 쓸 수 있는 총량 (글자) */
+    totalRuleFiles: 15000,
+    /** compound.md에 포함할 rule summary 최대 수 */
+    maxRuleSummaries: 10,
+};
+/** truncation 시 끝에 추가되는 표시 */
+export const TRUNCATION_SUFFIX = '\n... (truncated)';
+/** 주어진 content를 maxChars로 잘라서 반환. 초과 시 truncation suffix 추가. */
+export function truncateContent(content, maxChars) {
+    if (content.length <= maxChars)
+        return content;
+    const cutAt = Math.max(0, maxChars - TRUNCATION_SUFFIX.length);
+    let sliced = content.slice(0, cutAt);
+    // UTF-16 서로게이트 쌍 분리 방지: 마지막 문자가 high surrogate이면 제거
+    if (sliced.length > 0) {
+        const lastCode = sliced.charCodeAt(sliced.length - 1);
+        if (lastCode >= 0xD800 && lastCode <= 0xDBFF) {
+            sliced = sliced.slice(0, -1);
+        }
+    }
+    return sliced + TRUNCATION_SUFFIX;
+}

package/dist/hooks/shared/plugin-signal.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Forgen — Plugin Signal Protocol
+ *
+ * 플러그인 간 컨텍스트 주입량을 상호 인지하기 위한 파일 기반 시그널.
+ * 현재는 forgen만 시그널을 쓰지만, 다른 플러그인도 같은 프로토콜을
+ * 채택하면 동적 버짓 조율이 가능해집니다.
+ *
+ * 시그널 디렉토리: ~/.claude/plugin-signals/
+ * 파일 형식: {pluginName}-{sessionId}.json
+ * TTL: 30분 (자동 정리)
+ */
+export interface PluginSignal {
+    pluginName: string;
+    hookEvent: string;
+    charsInjected: number;
+    timestamp: string;
+}
+/** forgen의 주입 시그널을 기록합니다 */
+export declare function writeSignal(sessionId: string, hookEvent: string, charsInjected: number): void;
+/** stale 시그널 파일을 정리합니다 (읽기와 분리된 side-effect) */
+export declare function cleanupStaleSignals(): void;
+/** 다른 플러그인의 시그널을 읽어서 총 주입량을 반환합니다 (읽기 전용) */
+export declare function readOtherSignals(_sessionId: string): PluginSignal[];

package/dist/hooks/shared/plugin-signal.js

@@ -0,0 +1,104 @@
+/**
+ * Forgen — Plugin Signal Protocol
+ *
+ * 플러그인 간 컨텍스트 주입량을 상호 인지하기 위한 파일 기반 시그널.
+ * 현재는 forgen만 시그널을 쓰지만, 다른 플러그인도 같은 프로토콜을
+ * 채택하면 동적 버짓 조율이 가능해집니다.
+ *
+ * 시그널 디렉토리: ~/.claude/plugin-signals/
+ * 파일 형식: {pluginName}-{sessionId}.json
+ * TTL: 30분 (자동 정리)
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { CLAUDE_DIR } from '../../core/paths.js';
+const SIGNAL_DIR = path.join(CLAUDE_DIR, 'plugin-signals');
+const SIGNAL_TTL_MS = 30 * 60 * 1000; // 30분
+/** forgen의 주입 시그널을 기록합니다 */
+export function writeSignal(sessionId, hookEvent, charsInjected) {
+    try {
+        fs.mkdirSync(SIGNAL_DIR, { recursive: true });
+        // 경로 탈출 방지: sessionId에서 디렉토리 구분자와 위험 문자 제거
+        const safeId = sessionId.replace(/[^a-zA-Z0-9_-]/g, '_');
+        const filePath = path.join(SIGNAL_DIR, `forgen-${safeId}.json`);
+        const signal = {
+            pluginName: 'forgen',
+            hookEvent,
+            charsInjected,
+            timestamp: new Date().toISOString(),
+        };
+        fs.writeFileSync(filePath, JSON.stringify(signal));
+        // 쓰기 시점에 stale 시그널 정리 (읽기와 분리)
+        cleanupStaleSignals();
+    }
+    catch {
+        // 시그널 기록 실패는 무시
+    }
+}
+/** stale 시그널 파일을 정리합니다 (읽기와 분리된 side-effect) */
+export function cleanupStaleSignals() {
+    try {
+        if (!fs.existsSync(SIGNAL_DIR))
+            return;
+        const now = Date.now();
+        for (const file of fs.readdirSync(SIGNAL_DIR)) {
+            if (!file.endsWith('.json'))
+                continue;
+            try {
+                const filePath = path.join(SIGNAL_DIR, file);
+                // 파일 크기 체크 — 1KB 초과 시그널은 비정상 (DoS 방지)
+                const stat = fs.statSync(filePath);
+                if (stat.size > 1024) {
+                    fs.unlinkSync(filePath);
+                    continue;
+                }
+                const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                const age = now - new Date(data.timestamp).getTime();
+                if (!Number.isFinite(age) || age > SIGNAL_TTL_MS) {
+                    fs.unlinkSync(filePath);
+                }
+            }
+            catch {
+                // 개별 파일 처리 실패는 무시
+            }
+        }
+    }
+    catch {
+        // 디렉토리 접근 실패
+    }
+}
+/** 다른 플러그인의 시그널을 읽어서 총 주입량을 반환합니다 (읽기 전용) */
+export function readOtherSignals(_sessionId) {
+    const signals = [];
+    try {
+        if (!fs.existsSync(SIGNAL_DIR))
+            return signals;
+        const now = Date.now();
+        for (const file of fs.readdirSync(SIGNAL_DIR)) {
+            if (file.startsWith('forgen-'))
+                continue;
+            if (!file.endsWith('.json'))
+                continue;
+            try {
+                const filePath = path.join(SIGNAL_DIR, file);
+                // 파일 크기 체크 — 1KB 초과 시그널은 비정상
+                const stat = fs.statSync(filePath);
+                if (stat.size > 1024)
+                    continue;
+                const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                const age = now - new Date(data.timestamp).getTime();
+                // TTL 초과는 건너뜀 (삭제는 cleanupStaleSignals에서)
+                if (!Number.isFinite(age) || age > SIGNAL_TTL_MS)
+                    continue;
+                signals.push(data);
+            }
+            catch {
+                // 개별 시그널 읽기 실패는 무시
+            }
+        }
+    }
+    catch {
+        // 디렉토리 접근 실패
+    }
+    return signals;
+}

package/dist/hooks/shared/read-stdin.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 훅 공유 유틸: timeout-protected stdin 읽기
+ *
+ * event-based 패턴으로 Linux에서 hang을 방지합니다.
+ * (for await of process.stdin은 일부 환경에서 hang 발생)
+ */
+/** stdin에서 JSON 데이터를 읽어 파싱. 실패 시 null 반환. */
+export declare function readStdinJSON<T = Record<string, unknown>>(timeoutMs?: number): Promise<T | null>;

package/dist/hooks/shared/read-stdin.js

@@ -0,0 +1,63 @@
+/**
+ * 훅 공유 유틸: timeout-protected stdin 읽기
+ *
+ * event-based 패턴으로 Linux에서 hang을 방지합니다.
+ * (for await of process.stdin은 일부 환경에서 hang 발생)
+ */
+const MAX_STDIN_BYTES = 10 * 1024 * 1024; // 10MB — 메모리 고갈 방지
+/** stdin에서 JSON 데이터를 읽어 파싱. 실패 시 null 반환. */
+export async function readStdinJSON(timeoutMs = 2000) {
+    const chunks = [];
+    let totalSize = 0;
+    let settled = false;
+    const raw = await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                process.stdin.removeAllListeners();
+                process.stdin.pause();
+                resolve(Buffer.concat(chunks).toString('utf-8'));
+            }
+        }, timeoutMs);
+        // 일부 Node.js 환경에서 stdin이 paused 상태로 시작 — 명시적 resume 필요
+        if (typeof process.stdin.resume === 'function') {
+            process.stdin.resume();
+        }
+        process.stdin.on('data', (chunk) => {
+            const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            totalSize += buf.length;
+            if (totalSize > MAX_STDIN_BYTES) {
+                if (!settled) {
+                    settled = true;
+                    clearTimeout(timeout);
+                    process.stdin.removeAllListeners();
+                    if (typeof process.stdin.pause === 'function')
+                        process.stdin.pause();
+                    resolve('');
+                }
+                return;
+            }
+            chunks.push(buf);
+        });
+        process.stdin.on('end', () => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timeout);
+                resolve(Buffer.concat(chunks).toString('utf-8'));
+            }
+        });
+        process.stdin.on('error', () => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timeout);
+                resolve('');
+            }
+        });
+    });
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/hooks/shared/sanitize-id.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 훅 공유 유틸: session_id / 파일명에 사용되는 ID 정제
+ *
+ * path traversal 방지를 위해 영숫자, 하이픈, 언더스코어만 허용합니다.
+ */
+/** ID를 파일명에 안전한 형태로 변환. 위험 문자는 '_'로 치환. */
+export declare function sanitizeId(id: string, maxLength?: number): string;

package/dist/hooks/shared/sanitize-id.js

@@ -0,0 +1,9 @@
+/**
+ * 훅 공유 유틸: session_id / 파일명에 사용되는 ID 정제
+ *
+ * path traversal 방지를 위해 영숫자, 하이픈, 언더스코어만 허용합니다.
+ */
+/** ID를 파일명에 안전한 형태로 변환. 위험 문자는 '_'로 치환. */
+export function sanitizeId(id, maxLength = 128) {
+    return id.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, maxLength) || 'default';
+}

package/dist/hooks/shared/sanitize.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 훅 공유 유틸: 키워드/트리거 감지용 프롬프트 정제
+ *
+ * 코드 블록, URL, XML 태그, 파일 경로를 제거하여
+ * 순수 텍스트에서만 키워드를 감지할 수 있게 합니다.
+ */
+export declare function sanitizeForDetection(prompt: string): string;

package/dist/hooks/shared/sanitize.js

@@ -0,0 +1,22 @@
+/**
+ * 훅 공유 유틸: 키워드/트리거 감지용 프롬프트 정제
+ *
+ * 코드 블록, URL, XML 태그, 파일 경로를 제거하여
+ * 순수 텍스트에서만 키워드를 감지할 수 있게 합니다.
+ */
+export function sanitizeForDetection(prompt) {
+    let sanitized = prompt;
+    // 코드 블록 제거 (```...```)
+    sanitized = sanitized.replace(/```[\s\S]*?```/g, '');
+    // 인라인 코드 제거 (`...`)
+    sanitized = sanitized.replace(/`[^`]+`/g, '');
+    // URL 제거
+    sanitized = sanitized.replace(/https?:\/\/\S+/g, '');
+    // XML 태그 블록 제거 (열고 닫는 태그 이름 일치)
+    sanitized = sanitized.replace(/<(\w[\w-]*)[\s>][\s\S]*?<\/\1>/g, '');
+    // 자체 폐쇄 태그 제거
+    sanitized = sanitized.replace(/<\w[\w-]*(?:\s[^>]*)?\s*\/>/g, '');
+    // 파일 경로 제거 (multi-segment 포함)
+    sanitized = sanitized.replace(/(^|[\s"'`(])(?:\.?\/(?:[\w.-]+\/)*[\w.-]+|(?:[\w.-]+\/)+[\w.-]+\.\w+)/gm, '$1');
+    return sanitized;
+}

package/dist/hooks/skill-injector.d.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+/**
+ * Forgen — Skill Injector Hook
+ *
+ * Claude Code UserPromptSubmit 훅으로 등록.
+ * 프롬프트와 매칭되는 학습된 스킬을 자동으로 컨텍스트에 주입합니다.
+ *
+ * 스킬 파일 위치:
+ *   1. {project}/.compound/skills/*.md  (프로젝트 스킬)
+ *   2. ~/.compound/skills/*.md          (글로벌 스킬)
+ *   3. ~/.compound/me/skills/*.md       (개인 학습 스킬)
+ *
+ * 스킬 포맷:
+ *   ---
+ *   name: my-skill
+ *   description: What this skill does
+ *   triggers:
+ *     - "keyword1"
+ *     - "keyword2"
+ *   ---
+ *   <Purpose>...</Purpose>
+ *   <Steps>...</Steps>
+ */
+export interface SkillMeta {
+    name: string;
+    description: string;
+    triggers: string[];
+    filePath: string;
+    content: string;
+}
+/** YAML frontmatter 파싱 (간단한 구현) */
+export declare function parseFrontmatter(content: string): {
+    meta: Record<string, unknown>;
+    body: string;
+};
+/** 프롬프트와 스킬 트리거 매칭 (sanitized 텍스트에서만)
+ *  keyword-detector가 이미 처리하는 스킬은 제외하여 이중 주입을 방지합니다. */
+export declare function matchSkills(prompt: string, skills: SkillMeta[]): SkillMeta[];

package/dist/hooks/skill-injector.js

@@ -0,0 +1,285 @@
+#!/usr/bin/env node
+/**
+ * Forgen — Skill Injector Hook
+ *
+ * Claude Code UserPromptSubmit 훅으로 등록.
+ * 프롬프트와 매칭되는 학습된 스킬을 자동으로 컨텍스트에 주입합니다.
+ *
+ * 스킬 파일 위치:
+ *   1. {project}/.compound/skills/*.md  (프로젝트 스킬)
+ *   2. ~/.compound/skills/*.md          (글로벌 스킬)
+ *   3. ~/.compound/me/skills/*.md       (개인 학습 스킬)
+ *
+ * 스킬 포맷:
+ *   ---
+ *   name: my-skill
+ *   description: What this skill does
+ *   triggers:
+ *     - "keyword1"
+ *     - "keyword2"
+ *   ---
+ *   <Purpose>...</Purpose>
+ *   <Steps>...</Steps>
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createLogger } from '../core/logger.js';
+const log = createLogger('skill-injector');
+import { readStdinJSON } from './shared/read-stdin.js';
+import { sanitizeForDetection } from './shared/sanitize.js';
+import { sanitizeId } from './shared/sanitize-id.js';
+import { escapeAllXmlTags } from './prompt-injection-filter.js';
+function escapeXmlAttr(s) {
+    return s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+import { atomicWriteJSON } from './shared/atomic-write.js';
+import { FORGEN_HOME, ME_DIR, STATE_DIR } from '../core/paths.js';
+import { KEYWORD_PATTERNS } from './keyword-detector.js';
+import { isHookEnabled } from './hook-config.js';
+import { approve, approveWithContext, failOpen } from './shared/hook-response.js';
+/** keyword-detector가 처리하는 키워드 이름 집합 (skill + inject 모두 포함, 이중 주입 방지) */
+const KEYWORD_DETECTOR_SKILL_NAMES = new Set(KEYWORD_PATTERNS
+    .filter(p => p.type === 'skill' || p.type === 'inject')
+    .map(p => p.skill ?? p.keyword));
+const MAX_SKILLS_PER_SESSION = 5;
+/** 파일 기반 세션 캐시 (훅은 매번 새 프로세스로 실행되므로 in-memory 불가) */
+function getSessionCachePath(sessionId) {
+    return path.join(STATE_DIR, `skill-cache-${sanitizeId(sessionId)}.json`);
+}
+function loadSessionCache(sessionId) {
+    const cachePath = getSessionCachePath(sessionId);
+    try {
+        if (fs.existsSync(cachePath)) {
+            const data = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+            // 24시간 초과 시 만료
+            if (data.updatedAt && Date.now() - new Date(data.updatedAt).getTime() > 24 * 60 * 60 * 1000) {
+                fs.unlinkSync(cachePath);
+                return new Set();
+            }
+            return new Set(data.injected ?? []);
+        }
+    }
+    catch (e) {
+        log.debug('세션 캐시 파일 읽기/파싱 실패', e);
+    }
+    return new Set();
+}
+function saveSessionCache(sessionId, injected) {
+    atomicWriteJSON(getSessionCachePath(sessionId), {
+        injected: [...injected],
+        updatedAt: new Date().toISOString(),
+    });
+}
+/** YAML frontmatter 파싱 (간단한 구현) */
+export function parseFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!match)
+        return { meta: {}, body: content };
+    const meta = {};
+    const yamlLines = match[1].split('\n');
+    let currentKey = '';
+    let inArray = false;
+    const arrayValues = [];
+    for (const line of yamlLines) {
+        const trimmed = line.trim();
+        if (inArray) {
+            if (trimmed.startsWith('- ')) {
+                arrayValues.push(trimmed.slice(2).replace(/^["']|["']$/g, ''));
+                continue;
+            }
+            else {
+                meta[currentKey] = [...arrayValues];
+                arrayValues.length = 0;
+                inArray = false;
+            }
+        }
+        const kvMatch = trimmed.match(/^(\w[\w-]*)\s*:\s*(.*)$/);
+        if (kvMatch) {
+            currentKey = kvMatch[1];
+            const val = kvMatch[2].trim();
+            if (val === '' || val === '[]') {
+                // 다음 줄이 배열일 수 있음
+                inArray = true;
+            }
+            else {
+                meta[currentKey] = val.replace(/^["']|["']$/g, '');
+            }
+        }
+    }
+    if (inArray && arrayValues.length > 0) {
+        meta[currentKey] = arrayValues;
+    }
+    return { meta, body: match[2] };
+}
+/** 디렉토리에서 스킬 파일 스캔 */
+function scanSkills(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    try {
+        return fs.readdirSync(dir)
+            .filter(f => f.endsWith('.md'))
+            .filter(f => {
+            const filePath = path.join(dir, f);
+            try {
+                return !fs.lstatSync(filePath).isSymbolicLink();
+            }
+            catch {
+                return false;
+            }
+        })
+            .map(f => {
+            const filePath = path.join(dir, f);
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            const { meta, body } = parseFrontmatter(raw);
+            return {
+                name: meta.name ?? f.replace('.md', ''),
+                description: meta.description ?? '',
+                triggers: meta.triggers ?? [],
+                filePath,
+                content: body.trim(),
+            };
+        });
+    }
+    catch (e) {
+        log.debug(`스킬 디렉토리 스캔 실패: ${dir}`, e);
+        return [];
+    }
+}
+/** 모든 스킬 소스에서 스킬 수집 */
+function collectSkills() {
+    const skills = [];
+    const seen = new Map(); // name → source dir
+    // 패키지 내장 스킬 경로 (dist/../skills/)
+    const pkgSkillsDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'commands');
+    // v1: 팀 팩 스킬 제거. 프로젝트 > 개인 > 글로벌 > 패키지 내장
+    const dirs = [
+        path.join(process.cwd(), '.compound', 'skills'),
+        path.join(ME_DIR, 'skills'),
+        path.join(FORGEN_HOME, 'skills'),
+        pkgSkillsDir,
+    ];
+    const overrides = [];
+    for (const dir of dirs) {
+        for (const skill of scanSkills(dir)) {
+            if (!seen.has(skill.name)) {
+                seen.set(skill.name, dir);
+                skills.push(skill);
+            }
+            else {
+                // 팩 스킬이 무시된 경우 기록
+                const winnerDir = seen.get(skill.name) ?? '';
+                if (dir.includes('/packs/') || winnerDir.includes('/packs/')) {
+                    overrides.push({ name: skill.name, winner: winnerDir, loser: dir });
+                }
+            }
+        }
+    }
+    if (overrides.length > 0) {
+        for (const o of overrides) {
+            log.debug(`⚠ 스킬 '${o.name}' 오버라이드: ${path.basename(path.dirname(o.winner))} 우선, ${path.basename(path.dirname(o.loser))} 무시됨`);
+        }
+    }
+    return skills;
+}
+/** 프롬프트와 스킬 트리거 매칭 (sanitized 텍스트에서만)
+ *  keyword-detector가 이미 처리하는 스킬은 제외하여 이중 주입을 방지합니다. */
+export function matchSkills(prompt, skills) {
+    const sanitized = sanitizeForDetection(prompt);
+    const lower = sanitized.toLowerCase();
+    return skills.filter(skill => {
+        if (skill.triggers.length === 0)
+            return false;
+        // keyword-detector가 처리하는 스킬은 skill-injector에서 주입하지 않음
+        if (KEYWORD_DETECTOR_SKILL_NAMES.has(skill.name))
+            return false;
+        return skill.triggers.some(trigger => lower.includes(trigger.toLowerCase()));
+    });
+}
+/** 오래된 skill-cache 파일 가비지 컬렉션 (1시간마다 실행) */
+function cleanStaleSkillCaches() {
+    if (!fs.existsSync(STATE_DIR))
+        return;
+    // W-D3: 매 프롬프트 대신 1시간 간격으로 실행
+    const markerPath = path.join(STATE_DIR, '.last-cache-gc');
+    try {
+        if (fs.existsSync(markerPath)) {
+            const lastGc = fs.statSync(markerPath).mtimeMs;
+            if (Date.now() - lastGc < 60 * 60 * 1000)
+                return;
+        }
+    }
+    catch { /* marker read failure — proceed with GC */ }
+    try {
+        const now = Date.now();
+        for (const f of fs.readdirSync(STATE_DIR)) {
+            if (!f.startsWith('skill-cache-'))
+                continue;
+            const p = path.join(STATE_DIR, f);
+            const stat = fs.statSync(p);
+            if (now - stat.mtimeMs > 24 * 60 * 60 * 1000) {
+                fs.unlinkSync(p);
+            }
+        }
+        fs.writeFileSync(markerPath, '');
+    }
+    catch (e) {
+        log.debug('오래된 캐시 파일 삭제 실패', e);
+    }
+}
+// ── 메인 ──
+async function main() {
+    const input = await readStdinJSON();
+    if (!isHookEnabled('skill-injector')) {
+        console.log(approve());
+        return;
+    }
+    if (!input?.prompt) {
+        console.log(approve());
+        return;
+    }
+    const sessionId = input.session_id ?? 'default';
+    // 오래된 캐시 파일 정리 (가비지 컬렉션)
+    cleanStaleSkillCaches();
+    // 파일 기반 세션 캐시 로드
+    const injected = loadSessionCache(sessionId);
+    // 이미 최대치 주입했으면 통과
+    if (injected.size >= MAX_SKILLS_PER_SESSION) {
+        console.log(approve());
+        return;
+    }
+    // 스킬 수집 및 매칭
+    const allSkills = collectSkills();
+    const matched = matchSkills(input.prompt, allSkills)
+        .filter(s => !injected.has(s.name)); // 이미 주입된 것 제외
+    if (matched.length === 0) {
+        console.log(approve());
+        return;
+    }
+    // 최대 제한 적용
+    const toInject = matched.slice(0, MAX_SKILLS_PER_SESSION - injected.size);
+    // 파일 기반 캐시 업데이트
+    for (const skill of toInject) {
+        injected.add(skill.name);
+    }
+    saveSessionCache(sessionId, injected);
+    // Adaptive budget: 다른 플러그인 감지 시 스킬 주입량 축소
+    let skillCap = 3000; // INJECTION_CAPS.skillContentMax 기본값
+    try {
+        const { calculateBudget } = await import('./shared/context-budget.js');
+        skillCap = calculateBudget().skillContentMax;
+    }
+    catch { /* budget 로드 실패 시 기본값 사용 */ }
+    // 스킬 컨텍스트 주입 (adaptive cap 적용)
+    const injections = toInject.map(skill => {
+        const capped = skill.content.length > skillCap
+            ? `${skill.content.slice(0, skillCap)}\n... (capped)`
+            : skill.content;
+        return `<compound-learned-skill name="${escapeXmlAttr(skill.name)}" description="${escapeXmlAttr(skill.description)}">\n${escapeAllXmlTags(capped)}\n</compound-learned-skill>`;
+    }).join('\n\n');
+    console.log(approveWithContext(injections, 'UserPromptSubmit'));
+}
+main().catch((e) => {
+    process.stderr.write(`[ch-hook] ${e instanceof Error ? e.message : String(e)}\n`);
+    console.log(failOpen());
+});

package/dist/hooks/slop-detector.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * Forgen — Slop Detector Hook (PostToolUse)
+ *
+ * Write/Edit 도구 실행 후 결과물에서 AI 슬롭 패턴을 감지합니다.
+ * - TODO 주석 잔류, eslint-disable, @ts-expect-error, as any 등
+ * - Empty catch blocks, unnecessary comments, console.log debug code
+ */
+export declare const SLOP_PATTERNS: Array<{
+    pattern: RegExp;
+    message: string;
+    severity: 'warn' | 'info';
+}>;
+/** 텍스트에서 슬롭 패턴을 감지하여 메시지 목록 반환 (순수 함수) */
+export declare function detectSlop(text: string): Array<{
+    message: string;
+    severity: 'warn' | 'info';
+}>;