@wooojin/forgen 0.3.2 → 0.4.0

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

@@ -237,6 +237,68 @@ async function main() {
         catch (e) {
             log.debug('compound negative check 실패', e);
         }
+        // 6a+b. ADR-001 Mech-A PostToolUse + T3 bypass — single rule load, 두 dispatcher 공유.
+        // R2-P perf: 이전에는 6a, 6b 각각 loadActiveRules() 재호출 → file read 2배.
+        if (toolName === 'Write' || toolName === 'Edit' || toolName === 'Bash') {
+            const target = (() => {
+                const c = toolInput.content;
+                if (typeof c === 'string')
+                    return c;
+                const ns = toolInput.new_string;
+                if (typeof ns === 'string')
+                    return ns;
+                const cmd = toolInput.command;
+                if (typeof cmd === 'string')
+                    return cmd;
+                return '';
+            })() || toolResponse;
+            if (target) {
+                try {
+                    const [{ loadActiveRules }, { recordViolation, recordBypass }, { scanForBypass }, { compileSafeRegex, safeRegexTest },] = await Promise.all([
+                        import('../store/rule-store.js'),
+                        import('../engine/lifecycle/signals.js'),
+                        import('../engine/lifecycle/bypass-detector.js'),
+                        import('./shared/safe-regex.js'),
+                    ]);
+                    const rules = loadActiveRules();
+                    // Mech-A pattern_match dispatcher
+                    for (const rule of rules) {
+                        for (const spec of rule.enforce_via ?? []) {
+                            if (spec.hook !== 'PostToolUse' || spec.mech !== 'A')
+                                continue;
+                            const v = spec.verifier;
+                            if (!v || v.kind !== 'pattern_match')
+                                continue;
+                            const pattern = String(v.params?.pattern ?? '');
+                            if (!pattern)
+                                continue;
+                            const re = compileSafeRegex(pattern);
+                            if (!re.regex) {
+                                log.debug(`rule ${rule.rule_id} unsafe regex: ${re.reason}`);
+                                continue;
+                            }
+                            if (!safeRegexTest(re.regex, target))
+                                continue;
+                            recordViolation({
+                                rule_id: rule.rule_id, session_id: sessionId,
+                                source: 'post-tool-guard',
+                                kind: 'block',
+                                message_preview: target.slice(0, 120),
+                            });
+                            messages.push(`<compound-rule-violation>\n[Forgen] Rule ${rule.rule_id.slice(0, 8)} pattern matched in ${toolName} output.\n${spec.block_message ?? rule.policy.slice(0, 120)}\n</compound-rule-violation>`);
+                        }
+                    }
+                    // T3 bypass detection (same rules, same target)
+                    const candidates = scanForBypass({ rules, tool_name: toolName, tool_output: target, session_id: sessionId });
+                    for (const c of candidates) {
+                        recordBypass({ rule_id: c.rule_id, session_id: c.session_id, tool: c.tool, pattern_preview: c.pattern_preview });
+                    }
+                }
+                catch (e) {
+                    log.debug('enforce_via/bypass post-tool dispatch 실패', e);
+                }
+            }
+        }
         // 7. Compound success hint (non-blocking)
         try {
             const successHint = getCompoundSuccessHint(toolName, toolResponse, sessionId);

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

@@ -311,7 +311,63 @@ async function main() {
         const toolName = data.tool_name ?? data.toolName ?? '';
         const toolInput = data.tool_input ?? data.toolInput ?? {};
         const sessionId = data.session_id ?? 'default';
-        // Bash 도구: 위험 명령어 감지
+        // ADR-001 Mech-A PreToolUse dispatcher — 사용자가 정의한 rule 이 빌트인 위험-명령 감지보다 먼저.
+        // 이렇게 해야 rule.block_message (맥락 있는 안내) 가 제네릭 "Dangerous command blocked" 대신 노출됨.
+        // fail-open: 예외는 hook 차단 안 함.
+        try {
+            const [{ loadActiveRules }, { recordViolation }, { compileSafeRegex, safeRegexTest },] = await Promise.all([
+                import('../store/rule-store.js'),
+                import('../engine/lifecycle/signals.js'),
+                import('./shared/safe-regex.js'),
+            ]);
+            const rules = loadActiveRules();
+            const command = typeof toolInput.command === 'string'
+                ? String(toolInput.command)
+                : '';
+            for (const rule of rules) {
+                for (const spec of rule.enforce_via ?? []) {
+                    if (spec.hook !== 'PreToolUse' || spec.mech !== 'A')
+                        continue;
+                    const v = spec.verifier;
+                    if (!v || v.kind !== 'tool_arg_regex')
+                        continue;
+                    const pattern = String(v.params?.pattern ?? '');
+                    if (!pattern)
+                        continue;
+                    const re = compileSafeRegex(pattern, 'i');
+                    if (!re.regex) {
+                        log.debug(`rule ${rule.rule_id} unsafe regex: ${re.reason}`);
+                        continue;
+                    }
+                    if (!safeRegexTest(re.regex, command))
+                        continue;
+                    const requiresFlag = v.params?.requires_flag;
+                    const confirmed = process.env.FORGEN_USER_CONFIRMED === '1';
+                    if (requiresFlag && !confirmed) {
+                        recordViolation({ rule_id: rule.rule_id, session_id: sessionId, source: 'pre-tool-guard', kind: 'deny', message_preview: command.slice(0, 120) });
+                        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));
+                        return;
+                    }
+                    if (requiresFlag && confirmed) {
+                        // H3: 우회 감사 — FORGEN_USER_CONFIRMED 으로 Mech-A 를 우회할 때마다 violation 로그에
+                        // kind='correction' 으로 기록. T3 bypass 누적 대신 별도 채널로 운영자가 monitoring 가능.
+                        recordViolation({
+                            rule_id: rule.rule_id, session_id: sessionId,
+                            source: 'pre-tool-guard',
+                            kind: 'correction', // 'correction' = 사용자 명시 우회, rule 위반이지만 의도된 것
+                            message_preview: `[FORGEN_USER_CONFIRMED=1 bypass] ${command.slice(0, 120)}`,
+                        });
+                    }
+                }
+            }
+        }
+        catch (e) {
+            log.debug('enforce_via[PreToolUse] dispatch 실패', e);
+        }
+        // Bash 도구: 위험 명령어 감지 (빌트인 safety net)
         const check = checkDangerousCommand(toolName, toolInput);
         if (check.action === 'block') {
             console.log(deny(`[Forgen] Dangerous command blocked: ${check.description}\nCommand: ${check.command}`));

package/dist/hooks/secret-filter.d.ts

@@ -10,5 +10,15 @@ export interface SecretPattern {
     pattern: RegExp;
 }
 export declare const SECRET_PATTERNS: SecretPattern[];
+/**
+ * 텍스트에서 민감 정보 패턴을 찾아 `[REDACTED:<NAME>]` 로 치환 (순수 함수).
+ *
+ * R5-G2: auto-compound-runner 가 사용자 transcript 를 Claude (Haiku) 로 송신하기 전
+ * 적용. `detectSecrets` 는 감지만, 이 함수는 실제 문자열에서 대체.
+ */
+export declare function redactSecrets(text: string): {
+    redacted: string;
+    hits: SecretPattern[];
+};
 /** 텍스트에서 민감 정보 패턴 감지 (순수 함수) */
 export declare function detectSecrets(text: string): SecretPattern[];

package/dist/hooks/secret-filter.js

@@ -23,6 +23,26 @@ export const SECRET_PATTERNS = [
     { name: 'Google API Key', pattern: /\bAIza[0-9A-Za-z_-]{35}\b/ },
     { name: 'Slack Token', pattern: /\bxox[abpors]-[A-Za-z0-9-]{10,}/ },
 ];
+/**
+ * 텍스트에서 민감 정보 패턴을 찾아 `[REDACTED:<NAME>]` 로 치환 (순수 함수).
+ *
+ * R5-G2: auto-compound-runner 가 사용자 transcript 를 Claude (Haiku) 로 송신하기 전
+ * 적용. `detectSecrets` 는 감지만, 이 함수는 실제 문자열에서 대체.
+ */
+export function redactSecrets(text) {
+    const hits = [];
+    let out = text;
+    for (const sp of SECRET_PATTERNS) {
+        // regex 복제 (global flag 없이 repeated test 되는 경우 lastIndex 안전)
+        const re = new RegExp(sp.pattern.source, (sp.pattern.flags.includes('g') ? sp.pattern.flags : sp.pattern.flags + 'g'));
+        if (re.test(out)) {
+            hits.push(sp);
+            const re2 = new RegExp(sp.pattern.source, (sp.pattern.flags.includes('g') ? sp.pattern.flags : sp.pattern.flags + 'g'));
+            out = out.replace(re2, `[REDACTED:${sp.name}]`);
+        }
+    }
+    return { redacted: out, hits };
+}
 /** 텍스트에서 민감 정보 패턴 감지 (순수 함수) */
 export function detectSecrets(text) {
     const found = [];

package/dist/hooks/shared/atomic-write.d.ts

@@ -37,5 +37,12 @@ export declare function atomicWriteText(filePath: string, content: string, optio
     mode?: number;
     dirMode?: number;
 }): void;
-/** JSON 파일을 안전하게 읽기 (파싱 실패 시 fallback 반환) */
+/**
+ * JSON 파일을 안전하게 읽기 (파싱 실패 시 fallback 반환).
+ *
+ * R4-B3 (2026-04-22): UTF-8 BOM () prefix 제거 — Windows 메모장 등으로 저장된
+ *   rule/settings JSON 이 BOM 으로 시작해 JSON.parse 가 silent 실패하던 문제.
+ * R4-SKIP: FORGEN_DEBUG_SIGNALS=1 일 때 파싱 실패를 stderr 로 노출 — silent
+ *   누락을 운영자가 추적 가능하도록.
+ */
 export declare function safeReadJSON<T>(filePath: string, fallback: T): T;

package/dist/hooks/shared/atomic-write.js

@@ -136,13 +136,27 @@ export function atomicWriteText(filePath, content, options) {
         throw e;
     }
 }
-/** JSON 파일을 안전하게 읽기 (파싱 실패 시 fallback 반환) */
+/**
+ * JSON 파일을 안전하게 읽기 (파싱 실패 시 fallback 반환).
+ *
+ * R4-B3 (2026-04-22): UTF-8 BOM () prefix 제거 — Windows 메모장 등으로 저장된
+ *   rule/settings JSON 이 BOM 으로 시작해 JSON.parse 가 silent 실패하던 문제.
+ * R4-SKIP: FORGEN_DEBUG_SIGNALS=1 일 때 파싱 실패를 stderr 로 노출 — silent
+ *   누락을 운영자가 추적 가능하도록.
+ */
 export function safeReadJSON(filePath, fallback) {
     try {
         if (fs.existsSync(filePath)) {
-            return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            let raw = fs.readFileSync(filePath, 'utf-8');
+            if (raw.charCodeAt(0) === 0xFEFF)
+                raw = raw.slice(1); // strip BOM
+            return JSON.parse(raw);
+        }
+    }
+    catch (e) {
+        if (process.env.FORGEN_DEBUG_SIGNALS === '1') {
+            process.stderr.write(`[forgen:safeReadJSON] ${filePath} parse failed: ${e.message}\n`);
         }
     }
-    catch { /* JSON parse failure — return fallback */ }
     return fallback;
 }

package/dist/hooks/shared/hook-response.d.ts

@@ -29,6 +29,17 @@ export declare function approveWithWarning(warning: string): string;
 export declare function deny(reason: string): string;
 /** 사용자 확인 요청 (PreToolUse 전용) */
 export declare function ask(reason: string): string;
+/**
+ * Stop hook only — block the agent from stopping and feed a self-check
+ * question back to Claude so the current session resumes with new guidance.
+ *
+ * `reason` becomes the next-turn content (Claude reads this verbatim), while
+ * `systemMessage` is auxiliary context rendered alongside. Put the whole
+ * self-check question in `reason`; keep `systemMessage` to a short rule tag.
+ *
+ * Source: Stop hook spec — `decision: "block"` "prevents stopping and continues the agent's work".
+ */
+export declare function blockStop(reason: string, systemMessage?: string): string;
 /**
  * fail-open with error tracking: 에러 시 안전하게 통과하되, 실패 정보를 기록.
  * forgen doctor의 Hook Health 섹션에서 실패 이력을 표시할 수 있도록 JSONL 로그에 기록.

package/dist/hooks/shared/hook-response.js

@@ -59,6 +59,24 @@ export function ask(reason) {
         },
     });
 }
+/**
+ * Stop hook only — block the agent from stopping and feed a self-check
+ * question back to Claude so the current session resumes with new guidance.
+ *
+ * `reason` becomes the next-turn content (Claude reads this verbatim), while
+ * `systemMessage` is auxiliary context rendered alongside. Put the whole
+ * self-check question in `reason`; keep `systemMessage` to a short rule tag.
+ *
+ * Source: Stop hook spec — `decision: "block"` "prevents stopping and continues the agent's work".
+ */
+export function blockStop(reason, systemMessage) {
+    return JSON.stringify({
+        continue: true,
+        decision: 'block',
+        reason,
+        ...(systemMessage ? { systemMessage } : {}),
+    });
+}
 /**
  * fail-open with error tracking: 에러 시 안전하게 통과하되, 실패 정보를 기록.
  * forgen doctor의 Hook Health 섹션에서 실패 이력을 표시할 수 있도록 JSONL 로그에 기록.

package/dist/hooks/shared/safe-regex.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Safe regex compiler — ReDoS 방지용 경량 가드.
+ *
+ * rule JSON 의 verifier.params.pattern 등 user-controlled regex 를 hook 런타임에
+ * 그대로 new RegExp() 하면 catastrophic backtracking 으로 hook hang 위험이 있다.
+ * re2 같은 linear-time 엔진 의존은 native binding 을 추가시키므로, 여기서는
+ * **패턴 복잡도 제한** + **입력 크기 제한** 으로 1차 방어.
+ *
+ * 정책:
+ *   - 패턴 길이 ≤ 500자.
+ *   - 중첩 quantifier (`(...)+)+` / `(...)*)*` / `(.+)+`) 같은 catastrophic 신호 거부.
+ *   - backreference `\1..\9` 금지.
+ *   - compile 실패 또는 거부 시 null 반환 → 호출자가 skip.
+ */
+export interface SafeRegexResult {
+    regex: RegExp | null;
+    reason: string | null;
+}
+/**
+ * 패턴을 안전하게 컴파일. 거부되거나 실패 시 { regex: null, reason } 반환.
+ * 호출자는 reason 을 log.debug 로 기록하고 skip 하는 것이 권장 사용법.
+ */
+export declare function compileSafeRegex(pattern: string, flags?: string): SafeRegexResult;
+/** 입력을 MAX_INPUT_LEN 으로 자른 뒤 regex.test() 수행. 입력 DoS 방어. */
+export declare function safeRegexTest(regex: RegExp, input: string): boolean;

package/dist/hooks/shared/safe-regex.js

@@ -0,0 +1,50 @@
+/**
+ * Safe regex compiler — ReDoS 방지용 경량 가드.
+ *
+ * rule JSON 의 verifier.params.pattern 등 user-controlled regex 를 hook 런타임에
+ * 그대로 new RegExp() 하면 catastrophic backtracking 으로 hook hang 위험이 있다.
+ * re2 같은 linear-time 엔진 의존은 native binding 을 추가시키므로, 여기서는
+ * **패턴 복잡도 제한** + **입력 크기 제한** 으로 1차 방어.
+ *
+ * 정책:
+ *   - 패턴 길이 ≤ 500자.
+ *   - 중첩 quantifier (`(...)+)+` / `(...)*)*` / `(.+)+`) 같은 catastrophic 신호 거부.
+ *   - backreference `\1..\9` 금지.
+ *   - compile 실패 또는 거부 시 null 반환 → 호출자가 skip.
+ */
+const MAX_PATTERN_LEN = 500;
+const MAX_INPUT_LEN = 65536;
+// Catastrophic backtracking 의 흔한 형태 — 중첩된 quantifier 체인.
+const NESTED_QUANTIFIER = /\([^)]*[+*][^)]*\)[+*]/;
+// Alternation with shared prefix can also be catastrophic — heuristic only.
+const OVERLAPPING_ALT = /\(([^|)]+)\|\1[^)]*\)[+*]/;
+const BACKREFERENCE = /\\[1-9]/;
+/**
+ * 패턴을 안전하게 컴파일. 거부되거나 실패 시 { regex: null, reason } 반환.
+ * 호출자는 reason 을 log.debug 로 기록하고 skip 하는 것이 권장 사용법.
+ */
+export function compileSafeRegex(pattern, flags = '') {
+    if (typeof pattern !== 'string')
+        return { regex: null, reason: 'non-string pattern' };
+    if (pattern.length === 0)
+        return { regex: null, reason: 'empty pattern' };
+    if (pattern.length > MAX_PATTERN_LEN)
+        return { regex: null, reason: `pattern length ${pattern.length} > ${MAX_PATTERN_LEN}` };
+    if (NESTED_QUANTIFIER.test(pattern))
+        return { regex: null, reason: 'nested quantifier (catastrophic backtracking risk)' };
+    if (OVERLAPPING_ALT.test(pattern))
+        return { regex: null, reason: 'overlapping alternation with quantifier' };
+    if (BACKREFERENCE.test(pattern))
+        return { regex: null, reason: 'backreference in user regex (perf risk)' };
+    try {
+        return { regex: new RegExp(pattern, flags), reason: null };
+    }
+    catch (e) {
+        return { regex: null, reason: `compile error: ${String(e).slice(0, 80)}` };
+    }
+}
+/** 입력을 MAX_INPUT_LEN 으로 자른 뒤 regex.test() 수행. 입력 DoS 방어. */
+export function safeRegexTest(regex, input) {
+    const truncated = input.length > MAX_INPUT_LEN ? input.slice(0, MAX_INPUT_LEN) : input;
+    return regex.test(truncated);
+}

