@wooojin/forgen 0.2.1 → 0.3.1

package/dist/engine/solution-quarantine.js

@@ -0,0 +1,172 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import yaml from 'js-yaml';
+import { SOLUTION_QUARANTINE_PATH, STATE_DIR } from '../core/paths.js';
+import { diagnoseFrontmatter } from './solution-format.js';
+import { createLogger } from '../core/logger.js';
+const log = createLogger('solution-quarantine');
+/**
+ * Produce actionable frontmatter diagnostics directly from file content.
+ *
+ * This duplicates the YAML parse that `parseFrontmatterOnly` already does,
+ * but it runs only on the rare failure path (solution dropped from index),
+ * so the overhead is acceptable in exchange for a human-readable error list.
+ */
+export function diagnoseFromRawContent(content) {
+    const trimmed = content.trimStart();
+    if (!trimmed.startsWith('---'))
+        return ['no YAML frontmatter (missing leading ---)'];
+    const endIdx = trimmed.indexOf('---', 3);
+    if (endIdx === -1)
+        return ['frontmatter not closed (missing trailing ---)'];
+    const raw = trimmed.slice(3, endIdx);
+    if (raw.length > 5000)
+        return ['frontmatter too large (>5000 chars — YAML bomb guard)'];
+    let parsed;
+    try {
+        parsed = yaml.load(raw, { schema: yaml.JSON_SCHEMA });
+    }
+    catch (e) {
+        return [`YAML parse error: ${e instanceof Error ? e.message : String(e)}`];
+    }
+    return diagnoseFrontmatter(parsed);
+}
+/**
+ * Append one quarantine entry for `filePath`. Deduped by path within the
+ * current file: if the latest entry for this path already matches the
+ * current errors, skip the append.
+ *
+ * Storage: one JSONL line per quarantine event. Readers use only the
+ * latest line per path.
+ */
+export function recordQuarantine(filePath, errors) {
+    try {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        if (dedupeHit(filePath, errors))
+            return;
+        const entry = {
+            path: filePath,
+            at: new Date().toISOString(),
+            errors,
+        };
+        fs.appendFileSync(SOLUTION_QUARANTINE_PATH, JSON.stringify(entry) + '\n');
+    }
+    catch (e) {
+        log.debug(`quarantine write failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+function dedupeHit(filePath, errors) {
+    if (!fs.existsSync(SOLUTION_QUARANTINE_PATH))
+        return false;
+    try {
+        const text = fs.readFileSync(SOLUTION_QUARANTINE_PATH, 'utf-8');
+        const lines = text.split('\n').filter(Boolean);
+        for (let i = lines.length - 1; i >= 0; i--) {
+            let prev;
+            try {
+                prev = JSON.parse(lines[i]);
+            }
+            catch {
+                continue;
+            }
+            if (prev.path !== filePath)
+                continue;
+            if (sameErrors(prev.errors, errors))
+                return true;
+            return false;
+        }
+    }
+    catch { /* ignore */ }
+    return false;
+}
+function sameErrors(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const sa = [...a].sort();
+    const sb = [...b].sort();
+    for (let i = 0; i < sa.length; i++)
+        if (sa[i] !== sb[i])
+            return false;
+    return true;
+}
+/**
+ * Read the latest quarantine state: one entry per path, keyed to the most
+ * recent append. Entries whose file no longer exists are dropped.
+ */
+export function listQuarantined() {
+    if (!fs.existsSync(SOLUTION_QUARANTINE_PATH))
+        return [];
+    let text;
+    try {
+        text = fs.readFileSync(SOLUTION_QUARANTINE_PATH, 'utf-8');
+    }
+    catch {
+        return [];
+    }
+    const byPath = new Map();
+    for (const line of text.split('\n')) {
+        if (!line)
+            continue;
+        try {
+            const entry = JSON.parse(line);
+            byPath.set(entry.path, entry);
+        }
+        catch { /* skip bad line */ }
+    }
+    const result = [];
+    for (const entry of byPath.values()) {
+        try {
+            if (fs.existsSync(entry.path))
+                result.push(entry);
+        }
+        catch { /* skip */ }
+    }
+    return result;
+}
+/**
+ * Clear quarantine entries for files that now parse correctly or no longer
+ * exist. Intended to be called after `forgen learn fix-up` or a manual edit.
+ */
+export function pruneQuarantine() {
+    if (!fs.existsSync(SOLUTION_QUARANTINE_PATH))
+        return { removed: 0, kept: 0 };
+    // Read raw entries without listQuarantined's existsSync filter so we can
+    // count deleted files as removed rather than silently dropping them.
+    const byPath = new Map();
+    try {
+        const text = fs.readFileSync(SOLUTION_QUARANTINE_PATH, 'utf-8');
+        for (const line of text.split('\n')) {
+            if (!line)
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                byPath.set(entry.path, entry);
+            }
+            catch { /* skip bad line */ }
+        }
+    }
+    catch { /* empty */ }
+    const stillBad = [];
+    let removed = 0;
+    for (const entry of byPath.values()) {
+        let content;
+        try {
+            content = fs.readFileSync(entry.path, 'utf-8');
+        }
+        catch {
+            removed++;
+            continue;
+        }
+        const errors = diagnoseFromRawContent(content);
+        if (errors.length === 0) {
+            removed++;
+            continue;
+        }
+        stillBad.push({ ...entry, errors });
+    }
+    const dir = path.dirname(SOLUTION_QUARANTINE_PATH);
+    fs.mkdirSync(dir, { recursive: true });
+    const text = stillBad.map((e) => JSON.stringify(e)).join('\n') + (stillBad.length ? '\n' : '');
+    fs.writeFileSync(SOLUTION_QUARANTINE_PATH, text);
+    return { removed, kept: stillBad.length };
+}

package/dist/engine/solution-weakness.d.ts

@@ -0,0 +1,45 @@
+export interface UnderServedTag {
+    tag: string;
+    correction_mentions: number;
+    best_matching_champion: string | null;
+    best_fitness: number;
+}
+export interface ConflictCluster {
+    shared_tags: string[];
+    champion: {
+        name: string;
+        fitness: number;
+    };
+    underperform: {
+        name: string;
+        fitness: number;
+    };
+}
+export interface DeadCorner {
+    solution: string;
+    unique_tags: string[];
+    injected: number;
+}
+export interface VolatileSolution {
+    solution: string;
+    accept_rate_window_a: number;
+    accept_rate_window_b: number;
+    delta: number;
+}
+export interface WeaknessReport {
+    generated_at: string;
+    population: {
+        total: number;
+        champion: number;
+        active: number;
+        underperform: number;
+        draft: number;
+    };
+    under_served_tags: UnderServedTag[];
+    conflict_clusters: ConflictCluster[];
+    dead_corners: DeadCorner[];
+    volatile: VolatileSolution[];
+}
+export declare function buildWeaknessReport(solutionsDir?: string): WeaknessReport;
+export declare function saveWeaknessReport(report: WeaknessReport): string;
+export declare function latestWeaknessReport(): WeaknessReport | null;

package/dist/engine/solution-weakness.js

@@ -0,0 +1,225 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ME_SOLUTIONS, STATE_DIR } from '../core/paths.js';
+import { parseFrontmatterOnly } from './solution-format.js';
+import { computeFitness } from './solution-fitness.js';
+import { readAllOutcomes } from './solution-outcomes.js';
+import { createLogger } from '../core/logger.js';
+const log = createLogger('solution-weakness');
+function loadSolutionRows(solutionsDir) {
+    if (!fs.existsSync(solutionsDir))
+        return [];
+    const rows = [];
+    for (const file of fs.readdirSync(solutionsDir)) {
+        if (!file.endsWith('.md'))
+            continue;
+        try {
+            const content = fs.readFileSync(path.join(solutionsDir, file), 'utf-8');
+            const fm = parseFrontmatterOnly(content);
+            if (!fm)
+                continue;
+            rows.push({ name: fm.name, tags: fm.tags });
+        }
+        catch { /* skip */ }
+    }
+    return rows;
+}
+function findUnderServedTags(rows, fitnessByName) {
+    // Read correction evidence tags from ~/.forgen/me/behavior/*.json — each
+    // entry carries a `raw_payload` with inferred tags or keywords. Be
+    // tolerant: the schema has drifted historically, so we accept any string
+    // array we can find under likely field names.
+    const behaviorDir = path.join(ME_SOLUTIONS, '..', 'behavior');
+    const correctionTags = new Map();
+    if (fs.existsSync(behaviorDir)) {
+        for (const file of fs.readdirSync(behaviorDir)) {
+            if (!file.endsWith('.json'))
+                continue;
+            try {
+                const data = JSON.parse(fs.readFileSync(path.join(behaviorDir, file), 'utf-8'));
+                const payload = data.raw_payload ?? data.payload ?? {};
+                const tags = collectTags(payload).concat(collectTags(data.axis_refs ?? []));
+                const summary = typeof data.summary === 'string' ? data.summary.toLowerCase() : '';
+                for (const tag of new Set(tags)) {
+                    correctionTags.set(tag, (correctionTags.get(tag) ?? 0) + 1);
+                }
+                // Summary keywords fallback — split on whitespace, filter obvious fillers
+                for (const word of summary.split(/\s+/)) {
+                    if (word.length >= 5 && word.length <= 20) {
+                        correctionTags.set(word, (correctionTags.get(word) ?? 0) + 0.3);
+                    }
+                }
+            }
+            catch { /* skip bad json */ }
+        }
+    }
+    const result = [];
+    for (const [tag, count] of correctionTags) {
+        if (count < 2)
+            continue; // noise cutoff
+        let bestName = null;
+        let bestFitness = 0;
+        for (const row of rows) {
+            if (!row.tags.includes(tag))
+                continue;
+            const fit = fitnessByName.get(row.name)?.fitness ?? 0;
+            if (fit > bestFitness || (bestName === null && fit >= 0)) {
+                bestFitness = fit;
+                bestName = row.name;
+            }
+        }
+        // Under-served: no matching solution, or best match is not a champion
+        const bestFit = bestName ? fitnessByName.get(bestName) : null;
+        const isChampion = bestFit?.state === 'champion';
+        if (!bestName || !isChampion) {
+            result.push({
+                tag,
+                correction_mentions: Math.round(count),
+                best_matching_champion: isChampion ? bestName : null,
+                best_fitness: bestFitness,
+            });
+        }
+    }
+    result.sort((a, b) => b.correction_mentions - a.correction_mentions);
+    return result.slice(0, 10);
+}
+function collectTags(v) {
+    if (Array.isArray(v))
+        return v.filter((x) => typeof x === 'string');
+    if (v && typeof v === 'object') {
+        return Object.values(v)
+            .filter((x) => typeof x === 'string');
+    }
+    return [];
+}
+function findConflictClusters(rows, fitnessByName) {
+    const champions = rows.filter((r) => fitnessByName.get(r.name)?.state === 'champion');
+    const underperformers = rows.filter((r) => fitnessByName.get(r.name)?.state === 'underperform');
+    const clusters = [];
+    for (const ch of champions) {
+        for (const up of underperformers) {
+            const shared = ch.tags.filter((t) => up.tags.includes(t));
+            if (shared.length < 2)
+                continue;
+            clusters.push({
+                shared_tags: shared,
+                champion: { name: ch.name, fitness: fitnessByName.get(ch.name).fitness },
+                underperform: { name: up.name, fitness: fitnessByName.get(up.name).fitness },
+            });
+        }
+    }
+    clusters.sort((a, b) => b.shared_tags.length - a.shared_tags.length);
+    return clusters.slice(0, 5);
+}
+function findDeadCorners(rows, fitnessByName) {
+    // Dead = injected=0. Unique tags = tags present only in this solution.
+    const injectedRows = rows.filter((r) => (fitnessByName.get(r.name)?.injected ?? 0) > 0);
+    const injectedTags = new Set();
+    for (const r of injectedRows)
+        for (const t of r.tags)
+            injectedTags.add(t);
+    const dead = [];
+    for (const r of rows) {
+        const injected = fitnessByName.get(r.name)?.injected ?? 0;
+        if (injected > 0)
+            continue;
+        const unique = r.tags.filter((t) => !injectedTags.has(t));
+        if (unique.length === 0)
+            continue;
+        dead.push({ solution: r.name, unique_tags: unique, injected });
+    }
+    dead.sort((a, b) => b.unique_tags.length - a.unique_tags.length);
+    return dead.slice(0, 10);
+}
+function findVolatile(_fitnessByName) {
+    const events = readAllOutcomes();
+    if (events.length === 0)
+        return [];
+    // Split events into two halves by timestamp; compute per-solution accept
+    // rate delta between halves. Volatile = |delta| > 0.3 and enough data.
+    const mid = events[Math.floor(events.length / 2)].ts;
+    const by = new Map();
+    for (const ev of events) {
+        const c = by.get(ev.solution) ?? { a_accept: 0, a_total: 0, b_accept: 0, b_total: 0 };
+        if (ev.outcome === 'accept' || ev.outcome === 'correct' || ev.outcome === 'error') {
+            const isA = ev.ts < mid;
+            if (isA) {
+                c.a_total++;
+                if (ev.outcome === 'accept')
+                    c.a_accept++;
+            }
+            else {
+                c.b_total++;
+                if (ev.outcome === 'accept')
+                    c.b_accept++;
+            }
+        }
+        by.set(ev.solution, c);
+    }
+    const result = [];
+    for (const [name, c] of by) {
+        if (c.a_total < 3 || c.b_total < 3)
+            continue;
+        const rateA = c.a_accept / c.a_total;
+        const rateB = c.b_accept / c.b_total;
+        const delta = rateB - rateA;
+        if (Math.abs(delta) < 0.3)
+            continue;
+        result.push({
+            solution: name,
+            accept_rate_window_a: Number(rateA.toFixed(3)),
+            accept_rate_window_b: Number(rateB.toFixed(3)),
+            delta: Number(delta.toFixed(3)),
+        });
+    }
+    result.sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta));
+    return result.slice(0, 5);
+}
+export function buildWeaknessReport(solutionsDir = ME_SOLUTIONS) {
+    const rows = loadSolutionRows(solutionsDir);
+    const fitnessList = computeFitness();
+    const fitnessByName = new Map(fitnessList.map((f) => [f.solution, f]));
+    const population = {
+        total: fitnessList.length,
+        champion: fitnessList.filter((f) => f.state === 'champion').length,
+        active: fitnessList.filter((f) => f.state === 'active').length,
+        underperform: fitnessList.filter((f) => f.state === 'underperform').length,
+        draft: fitnessList.filter((f) => f.state === 'draft').length,
+    };
+    return {
+        generated_at: new Date().toISOString(),
+        population,
+        under_served_tags: findUnderServedTags(rows, fitnessByName),
+        conflict_clusters: findConflictClusters(rows, fitnessByName),
+        dead_corners: findDeadCorners(rows, fitnessByName),
+        volatile: findVolatile(fitnessByName),
+    };
+}
+export function saveWeaknessReport(report) {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+    const ts = Date.now();
+    const p = path.join(STATE_DIR, `weakness-report-${ts}.json`);
+    try {
+        fs.writeFileSync(p, JSON.stringify(report, null, 2));
+    }
+    catch (e) {
+        log.debug(`save failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    return p;
+}
+export function latestWeaknessReport() {
+    if (!fs.existsSync(STATE_DIR))
+        return null;
+    const candidates = fs.readdirSync(STATE_DIR)
+        .filter((f) => f.startsWith('weakness-report-') && f.endsWith('.json'))
+        .sort()
+        .reverse();
+    if (candidates.length === 0)
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(path.join(STATE_DIR, candidates[0]), 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/engine/solution-writer.d.ts

@@ -72,5 +72,10 @@ export declare function mutateSolutionByName(name: string, mutator: SolutionMuta
 /**
  * Evidence 카운터 단일 증가 helper.
  * mutateSolutionByName + 카운터 증가 패턴을 한 줄로.
+ *
+ * Also graduates Phase 4 candidates: when a `status: candidate` solution's
+ * injected count reaches `CANDIDATE_PROMOTION_INJECTIONS`, its status flips
+ * to `verified` in the same write. This keeps the exploration bonus from
+ * clinging to a solution that has had enough trials.
  */
 export declare function incrementEvidence(solutionName: string, field: 'reflected' | 'negative' | 'injected' | 'sessions' | 'reExtracted'): boolean;

package/dist/engine/solution-writer.js

@@ -142,9 +142,22 @@ export function mutateSolutionByName(name, mutator, options) {
     }
     return false;
 }
+/**
+ * Phase 4 candidate promotion threshold: a `status: candidate` solution
+ * automatically graduates to `status: verified` once its injected count
+ * crosses this cutoff. At that point the cold-start exploration bonus
+ * (solution-matcher.ts) disappears naturally, since the bonus keys off
+ * `candidate` status.
+ */
+const CANDIDATE_PROMOTION_INJECTIONS = 5;
 /**
  * Evidence 카운터 단일 증가 helper.
  * mutateSolutionByName + 카운터 증가 패턴을 한 줄로.
+ *
+ * Also graduates Phase 4 candidates: when a `status: candidate` solution's
+ * injected count reaches `CANDIDATE_PROMOTION_INJECTIONS`, its status flips
+ * to `verified` in the same write. This keeps the exploration bonus from
+ * clinging to a solution that has had enough trials.
  */
 export function incrementEvidence(solutionName, field) {
     return mutateSolutionByName(solutionName, sol => {
@@ -152,6 +165,11 @@ export function incrementEvidence(solutionName, field) {
         if (!(field in ev))
             return false;
         ev[field] = (ev[field] ?? 0) + 1;
+        if (field === 'injected' &&
+            sol.frontmatter.status === 'candidate' &&
+            ev.injected >= CANDIDATE_PROMOTION_INJECTIONS) {
+            sol.frontmatter.status = 'verified';
+        }
         return true;
     });
 }

package/dist/fgx.js

@@ -3,14 +3,17 @@
  * fgx — forgen --dangerously-skip-permissions 의 단축 명령
  * 모든 인자를 그대로 전달하되, --dangerously-skip-permissions 를 자동 주입
  */
+import { resolveLaunchContext } from './services/session.js';
+import { prepareHarness, isFirstRun } from './core/harness.js';
+import { spawnClaude } from './core/spawn.js';
 const args = process.argv.slice(2);
 // 이미 포함되어 있으면 중복 추가하지 않음
-if (!args.includes('--dangerously-skip-permissions')) {
-    args.unshift('--dangerously-skip-permissions');
+const launchContext = resolveLaunchContext(args);
+const runtime = launchContext.runtime;
+const launchArgs = [...launchContext.args];
+if (!launchArgs.includes('--dangerously-skip-permissions')) {
+    launchArgs.unshift('--dangerously-skip-permissions');
 }
-// cli.ts 의 main 로직을 재사용
-import { prepareHarness, isFirstRun } from './core/harness.js';
-import { spawnClaude } from './core/spawn.js';
 async function main() {
     // Security warning — fgx bypasses all Claude Code permission checks
     console.warn('\n  ⚠  fgx: ALL permission checks are disabled (--dangerously-skip-permissions)');
@@ -23,7 +26,7 @@ async function main() {
         console.log('  Creating ~/.forgen/ directory and default philosophy.');
         console.log('  Run `forgen onboarding` afterwards to complete personalization.\n');
     }
-    const context = await prepareHarness(process.cwd());
+    const context = await prepareHarness(process.cwd(), { runtime });
     if (firstRun) {
         console.log('  [Done] Initial setup complete.\n');
     }
@@ -33,8 +36,9 @@ async function main() {
         console.log(`[forgen] Trust: ${v1.session.effective_trust_policy}`);
     }
     console.log('[forgen] Mode: dangerously-skip-permissions');
-    console.log('[forgen] Starting Claude Code...\n');
-    await spawnClaude(args, context);
+    const runtimeLabel = runtime === 'codex' ? 'Codex' : 'Claude';
+    console.log(`[forgen] Starting ${runtimeLabel}...\n`);
+    await spawnClaude(launchArgs, context, runtime);
 }
 main().catch((err) => {
     console.error('[forgen] Error:', err instanceof Error ? err.message : err);

package/dist/hooks/context-guard.d.ts

@@ -32,3 +32,8 @@ export declare function buildAutoCompactMessage(totalChars: number): string;
 /** 경고 메시지 생성 (순수 함수) */
 export declare function buildContextWarningMessage(promptCount: number, totalChars: number): string;
 export declare function main(): Promise<void>;
+/**
+ * forge-loop 활성 시 미완료 스토리가 있으면 Stop을 차단하고 지속 메시지 주입.
+ * OMC의 persistent-mode.cjs 패턴 참고.
+ */
+export declare function checkForgeLoopActive(): string | null;

package/dist/hooks/context-guard.js

@@ -89,6 +89,12 @@ export async function main() {
         // Stop 훅: stop_hook_type이 있으면 처리
         if (input.stop_hook_type) {
             _hookEvent = 'Stop';
+            // forge-loop 활성 시 미완료 스토리 감지 → 지속 메시지 주입 (polite-stop 방지)
+            const forgeLoopBlock = checkForgeLoopActive();
+            if (forgeLoopBlock) {
+                console.log(forgeLoopBlock);
+                return;
+            }
             // 에러가 포함된 경우: context limit 감지
             if (input.error) {
                 const errorMsg = input.error;
@@ -119,12 +125,14 @@ export async function main() {
                         fs.writeFileSync(path.join(STATE_DIR, 'pending-compound.json'), JSON.stringify(marker));
                     }
                     catch { /* fail-open: marker write failure is non-critical */ }
-                    console.log(approveWithWarning(`[Forgen] Session with ${state.promptCount} prompts ended. Compound loop will auto-trigger on next session start.`));
+                    const summary = buildSessionSummary(sessionId, state.promptCount);
+                    console.log(approveWithWarning(`[Forgen] Session with ${state.promptCount} prompts ended.\n${summary}\nCompound loop will auto-trigger on next session start.`));
                     return;
                 }
                 if (state.promptCount >= 10) {
                     // 10-19 prompts: suggest /compound manually
-                    console.log(approveWithWarning(`[Forgen] 이 세션에서 ${state.promptCount}개의 프롬프트를 처리했습니다. /compound 를 실행하면 이 세션의 학습 내용을 축적할 수 있습니다.`));
+                    const summary = buildSessionSummary(sessionId, state.promptCount);
+                    console.log(approveWithWarning(`[Forgen] 이 세션에서 ${state.promptCount}개의 프롬프트를 처리했습니다.\n${summary}/compound 를 실행하면 이 세션의 학습 내용을 축적할 수 있습니다.`));
                     return;
                 }
             }
@@ -166,6 +174,114 @@ export async function main() {
         recordHookTiming('context-guard', Date.now() - _hookStart, _hookEvent);
     }
 }
+/**
+ * 세션 종료 시 "forgen이 도움이 된 정도"를 요약.
+ * solution-cache에서 이번 세션에 주입된 compound 솔루션 수를 집계하여
+ * 카운터팩추얼 "forgen 없었으면 ~N분 더 걸렸을 것" 메시지 생성.
+ */
+function buildSessionSummary(sessionId, promptCount) {
+    try {
+        const cachePath = path.join(STATE_DIR, `solution-cache-${sessionId}.json`);
+        if (!fs.existsSync(cachePath))
+            return '';
+        const cache = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+        const injected = Array.isArray(cache.injected) ? cache.injected : [];
+        if (injected.length === 0)
+            return '';
+        // 카운터팩추얼: 주입된 compound 1건당 평균 8분 절약 가정 (하한 추정)
+        const savedMins = injected.length * 8;
+        const savedStr = savedMins >= 60
+            ? `${Math.floor(savedMins / 60)}시간 ${savedMins % 60}분`
+            : `${savedMins}분`;
+        // 상위 3개 솔루션
+        const topNames = injected.slice(0, 3).map(i => `"${i.name}"`).join(', ');
+        const moreCount = injected.length - 3;
+        const topStr = moreCount > 0 ? `${topNames} 외 ${moreCount}개` : topNames;
+        return [
+            `\n📊 이번 세션 forgen 효과:`,
+            `  주입된 compound: ${injected.length}건 (${topStr})`,
+            `  추정 절약 시간: ${savedStr} (forgen 없었으면 시행착오 필요)`,
+            `  프롬프트 대비 효율: ${(injected.length / promptCount * 100).toFixed(0)}% 의 대화가 축적된 지식의 도움을 받음\n`,
+        ].join('\n');
+    }
+    catch {
+        return '';
+    }
+}
+// forge-loop 상태 파일 경로
+const FORGE_LOOP_STATE_PATH = path.join(STATE_DIR, 'forge-loop.json');
+// forge-loop 차단 안전 상한 (무한 루프 방지)
+const FORGE_LOOP_MAX_BLOCKS = 30;
+const FORGE_LOOP_STALE_MS = 2 * 60 * 60 * 1000; // 2시간
+/**
+ * forge-loop 활성 시 미완료 스토리가 있으면 Stop을 차단하고 지속 메시지 주입.
+ * OMC의 persistent-mode.cjs 패턴 참고.
+ */
+export function checkForgeLoopActive() {
+    try {
+        if (!fs.existsSync(FORGE_LOOP_STATE_PATH))
+            return null;
+        const state = JSON.parse(fs.readFileSync(FORGE_LOOP_STATE_PATH, 'utf-8'));
+        if (!state.active)
+            return null;
+        // Stale 감지: 2시간+ 미활동 → 자동 비활성화
+        const startedAt = new Date(state.startedAt).getTime();
+        if (Number.isFinite(startedAt) && Date.now() - startedAt > FORGE_LOOP_STALE_MS) {
+            state.active = false;
+            atomicWriteJSON(FORGE_LOOP_STATE_PATH, state);
+            return null;
+        }
+        // 확인 대기 중이면 차단하지 않음 (사용자 개입 허용)
+        if (state.awaitingConfirmation)
+            return null;
+        // 안전 상한: 30회 이상 차단 시 무한 루프로 간주하여 해제
+        const blockCount = state.blockCount ?? 0;
+        if (blockCount >= FORGE_LOOP_MAX_BLOCKS) {
+            state.active = false;
+            atomicWriteJSON(FORGE_LOOP_STATE_PATH, state);
+            return null;
+        }
+        // 미완료 스토리 확인
+        const stories = Array.isArray(state.stories) ? state.stories : [];
+        const pending = stories.filter((s) => !s.passes);
+        if (pending.length === 0) {
+            // 모든 스토리 완료 → forge-loop 종료
+            state.active = false;
+            atomicWriteJSON(FORGE_LOOP_STATE_PATH, state);
+            return null;
+        }
+        // 차단 카운트 증가 + 지속 메시지 주입
+        state.blockCount = blockCount + 1;
+        state.lastBlockAt = new Date().toISOString();
+        atomicWriteJSON(FORGE_LOOP_STATE_PATH, state);
+        const nextStory = pending[0];
+        const message = [
+            `<forgen-forge-loop iteration="${state.blockCount}/${FORGE_LOOP_MAX_BLOCKS}">`,
+            `[FORGE-LOOP] ${pending.length}개 스토리가 미완료입니다.`,
+            `현재 스토리: ${nextStory.id} — ${nextStory.title}`,
+            ``,
+            `계속 진행하세요. 보고는 다음 시점에만 합니다:`,
+            `  1. 모든 스토리 완료 (최종 리포트)`,
+            `  2. 3회 실패 (에스컬레이션)`,
+            `  3. Context limit 접근 (handoff)`,
+            ``,
+            `중간 "완료했습니다" 보고는 polite-stop anti-pattern입니다.`,
+            `취소하려면: "/forge-loop cancel" 또는 "cancelforgen" 입력`,
+            `</forgen-forge-loop>`,
+        ].join('\n');
+        // block 결정으로 Claude가 계속 작업하도록 강제
+        return JSON.stringify({
+            continue: true,
+            decision: 'block',
+            reason: message,
+        });
+    }
+    catch (e) {
+        // fail-open: forge-loop 상태 읽기 실패는 차단하지 않음
+        log.debug('forge-loop 상태 확인 실패', e);
+        return null;
+    }
+}
 function saveHandoff(sessionId, reason, detail) {
     fs.mkdirSync(HANDOFFS_DIR, { recursive: true });
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-');