@wooojin/forgen 0.3.1 → 0.4.0

package/dist/engine/lifecycle/trigger-t5-conflict.js

@@ -0,0 +1,78 @@
+/**
+ * T5 — 규칙 충돌 (conflict_detected).
+ *
+ * 트리거 조건:
+ *   같은 category 인 rule pair 중, policy 자연어가 상반 (negation + 공통 키워드 ≥ 2).
+ *
+ * auto-merge 안 함. conflict_refs 플래그만 설정 → 사용자 수동 해소.
+ */
+const NEGATION_RE = /\b(없|금지|마라|말라|하지\s*않|don'?t|never|not\s+|no\s+|avoid)\b/i;
+function tokens(policy) {
+    return new Set(policy
+        .toLowerCase()
+        .replace(/[.,;:!?()[\]{}"'`~]/g, ' ')
+        .split(/\s+/)
+        .filter((w) => w.length >= 3));
+}
+function sharedTokens(a, b, min) {
+    let count = 0;
+    for (const t of a)
+        if (b.has(t)) {
+            count += 1;
+            if (count >= min)
+                return true;
+        }
+    return false;
+}
+export function detect(input) {
+    const minShared = input.min_shared_tokens ?? 2;
+    const ts = input.ts ?? Date.now();
+    const events = [];
+    const reported = new Set(); // 'a|b' 쌍 중복 방지
+    // M/T5 fix: 짧은 policy 는 토큰 overlap 이 우연히 발생하기 쉬우므로 20자 이상만.
+    // scope 도 같아야 — session-scoped 임시 규칙과 me-scope 영구 규칙이 서로 충돌로 잡히면 노이즈.
+    const active = input.rules.filter((r) => r.status === 'active' && r.policy.length >= 20);
+    for (let i = 0; i < active.length; i++) {
+        const a = active[i];
+        const aTokens = tokens(a.policy);
+        const aNeg = NEGATION_RE.test(a.policy);
+        for (let j = i + 1; j < active.length; j++) {
+            const b = active[j];
+            if (a.category !== b.category)
+                continue;
+            if (a.scope !== b.scope)
+                continue; // M/T5: scope 불일치 시 pair 아님
+            const bTokens = tokens(b.policy);
+            const bNeg = NEGATION_RE.test(b.policy);
+            if (aNeg === bNeg)
+                continue; // 같은 어조 — 충돌 아님
+            if (!sharedTokens(aTokens, bTokens, minShared))
+                continue;
+            const key = [a.rule_id, b.rule_id].sort().join('|');
+            if (reported.has(key))
+                continue;
+            reported.add(key);
+            events.push({
+                kind: 't5_conflict_detected',
+                rule_id: a.rule_id,
+                evidence: {
+                    source: 'rule-pairing',
+                    refs: [a.rule_id, b.rule_id],
+                },
+                suggested_action: 'flag',
+                ts,
+            });
+            events.push({
+                kind: 't5_conflict_detected',
+                rule_id: b.rule_id,
+                evidence: {
+                    source: 'rule-pairing',
+                    refs: [a.rule_id, b.rule_id],
+                },
+                suggested_action: 'flag',
+                ts,
+            });
+        }
+    }
+    return events;
+}

package/dist/engine/lifecycle/types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * ADR-002 Lifecycle event model.
+ *
+ * 오케스트레이터가 발행하는 이벤트 — rule 상태 전이의 단위.
+ * 이 파일은 타입만 정의. 실제 이벤트 발행/소비 로직은 각 trigger-*.ts 참조.
+ */
+export type LifecycleEventKind = 't1_explicit_correction' | 't2_repeated_violation' | 't3_user_bypass' | 't4_time_decay' | 't5_conflict_detected' | 'meta_promote_to_a' | 'meta_demote_to_b';
+export type LifecycleSuggestedAction = 'flag' | 'suppress' | 'retire' | 'merge' | 'supersede' | 'promote_mech' | 'demote_mech';
+export interface LifecycleEvent {
+    kind: LifecycleEventKind;
+    rule_id: string;
+    session_id?: string;
+    evidence?: {
+        source: string;
+        refs: string[];
+        metrics?: Record<string, number>;
+    };
+    suggested_action: LifecycleSuggestedAction;
+    /** T5 merge 전용: 흡수 대상 rule_id */
+    merged_into?: string;
+    /** T1 supersede 전용: 교체 rule_id */
+    superseded_by?: string;
+    ts: number;
+}
+/**
+ * 트리거들이 공유하는 rule-level 시그널 집계.
+ * RuleState 는 Rule + signals (pure data). 각 detect() 는 이 상태 배열을 입력으로 받는다.
+ */
+export interface RuleSignals {
+    violations_30d: number;
+    violation_rate_30d: number;
+    bypass_7d: number;
+    last_inject_days_ago: number;
+    injects_rolling_n: number;
+    violations_rolling_n: number;
+    last_updated_days_ago: number;
+}
+export interface ViolationEntry {
+    at: string;
+    rule_id: string;
+    session_id: string;
+    source: 'stop-guard' | 'pre-tool-guard' | 'post-tool-guard' | 'evidence-store' | 'manual';
+    kind: 'block' | 'deny' | 'correction';
+    message_preview?: string;
+}
+export interface BypassEntry {
+    at: string;
+    rule_id: string;
+    session_id: string;
+    tool: string;
+    pattern_preview: string;
+}

package/dist/engine/lifecycle/types.js

@@ -0,0 +1,7 @@
+/**
+ * ADR-002 Lifecycle event model.
+ *
+ * 오케스트레이터가 발행하는 이벤트 — rule 상태 전이의 단위.
+ * 이 파일은 타입만 정의. 실제 이벤트 발행/소비 로직은 각 trigger-*.ts 참조.
+ */
+export {};

package/dist/engine/match-eval-log.js

@@ -69,6 +69,47 @@ const MAX_NORMALIZED_QUERY_LOGGED = 64;
 const MAX_MATCHED_TERMS_PER_CANDIDATE = 16;
 /** Read-side DoS guard: refuse to load if the JSONL file is larger than this. */
 const MAX_LOG_FILE_SIZE_BYTES = 50 * 1024 * 1024; // 50 MB
+/**
+ * Write-side rotation threshold (2026-04-21). When the active log reaches
+ * this size, it is renamed to `<path>.1` (clobbering any previous rotation)
+ * and a fresh empty file is opened. Keeps one generation of history for
+ * offline forensics without letting the log grow unbounded. Chosen so
+ * typical installs retain ~10-20k records — enough to spot recurrent
+ * matcher surprises, not enough to silently fill disk.
+ */
+const ROTATION_SIZE_BYTES = 10 * 1024 * 1024; // 10 MB
+/**
+ * Internal: rotate the log if it exceeds ROTATION_SIZE_BYTES. Called from
+ * inside the file lock so no concurrent writer observes a torn state. A
+ * rotation failure is swallowed — the caller will still attempt to append
+ * and either succeed (no-op rotation) or the append itself will surface
+ * the underlying fs error via the outer catch.
+ */
+function maybeRotate(logPath) {
+    let size = 0;
+    try {
+        const st = fs.statSync(logPath);
+        if (!st.isFile())
+            return;
+        size = st.size;
+    }
+    catch {
+        return; // missing file is fine, append will create it
+    }
+    if (size < ROTATION_SIZE_BYTES)
+        return;
+    const rotated = `${logPath}.1`;
+    try {
+        // rename is atomic on POSIX within the same directory; overwrites any
+        // previous rotation. We intentionally keep only one generation.
+        fs.renameSync(logPath, rotated);
+    }
+    catch {
+        // Best effort. If rotation fails (permissions, cross-device link)
+        // we leave the original file alone and the next append just continues
+        // growing. The 50 MB read-side cap still protects offline tools.
+    }
+}
 /**
  * Check whether logging is disabled via environment variable.
  * Accepts `off`, `disabled`, `0`, `false`, `no` (case-insensitive).
@@ -150,6 +191,10 @@ export function logMatchDecision(input) {
         // so concurrent writers could interleave without this lock. The lock
         // is taken on the log file itself, and cleaned up by withFileLockSync.
         withFileLockSync(MATCH_EVAL_LOG_PATH, () => {
+            // Rotate BEFORE opening the fd so the new fd points at the fresh
+            // file. Doing this after open would append to the file that is
+            // about to be renamed into the previous-generation slot.
+            maybeRotate(MATCH_EVAL_LOG_PATH);
             // O_NOFOLLOW: refuse to follow a symlink at the target path. This
             // blocks a local-attacker symlink swap attack where the log file
             // is replaced with a link to e.g. ~/.ssh/authorized_keys.

package/dist/engine/rule-toggle-cli.d.ts

@@ -0,0 +1,13 @@
+/**
+ * CLI handler for `forgen suppress-rule <id>` / `forgen activate-rule <id>`.
+ *
+ * R7-U2: Day-1 탈출구 — 사용자가 차단 메시지를 보고 JSON 을 손으로 편집하지 않아도
+ * 한 명령으로 규칙을 끄거나 되살릴 수 있도록.
+ *
+ * 구현:
+ *   - prefix-match 지원 (첫 8자만 쳐도 OK).
+ *   - multiple match 이면 목록 출력하고 중단.
+ *   - hard strength rule 은 cli 로도 suppress 불가 (ADR-002 불변 원칙).
+ */
+export declare function handleSuppressRule(args: string[]): Promise<void>;
+export declare function handleActivateRule(args: string[]): Promise<void>;

package/dist/engine/rule-toggle-cli.js

@@ -0,0 +1,76 @@
+/**
+ * CLI handler for `forgen suppress-rule <id>` / `forgen activate-rule <id>`.
+ *
+ * R7-U2: Day-1 탈출구 — 사용자가 차단 메시지를 보고 JSON 을 손으로 편집하지 않아도
+ * 한 명령으로 규칙을 끄거나 되살릴 수 있도록.
+ *
+ * 구현:
+ *   - prefix-match 지원 (첫 8자만 쳐도 OK).
+ *   - multiple match 이면 목록 출력하고 중단.
+ *   - hard strength rule 은 cli 로도 suppress 불가 (ADR-002 불변 원칙).
+ */
+import { loadAllRules, saveRule } from '../store/rule-store.js';
+export async function handleSuppressRule(args) {
+    const partial = args[0];
+    if (!partial) {
+        console.error('Usage: forgen suppress-rule <rule_id | prefix>');
+        process.exit(2);
+    }
+    const all = loadAllRules();
+    const matches = all.filter((r) => r.rule_id === partial || r.rule_id.startsWith(partial));
+    if (matches.length === 0) {
+        console.error(`No rule found matching "${partial}". Try \`forgen inspect rules\`.`);
+        process.exit(1);
+    }
+    if (matches.length > 1) {
+        console.error(`Ambiguous prefix "${partial}" — ${matches.length} rules match:`);
+        for (const r of matches) {
+            console.error(`  ${r.rule_id}  [${r.strength}]  ${r.policy.slice(0, 60)}`);
+        }
+        console.error('Use a longer prefix or the full rule_id.');
+        process.exit(1);
+    }
+    const rule = matches[0];
+    if (rule.strength === 'hard') {
+        console.error(`Refusing to suppress hard rule "${rule.rule_id}" (ADR-002 immutability).`);
+        console.error('  Hard rules require explicit removal from the rule source file.');
+        process.exit(1);
+    }
+    if (rule.status === 'suppressed') {
+        console.log(`Rule ${rule.rule_id} is already suppressed.`);
+        return;
+    }
+    saveRule({ ...rule, status: 'suppressed' });
+    console.log(`✓ Suppressed rule ${rule.rule_id}`);
+    console.log(`  Policy: ${rule.policy.slice(0, 80)}`);
+    console.log(`  Re-activate with: forgen activate-rule ${rule.rule_id}`);
+}
+export async function handleActivateRule(args) {
+    const partial = args[0];
+    if (!partial) {
+        console.error('Usage: forgen activate-rule <rule_id | prefix>');
+        process.exit(2);
+    }
+    const all = loadAllRules();
+    const matches = all.filter((r) => r.rule_id === partial || r.rule_id.startsWith(partial));
+    if (matches.length === 0) {
+        console.error(`No rule found matching "${partial}".`);
+        process.exit(1);
+    }
+    if (matches.length > 1) {
+        console.error(`Ambiguous prefix "${partial}" — ${matches.length} rules. Use longer prefix.`);
+        process.exit(1);
+    }
+    const rule = matches[0];
+    if (rule.status === 'active') {
+        console.log(`Rule ${rule.rule_id} is already active.`);
+        return;
+    }
+    if (rule.status === 'removed' || rule.status === 'superseded') {
+        console.error(`Cannot activate rule with status=${rule.status}. Edit the rule file directly.`);
+        process.exit(1);
+    }
+    saveRule({ ...rule, status: 'active' });
+    console.log(`✓ Activated rule ${rule.rule_id}`);
+    console.log(`  Policy: ${rule.policy.slice(0, 80)}`);
+}

package/dist/engine/solution-format.d.ts

@@ -74,8 +74,6 @@ export declare function parseFrontmatterOnly(content: string): SolutionFrontmatt
 export declare function parseSolutionV3(content: string): SolutionV3 | null;
 /** Serialize a SolutionV3 to a markdown string with YAML frontmatter */
 export declare function serializeSolutionV3(solution: SolutionV3): string;
-/** Check if content is in V3 format (YAML frontmatter) */
-export declare function isV3Format(content: string): boolean;
 /** Check if content is in V1 format (# Title + > Type: pattern) */
 export declare function isV1Format(content: string): boolean;
 /** 한국어 일반 조사/어미 — strip 대상 (긴 것부터 매칭)

package/dist/engine/solution-format.js

@@ -162,10 +162,6 @@ export function serializeSolutionV3(solution) {
     return `---\n${yamlStr}---\n\n## Context\n${solution.context}\n\n## Content\n${solution.content}\n`;
 }
 // ── Format Detection ──
-/** Check if content is in V3 format (YAML frontmatter) */
-export function isV3Format(content) {
-    return content.trimStart().startsWith('---');
-}
 /** Check if content is in V1 format (# Title + > Type: pattern) */
 export function isV1Format(content) {
     const lines = content.split('\n');

package/dist/engine/solution-matcher.d.ts

@@ -41,6 +41,14 @@ export interface SolutionMatch {
     tags: string[];
     identifiers: string[];
     matchedTags: string[];
+    /**
+     * Identifier substrings (function/file names) that appeared literally in the
+     * prompt. Added 2026-04-21 so solution-injector can enforce a precision gate
+     * distinguishing "user typed a specific identifier" (strong signal, survives
+     * 1-tag overlap) from "only 1 tag happens to overlap" (often noise — common
+     * nouns like 'type', 'file', 'forgen' trigger rare-tag BM25 boost).
+     */
+    matchedIdentifiers: string[];
 }
 /**
  * Optional hints for the v3 `calculateRelevance` path. Used by hot-path

package/dist/engine/solution-matcher.js

@@ -818,12 +818,14 @@ function loadTunedMatcherWeights() {
  * entries and almost always lose the first few rounds — not because
  * they're worse, but because matchers favor solutions with richer tag
  * histories. A small confidence multiplier lets candidates surface often
- * enough to accumulate outcome data, after which the fitness loop
- * decides their fate.
+ * enough to accumulate reflected/sessions evidence, after which the
+ * lifecycle loop decides their fate.
  *
  * The 1.3× factor is a starting point (Q1 in docs/design-solution-evolution.md).
- * Automatic deactivation after 5 accumulated injections is handled by a
- * separate promoter that flips `status` to `verified`.
+ * Bonus deactivation happens implicitly when compound-lifecycle.ts::
+ * runLifecycleCheck promotes the candidate to `verified` based on accumulated
+ * reflected/sessions evidence. There is no inject-count-based auto promotion
+ * (removed 2026-04-20 — see feedback_core_loop_invariant).
  */
 const CANDIDATE_EXPLORATION_MULTIPLIER = 1.3;
 function applyCandidateExplorationBonus(entries) {
@@ -865,5 +867,6 @@ export function matchSolutions(prompt, scope, cwd) {
         tags: c.solution.tags,
         identifiers: c.solution.identifiers,
         matchedTags: [...c.matchedTags, ...c.matchedIdentifiers],
+        matchedIdentifiers: c.matchedIdentifiers,
     }));
 }

package/dist/engine/solution-outcomes.d.ts

@@ -52,6 +52,10 @@ export declare function attributeCorrection(sessionId: string): string[];
  * — an error is a weaker signal and the next user prompt can still produce
  * a correct/accept decision.
  *
+ * Only the top-K most-relevant, recent, above-threshold pending solutions
+ * are attributed (see gates above). Below-threshold or stale pending
+ * entries are left untouched — they will resolve via accept/unknown later.
+ *
  * To avoid flooding the log with duplicate errors for the same pending
  * batch, we cap at one `error` event per (session, solution) pair per
  * pending-cycle by tracking a `error_flagged` set in the pending state.