@wooojin/forgen 0.4.12 → 0.5.0

package/dist/core/compound-sweep-cli.js

@@ -0,0 +1,354 @@
+/**
+ * forgen compound-sweep — 시간-기반 compound backstop (ADR-011).
+ *
+ * 이벤트 훅(Stop/PreCompact)이 fast path 라면, 이 sweep 는 **보장**이다:
+ * 최근 수정된 Claude transcript 중 세션별로 오래(stale) compound 안 된 것을 쓸어담아
+ * auto-compound-runner 를 돌린다. 세션 경계(재시작)에 의존하는 기존 backstop 의 갭
+ * (재시작 않는 긴 세션 유실)을 시간-트리거로 메운다. cron(시간당 권장)에서 호출.
+ *
+ * 순수 선택 로직(selectSweepCandidates)과 IO(runCompoundSweep) 분리 — 전자는 테스트 가능.
+ * 멱등·fail-open: 실패해도 세션은 다음 sweep 에서 재시도.
+ */
+import { execFileSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { STATE_DIR } from './paths.js';
+import { runAutoCompound } from './spawn.js';
+import { createLogger } from './logger.js';
+const log = createLogger('compound-sweep');
+export const DEFAULT_SWEEP_OPTS = {
+    windowMs: 24 * 60 * 60 * 1000,
+    staleMs: 2 * 60 * 60 * 1000,
+    minPrompts: 10,
+    maxPerRun: 5,
+};
+/**
+ * 순수 선택: 최근·충분한 대화·stale(오래 안 쓸린) 세션을, oldest-swept 우선으로 maxPerRun 만큼.
+ */
+export function selectSweepCandidates(transcripts, sweepState, opts) {
+    return transcripts
+        .filter((t) => opts.nowMs - t.mtimeMs <= opts.windowMs)
+        .filter((t) => t.promptCount >= opts.minPrompts)
+        .filter((t) => {
+        const s = sweepState[t.sessionId];
+        return !s || opts.nowMs - s.sweptAt >= opts.staleMs;
+    })
+        .sort((a, b) => (sweepState[a.sessionId]?.sweptAt ?? 0) - (sweepState[b.sessionId]?.sweptAt ?? 0))
+        .slice(0, Math.max(0, opts.maxPerRun));
+}
+function claudeProjectsDir() {
+    const base = process.env.CLAUDE_CONFIG_DIR
+        ? process.env.CLAUDE_CONFIG_DIR
+        : path.join(os.homedir(), '.claude');
+    return path.join(base, 'projects');
+}
+/** user 턴 판정 — tool_result 캐리어(type:'user'지만 content 가 tool_result)는 제외.
+ *  (리뷰 SEV-2: tool_result 가 promptCount 를 3~5배 부풀려 ≥10 게이트를 무력화). */
+function isRealUserTurn(e) {
+    if (e.type !== 'user' && e.role !== 'user' && e.message?.role !== 'user')
+        return false;
+    const content = e.message?.content;
+    if (Array.isArray(content) && content.some((c) => c?.type === 'tool_result')) {
+        return false; // 도구 결과 반환 — 실제 사용자 프롬프트 아님
+    }
+    return true;
+}
+/** transcript 에서 cwd + 실제 user 프롬프트 수 추출. cwd 는 라인의 cwd 필드 우선, 없으면 dir 명 역산. */
+function readTranscriptMeta(transcriptPath, projectDirName) {
+    let cwd = projectDirName.replace(/-/g, '/'); // fallback: sanitized dir → cwd (lossy, cwd 필드 없을 때만)
+    let promptCount = 0;
+    try {
+        const lines = fs.readFileSync(transcriptPath, 'utf-8').split('\n');
+        let cwdFound = false;
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const e = JSON.parse(line);
+                if (!cwdFound && typeof e.cwd === 'string' && e.cwd) {
+                    cwd = e.cwd;
+                    cwdFound = true;
+                }
+                if (isRealUserTurn(e))
+                    promptCount += 1;
+            }
+            catch {
+                /* skip malformed line */
+            }
+        }
+    }
+    catch {
+        /* unreadable — leave defaults */
+    }
+    return { cwd, promptCount };
+}
+/** Claude projects 하위의 최근 transcript 를 열거해 메타 구성. */
+export function enumerateTranscripts(windowMs, nowMs) {
+    const root = claudeProjectsDir();
+    let projDirs;
+    try {
+        projDirs = fs.readdirSync(root);
+    }
+    catch {
+        return []; // root 없음/접근불가 — fail-open
+    }
+    const out = [];
+    for (const projDir of projDirs) {
+        const abs = path.join(root, projDir);
+        let files;
+        try {
+            if (!fs.statSync(abs).isDirectory())
+                continue;
+            files = fs.readdirSync(abs).filter((f) => f.endsWith('.jsonl'));
+        }
+        catch {
+            continue;
+        }
+        for (const f of files) {
+            const fp = path.join(abs, f);
+            let mtimeMs;
+            try {
+                mtimeMs = fs.statSync(fp).mtimeMs;
+            }
+            catch {
+                continue;
+            }
+            if (nowMs - mtimeMs > windowMs)
+                continue; // 창 밖은 파싱 비용도 아낌
+            const { cwd, promptCount } = readTranscriptMeta(fp, projDir);
+            out.push({ sessionId: f.replace(/\.jsonl$/, ''), transcriptPath: fp, cwd, mtimeMs, promptCount });
+        }
+    }
+    return out;
+}
+function loadSweepState() {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(STATE_DIR, 'compound-sweep-state.json'), 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+/** sweep-state 저장. 실패 시 true 반환(호출측이 무인 재과금 위험을 경고). */
+function saveSweepState(state) {
+    try {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        fs.writeFileSync(path.join(STATE_DIR, 'compound-sweep-state.json'), JSON.stringify(state, null, 2));
+        return true;
+    }
+    catch (e) {
+        log.debug('sweep-state 저장 실패', e);
+        return false;
+    }
+}
+/** window 밖으로 사라진 세션 엔트리 정리 (무한 증가 방지, 리뷰 SEV-3). */
+function pruneSweepState(state, liveSessionIds, nowMs, windowMs) {
+    for (const sid of Object.keys(state)) {
+        if (!liveSessionIds.has(sid) && nowMs - state[sid].sweptAt > windowMs)
+            delete state[sid];
+    }
+}
+/**
+ * cron/CLI 진입점. dryRun 이면 실행 없이 후보만 보고.
+ * 무인 실행 안전장치: (1) 동시 실행 lock, (2) 실제 spawn('spawned') 만 sweptAt 기록,
+ * (3) state 저장 실패 시 경고 플래그.
+ */
+export function runCompoundSweep(opts = {}) {
+    const nowMs = Date.now();
+    const full = { nowMs, ...DEFAULT_SWEEP_OPTS, ...opts };
+    // 동시 cron fire 겹침 방지 (리뷰 SEV-3): stale(>1h) lock 은 무시.
+    const lockPath = path.join(STATE_DIR, 'compound-sweep.lock');
+    if (!opts.dryRun) {
+        try {
+            const raw = fs.readFileSync(lockPath, 'utf-8');
+            const { at } = JSON.parse(raw);
+            if (Number.isFinite(at) && nowMs - at < 60 * 60 * 1000) {
+                return { scanned: 0, eligible: 0, swept: [] }; // 다른 sweep 진행 중
+            }
+        }
+        catch {
+            /* lock 없음/손상 — 진행 */
+        }
+        try {
+            fs.mkdirSync(STATE_DIR, { recursive: true });
+            fs.writeFileSync(lockPath, JSON.stringify({ at: nowMs, pid: process.pid }));
+        }
+        catch {
+            /* lock 기록 실패 — 진행(단일 실행 가정) */
+        }
+    }
+    try {
+        const transcripts = enumerateTranscripts(full.windowMs, nowMs);
+        const state = loadSweepState();
+        const candidates = selectSweepCandidates(transcripts, state, full);
+        const swept = [];
+        for (const c of candidates) {
+            if (opts.dryRun) {
+                swept.push(c.sessionId);
+                continue;
+            }
+            // 실제 spawn 된 경우만 sweptAt 기록 (리뷰 SEV-2: dedup-skip/실패를 완료로 오기록 금지).
+            const status = runAutoCompound(c.cwd, c.transcriptPath, c.sessionId, c.promptCount);
+            if (status === 'spawned') {
+                state[c.sessionId] = { sweptAt: nowMs };
+                swept.push(c.sessionId);
+            }
+        }
+        let stateSaveFailed = false;
+        if (!opts.dryRun) {
+            pruneSweepState(state, new Set(transcripts.map((t) => t.sessionId)), nowMs, full.windowMs);
+            stateSaveFailed = !saveSweepState(state);
+        }
+        return { scanned: transcripts.length, eligible: candidates.length, swept, stateSaveFailed };
+    }
+    catch (e) {
+        log.debug('compound-sweep 실행 실패 (fail-open)', e);
+        return { scanned: 0, eligible: 0, swept: [] };
+    }
+    finally {
+        if (!opts.dryRun)
+            fs.rmSync(lockPath, { force: true });
+    }
+}
+// ── cron 자동설치 (ADR-011 §Consequences) ────────────────────────────────────
+const CRON_MARKER = '# forgen-compound-sweep (ADR-011)';
+const CRON_SCHEDULE = '17 * * * *'; // 매시 17분 — 정각 몰림 회피
+/** cron 은 각 라인을 /bin/sh 로 실행 → 공백/메타문자 경로가 word-split/injection 되지 않게 single-quote. */
+function shq(s) {
+    return `'${s.replace(/'/g, "'\\''")}'`;
+}
+/** crontab 라인 구성 (순수 — 테스트 가능). 경로는 shell-quote(리뷰 SEV-2). */
+export function buildCronLine(nodePath, cliPath, logPath, schedule = CRON_SCHEDULE) {
+    return `${schedule} ${shq(nodePath)} ${shq(cliPath)} compound sweep >> ${shq(logPath)} 2>&1 ${CRON_MARKER}`;
+}
+/** 기존 crontab 에서 forgen 라인을 upsert/제거 (순수 — 테스트 가능). */
+export function upsertCronText(existing, line) {
+    const kept = existing
+        .split('\n')
+        .filter((l) => l.trim() && !l.includes(CRON_MARKER));
+    if (line)
+        kept.push(line);
+    return `${kept.join('\n')}\n`;
+}
+/**
+ * 현재 crontab 읽기. 리뷰 SEV-1: `crontab -l` 실패를 무조건 ''(빈 crontab)로 취급하면
+ * 일시적 read 실패 시 기존 사용자 job 전체를 덮어써 파괴한다. "no crontab" 만 ''로 보고,
+ * 그 외 실 오류는 throw 하여 install/uninstall 이 **쓰지 않고 중단**하게 한다.
+ */
+function readCrontab() {
+    try {
+        return execFileSync('crontab', ['-l'], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'] });
+    }
+    catch (e) {
+        const err = e;
+        const stderr = String(err.stderr ?? '');
+        // "no crontab for <user>" = 정상적으로 비어있음 → '' (생성 안전).
+        if (/no crontab for/i.test(stderr))
+            return '';
+        // 그 외(권한/일시장애 등)는 알 수 없음 → 파괴적 쓰기 방지 위해 throw.
+        throw new Error(`crontab -l 실패 (기존 job 보호 위해 중단): ${stderr.trim() || e.message}`);
+    }
+}
+function distCliPath() {
+    // 이 파일 = dist/core/compound-sweep-cli.js → dist/cli.js
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'cli.js');
+}
+export function installCron() {
+    const nodePath = process.execPath;
+    const cliPath = distCliPath();
+    const logPath = path.join(STATE_DIR, 'compound-sweep.log');
+    const line = buildCronLine(nodePath, cliPath, logPath);
+    if (process.platform === 'win32') {
+        return {
+            ok: false,
+            message: 'Windows 는 crontab 미지원 — Task Scheduler 에 시간당 작업을 수동 등록하세요:\n' +
+                `  프로그램: ${nodePath}\n  인수: "${cliPath}" compound sweep`,
+        };
+    }
+    let existing;
+    try {
+        existing = readCrontab(); // read 실패(‘no crontab’ 제외) 시 throw → 아래서 중단
+    }
+    catch (e) {
+        return { ok: false, message: `${e.message}\n수동 등록: crontab -e 에 아래 추가:\n  ${line}` };
+    }
+    try {
+        execFileSync('crontab', ['-'], { input: upsertCronText(existing, line), encoding: 'utf-8' });
+        return { ok: true, message: `compound sweep cron 설치됨 (매시 17분):\n  ${line}` };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            message: `crontab 쓰기 실패: ${e.message}\n수동 등록: crontab -e 에 아래 추가:\n  ${line}`,
+        };
+    }
+}
+export function uninstallCron() {
+    if (process.platform === 'win32')
+        return { ok: false, message: 'Windows: Task Scheduler 에서 수동 제거하세요.' };
+    let existing;
+    try {
+        existing = readCrontab();
+    }
+    catch (e) {
+        return { ok: false, message: `${e.message} (제거 중단 — 기존 crontab 보호)` };
+    }
+    if (!existing.includes(CRON_MARKER))
+        return { ok: true, message: 'compound sweep cron 없음 (이미 미설치).' };
+    try {
+        execFileSync('crontab', ['-'], { input: upsertCronText(existing, null), encoding: 'utf-8' });
+        return { ok: true, message: 'compound sweep cron 제거됨.' };
+    }
+    catch (e) {
+        return { ok: false, message: `crontab 쓰기 실패: ${e.message}` };
+    }
+}
+export function cronStatus() {
+    if (process.platform === 'win32')
+        return { ok: false, message: 'Windows: Task Scheduler 확인.' };
+    try {
+        return readCrontab().includes(CRON_MARKER)
+            ? { ok: true, message: '설치됨 (매시 17분).' }
+            : { ok: false, message: '미설치. `forgen compound sweep --install-cron` 로 설치.' };
+    }
+    catch (e) {
+        return { ok: false, message: e.message };
+    }
+}
+/** CLI: forgen compound sweep [--dry-run|--install-cron|--uninstall-cron|--cron-status] [--window-hours N] [--stale-hours M] */
+export function compoundSweepCli(args) {
+    // cron 관리 플래그 (상호배타 — 우선 처리)
+    if (args.includes('--install-cron')) {
+        const r = installCron();
+        console.log(`[forgen compound sweep] ${r.message}`);
+        return;
+    }
+    if (args.includes('--uninstall-cron')) {
+        console.log(`[forgen compound sweep] ${uninstallCron().message}`);
+        return;
+    }
+    if (args.includes('--cron-status')) {
+        console.log(`[forgen compound sweep] cron: ${cronStatus().message}`);
+        return;
+    }
+    const dryRun = args.includes('--dry-run');
+    const num = (flag) => {
+        const i = args.indexOf(flag);
+        return i >= 0 && args[i + 1] ? Number(args[i + 1]) : undefined;
+    };
+    const wh = num('--window-hours');
+    const sh = num('--stale-hours');
+    const r = runCompoundSweep({
+        dryRun,
+        ...(wh ? { windowMs: wh * 3600_000 } : {}),
+        ...(sh ? { staleMs: sh * 3600_000 } : {}),
+    });
+    console.log(`[forgen compound sweep] scanned=${r.scanned} eligible=${r.eligible} ` +
+        `${dryRun ? 'dry-run' : 'swept'}=${r.swept.length}${r.swept.length ? ` (${r.swept.map((s) => s.slice(0, 8)).join(', ')})` : ''}`);
+    if (r.stateSaveFailed) {
+        console.error('  ⚠ sweep-state 저장 실패 — 다음 cron 이 동일 세션을 재-compound 할 수 있음(Haiku 재과금). ' +
+            '~/.forgen/state 쓰기 권한을 확인하세요.');
+    }
+}