package/dist/hooks/shared/stop-triggers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared Stop hook default trigger regexes.
+ *
+ * R6-F2 (2026-04-22): stop-guard 와 enforce-classifier 에 리터럴 중복되던 정규식을
+ * 단일 소스로 통합. 한쪽만 고치면 다른 쪽이 drift 하는 sibling-bug 패턴 차단.
+ *
+ * 설계 결정:
+ *   - trigger 는 명시적 완료 선언 동사/어미만 — "완료" 단독 매칭 금지 (retraction 오매칭 방지).
+ *   - exclude 는 retraction/negation/meta 언급 광범위 차단.
+ *   - A1 spike 결과로 검증됨 (10/10 scenarios pass, FP 0%).
+ */
+/** Stop hook 에서 rule trigger 가 명시되지 않을 때의 기본 완료 선언 매칭. */
+export declare const DEFAULT_STOP_TRIGGER_RE = "(\uC644\uB8CC\uD588|\uC644\uC131\uB410|\uC644\uC131\uB418|\uC644\uC131\uD588|done\\.|ready\\.|shipped\\.|LGTM|finished\\.)";
+/** Stop hook 기본 exclude — retraction/negation/meta 맥락 제외. */
+export declare const DEFAULT_STOP_EXCLUDE_RE = "(\uCDE8\uC18C|\uCCA0\uD68C|\uC5C6\uC74C|\uC5C6\uC2B5\uB2C8\uB2E4|\uC54A\uC558|\uD558\uC9C0\\s*\uC54A|\uC544\uB2D9\uB2C8\uB2E4|not\\s*yet|no\\s*longer|retract|withdraw|\uC544\uC9C1\\s*(\uC548|\uC544))";
+/** mock/stub/fake 감지 — R-B2 전용 pattern (자가검증 주장 차단). */
+export declare const MOCK_TRIGGER_RE = "(mock|stub|fake)";
+/** mock trigger 의 exclude — 테스트 맥락은 정상. */
+export declare const MOCK_EXCLUDE_RE = "(\uD14C\uC2A4\uD2B8|test|vi\\.mock|jest\\.mock|spec\\.)";

