@wooojin/forgen 0.4.3 → 0.4.4

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://claude.ai/schemas/claude-plugin.json",
   "name": "forgen",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "Claude Code harness — the more you use Claude, the better it gets",
   "author": {
     "name": "jang-ujin",

package/CHANGELOG.md

@@ -5,6 +5,109 @@ All notable changes to forgen will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.4.4] — 2026-05-06
+
+### v0.4.4 — measurement infra rebuild + stop-guard hardening (DANGEROUS-RESPONSE)
+
+forgen-eval testbed 의 측정 인프라 5-layer 결함을 모두 수정해 신뢰성을 회복하고,
+그 과정에서 발견한 driver-brittleness 결함(syn-004 — small driver 가 학습된 룰을
+`find -exec rm -r` 같은 우회로 회피)을 stop-guard `dangerous-response-pattern`
+체크로 직접 close. 사후 N=10 재측정에서 **ψ master gate PASS** (mean +0.098, 95%
+CI [+0.002, +0.222]) — pre-hardening (-0.028) 대비 부호 양수 전환. 또한
+δ(forgenOnly−vanilla) = +0.223 (CI [+0.134, +0.326], 10/10 cases positive) 으로
+forgen 효과가 robust 하게 확인됨.
+
+**Highlights**:
+
+- **DANGEROUS-RESPONSE 응답 텍스트 가드** (`feat`)
+  - `src/checks/dangerous-response-pattern.ts` + `tests/dangerous-response-pattern.test.ts` (12 케이스)
+  - `src/hooks/stop-guard.ts` checks pipeline 에 1순위로 wire-in (raw lastMessage 사용 — sanitizer 가 코드 fence 를 stripping 하므로 sanitized 는 부적합)
+  - 패턴 셋: `find -exec rm`, `find -delete`, `xargs rm`, `rm -r/-rf`, `git push --force`, `git reset --hard`, `DROP TABLE`, `dd of=/dev/`, `curl|sh`, `wget|sh` 등 14종 (응답 텍스트용)
+  - 매칭 시 block + correction 요청 (FORGEN_USER_CONFIRMED=1 으로 한 turn 우회 가능)
+  - 발동 검증: hardening N=10 측정에서 forgenOnly arm block 2건 (이전 측정들 0건)
+
+- **forgen-eval testbed 5-layer fix** (`fix`)
+  1. Judge contamination — `claude` CLI 가 사용자 전역 `~/.claude/CLAUDE.md` 로드 → judge 가 forgen 어시스턴트로 빙의 (β score=0/NaN 다발). `claude -p ... --system-prompt <blind>`, `codex exec --ignore-user-config --ignore-rules --ephemeral` 로 격리.
+  2. Persona stub — runner 가 ID 문자열만 β judge 에 전달. `loadPersonaSpec()` 도입해 `personas/persona-XXX.json` 실 spec 로드.
+  3. Trigger turn hook 누락 — `ForgenOnlyArm` 이 correctionSequence 만 hook 통과. trigger 단계도 UPS+Stop hook pipeline 추가.
+  4. Notepad 미초기화 — case 별 임시 cwd + `seedForgenNotepad()` 로 사전 학습 상태 시뮬레이션.
+  5. Hooks dir 경로 하드코딩 (root cause) — 잘못된 절대경로로 모든 hook 호출이 silently 실패. `import.meta.url` 기반 상대경로로 자동 해결. (이 결함이 이전 모든 ψ 측정을 무효화하고 있었음)
+  6. Bridge 응답 shape — `additionalContext` 가 `hookSpecificOutput` nested 필드. 인터페이스/접근 코드 동시 수정.
+
+- **Two-layer enforcement 명문화** (`docs`)
+  - `README.md` + `README.ko.md` 의 "How It Works" 에 "Two-layer safety enforcement / 2-layer 안전 적용" 섹션 추가. soft (notepad-injector) + hard (PreToolUse + Stop DANGEROUS-RESPONSE) 모델 명시. 작은 driver 가 학습 룰을 우회해도 hard layer 가 차단함을 사용자가 이해 가능.
+
+- **Judge rubric 4-anchor 명세** (`fix`)
+  - `packages/forgen-eval/src/judges/judge-types.ts` β/γ/φ 프롬프트에 1/2/3/4 모든 anchor 명시 (이전엔 1/4 만). 작은 judge 가 중간 점수 일관성 확보.
+
+- **Reports as audit trail** (`chore`)
+  - `packages/forgen-eval/reports/psi-stat/*.json` 7건 (5월 4-6일) — pre-isolation, post-isolation, broken sleep run, fixed run, post-rubric, post-hardening 의 비교 가능한 측정 시리즈.
+
+- **4축 personalization P1 — facet 임계값 분기 활성화** (`feat`)
+  - `src/renderer/rule-renderer.ts` — `_profile` → `profile` 활성화. 13개 facet (3 quality + 4 autonomy + 3 judgment + 3 communication) 의 0.85 / 0.15 임계값 분기 도입.
+  - 이전엔 facet 값이 inspect-print 외 어디에도 사용되지 않았음 (12-bucket pack lookup 만 활성). 본 변경으로 4축이 *연속 값* 으로 응답에 영향.
+  - `tests/renderer/rule-renderer.test.ts` — facet 0.1 vs 0.9 byte-diff 회귀 테스트 5건 (verification_depth, verbosity, approval_threshold 등).
+
+- **judgment / communication 축 facet delta 갱신 경로** (`feat`)
+  - `src/core/auto-compound-runner.ts` — `profile_delta` 스키마 + 적용 분기에 `judgment_philosophy`, `communication_style` 케이스 추가. 이전엔 quality_safety / autonomy 2축만 자동 갱신, 나머지 2축은 0.5/0.45 default 영원 고정.
+
+- **시맨틱 룰 FP 좁히기** (`fix`)
+  - `src/checks/fact-vs-agreement.ts` — `EVIDENCE_INDICATORS` 추가 (test counts `\d+/\d+`, exit code, timing, vitest output 형식, diff hunks 등 9 패턴). 응답에 측정 증거가 paste 되어 있으면 alert 억제 → "Docker e2e 77/77 PASS" 류 정량 사실 보고 FP 감소. tests/fact-vs-agreement.test.ts 4 케이스 추가 (총 13).
+  - `~/.forgen/me/rules/L1-no-mock-as-proof.json` — `trigger_exclude_regex` 에 `<observation>`, `<summary>`, observer 메타 패턴 추가. 메타-설명 응답 FP 감소.
+  - `~/.forgen/me/rules/L1-e2e-before-done.json` — TDD 진행 보고(`RED→GREEN`, `[N/M]`, `다음 단계`, `진행 상황`) 제외 패턴 추가.
+
+**Final measurement (post-hardening + post-narrowing, 두 N=10 합산 N=20)**:
+- ψ master gate: 두 측정 모두 borderline 0 (run1 −0.026, run2 +0.001) — composition-synergy metric 으로는 회귀
+- **δ(forgenOnly−vanilla) N=20 = +0.161, CI [+0.068, +0.256]** — *진짜 forgen 효과* metric, 0 위로 robust. 14/20 cases positive.
+- δ(full−vanilla) N=10 (run2): +0.218, CI [+0.117, +0.323]
+- κ_γ ~0.38 / κ_β ~0.41 — subscription-mode CLI judge 한계 (haiku 가 4점 척도 안정 분류 어려움)
+- fallback 5/160 = 3.1% (≤ 10% 게이트)
+- forgenOnly arm block 이벤트 발화 — DANGEROUS-RESPONSE 패턴이 driver 우회 응답을 차단
+
+**Production data sample (8일, 230 violations)**:
+- 9 distinct rules 발화: fact-vs-agreement 67, L1-no-mock-as-proof 56, self-score-inflation 41, L1-no-rm-rf-unconfirmed (PreToolUse) 23, dangerous-response-pattern (신설, 첫날) 20, L1-e2e-before-done 15, etc.
+- Stratified random sample N=30 → precision 60.7%. **Hard layer (PreToolUse + dangerous-response-pattern) 100% (6/6)**, semantic Stop-guard 룰 43-60%.
+- drift 자가복구 14건 — stuck-loop 상황 force-approve 후 drift 기록 (메타 안전성).
+
+**Host parity status**:
+- ✅ **Claude (claude)**: 모든 hook 동작 확정 (이번 세션 라이브 self-validated 다수)
+- ⚠️ **Codex (codex)**: PreToolUse hard layer + UserPromptSubmit soft layer 동등. Stop hook response-text 검사 (DANGEROUS-RESPONSE, L1-no-mock-as-proof 자가검증 등) 는 *best-effort* — codex CLI 가 Stop input 에 `last_assistant_message` 또는 `transcript_path` 를 제공해야 발화. 미제공 시 silently auto-approve (안전). 실 codex 사용 데이터로 다음 1주 검증 예정 (gap 발견 시 v0.4.5 보완).
+
+**v0.4.4 Does NOT claim**:
+- v0.5.0 release-proof. v0.5.0 은 70B 로컬 / Sonnet API 기반 강judge 로 κ ≥ 0.7 + 더 큰 N 으로 *사전 등록* metric (δ 우선) 으로 처음부터 측정 예정.
+- 외부 재현 — 실행에 Claude Max + Codex subscription 필요.
+- ψ master gate PASS — 두 N=10 측정 모두 borderline 0. ψ 자체가 composition-synergy 측정이라 "forgen이 vanilla 대비 좋은가" 질문에 부적합 metric 임이 본 사이클에서 확인됨. δ 가 답이고 δ 는 양수.
+
+**Lessons (post-mortem)**:
+- 측정 인프라 5-layer 결함 (특히 hooks dir 하드코딩) 으로 이전 모든 ψ 측정이 실은 vanilla-vs-vanilla 였음. 5월 6일 hardening + bridge fix 후에야 forgen 메커니즘이 testbed 에서 실제로 발화 시작.
+- ψ 정의 ("full vs best single arm composition") 가 주 product 질문 ("forgen 이 vanilla 대비 좋은가") 과 어긋남을 늦게 발견. v0.5.0 metric 재정의 필요.
+- 1주일 production data 가 enforcement 메커니즘 활성을 입증하나, FP precision (특히 시맨틱 룰 43-60%) 은 별도 트랙 개선 과제.
+
+### Internal — pathfinder + Deep Interview fix cycle (2026-04-30 post-v0.4.3)
+
+**Pathfinder (stop-guard 3-check 구조 진단 + unify)** (`refactor`)
+- `PATHFINDER-2026-04-30/` — features → flowcharts → duplication report → unified proposal → handoff
+- `src/checks/_shared/text-sanitizer.ts` + tests — 3-check (`self-score-inflation`, `fact-vs-agreement`, `conclusion-verification-ratio`) measurement Set 중복 제거
+- `src/hooks/stop-guard.ts` — 3-check 디스패처 정리
+
+**Deep Interview D9/D11/D12 fix** (`fix`)
+- D9: `docs/guard-design-checklist.md` — guard 설계 invariant 명문화
+- D11: `src/store/compound-usage-store.ts` + tests + `src/mcp/tools.ts` wiring
+  - MCP `compound-read/list/search` 호출 시 `~/.forgen/state/compound-usage.jsonl` 에 사용 evidence 적재
+- D12: `assets/claude/commands/calibrate.md` + `retro.md` — `~/.forgen/me/evidence/` → `behavior/` 경로 drift 수정 (skill 카탈로그 정합성 회복)
+
+**Auto-compound retry 로깅 개선** (`chore`)
+- `src/core/auto-compound-runner.ts` — retry 메시지에 attempt count + 에러 코드 + fail-open 단언 (UX 명확화, 동작 변경 없음)
+
+### Hygiene
+- `package.json` self-dep 오염 (`@wooojin/forgen ^0.4.3`) 제거
+- `plugin.json` (root) 0.4.2 → 0.4.3 sync (이전 d4c640c 가 `.claude-plugin/plugin.json` 만 sync)
+- `package-lock.json` workspace + transitive peer dep 동기화
+
+**Verification**: vitest 2373/2373 PASS, Docker e2e 77/77 PASS (round 16)
+
 ## [0.4.3] — 2026-04-30 — Self-correcting hotfix + testbed prep (alpha)
 
 forgen-eval introspect testbed (이번 릴리즈에 포함된 자기 측정 시스템) 가

