@wooojin/forgen 0.4.1 → 0.4.3

package/dist/engine/lifecycle/bypass-detector.js

@@ -4,12 +4,17 @@
  * Rule.policy 자연어에서 "피해야 할 패턴" 을 추출하고, Write/Edit/Bash 도구
  * 출력에서 해당 패턴을 찾아 BypassEntry 후보로 반환한다.
  *
- * Heuristic:
+ * Heuristic priority (most explicit first):
+ *   0) Parenthesized examples (e.g., "(rm -rf, DROP, force-push)") → tokens inside
  *   1) "use X not Y" / "use X instead of Y" / "X over Y" → bypass = Y
  *   2) "avoid X" / "don't use X" / "never use X" / "do not use X" → bypass = X
  *   3) Korean: "X 말라" / "X 금지" / "X 하지 않" → bypass = X
  *   4) 그 외: 빈 배열 (탐지 불가).
  *
+ * Stop list filter: generic Korean verbs (실행/사용/선언/...) extracted by Korean
+ * heuristic are removed — they cause massive FP (RC5/E9: matched the word "실행"
+ * everywhere instead of "rm -rf"). 64 false-positive bypasses observed before fix.
+ *
  * 반환된 패턴은 escape 된 정규식 문자열 — caller 가 `new RegExp(p)` 로 사용.
  */
 function escapeRegex(s) {
@@ -29,9 +34,50 @@ function trimPunct(s) {
     out = out.replace(/^[,;:!?"'`(]+|[.,;:!?"'`)]+$/g, '');
     return out;
 }
+/**
+ * Generic Korean verbs/words that produce massive false positives if used as
+ * bypass patterns (RC5/E9 fix). Extending requires retro evidence.
+ */
+const KO_GENERIC_STOP_WORDS = new Set([
+    '실행', '사용', '선언', '수행', '처리', '작성', '호출', '적용',
+    '실행하지', '사용하지', '선언하지', '수행하지', '처리하지',
+    // English fallthroughs (already low value as bypass signals)
+    'use', 'do', 'execute',
+]);
+/** Korean markers that signal the parenthesized content is NOT an example list. */
+const KO_NON_EXAMPLE_MARKERS = ['제외', '한정', '예외', '단서', 'except'];
+/** Extract concrete tokens inside parenthesized example list. */
+function extractParenthesizedExamples(p) {
+    const out = [];
+    // Match (...) groups; multiple groups in policy are uncommon but supported
+    const re = /\(([^)]+)\)/g;
+    let m;
+    while ((m = re.exec(p))) {
+        const inside = m[1];
+        // Skip if it looks like a path (contains "/" before any obvious separator commitment)
+        if (/[a-zA-Z]+\/[a-zA-Z]/.test(inside))
+            continue;
+        // Skip if it's an exclusion / scope-restriction note (Korean markers)
+        if (KO_NON_EXAMPLE_MARKERS.some((mk) => inside.includes(mk)))
+            continue;
+        // Skip if any single segment is suspiciously long (full sentence rather than token)
+        const segs = inside.split(/[,]|\s+(?:or|와|및)\s+/i).map((s) => s.trim());
+        if (segs.some((s) => s.length > 30))
+            continue;
+        const tokens = segs
+            .map((t) => trimPunct(t))
+            .filter((t) => t.length >= 2 && !KO_GENERIC_STOP_WORDS.has(t));
+        out.push(...tokens);
+    }
+    return out;
+}
 export function extractBypassPatterns(rule) {
     const patterns = [];
     const p = rule.policy;
+    // 0) Parenthesized examples (highest priority — explicit signal)
+    for (const ex of extractParenthesizedExamples(p)) {
+        patterns.push(escapeRegex(ex));
+    }
     // use X not Y / use X instead of Y / use X over Y
     // X, Y may contain dots (e.g., ".then()", "vi.mock"). Strip trailing punctuation.
     const useNot = p.match(/\b(?:use|prefer|choose)\s+(\S+?)\s+(?:not|instead\s+of|over|rather\s+than)\s+(\S+)/i);
@@ -43,10 +89,16 @@ export function extractBypassPatterns(rule) {
         patterns.push(escapeRegex(trimPunct(avoid[1])));
     // Korean: "X 말라" / "X 금지" / "X 하지 마"
     const ko = p.match(/(\S+)\s*(?:말라|금지|하지\s*마|쓰지\s*마)/);
-    if (ko)
-        patterns.push(escapeRegex(trimPunct(ko[1])));
-    // Dedupe + filter trivial
-    return [...new Set(patterns)].filter((pat) => pat.length >= 2);
+    if (ko) {
+        const candidate = trimPunct(ko[1]);
+        if (!KO_GENERIC_STOP_WORDS.has(candidate)) {
+            patterns.push(escapeRegex(candidate));
+        }
+    }
+    // Dedupe + filter trivial + filter stop-words (defense in depth)
+    return [...new Set(patterns)]
+        .filter((pat) => pat.length >= 2)
+        .filter((pat) => !KO_GENERIC_STOP_WORDS.has(pat.replace(/\\/g, '')));
 }
 /**
  * Pure — rules + tool output 으로 bypass candidates 추출.

package/dist/fgx.js

@@ -6,6 +6,7 @@
 import { resolveLaunchContext } from './services/session.js';
 import { prepareHarness, isFirstRun } from './core/harness.js';
 import { spawnClaude } from './core/spawn.js';
+import { getHostRuntime } from './host/host-runtime.js';
 const args = process.argv.slice(2);
 // 이미 포함되어 있으면 중복 추가하지 않음
 const launchContext = resolveLaunchContext(args);
@@ -43,7 +44,7 @@ async function main() {
         console.log(`[forgen] Trust: ${v1.session.effective_trust_policy}`);
     }
     console.log('[forgen] Mode: dangerously-skip-permissions');
-    const runtimeLabel = runtime === 'codex' ? 'Codex' : 'Claude';
+    const runtimeLabel = getHostRuntime(runtime).displayName;
     console.log(`[forgen] Starting ${runtimeLabel}...\n`);
     await spawnClaude(launchArgs, context, runtime);
 }

package/dist/forge/evidence-processor.js

@@ -8,6 +8,7 @@
 import { createEvidence, appendEvidence } from '../store/evidence-store.js';
 import { createRule, saveRule } from '../store/rule-store.js';
 import { classify, applyProposal } from '../engine/enforce-classifier.js';
+import { bumpAxisConfidence } from '../store/profile-store.js';
 // ── Correction → Evidence + Temporary Rule ──
 /**
  * 사용자 교정을 Evidence로 기록하고, 필요 시 temporary rule 생성.
@@ -31,6 +32,17 @@ export function processCorrection(req) {
         },
     });
     appendEvidence(evidence); // T1 lifecycle trigger fires here for explicit_correction
+    // D2 fix (2026-04-27): explicit_correction 의 axis_hint 가 axes confidence 에
+    // 직접 반영되도록 bump. autonomy 6건이 score 못 움직였던 결함 해결.
+    // 회귀 안전: facet 값은 안 건드리고 confidence 만 +0.02 (avoid-this 는 +0.04
+    // 로 더 강한 신호). docs/issues/D2-autonomy-facet-stuck.md 참조.
+    if (req.axis_hint) {
+        const bump = req.kind === 'avoid-this' ? 0.04 : 0.02;
+        try {
+            bumpAxisConfidence(req.axis_hint, bump);
+        }
+        catch { /* fail-open */ }
+    }
     // fix-now, avoid-this → temporary session rule
     let temporaryRule = null;
     if (req.kind === 'fix-now' || req.kind === 'avoid-this') {

package/dist/forge/onboarding.d.ts

@@ -1,8 +1,9 @@
 /**
  * Forgen v1 — Onboarding
  *
- * 2문항 온보딩, 점수 계산, pack 추천.
- * Authoritative spec: docs/plans/2026-04-03-forgen-onboarding-adaptation-spec.md §3-4
+ * 4문항 온보딩 (quality / autonomy / judgment / communication 4축), 점수 계산, pack 추천.
+ * Authoritative spec: docs/history/2026-04-03-tenetx-onboarding-adaptation-spec.md
+ *   (spec §3 은 v0.1 시점 2문항 기준 — v0.4 부터 4문항으로 확장됨, src/forge/onboarding-cli.ts:69-75 참조)
  */
 import type { QualityPack, AutonomyPack, JudgmentPack, CommunicationPack, TrustPolicy, PackRecommendation } from '../store/types.js';
 export type ChoiceId = 'A' | 'B' | 'C';

package/dist/forge/onboarding.js

@@ -1,8 +1,9 @@
 /**
  * Forgen v1 — Onboarding
  *
- * 2문항 온보딩, 점수 계산, pack 추천.
- * Authoritative spec: docs/plans/2026-04-03-forgen-onboarding-adaptation-spec.md §3-4
+ * 4문항 온보딩 (quality / autonomy / judgment / communication 4축), 점수 계산, pack 추천.
+ * Authoritative spec: docs/history/2026-04-03-tenetx-onboarding-adaptation-spec.md
+ *   (spec §3 은 v0.1 시점 2문항 기준 — v0.4 부터 4문항으로 확장됨, src/forge/onboarding-cli.ts:69-75 참조)
  */
 import { createRecommendation } from '../store/recommendation-store.js';
 // 질문 1: 애매한 구현 요청 + 인접 영향 가능성

package/dist/hooks/db-guard.js

@@ -9,7 +9,7 @@ import * as path from 'node:path';
 import { readStdinJSON } from './shared/read-stdin.js';
 import { atomicWriteJSON } from './shared/atomic-write.js';
 import { isHookEnabled } from './hook-config.js';
-import { approve, approveWithWarning, deny, failOpenWithTracking } from './shared/hook-response.js';
+import { approve, approveWithWarning, denyOrObserve, failOpenWithTracking } from './shared/hook-response.js';
 import { STATE_DIR } from '../core/paths.js';
 import { preprocessForMatch } from './shared/command-parser.js';
 const FAIL_COUNTER_PATH = path.join(STATE_DIR, 'db-guard-fail-counter.json');
@@ -89,7 +89,7 @@ async function main() {
     if (!data) {
         const failCount = getAndIncrementFailCount();
         if (failCount >= FAIL_CLOSE_THRESHOLD) {
-            console.log(deny(`[Forgen] DB Guard: stdin parse failed ${failCount} consecutive times — blocking for safety.`));
+            console.log(denyOrObserve('db-guard', `[Forgen] DB Guard: stdin parse failed ${failCount} consecutive times — blocking for safety.`));
         }
         else {
             process.stderr.write(`[ch-hook] db-guard stdin parse failed (${failCount}/${FAIL_CLOSE_THRESHOLD})\n`);
@@ -106,7 +106,7 @@ async function main() {
     const toolInput = data.tool_input ?? data.toolInput ?? {};
     const check = checkDangerousSql(toolName, toolInput);
     if (check.action === 'block') {
-        console.log(deny(`[Forgen] Dangerous SQL blocked: ${check.description}`));
+        console.log(denyOrObserve('db-guard', `[Forgen] Dangerous SQL blocked: ${check.description}`));
         return;
     }
     if (check.action === 'warn') {

package/dist/hooks/forge-loop-progress.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * Forgen — Forge Loop Progress Injector
+ *
+ * Claude Code UserPromptSubmit 훅. forge-loop active=true 인 동안 매 프롬프트
+ * 마다 진행 상황(N/M, next story)을 컨텍스트에 inject 한다. RC6 가드의 두 번째
+ * 축 — 세션 도중에도 forge-loop 가 컨텍스트에서 사라지지 않게 함.
+ */
+export {};

package/dist/hooks/forge-loop-progress.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+/**
+ * Forgen — Forge Loop Progress Injector
+ *
+ * Claude Code UserPromptSubmit 훅. forge-loop active=true 인 동안 매 프롬프트
+ * 마다 진행 상황(N/M, next story)을 컨텍스트에 inject 한다. RC6 가드의 두 번째
+ * 축 — 세션 도중에도 forge-loop 가 컨텍스트에서 사라지지 않게 함.
+ */
+import { readStdinJSON } from './shared/read-stdin.js';
+import { isHookEnabled } from './hook-config.js';
+import { approve, approveWithContext, failOpenWithTracking } from './shared/hook-response.js';
+import { recordHookTiming } from './shared/hook-timing.js';
+import { readForgeLoopState, renderForgeLoopForPrompt } from './shared/forge-loop-state.js';
+import { createLogger } from '../core/logger.js';
+const log = createLogger('forge-loop-progress');
+async function main() {
+    const _hookStart = Date.now();
+    try {
+        await readStdinJSON().catch((e) => { log.debug('stdin read failed', e); return null; });
+        if (!isHookEnabled('forge-loop-progress')) {
+            console.log(approve());
+            return;
+        }
+        const block = renderForgeLoopForPrompt(readForgeLoopState());
+        if (!block) {
+            console.log(approve());
+            return;
+        }
+        console.log(approveWithContext(block, 'UserPromptSubmit'));
+    }
+    finally {
+        recordHookTiming('forge-loop-progress', Date.now() - _hookStart, 'UserPromptSubmit');
+    }
+}
+main().catch((e) => {
+    process.stderr.write(`[ch-hook] forge-loop-progress: ${e instanceof Error ? e.message : String(e)}\n`);
+    console.log(failOpenWithTracking('forge-loop-progress', e));
+});

package/dist/hooks/hook-registry.js

@@ -20,7 +20,7 @@ const require = createRequire(import.meta.url);
  *     (Code Reflection + permission hints 주입 타이밍)
  *   - 같은 이벤트 내 훅은 배열 순서대로 실행됨
  */
-import registryData from '../../hooks/hook-registry.json' with { type: 'json' };
+import registryData from '../../assets/shared/hook-registry.json' with { type: 'json' };
 export const HOOK_REGISTRY = registryData;
 /** 티어별 훅 목록 조회 */
 export function getHooksByTier(tier) {

package/dist/hooks/hooks-generator.d.ts

@@ -9,7 +9,7 @@
  *   - forgen config hooks (사용자 설정 변경 후)
  *   - forgen install (플러그인 설치 후)
  */
-import { type RuntimeHost } from '../core/types.js';
+import type { RuntimeHost } from '../core/types.js';
 interface HookCommand {
     type: 'command';
     command: string;
@@ -30,6 +30,12 @@ interface GenerateOptions {
     pluginRoot?: string;
     /** 런타임 (claude|codex) */
     runtime?: RuntimeHost;
+    /**
+     * 환경 독립 산출물 모드 (W4, 2026-04-27).
+     * true 시 plugin 감지 + hook-config 비활성화 모두 건너뛰어 모든 hook 이 active.
+     * 배포(prepack), 테스트 결정론, runtime 환경 분리에 사용.
+     */
+    releaseMode?: boolean;
 }
 /**
  * 활성 훅만 포함한 hooks.json 객체를 생성합니다.
@@ -39,6 +45,14 @@ interface GenerateOptions {
  *   2. 충돌 훅 식별
  *   3. hook-config.json 설정 적용
  *   4. 활성 훅만 hooks.json 구조로 변환
+ *
+ * releaseMode: 환경 독립 산출물 모드 (W4, 2026-04-27).
+ *   - true 시 plugin 감지를 건너뛰고, hook-config.json 의 사용자 비활성화도 무시한다.
+ *   - 결과는 항상 모든 hook active — 배포 산출물 결정론화 + 테스트 안정화.
+ *   - prepack-hooks.cjs 는 이미 HOME swap 으로 같은 효과를 내지만, 본 옵션은
+ *     명시적 API 로 동일 보장을 제공해 테스트가 환경 독립 검증 가능.
+ *   - 자기증거: 본 세션이 사용자 HOME 에서 19/21 active 산출물을 받아 우회한
+ *     사례 — docs/issues/W4-W5-self-evidence.md 박제.
  */
 export declare function generateHooksJson(options?: GenerateOptions): HooksJson;
 /**

package/dist/hooks/hooks-generator.js

@@ -14,6 +14,7 @@ import * as path from 'node:path';
 import { HOOK_REGISTRY } from './hook-registry.js';
 import { isHookEnabled } from './hook-config.js';
 import { detectInstalledPlugins, getHookConflicts } from '../core/plugin-detector.js';
+import { getHostRuntime } from '../host/host-runtime.js';
 function splitCommand(raw) {
     const tokens = raw.match(/"([^"]+)"|\S+/g) ?? [];
     const unquoted = tokens.map(token => token.replace(/^"/, '').replace(/"$/, ''));
@@ -24,16 +25,9 @@ function quoteArg(raw) {
 }
 function buildHookCommand(pluginRoot, rawScript, runtime) {
     const { script, args } = splitCommand(rawScript);
-    const scriptPath = `${pluginRoot}/${script}`;
     const quotedArgs = args.map(quoteArg).join(' ');
-    if (runtime === 'codex') {
-        const adapterPath = `${pluginRoot}/host/codex-adapter.js`;
-        const baseCommand = `node ${quoteArg(adapterPath)} ${quoteArg(scriptPath)}`;
-        return `${baseCommand}${quotedArgs ? ` ${quotedArgs}` : ''}`;
-    }
-    return quotedArgs
-        ? `node ${quoteArg(scriptPath)} ${quotedArgs}`
-        : `node ${quoteArg(scriptPath)}`;
+    // Phase 2: host-runtime 위임 — Codex 표면 (codex-adapter 경유) 을 core 가 모르도록.
+    return getHostRuntime(runtime).wrapHookCommand(pluginRoot, script, quotedArgs);
 }
 /**
  * 활성 훅만 포함한 hooks.json 객체를 생성합니다.
@@ -43,23 +37,31 @@ function buildHookCommand(pluginRoot, rawScript, runtime) {
  *   2. 충돌 훅 식별
  *   3. hook-config.json 설정 적용
  *   4. 활성 훅만 hooks.json 구조로 변환
+ *
+ * releaseMode: 환경 독립 산출물 모드 (W4, 2026-04-27).
+ *   - true 시 plugin 감지를 건너뛰고, hook-config.json 의 사용자 비활성화도 무시한다.
+ *   - 결과는 항상 모든 hook active — 배포 산출물 결정론화 + 테스트 안정화.
+ *   - prepack-hooks.cjs 는 이미 HOME swap 으로 같은 효과를 내지만, 본 옵션은
+ *     명시적 API 로 동일 보장을 제공해 테스트가 환경 독립 검증 가능.
+ *   - 자기증거: 본 세션이 사용자 HOME 에서 19/21 active 산출물을 받아 우회한
+ *     사례 — docs/issues/W4-W5-self-evidence.md 박제.
  */
 export function generateHooksJson(options) {
     const cwd = options?.cwd;
+    const releaseMode = options?.releaseMode ?? false;
     // biome-ignore lint/suspicious/noTemplateCurlyInString: CLAUDE_PLUGIN_ROOT is a Claude Code Plugin SDK variable resolved at runtime
     const pluginRoot = options?.pluginRoot ?? '${CLAUDE_PLUGIN_ROOT}/dist';
     const runtime = options?.runtime ?? 'claude';
-    // 다른 플러그인의 충돌 훅 감지
-    const hookConflicts = getHookConflicts(cwd);
-    const detectedPlugins = detectInstalledPlugins(cwd);
-    const hasOtherPlugins = detectedPlugins.length > 0;
+    // 다른 플러그인의 충돌 훅 감지 — releaseMode 시 건너뜀
+    const hookConflicts = releaseMode ? new Set() : getHookConflicts(cwd);
+    const hasOtherPlugins = !releaseMode && detectInstalledPlugins(cwd).length > 0;
     // 활성 훅 필터링
     const activeHooks = HOOK_REGISTRY.filter(hook => {
-        // 1) hook-config.json에서 명시적 비활성화
-        if (!isHookEnabled(hook.name))
+        // 1) hook-config.json에서 명시적 비활성화 (releaseMode 시 무시)
+        if (!releaseMode && !isHookEnabled(hook.name))
             return false;
         // 2) 다른 플러그인과 충돌하는 workflow 훅은 자동 비활성
-        //    (단, compound-critical 훅은 항상 유지)
+        //    (단, compound-critical 훅은 항상 유지. releaseMode 면 분기 조건이 false)
         if (hasOtherPlugins && hook.tier === 'workflow' && hookConflicts.has(hook.name) && !hook.compoundCritical) {
             return false;
         }

package/dist/hooks/keyword-detector.js

@@ -106,7 +106,7 @@ function loadSkillContent(skillName) {
     // 글로벌 스킬 경로
     searchPaths.push(path.join(FORGEN_HOME, 'skills', `${skillName}.md`));
     // forgen 패키지 내장 스킬
-    const pkgSkillPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'commands', `${skillName}.md`);
+    const pkgSkillPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'assets', 'claude', 'commands', `${skillName}.md`);
     searchPaths.push(pkgSkillPath);
     for (const p of searchPaths) {
         if (fs.existsSync(p)) {

package/dist/hooks/post-tool-use.d.ts

@@ -38,7 +38,7 @@ export interface AgentValidationResult {
     severity: 'info' | 'warning' | 'error';
     message: string;
 }
-export declare function validateAgentOutput(toolResponse: string): AgentValidationResult | null;
+export declare function validateAgentOutput(toolResponse: unknown): AgentValidationResult | null;
 export declare function trackModifiedFile(state: ModifiedFilesState, filePath: string, toolName: string): {
     state: ModifiedFilesState;
     count: number;

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

@@ -75,15 +75,21 @@ const AGENT_QUALITY_PATTERNS = [
     { pattern: /(?:context (?:window|limit) (?:exceeded|reached)|too (?:large|long) to (?:read|process))/i, signal: 'agent_context_overflow', severity: 'warning', message: 'Agent hit context limits — output may be incomplete' },
 ];
 export function validateAgentOutput(toolResponse) {
-    if (!toolResponse || toolResponse.trim().length < AGENT_MIN_OUTPUT_LENGTH) {
+    // tool_response 는 string / object / array 모두 가능. main() 측에서 stringify 를 한 번 더
+    // 하지만 직접 호출 보호 (defense in depth).
+    if (typeof toolResponse !== 'string') {
+        toolResponse = toolResponse == null ? '' : JSON.stringify(toolResponse);
+    }
+    const r = toolResponse;
+    if (!r || r.trim().length < AGENT_MIN_OUTPUT_LENGTH) {
         return {
             signal: 'agent_empty_output',
             severity: 'warning',
-            message: `Agent returned minimal output (${toolResponse?.trim().length ?? 0} chars). Verify the result is usable.`,
+            message: `Agent returned minimal output (${r.trim().length} chars). Verify the result is usable.`,
         };
     }
     for (const p of AGENT_QUALITY_PATTERNS) {
-        if (p.pattern.test(toolResponse)) {
+        if (p.pattern.test(r)) {
             return { signal: p.signal, severity: p.severity, message: p.message };
         }
     }
@@ -114,7 +120,10 @@ async function main() {
         }
         const toolName = data.tool_name ?? data.toolName ?? '';
         const toolInput = data.tool_input ?? data.toolInput ?? {};
-        const toolResponse = data.tool_response ?? data.toolOutput ?? '';
+        // tool_response 는 string / object / array 모두 가능 (sub-agent 결과는 object 가 흔함).
+        // 모든 downstream 이 string 가정이라 stringify 로 normalize. 회귀 박제: tests/hooks/post-tool-use.test.ts
+        const rawResponse = data.tool_response ?? data.toolOutput ?? '';
+        const toolResponse = typeof rawResponse === 'string' ? rawResponse : JSON.stringify(rawResponse);
         const sessionId = data.session_id ?? 'default';
         const modState = loadModifiedFiles(sessionId);
         modState.toolCallCount = (modState.toolCallCount ?? 0) + 1;

package/dist/hooks/pre-compact.js

@@ -74,7 +74,7 @@ export function buildSessionBrief(sessionId) {
     }
     catch { /* fail-open */ }
     // solutionsInjected: read injection-cache-*.json files, collect solutions[].name
-    let solutionsInjected = [];
+    const solutionsInjected = [];
     try {
         if (fs.existsSync(STATE_DIR)) {
             for (const f of fs.readdirSync(STATE_DIR)) {

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

@@ -19,7 +19,7 @@ import { sanitizeId } from './shared/sanitize-id.js';
 import { incrementEvidence } from '../engine/solution-writer.js';
 import { isReflectionCandidate } from './compound-reflection.js';
 import { isHookEnabled } from './hook-config.js';
-import { approve, approveWithWarning, deny, failOpenWithTracking } from './shared/hook-response.js';
+import { approve, approveWithWarning, denyOrObserve, failOpenWithTracking } from './shared/hook-response.js';
 import { FORGEN_HOME, STATE_DIR } from '../core/paths.js';
 import { recordHookTiming } from './shared/hook-timing.js';
 import { maskQuotedContent } from './shared/command-parser.js';
@@ -305,7 +305,7 @@ async function main() {
             // for `forgen doctor` / log inspection. Mirrors `db-guard.ts:85-96`.
             const failCount = getAndIncrementFailCount();
             if (failCount >= FAIL_CLOSE_THRESHOLD) {
-                console.log(deny(`[Forgen] PreToolUse: stdin parse failed ${failCount} consecutive times — blocking for safety.`));
+                console.log(denyOrObserve('pre-tool-use', `[Forgen] PreToolUse: stdin parse failed ${failCount} consecutive times — blocking for safety.`));
             }
             else {
                 process.stderr.write(`[ch-hook] pre-tool-use stdin parse failed (${failCount}/${FAIL_CLOSE_THRESHOLD})\n`);
@@ -366,7 +366,7 @@ async function main() {
                         const baseMsg = spec.block_message ?? `[${rule.rule_id}] policy violation: ${rule.policy.slice(0, 120)}`;
                         // G8: override 힌트 — FORGEN_USER_CONFIRMED=1 으로 사용자 명시 승인 가능, 감사 로그 기록됨.
                         const msgWithHint = `${baseMsg}\n\n(override: set FORGEN_USER_CONFIRMED=1 (bypass will be audited in violations.jsonl))`;
-                        console.log(deny(msgWithHint));
+                        console.log(denyOrObserve('pre-tool-use', msgWithHint));
                         return;
                     }
                     if (requiresFlag && confirmed) {
@@ -388,7 +388,7 @@ async function main() {
         // Bash 도구: 위험 명령어 감지 (빌트인 safety net)
         const check = checkDangerousCommand(toolName, toolInput);
         if (check.action === 'block') {
-            console.log(deny(`[Forgen] Dangerous command blocked: ${check.description}\nCommand: ${check.command}`));
+            console.log(denyOrObserve('pre-tool-use', `[Forgen] Dangerous command blocked: ${check.description}\nCommand: ${check.command}`));
             return;
         }
         if (check.action === 'warn') {

package/dist/hooks/rate-limiter.js

@@ -10,7 +10,7 @@ import * as path from 'node:path';
 import { readStdinJSON } from './shared/read-stdin.js';
 import { atomicWriteJSON } from './shared/atomic-write.js';
 import { isHookEnabled } from './hook-config.js';
-import { approve, deny, failOpenWithTracking } from './shared/hook-response.js';
+import { approve, denyOrObserve, failOpenWithTracking } from './shared/hook-response.js';
 import { STATE_DIR } from '../core/paths.js';
 const RATE_LIMIT_PATH = path.join(STATE_DIR, 'rate-limit.json');
 const DEFAULT_LIMIT = 30; // calls per minute
@@ -75,7 +75,7 @@ async function main() {
         saveRateLimitState(updatedState);
     }
     if (exceeded) {
-        console.log(deny(`[Forgen] Rate limit exceeded (${count}/${DEFAULT_LIMIT}/min). Wait before retrying.`));
+        console.log(denyOrObserve('rate-limiter', `[Forgen] Rate limit exceeded (${count}/${DEFAULT_LIMIT}/min). Wait before retrying.`));
         return;
     }
     console.log(approve());

package/dist/hooks/session-recovery.js

@@ -320,6 +320,17 @@ async function main() {
             }
         }
         catch { /* fail-open */ }
+        // US-M1 (RC6 가드): 직전 forge-loop findings 또는 진행 중 stories 자동 inject.
+        // 본 세션 자기증거 — head -80 truncation 으로 findings 누락 → 같은 가설 재발.
+        try {
+            const { readForgeLoopState, renderForgeLoopForSession } = await import('./shared/forge-loop-state.js');
+            const block = renderForgeLoopForSession(readForgeLoopState());
+            if (block)
+                recoveryMessages.push(block);
+        }
+        catch (e) {
+            log.debug('forge-loop findings inject 실패', e);
+        }
         const sessionId = sessionContext.sessionId;
         // 이전 세션 자동 compound (fire-and-forget)
         // /new로 세션 리셋 시 SessionStart가 다시 호출됨 — 이때 이전 transcript를 compound

package/dist/hooks/shared/blocking-allowlist.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Blocking ALLOW-LIST — P3' (2026-04-27)
+ *
+ * 사용자 작업을 차단(block)할 권한을 가진 hook 의 명시적 화이트리스트.
+ * 목록 외 hook 의 부정적 판정은 "관찰 신호"(log only) 로만 처리되어야 한다.
+ *
+ * RC5 (retro-v040): 분산된 detector 가 각자 block 결정을 내리면서 false-positive
+ * 가 메인 로직 흐름까지 차단하는 회귀 패턴 발생. ALLOW-LIST 명시화로 차단 권한
+ * 의 source-of-truth 를 단일화.
+ *
+ * v0.4.2 정책:
+ *   - 본 모듈은 ALLOW-LIST 정의 + 검증 helper. 기존 deny() 직접 호출 hook 들은
+ *     v0.4.2 에서 denyOrObserve(name, reason) 로 마이그레이션 완료.
+ *   - 신규 hook 추가 시 차단 권한이 필요하면 본 ALLOW-LIST 에 추가 + 본 파일의
+ *     사유 문서화 의무. 본 commit diff 가 review 필수 항목.
+ *
+ * 멤버 사유:
+ *   - stop-guard: Stop hook — false-completion 메타 가드 (자가 검증 강제)
+ *   - pre-tool-use: Bash dangerous-pattern + 수동 confirm 가드
+ *   - secret-filter: Write/Edit 결과의 .env / API key 노출 차단
+ *   - db-guard: Bash 의 destructive DB 명령 (DROP/TRUNCATE/DELETE) 차단
+ *   - rate-limiter: 사용자 작업 빈도 임계 초과 시 cool-down 차단 (resource abuse 방어)
+ */
+export declare const BLOCKING_ALLOWLIST: ReadonlySet<string>;
+/** hook 이 block 결정을 출력할 권한이 있는지. */
+export declare function canBlock(hookName: string): boolean;
+/** ALLOW-LIST 에 추가하려는 hook 이 정책 문서화를 요구하는지 (lint helper). */
+export declare function requiresPolicyDoc(hookName: string): boolean;

package/dist/hooks/shared/blocking-allowlist.js

@@ -0,0 +1,38 @@
+/**
+ * Blocking ALLOW-LIST — P3' (2026-04-27)
+ *
+ * 사용자 작업을 차단(block)할 권한을 가진 hook 의 명시적 화이트리스트.
+ * 목록 외 hook 의 부정적 판정은 "관찰 신호"(log only) 로만 처리되어야 한다.
+ *
+ * RC5 (retro-v040): 분산된 detector 가 각자 block 결정을 내리면서 false-positive
+ * 가 메인 로직 흐름까지 차단하는 회귀 패턴 발생. ALLOW-LIST 명시화로 차단 권한
+ * 의 source-of-truth 를 단일화.
+ *
+ * v0.4.2 정책:
+ *   - 본 모듈은 ALLOW-LIST 정의 + 검증 helper. 기존 deny() 직접 호출 hook 들은
+ *     v0.4.2 에서 denyOrObserve(name, reason) 로 마이그레이션 완료.
+ *   - 신규 hook 추가 시 차단 권한이 필요하면 본 ALLOW-LIST 에 추가 + 본 파일의
+ *     사유 문서화 의무. 본 commit diff 가 review 필수 항목.
+ *
+ * 멤버 사유:
+ *   - stop-guard: Stop hook — false-completion 메타 가드 (자가 검증 강제)
+ *   - pre-tool-use: Bash dangerous-pattern + 수동 confirm 가드
+ *   - secret-filter: Write/Edit 결과의 .env / API key 노출 차단
+ *   - db-guard: Bash 의 destructive DB 명령 (DROP/TRUNCATE/DELETE) 차단
+ *   - rate-limiter: 사용자 작업 빈도 임계 초과 시 cool-down 차단 (resource abuse 방어)
+ */
+export const BLOCKING_ALLOWLIST = new Set([
+    'stop-guard',
+    'pre-tool-use',
+    'secret-filter',
+    'db-guard',
+    'rate-limiter',
+]);
+/** hook 이 block 결정을 출력할 권한이 있는지. */
+export function canBlock(hookName) {
+    return BLOCKING_ALLOWLIST.has(hookName);
+}
+/** ALLOW-LIST 에 추가하려는 hook 이 정책 문서화를 요구하는지 (lint helper). */
+export function requiresPolicyDoc(hookName) {
+    return !BLOCKING_ALLOWLIST.has(hookName);
+}

package/dist/hooks/shared/forge-loop-state.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Forge Loop State — RC6 가드 (US-M1)
+ *
+ * 직전 forge-loop 의 findings 또는 진행 중 stories 를 ≤1KB 요약으로 렌더한다.
+ * SessionStart 와 UserPromptSubmit 두 hook 이 공유하는 단일 진입점.
+ *
+ * RC6 자기증거: 본 세션 R1 에서 head -80 으로 forge-loop.json 을 읽어 findings
+ * 8줄(line 92~99)이 잘렸음. 결과적으로 직전 결론을 컨텍스트에 못 가져 같은
+ * 가설을 재발. 이 모듈은 그 회귀를 시스템 레벨에서 차단한다.
+ */
+interface ForgeLoopStory {
+    id: string;
+    title: string;
+    passes?: boolean;
+}
+export interface ForgeLoopState {
+    active?: boolean;
+    task?: string;
+    startedAt?: string;
+    completedAt?: string;
+    stories?: ForgeLoopStory[];
+    findings?: Record<string, string>;
+}
+export declare function readForgeLoopState(filePath?: string): ForgeLoopState | null;
+/** SessionStart 용 — 완료된 forge-loop 의 findings 또는 진행 중 stories 요약. */
+export declare function renderForgeLoopForSession(state: ForgeLoopState | null, now?: number): string | null;
+/** UserPromptSubmit 용 — active=true 시에만 짧은 진행 상황 1~2줄. */
+export declare function renderForgeLoopForPrompt(state: ForgeLoopState | null, now?: number): string | null;
+/** 테스트 노출용 상수 — 회귀 시 임계값 변경 즉시 감지. */
+export declare const FORGE_LOOP_LIMITS: {
+    readonly SOFT_STALE_MS: number;
+    readonly HARD_STALE_MS: number;
+    readonly MAX_INJECT_BYTES: 1024;
+    readonly MAX_PENDING: 5;
+};
+export {};