package/dist/core/config-injector.d.ts

@@ -8,11 +8,26 @@
  */
 import type { RuntimeHost } from './types.js';
 /** 보안 규칙 (정적 — v1 GLOBAL_SAFETY_RULES와 동일 맥락) */
+/**
+ * ADR-010 W2-3: 보안 규칙 prose → 2줄 포인터로 축약.
+ * 실제 강제는 훅(secret-filter, db-guard)이 결정적으로 수행하며,
+ * prose 는 순수 토큰 비용이었다 (native /doctor 도 "코드에서 유추 가능한
+ * 규칙"으로 트리밍 제안하는 부류). 차단 발생 시 확인: `forgen explain`.
+ */
 export declare function generateSecurityRules(): string;
-/** 안티패턴 감지 규칙 (정적) */
+/** ADR-010 W2-3: prose 제거 — 포인터는 generateSecurityRules 로 통합됨 */
 export declare function generateAntiPatternRules(): string;
 /** compound loop + 개인 규칙 (me/rules) 로드 */
 export declare function generateCompoundRules(cwd: string): string;
+/**
+ * ADR-010 W1-2: 캡처 사이드 공유 판정 — 첫 유효 라인이 Claude-voice 에코인가.
+ *
+ * auto-compound-runner 가 behavior 파일을 디스크에 쓰기 전에 호출한다.
+ * 렌더 타임 필터(위)만으로는 오염 데이터가 스토어에 계속 쌓이므로,
+ * 저장 자체를 차단하는 것이 우선이다. 판정은 첫 유효 라인 기준 —
+ * 에코는 항상 assistant 발화로 시작하고, 진짜 패턴 요약은 지시문으로 시작한다.
+ */
+export declare function isSelfReferentialEcho(text: string): boolean;
 /**
  * Strip formatting that already exists in the source line BEFORE the
  * renderer adds its own prefix/suffix. Without this, a behavior file

package/dist/core/config-injector.js

@@ -108,40 +108,24 @@ function loadProjectMapSummary(cwd) {
 }
 // ── v1 Static Rules ──
 /** 보안 규칙 (정적 — v1 GLOBAL_SAFETY_RULES와 동일 맥락) */
