@wooojin/forgen 0.3.1 → 0.4.0

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,8 +29,17 @@ export declare function approveWithWarning(warning: string): string;
 export declare function deny(reason: string): string;
 /** 사용자 확인 요청 (PreToolUse 전용) */
 export declare function ask(reason: string): string;
-/** fail-open: 에러 시 안전하게 통과 */
-export declare function failOpen(): 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

@@ -14,8 +14,8 @@
  *   모델에 컨텍스트를 주입하려면 반드시 additionalContext를 사용해야 함.
  */
 import * as fs from 'node:fs';
-import * as os from 'node:os';
 import * as path from 'node:path';
+import { STATE_DIR } from '../../core/paths.js';
 /** 통과 응답 (컨텍스트 없음, 모든 이벤트 공통) */
 export function approve() {
     return JSON.stringify({ continue: true });
@@ -59,9 +59,23 @@ export function ask(reason) {
         },
     });
 }
-/** fail-open: 에러 시 안전하게 통과 */
-export function failOpen() {
-    return JSON.stringify({ continue: true });
+/**
+ * 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: 에러 시 안전하게 통과하되, 실패 정보를 기록.
@@ -71,9 +85,8 @@ export function failOpen() {
  */
 export function failOpenWithTracking(hookName) {
     try {
-        const stateDir = path.join(os.homedir(), '.forgen', 'state');
-        fs.mkdirSync(stateDir, { recursive: true });
-        const logPath = path.join(stateDir, 'hook-errors.jsonl');
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        const logPath = path.join(STATE_DIR, 'hook-errors.jsonl');
         const entry = JSON.stringify({ hook: hookName, at: Date.now() });
         fs.appendFileSync(logPath, entry + '\n');
     }

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

@@ -9,13 +9,22 @@ import * as path from 'node:path';
 import { STATE_DIR } from '../../core/paths.js';
 const TIMING_LOG = path.join(STATE_DIR, 'hook-timing.jsonl');
 const MAX_LINES = 500;
+// P0-2 fix (2026-04-20): rotate를 size gate로 보호. 이전에는 매 hook 완료마다
+// full-file read + length split + write까지 실행해 steady-state(500줄 근처)에서
+// 매 tool call당 ~40KB의 불필요 I/O가 발생했다. statSync 한 번으로 크기만 보고
+// threshold 이하면 read/write 둘 다 skip한다. threshold는 ~80바이트/엔트리 기준
+// MAX_LINES × 1.5 여유를 둠.
+const ROTATE_SIZE_BYTES = MAX_LINES * 80 * 2; // ~80KB
 export function recordHookTiming(hookName, durationMs, event) {
     try {
         fs.mkdirSync(STATE_DIR, { recursive: true });
         const entry = JSON.stringify({ hook: hookName, ms: durationMs, event, at: Date.now() });
         fs.appendFileSync(TIMING_LOG, entry + '\n');
-        // Rotate if too large
+        // Rotate if too large — size-gated (statSync only, skip read/write 대부분의 호출)
         try {
+            const size = fs.statSync(TIMING_LOG).size;
+            if (size < ROTATE_SIZE_BYTES)
+                return;
             const content = fs.readFileSync(TIMING_LOG, 'utf-8');
             const lines = content.trim().split('\n');
             if (lines.length > MAX_LINES) {

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/solution-injector.d.ts

@@ -7,6 +7,27 @@
  *
  * knowledge-comes-to-you 원칙: 필요한 지식은 찾아와야 한다
  */
+/**
+ * Minimum relevance thresholds by fitness state (2026-04-21 gate sweep).
+ *
+ * Motivation: a flat 0.3 floor gave 100% precision but 60% recall on a
+ * synthetic 40-query workload — 10 legitimate matches that scored
+ * 0.25-0.30 were blocked alongside noise. A pure 0.25 floor pushed recall
+ * to 84% but stripped noise protection for unverified solutions.
+ *
+ * Champion-aware solution: trust graduates more. Solutions whose fitness
+ * classification is `champion` or `active` (accept/correct ratio has
+ * survived ≥5 injections under the v0.3.2 gates) earn a lower 0.25
+ * injection floor; everything else stays at 0.3. On the sweep this hit
+ * precision 95.5% / recall 84% / off-topic specificity 100% — best
+ * trade in the variant set.
+ *
+ * If fitness data is unavailable (fresh install, empty outcomes/),
+ * every solution falls into the default 0.3 bucket — identical to the
+ * pre-0.3.2 gate. No cold-start regression.
+ */
+export declare const MIN_INJECT_RELEVANCE = 0.3;
+export declare const MIN_INJECT_RELEVANCE_TRUSTED = 0.25;
 interface SessionCacheCommitResult {
     /**
      * commit 상태:

package/dist/hooks/solution-injector.js

@@ -30,6 +30,27 @@ import { STATE_DIR } from '../core/paths.js';
 import { recordHookTiming } from './shared/hook-timing.js';
 import { appendPending, flushAccept } from '../engine/solution-outcomes.js';
 const MAX_SOLUTIONS_PER_SESSION = 10;
+/**
+ * Minimum relevance thresholds by fitness state (2026-04-21 gate sweep).
+ *
+ * Motivation: a flat 0.3 floor gave 100% precision but 60% recall on a
+ * synthetic 40-query workload — 10 legitimate matches that scored
+ * 0.25-0.30 were blocked alongside noise. A pure 0.25 floor pushed recall
+ * to 84% but stripped noise protection for unverified solutions.
+ *
+ * Champion-aware solution: trust graduates more. Solutions whose fitness
+ * classification is `champion` or `active` (accept/correct ratio has
+ * survived ≥5 injections under the v0.3.2 gates) earn a lower 0.25
+ * injection floor; everything else stays at 0.3. On the sweep this hit
+ * precision 95.5% / recall 84% / off-topic specificity 100% — best
+ * trade in the variant set.
+ *
+ * If fitness data is unavailable (fresh install, empty outcomes/),
+ * every solution falls into the default 0.3 bucket — identical to the
+ * pre-0.3.2 gate. No cold-start regression.
+ */
+export const MIN_INJECT_RELEVANCE = 0.3;
+export const MIN_INJECT_RELEVANCE_TRUSTED = 0.25;
 /** 세션별 이미 주입된 솔루션 추적 (중복 방지) */
 function getSessionCachePath(sessionId) {
     return path.join(STATE_DIR, `solution-cache-${sanitizeId(sessionId)}.json`);
@@ -299,12 +320,50 @@ async function main() {
             console.log(approve());
             return;
         }
-        // 어댑티브 프롬프트당 솔루션 수 제한, experiment는 1개 제한
+        // 어댑티브 프롬프트당 솔루션 수 제한, experiment는 1개 제한.
+        // 2026-04-21: MIN_INJECT_RELEVANCE 게이트 추가. 과거 0.15~0.21짜리 저신뢰 매칭이
+        // 거의 모든 세션에 주입되어 error 귀속의 80%를 차지했음.
+        //
+        // 2026-04-21 (precision audit follow-up): 단일 태그 매칭은 주입 차단.
+        // ~/.forgen/state/match-eval-log.jsonl 7406 queries 분석 결과, top-1의
+        // 33.5%가 "forgen", "type", "file" 같은 공통 단어 한 개로 매칭되어 희귀
+        // 태그 BM25 boost로 0.5~0.8 점수를 받고 사용자 컨텍스트를 오염시켰다.
+        // Matcher는 top-5 recall 유지를 위해 permissive 하게 두고 (bootstrap eval
+        // 호환), 주입 직전에만 엄격히:
+        //   - identifier match ≥ 1 (함수/파일 이름 리터럴 매칭 — 강한 신호) OR
+        //   - matched tags ≥ 2 (의도 교차점 2개 이상)
+        // 둘 중 하나를 만족해야 주입.
+        // 2026-04-21 (champion-aware gate): fitness 상태가 champion/active인 솔루션은
+        // 검증된 신호가 있으므로 임계값 0.25로 완화. draft/underperform 은 0.3 그대로.
+        // Fitness 데이터가 없으면 전체 default 0.3 (cold-start 회귀 없음).
+        // Gate sweep 결과: precision 95.5% / recall 84% / off-topic specificity 100%.
+        const fitnessStateMap = new Map();
+        try {
+            const { computeFitness } = await import('../engine/solution-fitness.js');
+            for (const r of computeFitness()) {
+                fitnessStateMap.set(r.solution, r.state);
+            }
+        }
+        catch (e) {
+            log.debug('fitness state load 실패 — default 0.3 적용', e);
+        }
+        function minRelevanceFor(name) {
+            const state = fitnessStateMap.get(name);
+            return (state === 'champion' || state === 'active')
+                ? MIN_INJECT_RELEVANCE_TRUSTED
+                : MIN_INJECT_RELEVANCE;
+        }
         let experimentCount = 0;
         const toInject = [];
         for (const sol of matches) {
             if (injected.has(sol.name))
                 continue;
+            if (sol.relevance < minRelevanceFor(sol.name))
+                continue;
+            const idMatches = sol.matchedIdentifiers?.length ?? 0;
+            const tagMatches = Math.max(0, sol.matchedTags.length - idMatches);
+            if (idMatches < 1 && tagMatches < 2)
+                continue;
             if (sol.status === 'experiment') {
                 if (experimentCount >= 1)
                     continue;

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 {};