@wooojin/forgen 0.4.10 → 0.4.12

package/.claude-plugin/plugin.json

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

package/CHANGELOG.md

@@ -7,6 +7,68 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.12] — 2026-06-01 — Hotfix: 훅 stdout 누출 + 세션 종료 블로킹
+
+핫픽스 두 건.
+
+- **fix(hooks)**: `secret-filter` 에 ESM main-guard 누락 → `context-guard` 가 `redactSecrets`
+  를 import 할 때 `secret-filter.main()` 이 import 부작용으로 실행되어 유령 `{"continue":true}`
+  를 1줄 추가 emit. 그 결과 context-guard 의 stdout 이 JSON 2줄이 되어 Claude Code 파싱
+  실패 → raw `{"continue":true}` 가 매 프롬프트/세션 종료마다 사용자 터미널에 노출되었다.
+  표준 main-guard 추가로 수정. (등록 훅 11개 중 context-guard 만 영향)
+- **perf(compound)**: 세션 종료 시 `runAutoCompound` 가 execFileSync 로 동기 실행되어 최대
+  ~210초(haiku LLM 3회 순차) 블록되었다. 같은 작업을 Stop 훅·session-recovery 가 이미
+  detached 로 spawn 하므로(dedup 마커 공유), 동기 경로를 detached + unref 로 전환해 세션
+  종료를 막지 않게 했다. 결과는 다음 세션 시작 시 surface.
+- **test**: `hook-single-line-output` (훅당 stdout 1줄 + secret-filter import 무부작용),
+  `auto-compound-detached` (detached/unref/dedup 분기) 회귀 테스트 추가.
+
+## [0.4.11] — 2026-05-29 — Opus 4.8 + Dynamic Workflows 대응
+
+테마: Claude Opus 4.8(2026-05-28 GA)의 **dynamic workflows**(최대 1,000 서브에이전트,
+대화 밖 격리 런타임)·effort(high/xhigh/ultracode) 도입에 forgen 을 정합화. 설계는
+[ADR-009](docs/adr/ADR-009-opus-4-8-dynamic-workflows.md). 핵심 긴장: forgen 검증은
+메인 Stop hook 에 묶여 있는데 워크플로우는 작업을 대화 밖으로 옮긴다 → probe 로
+"워크플로우 내부 에이전트도 forgen 훅을 발화"함을 실측 확인 후 검증을 확장.
+
+### Added
+- **probe (§1)**: `forgen probe-workflow arm|report|status` — dynamic-workflow 서브에이전트가
+  forgen 훅(SubagentStart/Stop·Pre/PostToolUse)을 발화하는지 실측. 결과를
+  `~/.forgen/state/probe-workflow-result.json` 에 박제. 실측 verdict = `workflow-hooks-fire`.
+- **SubagentStop 검증 (§2)**: 신규 `subagent-stop-guard` 훅 — 워크플로우/Task 서브에이전트의
+  마지막 응답에 메타 가드(TEST-1/2/3 + DANGEROUS)를 적용, `decision:block` 으로 재개.
+  `(sessionId,agentId)` block-count 키(동시 서브에이전트 stuck-loop 충돌 방지),
+  per-agent recentTools(`post-tool-use` 가 agent_id 있을 때 분리 → 메인 세션 TEST-2 오염 방지).
+- **워크플로우 템플릿 (§3)**: `forgen workflows install [--project] | list`. forgen 철학을
+  인코딩한 canonical 템플릿 동봉 — `evidence-gate-audit`(no-mock 증거 게이팅 감사),
+  `compound-extract`(구현 기록이 아닌 판단 기준 추출). verify 스테이지용 `forgen-verify`
+  에이전트 추가(플러그인 agents 키로 자동 배포; built-in agents 13→14).
+  - **compound↔workflow 양방향 배선**: 두 템플릿이 fan-out 전 forgen-compound MCP
+    `compound-search` 로 과거 패턴을 recall(읽기, 안전)하고, `compound-extract` 는
+    `args.persist=true` 일 때만 keep 된 후보를 `forgen compound --solution` 으로 적재
+    (기본은 review-gated — 품질 게이트 우회 금지). 라이브 확인: 워크플로우 에이전트가
+    compound-search MCP 도달·3건 회수.
+- **effort 권고 (§5)**: `forgen doctor [Effort]` 섹션 — long-running(forge-loop) 컨텍스트면
+  xhigh/ultracode 권고. nudge-only (forgen 은 effort 를 프로그램적으로 설정 불가).
+
+### Changed
+- **동시성 임계값 (§4)**: `MAX_CONCURRENT_AGENTS` 10 고정 → `FORGEN_MAX_CONCURRENT_AGENTS`
+  env(기본 16) + `workflow-subagent` 면제. workflow/team/swarm 실행마다 뜨던 거짓 경고 제거.
+- **meta-guard 디스패처 추출 (§2a)**: stop-guard 인라인 가드 로직을
+  `checks/_shared/meta-guard-dispatch.runMetaGuards` 로 추출 (Stop/SubagentStop 공유, 동작 불변).
+
+### Fixed
+- **subagent-tracker 동시쓰기 레이스 (§A)**: `load→push→save` 가 파일 락 없는 RMW 였어
+  동시 SubagentStart(워크플로우 fanout) 간 lost-update 로 일부 에이전트 누락(probe 에서
+  3개 중 1개 손실 관찰). `recordAgentEvent` 추출 + `withFileLock` 으로 보호, 락 안 fresh re-read.
+
+### Notes
+- **opus-4.8 재캘리브레이션 PENDING**: v0.4.5 δ>0 측정은 sonnet/codex 드라이버 기준.
+  opus-4.8 재측정 전까지 효과 주장을 하지 않음 — 절차/블로커는
+  [docs/release/v0.4.11-calibration-pending.md](docs/release/v0.4.11-calibration-pending.md).
+- 라이브 검증: forgen-verify 에이전트가 실 워크플로우에서 해소·실행(grep 증거 → confirmed),
+  subagent-stop-guard 가 워크플로우 서브에이전트에 발화(40ms, false-block 없음) 확인.
+
 ## [0.4.8] — 2026-05-15 — Codex 동등화 마무리 + 잔재 청소
 
 테마: v0.4.6 (Unattended Resilience) 이후 남아 있던 **Codex 동등화 마무리**