+/**
+ * ADR-010 W2-3: 보안 규칙 prose → 2줄 포인터로 축약.
+ * 실제 강제는 훅(secret-filter, db-guard)이 결정적으로 수행하며,
+ * prose 는 순수 토큰 비용이었다 (native /doctor 도 "코드에서 유추 가능한
+ * 규칙"으로 트리밍 제안하는 부류). 차단 발생 시 확인: `forgen explain`.
+ */
 export function generateSecurityRules() {
     return [
-        '# Forgen — Security Rules',
+        '# Forgen — Security & Anti-Pattern',
         '',
-        '## Dangerous Command Warning',
-        '- Always confirm before executing destructive commands like `rm -rf`, `git push --force`, `DROP TABLE`',
-        '- Double confirmation required for production environment access',
-        '',
-        '## Secret Key Protection',
-        '- Do not commit sensitive information such as `.env`, `credentials.json`, API keys',
-        '- Manage through environment variables or a secrets manager',
-        '- Detect hardcoded secrets during code review',
+        '- 보안/위험명령/안티패턴 강제는 forgen 훅이 수행: secret-filter(비밀키 커밋 차단), db-guard(위험 SQL/rm -rf 확인), slop-detector(AI 슬롭 감지).',
+        '- 차단이 발생하면 `forgen status --blocks` 로 규칙·사유·해결책 확인.',
         '',
     ].join('\n');
 }