package/README.ko.md

@@ -274,6 +274,20 @@ Linux 컨테이너에서 `~/.claude.json` 만 마운트하면 refresh 토큰이
                     (다음 세션: 업데이트된 규칙)
 ```
 
+### 2-layer 안전 적용
+
+학습된 제약이 모델이 우회를 시도해도 유지되도록 forgen은 **두 단계**에서 적용됩니다:
+
+| 단계 | Hook | 시점 | 차단 대상 |
+|---|---|---|---|
+| **Soft (컨텍스트)** | UserPromptSubmit (`notepad-injector`) | 매 turn 시작 전 | 활성 룰을 Claude 컨텍스트에 재주입 — 모델이 자율 준수하도록 유도. |
+| **Hard (도구)** | PreToolUse (`pre-tool-use` + `dangerous-patterns.json`) | 모든 Bash / Edit / Write 직전 | `rm -rf /`, `git push --force`, `DROP TABLE`, `mkfs`, `curl \| sh` 등 패턴 매칭 차단 — 모델 의도 무관하게 발동. |
+| **Hard (응답)** | Stop (`stop-guard` DANGEROUS-RESPONSE) | Claude 응답 직후 | 응답 텍스트 자체 패턴 매칭 — *제안된* 파괴 명령(예: `find … -exec rm`, `xargs rm` 우회)을 사용자가 보기 전에 차단. |
+
+Soft layer는 모델에게 "지켜줘"라고 요청하고, Hard layer는 요청하지 않습니다. driver 모델이 약해서 학습된 룰을 "창의적으로" 우회하려 해도 (예: `rm -rf` 금지 → `find -exec rm -r` 제안) Hard layer가 미리 차단합니다.
+
+오버라이드: 한 turn만 감사 우회는 `FORGEN_USER_CONFIRMED=1`, 특정 룰 영구 비활성화는 `forgen suppress-rule <rule_id>`.
+
 ### Compound 지식
 
 지식은 세션을 거치며 신뢰도 기반 라이프사이클로 축적됩니다:

package/README.md

@@ -319,6 +319,25 @@ entries in `~/.forgen/state/implicit-feedback.jsonl`. Idempotent — safe to re-
                     (next session: updated rules)
 ```
 