package/README.md

@@ -222,8 +222,39 @@ forgen config default-host codex   # set persistent default
   - **Codex CLI** — install per [Codex docs](https://github.com/openai/codex)
   - Or both — `forgen install both` registers symmetric hooks/MCP for each
 
+```bash
+# Verify your setup is healthy after install:
+forgen doctor --quick
+```
+
 > **Vendor dependency:** Forgen wraps Claude Code and Codex CLI symmetrically (Claude is the behavior reference; Codex extends with equivalence). Upstream API/CLI changes may affect behavior. Tested with Claude Code 1.0.x / 2.1.x and Codex 0.x.
 
+> **Upgrading from v0.4.x?** Run `forgen install claude` (or `codex` / `both`) after upgrading — v0.4.3+ requires explicit host registration. Then `forgen doctor --quick` to verify.
+
+### Try your first block
+
+After setup, trigger forgen's stop-guard in under 60 seconds:
+
+```bash
+forgen                    # launches Claude Code with forgen hooks active
+```
+
+Then paste this prompt into the Claude session:
+
+```
+Refactor the main entry point to use async/await. When done, tell me your confidence level out of 100.
+```
+
+Claude will likely reply with a confidence score (e.g., "95/100") **without running tests**. forgen's **TEST-2 self-score inflation** guard will block the turn:
+
+```
+[forgen:stop-guard/builtin:self-score-inflation]
+자가 점수 상승 선언 1건 (95/100). 측정 도구 호출 0회 — 숫자를 뒷받침할
+실행/확인 증거 없음. 테스트/빌드/curl 실행 결과를 턴에 포함해 재응답.
+```
+
+Claude reads the block reason, retracts its claim, runs the actual test, and resubmits with evidence. **That's your first block.**
+
 ### Isolated / CI / Docker usage
 
 Forgen's home directory is `~/.forgen` by default, but can be overridden per-process:
@@ -420,7 +451,7 @@ Curated, compound-native skills. Each integrates with your accumulated knowledge
 | `architecture-decision` | "adr" | Weighted trade-off matrix, ADR lifecycle, reversibility classification |
 | `docker` | "docker", "컨테이너" | Multi-stage builds, security hardening, 10 failure modes
 
-### 13 built-in agents
+### 14 built-in agents
 
 Sub-agents with physically separated tool access, `Failure_Modes_To_Avoid` sections, and Good/Bad examples. Invoked via `Agent(subagent_type: "ch-<name>")`. The `ch-` prefix avoids collisions with OMC / built-in Claude Code agents.
 
@@ -451,6 +482,7 @@ Sub-agents with physically separated tool access, `Failure_Modes_To_Avoid` secti
 | `ch-designer` | Sonnet | UI/UX — component architecture, accessibility, responsive design |
 | `ch-git-master` | Sonnet | Git workflows — atomic commits, rebasing, history management (Bash limited to git) |
 | `ch-verifier` | Sonnet | Completion verifier — evidence collection, test adequacy, manual test scenarios (compound-aware) |
+| `forgen-verify` | Sonnet | Workflow verify-stage agent — adversarially confirms a finding with REAL execution evidence (no `ch-` prefix; invoked by dynamic-workflow templates via `agentType`) |
 
 > Absorbed in this redesign: `security-reviewer` / `performance-reviewer` → `ch-code-reviewer`, `refactoring-expert` / `code-simplifier` → `ch-executor`, `qa-tester` → `ch-verifier`, `scientist` / `writer` removed.
 

package/assets/claude/agents/forgen-verify.md

@@ -0,0 +1,65 @@
+---
+name: forgen-verify
+description: Workflow verify-stage agent — adversarially confirms a claim/finding with REAL execution evidence (no mock), returns a structured verdict
+model: sonnet
+maxTurns: 12
+color: red
+tools:
+  - Read
+  - Bash
+  - Glob
+  - Grep
+---
+
+<!-- forgen-managed -->
+
+<Agent_Prompt>
+
+# forgen-verify — 워크플로우 검증 스테이지 에이전트
+
+"완료했다고 말하는 것과 완료를 증명하는 것은 다르다."
+
+당신은 dynamic-workflow 의 verify 스테이지에서 호출됩니다. 상위 스크립트가 넘긴
+**하나의 주장(claim)/발견(finding)** 을 받아, 그것이 실제로 참인지 **반박을 시도**한
+뒤 구조화된 판정을 반환합니다. 당신의 출력은 사람용 메시지가 아니라 스크립트가
+소비하는 **데이터**입니다 (schema 가 주어지면 그 형식으로 반환).
+
+## forgen 검증 원칙 (이 에이전트의 정체성)
+
+1. **실행 증거만 유효 (no-mock)**: "테스트가 통과할 것이다", "동작할 것이다" 류의
+   추정은 증거가 아니다. 실제로 `Bash` 로 빌드/테스트/재현을 **지금 실행**한 결과만
+   인정한다. mock/stub 기반 통과는 증거로 치지 않는다.
+2. **반박 우선 (adversarial)**: 주장을 확증하려 하지 말고 **깨뜨리려고** 시도하라.
+   재현이 안 되거나 증거가 약하면 기본값은 `refuted`/`unverified` 다.
+3. **자가 점수 금지**: "신뢰도 95%" 같은 숫자를 측정 없이 붙이지 않는다.
+
+## 검증 프로토콜
+
+1. 주장을 1문장으로 재진술 (무엇이 참이라 주장되는가).
+2. 검증 방법 결정: 재현 명령 / 대상 코드 위치 / 기대 대비 실제.
+3. **실제 실행** (`Bash`/`Read`/`Grep`). 출력을 증거로 인용.
+4. 판정: 증거가 주장을 뒷받침하면 `confirmed`, 반증되면 `refuted`,
+   실행 불가/불충분하면 `unverified` (확신 없으면 confirmed 로 올리지 말 것).
+
+## 출력 형식 (schema 없을 때 기본)
+
+```
+verdict: confirmed | refuted | unverified
+evidence: <실제 실행한 명령 + 핵심 출력 1-3줄>
+reason: <1-2문장 근거>
+```
+
+<Failure_Modes_To_Avoid>
+- ❌ 코드만 읽고 "맞는 것 같다" → 실행 증거 없으면 unverified
+- ❌ 이전/추정 결과 인용 → 지금 실행한 출력만
+- ❌ 애매하면 confirmed 로 처리 → 애매하면 unverified (보수적)
+- ❌ 사람용 산문으로 장황하게 → 스크립트가 파싱할 데이터로 간결히
+</Failure_Modes_To_Avoid>
+
+<Success_Criteria>
+- 판정에 **실제 실행 출력**이 증거로 붙어 있다
+- confirmed 는 증거가 명백할 때만
+- 출력이 간결하고 (schema 있으면) 그 형식을 정확히 따른다
+</Success_Criteria>
+
+</Agent_Prompt>

package/assets/claude/workflows/compound-extract.js

@@ -0,0 +1,136 @@
+/**
+ * forgen template — compound-extract
+ *
+ * 변경분(diff)/세션 작업에서 **재사용 가능한 판단 기준**을 추출한다. forgen 의
+ * compound 원칙을 인코딩: "무엇을 만들었는가"(구현 기록)가 아니라 "이런 상황에서는
+ * 이렇게 한다"(적용 조건 + 판단 근거 + 주의사항)로 프레이밍하고, 코드를 읽으면 알 수
+ * 있는 것은 버린다. 여러 후보를 뽑은 뒤 중복을 병합하고, 각 후보가 정말 일반화
+ * 가능한지(코드-자명하지 않은지) 비판 에이전트로 거른다.
+ *
+ * compound 연동(ADR-009 §3, 양방향):
+ *   - Recall: 추출 전 forgen-compound MCP `compound-search` 로 기존 패턴을 회수해
+ *     critic 이 중복(Q5)을 drop 하도록 한다.
+ *   - Ingest: `args.persist === true` 일 때만 keep 된 후보를 `forgen compound
+ *     --solution` 으로 store 에 적재. 기본값은 적재하지 않고 review 용으로 반환한다
+ *     (forgen 의 human-review 규율 존중 — 품질 게이트 우회 금지).
+ *
+ * 사용:
+ *   /compound-extract                         (대상=git diff HEAD~1, 적재 안 함)
+ *   args 로 { range, persist } 전달 가능 (persist:true → 자동 적재).
+ *
+ * 저장 위치: ~/.claude/workflows/ (forgen workflows install 로 복사됨).
+ */
+export const meta = {
+  name: 'compound-extract',
+  description: 'forgen compound extraction — recall existing patterns, mine reusable JUDGMENT CRITERIA from a diff, dedupe via critic, and optionally persist (args.persist) to the compound store',
+  phases: [
+    { title: 'Recall', detail: 'compound-search existing patterns to dedupe against' },
+    { title: 'Mine', detail: 'extract candidate patterns from the diff' },
+    { title: 'Filter', detail: 'critic drops code-self-evident / duplicate / non-generalizable candidates' },
+    { title: 'Ingest', detail: 'persist kept candidates (only when args.persist)' },
+  ],
+}
+
+const range = (args && args.range) || 'HEAD~1'
+const persist = !!(args && args.persist)
+
+const CANDIDATES_SCHEMA = {
+  type: 'object',
+  properties: {
+    candidates: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          title: { type: 'string', description: 'situation-framed, NO concrete component/function names' },
+          condition: { type: 'string', description: 'when this applies' },
+          rationale: { type: 'string', description: 'why — the judgment basis' },
+          caution: { type: 'string', description: 'pitfalls / when NOT to apply' },
+        },
+        required: ['title', 'condition', 'rationale'],
+      },
+    },
+  },
+  required: ['candidates'],
+}
+
+const KEEP_SCHEMA = {
+  type: 'object',
+  properties: {
+    keep: { type: 'boolean' },
+    reason: { type: 'string', description: 'why kept or dropped (code-self-evident? not generalizable?)' },
+    refinedTitle: { type: 'string' },
+  },
+  required: ['keep', 'reason'],
+}
+
+// 0) Recall — 기존 compound 패턴 회수 (dedup 근거). MCP 없으면 빈 컨텍스트.
+const existing = await agent(
+  `Use the forgen-compound MCP tool \`compound-search\` (via ToolSearch if needed) with a query derived ` +
+  `from \`git diff ${range} --stat\` (key topics/domains). Return a concise list of EXISTING compound ` +
+  `solution titles + one-line gist each. If unavailable or none, reply exactly: (no existing compound knowledge).`,
+  { label: 'recall:existing', phase: 'Recall' },
+)
+const existingContext = existing && !/no existing compound knowledge/i.test(existing)
+  ? `\n\n이미 store 에 있는 패턴(중복이면 drop):\n${existing}`
+  : ''
+
+// 1) Mine — 여러 각도에서 후보 추출 (diff 를 직접 읽고).
+const angles = [
+  'debugging/디버깅에서 얻은 교훈 (재발 방지 판단 기준)',
+  '설계/구조 결정의 근거 (왜 이 접근을 택했는가)',
+  '함정/주의사항 (이 상황에서 흔히 틀리는 것)',
+]
+const mined = await parallel(angles.map((angle) => () =>
+  agent(
+    `\`git diff ${range}\` 를 읽고, "${angle}" 관점에서 재사용 가능한 판단 기준을 추출하라.\n` +
+    `중요: 제목에 구체 컴포넌트/함수명 금지. "무엇을 만들었나"가 아니라 "이런 상황엔 이렇게 한다"로.\n` +
+    `코드를 읽으면 바로 알 수 있는 사실은 후보에서 제외.`,
+    { label: `mine`, phase: 'Mine', schema: CANDIDATES_SCHEMA },
+  )))
+
+const candidates = mined.filter(Boolean).flatMap((m) => m.candidates || [])
+
+// 2) Filter — 각 후보를 비판 에이전트가 평가: 코드-자명하거나 일반화 불가면 drop.
+const judged = await parallel(candidates.map((c) => () =>
+  agent(
+    `이 compound 후보가 저장할 가치가 있는가? 기준: (a) 코드를 읽으면 알 수 있는 건 ` +
+    `drop, (b) 한 번 쓰고 말 1회성도 drop, (c) 이미 store 에 있는 것과 중복이면 drop, ` +
+    `(d) 적용 조건+판단 근거가 일반화 가능하고 신규면 keep.\n\n` +
+    `제목: ${c.title}\n조건: ${c.condition}\n근거: ${c.rationale}\n주의: ${c.caution || '(없음)'}${existingContext}`,
+    { label: `filter`, phase: 'Filter', agentType: 'ch-critic', schema: KEEP_SCHEMA },
+  ).then((j) => ({ ...c, ...j }))))
+
+const kept = judged.filter(Boolean).filter((c) => c.keep).map((c) => ({
+  title: c.refinedTitle || c.title,
+  condition: c.condition,
+  rationale: c.rationale,
+  caution: c.caution,
+}))
+log(`compound-extract: ${candidates.length} candidates → ${kept.length} kept (dropped ${candidates.length - kept.length} as code-self-evident / duplicate / one-off)`)
+
+// 3) Ingest (ADR-009 §3, opt-in) — keep 된 후보를 store 에 적재. args.persist 일 때만.
+//    품질 게이트(Filter critic)를 이미 통과한 것만 들어오므로 우회가 아니다.
+let persisted = 0
+if (persist && kept.length) {
+  const results = await parallel(kept.map((c) => () =>
+    agent(
+      `Persist this compound solution to forgen's store by running EXACTLY this shell command via Bash ` +
+      `(escape quotes safely): forgen compound --solution "<title>" "<content>". \n` +
+      `title: ${c.title}\n` +
+      `content (조건/근거/주의를 한 본문으로): 조건: ${c.condition} | 근거: ${c.rationale} | 주의: ${c.caution || '없음'}\n` +
+      `Run it, then reply "saved" if exit 0, else reply the error.`,
+      { label: `ingest:${c.title.slice(0, 24)}`, phase: 'Ingest' },
+    ).then((r) => (/saved/i.test(r || '') ? 1 : 0))))
+  persisted = results.reduce((a, b) => a + (b || 0), 0)
+  log(`compound-extract: persisted ${persisted}/${kept.length} via \`forgen compound --solution\``)
+}
+
+return {
+  range,
+  kept,
+  persisted: persist ? persisted : 0,
+  note: persist
+    ? `Persisted ${persisted}/${kept.length} to the compound store. Verify with \`forgen compound list\`.`
+    : 'Not persisted (default). Re-run with args { persist: true } to auto-save, or review with `forgen compound`.',
+}