package/dist/hooks/shared/stop-triggers.js

@@ -0,0 +1,19 @@
+/**
+ * Shared Stop hook default trigger regexes.
+ *
+ * R6-F2 (2026-04-22): stop-guard 와 enforce-classifier 에 리터럴 중복되던 정규식을
+ * 단일 소스로 통합. 한쪽만 고치면 다른 쪽이 drift 하는 sibling-bug 패턴 차단.
+ *
+ * 설계 결정:
+ *   - trigger 는 명시적 완료 선언 동사/어미만 — "완료" 단독 매칭 금지 (retraction 오매칭 방지).
+ *   - exclude 는 retraction/negation/meta 언급 광범위 차단.
+ *   - A1 spike 결과로 검증됨 (10/10 scenarios pass, FP 0%).
+ */
+/** Stop hook 에서 rule trigger 가 명시되지 않을 때의 기본 완료 선언 매칭. */
+export const DEFAULT_STOP_TRIGGER_RE = '(완료했|완성됐|완성되|완성했|done\\.|ready\\.|shipped\\.|LGTM|finished\\.)';
+/** Stop hook 기본 exclude — retraction/negation/meta 맥락 제외. */
+export const DEFAULT_STOP_EXCLUDE_RE = '(취소|철회|없음|없습니다|않았|하지\\s*않|아닙니다|not\\s*yet|no\\s*longer|retract|withdraw|아직\\s*(안|아))';
+/** mock/stub/fake 감지 — R-B2 전용 pattern (자가검증 주장 차단). */
+export const MOCK_TRIGGER_RE = '(mock|stub|fake)';
+/** mock trigger 의 exclude — 테스트 맥락은 정상. */
+export const MOCK_EXCLUDE_RE = '(테스트|test|vi\\.mock|jest\\.mock|spec\\.)';