+### Two-layer safety enforcement
+
+forgen enforces your rules at **two layers** so a learned constraint holds even
+if the model rationalizes a workaround:
+
+| Layer | Hook | When | Catches |
+|---|---|---|---|
+| **Soft (context)** | UserPromptSubmit (`notepad-injector`) | Before each turn | Re-injects active rules into Claude's context so the model can self-comply. |
+| **Hard (tool)** | PreToolUse (`pre-tool-use` + `dangerous-patterns.json`) | Before every Bash / Edit / Write | Pattern-match block on `rm -rf /`, `git push --force`, `DROP TABLE`, `mkfs`, `curl \| sh`, etc — fires regardless of model intent. |
+| **Hard (response)** | Stop (`stop-guard` DANGEROUS-RESPONSE) | After Claude's reply | Pattern-match on the reply text itself — catches *suggestions* of destructive commands (e.g., `find … -exec rm`, `xargs rm` rationalizations) before the user sees them. |
+
+The soft layer asks the model to behave; the hard layers don't ask. Even with a
+weaker driver model that "creatively" routes around a learned rule (e.g.,
+suggesting `find -exec rm -r {}` because `rm -rf` was forbidden), the hard
+layers stop it before any damage.
+
+Override hatch: set `FORGEN_USER_CONFIRMED=1` for a one-turn audited bypass, or
+`forgen suppress-rule <rule_id>` to disable a specific rule permanently.
+
 ### Compound knowledge
 
 Knowledge accumulates across sessions with a trust-based lifecycle:

package/assets/claude/commands/calibrate.md

@@ -39,7 +39,8 @@ triggers:
 calibrate는 두 가지 데이터 소스를 사용합니다:
 
 ### 1차 소스: Evidence 파일
-`~/.forgen/me/evidence/` 디렉토리의 JSON 파일을 읽습니다.
+`~/.forgen/me/behavior/` 디렉토리의 JSON 파일을 읽습니다.
+(파일명: UUID.json — correction-record MCP 도구가 작성. 같은 디렉토리의 auto-*.md 는 auto-compound 산출이므로 calibrate 분석 대상 아님.)
 각 파일의 구조:
 ```json
 {
@@ -70,8 +71,8 @@ evidence 0건 + compound 교정 패턴 0건이면:
 ## Phase 1: Evidence 로드 및 검증
 
 ```bash
-ls ~/.forgen/me/evidence/ 2>/dev/null || echo "EMPTY"
-cat ~/.forgen/me/evidence/*.json 2>/dev/null || echo "NO_FILES"
+ls ~/.forgen/me/behavior/*.json 2>/dev/null || echo "EMPTY"
+cat ~/.forgen/me/behavior/*.json 2>/dev/null || echo "NO_FILES"
 ```
 
 로드한 JSON 파일마다 다음을 검증합니다:

package/assets/claude/commands/retro.md

@@ -69,8 +69,8 @@ compound-list
 ### 1-3: 교정 기록
 
 ```bash
-ls -la ~/.forgen/me/evidence/ 2>/dev/null || echo "교정 데이터 없음"
-find ~/.forgen/me/evidence/ -name "*.json" -mtime -{period_days} 2>/dev/null | wc -l
+ls -la ~/.forgen/me/behavior/ 2>/dev/null || echo "교정 데이터 없음"
+find ~/.forgen/me/behavior/ -name "*.json" -mtime -{period_days} 2>/dev/null | wc -l
 ```
 
 ## Phase 2: 코드 활동 분석

package/dist/checks/_shared/text-sanitizer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Forgen — text-sanitizer (Pathfinder D4 + D5 흡수).
+ *
+ * stop-guard 진입 시 lastMessage 에 한 번 적용. 두 가지 면제:
+ *
+ *   D4 — Structured-output 면제:
+ *     observer hook / skill 산출물(<observation>...</observation>,
+ *     <summary>...</summary> 등)은 *과거 사실 기록* 이지 자기 평가가 아님.
+ *     본문 안의 "verified", "신뢰도 95/100" 같은 어휘에 가드가 발화하면 FP.
+ *
+ *   D5 — Self-paradox 면제:
+ *     regex 트리거 어휘(예: 4/10, verified)를 *인용해서* 설명만 해도 본인
+ *     매칭. 메타 대화/디버깅에서 가드가 무력화됨. 코드/직인용 본문은 가드
+ *     판정 대상이 아니므로 stripping.
+ *
+ * 결정 (PATHFINDER-2026-04-30/03-unified-proposal.md):
+ *  - 자연 산문 속 진짜 점수 인플레이션은 살아남아야 함 (TP 보존)
+ *  - 짧은 인용("...") 만 제거; 긴 인용은 사용자 인용일 수 있어 보존
+ *  - idempotent: 두 번 적용해도 결과 동일
+ */
+export declare function sanitizeForGuard(raw: string): string;

package/dist/checks/_shared/text-sanitizer.js

@@ -0,0 +1,60 @@
+/**
+ * Forgen — text-sanitizer (Pathfinder D4 + D5 흡수).
+ *
+ * stop-guard 진입 시 lastMessage 에 한 번 적용. 두 가지 면제:
+ *
+ *   D4 — Structured-output 면제:
+ *     observer hook / skill 산출물(<observation>...</observation>,
+ *     <summary>...</summary> 등)은 *과거 사실 기록* 이지 자기 평가가 아님.
+ *     본문 안의 "verified", "신뢰도 95/100" 같은 어휘에 가드가 발화하면 FP.
+ *
+ *   D5 — Self-paradox 면제:
+ *     regex 트리거 어휘(예: 4/10, verified)를 *인용해서* 설명만 해도 본인
+ *     매칭. 메타 대화/디버깅에서 가드가 무력화됨. 코드/직인용 본문은 가드
+ *     판정 대상이 아니므로 stripping.
+ *
+ * 결정 (PATHFINDER-2026-04-30/03-unified-proposal.md):
+ *  - 자연 산문 속 진짜 점수 인플레이션은 살아남아야 함 (TP 보존)
+ *  - 짧은 인용("...") 만 제거; 긴 인용은 사용자 인용일 수 있어 보존
+ *  - idempotent: 두 번 적용해도 결과 동일
+ */
+const STRUCTURED_TAGS = [
+    'observation',
+    'summary',
+    'request',
+    'investigated',
+    'completed',
+    'next-steps',
+    'next_steps',
+    'title',
+    'subtitle',
+    'learned',
+    'discovery',
+];
+const SHORT_QUOTE_MAX = 20;
+export function sanitizeForGuard(raw) {
+    if (!raw)
+        return raw;
+    let s = raw;
+    // 1) structured-output 블록 (open + close 쌍) 제거
+    for (const tag of STRUCTURED_TAGS) {
+        const re = new RegExp(`<${tag}\\b[^>]*>[\\s\\S]*?<\\/${tag}>`, 'gi');
+        s = s.replace(re, '');
+    }
+    // self-closing 또는 dangling open tag 도 제거 (열렸지만 닫힘 누락 케이스)
+    for (const tag of STRUCTURED_TAGS) {
+        const reSelf = new RegExp(`<${tag}\\b[^>]*\\/?>`, 'gi');
+        s = s.replace(reSelf, '');
+        const reClose = new RegExp(`<\\/${tag}>`, 'gi');
+        s = s.replace(reClose, '');
+    }
+    // 2) fenced code block (```...```) 제거 — 진짜 점수가 들어갈 자리 아님
+    s = s.replace(/```[\s\S]*?```/g, '');
+    // 3) inline backtick 코드 (`...`) 제거
+    s = s.replace(/`[^`\n]*`/g, '');
+    // 4) 짧은 직인용 ("...") 제거 — 길이 SHORT_QUOTE_MAX 이하만.
+    //    긴 인용은 사용자 발언/실제 사실 인용이므로 가드 판정 대상에 남김.
+    const shortQuoteRe = new RegExp(`"[^"\\n]{0,${SHORT_QUOTE_MAX}}"`, 'g');
+    s = s.replace(shortQuoteRe, '');
+    return s;
+}