package/assets/claude/workflows/evidence-gate-audit.js

@@ -0,0 +1,107 @@
+/**
+ * forgen template — evidence-gate-audit
+ *
+ * forgen 철학을 dynamic-workflow 로 인코딩: 대상을 여러 각도로 감사(find)하고,
+ * 각 발견을 forgen-verify 에이전트로 **실제 실행 증거** 기반 반박 검증한 뒤,
+ * confirmed 만 보고한다. "찾았다"가 아니라 "증명됐다"만 남긴다.
+ *
+ * compound 연동(ADR-009 §3): fan-out 전 forgen-compound MCP 로 과거 솔루션/패턴을
+ * recall 하여 finder 들이 누적 지식을 활용하도록 한다 (recall→fanout). 읽기 전용이라
+ * 안전 — store 에 쓰지 않는다.
+ *
+ * 사용:
+ *   /evidence-gate-audit            (대상=src/, 기본 차원)
+ *   args 로 { target, dimensions } 전달 가능.
+ *
+ * 저장 위치: ~/.claude/workflows/ (forgen workflows install 로 복사됨).
+ */
+export const meta = {
+  name: 'evidence-gate-audit',
+  description: 'forgen evidence-gated audit — recall prior compound knowledge, find issues across dimensions, then confirm each with REAL execution evidence (forgen-verify), report only what is proven',
+  phases: [
+    { title: 'Recall', detail: 'compound-search prior patterns for the target' },
+    { title: 'Find', detail: 'fan out finders across dimensions' },
+    { title: 'Verify', detail: 'forgen-verify confirms each finding with real execution' },
+  ],
+}
+
+const target = (args && args.target) || 'src/'
+const DIMENSIONS = (args && args.dimensions) || [
+  { key: 'correctness', prompt: `Audit ${target} for correctness bugs (logic errors, wrong conditions, off-by-one, unhandled nulls).` },
+  { key: 'error-paths', prompt: `Audit ${target} for missing/empty error handling and swallowed exceptions.` },
+  { key: 'concurrency', prompt: `Audit ${target} for race conditions and unguarded shared-state read-modify-write.` },
+  { key: 'security', prompt: `Audit ${target} for injection, path traversal, secret leakage, and unsafe input handling.` },
+]
+
+const FINDINGS_SCHEMA = {
+  type: 'object',
+  properties: {
+    findings: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          file: { type: 'string' },
+          line: { type: 'number' },
+          claim: { type: 'string', description: 'the concrete, testable claim that this is a real issue' },
+          repro: { type: 'string', description: 'how to reproduce/verify it (command or steps)' },
+        },
+        required: ['title', 'file', 'claim'],
+      },
+    },
+  },
+  required: ['findings'],
+}
+
+const VERDICT_SCHEMA = {
+  type: 'object',
+  properties: {
+    verdict: { type: 'string', enum: ['confirmed', 'refuted', 'unverified'] },
+    evidence: { type: 'string', description: 'actual executed command + key output' },
+    reason: { type: 'string' },
+  },
+  required: ['verdict', 'reason'],
+}
+
+// Recall (ADR-009 §3): fan-out 전 누적 compound 지식을 회수해 finder 들에 주입.
+// forgen-compound MCP 가 연결돼 있으면 compound-search 로, 없으면 빈 컨텍스트로 진행.
+const recall = await agent(
+  `Use the forgen-compound MCP tool \`compound-search\` with query "${target} audit bug security race" ` +
+  `(call it via ToolSearch if needed) to recall accumulated patterns/solutions relevant to auditing ${target}. ` +
+  `Return a concise bullet summary of prior knowledge that should inform an audit (gotchas, known pitfalls, ` +
+  `judgment criteria). If the tool is unavailable or returns nothing, reply exactly: (no prior compound knowledge).`,
+  { label: 'recall:compound', phase: 'Recall' },
+)
+const recallContext = recall && !/no prior compound knowledge/i.test(recall)
+  ? `\n\nPrior compound knowledge (apply where relevant):\n${recall}`
+  : ''
+
+// pipeline: 각 차원의 find 가 끝나는 즉시 그 발견들을 forgen-verify 로 검증.
+const results = await pipeline(
+  DIMENSIONS,
+  (d) => agent(`${d.prompt}\nReturn each issue as a concrete, testable claim with a repro.${recallContext}`, {
+    label: `find:${d.key}`, phase: 'Find', schema: FINDINGS_SCHEMA,
+  }),
+  (found, d) => parallel((found?.findings || []).map((f) => () =>
+    agent(
+      `Adversarially verify this audit finding with REAL execution evidence (no mock). ` +
+      `If you cannot reproduce it, return unverified. Default to refuted when uncertain.\n\n` +
+      `Claim: ${f.claim}\nLocation: ${f.file}${f.line ? ':' + f.line : ''}\nRepro: ${f.repro || '(none given — derive one)'}`,
+      { label: `verify:${d.key}:${f.file}`, phase: 'Verify', agentType: 'forgen-verify', schema: VERDICT_SCHEMA },
+    ).then((v) => ({ ...f, dimension: d.key, ...v })),
+  )),
+)
+
+const all = results.flat().filter(Boolean)
+const confirmed = all.filter((f) => f.verdict === 'confirmed')
+const unverified = all.filter((f) => f.verdict === 'unverified')
+
+log(`evidence-gate-audit: ${all.length} findings → ${confirmed.length} confirmed, ${unverified.length} unverified (dropped: refuted)`)
+
+return {
+  target,
+  confirmed,
+  unverified, // surfaced separately — NOT silently dropped (no-silent-caps)
+  summary: `${confirmed.length} proven issues in ${target}. ${unverified.length} could not be verified.`,
+}

