@wooojin/forgen 0.4.8 → 0.4.9

package/dist/core/spawn.js

@@ -2,13 +2,16 @@ import { spawn, execFileSync } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
+import * as crypto from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { buildEnv } from './config-injector.js';
 import { loadGlobalConfig } from './global-config.js';
 import { createLogger } from './logger.js';
-import { STATE_DIR } from './paths.js';
+import { STATE_DIR, ME_SOLUTIONS } from './paths.js';
 import { getHostRuntime } from '../host/host-runtime.js';
 import { sendNotification } from './notify.js';
+import { querySurfacedWithin, emitSolutionEvent } from './observability-store.js';
+import { parseSolutionV3 } from '../engine/solution-format.js';
 const log = createLogger('spawn');
 /** Phase 2: host-runtime 어댑터 위임. */
 function findRuntimeLauncher(runtime) {
@@ -139,6 +142,83 @@ async function countUserMessages(transcriptPath) {
     }
     return count;
 }
+/**
+ * Observability P2: commit-diff acted_on signal.
+ * 세션 시작 이후 생성된 commit 들의 diff 를 scan 하여 surfaced 솔루션과 키워드 매칭.
+ * 프라이버시: commit sha 는 SHA1 해시 12char prefix 만 저장, diff/path 내용 미저장.
+ */
+async function scanCommitDiffForActedOn(sessionId, cwd, sessionStartTime) {
+    try {
+        const surfaces = querySurfacedWithin(sessionId, 30); // 30분 window
+        if (surfaces.length === 0)
+            return;
+        const since = new Date(sessionStartTime).toISOString();
+        let logOutput;
+        try {
+            logOutput = execFileSync('git', ['log', '--since', since, '--pretty=format:%H'], {
+                cwd, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        }
+        catch {
+            return; // git not available or not a repo
+        }
+        const shas = logOutput.trim().split('\n').filter(Boolean);
+        if (shas.length === 0)
+            return;
+        const seen = new Set(); // (sha12+solutionId) dedup
+        for (const sha of shas) {
+            let diff;
+            try {
+                diff = execFileSync('git', ['show', '--unified=0', sha], {
+                    cwd, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'],
+                });
+            }
+            catch {
+                continue;
+            }
+            const diffLower = diff.toLowerCase();
+            const shaHash = crypto.createHash('sha1').update(sha).digest('hex').slice(0, 12);
+            for (const surf of surfaces) {
+                const dedupKey = `${shaHash}:${surf.solutionId}`;
+                if (seen.has(dedupKey))
+                    continue;
+                const filePath = path.join(ME_SOLUTIONS, `${surf.solutionId}.md`);
+                if (!fs.existsSync(filePath))
+                    continue;
+                let raw;
+                try {
+                    raw = fs.readFileSync(filePath, 'utf-8');
+                }
+                catch {
+                    continue;
+                }
+                const sol = parseSolutionV3(raw);
+                if (!sol)
+                    continue;
+                const tags = sol.frontmatter.tags ?? [];
+                const identifiers = sol.frontmatter.identifiers ?? [];
+                if (tags.length === 0 && identifiers.length === 0)
+                    continue;
+                const hit = tags.some(t => diffLower.includes(t.toLowerCase()))
+                    || identifiers.some(id => diffLower.includes(id.toLowerCase()));
+                if (!hit)
+                    continue;
+                seen.add(dedupKey);
+                emitSolutionEvent({
+                    sessionId,
+                    solutionId: surf.solutionId,
+                    eventType: 'acted_on',
+                    signalSource: 'commit-diff',
+                    signalScore: 0.30,
+                    meta: { commit_sha_hash: shaHash, surface_ts: surf.ts },
+                });
+            }
+        }
+    }
+    catch (e) {
+        log.debug('scanCommitDiffForActedOn 실패', e);
+    }
+}
 /**
  * 세션 종료 후 자동 compound 추출 + USER.md 업데이트.
  * auto-compound-runner.ts를 동기 실행하여 솔루션 추출 + 사용자 패턴 관찰.
@@ -178,6 +258,78 @@ async function indexTranscriptToFTS(cwd, transcriptPath, sessionId, runtime = 'c
         log.debug('FTS5 인덱싱 실패 (session-store 미구현 시 정상)', e);
     }
 }
+/**
+ * Plan B-1: 세션 transcript 사후 스캔으로 rate-limit 감지.
+ *
+ * stdio='inherit' 라 Claude 출력을 직접 캡처할 수 없으므로,
+ * 세션 종료 후 transcript JSONL 의 마지막 N 라인을 읽어
+ * RATE_LIMIT_REGEX 매칭 여부를 확인한다.
+ *
+ * - transcript 없음 / 빈 파일 / parse 실패 → matched: false (fail-open)
+ * - 이미 pending-resume.json 존재 시 hook 이 먼저 잡은 것이므로 덮어쓰지 않음
+ *
+ * @param transcriptPath JSONL 파일 경로
+ * @param tailLines 검사할 마지막 라인 수 (기본 5)
+ */
+export async function scanTranscriptForRateLimit(transcriptPath, tailLines = 5) {
+    const notFound = { matched: false, resetAt: null };
+    if (!transcriptPath)
+        return notFound;
+    try {
+        if (!fs.existsSync(transcriptPath))
+            return notFound;
+        const { RATE_LIMIT_REGEX, parseRateLimitResetAt } = await import('../hooks/context-guard.js');
+        // tail: 파일 끝에서 tailLines 개 라인만 읽음 (대용량 transcript 효율)
+        const { createInterface } = await import('node:readline');
+        const stream = fs.createReadStream(transcriptPath, { encoding: 'utf-8' });
+        const rl = createInterface({ input: stream, crlfDelay: Infinity });
+        const lines = [];
+        for await (const line of rl) {
+            if (line)
+                lines.push(line);
+            if (lines.length > tailLines)
+                lines.shift();
+        }
+        rl.close();
+        stream.close();
+        if (lines.length === 0)
+            return notFound;
+        // 각 라인의 content/text/message 필드를 합쳐 regex 적용
+        const combined = lines
+            .map((line) => {
+            try {
+                const obj = JSON.parse(line);
+                const parts = [];
+                if (typeof obj.content === 'string')
+                    parts.push(obj.content);
+                if (typeof obj.text === 'string')
+                    parts.push(obj.text);
+                if (typeof obj.message === 'string')
+                    parts.push(obj.message);
+                // content 가 배열인 경우 (Claude JSONL block format)
+                if (Array.isArray(obj.content)) {
+                    for (const block of obj.content) {
+                        if (block && typeof block.text === 'string') {
+                            parts.push(block.text);
+                        }
+                    }
+                }
+                return parts.join(' ');
+            }
+            catch {
+                return '';
+            }
+        })
+            .join(' ');
+        if (!RATE_LIMIT_REGEX.test(combined))
+            return notFound;
+        const resetAt = parseRateLimitResetAt(combined);
+        return { matched: true, resetAt };
+    }
+    catch {
+        return notFound;
+    }
+}
 /** Claude Code를 하네스 환경으로 실행. exit code를 반환. */
 export async function spawnClaude(args, context, runtime = 'claude') {
     const launcher = findRuntimeLauncher(runtime);
@@ -235,7 +387,32 @@ export async function spawnClaude(args, context, runtime = 'claude') {
                     }
                     // 1. FTS5 인덱싱 — v0.4.8 (A1) 부터 Claude/Codex 모두 지원.
                     await indexTranscriptToFTS(context.cwd, transcript, sessionId, runtime);
-                    // 2. 자동 compound (10+ user 메시지인 경우만) — 양 runtime 호환
+                    // 2. Plan B-1: transcript 사후 스캔으로 rate-limit 감지 (hook 미감지 보완)
+                    const resumePath = path.join(STATE_DIR, 'pending-resume.json');
+                    if (!fs.existsSync(resumePath)) {
+                        try {
+                            const scanResult = await scanTranscriptForRateLimit(transcript);
+                            if (scanResult.matched) {
+                                const marker = {
+                                    reason: 'rate-limit',
+                                    sessionId,
+                                    runtime,
+                                    resetAt: scanResult.resetAt,
+                                    savedAt: new Date().toISOString(),
+                                    cwd: context.cwd,
+                                    source: 'spawn-transcript-scan',
+                                };
+                                fs.writeFileSync(resumePath, JSON.stringify(marker, null, 2));
+                                log.debug(`transcript scan: rate-limit 감지 → pending-resume.json 작성`);
+                            }
+                        }
+                        catch (e) {
+                            log.debug('transcript rate-limit scan 실패 (fail-open)', e);
+                        }
+                    }
+                    // 3. Observability P2: commit-diff acted_on scan
+                    await scanCommitDiffForActedOn(sessionId, context.cwd, sessionStartTime);
+                    // 4. 자동 compound (10+ user 메시지인 경우만) — 양 runtime 호환
                     const userMsgCount = await countUserMessages(transcript);
                     if (userMsgCount >= 10) {
                         await runAutoCompound(context.cwd, transcript, sessionId);

package/dist/core/statusline-cli.js

@@ -17,6 +17,7 @@ import { execSync } from 'node:child_process';
 import { loadActiveRules } from '../store/rule-store.js';
 import { getUsageStats } from './usage-telemetry.js';
 import { STATE_DIR } from './paths.js';
+import { classifySolutions } from './lifecycle-classifier.js';
 // 0.4.6 perf #13 — statusline 출력을 5초 캐싱.
 // claude statusLine 은 짧은 간격으로 재호출되는데 매번 git/find/rule-store 를
 // 실행하면 ~100ms 누적. CACHE_TTL_MS 동안 동일 출력 재사용.
@@ -123,6 +124,30 @@ function buildLine1(payload, cwd) {
         parts.push(`${GREEN}${gitBranch}${RESET}`);
     return parts.join(`  ${DIM}|${RESET}  `);
 }
+/** Build lifecycle line: "🔥X 🟡X 🥶X 💀X 🌱X" — P3 신설. 0건이면 null */
+function buildLifecycleLine() {
+    try {
+        const classified = classifySolutions();
+        if (classified.length === 0)
+            return null;
+        const counts = { hot: 0, warm: 0, cold: 0, dead: 0, new: 0 };
+        for (const c of classified)
+            counts[c.lifecycle]++;
+        const total = counts.hot + counts.warm + counts.cold + counts.dead + counts.new;
+        if (total === 0)
+            return null;
+        return [
+            `${YELLOW}🔥${counts.hot}${RESET}`,
+            `${YELLOW}🟡${counts.warm}${RESET}`,
+            `${DIM}🥶${counts.cold}${RESET}`,
+            `${DIM}💀${counts.dead}${RESET}`,
+            `${DIM}🌱${counts.new}${RESET}`,
+        ].join(`  `);
+    }
+    catch {
+        return null;
+    }
+}
 /** Build usage line: "📊 87/5h · 412/wk (claude)" — 0.4.6 신설 */
 function buildUsageLine() {
     try {
@@ -193,6 +218,7 @@ export async function handleStatusline() {
     const line1 = buildLine1(payload, cwd);
     const line3 = buildLine3(claudeDir, cwd);
     const usageLine = buildUsageLine();
+    const lifecycleLine = buildLifecycleLine();
     // Line 2 (context/usage): stdin JSON spec 미확인으로 생략 — TODO
     // Line 4 (tool counts): 추적 인프라 없음 — TODO
     // Line 5 (active task): 추적 인프라 없음 — TODO
@@ -200,6 +226,13 @@ export async function handleStatusline() {
     console.log(line3);
     if (usageLine)
         console.log(usageLine);
-    const cacheBody = usageLine ? `${line1}\n${line3}\n${usageLine}\n` : `${line1}\n${line3}\n`;
+    if (lifecycleLine)
+        console.log(lifecycleLine);
+    const cacheLines = [line1, line3];
+    if (usageLine)
+        cacheLines.push(usageLine);
+    if (lifecycleLine)
+        cacheLines.push(lifecycleLine);
+    const cacheBody = cacheLines.join('\n') + '\n';
     writeCache(cacheBody);
 }

package/dist/engine/compound-extractor.js

@@ -21,6 +21,7 @@ import { execFileSync } from 'node:child_process';
 import { execHost } from '../host/exec-host.js';
 import { serializeSolutionV3, DEFAULT_EVIDENCE, extractTags } from './solution-format.js';
 import { createLogger } from '../core/logger.js';
+import { emitSolutionEvent } from '../core/observability-store.js';
 const log = createLogger('compound-extractor');
 import { CLAUDE_DIR, ME_SOLUTIONS, STATE_DIR } from '../core/paths.js';
 import { atomicWriteJSON, atomicWriteText } from '../hooks/shared/atomic-write.js';
@@ -845,6 +846,42 @@ export async function runExtraction(cwd, sessionId) {
     }
     return result;
 }
+/**
+ * Observability P2: 새 솔루션 본문/supersedes 에서 기존 솔루션 참조 감지 → acted_on emit.
+ * fail-open.
+ */
+function emitCompoundExtractActedOn(sessionId, newSolutionName, newContent, newSupersedes) {
+    try {
+        if (!fs.existsSync(ME_SOLUTIONS))
+            return;
+        const bodyLower = newContent.toLowerCase();
+        const supersedes = newSupersedes ?? '';
+        const files = fs.readdirSync(ME_SOLUTIONS).filter(f => f.endsWith('.md'));
+        for (const file of files) {
+            const existingName = path.basename(file, '.md');
+            if (existingName === newSolutionName)
+                continue;
+            const referenced = (supersedes && existingName === supersedes)
+                || bodyLower.includes(existingName.toLowerCase());
+            if (!referenced)
+                continue;
+            emitSolutionEvent({
+                sessionId,
+                solutionId: existingName,
+                eventType: 'acted_on',
+                signalSource: 'compound-extract',
+                signalScore: 0.20,
+                meta: {
+                    new_solution: newSolutionName,
+                    via: (supersedes && existingName === supersedes) ? 'supersedes' : 'body-mention',
+                },
+            });
+        }
+    }
+    catch (e) {
+        log.debug('emitCompoundExtractActedOn 실패', e);
+    }
+}
 /** Process LLM extraction results (called after LLM returns) */
 export function processExtractionResults(rawJson, sessionId) {
     const saved = [];
@@ -882,6 +919,8 @@ export function processExtractionResults(rawJson, sessionId) {
         const savedName = saveExtractedSolution(sol, sessionId);
         if (savedName) {
             saved.push(savedName);
+            // Observability P2: compound-extract acted_on signal
+            emitCompoundExtractActedOn(sessionId, savedName, sol.content, null);
         }
         else {
             skipped.push(`${sol.name}: 파일 이미 존재`);

package/dist/engine/compound-loop.js

@@ -332,6 +332,12 @@ export async function handleCompound(args) {
         rollbackSolutions(since, { dryRun });
         return;
     }
+    // --- retire command (P3: dead 솔루션 archive) ---
+    if (args.includes('retire') || args.includes('--retire')) {
+        const { handleCompoundRetire } = await import('./compound-retire.js');
+        await handleCompoundRetire(args);
+        return;
+    }
     // --- explicit interactive command ---
     if (args.includes('interactive') || args.includes('--interactive')) {
         await interactiveCompound(cwd, scope);

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

@@ -0,0 +1,20 @@
+/**
+ * Forgen — Compound Retire (P3)
+ *
+ * `forgen compound retire [--dry-run] [--apply]`
+ *
+ * dead 분류 솔루션을 ~/ .forgen/lab/archived/<id>.md 로 이동.
+ * 기본은 dry-run (목록만 출력). --apply 시 사용자 확인 후 이동.
+ */
+export interface RetireResult {
+    retired: string[];
+    skipped: string[];
+    dryRun: boolean;
+}
+/** dead 솔루션을 lab/archived/ 로 이동 */
+export declare function retireDeadSolutions(opts: {
+    dryRun: boolean;
+    yes?: boolean;
+}): Promise<RetireResult>;
+/** CLI 핸들러: forgen compound retire */
+export declare function handleCompoundRetire(args: string[]): Promise<void>;

package/dist/engine/compound-retire.js

@@ -0,0 +1,85 @@
+/**
+ * Forgen — Compound Retire (P3)
+ *
+ * `forgen compound retire [--dry-run] [--apply]`
+ *
+ * dead 분류 솔루션을 ~/ .forgen/lab/archived/<id>.md 로 이동.
+ * 기본은 dry-run (목록만 출력). --apply 시 사용자 확인 후 이동.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as readline from 'node:readline';
+import { ME_SOLUTIONS, ARCHIVED_DIR } from '../core/paths.js';
+import { classifySolutions } from '../core/lifecycle-classifier.js';
+function promptConfirm(question) {
+    return new Promise(resolve => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(question, answer => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === 'y' || answer.trim().toLowerCase() === 'yes');
+        });
+    });
+}
+/** dead 솔루션을 lab/archived/ 로 이동 */
+export async function retireDeadSolutions(opts) {
+    const classified = classifySolutions();
+    const dead = classified.filter(c => c.lifecycle === 'dead');
+    const retired = [];
+    const skipped = [];
+    if (dead.length === 0) {
+        return { retired: [], skipped: [], dryRun: opts.dryRun };
+    }
+    // dry-run or apply 출력
+    console.log(`\n  Dead solutions (${dead.length}):\n`);
+    for (const d of dead) {
+        const dest = path.join(ARCHIVED_DIR, `${d.solutionId}.md`);
+        console.log(`    ${d.solutionId}`);
+        console.log(`      matched_180d=${d.matched_180d}  age=${d.ageDays}d`);
+        console.log(`      → ${dest}`);
+    }
+    console.log();
+    if (opts.dryRun) {
+        console.log('  [dry-run] 파일 이동 없음. --apply 로 실행하세요.\n');
+        return { retired: dead.map(d => d.solutionId), skipped: [], dryRun: true };
+    }
+    // apply — 확인 프롬프트
+    if (!opts.yes) {
+        const ok = await promptConfirm(`  ${dead.length}개 솔루션을 archived 로 이동합니다. 계속하시겠습니까? (y/N) `);
+        if (!ok) {
+            console.log('  취소되었습니다.\n');
+            return { retired: [], skipped: dead.map(d => d.solutionId), dryRun: false };
+        }
+    }
+    // mkdir + rename (fail-stop: 오류 시 즉시 throw)
+    fs.mkdirSync(ARCHIVED_DIR, { recursive: true });
+    for (const d of dead) {
+        const src = path.join(ME_SOLUTIONS, `${d.solutionId}.md`);
+        const dest = path.join(ARCHIVED_DIR, `${d.solutionId}.md`);
+        // 이미 archived 인 경우 skip
+        if (fs.existsSync(dest)) {
+            skipped.push(d.solutionId);
+            continue;
+        }
+        // src 없으면 skip
+        if (!fs.existsSync(src)) {
+            skipped.push(d.solutionId);
+            continue;
+        }
+        // fail-stop: rename 실패 시 throw (데이터 이동 정확성 우선)
+        fs.renameSync(src, dest);
+        retired.push(d.solutionId);
+    }
+    console.log(`  ✓ ${retired.length}개 이동 완료`);
+    if (skipped.length > 0) {
+        console.log(`  ○ ${skipped.length}개 skip (이미 archived 또는 파일 없음)`);
+    }
+    console.log();
+    return { retired, skipped, dryRun: false };
+}
+/** CLI 핸들러: forgen compound retire */
+export async function handleCompoundRetire(args) {
+    const apply = args.includes('--apply');
+    const yes = args.includes('--yes');
+    const dryRun = !apply;
+    await retireDeadSolutions({ dryRun, yes });
+}

package/dist/hooks/context-guard.js

@@ -29,7 +29,7 @@ const PROMPT_HISTORY_TRUNCATE = 1024; // ADR-008: 1KB cap per entry
 const RATE_LIMIT_MISSES_PATH = path.join(STATE_DIR, 'rate-limit-misses.jsonl');
 // ADR-008: detection regex 분리. token-limit 은 context window, rate-limit 은 API quota.
 export const TOKEN_LIMIT_REGEX = /context.*limit|token.*limit|conversation.*too.*long/i;
-export const RATE_LIMIT_REGEX = /rate.?limit|5.?hour.*limit|weekly.*limit|usage.*limit|quota.*exceeded/i;
+export const RATE_LIMIT_REGEX = /rate.?limit|5.?hour.*limit|weekly.*limit|usage.*limit|quota.*exceeded|out of (?:extra |free )?usage|usage cap|monthly limit reached?/i;
 /**
  * Best-effort reset 시각 파서 (ADR-008 §2).
  *
@@ -64,6 +64,30 @@ export function parseRateLimitResetAt(msg, now = Date.now()) {
         if (sec > 0)
             return new Date(now + sec * 1000).toISOString();
     }
+    // Pattern 5: "resets <H>:<MM><am|pm>" (12h, optional "at", optional TZ label in parens)
+    // Pattern 1보다 앞에 위치: "resets at 4:20 pm" 에서 Pattern 1이 am/pm 없이 잡으면
+    // 24h 로 오변환되므로 am/pm 있는 경우를 먼저 처리.
+    // 예: "resets 4:20pm", "resets 4:20pm (Asia/Seoul)", "resets at 4:20 pm"
+    const ampm = msg.match(/resets?\s+(?:at\s+)?(\d{1,2}):(\d{2})\s*(am|pm)/i);
+    if (ampm) {
+        let h = parseInt(ampm[1], 10);
+        const m = parseInt(ampm[2], 10);
+        const meridiem = ampm[3].toLowerCase();
+        if (h >= 1 && h <= 12 && m >= 0 && m <= 59) {
+            // 12h → 24h 변환: 12am=0, 12pm=12, 1-11am=1-11, 1-11pm=13-23
+            if (meridiem === 'am') {
+                h = h === 12 ? 0 : h;
+            }
+            else {
+                h = h === 12 ? 12 : h + 12;
+            }
+            const d = new Date(now);
+            d.setUTCHours(h, m, 0, 0);
+            if (d.getTime() <= now)
+                d.setUTCDate(d.getUTCDate() + 1);
+            return d.toISOString();
+        }
+    }
     // Pattern 1: "Resets at HH:MM(:SS)? TZ" — TZ 미지원 (UTC 가정)
     const hhmm = msg.match(/(?:reset|retry|available)s?\s+at\s+(\d{1,2}):(\d{2})(?::(\d{2}))?\s*(UTC|GMT|PST|PDT|EST|EDT|KST|JST)?/i);
     if (hhmm) {

package/dist/hooks/post-tool-use.js

@@ -22,6 +22,9 @@ import { recordHookTiming } from './shared/hook-timing.js';
 import { createDriftState, evaluateDrift } from '../core/drift-score.js';
 import { appendImplicitFeedback } from '../store/implicit-feedback-store.js';
 import { recordToolCall } from '../core/usage-telemetry.js';
+import { emitSolutionEvent, querySurfacedWithin } from '../core/observability-store.js';
+import { parseSolutionV3 } from '../engine/solution-format.js';
+import { ME_SOLUTIONS } from '../core/paths.js';
 const RECENT_TOOL_NAMES_WINDOW = 20;
 /** Lightweight hash for content comparison (not cryptographic) */
 function simpleHash(content) {
@@ -338,6 +341,51 @@ async function main() {
         catch (e) {
             log.debug('success hint generation 실패', e);
         }
+        // 8. Observability P2: tool-pattern acted_on signal
+        try {
+            const recentSurfaces = querySurfacedWithin(sessionId, 5);
+            if (recentSurfaces.length > 0 && toolName) {
+                const toolNameLower = toolName.toLowerCase();
+                const seen = new Set();
+                for (const surf of recentSurfaces) {
+                    if (seen.has(surf.solutionId))
+                        continue;
+                    seen.add(surf.solutionId);
+                    const filePath = path.join(ME_SOLUTIONS, `${surf.solutionId}.md`);
+                    if (!fs.existsSync(filePath))
+                        continue;
+                    let raw;
+                    try {
+                        raw = fs.readFileSync(filePath, 'utf-8');
+                    }
+                    catch {
+                        continue;
+                    }
+                    const sol = parseSolutionV3(raw);
+                    if (!sol)
+                        continue;
+                    const tags = sol.frontmatter.tags ?? [];
+                    const identifiers = sol.frontmatter.identifiers ?? [];
+                    if (tags.length === 0 && identifiers.length === 0)
+                        continue;
+                    const hit = tags.some(t => toolNameLower.includes(t.toLowerCase()))
+                        || identifiers.some(id => toolNameLower.includes(id.toLowerCase()));
+                    if (!hit)
+                        continue;
+                    emitSolutionEvent({
+                        sessionId,
+                        solutionId: surf.solutionId,
+                        eventType: 'acted_on',
+                        signalSource: 'tool-pattern',
+                        signalScore: 0.30,
+                        meta: { tool: toolName, surface_ts: surf.ts },
+                    });
+                }
+            }
+        }
+        catch (e) {
+            log.debug('tool-pattern acted_on emit 실패', e);
+        }
         saveModifiedFiles(modState);
         if (messages.length > 0) {
             console.log(approveWithWarning(messages.join('\n')));