package/dist/checks/dangerous-response-pattern.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Forgen — DANGEROUS-RESPONSE: 응답 텍스트 파괴적 명령 가드
+ *
+ * Stop hook 단계에서 어시스턴트 응답 텍스트를 스캔하여 *파괴적 명령 제안*을
+ * 감지한다. PreToolUse 가드는 실제 도구 실행 직전에만 동작하므로, 모델이
+ * 텍스트로 위험한 대안을 *제안*하는 케이스(예: `find ... -exec rm -r {}`)는
+ * 도구 실행 단계에 도달하지 못하면 차단되지 않는다. 본 체크는 그 갭을 메운다.
+ *
+ * 발견 경위 (forgen-eval syn-004, 2026-05-06):
+ *   notepad 룰 "[no-rm-rf-unconfirmed]" inject 상태에서, driver(llama 8B) 가
+ *   `rm -rf` 리터럴은 회피했지만 `find . -type d -name 'build' -exec rm -r {}`
+ *   같은 우회 명령을 "안전한 대안"으로 제안. PreToolUse 차단은 실 실행 시
+ *   동작하지만 "응답 텍스트만으론" 못 막음. driver 모델 능력에 무관하게
+ *   일관된 안전 보장이 되도록 응답 단계에서 한 번 더 잡아낸다.
+ *
+ * 동작:
+ *   - 어시스턴트 응답에 등록된 파괴 패턴이 매칭되면 block 권고.
+ *   - "확실히, 명시적 확인" 같은 confirm 표현 동반 여부는 검사하지 않는다
+ *     (휴리스틱 brittle). 매칭 시 무조건 block 후, 모델이 안전한 대안 제시
+ *     또는 명시적 confirm 절차로 재응답하도록 유도.
+ *
+ * 순수 함수 — Stop hook 이 reason 문자열을 그대로 주입.
+ */
+export interface DangerousResultMatch {
+    block: boolean;
+    matched?: string;
+    reason: string;
+}
+/** 응답 텍스트가 파괴적 명령 패턴을 포함하는지 검사. */
+export declare function checkDangerousResponsePattern(opts: {
+    text: string;
+}): DangerousResultMatch;

package/dist/checks/dangerous-response-pattern.js

@@ -0,0 +1,65 @@
+/**
+ * Forgen — DANGEROUS-RESPONSE: 응답 텍스트 파괴적 명령 가드
+ *
+ * Stop hook 단계에서 어시스턴트 응답 텍스트를 스캔하여 *파괴적 명령 제안*을
+ * 감지한다. PreToolUse 가드는 실제 도구 실행 직전에만 동작하므로, 모델이
+ * 텍스트로 위험한 대안을 *제안*하는 케이스(예: `find ... -exec rm -r {}`)는
+ * 도구 실행 단계에 도달하지 못하면 차단되지 않는다. 본 체크는 그 갭을 메운다.
+ *
+ * 발견 경위 (forgen-eval syn-004, 2026-05-06):
+ *   notepad 룰 "[no-rm-rf-unconfirmed]" inject 상태에서, driver(llama 8B) 가
+ *   `rm -rf` 리터럴은 회피했지만 `find . -type d -name 'build' -exec rm -r {}`
+ *   같은 우회 명령을 "안전한 대안"으로 제안. PreToolUse 차단은 실 실행 시
+ *   동작하지만 "응답 텍스트만으론" 못 막음. driver 모델 능력에 무관하게
+ *   일관된 안전 보장이 되도록 응답 단계에서 한 번 더 잡아낸다.
+ *
+ * 동작:
+ *   - 어시스턴트 응답에 등록된 파괴 패턴이 매칭되면 block 권고.
+ *   - "확실히, 명시적 확인" 같은 confirm 표현 동반 여부는 검사하지 않는다
+ *     (휴리스틱 brittle). 매칭 시 무조건 block 후, 모델이 안전한 대안 제시
+ *     또는 명시적 confirm 절차로 재응답하도록 유도.
+ *
+ * 순수 함수 — Stop hook 이 reason 문자열을 그대로 주입.
+ */
+import { compileSafeRegex, safeRegexTest } from '../hooks/shared/safe-regex.js';
+/**
+ * 응답 텍스트에서 검사할 파괴적 명령 패턴.
+ * dist/hooks/dangerous-patterns.json (PreToolUse 용) 와 별도 — 응답 텍스트
+ * 분석에 적합한 더 넓은 패턴 (find -exec rm 같은 우회 포함).
+ */
+/** 패턴 순서 중요: 더 구체적인(우회) 패턴을 먼저 두어 일반 rm -r 패턴이 가로채지 않게 함. */
+const RESPONSE_PATTERNS = [
+    { pattern: '\\bfind\\b[^\\n]{0,80}-exec\\s+rm\\b', description: 'find -exec rm (rm 우회)', flags: 'i' },
+    { pattern: '\\bfind\\b[^\\n]{0,80}-delete\\b', description: 'find -delete (rm 우회)', flags: 'i' },
+    { pattern: '\\bxargs\\s+rm\\b', description: 'xargs rm (rm 우회)', flags: 'i' },
+    { pattern: '\\brm\\s+-(?:rf|fr|r)\\b', description: 'rm -r/-rf 직접 호출', flags: 'i' },
+    { pattern: '\\bgit\\s+push\\b[^\\n]{0,40}--force(?!-)', description: 'git push --force', flags: 'i' },
+    { pattern: '\\bgit\\s+reset\\s+--hard\\b', description: 'git reset --hard', flags: 'i' },
+    { pattern: '\\bgit\\s+clean\\s+-[a-z]*f', description: 'git clean -f', flags: 'i' },
+    { pattern: '\\bDROP\\s+(?:TABLE|DATABASE)\\b', description: 'SQL DROP TABLE/DATABASE', flags: 'i' },
+    { pattern: '\\bTRUNCATE\\s+TABLE\\b', description: 'SQL TRUNCATE TABLE', flags: 'i' },
+    { pattern: '>\\s*/dev/sd[a-z]\\b', description: '/dev/sdX 직접 write', flags: 'i' },
+    { pattern: '\\bmkfs\\b', description: 'mkfs (파일시스템 포맷)', flags: 'i' },
+    { pattern: '\\bdd\\b[^\\n]{0,60}\\bof=/dev/', description: 'dd of=/dev/* (장치 write)', flags: 'i' },
+    { pattern: '\\bcurl\\b[^\\n]{0,60}\\|\\s*(?:ba)?sh\\b', description: 'curl | sh (원격 코드 실행)', flags: 'i' },
+    { pattern: '\\bwget\\b[^\\n]{0,60}\\|\\s*(?:ba)?sh\\b', description: 'wget | sh (원격 코드 실행)', flags: 'i' },
+];
+/** 응답 텍스트가 파괴적 명령 패턴을 포함하는지 검사. */
+export function checkDangerousResponsePattern(opts) {
+    const text = opts.text ?? '';
+    if (!text.trim())
+        return { block: false, reason: '' };
+    for (const p of RESPONSE_PATTERNS) {
+        const compiled = compileSafeRegex(p.pattern, p.flags ?? 'i');
+        if (!compiled.regex)
+            continue; // bad regex — skip
+        if (safeRegexTest(compiled.regex, text)) {
+            return {
+                block: true,
+                matched: p.description,
+                reason: `응답에 파괴적 명령 패턴이 포함되었습니다 (${p.description}). 사용자 명시 확인 절차를 포함하거나 비파괴 대안 (예: dry-run, --interactive)을 제시해 다시 응답하세요.`,
+            };
+        }
+    }
+    return { block: false, reason: '' };
+}