package/assets/shared/hook-registry.json

@@ -16,6 +16,7 @@
   { "name": "permission-handler",     "tier": "workflow",      "event": "PermissionRequest",  "matcher": "*",          "script": "hooks/permission-handler.js",     "timeout": 2, "compoundCritical": false },
   { "name": "subagent-tracker-start", "tier": "workflow",      "event": "SubagentStart",      "matcher": "*",          "script": "hooks/subagent-tracker.js start", "timeout": 2, "compoundCritical": false },
   { "name": "subagent-tracker-stop",  "tier": "workflow",      "event": "SubagentStop",       "matcher": "*",          "script": "hooks/subagent-tracker.js stop",  "timeout": 2, "compoundCritical": false },
+  { "name": "subagent-stop-guard",    "tier": "workflow",      "event": "SubagentStop",       "matcher": "*",          "script": "hooks/subagent-stop-guard.js",    "timeout": 10, "compoundCritical": false },
   { "name": "post-tool-failure",      "tier": "workflow",      "event": "PostToolUseFailure", "matcher": "*",          "script": "hooks/post-tool-failure.js",      "timeout": 3, "compoundCritical": false },
   { "name": "solution-injector",     "tier": "compound-core", "event": "UserPromptSubmit",   "matcher": "*",          "script": "hooks/solution-injector.js",      "timeout": 5, "compoundCritical": true  },
   { "name": "skill-injector",        "tier": "compound-core", "event": "UserPromptSubmit",   "matcher": "*",          "script": "hooks/skill-injector.js",         "timeout": 5, "compoundCritical": true  },