package/dist/hooks/stop-guard.d.ts

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+/**
+ * Forgen — Stop Guard (Mech-B prototype, spike/mech-b-a1)
+ *
+ * Stop hook: 어시스턴트 직전 응답에서 "완료 선언" 패턴을 감지하고, 연결된
+ * Mech-A(artifact_check) / Mech-B(self_check_prompt) 규칙을 평가하여
+ * 위반 시 blockStop 으로 세션을 재개시킨다.
+ *
+ * Prototype scope (spike only — NOT v0.4.0 final):
+ *   - 규칙은 tests/spike/mech-b-inject/scenarios.json 에서 로드
+ *     (FORGEN_SPIKE_RULES env 로 override 가능)
+ *   - 어시스턴트 메시지는 transcript_path 에서 마지막 assistant 턴을 뽑거나
+ *     FORGEN_SPIKE_LAST_MESSAGE env 로 주입 가능 (runner/단위테스트용)
+ *   - artifact_check 는 `~/.forgen/state/<relative>` 경로를 기준으로 평가
+ *
+ * 설계 제약 (ADR-001, Day-1 verification):
+ *   - self_check_prompt 질문은 **reason** 에 전체를 담는다 (모델 도달).
+ *   - systemMessage 는 rule tag 한 줄만 (UI 표시 보조).
+ *   - 외부 LLM API 호출 없음 (β1 유지).
+ */
+import type { Rule } from '../store/types.js';
+interface VerifierSpec {
+    kind: 'self_check_prompt' | 'artifact_check' | 'tool_arg_regex';
+    params: Record<string, string | number | boolean>;
+}
+interface SpikeRule {
+    id: string;
+    mech: 'A' | 'B' | 'C';
+    hook: 'Stop' | 'PreToolUse' | 'PostToolUse' | 'UserPromptSubmit';
+    trigger: {
+        response_keywords_regex?: string;
+        context_exclude_regex?: string;
+    };
+    verifier: VerifierSpec;
+    block_message?: string;
+    system_tag?: string;
+}
+/**
+ * 프로덕션 rule-store 로더.
+ * ~/.forgen/me/rules 의 Rule 중 `enforce_via` 에 `hook: 'Stop'` 이 있는 것만
+ * SpikeRule 내부 shape 로 변환해 반환한다.
+ *
+ * 변환 규칙:
+ *   - `trigger_keywords_regex` 미지정 → DEFAULT_STOP_TRIGGER_RE (shared)
+ *   - `trigger_exclude_regex` 미지정 → DEFAULT_STOP_EXCLUDE_RE (shared)
+ *   - verifier.kind 는 `self_check_prompt` 또는 `artifact_check` 지원
+ *   - 그 외 verifier 는 skip (PreToolUse 전용 tool_arg_regex 등)
+ */
+export declare function rulesFromStore(rules: Rule[]): SpikeRule[];
+/** Pure core — 단위 테스트용. stdin/IO 없음. */
+export declare function evaluateStop(lastAssistantMessage: string, rules: SpikeRule[]): {
+    action: 'approve';
+    hit: null;
+} | {
+    action: 'block';
+    hit: SpikeRule;
+    reason: string;
+};
+/**
+ * 같은 (session, rule) 조합의 연속 block 카운트. approve 가 일어나면 0 으로 초기화.
+ * export for tests. 부수효과: 디렉토리 생성 + 파일 쓰기.
+ */
+export declare function incrementBlockCount(sessionId: string, ruleId: string): number;
+export declare function resetBlockCount(sessionId: string, ruleId: string): void;
+/**
+ * R9-PA2: approve 시점에 같은 session 의 pending block 을 찾아 ack 이벤트로 기록.
+ * Mech-B 의 핵심 가치(block → retract → pass)가 실제 작동했음을 관측 가능하게 한다.
+ * Best-effort: 실패해도 approve 자체는 영향받지 않는다.
+ *
+ * 기록 후 block-count 파일은 cleanup — 같은 session 의 같은 rule 이 다시 block 되면
+ * 새로운 카운트로 시작 (block-count 의미 보존).
+ */
+export declare function acknowledgeSessionBlocks(sessionId: string): number;
+export declare function logDriftEvent(event: {
+    kind: string;
+    session_id: string;
+    rule_id: string;
+    count: number;
+    reason_preview?: string;
+    message_preview?: string;
+}): void;
+export declare function getStuckLoopThreshold(): number;
+export declare function main(): Promise<void>;
+export {};