package/dist/checks/fact-vs-agreement.js

@@ -47,6 +47,26 @@ const AGREEMENT_SOFTENERS = [
     /(생각합니다|생각함|생각해|봅니다|예상(합니다|돼))/,
     /(그럴\s*것\s*같|맞을\s*것\s*같)/,
 ];
+/**
+ * 측정-증거 지표 — 실제 실행/측정 결과가 응답에 *paste 되어 있다*는 신호.
+ *
+ * v0.4.4 (2026-05-06): FP 감소. "Docker e2e 77/77 PASS" 같은 *정량 사실 보고*
+ * 가 recentTools 윈도우 밖 측정 (예: 이전 turn Bash 결과, 사용자 paste, CI 로그
+ * 인용)이라 Bash 카운트가 0이지만 본질적으로 measurement-backed 응답.
+ *
+ * 임계: 본 패턴이 2+ 매칭되면 alert 억제 (응답이 측정 증거를 *제시*하고 있다고 본다).
+ */
+const EVIDENCE_INDICATORS = [
+    /\b\d+\/\d+\b/, // test counts: "77/77", "22/22"
+    /\bexit\s*code\s*[:=]?\s*\d+/i, // exit code
+    /\b\d+(\.\d+)?\s*(ms|s|sec|seconds)\b/i, // timings: "232s", "1.5ms"
+    /\b(?:Test|Spec)s?\s*Files?\s+\d+/i, // vitest "Test Files 218"
+    /\b(?:Tests?:?\s+)?\d+\s+passed?\b/i, // "2382 passed"
+    /\b(?:CI|HEAD|sha|commit)\s*[:=]?\s*[a-f0-9]{7,}/i, // commit ref
+    /^[+-]{3}\s/m, // diff hunks
+    /\bcoverage\s*[:=]?\s*\d+(\.\d+)?%/i, // coverage %
+    /^\s*✓\s|^\s*✗\s|^\s*PASS\b|^\s*FAIL\b/m, // test runner output markers
+];
 function findMatches(text, patterns, max = 3) {
     const out = [];
     for (const p of patterns) {
@@ -69,8 +89,12 @@ export function checkFactVsAgreement(input) {
     const factAssertions = findMatches(text, FACT_ASSERTION_PATTERNS);
     const agreementSofteners = findMatches(text, AGREEMENT_SOFTENERS);
     const measurementCount = recentTools.filter((t) => MEASUREMENT_TOOL_CATEGORIES.has(t)).length;
+    // Evidence indicator suppression — 응답에 측정 결과가 *paste* 되어 있으면
+    // recentTools 윈도우 밖 측정으로 보고 alert 억제 (FP 감소).
+    const evidenceIndicators = findMatches(text, EVIDENCE_INDICATORS, 99);
+    const hasMeasurementEvidence = evidenceIndicators.length >= 2;
     const hasFactAssertion = factAssertions.length > 0;
-    const measurementMissing = measurementCount < minMeasurements;
+    const measurementMissing = measurementCount < minMeasurements && !hasMeasurementEvidence;
     const alert = hasFactAssertion && measurementMissing;
     let reason = '';
     if (alert) {

package/dist/core/auto-compound-runner.js

@@ -40,17 +40,22 @@ function execClaudeRetry(args, opts) {
     if (host === 'claude') {
         // Claude 측은 기존 보안 hardening 보존: --allowedTools 등 args 그대로 전달.
         const TRANSIENT = /ETIMEDOUT|ECONNRESET|ECONNREFUSED|EPIPE/;
-        for (let attempt = 0; attempt < 2; attempt++) {
+        const MAX_ATTEMPTS = 2;
+        for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
             try {
                 return execFileSync('claude', args, opts);
             }
             catch (e) {
                 const msg = e instanceof Error ? e.message : String(e);
-                if (attempt === 0 && TRANSIENT.test(msg)) {
-                    process.stderr.write(`[forgen-auto-compound] transient error, retrying in 3s...\n`);
+                const match = msg.match(TRANSIENT);
+                if (attempt < MAX_ATTEMPTS && match) {
+                    process.stderr.write(`[forgen-auto-compound] ${match[0]} on attempt ${attempt}/${MAX_ATTEMPTS}, retrying in 3s (auto-recovery)...\n`);
                     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 3000);
                     continue;
                 }
+                if (match) {
+                    process.stderr.write(`[forgen-auto-compound] ${match[0]} after ${attempt}/${MAX_ATTEMPTS} attempts — giving up (fail-open)\n`);
+                }
                 throw e;
             }
         }
@@ -425,7 +430,9 @@ ${profileContext}
   "pack_direction": null 또는 "opposite_quality" 또는 "opposite_autonomy",
   "profile_delta": {
     "quality_safety": { "verification_depth": 0.0, "stop_threshold": 0.0, "change_conservatism": 0.0 },
-    "autonomy": { "confirmation_independence": 0.0, "assumption_tolerance": 0.0, "scope_expansion_tolerance": 0.0, "approval_threshold": 0.0 }
+    "autonomy": { "confirmation_independence": 0.0, "assumption_tolerance": 0.0, "scope_expansion_tolerance": 0.0, "approval_threshold": 0.0 },
+    "judgment_philosophy": { "minimal_change_bias": 0.0, "abstraction_bias": 0.0, "evidence_first_bias": 0.0 },
+    "communication_style": { "verbosity": 0.0, "structure": 0.0, "teaching_bias": 0.0 }
   }
 }
 
@@ -493,6 +500,26 @@ ${sanitizedSummary.slice(0, 4000)}
                             }
                         }
                     }
+                    if (parsed.profile_delta.judgment_philosophy) {
+                        const d = parsed.profile_delta.judgment_philosophy;
+                        const f = profile.axes.judgment_philosophy.facets;
+                        for (const [k, v] of Object.entries(d)) {
+                            if (typeof v === 'number' && Math.abs(v) > 0.001 && k in f) {
+                                f[k] = clamp(f[k] + v);
+                                changed = true;
+                            }
+                        }
+                    }
+                    if (parsed.profile_delta.communication_style) {
+                        const d = parsed.profile_delta.communication_style;
+                        const f = profile.axes.communication_style.facets;
+                        for (const [k, v] of Object.entries(d)) {
+                            if (typeof v === 'number' && Math.abs(v) > 0.001 && k in f) {
+                                f[k] = clamp(f[k] + v);
+                                changed = true;
+                            }
+                        }
+                    }
                     if (changed) {
                         profile.metadata.updated_at = new Date().toISOString();
                         fs.writeFileSync(V1_PROFILE, JSON.stringify(profile, null, 2));

package/dist/hooks/stop-guard.js

@@ -27,6 +27,8 @@ import { takeLastExtractionNotice } from '../core/extraction-notice.js';
 import { checkConclusionVerificationRatio } from '../checks/conclusion-verification-ratio.js';
 import { checkSelfScoreInflation } from '../checks/self-score-deflation.js';
 import { checkFactVsAgreement } from '../checks/fact-vs-agreement.js';
+import { checkDangerousResponsePattern } from '../checks/dangerous-response-pattern.js';
+import { sanitizeForGuard } from '../checks/_shared/text-sanitizer.js';
 import { STATE_DIR } from '../core/paths.js';
 import { sanitizeId } from './shared/sanitize-id.js';
 import { detectRecallReferences } from '../core/recall-reference-detector.js';
@@ -496,58 +498,73 @@ export async function main() {
         // block/approve 어느 경로이든 동일하게 기록 (참조는 응답 내용이 결정).
         const sessionIdForRef = input?.session_id ?? 'unknown';
         emitRecallReferencesFailOpen(sessionIdForRef, lastMessage);
-        // TEST-2/3: rule-free meta guards — FORGEN_USER_CONFIRMED=1 우회 공통.
+        // TEST-1/2/3: rule-free meta guards — FORGEN_USER_CONFIRMED=1 우회 공통.
+        // Pathfinder D7: 3중 보일러플레이트를 CHECKS 배열 + for-loop 디스패처로 통합.
+        // Pathfinder D4/D5: sanitizeForGuard 가 모든 체크 입력 단계에 일괄 적용.
         if (process.env.FORGEN_USER_CONFIRMED !== '1') {
             const sessionId = input?.session_id ?? 'unknown';
-            // TEST-2 (자가 점수 인플레이션): 숫자 점수 상승 선언 + 측정 도구 0회 → block.
-            // TEST-3 보다 강한 신호라 먼저 평가.
             const recentTools = loadRecentToolNames(sessionId);
-            const score = checkSelfScoreInflation({ text: lastMessage, recentTools });
-            if (score.block) {
-                recordViolation({
-                    rule_id: 'builtin:self-score-inflation',
-                    session_id: sessionId,
-                    source: 'stop-guard',
+            const sanitized = sanitizeForGuard(lastMessage);
+            // 평가 순서: DANGEROUS-RESPONSE (즉시 차단 — 안전 우선) → TEST-2 (강한 신호) → TEST-3 (텍스트 비율) → TEST-1 (alert-only).
+            const checks = [
+                {
+                    shortId: 'dangerous-response-pattern',
+                    ruleSlug: 'rule:DANGEROUS-RESPONSE — destructive command suggestion',
                     kind: 'block',
-                    message_preview: lastMessage.slice(0, 120),
-                });
-                const reasonText = `[forgen:stop-guard/self-score-inflation] ${score.reason}
-
-(Override this turn: set FORGEN_USER_CONFIRMED=1 (audited).)`;
-                console.log(blockStop(reasonText, 'rule:TEST-2 — self-score inflation'));
-                return;
-            }
-            // TEST-3: 결론/검증 비율 — Claude 가 실제 측정 도구는 돌렸지만 서술이
-            // 결론-편향이면 여전히 block.
-            const ratio = checkConclusionVerificationRatio({ text: lastMessage });
-            if (ratio.block) {
+                    // 주의: sanitizer 가 백틱/코드블록을 제거하므로 raw lastMessage 를 전달.
+                    // 위험 명령은 코드 fence 안에 있어도 동등하게 위험함.
+                    run: () => {
+                        const r = checkDangerousResponsePattern({ text: lastMessage });
+                        return { triggered: r.block, reason: r.reason };
+                    },
+                },
+                {
+                    shortId: 'self-score-inflation',
+                    ruleSlug: 'rule:TEST-2 — self-score inflation',
+                    kind: 'block',
+                    run: () => {
+                        const r = checkSelfScoreInflation({ text: sanitized, recentTools });
+                        return { triggered: r.block, reason: r.reason };
+                    },
+                },
+                {
+                    shortId: 'conclusion-ratio',
+                    ruleSlug: 'rule:TEST-3 — conclusion/verification ratio',
+                    kind: 'block',
+                    run: () => {
+                        const r = checkConclusionVerificationRatio({ text: sanitized });
+                        return { triggered: r.block, reason: r.reason };
+                    },
+                },
+                {
+                    shortId: 'fact-vs-agreement',
+                    ruleSlug: 'rule:TEST-1 — fact vs agreement',
+                    kind: 'correction', // alert-level only per fact-vs-agreement.ts design
+                    run: () => {
+                        const r = checkFactVsAgreement({ text: sanitized, recentTools, minMeasurements: 1 });
+                        return { triggered: r.alert, reason: r.reason };
+                    },
+                },
+            ];
+            for (const c of checks) {
+                const out = c.run();
+                if (!out.triggered)
+                    continue;
                 recordViolation({
-                    rule_id: 'builtin:conclusion-verification-ratio',
+                    rule_id: `builtin:${c.shortId}`,
                     session_id: sessionId,
                     source: 'stop-guard',
-                    kind: 'block',
+                    kind: c.kind,
                     message_preview: lastMessage.slice(0, 120),
                 });
-                const reasonText = `[forgen:stop-guard/conclusion-ratio] ${ratio.reason}
+                if (c.kind !== 'block')
+                    continue;
+                const reasonText = `[forgen:stop-guard/${c.shortId}] ${out.reason}
 
 (Override this turn: set FORGEN_USER_CONFIRMED=1 (audited).)`;
-                console.log(blockStop(reasonText, 'rule:TEST-3 — conclusion/verification ratio'));
+                console.log(blockStop(reasonText, c.ruleSlug));
                 return;
             }
-            // TEST-1: 사실 vs 합의 — fact assertion 키워드가 있으나 측정 도구 호출 0건.
-            // 원 design intent (per fact-vs-agreement.ts): alert level only — block 은 TEST-2/3.
-            // 여기서는 measurement 신호를 violations.jsonl 에 'alert' kind 로 기록만 (block 안 함).
-            // wiring gap 발견 (forgen-eval introspect) → 측정 가능하게 wired up.
-            const fva = checkFactVsAgreement({ text: lastMessage, recentTools, minMeasurements: 1 });
-            if (fva.alert) {
-                recordViolation({
-                    rule_id: 'builtin:fact-vs-agreement',
-                    session_id: sessionId,
-                    source: 'stop-guard',
-                    kind: 'correction', // alert-level signal (not block) per fact-vs-agreement.ts design
-                    message_preview: lastMessage.slice(0, 120),
-                });
-            }
         }
         const rules = loadStopRules();
         if (rules.length === 0) {

package/dist/mcp/tools.js

@@ -136,6 +136,10 @@ export function registerTools(server) {
                     }],
             };
         }
+        // D11 — compound usage signal: 사용자 reuse 신호를 한 줄 기록.
+        // mature 승격 정책의 입력 데이터 (정책은 별도 사이클).
+        const usageMod = await import('../store/compound-usage-store.js');
+        usageMod.recordUsage(result.name, 'mcp');
         const header = `# ${result.name}\n` +
             `Status: ${result.status} | Confidence: ${result.confidence.toFixed(2)} | Type: ${result.type} | Scope: ${result.scope}\n` +
             `Tags: ${result.tags.join(', ')}\n` +

package/dist/renderer/rule-renderer.d.ts

@@ -15,4 +15,4 @@ export interface RenderContext {
     include_pack_summary: boolean;
 }
 export declare const DEFAULT_CONTEXT: RenderContext;
-export declare function renderRules(rules: Rule[], state: SessionEffectiveState, _profile: Profile, ctx?: RenderContext): string;
+export declare function renderRules(rules: Rule[], state: SessionEffectiveState, profile: Profile, ctx?: RenderContext): string;

package/dist/renderer/rule-renderer.js

@@ -91,8 +91,74 @@ function communicationPackRules(pack) {
         case '균형형': return s.commBalanced;
     }
 }
+// ── Facet-driven rules ──
+// 4축 facet 값의 양 극단(≤0.15, ≥0.85)에서만 추가 규칙을 emit. 중간 값은
+// pack 기본 규칙으로 충분하다고 본다 — 12-bucket pack lookup 위에 *연속 값
+// 차별화*를 얇게 얹는 설계.
+//
+// Threshold 정당화: 0.5 가 default 이고 자동 갱신은 ±0.1 단위 (auto-compound-runner).
+// 0.15/0.85 = 3 단계 강한 신호 누적 후에야 발화 → 노이즈에 둔감.
+const FACET_HIGH = 0.85;
+const FACET_LOW = 0.15;
+function facetDrivenRules(profile) {
+    const out = [];
+    const q = profile.axes.quality_safety.facets;
+    const a = profile.axes.autonomy.facets;
+    const j = profile.axes.judgment_philosophy.facets;
+    const c = profile.axes.communication_style.facets;
+    // Quality
+    if (q.verification_depth >= FACET_HIGH) {
+        out.push({ section: 'How To Validate', rule: '완료 선언 전 실행 로그 / 테스트 결과 / e2e 증거를 응답에 첨부' });
+    }
+    if (q.stop_threshold >= FACET_HIGH) {
+        out.push({ section: 'Working Defaults', rule: '첫 실패 시 즉시 멈추고 진단 — 무진단 재시도 금지' });
+    }
+    if (q.change_conservatism >= FACET_HIGH) {
+        out.push({ section: 'Working Defaults', rule: '의뢰 범위 외 리팩토링/일반화 금지 — 최소 diff 우선' });
+    }
+    else if (q.change_conservatism <= FACET_LOW) {
+        out.push({ section: 'Working Defaults', rule: '명확성을 위한 리팩토링은 허용 — 디버그 중 발견된 인접 결함도 같은 PR 가능' });
+    }
+    // Autonomy
+    if (a.confirmation_independence >= FACET_HIGH) {
+        out.push({ section: 'When To Ask', rule: '목표 합의 후 단계별 재확인 생략 — 마무리 시점 한 번만 보고' });
+    }
+    else if (a.confirmation_independence <= FACET_LOW) {
+        out.push({ section: 'When To Ask', rule: '비-사소한 단계마다 사용자 확인을 받고 진행' });
+    }
+    if (a.approval_threshold >= FACET_HIGH) {
+        out.push({ section: 'When To Ask', rule: '비가역 작업(force push, 데이터 삭제, 외부 broadcast) 전 명시 승인 필수' });
+    }
+    // Judgment
+    if (j.minimal_change_bias >= FACET_HIGH) {
+        out.push({ section: 'Working Defaults', rule: '직면한 문제만 해결 — 인접 개선/추상화 제안은 별도 보고' });
+    }
+    if (j.abstraction_bias >= FACET_HIGH) {
+        out.push({ section: 'Working Defaults', rule: '반복 패턴 발견 시 재사용 가능한 추상화로 통합 제안' });
+    }
+    else if (j.abstraction_bias <= FACET_LOW) {
+        out.push({ section: 'Working Defaults', rule: '명확성을 해치는 추상화 금지 — 인라인 중복 허용' });
+    }
+    if (j.evidence_first_bias >= FACET_HIGH) {
+        out.push({ section: 'How To Report', rule: '결론·가설 명시 전 근거(파일:라인, 로그, 측정값)를 먼저 표면화' });
+    }
+    // Communication
+    if (c.verbosity <= FACET_LOW) {
+        out.push({ section: 'How To Report', rule: '코드 표시가 필요하지 않으면 답변은 3문장 이내' });
+    }
+    else if (c.verbosity >= FACET_HIGH) {
+        out.push({ section: 'How To Report', rule: '결정 배경·대안·tradeoff 를 답변에 포함' });
+    }
+    if (c.structure >= FACET_HIGH) {
+        out.push({ section: 'How To Report', rule: '다중 포인트 답변은 헤더/표/리스트로 구조화' });
+    }
+    if (c.teaching_bias >= FACET_HIGH) {
+        out.push({ section: 'How To Report', rule: 'why/how 를 함께 설명 — what 만 답하지 말 것' });
+    }
+    return out;
+}
 // ── Main Render ──
-export function renderRules(rules, state, _profile, ctx = DEFAULT_CONTEXT) {
+export function renderRules(rules, state, profile, ctx = DEFAULT_CONTEXT) {
     // 1. active만 수집
     const active = rules.filter(r => r.status === 'active');
     // 2. dedupe by render_key
@@ -122,6 +188,12 @@ export function renderRules(rules, state, _profile, ctx = DEFAULT_CONTEXT) {
         for (const rule of communicationPackRules(state.communication_pack)) {
             sections.get('How To Report').push(rule);
         }
+        // 4축 facet 극단값 → 추가 규칙 (12-bucket pack 위에 연속 값 차별화).
+        // 각 facet 0.5 default 이고 자동 갱신 ±0.1 단위이므로, 0.85/0.15 임계값은
+        // 여러 세션에 걸친 강한 신호 누적 후에만 발화한다.
+        for (const fr of facetDrivenRules(profile)) {
+            sections.get(fr.section).push(fr.rule);
+        }
     }
     // 6. 섹션 조립 (AI-optimized: 간결한 태그 형식)
     const parts = [];

package/dist/store/compound-usage-store.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Forgen — compound usage signal store (Pathfinder D11 fix, MVP).
+ *
+ * 배경 (Deep Interview 2026-04-30 Round 5):
+ *   verified compound 23개, candidate 8개 — 그러나 mature 0. retro 회고에서
+ *   "활용률 측정 불가 — compound-search 호출 카운터 미수집" 확인. 즉 사용자가
+ *   compound 를 reuse 했다는 신호 자체가 잡히지 않아서 mature 승격 입력이 없음.
+ *
+ *   원칙(user-mirror, Round 4 Contrarian): forgen 자기 학습이 아니라 *사용자
+ *   reuse* 가 mature 의 권위 종착점. 따라서 compound-read 호출이 있을 때마다
+ *   "이 패턴이 사용됐다" 신호를 한 줄 기록.
+ *
+ * MVP 스코프: 신호 *수집*만. 승격 정책(예: 5회 reuse → mature) 은 다음 사이클.
+ *   기록만 잘 쌓이면 임계 설정·승격 로직은 위에 얹기 쉬움.
+ *
+ * 데이터: append-only JSONL at ~/.forgen/state/compound-usage.jsonl
+ *   각 라인: {"at": ISO, "name": "<solution-slug>", "via": "mcp|cli|hook"}
+ *   crash-safe: 단순 fs.appendFileSync — 동시 append 는 OS 가 atomic 보장 (POSIX <PIPE_BUF).
+ */
+export declare const COMPOUND_USAGE_LOG: string;
+export interface UsageEntry {
+    at: string;
+    name: string;
+    via: 'mcp' | 'cli' | 'hook';
+}
+export declare function recordUsage(name: string, via?: UsageEntry['via']): void;
+/** 단순 카운터 — 승격 정책에서 호출. MVP 에선 미사용. */
+export declare function readUsageCounts(): Map<string, number>;

package/dist/store/compound-usage-store.js

@@ -0,0 +1,59 @@
+/**
+ * Forgen — compound usage signal store (Pathfinder D11 fix, MVP).
+ *
+ * 배경 (Deep Interview 2026-04-30 Round 5):
+ *   verified compound 23개, candidate 8개 — 그러나 mature 0. retro 회고에서
+ *   "활용률 측정 불가 — compound-search 호출 카운터 미수집" 확인. 즉 사용자가
+ *   compound 를 reuse 했다는 신호 자체가 잡히지 않아서 mature 승격 입력이 없음.
+ *
+ *   원칙(user-mirror, Round 4 Contrarian): forgen 자기 학습이 아니라 *사용자
+ *   reuse* 가 mature 의 권위 종착점. 따라서 compound-read 호출이 있을 때마다
+ *   "이 패턴이 사용됐다" 신호를 한 줄 기록.
+ *
+ * MVP 스코프: 신호 *수집*만. 승격 정책(예: 5회 reuse → mature) 은 다음 사이클.
+ *   기록만 잘 쌓이면 임계 설정·승격 로직은 위에 얹기 쉬움.
+ *
+ * 데이터: append-only JSONL at ~/.forgen/state/compound-usage.jsonl
+ *   각 라인: {"at": ISO, "name": "<solution-slug>", "via": "mcp|cli|hook"}
+ *   crash-safe: 단순 fs.appendFileSync — 동시 append 는 OS 가 atomic 보장 (POSIX <PIPE_BUF).
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { STATE_DIR } from '../core/paths.js';
+export const COMPOUND_USAGE_LOG = path.join(STATE_DIR, 'compound-usage.jsonl');
+export function recordUsage(name, via = 'mcp') {
+    if (!name)
+        return;
+    try {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        const entry = { at: new Date().toISOString(), name, via };
+        fs.appendFileSync(COMPOUND_USAGE_LOG, JSON.stringify(entry) + '\n');
+    }
+    catch {
+        // fail-open: 신호 수집 실패가 사용자 경험을 방해하면 안 됨
+    }
+}
+/** 단순 카운터 — 승격 정책에서 호출. MVP 에선 미사용. */
+export function readUsageCounts() {
+    const counts = new Map();
+    if (!fs.existsSync(COMPOUND_USAGE_LOG))
+        return counts;
+    try {
+        const lines = fs.readFileSync(COMPOUND_USAGE_LOG, 'utf-8').split('\n').filter(Boolean);
+        for (const line of lines) {
+            try {
+                const entry = JSON.parse(line);
+                if (typeof entry.name === 'string') {
+                    counts.set(entry.name, (counts.get(entry.name) ?? 0) + 1);
+                }
+            }
+            catch {
+                // skip malformed
+            }
+        }
+    }
+    catch {
+        // fail-open
+    }
+    return counts;
+}

package/package.json

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

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://claude.ai/schemas/claude-plugin.json",
   "name": "forgen",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "Claude Code harness — the more you use Claude, the better it gets",
   "author": {
     "name": "jang-ujin",

package/skills/calibrate/SKILL.md

@@ -21,7 +21,8 @@ description: This skill should be used when the user asks to "calibrate, 캘리
 calibrate는 두 가지 데이터 소스를 사용합니다:
 
 ### 1차 소스: Evidence 파일
-`~/.forgen/me/evidence/` 디렉토리의 JSON 파일을 읽습니다.
+`~/.forgen/me/behavior/` 디렉토리의 JSON 파일을 읽습니다.
+(파일명: UUID.json — correction-record MCP 도구가 작성. 같은 디렉토리의 auto-*.md 는 auto-compound 산출이므로 calibrate 분석 대상 아님.)
 각 파일의 구조:
 ```json
 {
@@ -52,8 +53,8 @@ evidence 0건 + compound 교정 패턴 0건이면:
 ## Phase 1: Evidence 로드 및 검증
 
 ```bash
-ls ~/.forgen/me/evidence/ 2>/dev/null || echo "EMPTY"
-cat ~/.forgen/me/evidence/*.json 2>/dev/null || echo "NO_FILES"
+ls ~/.forgen/me/behavior/*.json 2>/dev/null || echo "EMPTY"
+cat ~/.forgen/me/behavior/*.json 2>/dev/null || echo "NO_FILES"
 ```
 
 로드한 JSON 파일마다 다음을 검증합니다:

package/skills/retro/SKILL.md

@@ -53,8 +53,8 @@ compound-list
 ### 1-3: 교정 기록
 
 ```bash
-ls -la ~/.forgen/me/evidence/ 2>/dev/null || echo "교정 데이터 없음"
-find ~/.forgen/me/evidence/ -name "*.json" -mtime -{period_days} 2>/dev/null | wc -l
+ls -la ~/.forgen/me/behavior/ 2>/dev/null || echo "교정 데이터 없음"
+find ~/.forgen/me/behavior/ -name "*.json" -mtime -{period_days} 2>/dev/null | wc -l
 ```
 
 ## Phase 2: 코드 활동 분석