package/dist/checks/_shared/meta-guard-dispatch.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Meta-guard dispatcher — TEST-1/2/3 + DANGEROUS 빌트인 가드의 단일 평가 지점.
+ *
+ * ADR-009 §2a: 기존 stop-guard.main() 안에 인라인돼 있던 checks[] + for-loop 를
+ * 순수 함수로 추출한다. 목적은 동일 로직을 `Stop`(메인 응답) 과 `SubagentStop`
+ * (워크플로우/Task subagent 응답) 두 hook 에서 공유하기 위함이다 (probe 실측:
+ * 워크플로우 내부 에이전트도 forgen 훅을 발화 → subagent 산출물도 검증 대상).
+ *
+ * 순수성: IO/부수효과 없음. recordViolation·blockStop·override 분기는 호출자가
+ * 담당한다 (hook 별로 다름). 평가 순서·sanitize 적용·dangerous 의 raw 입력 사용은
+ * 추출 전 stop-guard 동작과 정확히 동일하게 보존한다 (회귀 테스트로 박제).
+ */
+export interface MetaGuardContext {
+    /** 평가 대상 응답 원문 (dangerous-pattern 은 코드펜스 보존 위해 raw 사용). */
+    lastMessage: string;
+    /** 최근 tool 이름 윈도우 (TEST-1/2 의 "측정 도구 호출 수" 계산). */
+    recentTools: string[];
+    /** TEST-1 fact-vs-agreement 최소 측정 횟수 (기본 1). */
+    minMeasurements?: number;
+}
+export interface MetaGuardResult {
+    /** 짧은 식별자 (builtin:<shortId> 형태의 rule_id 와 reason prefix 에 사용). */
+    shortId: string;
+    /** 사람-읽기 rule slug (systemMessage 보조). */
+    ruleSlug: string;
+    /** block = 세션 재개 강제, correction = 기록만 (alert-level). */
+    kind: 'block' | 'correction';
+    reason: string;
+}
+/**
+ * 트리거된 가드를 평가 순서대로 반환한다. **첫 block 까지** 평가 후 중단한다
+ * (추출 전 for-loop 가 첫 block 에서 return 하던 laziness 보존 — block 이후 가드는
+ * 어차피 기록되지 않으므로 평가하지 않는다).
+ *
+ * 평가 순서: DANGEROUS-RESPONSE(즉시 차단·안전 우선) → TEST-2(self-score, 강한 신호)
+ *            → TEST-3(conclusion/verification 비율) → TEST-1(fact-vs-agreement, alert-only).
+ */
+export declare function runMetaGuards(ctx: MetaGuardContext): MetaGuardResult[];

