@triflux/core 10.1.0 → 10.26.0

package/hub/team/retry-state-machine.mjs

@@ -0,0 +1,336 @@
+// hub/team/retry-state-machine.mjs
+// Phase 3 Step A — true ralph / auto-escalate retry state machine.
+// 설계 문서: .triflux/plans/phase3-lead-codex-ralph-escalate.md
+//
+// Modes:
+//   bounded       — --retry 1 (기본): maxIterations 도달 시 BUDGET_EXCEEDED.
+//   ralph         — --retry ralph: maxIterations=0 이면 unlimited. stuck detector 만 종료.
+//   auto-escalate — --retry auto-escalate: BUDGET_EXCEEDED 시 다음 CLI 로 전이.
+//
+// 상태 전이:
+//   PLANNING → EXECUTING → VERIFYING.success → DONE
+//                       → VERIFYING.fail   → DIAGNOSING → EXECUTING …
+//                       → stuckCounter≥3   → STUCK
+//                       → iter≥max         → BUDGET_EXCEEDED (escalate 모드는 다음 CLI)
+
+import { EventEmitter } from "node:events";
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+
+export const STATES = Object.freeze({
+  PLANNING: "PLANNING",
+  EXECUTING: "EXECUTING",
+  DIAGNOSING: "DIAGNOSING",
+  STUCK: "STUCK",
+  BUDGET_EXCEEDED: "BUDGET_EXCEEDED",
+  DONE: "DONE",
+});
+
+export const MODES = Object.freeze({
+  BOUNDED: "bounded",
+  RALPH: "ralph",
+  ESCALATE: "auto-escalate",
+});
+
+const ESCALATION_CHAIN_CONFIG_PATH = ".triflux/config/escalation-chain.json";
+
+// Escalation chain (2026-05-27 정책):
+//   1. codex gpt-5.5   — 코드/추론/비용에서 mini/5.3-codex 중간 단계를 대체
+//   2. claude opus-4-7 — 최종 수단
+const DEFAULT_ESCALATION_CHAIN = Object.freeze([
+  Object.freeze({ cli: "codex", model: "gpt-5.5" }),
+  Object.freeze({ cli: "claude", model: "opus-4-7" }),
+]);
+
+const STUCK_THRESHOLD = 3;
+
+export function createRetryStateMachine(options = {}) {
+  const mode = options.mode || MODES.BOUNDED;
+  const cliChain = resolveEscalationChain(options);
+  const maxIterationsInput =
+    typeof options.maxIterations === "number" ? options.maxIterations : null;
+  const maxIterations =
+    maxIterationsInput !== null
+      ? maxIterationsInput
+      : mode === MODES.BOUNDED
+        ? 3
+        : 0;
+  const stateFile = options.stateFile || null;
+  const sessionId = options.sessionId || null;
+
+  const emitter = new EventEmitter();
+  const state = {
+    current: STATES.PLANNING,
+    iterations: 0,
+    maxIterations,
+    stuckCounter: 0,
+    lastFailureReason: null,
+    cliIndex: 0,
+    cliChain,
+    mode,
+    sessionId,
+    stateFile,
+    history: [],
+  };
+
+  function transition(next, meta = {}) {
+    const prev = state.current;
+    state.current = next;
+    const entry = {
+      t: Date.now(),
+      from: prev,
+      to: next,
+      iteration: state.iterations,
+      cliIndex: state.cliIndex,
+      ...meta,
+    };
+    state.history.push(entry);
+    if (stateFile) persistTransition(stateFile, entry);
+    emitter.emit("transition", entry);
+    return entry;
+  }
+
+  function startIteration() {
+    state.iterations += 1;
+    return transition(STATES.EXECUTING, { iteration: state.iterations });
+  }
+
+  function reportVerifySuccess() {
+    return transition(STATES.DONE);
+  }
+
+  function reportVerifyFail(failureReason) {
+    const reason = String(failureReason || "unknown");
+    if (reason === state.lastFailureReason) {
+      state.stuckCounter += 1;
+    } else {
+      state.stuckCounter = 1;
+      state.lastFailureReason = reason;
+    }
+
+    if (state.stuckCounter >= STUCK_THRESHOLD) {
+      return transition(STATES.STUCK, {
+        reason,
+        stuckCounter: state.stuckCounter,
+      });
+    }
+
+    if (state.maxIterations > 0 && state.iterations >= state.maxIterations) {
+      if (state.mode === MODES.ESCALATE) {
+        return escalate();
+      }
+      return transition(STATES.BUDGET_EXCEEDED, {
+        reason,
+        iterations: state.iterations,
+      });
+    }
+
+    return transition(STATES.DIAGNOSING, { reason });
+  }
+
+  function escalate() {
+    if (state.cliIndex + 1 >= state.cliChain.length) {
+      return transition(STATES.BUDGET_EXCEEDED, {
+        reason: "escalation-chain-exhausted",
+        chain: state.cliChain,
+      });
+    }
+    state.cliIndex += 1;
+    state.iterations = 0;
+    state.stuckCounter = 0;
+    state.lastFailureReason = null;
+    return transition(STATES.EXECUTING, {
+      cli: state.cliChain[state.cliIndex],
+      escalated: true,
+    });
+  }
+
+  function getCurrent() {
+    return {
+      current: state.current,
+      iterations: state.iterations,
+      maxIterations: state.maxIterations,
+      stuckCounter: state.stuckCounter,
+      lastFailureReason: state.lastFailureReason,
+      cliIndex: state.cliIndex,
+      cliChain: state.cliChain.slice(),
+      mode: state.mode,
+      sessionId: state.sessionId,
+      history: state.history.slice(),
+    };
+  }
+
+  function on(event, listener) {
+    emitter.on(event, listener);
+    return () => emitter.off(event, listener);
+  }
+
+  function serialize() {
+    return {
+      version: 1,
+      current: state.current,
+      iterations: state.iterations,
+      maxIterations: state.maxIterations,
+      stuckCounter: state.stuckCounter,
+      lastFailureReason: state.lastFailureReason,
+      cliIndex: state.cliIndex,
+      cliChain: state.cliChain.slice(),
+      mode: state.mode,
+      sessionId: state.sessionId,
+      history: state.history.slice(),
+    };
+  }
+
+  function applySnapshot(snapshot) {
+    if (!snapshot || typeof snapshot !== "object") return;
+    state.current = snapshot.current || STATES.PLANNING;
+    state.iterations = Number(snapshot.iterations) || 0;
+    state.maxIterations =
+      snapshot.maxIterations !== undefined
+        ? Number(snapshot.maxIterations)
+        : state.maxIterations;
+    state.stuckCounter = Number(snapshot.stuckCounter) || 0;
+    state.lastFailureReason = snapshot.lastFailureReason || null;
+    state.cliIndex = Number(snapshot.cliIndex) || 0;
+    if (Array.isArray(snapshot.cliChain) && snapshot.cliChain.length > 0) {
+      state.cliChain = normalizeEscalationChain(
+        snapshot.cliChain,
+        "snapshot.cliChain",
+      );
+    }
+    if (snapshot.mode) state.mode = snapshot.mode;
+    if (snapshot.sessionId !== undefined) state.sessionId = snapshot.sessionId;
+    if (Array.isArray(snapshot.history))
+      state.history = snapshot.history.slice();
+  }
+
+  return {
+    STATES,
+    MODES,
+    getCurrent,
+    startIteration,
+    reportVerifySuccess,
+    reportVerifyFail,
+    escalate,
+    on,
+    serialize,
+    applySnapshot,
+  };
+}
+
+function resolveEscalationChain(options) {
+  if (Array.isArray(options.cliChain)) {
+    return normalizeEscalationChain(options.cliChain, "options.cliChain");
+  }
+
+  const projectRoot = options.projectRoot || process.cwd();
+  return (
+    loadEscalationChainOverride(projectRoot) ||
+    normalizeEscalationChain(
+      DEFAULT_ESCALATION_CHAIN,
+      "DEFAULT_ESCALATION_CHAIN",
+    )
+  );
+}
+
+export function loadEscalationChainOverride(projectRoot = process.cwd()) {
+  const configPath = join(projectRoot, ESCALATION_CHAIN_CONFIG_PATH);
+  if (!existsSync(configPath)) return null;
+
+  const raw = readFileSync(configPath, "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `escalation-chain override 파싱 실패: ${configPath} — 원인: ${err.message} — 수정: JSON 문법 확인 또는 파일 삭제로 DEFAULT_ESCALATION_CHAIN 사용`,
+      { cause: err },
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${configPath}: expected object`);
+  }
+  if (parsed.version !== undefined && parsed.version !== 1) {
+    throw new Error(`${configPath}: unsupported version ${parsed.version}`);
+  }
+  return normalizeEscalationChain(parsed.chain, configPath);
+}
+
+function normalizeEscalationChain(chain, source) {
+  if (!Array.isArray(chain) || chain.length === 0) {
+    throw new Error(`${source}: chain must be a non-empty array`);
+  }
+  return chain.map((entry, index) =>
+    normalizeEscalationChainEntry(entry, index, source),
+  );
+}
+
+function normalizeEscalationChainEntry(entry, index, source) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+    throw new Error(`${source}: chain[${index}] must be an object`);
+  }
+  if (typeof entry.cli !== "string" || entry.cli.trim() === "") {
+    throw new Error(
+      `${source}: chain[${index}].cli must be a non-empty string`,
+    );
+  }
+  if (typeof entry.model !== "string" || entry.model.trim() === "") {
+    throw new Error(
+      `${source}: chain[${index}].model must be a non-empty string`,
+    );
+  }
+
+  const normalized = {
+    cli: entry.cli,
+    model: entry.model,
+  };
+  if (typeof entry.profile === "string" && entry.profile.trim() !== "") {
+    normalized.profile = entry.profile;
+  }
+  return normalized;
+}
+
+function persistTransition(stateFile, entry) {
+  const dir = dirname(stateFile);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  appendFileSync(stateFile, `${JSON.stringify(entry)}\n`, "utf8");
+}
+
+export function resumeFromStateFile(stateFile) {
+  if (!existsSync(stateFile)) return null;
+  const raw = readFileSync(stateFile, "utf8").trim();
+  if (!raw) return null;
+  const lines = raw.split("\n").filter(Boolean);
+  if (lines.length === 0) return null;
+  return JSON.parse(lines[lines.length - 1]);
+}
+
+// Full-snapshot 기반 stateFile I/O — bridge retry-run 에서 multi-process state 복원용.
+// transition event log (resumeFromStateFile) 와 별도 파일로 관리하는 것을 권장.
+export function loadSnapshot(snapshotFile) {
+  if (!existsSync(snapshotFile)) return null;
+  const raw = readFileSync(snapshotFile, "utf8").trim();
+  if (!raw) return null;
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object") return null;
+  if (parsed.version !== 1) {
+    throw new Error(
+      `unsupported snapshot version: ${parsed.version} (expected 1)`,
+    );
+  }
+  return parsed;
+}
+
+export function saveSnapshot(snapshotFile, snapshot) {
+  const dir = dirname(snapshotFile);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(snapshotFile, JSON.stringify(snapshot), "utf8");
+}
+
+export { DEFAULT_ESCALATION_CHAIN, STUCK_THRESHOLD };

package/hub/token-mode.mjs

@@ -2,83 +2,84 @@
 // GAP 분석 P2 #7: 심볼 통신 + 약어로 30-50% 토큰 절감
 
 /**
+ * @experimental 런타임 미연결 — 향후 통합 예정
  * @experimental
  * @type {Array<{ from: string[], to: string, type: 'symbol'|'abbrev' }>}
  */
 export const COMPACT_RULES = [
   // ── 심볼 치환 (긴 매칭 우선 정렬) ──
-  { from: ['greater than or equal'],                to: '≥',  type: 'symbol' },
-  { from: ['less than or equal'],                   to: '≤',  type: 'symbol' },
-  { from: ['results in', '결과적으로'],             to: '→',  type: 'symbol' },
-  { from: ['therefore', '따라서'],                  to: '∴',  type: 'symbol' },
-  { from: ['because', '왜냐하면'],                  to: '∵',  type: 'symbol' },
-  { from: ['approximately', '대략'],                to: '≈',  type: 'symbol' },
-  { from: ['not equal', '같지 않'],                 to: '≠',  type: 'symbol' },
-  { from: ['in progress', '진행 중'],               to: '⏳', type: 'symbol' },
-  { from: ['completed', '완료'],                    to: '✓',  type: 'symbol' },
-  { from: ['success', '성공'],                      to: '✓',  type: 'symbol' },
-  { from: ['failure', '실패'],                      to: '✗',  type: 'symbol' },
-  { from: ['warning', '경고'],                      to: '⚠',  type: 'symbol' },
-  { from: ['error', '에러'],                        to: '✗',  type: 'symbol' },
-  { from: ['pending', '대기'],                      to: '⏸',  type: 'symbol' },
+  { from: ["greater than or equal"], to: "≥", type: "symbol" },
+  { from: ["less than or equal"], to: "≤", type: "symbol" },
+  { from: ["results in", "결과적으로"], to: "→", type: "symbol" },
+  { from: ["therefore", "따라서"], to: "∴", type: "symbol" },
+  { from: ["because", "왜냐하면"], to: "∵", type: "symbol" },
+  { from: ["approximately", "대략"], to: "≈", type: "symbol" },
+  { from: ["not equal", "같지 않"], to: "≠", type: "symbol" },
+  { from: ["in progress", "진행 중"], to: "⏳", type: "symbol" },
+  { from: ["completed", "완료"], to: "✓", type: "symbol" },
+  { from: ["success", "성공"], to: "✓", type: "symbol" },
+  { from: ["failure", "실패"], to: "✗", type: "symbol" },
+  { from: ["warning", "경고"], to: "⚠", type: "symbol" },
+  { from: ["error", "에러"], to: "✗", type: "symbol" },
+  { from: ["pending", "대기"], to: "⏸", type: "symbol" },
 
   // ── 약어 (긴 매칭 우선 정렬) ──
-  { from: ['configuration', '설정'],                to: 'cfg',    type: 'abbrev' },
-  { from: ['implementation', '구현'],               to: 'impl',   type: 'abbrev' },
-  { from: ['architecture', '아키텍처'],             to: 'arch',   type: 'abbrev' },
-  { from: ['dependency', '의존성'],                 to: 'dep',    type: 'abbrev' },
-  { from: ['function', '함수'],                     to: 'fn',     type: 'abbrev' },
-  { from: ['parameter', '파라미터'],                to: 'param',  type: 'abbrev' },
-  { from: ['repository', '저장소'],                 to: 'repo',   type: 'abbrev' },
-  { from: ['environment', '환경'],                  to: 'env',    type: 'abbrev' },
-  { from: ['variable', '변수'],                     to: 'var',    type: 'abbrev' },
-  { from: ['directory', '디렉토리'],                to: 'dir',    type: 'abbrev' },
+  { from: ["configuration", "설정"], to: "cfg", type: "abbrev" },
+  { from: ["implementation", "구현"], to: "impl", type: "abbrev" },
+  { from: ["architecture", "아키텍처"], to: "arch", type: "abbrev" },
+  { from: ["dependency", "의존성"], to: "dep", type: "abbrev" },
+  { from: ["function", "함수"], to: "fn", type: "abbrev" },
+  { from: ["parameter", "파라미터"], to: "param", type: "abbrev" },
+  { from: ["repository", "저장소"], to: "repo", type: "abbrev" },
+  { from: ["environment", "환경"], to: "env", type: "abbrev" },
+  { from: ["variable", "변수"], to: "var", type: "abbrev" },
+  { from: ["directory", "디렉토리"], to: "dir", type: "abbrev" },
 
   // ── 한국어 동사/명령형 약어 ──
-  { from: ['구현해'],   to: 'impl',    type: 'abbrev' },
-  { from: ['확인해'],   to: 'check',   type: 'abbrev' },
-  { from: ['수정해'],   to: 'fix',     type: 'abbrev' },
-  { from: ['테스트'],   to: 'test',    type: 'abbrev' },
-  { from: ['리뷰'],     to: 'review',  type: 'abbrev' },
-  { from: ['분석'],     to: 'analyze', type: 'abbrev' },
-  { from: ['설계'],     to: 'design',  type: 'abbrev' },
-  { from: ['문서화'],   to: 'docs',    type: 'abbrev' },
+  { from: ["구현해"], to: "impl", type: "abbrev" },
+  { from: ["확인해"], to: "check", type: "abbrev" },
+  { from: ["수정해"], to: "fix", type: "abbrev" },
+  { from: ["테스트"], to: "test", type: "abbrev" },
+  { from: ["리뷰"], to: "review", type: "abbrev" },
+  { from: ["분석"], to: "analyze", type: "abbrev" },
+  { from: ["설계"], to: "design", type: "abbrev" },
+  { from: ["문서화"], to: "docs", type: "abbrev" },
 ];
 
 /** @type {Array<{ from: string[], to: string, type: 'symbol'|'abbrev' }>} */
 export const REVIEW_RULES = [
-  { from: ['looks good to me', 'lgtm'],    to: '✓lgtm',   type: 'abbrev' },
-  { from: ['needs changes', '수정 필요'],  to: '✗chg',    type: 'abbrev' },
-  { from: ['nitpick', '사소한'],           to: 'nit',     type: 'abbrev' },
-  { from: ['blocking', '블로킹'],          to: 'blk',     type: 'abbrev' },
-  { from: ['suggestion', '제안'],          to: 'sug',     type: 'abbrev' },
-  { from: ['question', '질문'],            to: 'q',       type: 'abbrev' },
-  { from: ['approved', '승인'],            to: '✓apv',    type: 'abbrev' },
-  { from: ['request changes', '변경 요청'], to: '✗req',   type: 'abbrev' },
+  { from: ["looks good to me", "lgtm"], to: "✓lgtm", type: "abbrev" },
+  { from: ["needs changes", "수정 필요"], to: "✗chg", type: "abbrev" },
+  { from: ["nitpick", "사소한"], to: "nit", type: "abbrev" },
+  { from: ["blocking", "블로킹"], to: "blk", type: "abbrev" },
+  { from: ["suggestion", "제안"], to: "sug", type: "abbrev" },
+  { from: ["question", "질문"], to: "q", type: "abbrev" },
+  { from: ["approved", "승인"], to: "✓apv", type: "abbrev" },
+  { from: ["request changes", "변경 요청"], to: "✗req", type: "abbrev" },
 ];
 
 /** @type {Array<{ from: string[], to: string, type: 'symbol'|'abbrev' }>} */
 export const DESIGN_RULES = [
-  { from: ['component', '컴포넌트'],       to: 'cmp',     type: 'abbrev' },
-  { from: ['interface', '인터페이스'],     to: 'iface',   type: 'abbrev' },
-  { from: ['abstraction', '추상화'],       to: 'abs',     type: 'abbrev' },
-  { from: ['pattern', '패턴'],             to: 'ptn',     type: 'abbrev' },
-  { from: ['dependency injection', '의존성 주입'], to: 'di', type: 'abbrev' },
-  { from: ['single responsibility', '단일 책임'],  to: 'srp', type: 'abbrev' },
-  { from: ['open closed', '개방 폐쇄'],    to: 'ocp',     type: 'abbrev' },
-  { from: ['inheritance', '상속'],         to: 'inh',     type: 'abbrev' },
+  { from: ["component", "컴포넌트"], to: "cmp", type: "abbrev" },
+  { from: ["interface", "인터페이스"], to: "iface", type: "abbrev" },
+  { from: ["abstraction", "추상화"], to: "abs", type: "abbrev" },
+  { from: ["pattern", "패턴"], to: "ptn", type: "abbrev" },
+  { from: ["dependency injection", "의존성 주입"], to: "di", type: "abbrev" },
+  { from: ["single responsibility", "단일 책임"], to: "srp", type: "abbrev" },
+  { from: ["open closed", "개방 폐쇄"], to: "ocp", type: "abbrev" },
+  { from: ["inheritance", "상속"], to: "inh", type: "abbrev" },
 ];
 
 /** @type {Array<{ from: string[], to: string, type: 'symbol'|'abbrev' }>} */
 export const DOCS_RULES = [
-  { from: ['description', '설명'],         to: 'desc',    type: 'abbrev' },
-  { from: ['example', '예시'],             to: 'ex',      type: 'abbrev' },
-  { from: ['reference', '참조'],           to: 'ref',     type: 'abbrev' },
-  { from: ['introduction', '소개'],        to: 'intro',   type: 'abbrev' },
-  { from: ['deprecated', '사용 중단'],     to: 'dep',     type: 'abbrev' },
-  { from: ['optional', '선택적'],          to: 'opt',     type: 'abbrev' },
-  { from: ['required', '필수'],            to: 'req',     type: 'abbrev' },
-  { from: ['returns', '반환'],             to: 'ret',     type: 'abbrev' },
+  { from: ["description", "설명"], to: "desc", type: "abbrev" },
+  { from: ["example", "예시"], to: "ex", type: "abbrev" },
+  { from: ["reference", "참조"], to: "ref", type: "abbrev" },
+  { from: ["introduction", "소개"], to: "intro", type: "abbrev" },
+  { from: ["deprecated", "사용 중단"], to: "dep", type: "abbrev" },
+  { from: ["optional", "선택적"], to: "opt", type: "abbrev" },
+  { from: ["required", "필수"], to: "req", type: "abbrev" },
+  { from: ["returns", "반환"], to: "ret", type: "abbrev" },
 ];
 
 // ── 프로필 맵 ──
@@ -86,9 +87,9 @@ export const DOCS_RULES = [
 /** @type {Record<string, Array<{ from: string[], to: string, type: 'symbol'|'abbrev' }>>} */
 const PROFILE_MAP = {
   default: COMPACT_RULES,
-  review:  [...COMPACT_RULES, ...REVIEW_RULES],
-  design:  [...COMPACT_RULES, ...DESIGN_RULES],
-  docs:    [...COMPACT_RULES, ...DOCS_RULES],
+  review: [...COMPACT_RULES, ...REVIEW_RULES],
+  design: [...COMPACT_RULES, ...DESIGN_RULES],
+  docs: [...COMPACT_RULES, ...DOCS_RULES],
 };
 
 // ── 내부: 정렬된 치환 쌍 빌드 헬퍼 ──
@@ -134,7 +135,7 @@ const CODE_BLOCK_RE = /```[\s\S]*?```/g;
  */
 function withCodeProtection(text, transform) {
   const blocks = [];
-  const placeholder = '\x00CB';
+  const placeholder = "\x00CB";
   let idx = 0;
   const masked = text.replace(CODE_BLOCK_RE, (match) => {
     blocks.push(match);
@@ -145,7 +146,7 @@ function withCodeProtection(text, transform) {
 
   // 플레이스홀더 복원
   return transformed.replace(
-    new RegExp(`${placeholder}(\\d+)${placeholder}`, 'g'),
+    new RegExp(`${placeholder}(\\d+)${placeholder}`, "g"),
     (_, i) => blocks[Number(i)],
   );
 }
@@ -169,14 +170,14 @@ export function isCompactMode() {
  * @returns {string}
  */
 export function compactify(text) {
-  if (!text || typeof text !== 'string') return text ?? '';
+  if (!text || typeof text !== "string") return text ?? "";
   _compactMode = true;
 
   return withCodeProtection(text, (segment) => {
     let result = segment;
     for (const { pattern, to } of _compactPairs) {
-      const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-      const re = new RegExp(escaped, 'gi');
+      const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const re = new RegExp(escaped, "gi");
       result = result.replace(re, to);
     }
     return result;
@@ -189,8 +190,8 @@ export function compactify(text) {
  * @param {'default'|'review'|'design'|'docs'} [profile='default'] — 도메인 프로필
  * @returns {string}
  */
-export function applyCompactRules(text, profile = 'default') {
-  if (!text || typeof text !== 'string') return text ?? '';
+export function applyCompactRules(text, profile = "default") {
+  if (!text || typeof text !== "string") return text ?? "";
 
   const rules = PROFILE_MAP[profile] ?? COMPACT_RULES;
   const pairs = buildCompactPairs(rules);
@@ -198,8 +199,8 @@ export function applyCompactRules(text, profile = 'default') {
   return withCodeProtection(text, (segment) => {
     let result = segment;
     for (const { pattern, to } of pairs) {
-      const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-      const re = new RegExp(escaped, 'gi');
+      const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const re = new RegExp(escaped, "gi");
       result = result.replace(re, to);
     }
     return result;
@@ -212,14 +213,14 @@ export function applyCompactRules(text, profile = 'default') {
  * @returns {string}
  */
 export function expand(text) {
-  if (!text || typeof text !== 'string') return text ?? '';
+  if (!text || typeof text !== "string") return text ?? "";
   _compactMode = false;
 
   return withCodeProtection(text, (segment) => {
     let result = segment;
     for (const { symbol, restore } of _expandPairs) {
-      const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-      const re = new RegExp(escaped, 'g');
+      const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const re = new RegExp(escaped, "g");
       result = result.replace(re, restore);
     }
     return result;