-/** 안티패턴 감지 규칙 (정적) */
+/** ADR-010 W2-3: prose 제거 — 포인터는 generateSecurityRules 로 통합됨 */
 export function generateAntiPatternRules() {
-    return [
-        '# Forgen — Anti-Pattern Detection',
-        '',
-        '## Repeated Edit Warning',
-        '- Stop immediately when editing the same file 3+ times → full structure redesign required',
-        '- For 5+ edits, always check current state with Read before replacing with a single Write',
-        '',
-        '## Error Suppression Warning',
-        '- No empty catch blocks — at minimum log or re-throw',
-        '- Minimize suppression comments like eslint-disable, @ts-ignore',
-        '',
-        '## Excessive Complexity Warning',
-        '- Consider splitting single functions exceeding 50 lines',
-        '- Apply early return pattern when nesting depth exceeds 4',
-        '- No unnecessary abstraction — implement only what is currently needed',
-        '',
-    ].join('\n');
+    return '';
 }
 /** compound loop + 개인 규칙 (me/rules) 로드 */
 export function generateCompoundRules(cwd) {
@@ -230,11 +214,38 @@ const SELF_REFERENTIAL_PATTERNS = Object.freeze([
     /^I['\u2019]?ll\s+(analyze|review|check|update|add|create|run|fix)/i,
     /^Let me\s+(analyze|check|look|verify|update|add)/i,
     /^I['\u2019]?ve\s+(added|updated|created|fixed|completed)/i,
+    // ADR-010 W1-2 (2026-07-16): \uc2e4\uc720\ucd9c 60\uac74(behavior-echoes \ubc31\uc5c5 = fixture \uc18c\uc2a4)\uc5d0\uc11c
+    // \ud655\uc778\ub41c \ucd94\uac00 \uc5d0\ucf54 \ud615\ud0dc. \uc804\ubd80 line-start \uc575\ucee4 \u2014 H-2 \uc624\ud0d0 \uaddc\uce59 \uc900\uc218.
+    // \uc774 \ubaa9\ub85d\uc740 \ubcf4\uc870 \ubc29\uc5b4\ub2e4: \uc8fc\ub825\uc740 observedCount >= 2 \uac8c\uc774\ud2b8 (\uc544\ub798 \ub80c\ub354 \ub8e8\ud504).
+    /^I (see|notice|understand)\b/i,
+    /^I['\u2019]?m ready\b/i,
+    /^Understood\b/i,
+    /^Got it\b/i,
+    /^[\u26a0\u2705\u274c\u{1f534}\u{1f4cb}]/u, // \u26a0 \u2705 \u274c \ud83d\udd34 \ud83d\udccb \uc120\ub450 \u2014 assistant \uc0c1\ud0dc \ub9c8\ucee4
+    /^(\uc774\ud574\ud588\uc2b5\ub2c8\ub2e4|\uc54c\uaca0\uc2b5\ub2c8\ub2e4|\ud655\uc778\ud588\uc2b5\ub2c8\ub2e4|\ud655\uc778\ud558\uaca0\uc2b5\ub2c8\ub2e4|\ud30c\uc545\ud588\uc2b5\ub2c8\ub2e4)/,
+    // "\ud604\uc7ac \uc0c1\ud669"/"\uc900\ube44 \uc644\ub8cc"\ub294 Claude-voice \ubb38\uc7a5 \uc644\uacb0\ud615\ub9cc \ub9e4\uce58 \u2014 \uc0ac\uc6a9\uc790 \uc9c0\uc2dc\ubb38
+    // "\ud604\uc7ac \uc0c1\ud669 \ud30c\uc545 \ud6c4 \uc791\uc5c5 \uc2dc\uc791", "\uc900\ube44 \uc644\ub8cc\ub418\uba74 \uc54c\ub824\uc8fc\uc138\uc694"\ub294 \ud1b5\uacfc\ud574\uc57c \ud55c\ub2e4 (H-2).
+    /^(\uc791\uc5c5 \uc0c1\ud0dc\ub97c \ud655\uc778|\uc0c1\ud669\uc744 \ud30c\uc545\ud588|\uc548\ub155\ud558\uc138\uc694)/,
+    /^\ud604\uc7ac \uc0c1\ud669(:|\uc774|\uc740|\uc744 (\ud30c\uc545|\ud655\uc778|\uc815\ub9ac))/,
+    /^\uc900\ube44 \uc644\ub8cc(\uc785\ub2c8\ub2e4|\ud588\uc2b5\ub2c8\ub2e4|[.!])/,
+    /^\ubc31\uadf8\ub77c\uc6b4\ub4dc .*(\uc644\ub8cc|\uc911\ub2e8)/,
     // Object.freeze is defense-in-depth: the readonly type is compile-time
     // only. Freezing prevents runtime mutation by any other module loaded
     // in the same process from silently disabling the filter by pushing
     // an over-broad pattern or emptying the array.
 ]);
+/**
+ * ADR-010 W1-2: 캡처 사이드 공유 판정 — 첫 유효 라인이 Claude-voice 에코인가.
+ *
+ * auto-compound-runner 가 behavior 파일을 디스크에 쓰기 전에 호출한다.
+ * 렌더 타임 필터(위)만으로는 오염 데이터가 스토어에 계속 쌓이므로,
+ * 저장 자체를 차단하는 것이 우선이다. 판정은 첫 유효 라인 기준 —
+ * 에코는 항상 assistant 발화로 시작하고, 진짜 패턴 요약은 지시문으로 시작한다.
+ */
+export function isSelfReferentialEcho(text) {
+    const firstLine = text.split('\n').map((l) => l.trim()).find((l) => l.length > 0) ?? '';
+    return SELF_REFERENTIAL_PATTERNS.some((re) => re.test(firstLine));
+}
 /**
  * Strip formatting that already exists in the source line BEFORE the
  * renderer adds its own prefix/suffix. Without this, a behavior file
@@ -284,6 +295,14 @@ function generateBehavioralRules() {
             const countMatch = fm.match(/^observedCount:\s*(\d+)/m);
             const kind = kindMatch?.[1]?.trim().replace(/^["']|["']$/g, '') ?? '';
             const observedCount = countMatch ? parseInt(countMatch[1], 10) : 0;
+            // ADR-010 W1-2 주력 방어 — 1회 관찰 항목은 렌더하지 않는다 (모든 kind).
+            // 실측(2026-07-16): 오염된 behavior 엔트리 49/49(100%)가 observedCount=1.
+            // 진짜 사용자 패턴은 재관찰되어 mergeOrCreateBehavior 가 count 를 누적한다.
+            // 주의(정직한 한계): count 는 50% word-overlap merge 로도 오르므로, regex
+            // 3중 방어(캡처/렌더)를 모두 뚫는 novel echo 2건이 서로 merge 되면 이 게이트도
+            // 뚫린다 — 알려진 60건 형태는 캡처 사이드에서 차단되므로 잔존 리스크는 낮음.
+            if (observedCount < 2)
+                continue;
             const contentIdx = body.indexOf('## Content');
             const contentBody = contentIdx >= 0 ? body.slice(contentIdx + '## Content'.length) : body;
             const rawDesc = contentBody.split('\n').find(l => {
@@ -414,7 +433,7 @@ export function generateClaudeRules(cwd, v1RenderedRules) {
 export async function registerTmuxBindings() {
     const { execFileSync } = await import('node:child_process');
     try {
-        execFileSync('tmux', ['bind-key', 'T', 'run-shell', 'forgen me'], { stdio: 'ignore' });
+        execFileSync('tmux', ['bind-key', 'T', 'run-shell', 'forgen status --profile'], { stdio: 'ignore' });
     }
     catch (e) {
         log.debug('tmux 키바인딩 등��� 실패', e);

package/dist/core/dashboard-cli.js

@@ -7,6 +7,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { getUsageStats } from './usage-telemetry.js';
+import { loadRoiDemotions, isRoiQuarantined } from '../engine/roi-demotion.js';
 import { classifySolutions } from './lifecycle-classifier.js';
 import { STATE_DIR } from './paths.js';
 import { FORGEN_HOME } from './paths.js';
@@ -22,7 +23,7 @@ const C = {
     red: isTTY ? '\x1b[31m' : '',
 };
 const BOX_WIDTH = 66;
-function bar(pct, width = 10) {
+function _bar(pct, width = 10) {
     const filled = Math.round(pct * width);
     const empty = width - filled;
     return '█'.repeat(Math.max(0, filled)) + '░'.repeat(Math.max(0, empty));
@@ -47,13 +48,28 @@ function boxBottom() {
 }
 function collectData() {
     const now = new Date();
-    // usage
+    // usage (deprecated — W2-2): 과거 축적분만 읽힘, 신규 기록 없음
     const usage = (() => {
         try {
-            return getUsageStats();
+            return { ...getUsageStats(), deprecated: true };
         }
         catch {
-            return { hour5: { claude: 0, codex: 0, total: 0 }, week: { claude: 0, codex: 0, total: 0 } };
+            return { hour5: { claude: 0, codex: 0, total: 0 }, week: { claude: 0, codex: 0, total: 0 }, deprecated: true };
+        }
+    })();
+    // ROI 강등 (W3-1): surfaced-but-ignored top-5
+    const roiDemoted = (() => {
+        try {
+            return Object.values(loadRoiDemotions())
+                .sort((a, b) => b.surfaced - a.surfaced)
+                .slice(0, 5)
+                .map(e => ({
+                id: e.solutionId, surfaced: e.surfaced, actedOn: e.actedOn,
+                windowCount: e.windowCount, quarantined: isRoiQuarantined(e),
+            }));
+        }
+        catch {
+            return [];
         }
     })();
     // today extracted: me/solutions/*.md mtime이 오늘인 것 (또는 last-extraction.json)
@@ -137,6 +153,7 @@ function collectData() {
     return {
         timestamp: now.toISOString(),
         usage,
+        roiDemoted,
         todayExtracted,
         solutions: {
             total: classified.length,
@@ -152,16 +169,23 @@ function renderTTY(data) {
     const lines = [];
     lines.push(boxTop());
     lines.push(boxEmpty());
-    // Usage
+    // Usage — ADR-010 W2-2: recordToolCall no-op 이후 이 카운트는 영구 0 으로
+    // 수렴한다. 침묵 열화 대신 이관 안내를 표시 (JSON 은 deprecated 플래그).
     lines.push(boxLine(`${C.bold}Usage${C.reset}`));
-    const h5total = data.usage.hour5.total;
-    const h5pct = Math.min(1, h5total / Math.max(h5total + 10, 50));
-    const h5bar = bar(h5pct);
-    lines.push(boxLine(`  5h window:    ${C.yellow}${h5bar}${C.reset}  (${h5total} tool calls)`));
-    const wktotal = data.usage.week.total;
-    const wkpct = Math.min(1, wktotal / Math.max(wktotal + 10, 100));
-    const wkbar = bar(wkpct);
-    lines.push(boxLine(`  weekly:       ${C.yellow}${wkbar}${C.reset}  (${wktotal} tool calls)`));
+    lines.push(boxLine(`  ${C.dim}→ native /usage 로 이동 (plan limit 을 skill/subagent별 분해)${C.reset}`));
+    lines.push(boxEmpty());
+    // Surfaced-but-ignored (W3-1): 저 ROI 주입 top-5 — δ 는 injection 에서 오므로
+    // "노출되는데 안 쓰이는" 솔루션이 곧 낭비되는 컨텍스트다.
+    lines.push(boxLine(`${C.bold}Surfaced but ignored (low ROI)${C.reset}`));
+    if (data.roiDemoted.length === 0) {
+        lines.push(boxLine(`  ${C.dim}none — 주입되는 솔루션이 실제로 쓰이고 있음${C.reset}`));
+    }
+    else {
+        for (const e of data.roiDemoted) {
+            const mark = e.quarantined ? `${C.red}⛔ quarantined` : `${C.yellow}↓ demoted`;
+            lines.push(boxLine(`  ${mark}${C.reset} ${e.id}  (surfaced ${e.surfaced}, acted ${e.actedOn})`));
+        }
+    }
     lines.push(boxEmpty());
     // Today compound
     lines.push(boxLine(`${C.bold}Today's compound${C.reset}`));
@@ -181,7 +205,7 @@ function renderTTY(data) {
         lines.push(boxLine(`${C.bold}Top ${data.solutions.topHot.length} hot (90d)${C.reset}`));
         for (const h of data.solutions.topHot) {
             const pctStr = `${Math.round(h.rate * 100)}%`;
-            const idShort = h.id.length > 36 ? h.id.slice(0, 33) + '...' : h.id;
+            const idShort = h.id.length > 36 ? `${h.id.slice(0, 33)}...` : h.id;
             lines.push(boxLine(`  · ${C.yellow}${idShort}${C.reset}  surf=${h.surfaced} acted=${h.acted} (${pctStr})`));
         }
         lines.push(boxEmpty());
@@ -203,14 +227,14 @@ export async function runDashboard(opts) {
         if (opts.json) {
             // Strip classified array (verbose) from JSON output for cleaner schema
             const { solutions: { classified: _c, ...solutionStats }, ...rest } = data;
-            process.stdout.write(JSON.stringify({ ...rest, solutions: solutionStats }, null, 2) + '\n');
+            process.stdout.write(`${JSON.stringify({ ...rest, solutions: solutionStats }, null, 2)}\n`);
             return;
         }
         const output = renderTTY(data);
         if (opts.watch) {
             process.stdout.write('\x1b[2J\x1b[H'); // clear screen
         }
-        process.stdout.write(output + '\n');
+        process.stdout.write(`${output}\n`);
     };
     render();
     if (opts.watch) {

package/dist/core/dashboard.d.ts

@@ -96,18 +96,17 @@ export declare function collectMultiHostData(): MultiHostData;
 export interface LearningCurve {
     correctionsLast7d: number;
     correctionsPrev7d: number;
-    correctionTrend: 'improving' | 'stable' | 'worsening';
+    /** 교정 카운트 델타의 관찰 (인과 효과 아님 — down=count 감소일 뿐). */
+    correctionTrend: 'down' | 'flat' | 'up';
     evidenceTotalDays: number;
     sessionsAnalyzed: number;
-    estimatedMinutesSaved: number;
     topCorrectionAxes: Array<{
         axis: string;
         count: number;
     }>;
 }
 /**
- * Learning Curve 수집.
- * evidence 파일(교정 기록)과 compound 활용률을 교차 분석하여 "쓸수록 나아진다"를 정량화.
+ * 교정·활동 요약 수집 (관찰). evidence 파일(교정 기록) 기반. 인과 효과/절약은 미주장.
  */
 export declare function collectLearningCurve(): LearningCurve;
 export declare function renderDashboard(): string;