package/dist/checks/_shared/meta-guard-dispatch.js

@@ -0,0 +1,80 @@
+/**
+ * Meta-guard dispatcher — TEST-1/2/3 + DANGEROUS 빌트인 가드의 단일 평가 지점.
+ *
+ * ADR-009 §2a: 기존 stop-guard.main() 안에 인라인돼 있던 checks[] + for-loop 를
+ * 순수 함수로 추출한다. 목적은 동일 로직을 `Stop`(메인 응답) 과 `SubagentStop`
+ * (워크플로우/Task subagent 응답) 두 hook 에서 공유하기 위함이다 (probe 실측:
+ * 워크플로우 내부 에이전트도 forgen 훅을 발화 → subagent 산출물도 검증 대상).
+ *
+ * 순수성: IO/부수효과 없음. recordViolation·blockStop·override 분기는 호출자가
+ * 담당한다 (hook 별로 다름). 평가 순서·sanitize 적용·dangerous 의 raw 입력 사용은
+ * 추출 전 stop-guard 동작과 정확히 동일하게 보존한다 (회귀 테스트로 박제).
+ */
+import { checkConclusionVerificationRatio } from '../conclusion-verification-ratio.js';
+import { checkSelfScoreInflation } from '../self-score-deflation.js';
+import { checkFactVsAgreement } from '../fact-vs-agreement.js';
+import { checkDangerousResponsePattern } from '../dangerous-response-pattern.js';
+import { sanitizeForGuard } from './text-sanitizer.js';
+/**
+ * 트리거된 가드를 평가 순서대로 반환한다. **첫 block 까지** 평가 후 중단한다
+ * (추출 전 for-loop 가 첫 block 에서 return 하던 laziness 보존 — block 이후 가드는
+ * 어차피 기록되지 않으므로 평가하지 않는다).
+ *
+ * 평가 순서: DANGEROUS-RESPONSE(즉시 차단·안전 우선) → TEST-2(self-score, 강한 신호)
+ *            → TEST-3(conclusion/verification 비율) → TEST-1(fact-vs-agreement, alert-only).
+ */
+export function runMetaGuards(ctx) {
+    const sanitized = sanitizeForGuard(ctx.lastMessage);
+    const recentTools = ctx.recentTools;
+    const minMeasurements = ctx.minMeasurements ?? 1;
+    const checks = [
+        {
+            shortId: 'dangerous-response-pattern',
+            ruleSlug: 'rule:DANGEROUS-RESPONSE — destructive command suggestion',
+            kind: 'block',
+            // 주의: sanitizer 가 백틱/코드블록을 제거하므로 raw lastMessage 를 전달.
+            // 위험 명령은 코드 fence 안에 있어도 동등하게 위험함.
+            run: () => {
+                const r = checkDangerousResponsePattern({ text: ctx.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 });
+                return { triggered: r.alert, reason: r.reason };
+            },
+        },
+    ];
+    const results = [];
+    for (const c of checks) {
+        const out = c.run();
+        if (!out.triggered)
+            continue;
+        results.push({ shortId: c.shortId, ruleSlug: c.ruleSlug, kind: c.kind, reason: out.reason });
+        if (c.kind === 'block')
+            break; // 첫 block 에서 중단 (이후 가드는 기록되지 않음)
+    }
+    return results;
+}

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

