@wooojin/forgen 0.3.1 → 0.3.2

package/dist/core/state-gc.js

@@ -0,0 +1,119 @@
+/**
+ * State directory garbage collector.
+ *
+ * `~/.forgen/state/` accumulates per-session files that are never cleaned
+ * up (injection-cache, active-agents, checkpoint, modified-files,
+ * outcome-pending, permissions, skill-trigger, tool-state, etc.). A field
+ * audit on 2026-04-21 found one installation with 10,802 files in a single
+ * flat directory — SessionStart hook scans linearly on each session, and
+ * `ls` / `rsync` / backup tools all pay the cost.
+ *
+ * This module scans session-scoped files by filename prefix and prunes
+ * those older than a configurable retention window (default 7 days). The
+ * jsonl aggregate logs (hook-errors.jsonl, hook-timing.jsonl,
+ * implicit-feedback.jsonl, match-eval-log.jsonl, solution-quarantine.jsonl)
+ * are left alone — they are tracked append-only and handled by #5
+ * (log rotation).
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { STATE_DIR, OUTCOMES_DIR } from './paths.js';
+/** Filename prefixes that identify session-scoped ephemeral files. */
+const SESSION_SCOPED_PREFIXES = [
+    'active-agents-',
+    'checkpoint-',
+    'injection-cache-',
+    'modified-files-',
+    'outcome-pending-',
+    'permissions-',
+    'skill-trigger-',
+    'tool-state-',
+    'reminder-',
+    'context-',
+    'last-',
+];
+const DEFAULT_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+function hasSessionPrefix(name) {
+    return SESSION_SCOPED_PREFIXES.some((pfx) => name.startsWith(pfx));
+}
+function pruneDir(dir, cutoff, dryRun, filter) {
+    const out = { scanned: 0, pruned: 0, bytes: 0, sample: [] };
+    if (!fs.existsSync(dir))
+        return out;
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return out;
+    }
+    for (const name of entries) {
+        if (!filter(name))
+            continue;
+        const full = path.join(dir, name);
+        let stat;
+        try {
+            stat = fs.statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (!stat.isFile())
+            continue;
+        out.scanned++;
+        if (stat.mtimeMs >= cutoff)
+            continue;
+        if (!dryRun) {
+            try {
+                fs.unlinkSync(full);
+            }
+            catch {
+                continue;
+            }
+        }
+        out.pruned++;
+        out.bytes += stat.size;
+        if (out.sample.length < 20)
+            out.sample.push(name);
+    }
+    return out;
+}
+/**
+ * Prune session-scoped files older than `retentionMs` from the state and
+ * outcomes directories. Defaults to a dry-run so callers must opt-in to
+ * deletion via `dryRun: false`.
+ */
+export function pruneState(opts = {}) {
+    const retentionMs = opts.retentionMs ?? DEFAULT_RETENTION_MS;
+    const dryRun = opts.dryRun ?? true;
+    const stateDir = opts.stateDir ?? STATE_DIR;
+    const outcomesDir = opts.outcomesDir ?? OUTCOMES_DIR;
+    const now = opts.now ?? Date.now();
+    const cutoff = now - retentionMs;
+    const state = pruneDir(stateDir, cutoff, dryRun, hasSessionPrefix);
+    // outcomes/*.jsonl: one file per session, session-scoped by design.
+    // These compound over time exactly like state session files.
+    const outcomes = pruneDir(outcomesDir, cutoff, dryRun, (n) => n.endsWith('.jsonl'));
+    return {
+        scanned: state.scanned + outcomes.scanned,
+        pruned: state.pruned + outcomes.pruned,
+        bytesFreed: state.bytes + outcomes.bytes,
+        retentionDays: Math.round(retentionMs / (24 * 60 * 60 * 1000)),
+        dryRun,
+        sample: [...state.sample, ...outcomes.sample].slice(0, 20),
+    };
+}
+/**
+ * Count session-scoped files in STATE_DIR without deleting. Used by doctor
+ * to surface a warning when the directory is bloated.
+ */
+export function countSessionScopedFiles(stateDir = STATE_DIR) {
+    if (!fs.existsSync(stateDir))
+        return 0;
+    try {
+        return fs.readdirSync(stateDir).filter(hasSessionPrefix).length;
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/core/uninstall.js

@@ -118,11 +118,13 @@ function cleanSettings() {
         console.error('[forgen] Failed to parse settings.json — skipping.');
         return;
     }
-    // env에서 COMPOUND_ 접두어 키 제거
+    // Audit fix #7 (2026-04-21): env 정리가 `COMPOUND_` 접두어만 검사해서
+    // install이 주입한 `FORGEN_*` 키(예: FORGEN_HARNESS, FORGEN_CWD)가
+    // uninstall 후에도 settings.json에 영구 잔존했다. 이제 둘 다 정리.
     const env = settings.env;
     if (env) {
         for (const key of Object.keys(env)) {
-            if (key.startsWith('COMPOUND_'))
+            if (key.startsWith('COMPOUND_') || key.startsWith('FORGEN_'))
                 delete env[key];
         }
         if (Object.keys(env).length === 0) {
@@ -162,9 +164,15 @@ function cleanSettings() {
             delete settings.hooks;
         }
     }
-    // statusLine이 forgen status면 제거
+    // statusLine이 forgen이 설치한 command 중 하나면 제거.
+    //
+    // Audit fix #7 (2026-04-21): 이전 체크는 `'forgen status'`만 인식했지만
+    // 실제 install은 `settings-injector.ts:59`에서 `'forgen me'`를 주입한다.
+    // command 문자열이 `forgen`으로 시작하는 경우를 모두 forgen 소유로 보고
+    // 제거 — 사용자 커스텀 statusLine(예: `custom-cli ...`)은 건드리지 않음.
     const statusLine = settings.statusLine;
-    if (statusLine?.command === 'forgen status') {
+    if (typeof statusLine?.command === 'string' &&
+        /^forgen(\s|$)/.test(statusLine.command.trim())) {
         delete settings.statusLine;
     }
     // enabledPlugins에서 forgen@forgen-local 제거

package/dist/core/v1-bootstrap.js

@@ -15,7 +15,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as crypto from 'node:crypto';
-import { FORGEN_HOME, V1_ME_DIR, V1_RULES_DIR, V1_EVIDENCE_DIR, V1_RECOMMENDATIONS_DIR, V1_SESSIONS_DIR, V1_STATE_DIR, V1_RAW_LOGS_DIR, V1_SOLUTIONS_DIR } from './paths.js';
+import { FORGEN_HOME, ME_DIR, ME_RULES, ME_BEHAVIOR, V1_RECOMMENDATIONS_DIR, V1_SESSIONS_DIR, STATE_DIR, V1_RAW_LOGS_DIR, ME_SOLUTIONS } from './paths.js';
 import { checkLegacyProfile, runLegacyCutover } from './legacy-detector.js';
 import { detectRuntimeCapability } from './runtime-detector.js';
 import { loadProfile, profileExists } from '../store/profile-store.js';
@@ -27,7 +27,7 @@ import { loadEvidenceBySession } from '../store/evidence-store.js';
 import { computeSessionSignals, detectMismatch } from '../forge/mismatch-detector.js';
 import { createRecommendation, saveRecommendation } from '../store/recommendation-store.js';
 // ── Directory Initialization ──
-const V1_DIRS = [FORGEN_HOME, V1_ME_DIR, V1_RULES_DIR, V1_EVIDENCE_DIR, V1_RECOMMENDATIONS_DIR, V1_STATE_DIR, V1_SESSIONS_DIR, V1_RAW_LOGS_DIR, V1_SOLUTIONS_DIR];
+const V1_DIRS = [FORGEN_HOME, ME_DIR, ME_RULES, ME_BEHAVIOR, V1_RECOMMENDATIONS_DIR, STATE_DIR, V1_SESSIONS_DIR, V1_RAW_LOGS_DIR, ME_SOLUTIONS];
 export function ensureV1Directories() {
     for (const dir of V1_DIRS) {
         fs.mkdirSync(dir, { recursive: true });

package/dist/engine/compound-cli.d.ts

@@ -20,5 +20,30 @@ export declare function removeSolution(name: string): void;
 export declare function cleanStaleSolutions(): void;
 /** Retag all solutions using improved extractTags */
 export declare function retagSolutions(): void;
-/** Rollback auto-extracted solutions since a given date */
-export declare function rollbackSolutions(sinceDate: string): void;
+/** Result of a rollback operation — used by tests and callers that need counts. */
+export interface RollbackCliResult {
+    archived: string[];
+    archiveDir: string | null;
+    skipped: string[];
+    errors: string[];
+    dryRun: boolean;
+}
+/**
+ * Rollback auto-extracted solutions created since a given date.
+ *
+ * Invariant (2026-04-20, feedback_core_loop_invariant):
+ *   rollback은 **archive 이동**만 수행한다. `fs.unlinkSync`로 솔루션 파일을
+ *   영구 삭제하지 않는다. 실수로 rollback을 실행해도 `~/.forgen/lab/archived/
+ *   rollback-{ts}/`에서 복구할 수 있어야 한다. (과거 `unlinkSync` 경로는
+ *   time-bounded rollback이 "되돌리기 불가 영구 삭제"로 동작하던 버그였다.)
+ *
+ * 필터 기준:
+ *   - category === 'solution'만 대상 (rule은 제외)
+ *   - reflected > 0 OR sessions > 0인 것은 유지 (사용된 솔루션 보호)
+ *   - created >= since 인 것만 대상
+ *
+ * dryRun=true면 아무 파일도 건드리지 않고 대상 목록만 반환.
+ */
+export declare function rollbackSolutions(sinceDate: string, opts?: {
+    dryRun?: boolean;
+}): RollbackCliResult;

package/dist/engine/compound-cli.js

@@ -2,7 +2,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { extractTags, parseFrontmatterOnly, parseSolutionV3 } from './solution-format.js';
 import { mutateSolutionFile } from './solution-writer.js';
-import { ME_SOLUTIONS, ME_RULES } from '../core/paths.js';
+import { ARCHIVED_DIR, ME_SOLUTIONS, ME_RULES } from '../core/paths.js';
 /** Scan saved compound entries and return summaries */
 function scanEntries() {
     const summaries = [];
@@ -78,7 +78,17 @@ export function listSolutions() {
             console.log(`      ${entry.name} [${entry.category}]  (${entry.confidence.toFixed(2)})  ${evStr}  [${entry.tags.slice(0, 3).join(', ')}]`);
         }
     }
-    console.log(`\n  Total: ${total} entries\n`);
+    // retired 카운트: scanEntries는 모든 상태를 포함하므로 직접 계산
+    const retiredCount = entries.filter(e => e.status === 'retired').length;
+    const activeCount = total - retiredCount;
+    const highConfidence = entries.filter(e => e.status === 'verified' || e.status === 'mature').length;
+    const denominator = total;
+    const precision = denominator > 0 ? Math.round((highConfidence / denominator) * 100) : null;
+    console.log(`\n  Total: ${activeCount} active + ${retiredCount} retired`);
+    if (precision !== null) {
+        console.log(`  Extraction precision: ${precision}%`);
+    }
+    console.log();
 }
 /** Inspect a single saved entry in detail */
 export function inspectSolution(name) {
@@ -218,33 +228,76 @@ export function retagSolutions() {
     }
     console.log(`\n  Retagged ${retagged}/${entries.length} solutions.\n`);
 }
-/** Rollback auto-extracted solutions since a given date */
-export function rollbackSolutions(sinceDate) {
+/**
+ * Rollback auto-extracted solutions created since a given date.
+ *
+ * Invariant (2026-04-20, feedback_core_loop_invariant):
+ *   rollback은 **archive 이동**만 수행한다. `fs.unlinkSync`로 솔루션 파일을
+ *   영구 삭제하지 않는다. 실수로 rollback을 실행해도 `~/.forgen/lab/archived/
+ *   rollback-{ts}/`에서 복구할 수 있어야 한다. (과거 `unlinkSync` 경로는
+ *   time-bounded rollback이 "되돌리기 불가 영구 삭제"로 동작하던 버그였다.)
+ *
+ * 필터 기준:
+ *   - category === 'solution'만 대상 (rule은 제외)
+ *   - reflected > 0 OR sessions > 0인 것은 유지 (사용된 솔루션 보호)
+ *   - created >= since 인 것만 대상
+ *
+ * dryRun=true면 아무 파일도 건드리지 않고 대상 목록만 반환.
+ */
+export function rollbackSolutions(sinceDate, opts = {}) {
+    const result = {
+        archived: [],
+        archiveDir: null,
+        skipped: [],
+        errors: [],
+        dryRun: !!opts.dryRun,
+    };
     const since = new Date(sinceDate);
     if (Number.isNaN(since.getTime())) {
         console.log(`\n  Invalid date: ${sinceDate}\n`);
-        return;
+        result.errors.push(`invalid-date:${sinceDate}`);
+        return result;
     }
     const solutions = scanEntries().filter((entry) => entry.category === 'solution');
-    const toRemove = solutions.filter((solution) => {
+    const toRollback = solutions.filter((solution) => {
         if (solution.evidence.reflected > 0 || solution.evidence.sessions > 0)
-            return false; // keep used ones
+            return false;
         const created = new Date(solution.created);
         return created >= since;
     });
-    if (toRemove.length === 0) {
+    if (toRollback.length === 0) {
         console.log(`\n  No solutions to rollback since ${sinceDate}.\n`);
-        return;
+        return result;
     }
-    console.log(`\n  Rolling back ${toRemove.length} solutions since ${sinceDate}:\n`);
-    for (const sol of toRemove) {
+    if (opts.dryRun) {
+        console.log(`\n  [dry-run] ${toRollback.length} solutions would be archived since ${sinceDate}:\n`);
+        for (const sol of toRollback) {
+            console.log(`    Would archive: ${sol.name}`);
+            result.skipped.push(sol.filePath);
+        }
+        console.log(`\n  Re-run without --dry-run to archive them.\n`);
+        return result;
+    }
+    const archiveDir = path.join(ARCHIVED_DIR, `rollback-${Date.now()}`);
+    result.archiveDir = archiveDir;
+    console.log(`\n  Rolling back ${toRollback.length} solutions since ${sinceDate} → ${archiveDir}:\n`);
+    for (const sol of toRollback) {
         try {
-            fs.unlinkSync(sol.filePath);
-            console.log(`    Removed: ${sol.name}`);
+            fs.mkdirSync(archiveDir, { recursive: true });
+            // 원본 경로 정보를 destName에 보존 — 복원 시 원위치 판별용.
+            // 예: "solutions__my-pattern.md"
+            const originDir = path.basename(path.dirname(sol.filePath));
+            const destName = `${originDir}__${path.basename(sol.filePath)}`;
+            fs.renameSync(sol.filePath, path.join(archiveDir, destName));
+            console.log(`    Archived: ${sol.name}`);
+            result.archived.push(sol.filePath);
         }
-        catch {
-            console.log(`    Failed: ${sol.name}`);
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.log(`    Failed: ${sol.name} — ${msg}`);
+            result.errors.push(`${sol.filePath}: ${msg}`);
         }
     }
-    console.log();
+    console.log(`\n  ${result.archived.length}/${toRollback.length} archived. Restore from ${archiveDir} if needed.\n`);
+    return result;
 }

package/dist/engine/compound-export.d.ts

@@ -7,6 +7,21 @@
  * Export creates a tar.gz archive; Import extracts it while skipping existing
  * files to prevent accidental overwrites.
  */
+/**
+ * Test-friendly containment check (exported for unit tests).
+ *
+ * Audit fix (2026-04-21, follow-up #A): prior guard
+ * `realDest.startsWith(ME_DIR)` was a naive prefix match. A path like
+ * `/home/u/.forgen/me-evil/x.md` starts with `/home/u/.forgen/me` and
+ * bypassed the check — even though it's a sibling, not a child, of
+ * ME_DIR. Fix: compare with `parent + path.sep` so `/home/u/.forgen/me/`
+ * cannot prefix-match `/home/u/.forgen/me-evil/...`.
+ *
+ * @param parentWithSep absolute canonical parent path that INCLUDES a
+ *   trailing `path.sep` (precomputed by caller once per archive).
+ * @param candidate any path string (will be resolved lexically).
+ */
+export declare function isPathInside(parentWithSep: string, candidate: string): boolean;
 export interface ExportResult {
     outputPath: string;
     counts: Record<string, number>;

package/dist/engine/compound-export.js

@@ -14,6 +14,24 @@ import { execFileSync } from 'node:child_process';
 import { ME_DIR } from '../core/paths.js';
 /** Directories within ME_DIR to include in the archive. */
 const KNOWLEDGE_DIRS = ['solutions', 'rules', 'behavior'];
+/**
+ * Test-friendly containment check (exported for unit tests).
+ *
+ * Audit fix (2026-04-21, follow-up #A): prior guard
+ * `realDest.startsWith(ME_DIR)` was a naive prefix match. A path like
+ * `/home/u/.forgen/me-evil/x.md` starts with `/home/u/.forgen/me` and
+ * bypassed the check — even though it's a sibling, not a child, of
+ * ME_DIR. Fix: compare with `parent + path.sep` so `/home/u/.forgen/me/`
+ * cannot prefix-match `/home/u/.forgen/me-evil/...`.
+ *
+ * @param parentWithSep absolute canonical parent path that INCLUDES a
+ *   trailing `path.sep` (precomputed by caller once per archive).
+ * @param candidate any path string (will be resolved lexically).
+ */
+export function isPathInside(parentWithSep, candidate) {
+    const resolved = path.resolve(candidate) + path.sep;
+    return resolved.startsWith(parentWithSep) && resolved !== parentWithSep;
+}
 /**
  * Count .md files in a directory (non-recursive).
  * Returns 0 if the directory does not exist.
@@ -92,12 +110,21 @@ export function importKnowledge(archivePath) {
             stdio: ['pipe', 'pipe', 'pipe'],
         });
         const result = { imported: 0, skipped: 0, details: [] };
+        // Audit fix (2026-04-21, follow-up #A): prior check
+        // `realDest.startsWith(ME_DIR)` was a broken prefix guard. An archive
+        // entry `../me-evil/payload.md` resolves to a sibling directory path
+        // that still startsWith ME_DIR (prefix collision) and bypasses the
+        // check. Fix: compare lexically resolved paths with an explicit
+        // `path.sep` suffix so `.../me-evil` can never masquerade as
+        // `.../me/...`. Both source and destination are validated — a
+        // malformed archive must neither read from outside tmpDir nor write
+        // outside ME_DIR.
+        const meDirCanon = path.resolve(ME_DIR) + path.sep;
+        const tmpDirCanon = path.resolve(tmpDir) + path.sep;
         for (const relFile of archiveFiles) {
-            const srcPath = path.join(tmpDir, relFile);
-            const destPath = path.join(ME_DIR, relFile);
-            // Security: ensure the dest path stays within ME_DIR
-            const realDest = path.resolve(destPath);
-            if (!realDest.startsWith(ME_DIR)) {
+            const srcPath = path.resolve(path.join(tmpDir, relFile));
+            const destPath = path.resolve(path.join(ME_DIR, relFile));
+            if (!isPathInside(meDirCanon, destPath) || !isPathInside(tmpDirCanon, srcPath)) {
                 result.skipped++;
                 result.details.push({ file: relFile, action: 'skipped' });
                 continue;

package/dist/engine/compound-loop.js

@@ -324,11 +324,12 @@ export async function handleCompound(args) {
         const sinceIdx = args.indexOf('--since');
         const since = sinceIdx !== -1 ? args[sinceIdx + 1] : undefined;
         if (!since) {
-            console.log('  Usage: forgen compound rollback --since 2026-03-20\n');
+            console.log('  Usage: forgen compound rollback --since YYYY-MM-DD [--dry-run]\n');
             return;
         }
+        const dryRun = args.includes('--dry-run');
         const { rollbackSolutions } = await import('./compound-cli.js');
-        rollbackSolutions(since);
+        rollbackSolutions(since, { dryRun });
         return;
     }
     // --- explicit interactive command ---

package/dist/engine/learn-cli.js

@@ -1,3 +1,4 @@
+import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
 import { fixupSolutions } from './solution-fixup.js';
@@ -6,6 +7,8 @@ import { computeFitness } from './solution-fitness.js';
 import { buildWeaknessReport, saveWeaknessReport } from './solution-weakness.js';
 import { listCandidates, promoteCandidate, rollbackSince } from './solution-candidate.js';
 const ME_SOLUTIONS = path.join(os.homedir(), '.forgen', 'me', 'solutions');
+const STATE_DIR = path.join(os.homedir(), '.forgen', 'state');
+const OUTCOMES_DIR = path.join(STATE_DIR, 'outcomes');
 export async function handleLearn(args) {
     const sub = args[0];
     if (sub === 'fix-up')
@@ -16,6 +19,8 @@ export async function handleLearn(args) {
         return runFitness(args.slice(1));
     if (sub === 'evolve')
         return runEvolve(args.slice(1));
+    if (sub === 'reset-outcomes')
+        return runResetOutcomes(args.slice(1));
     printUsage();
 }
 function printUsage() {
@@ -28,8 +33,55 @@ function printUsage() {
     forgen learn fitness [--json]         Show per-solution fitness (accept/correct/error ratios)
     forgen learn evolve [--save|--rollback <ts>|--promote <name>]
                                           Phase 4 evolution: weakness report + candidate lifecycle
+    forgen learn reset-outcomes [--apply] Archive pre-audit outcome history (dry-run by default).
+                                          Use after upgrading from <0.3.2 to start fitness fresh
+                                          under the new attribution gates. Old data is preserved
+                                          at ~/.forgen/state/outcomes.archive-<ts>/ (never deleted).
 `);
 }
+/**
+ * Archive the outcomes directory to a timestamped sibling so fitness
+ * computation starts fresh under v0.3.2's corrected attribution gates
+ * (match_score≥0.3, lag≤5min, top-3, single-tag rejection). Pre-0.3.2
+ * outcomes were recorded with blanket error-attribution on every tool
+ * failure in the session window, producing a 91% global error rate even
+ * for solutions that weren't actually causing the failures.
+ *
+ * Archive, never delete — users who want to audit their pre-0.3.2
+ * history can still read `outcomes.archive-<ts>/*.jsonl`.
+ */
+function runResetOutcomes(args) {
+    const apply = args.includes('--apply');
+    if (!fs.existsSync(OUTCOMES_DIR)) {
+        console.log(`\n  No outcomes directory yet — nothing to reset.\n`);
+        return;
+    }
+    const files = fs.readdirSync(OUTCOMES_DIR).filter((f) => f.endsWith('.jsonl'));
+    if (files.length === 0) {
+        console.log(`\n  Outcomes directory is empty — nothing to reset.\n`);
+        return;
+    }
+    let totalLines = 0;
+    for (const f of files) {
+        try {
+            totalLines += fs.readFileSync(path.join(OUTCOMES_DIR, f), 'utf-8').split('\n').filter(Boolean).length;
+        }
+        catch { /* ignore */ }
+    }
+    console.log(`\n  Outcomes snapshot: ${files.length} session files, ${totalLines} events.`);
+    if (!apply) {
+        console.log(`\n  Dry-run. Re-run with --apply to archive:`);
+        console.log(`    mv ~/.forgen/state/outcomes  →  ~/.forgen/state/outcomes.archive-<ts>`);
+        console.log(`    new empty ~/.forgen/state/outcomes/\n`);
+        return;
+    }
+    const archivePath = `${OUTCOMES_DIR}.archive-${Date.now()}`;
+    fs.renameSync(OUTCOMES_DIR, archivePath);
+    fs.mkdirSync(OUTCOMES_DIR, { recursive: true });
+    console.log(`\n  ✓ Archived to ${archivePath}`);
+    console.log(`  ✓ Fresh ${OUTCOMES_DIR} created.`);
+    console.log(`\n  Next fitness snapshot reflects v0.3.2 attribution gates only.\n`);
+}
 function runFixUp(args) {
     const apply = args.includes('--apply');
     const result = fixupSolutions(ME_SOLUTIONS, { dryRun: !apply });

package/dist/engine/match-eval-log.js

@@ -69,6 +69,47 @@ const MAX_NORMALIZED_QUERY_LOGGED = 64;
 const MAX_MATCHED_TERMS_PER_CANDIDATE = 16;
 /** Read-side DoS guard: refuse to load if the JSONL file is larger than this. */
 const MAX_LOG_FILE_SIZE_BYTES = 50 * 1024 * 1024; // 50 MB
+/**
+ * Write-side rotation threshold (2026-04-21). When the active log reaches
+ * this size, it is renamed to `<path>.1` (clobbering any previous rotation)
+ * and a fresh empty file is opened. Keeps one generation of history for
+ * offline forensics without letting the log grow unbounded. Chosen so
+ * typical installs retain ~10-20k records — enough to spot recurrent
+ * matcher surprises, not enough to silently fill disk.
+ */
+const ROTATION_SIZE_BYTES = 10 * 1024 * 1024; // 10 MB
+/**
+ * Internal: rotate the log if it exceeds ROTATION_SIZE_BYTES. Called from
+ * inside the file lock so no concurrent writer observes a torn state. A
+ * rotation failure is swallowed — the caller will still attempt to append
+ * and either succeed (no-op rotation) or the append itself will surface
+ * the underlying fs error via the outer catch.
+ */
+function maybeRotate(logPath) {
+    let size = 0;
+    try {
+        const st = fs.statSync(logPath);
+        if (!st.isFile())
+            return;
+        size = st.size;
+    }
+    catch {
+        return; // missing file is fine, append will create it
+    }
+    if (size < ROTATION_SIZE_BYTES)
+        return;
+    const rotated = `${logPath}.1`;
+    try {
+        // rename is atomic on POSIX within the same directory; overwrites any
+        // previous rotation. We intentionally keep only one generation.
+        fs.renameSync(logPath, rotated);
+    }
+    catch {
+        // Best effort. If rotation fails (permissions, cross-device link)
+        // we leave the original file alone and the next append just continues
+        // growing. The 50 MB read-side cap still protects offline tools.
+    }
+}
 /**
  * Check whether logging is disabled via environment variable.
  * Accepts `off`, `disabled`, `0`, `false`, `no` (case-insensitive).
@@ -150,6 +191,10 @@ export function logMatchDecision(input) {
         // so concurrent writers could interleave without this lock. The lock
         // is taken on the log file itself, and cleaned up by withFileLockSync.
         withFileLockSync(MATCH_EVAL_LOG_PATH, () => {
+            // Rotate BEFORE opening the fd so the new fd points at the fresh
+            // file. Doing this after open would append to the file that is
+            // about to be renamed into the previous-generation slot.
+            maybeRotate(MATCH_EVAL_LOG_PATH);
             // O_NOFOLLOW: refuse to follow a symlink at the target path. This
             // blocks a local-attacker symlink swap attack where the log file
             // is replaced with a link to e.g. ~/.ssh/authorized_keys.

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

@@ -74,8 +74,6 @@ export declare function parseFrontmatterOnly(content: string): SolutionFrontmatt
 export declare function parseSolutionV3(content: string): SolutionV3 | null;
 /** Serialize a SolutionV3 to a markdown string with YAML frontmatter */
 export declare function serializeSolutionV3(solution: SolutionV3): string;
-/** Check if content is in V3 format (YAML frontmatter) */
-export declare function isV3Format(content: string): boolean;
 /** Check if content is in V1 format (# Title + > Type: pattern) */
 export declare function isV1Format(content: string): boolean;
 /** 한국어 일반 조사/어미 — strip 대상 (긴 것부터 매칭)

package/dist/engine/solution-format.js

@@ -162,10 +162,6 @@ export function serializeSolutionV3(solution) {
     return `---\n${yamlStr}---\n\n## Context\n${solution.context}\n\n## Content\n${solution.content}\n`;
 }
 // ── Format Detection ──
-/** Check if content is in V3 format (YAML frontmatter) */
-export function isV3Format(content) {
-    return content.trimStart().startsWith('---');
-}
 /** Check if content is in V1 format (# Title + > Type: pattern) */
 export function isV1Format(content) {
     const lines = content.split('\n');

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

@@ -41,6 +41,14 @@ export interface SolutionMatch {
     tags: string[];
     identifiers: string[];
     matchedTags: string[];
+    /**
+     * Identifier substrings (function/file names) that appeared literally in the
+     * prompt. Added 2026-04-21 so solution-injector can enforce a precision gate
+     * distinguishing "user typed a specific identifier" (strong signal, survives
+     * 1-tag overlap) from "only 1 tag happens to overlap" (often noise — common
+     * nouns like 'type', 'file', 'forgen' trigger rare-tag BM25 boost).
+     */
+    matchedIdentifiers: string[];
 }
 /**
  * Optional hints for the v3 `calculateRelevance` path. Used by hot-path

package/dist/engine/solution-matcher.js

@@ -818,12 +818,14 @@ function loadTunedMatcherWeights() {
  * entries and almost always lose the first few rounds — not because
  * they're worse, but because matchers favor solutions with richer tag
  * histories. A small confidence multiplier lets candidates surface often
- * enough to accumulate outcome data, after which the fitness loop
- * decides their fate.
+ * enough to accumulate reflected/sessions evidence, after which the
+ * lifecycle loop decides their fate.
  *
  * The 1.3× factor is a starting point (Q1 in docs/design-solution-evolution.md).
- * Automatic deactivation after 5 accumulated injections is handled by a
- * separate promoter that flips `status` to `verified`.
+ * Bonus deactivation happens implicitly when compound-lifecycle.ts::
+ * runLifecycleCheck promotes the candidate to `verified` based on accumulated
+ * reflected/sessions evidence. There is no inject-count-based auto promotion
+ * (removed 2026-04-20 — see feedback_core_loop_invariant).
  */
 const CANDIDATE_EXPLORATION_MULTIPLIER = 1.3;
 function applyCandidateExplorationBonus(entries) {
@@ -865,5 +867,6 @@ export function matchSolutions(prompt, scope, cwd) {
         tags: c.solution.tags,
         identifiers: c.solution.identifiers,
         matchedTags: [...c.matchedTags, ...c.matchedIdentifiers],
+        matchedIdentifiers: c.matchedIdentifiers,
     }));
 }

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

@@ -52,6 +52,10 @@ export declare function attributeCorrection(sessionId: string): string[];
  * — an error is a weaker signal and the next user prompt can still produce
  * a correct/accept decision.
  *
+ * Only the top-K most-relevant, recent, above-threshold pending solutions
+ * are attributed (see gates above). Below-threshold or stale pending
+ * entries are left untouched — they will resolve via accept/unknown later.
+ *
  * To avoid flooding the log with duplicate errors for the same pending
  * batch, we cap at one `error` event per (session, solution) pair per
  * pending-cycle by tracking a `error_flagged` set in the pending state.