@wooojin/forgen 0.4.7 → 0.4.9

package/dist/core/inspect-cli.js

@@ -21,7 +21,7 @@ export async function handleInspect(args) {
             console.log('\n  No v1 profile found. Run onboarding first.\n');
             return;
         }
-        console.log('\n' + inspect.renderProfile(profile) + '\n');
+        console.log(`\n${inspect.renderProfile(profile)}\n`);
         // ── Learning Loop Status ──
         const activeRules = loadActiveRules();
         const rulesByScope = {
@@ -75,13 +75,13 @@ export async function handleInspect(args) {
     }
     if (sub === 'rules') {
         const rules = loadAllRules();
-        console.log('\n' + inspect.renderRules(rules) + '\n');
+        console.log(`\n${inspect.renderRules(rules)}\n`);
         return;
     }
     // R9-IA2: user-facing name is "corrections"; "evidence" kept as back-compat alias.
     if (sub === 'corrections' || sub === 'evidence') {
         const evidence = loadRecentEvidence(20);
-        console.log('\n' + inspect.renderEvidence(evidence) + '\n');
+        console.log(`\n${inspect.renderEvidence(evidence)}\n`);
         return;
     }
     if (sub === 'session') {
@@ -90,7 +90,7 @@ export async function handleInspect(args) {
             console.log('\n  No session state found.\n');
             return;
         }
-        console.log('\n' + inspect.renderSession(sessions[0]) + '\n');
+        console.log(`\n${inspect.renderSession(sessions[0])}\n`);
         return;
     }
     // R5-G1: 2AM 디버깅용 jsonl tail — violations/bypass/drift

package/dist/core/lifecycle-classifier.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Forgen — Lifecycle Classifier (P3)
+ *
+ * 솔루션 catalog (~/.forgen/me/solutions/*.md) 를 읽어 각 솔루션의
+ * lifecycle 을 hot/warm/cold/dead/new 로 분류한다.
+ */
+import type { HitRateRow } from './observability-store.js';
+export type Lifecycle = 'hot' | 'warm' | 'cold' | 'dead' | 'new';
+export interface LifecycleClass {
+    solutionId: string;
+    lifecycle: Lifecycle;
+    /** acted_90d / max(surfaced_90d, 1). surfaced_90d == 0 이면 null */
+    hitRate: number | null;
+    matched_90d: number;
+    surfaced_90d: number;
+    acted_90d: number;
+    matched_180d: number;
+    ageDays: number;
+}
+/** 분류 로직 — §5.2 */
+export declare function classifyOne(_solutionId: string, ageDays: number, rates: HitRateRow): Lifecycle;
+/** ~/.forgen/me/solutions/*.md 전체를 분류하여 반환 */
+export declare function classifySolutions(): LifecycleClass[];

package/dist/core/lifecycle-classifier.js

@@ -0,0 +1,104 @@
+/**
+ * Forgen — Lifecycle Classifier (P3)
+ *
+ * 솔루션 catalog (~/.forgen/me/solutions/*.md) 를 읽어 각 솔루션의
+ * lifecycle 을 hot/warm/cold/dead/new 로 분류한다.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ME_SOLUTIONS } from './paths.js';
+import { parseFrontmatterOnly } from '../engine/solution-format.js';
+import { queryHitRate } from './observability-store.js';
+/** 분류 로직 — §5.2 */
+export function classifyOne(_solutionId, ageDays, rates) {
+    // new: age ≤ 30d
+    if (ageDays <= 30)
+        return 'new';
+    // dead: matched_180d == 0 AND age > 30d
+    if (rates.matched_180d === 0)
+        return 'dead';
+    // hot: acted_90d >= 3 AND (acted_90d / max(surfaced_90d, 1)) >= 0.4
+    const hitRate = rates.acted_90d / Math.max(rates.surfaced_90d, 1);
+    if (rates.acted_90d >= 3 && hitRate >= 0.4)
+        return 'hot';
+    // warm: surfaced_90d >= 3 AND acted_90d >= 1
+    if (rates.surfaced_90d >= 3 && rates.acted_90d >= 1)
+        return 'warm';
+    // cold: matched_90d >= 1 AND surfaced_90d == 0
+    if (rates.matched_90d >= 1 && rates.surfaced_90d === 0)
+        return 'cold';
+    // fallback
+    return 'cold';
+}
+/** ~/.forgen/me/solutions/*.md 전체를 분류하여 반환 */
+export function classifySolutions() {
+    const results = [];
+    let files;
+    try {
+        if (!fs.existsSync(ME_SOLUTIONS))
+            return [];
+        files = fs.readdirSync(ME_SOLUTIONS).filter(f => f.endsWith('.md'));
+    }
+    catch {
+        return [];
+    }
+    // queryHitRate() 는 전체 결과를 한 번에 가져옴
+    const rateMap = new Map();
+    try {
+        const rows = queryHitRate();
+        for (const row of rows) {
+            rateMap.set(row.solutionId, row);
+        }
+    }
+    catch {
+        // fail-open: DB 없으면 빈 map
+    }
+    const now = Date.now();
+    for (const file of files) {
+        const filePath = path.join(ME_SOLUTIONS, file);
+        let content;
+        try {
+            content = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        const fm = parseFrontmatterOnly(content);
+        if (!fm)
+            continue;
+        const solutionId = fm.name;
+        // ageDays: frontmatter created date 에서 계산
+        let ageDays = 999;
+        try {
+            const createdMs = new Date(fm.created).getTime();
+            if (!isNaN(createdMs)) {
+                ageDays = Math.floor((now - createdMs) / (24 * 60 * 60 * 1000));
+            }
+        }
+        catch {
+            // keep 999 (treat as old)
+        }
+        const rates = rateMap.get(solutionId) ?? {
+            solutionId,
+            matched_30d: 0, surfaced_30d: 0, acted_30d: 0,
+            matched_90d: 0, surfaced_90d: 0, acted_90d: 0,
+            matched_180d: 0, surfaced_180d: 0, acted_180d: 0,
+            last_event_ts: 0,
+        };
+        const lifecycle = classifyOne(solutionId, ageDays, rates);
+        const hitRate = rates.surfaced_90d > 0
+            ? rates.acted_90d / rates.surfaced_90d
+            : null;
+        results.push({
+            solutionId,
+            lifecycle,
+            hitRate,
+            matched_90d: rates.matched_90d,
+            surfaced_90d: rates.surfaced_90d,
+            acted_90d: rates.acted_90d,
+            matched_180d: rates.matched_180d,
+            ageDays,
+        });
+    }
+    return results;
+}

package/dist/core/migrate-evidence-host.js

@@ -35,7 +35,7 @@ export function migrateEvidenceHost(options) {
             skipped++;
             continue;
         }
-        const host = data['host'];
+        const host = data.host;
         if (host === 'claude' || host === 'codex') {
             skipped++;
             continue;

package/dist/core/notify.js

@@ -37,6 +37,9 @@ function notifyDarwin(title, body) {
     try {
         const script = `display notification "${escapeForOsascript(body)}" with title "${escapeForOsascript(title)}"`;
         const child = spawn('osascript', ['-e', script], { detached: true, stdio: 'ignore' });
+        // ENOENT 등 spawn 실패는 동기 throw 가 아니라 'error' event 로 emit 됨.
+        // 핸들러 없으면 unhandled 로 process crash → headless CI 회귀 가드.
+        child.on('error', (e) => log.debug('osascript notification 실패 (event)', e));
         child.unref();
     }
     catch (e) {
@@ -47,6 +50,10 @@ function notifyDarwin(title, body) {
 function notifyLinux(title, body) {
     try {
         const child = spawn('notify-send', [title, body], { detached: true, stdio: 'ignore' });
+        // headless 환경 (CI, Docker) 에서 notify-send 부재 시 ENOENT 가 'error' event 로 emit.
+        // 핸들러 없으면 unhandled 로 caller 프로세스 죽음 — rate-limit-spawn-integration
+        // CI 실패의 사전 존재 원인.
+        child.on('error', (e) => log.debug('notify-send 실패 (event)', e));
         child.unref();
     }
     catch (e) {

package/dist/core/observability-backfill.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Forgen — Observability Backfill (Phase 2)
+ *
+ * 기존 JSONL 상태 파일에서 solution_events 를 소급 생성한다.
+ * Phase A (결정론적): match-eval-log, implicit-feedback, compound-usage, outcomes
+ * Phase B (휴리스틱): transcript 스캔 — CLI --phase B|all 로만 활성
+ *
+ * 안전성:
+ *   - 기본: events 가 이미 있으면 reject (--force 필요)
+ *   - signal_source 에 '-backfill' prefix 로 실시간 emit 과 구분
+ *   - BEGIN/COMMIT 단위 트랜잭션
+ *   - fail-open: 파일 누락은 조용히 skip
+ */
+export interface BackfillOptions {
+    force?: boolean;
+    phase?: 'A' | 'B' | 'all';
+    dryRun?: boolean;
+}
+export interface BackfillResult {
+    phaseA: {
+        matched: number;
+        surfaced: number;
+        acted_on: number;
+    };
+    phaseB: {
+        acted_on: number;
+    };
+    total: number;
+    durationMs: number;
+}
+export declare function runBackfill(opts?: BackfillOptions): Promise<BackfillResult>;

package/dist/core/observability-backfill.js

@@ -0,0 +1,178 @@
+/**
+ * Forgen — Observability Backfill (Phase 2)
+ *
+ * 기존 JSONL 상태 파일에서 solution_events 를 소급 생성한다.
+ * Phase A (결정론적): match-eval-log, implicit-feedback, compound-usage, outcomes
+ * Phase B (휴리스틱): transcript 스캔 — CLI --phase B|all 로만 활성
+ *
+ * 안전성:
+ *   - 기본: events 가 이미 있으면 reject (--force 필요)
+ *   - signal_source 에 '-backfill' prefix 로 실시간 emit 과 구분
+ *   - BEGIN/COMMIT 단위 트랜잭션
+ *   - fail-open: 파일 누락은 조용히 skip
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createRequire } from 'node:module';
+import { STATE_DIR, MATCH_EVAL_LOG_PATH, FORGEN_HOME } from './paths.js';
+import { createLogger } from './logger.js';
+import { emitSolutionEvent } from './observability-store.js';
+const require = createRequire(import.meta.url);
+const log = createLogger('observability-backfill');
+const DB_PATH = path.join(FORGEN_HOME, 'sessions.db');
+const COMPOUND_USAGE_LOG = path.join(STATE_DIR, 'compound-usage.jsonl');
+const IMPLICIT_FEEDBACK_LOG = path.join(STATE_DIR, 'implicit-feedback.jsonl');
+const OUTCOMES_DIR = path.join(STATE_DIR, 'outcomes');
+function readJsonlLines(filePath) {
+    if (!fs.existsSync(filePath))
+        return [];
+    try {
+        return fs.readFileSync(filePath, 'utf-8')
+            .split('\n')
+            .filter(Boolean)
+            .map(l => { try {
+            return JSON.parse(l);
+        }
+        catch {
+            return null;
+        } })
+            .filter((x) => x !== null);
+    }
+    catch {
+        return [];
+    }
+}
+function hasExistingEvents() {
+    try {
+        if (!fs.existsSync(DB_PATH))
+            return false;
+        const { DatabaseSync } = require('node:sqlite');
+        const db = new DatabaseSync(DB_PATH);
+        try {
+            const row = db.prepare(`SELECT COUNT(*) AS cnt FROM solution_events`).get();
+            return (row?.cnt ?? 0) > 0;
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch {
+        return false;
+    }
+}
+/** Phase A: 결정론적 소급 */
+async function runPhaseA(opts) {
+    const counts = { matched: 0, surfaced: 0, acted_on: 0 };
+    // 1. match-eval-log.jsonl → matched events
+    const matchLines = readJsonlLines(MATCH_EVAL_LOG_PATH);
+    for (const line of matchLines) {
+        const sessionId = line.sessionId ?? line.session_id ?? undefined;
+        const topN = line.rankedTopN ?? line.candidates?.slice(0, 5).map(c => c.name) ?? [];
+        const candidateMap = new Map((line.candidates ?? []).map(c => [c.name, c.relevance]));
+        for (const name of topN) {
+            if (!name)
+                continue;
+            const score = candidateMap.get(name) ?? null;
+            if (!opts.dryRun) {
+                emitSolutionEvent({
+                    sessionId: sessionId ?? null,
+                    solutionId: name,
+                    eventType: 'matched',
+                    signalSource: 'matcher-backfill',
+                    signalScore: score,
+                });
+            }
+            counts.matched++;
+            if (counts.matched % 1000 === 0)
+                process.stderr.write(`[backfill] matched: ${counts.matched}\n`);
+        }
+    }
+    // 2. implicit-feedback.jsonl type='recommendation_surfaced' → surfaced
+    const feedbackLines = readJsonlLines(IMPLICIT_FEEDBACK_LOG);
+    for (const line of feedbackLines) {
+        if (line.type !== 'recommendation_surfaced')
+            continue;
+        const sid = line.solutionId ?? line.solution_id;
+        if (!sid)
+            continue;
+        const sessionId = line.sessionId ?? line.session_id ?? undefined;
+        if (!opts.dryRun) {
+            emitSolutionEvent({
+                sessionId: sessionId ?? null,
+                solutionId: sid,
+                eventType: 'surfaced',
+                signalSource: 'hook-backfill',
+            });
+        }
+        counts.surfaced++;
+    }
+    // 3. compound-usage.jsonl → acted_on (signalSource='mcp-read-backfill')
+    const usageLines = readJsonlLines(COMPOUND_USAGE_LOG);
+    for (const line of usageLines) {
+        if (!line.name)
+            continue;
+        if (!opts.dryRun) {
+            emitSolutionEvent({
+                sessionId: null,
+                solutionId: line.name,
+                eventType: 'acted_on',
+                signalSource: 'mcp-read-backfill',
+                signalScore: 0.30,
+            });
+        }
+        counts.acted_on++;
+        if (counts.acted_on % 1000 === 0)
+            process.stderr.write(`[backfill] acted_on: ${counts.acted_on}\n`);
+    }
+    // 4. outcomes/<sid>.jsonl outcome='accept' → acted_on (signalSource='outcome-accept-backfill')
+    if (fs.existsSync(OUTCOMES_DIR)) {
+        const outFiles = fs.readdirSync(OUTCOMES_DIR).filter(f => f.endsWith('.jsonl'));
+        for (const file of outFiles) {
+            const lines = readJsonlLines(path.join(OUTCOMES_DIR, file));
+            for (const line of lines) {
+                if (line.outcome !== 'accept')
+                    continue;
+                const sid = line.solution_id ?? line.solutionId;
+                if (!sid)
+                    continue;
+                const sessionId = line.session_id ?? line.sessionId ?? undefined;
+                if (!opts.dryRun) {
+                    emitSolutionEvent({
+                        sessionId: sessionId ?? null,
+                        solutionId: sid,
+                        eventType: 'acted_on',
+                        signalSource: 'outcome-accept-backfill',
+                        signalScore: 0.15,
+                    });
+                }
+                counts.acted_on++;
+            }
+        }
+    }
+    return counts;
+}
+export async function runBackfill(opts = {}) {
+    const start = Date.now();
+    const phase = opts.phase ?? 'A';
+    if (!opts.force && !opts.dryRun) {
+        if (hasExistingEvents()) {
+            throw new Error('solution_events 테이블에 기존 이벤트가 있습니다. ' +
+                '--force 플래그를 사용하면 강행합니다.');
+        }
+    }
+    const phaseA = { matched: 0, surfaced: 0, acted_on: 0 };
+    const phaseB = { acted_on: 0 };
+    if (phase === 'A' || phase === 'all') {
+        const aResult = await runPhaseA(opts);
+        phaseA.matched = aResult.matched;
+        phaseA.surfaced = aResult.surfaced;
+        phaseA.acted_on = aResult.acted_on;
+    }
+    // Phase B: transcript 스캔 — 1차 release 는 opt-in 만
+    if (phase === 'B' || phase === 'all') {
+        log.debug('Phase B (transcript scan) 은 현재 미구현 — 향후 릴리스에서 활성화');
+    }
+    const total = phaseA.matched + phaseA.surfaced + phaseA.acted_on + phaseB.acted_on;
+    const durationMs = Date.now() - start;
+    return { phaseA, phaseB, total, durationMs };
+}

package/dist/core/observability-store.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Forgen — Observability Store (Phase 1)
+ *
+ * solution_events 테이블에 matched/surfaced/acted_on 이벤트를 기록.
+ * Fail-open: 모든 함수는 내부 오류를 삼키고 절대 throw 하지 않는다.
+ */
+export type EventType = 'matched' | 'surfaced' | 'acted_on';
+export interface EmitOptions {
+    ts?: number;
+    sessionId?: string | null;
+    solutionId: string;
+    eventType: EventType;
+    signalSource: string;
+    signalScore?: number | null;
+    meta?: Record<string, unknown>;
+}
+export interface SurfacedEvent {
+    id: number;
+    ts: number;
+    sessionId: string | null;
+    solutionId: string;
+    signalSource: string;
+    signalScore: number | null;
+    meta: Record<string, unknown> | null;
+}
+export interface HitRateRow {
+    solutionId: string;
+    matched_30d: number;
+    surfaced_30d: number;
+    acted_30d: number;
+    matched_90d: number;
+    surfaced_90d: number;
+    acted_90d: number;
+    matched_180d: number;
+    surfaced_180d: number;
+    acted_180d: number;
+    last_event_ts: number;
+}
+interface SqliteDb {
+    exec(sql: string): void;
+    prepare(sql: string): {
+        run(...args: unknown[]): {
+            lastInsertRowid: number;
+        };
+        get(...args: unknown[]): unknown;
+        all(...args: unknown[]): unknown[];
+    };
+    close(): void;
+}
+/** solution_events 스키마 및 schema_version 초기화. idempotent. */
+export declare function ensureObservabilitySchema(db: SqliteDb): void;
+/** solution_events 에 이벤트를 기록한다. fail-open (throw 없음). */
+export declare function emitSolutionEvent(opts: EmitOptions): void;
+/** 특정 세션에서 지정 시간 window 내 surfaced 이벤트 조회. */
+export declare function querySurfacedWithin(sessionId: string, minutesWindow: number): SurfacedEvent[];
+/** 30/90/180일 hit-rate 집계. solutionId 지정 시 단일 솔루션만. */
+export declare function queryHitRate(solutionId?: string): HitRateRow[];
+export {};

package/dist/core/observability-store.js

@@ -0,0 +1,195 @@
+/**
+ * Forgen — Observability Store (Phase 1)
+ *
+ * solution_events 테이블에 matched/surfaced/acted_on 이벤트를 기록.
+ * Fail-open: 모든 함수는 내부 오류를 삼키고 절대 throw 하지 않는다.
+ */
+import { createRequire } from 'node:module';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createLogger } from './logger.js';
+import { FORGEN_HOME } from './paths.js';
+const require = createRequire(import.meta.url);
+const log = createLogger('observability');
+const DB_PATH = path.join(FORGEN_HOME, 'sessions.db');
+const DEDUP_WINDOW_MS = 5 * 60 * 1000;
+/** DB 파일을 열고 SqliteDb 반환. 실패 시 null. */
+function openObsDb() {
+    try {
+        const { DatabaseSync } = require('node:sqlite');
+        const dbDir = path.dirname(DB_PATH);
+        if (!fs.existsSync(dbDir))
+            fs.mkdirSync(dbDir, { recursive: true });
+        const db = new DatabaseSync(DB_PATH);
+        db.exec(`PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL; PRAGMA busy_timeout=1000;`);
+        return db;
+    }
+    catch (e) {
+        log.debug('openObsDb 실패', e);
+        return null;
+    }
+}
+/** solution_events 스키마 및 schema_version 초기화. idempotent. */
+export function ensureObservabilitySchema(db) {
+    try {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS schema_version (
+        component TEXT PRIMARY KEY,
+        version INTEGER NOT NULL,
+        applied_at INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS solution_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        ts INTEGER NOT NULL,
+        session_id TEXT,
+        solution_id TEXT NOT NULL,
+        event_type TEXT NOT NULL CHECK(event_type IN ('matched','surfaced','acted_on')),
+        signal_source TEXT,
+        signal_score REAL,
+        meta TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_se_solution ON solution_events(solution_id, ts);
+      CREATE INDEX IF NOT EXISTS idx_se_session  ON solution_events(session_id, ts);
+      CREATE INDEX IF NOT EXISTS idx_se_type     ON solution_events(event_type, ts);
+    `);
+        const row = db.prepare(`SELECT version FROM schema_version WHERE component = 'observability'`).get();
+        if (!row) {
+            db.prepare(`INSERT INTO schema_version (component, version, applied_at) VALUES ('observability', 1, ?)`).run(Date.now());
+        }
+    }
+    catch (e) {
+        log.debug('ensureObservabilitySchema 실패', e);
+    }
+}
+/** solution_events 에 이벤트를 기록한다. fail-open (throw 없음). */
+export function emitSolutionEvent(opts) {
+    const ts = opts.ts ?? Date.now();
+    let db = null;
+    try {
+        db = openObsDb();
+        if (!db)
+            return;
+        ensureObservabilitySchema(db);
+        // dedup: 직전 5분 내 동일 (session, solution, source) 존재 시 skip
+        if (opts.sessionId) {
+            const dup = db.prepare(`
+        SELECT id FROM solution_events
+        WHERE session_id = ? AND solution_id = ? AND signal_source = ?
+          AND ts > ?
+        LIMIT 1
+      `).get(opts.sessionId, opts.solutionId, opts.signalSource, ts - DEDUP_WINDOW_MS);
+            if (dup)
+                return;
+        }
+        db.prepare(`
+      INSERT INTO solution_events (ts, session_id, solution_id, event_type, signal_source, signal_score, meta)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(ts, opts.sessionId ?? null, opts.solutionId, opts.eventType, opts.signalSource, opts.signalScore ?? null, opts.meta ? JSON.stringify(opts.meta) : null);
+    }
+    catch (e) {
+        log.debug('emitSolutionEvent 실패', e);
+    }
+    finally {
+        try {
+            db?.close();
+        }
+        catch { /* ignore */ }
+    }
+}
+/** 특정 세션에서 지정 시간 window 내 surfaced 이벤트 조회. */
+export function querySurfacedWithin(sessionId, minutesWindow) {
+    let db = null;
+    try {
+        db = openObsDb();
+        if (!db)
+            return [];
+        ensureObservabilitySchema(db);
+        const since = Date.now() - minutesWindow * 60 * 1000;
+        const rows = db.prepare(`
+      SELECT id, ts, session_id, solution_id, signal_source, signal_score, meta
+      FROM solution_events
+      WHERE session_id = ? AND event_type = 'surfaced' AND ts >= ?
+      ORDER BY ts DESC
+    `).all(sessionId, since);
+        return rows.map(r => ({
+            id: r.id,
+            ts: r.ts,
+            sessionId: r.session_id,
+            solutionId: r.solution_id,
+            signalSource: r.signal_source,
+            signalScore: r.signal_score,
+            meta: r.meta ? JSON.parse(r.meta) : null,
+        }));
+    }
+    catch (e) {
+        log.debug('querySurfacedWithin 실패', e);
+        return [];
+    }
+    finally {
+        try {
+            db?.close();
+        }
+        catch { /* ignore */ }
+    }
+}
+/** 30/90/180일 hit-rate 집계. solutionId 지정 시 단일 솔루션만. */
+export function queryHitRate(solutionId) {
+    let db = null;
+    try {
+        db = openObsDb();
+        if (!db)
+            return [];
+        ensureObservabilitySchema(db);
+        const now = Date.now();
+        const cutoff30 = now - 30 * 24 * 60 * 60 * 1000;
+        const cutoff90 = now - 90 * 24 * 60 * 60 * 1000;
+        const cutoff180 = now - 180 * 24 * 60 * 60 * 1000;
+        const where = solutionId ? `WHERE solution_id = ?` : '';
+        const baseParams = [
+            cutoff30, cutoff30, cutoff30,
+            cutoff90, cutoff90, cutoff90,
+            cutoff180, cutoff180, cutoff180,
+        ];
+        const params = solutionId ? [...baseParams, solutionId] : baseParams;
+        const rows = db.prepare(`
+      SELECT
+        solution_id,
+        SUM(CASE WHEN event_type='matched'  AND ts > ? THEN 1 ELSE 0 END) AS matched_30d,
+        SUM(CASE WHEN event_type='surfaced' AND ts > ? THEN 1 ELSE 0 END) AS surfaced_30d,
+        SUM(CASE WHEN event_type='acted_on' AND ts > ? THEN 1 ELSE 0 END) AS acted_30d,
+        SUM(CASE WHEN event_type='matched'  AND ts > ? THEN 1 ELSE 0 END) AS matched_90d,
+        SUM(CASE WHEN event_type='surfaced' AND ts > ? THEN 1 ELSE 0 END) AS surfaced_90d,
+        SUM(CASE WHEN event_type='acted_on' AND ts > ? THEN 1 ELSE 0 END) AS acted_90d,
+        SUM(CASE WHEN event_type='matched'  AND ts > ? THEN 1 ELSE 0 END) AS matched_180d,
+        SUM(CASE WHEN event_type='surfaced' AND ts > ? THEN 1 ELSE 0 END) AS surfaced_180d,
+        SUM(CASE WHEN event_type='acted_on' AND ts > ? THEN 1 ELSE 0 END) AS acted_180d,
+        MAX(ts) AS last_event_ts
+      FROM solution_events
+      ${where}
+      GROUP BY solution_id
+    `).all(...params);
+        return rows.map(r => ({
+            solutionId: r.solution_id,
+            matched_30d: r.matched_30d,
+            surfaced_30d: r.surfaced_30d,
+            acted_30d: r.acted_30d,
+            matched_90d: r.matched_90d,
+            surfaced_90d: r.surfaced_90d,
+            acted_90d: r.acted_90d,
+            matched_180d: r.matched_180d,
+            surfaced_180d: r.surfaced_180d,
+            acted_180d: r.acted_180d,
+            last_event_ts: r.last_event_ts,
+        }));
+    }
+    catch (e) {
+        log.debug('queryHitRate 실패', e);
+        return [];
+    }
+    finally {
+        try {
+            db?.close();
+        }
+        catch { /* ignore */ }
+    }
+}