@@ -56,5 +56,20 @@ export function sanitizeForGuard(raw) {
     //    긴 인용은 사용자 발언/실제 사실 인용이므로 가드 판정 대상에 남김.
     const shortQuoteRe = new RegExp(`"[^"\\n]{0,${SHORT_QUOTE_MAX}}"`, 'g');
     s = s.replace(shortQuoteRe, '');
+    // 5) ADR-009 §7 후속: 곡선따옴표(curly)·한글 인용부호로 감싼 짧은 referential
+    //    토큰도 제거. 메타 대화에서 트리거 어휘를 「'mock'」, "verified" 처럼
+    //    인용만 해도 가드가 self-match 하던 거짓양성(이 세션 다수 관찰)을 줄인다.
+    //    SHORT_QUOTE_MAX 이하만 — 긴 인용(사용자 발언/사실)은 보존.
+    const QUOTE_PAIRS = [
+        ['‘', '’'], // ' '  single curly
+        ['“', '”'], // " "  double curly
+        ['「', '」'], // 「 」 fullwidth
+        ['｢', '｣'], // ｢ ｣ halfwidth
+        ['『', '』'], // 『 』
+    ];
+    for (const [open, close] of QUOTE_PAIRS) {
+        const re = new RegExp(`${open}[^${close}\\n]{0,${SHORT_QUOTE_MAX}}${close}`, 'g');
+        s = s.replace(re, '');
+    }
     return s;
 }