@wooojin/forgen 0.3.0 → 0.3.1

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/hooks/post-tool-failure.js

@@ -105,6 +105,13 @@ async function main() {
     saveFailureState(state);
     // 컨텍스트 신호 업데이트
     incrementFailureSignal(sessionId);
+    // Outcome tracking (Phase 1): attribute this tool failure to pending
+    // solution injections in the same session. Fail-open.
+    try {
+        const { attributeError } = await import('../engine/solution-outcomes.js');
+        attributeError(sessionId);
+    }
+    catch { /* ignore */ }
     const failCount = state.failures[toolName].count;
     const suggestion = getRecoverySuggestion(error, toolName);
     // 3회 이상 반복 실패 시 강화된 경고

package/dist/hooks/solution-injector.js

@@ -28,6 +28,7 @@ import { writeSignal } from './shared/plugin-signal.js';
 import { approve, approveWithContext, failOpenWithTracking } from './shared/hook-response.js';
 import { STATE_DIR } from '../core/paths.js';
 import { recordHookTiming } from './shared/hook-timing.js';
+import { appendPending, flushAccept } from '../engine/solution-outcomes.js';
 const MAX_SOLUTIONS_PER_SESSION = 10;
 /** 세션별 이미 주입된 솔루션 추적 (중복 방지) */
 function getSessionCachePath(sessionId) {
@@ -451,6 +452,25 @@ async function main() {
         catch (e) {
             log.debug('plugin signal 기록 실패', e);
         }
+        // Outcome tracking (Phase 1): flush previous pending as `accept` (silence
+        // = consent), then record this round's injections as new pending. Both
+        // calls are fail-open — a tracking crash must not block injection.
+        try {
+            flushAccept(sessionId);
+        }
+        catch (e) {
+            log.debug('outcome flushAccept 실패', e);
+        }
+        try {
+            appendPending(sessionId, effectiveToInject.map((sol) => ({
+                solution: sol.name,
+                match_score: sol.relevance,
+                injected_chars: (summaries.get(sol.name) ?? sol.name).length,
+            })));
+        }
+        catch (e) {
+            log.debug('outcome appendPending 실패', e);
+        }
         console.log(approveWithContext(fullInjection, 'UserPromptSubmit'));
     }
     finally {

package/dist/mcp/tools.js

@@ -273,6 +273,14 @@ export function registerTools(server) {
                 target,
                 axis_hint: axis_hint,
             });
+            // Outcome tracking (Phase 1): attribute this correction to any
+            // pending injections in the session. Fail-open — attribution is a
+            // best-effort signal, never block the correction record itself.
+            try {
+                const { attributeCorrection } = await import('../engine/solution-outcomes.js');
+                attributeCorrection(effectiveSessionId);
+            }
+            catch { /* ignore */ }
             const lines = [
                 `Evidence recorded: ${result.evidence_event_id}`,
             ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wooojin/forgen",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "preferGlobal": true,
   "main": "dist/lib.js",
   "types": "./dist/lib.d.ts",