freelang-editor 11.7.4

package/src/runtime-helpers.ts

@@ -0,0 +1,234 @@
+/**
+ * src/runtime-helpers.ts
+ *
+ * Runtime helper functions for FreeLang
+ * Extracted and enhanced for self-hosting L2 Fixpoint
+ */
+
+/**
+ * 런타임 헬퍼 함수 프리앰블 생성
+ * Stage1.js 최상단에 주입되어 JavaScript 코드 실행 지원
+ */
+export function generateRuntimePreamble(): string {
+  return `
+// ═══════════════════════════════════════════════════════
+// FreeLang v11 Runtime Helpers (Enhanced 2026-04-30)
+// ═══════════════════════════════════════════════════════
+
+// ─ 산술 및 논리 연산자 (stdlib) ─
+function _plus(...args) { if (args.length === 0) return 0; if (args.length === 1) return args[0]; return args.reduce((a, b) => a + b); }
+function _minus(...args) { if (args.length === 0) return 0; if (args.length === 1) return -args[0]; return args.reduce((a, b) => a - b); }
+function _star(...args) { if (args.length === 0) return 1; if (args.length === 1) return args[0]; return args.reduce((a, b) => a * b); }
+function _slash(...args) { if (args.length === 0) return 1; if (args.length === 1) return 1/args[0]; return args.reduce((a, b) => a / b); }
+function _gt(a, b) { return a > b; }
+function _lt(a, b) { return a < b; }
+function _eq(a, b) { return a === b; }
+function _gt_eq(a, b) { return a >= b; }
+function _lt_eq(a, b) { return a <= b; }
+function _not(a) { return !a; }
+function _and(...args) { for(let a of args) if(!a) return false; return args.length > 0 ? args[args.length-1] : true; }
+function _or(...args) { for(let a of args) if(a) return a; return false; }
+function _concat(...args) { 
+  if (args.length === 0) return "";
+  if (Array.isArray(args[0])) return [].concat(...args);
+  return args.join("");
+}
+
+// ─ 타입 체크 ─
+function _fl_null_q(v) { return v === null || v === undefined; }
+function _fl_true_q(v) { return v === true; }
+function _fl_false_q(v) { return v === false; }
+function _fl_number_q(v) { return typeof v === 'number'; }
+function _fl_string_q(v) { return typeof v === 'string'; }
+function _fl_list_q(v) { return Array.isArray(v); }
+function _fl_array_q(v) { return Array.isArray(v); }
+function _fl_map_q(v) { return v !== null && typeof v === 'object' && !Array.isArray(v); }
+function _fl_fn_q(v) { return typeof v === 'function'; }
+
+// ─ 데이터 접근 및 조작 ─
+function _fl_length(v) { if(v==null) return 0; return v.length !== undefined ? v.length : 0; }
+function _fl_get(obj, key, dflt) {
+  if (obj === null || obj === undefined) return dflt || null;
+  if (obj instanceof Map) return obj.has(key) ? obj.get(key) : (dflt || null);
+  
+  let k = (typeof key === "object" && key !== null) ? (key.name || key.value || String(key)) : String(key);
+  if (k.startsWith(":")) k = k.slice(1);
+
+  if (Array.isArray(obj)) {
+    if (typeof key === "number") return obj[key] !== undefined ? obj[key] : (dflt || null);
+    if (k === "length") return obj.length;
+    let idx = parseInt(k);
+    if (!isNaN(idx)) return obj[idx] !== undefined ? obj[idx] : (dflt || null);
+  }
+  
+  if (typeof obj === "object") {
+    if (obj[k] !== undefined) return obj[k];
+    if (obj[":" + k] !== undefined) return obj[":" + k];
+  }
+  return dflt || null;
+}
+function _fl_first(l) { return (l && l.length > 0) ? l[0] : null; }
+function _fl_last(l) { return (l && l.length > 0) ? l[l.length - 1] : null; }
+function _fl_rest(l) { return (l && l.length > 0) ? l.slice(1) : []; }
+function _fl_append(l, x) { return [...(l || []), x]; }
+function _fl_concat(a, b) { return Array.isArray(a) && Array.isArray(b) ? [...a, ...b] : String(a || "") + String(b || ""); }
+function _fl_keys(o) { return o ? Object.keys(o) : []; }
+function _fl_values(o) { return o ? Object.values(o) : []; }
+var _fl_entries = (o) => o ? Object.entries(o).map(([k,v]) => [k,v]) : [];
+function _fl_map_set(o, ...args) { const result = {...(o || {})}; for (let i = 0; i + 1 < args.length; i += 2) { result[args[i]] = args[i + 1]; } return result; }
+function _fl_has_key_q(o, k) { return o ? (String(k) in o) : false; }
+
+// ─ 문자열 조작 ─
+function _fl_str(...xs) { return xs.map(x => x === null || x === undefined ? "" : (typeof x === "object" ? JSON.stringify(x) : String(x))).join(""); }
+function _fl_char_at(s, i) { return (s && s[i]) || null; }
+function _fl_substring(s, a, b) { return s ? (b === undefined ? s.slice(a) : s.slice(a, b)) : ""; }
+function _fl_lower(s) { return String(s || "").toLowerCase(); }
+function _fl_upper(s) { return String(s || "").toUpperCase(); }
+function _fl_trim(s) { return String(s || "").trim(); }
+function _fl_replace(s, a, b) { return String(s || "").split(a).join(b); }
+function _fl_str_index_of(s, sub) { return (s || "").indexOf(sub); }
+function _fl_contains_q(s, sub) { return (s || "").includes(sub); }
+function _fl_str_to_num(s) { const n = Number(s); return isNaN(n) ? null : n; }
+function _fl_join(arr, sep) { return (arr || []).join(sep !== undefined ? sep : ""); }
+function _fl_split(s, sep) { return (s || "").split(sep !== undefined ? sep : ""); }
+function _fl_repeat(s, n) { return (s || "").repeat(n || 0); }
+function _fl_range(a, b, s) { let r = []; let start = b === undefined ? 0 : a; let end = b === undefined ? a : b; let step = s || 1; if (step > 0) { for (let i = start; i < end; i += step) r.push(i); } else { for (let i = start; i > end; i += step) r.push(i); } return r; }
+
+// ─ 고차 함수 (Null-safe & Spread) ─
+function _fl_map(arr, fn) { return (arr || []).map(x => fn(x)); }
+function _fl_filter(arr, fn) { return (arr || []).filter(x => { const r = fn(x); return r !== false && r !== null; }); }
+function _fl_reduce(arr, fn, init) { return (arr || []).reduce((a, x) => fn(a, x), init); }
+
+// ─ 데이터 접근 및 조작 보조 ─
+function _fl_slice(l, a, b) { return (l || []).slice(a, b); }
+
+// ─ 시스템 및 I/O ─
+function _fl_print(v) { console.log(v); return v; }
+function _fl_get_argv() { return (typeof process !== "undefined" ? process.argv.slice(2) : []); }
+function _fl_file_read(p) { return require("fs").readFileSync(p, "utf8"); }
+function _fl_file_write(p, c) { return require("fs").writeFileSync(p, c); }
+function _fl_file_exists(p) { return require("fs").existsSync(p); }
+function _fl_file_delete(p) { try { require("fs").unlinkSync(p); } catch(e) {} }
+function _fl_file_append(p, c) { require("fs").appendFileSync(p, String(c)); }
+function _fl_file_copy(s, d) { require("fs").copyFileSync(s, d); }
+function _fl_file_rename(o, n) { require("fs").renameSync(o, n); }
+function _fl_file_size(p) { try { return require("fs").statSync(p).size; } catch(e) { return 0; } }
+function _fl_file_modified(p) { try { return require("fs").statSync(p).mtimeMs; } catch(e) { return 0; } }
+function _fl_file_mkdir(p) { try { require("fs").mkdirSync(p, { recursive: true }); } catch(e) {} }
+function _fl_file_rmdir(p) { try { require("fs").rmSync(p, { recursive: true, force: true }); } catch(e) {} }
+function _fl_file_list(p) { try { return require("fs").readdirSync(p); } catch(e) { return []; } }
+function _fl_process_run(cmd) { try { const {execSync}=require("child_process"); return execSync(cmd,{encoding:"utf8"}); } catch(e) { return ""; } }
+function _fl_process_run_args(cmd, args) { try { const {execSync}=require("child_process"); return execSync(cmd+" "+(args||[]).join(" "),{encoding:"utf8"}); } catch(e) { return ""; } }
+function _fl_process_exec(cmd) { try { const {execSync}=require("child_process"); return execSync(cmd,{encoding:"utf8"}); } catch(e) { return ""; } }
+function _fl_process_exec_args(cmd, args) { try { const {execSync}=require("child_process"); return execSync(cmd+" "+(args||[]).join(" "),{encoding:"utf8"}); } catch(e) { return ""; } }
+function _fl_process_spawn(cmd, args) { try { const {spawnSync}=require("child_process"); const r=spawnSync(cmd,args||[],{encoding:"utf8"}); return r.stdout||""; } catch(e) { return ""; } }
+function _fl_run_inherit(cmd) { require("child_process").spawnSync(cmd,{shell:true,stdio:"inherit"}); }
+function _fl_process_kill(pid) { try { process.kill(pid); } catch(e) {} }
+function _fl_process_wait(pid) { return null; }
+function _fl_env_get(k) { return process.env[k] || null; }
+function _fl_env_set(k, v) { process.env[k] = String(v); }
+function _fl_env_all() { return process.env; }
+function _fl_file_is_file(p) { try { return require("fs").statSync(p).isFile(); } catch(e) { return false; } }
+function _fl_file_is_dir(p) { try { return require("fs").statSync(p).isDirectory(); } catch(e) { return false; } }
+function _fl_process_exists(pid) { try { process.kill(pid, 0); return true; } catch(e) { return false; } }
+function _fl_process_getcwd() { return process.cwd(); }
+function _fl_process_chdir(p) { try { process.chdir(p); } catch(e) {} }
+function _fl_process_pid() { return process.pid; }
+function _fl_process_ppid() { return process.ppid || null; }
+function _fl_readline(prompt) {
+  if (prompt) process.stdout.write(prompt);
+  try {
+    const fs = require("fs");
+    const parts = [];
+    const b = Buffer.alloc(1);
+    while (true) {
+      const n = fs.readSync(process.stdin.fd, b, 0, 1);
+      if (n === 0) return parts.length === 0 ? null : parts.join("");
+      const c = b[0];
+      if (c === 10) break;
+      if (c !== 13) parts.push(String.fromCharCode(c));
+    }
+    return parts.join("");
+  } catch(e) { return null; }
+}
+function _fl_shell_capture(cmd) {
+  try {
+    const {execSync} = require("child_process");
+    return {stdout: execSync(cmd, {encoding: "utf8"}), stderr: "", code: 0, ok: true};
+  } catch(e) {
+    return {stdout: "", stderr: String(e), code: 1, ok: false};
+  }
+}
+
+// ─ 타입 ─
+function _fl_type_of(v) { if (v === null || v === undefined) return "nil"; if (Array.isArray(v)) return "list"; return typeof v; }
+
+// ─ 기타 ─
+function _while(condFn, bodyFn) { while(condFn()) { bodyFn(); } }
+
+// ─ 시간 ─
+const now_ms = () => Date.now();
+const now_iso = () => new Date().toISOString();
+const now_unix = () => Math.floor(Date.now() / 1000);
+
+// ─ 셸 실행 ─
+const shell_exec = (cmd, inp) => { try { const {execSync} = require("child_process"); const opts = {encoding: "utf8"}; if (inp) opts["input"] = inp; return execSync(cmd, opts); } catch(e) { return ""; } };
+
+// ─ 수학 ─
+var math_sqrt = (n) => Math.sqrt(n);
+var math_pow = (a, b) => Math.pow(a, b);
+var math_pi = Math.PI;
+var round = (n) => Math.round(n);
+var floor = (n) => Math.floor(n);
+var ceil = (n) => Math.ceil(n);
+var abs = (n) => Math.abs(n);
+var min = (...args) => Math.min(...args);
+var max = (...args) => Math.max(...args);
+
+// ─ 컬렉션 확장 ─
+function _fl_take(n, arr) { return (arr || []).slice(0, n); }
+function _fl_drop(n, arr) { return (arr || []).slice(n); }
+function _fl_zip(a, b) { const r = []; const l = Math.min((a || []).length, (b || []).length); for (let i = 0; i < l; i++) r.push([a[i], b[i]]); return r; }
+function _fl_flatten(arr) { return (arr || []).flat(); }
+function _fl_reverse(arr) { return Array.isArray(arr) ? [...arr].reverse() : arr; }
+function _fl_sort(arr, fn) { return fn ? [...(arr || [])].sort((a, b) => fn(a, b) ? -1 : 1) : [...(arr || [])].sort(); }
+
+// ─ 문자열 공개 별칭 ─
+var str_upper = (s) => String(s || "").toUpperCase();
+var str_lower = (s) => String(s || "").toLowerCase();
+var str_contains = (s, sub) => String(s || "").includes(String(sub || ""));
+var str_replace = (s, a, b) => { if (s == null) return ""; return String(s).split(String(a || "")).join(String(b || "")); };
+var str_starts_with = (s, p) => String(s || "").startsWith(String(p || ""));
+var str_ends_with = (s, sf) => String(s || "").endsWith(String(sf || ""));
+var str_trim = (s) => String(s || "").trim();
+var str_length = (s) => String(s || "").length;
+var str_split = (s, sep) => String(s || "").split(sep);
+
+// ─ 타입 확장 ─
+var list_q = (v) => Array.isArray(v);
+var map_q = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var fn_q = (v) => typeof v === "function";
+
+// ─ IIFE 폴백 ─
+var unknown = (...a) => a[a.length - 1];
+
+// ─ 글로벌 바인딩 ─
+let __argv__ = _fl_get_argv();
+
+// ═══════════════════════════════════════════════════════
+`.trim();
+}
+
+/**
+ * 헬퍼 함수 목록
+ */
+export const HELPER_FUNCTIONS = [
+  '_plus', '_minus', '_star', '_slash', '_gt', '_lt', '_eq', '_gt_eq', '_lt_eq', '_not', '_and', '_or', '_concat',
+  '_fl_null_q', '_fl_true_q', '_fl_false_q', '_fl_number_q', '_fl_string_q', '_fl_list_q', '_fl_array_q', '_fl_map_q', '_fl_fn_q',
+  '_fl_length', '_fl_get', '_fl_first', '_fl_last', '_fl_rest', '_fl_append', '_fl_concat', '_fl_keys', '_fl_values', '_fl_entries', '_fl_map_set', '_fl_has_key_q',
+  '_fl_str', '_fl_char_at', '_fl_substring', '_fl_lower', '_fl_upper', '_fl_trim', '_fl_replace', '_fl_str_index_of', '_fl_contains_q', '_fl_str_to_num', '_fl_join', '_fl_split', '_fl_repeat', '_fl_range',
+  '_fl_map', '_fl_filter', '_fl_reduce', '_fl_slice', '_fl_print', '_fl_get_argv', '_fl_file_read', '_fl_file_write', '_fl_file_exists', '_fl_shell_capture',
+  '_fl_take', '_fl_drop', '_fl_zip', '_fl_flatten', '_fl_reverse', '_fl_sort'
+];
+
+export const HELPER_COUNT = HELPER_FUNCTIONS.length;

package/src/self-evolution-hub.ts

@@ -0,0 +1,431 @@
+// self-evolution-hub.ts — FreeLang v9 Phase 140: 자기 진화 통합 허브
+// Phase 131-139의 모든 자기 진화 기능을 통합하는 마스터 허브
+
+import { EvolutionEngine, evolveNumbers as _evolveNumbers, evolveStrings as _evolveStrings } from "./evolve";
+import { Mutator } from "./mutate";
+import { Crossover } from "./crossover";
+import { FitnessEvaluator } from "./fitness";
+import { GenerationLoop } from "./generation";
+import { Pruner } from "./prune";
+import { SelfRefactorer } from "./refactor-self";
+import { SelfBenchmark } from "./benchmark-self";
+import { SelfVersioning } from "./version-self";
+import { randomUUID } from "crypto";
+
+// ── 타입 정의 ─────────────────────────────────────────────────────────────────
+
+export interface EvolutionCycleConfig {
+  target: unknown;                  // 목표 솔루션
+  populationSize: number;           // 개체군 크기
+  generations: number;              // 세대 수
+  mutationRate: number;             // 변이율
+  eliteRatio: number;               // 엘리트 비율
+  pruneThreshold: number;           // 가지치기 임계값
+  enableVersioning: boolean;        // 버전 관리 사용 여부
+  enableBenchmark: boolean;         // 벤치마크 측정 여부
+  enableRefactor: boolean;          // 리팩토링 사용 여부
+}
+
+export const DEFAULT_CYCLE_CONFIG: EvolutionCycleConfig = {
+  target: null,
+  populationSize: 20,
+  generations: 30,
+  mutationRate: 0.1,
+  eliteRatio: 0.1,
+  pruneThreshold: 0.2,
+  enableVersioning: false,
+  enableBenchmark: false,
+  enableRefactor: false,
+};
+
+export interface EvolutionCycleResult {
+  best: unknown;                    // 최고 솔루션
+  bestFitness: number;              // 최고 적합도
+  generations: number;              // 실행 세대 수
+  improvements: number;             // 총 개선 횟수
+  prunedCount: number;              // 가지치기된 수
+  benchmarkMs?: number;             // 실행 시간 (enableBenchmark)
+  versionId?: string;               // 저장된 버전 ID (enableVersioning)
+  report: string;                   // 텍스트 리포트
+}
+
+export interface SelfEvolutionReport {
+  timestamp: Date;
+  cycles: number;
+  totalGenerations: number;
+  fitnessProgress: number[];        // 세대별 최고 적합도
+  refactorSuggestions: number;      // 리팩토링 제안 수
+  versions: number;                 // 생성된 버전 수
+  summary: string;
+}
+
+// ── SelfEvolutionHub ──────────────────────────────────────────────────────────
+
+export class SelfEvolutionHub {
+  private fitnessEval: FitnessEvaluator;
+  private pruner: Pruner<unknown>;
+  private refactorer: SelfRefactorer;
+  private benchmark: SelfBenchmark;
+  private versioning: SelfVersioning<unknown>;
+
+  // 내부 통계
+  private _cycleCount: number = 0;
+  private _totalGenerations: number = 0;
+  private _refactorSuggestions: number = 0;
+  private _versionCount: number = 0;
+  private _fitnessHistory: number[] = [];
+
+  constructor() {
+    this.fitnessEval = new FitnessEvaluator({ normalize: true, maximize: true });
+    this.pruner = new Pruner<unknown>();
+    this.refactorer = new SelfRefactorer();
+    this.benchmark = new SelfBenchmark("self-evolution-hub");
+    this.versioning = new SelfVersioning<unknown>(200);
+  }
+
+  // ── 완전한 진화 사이클 실행 ────────────────────────────────────────────────
+
+  runCycle(
+    population: unknown[],
+    fitnessFunc: (item: unknown) => number,
+    mutateFunc: (item: unknown) => unknown,
+    crossoverFunc: (a: unknown, b: unknown) => unknown,
+    config?: Partial<EvolutionCycleConfig>
+  ): EvolutionCycleResult {
+    const cfg: EvolutionCycleConfig = { ...DEFAULT_CYCLE_CONFIG, ...config };
+    const startMs = Date.now();
+
+    // 빈 population 처리
+    if (!population || population.length === 0) {
+      return this._emptyResult(cfg);
+    }
+
+    const pop = [...population];
+    let bestFitness = -Infinity;
+    let best: unknown = pop[0];
+    let improvements = 0;
+    let prunedCount = 0;
+    const fitnessProgress: number[] = [];
+    let gens = 0;
+
+    const mutator = new Mutator({ rate: cfg.mutationRate });
+    const crossover = new Crossover();
+    const genLoop = new GenerationLoop({ maxGenerations: cfg.generations });
+
+    // 세대별 진화 루프
+    for (let g = 0; g < cfg.generations; g++) {
+      gens++;
+
+      // 각 개체의 적합도 계산
+      const scored = pop.map(item => ({
+        item,
+        fitness: fitnessFunc(item),
+      }));
+      scored.sort((a, b) => b.fitness - a.fitness);
+
+      const genBest = scored[0].fitness;
+      fitnessProgress.push(genBest);
+
+      if (genBest > bestFitness) {
+        bestFitness = genBest;
+        best = scored[0].item;
+        improvements++;
+      }
+
+      // 가지치기
+      const pruneCount = Math.floor(pop.length * cfg.pruneThreshold);
+      if (pruneCount > 0) {
+        prunedCount += pruneCount;
+        // 하위 pruneCount개 제거 후 채우기
+        const kept = scored.slice(0, pop.length - pruneCount).map(s => s.item);
+        pop.length = 0;
+        pop.push(...kept);
+      }
+
+      // 새 개체 생성 (교배 + 변이)
+      while (pop.length < cfg.populationSize) {
+        const a = pop[Math.floor(Math.random() * pop.length)];
+        const b = pop[Math.floor(Math.random() * pop.length)];
+        const child = crossoverFunc(a, b);
+        const mutated = mutateFunc(child);
+        pop.push(mutated);
+      }
+    }
+
+    this._cycleCount++;
+    this._totalGenerations += gens;
+    this._fitnessHistory.push(...fitnessProgress);
+
+    // 벤치마크
+    let benchmarkMs: number | undefined;
+    if (cfg.enableBenchmark) {
+      benchmarkMs = Date.now() - startMs;
+    }
+
+    // 버전 관리
+    let versionId: string | undefined;
+    if (cfg.enableVersioning) {
+      try {
+        const snap = this.versioning.snapshot(
+          best,
+          `evolution-cycle-${this._cycleCount}`,
+          ["auto-evolved"],
+          bestFitness
+        );
+        versionId = snap.id;
+        this._versionCount++;
+      } catch {
+        versionId = randomUUID();
+        this._versionCount++;
+      }
+    }
+
+    // 리팩토링 제안
+    let refactorCount = 0;
+    if (cfg.enableRefactor) {
+      try {
+        const suggestions = this.refactorer.suggest(String(best));
+        refactorCount = suggestions.length;
+        this._refactorSuggestions += refactorCount;
+      } catch {
+        refactorCount = 0;
+      }
+    }
+
+    const report = this._buildReport({
+      bestFitness,
+      generations: gens,
+      improvements,
+      prunedCount,
+      benchmarkMs,
+      versionId,
+      refactorCount,
+    });
+
+    return {
+      best,
+      bestFitness,
+      generations: gens,
+      improvements,
+      prunedCount,
+      benchmarkMs,
+      versionId,
+      report,
+    };
+  }
+
+  // ── 숫자 배열 자동 진화 (올인원) ────────────────────────────────────────────
+
+  evolveNumbers(
+    target: number[],
+    config?: Partial<EvolutionCycleConfig>
+  ): EvolutionCycleResult {
+    const cfg: EvolutionCycleConfig = { ...DEFAULT_CYCLE_CONFIG, target, ...config };
+    const popSize = cfg.populationSize;
+    const len = target.length;
+
+    // 초기 population 생성 (랜덤 배열)
+    const initPop: number[][] = Array.from({ length: popSize }, () =>
+      Array.from({ length: len }, () => Math.random() * 10)
+    );
+
+    // 적합도: 목표 배열에 가까울수록 높음
+    const fitnessFunc = (item: unknown): number => {
+      const arr = item as number[];
+      if (!Array.isArray(arr)) return 0;
+      const dist = target.reduce((sum, t, i) => sum + Math.abs(t - (arr[i] ?? 0)), 0);
+      return 1 / (1 + dist);
+    };
+
+    // 변이: 랜덤 인덱스 값 조정
+    const mutateFunc = (item: unknown): unknown => {
+      const arr = [...(item as number[])];
+      const idx = Math.floor(Math.random() * arr.length);
+      arr[idx] += (Math.random() - 0.5) * cfg.mutationRate * 2;
+      return arr;
+    };
+
+    // 교배: 단순 단일점 교배
+    const crossoverFunc = (a: unknown, b: unknown): unknown => {
+      const arrA = a as number[];
+      const arrB = b as number[];
+      const point = Math.floor(Math.random() * arrA.length);
+      return [...arrA.slice(0, point), ...arrB.slice(point)];
+    };
+
+    return this.runCycle(initPop, fitnessFunc, mutateFunc, crossoverFunc, cfg);
+  }
+
+  // ── 문자열 자동 진화 ────────────────────────────────────────────────────────
+
+  evolveString(
+    target: string,
+    config?: Partial<EvolutionCycleConfig>
+  ): EvolutionCycleResult {
+    const cfg: EvolutionCycleConfig = { ...DEFAULT_CYCLE_CONFIG, target, ...config };
+    const CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ";
+    const len = target.length;
+    const popSize = cfg.populationSize;
+
+    // 초기 population
+    const initPop: string[] = Array.from({ length: popSize }, () =>
+      Array.from({ length: len }, () => CHARS[Math.floor(Math.random() * CHARS.length)]).join("")
+    );
+
+    // 적합도: 목표 문자열과 같은 문자 비율
+    const fitnessFunc = (item: unknown): number => {
+      const s = String(item);
+      if (s.length !== target.length) return 0;
+      let matches = 0;
+      for (let i = 0; i < target.length; i++) {
+        if (s[i] === target[i]) matches++;
+      }
+      return matches / target.length;
+    };
+
+    // 변이: 랜덤 문자 교체
+    const mutateFunc = (item: unknown): unknown => {
+      const chars = String(item).split("");
+      for (let i = 0; i < chars.length; i++) {
+        if (Math.random() < cfg.mutationRate) {
+          chars[i] = CHARS[Math.floor(Math.random() * CHARS.length)];
+        }
+      }
+      return chars.join("");
+    };
+
+    // 교배: 단일점
+    const crossoverFunc = (a: unknown, b: unknown): unknown => {
+      const sa = String(a);
+      const sb = String(b);
+      const point = Math.floor(Math.random() * sa.length);
+      return sa.slice(0, point) + sb.slice(point);
+    };
+
+    return this.runCycle(initPop, fitnessFunc, mutateFunc, crossoverFunc, cfg);
+  }
+
+  // ── 리포트 생성 ────────────────────────────────────────────────────────────
+
+  generateReport(results: EvolutionCycleResult[]): SelfEvolutionReport {
+    const cycles = results.length;
+    const totalGenerations = results.reduce((sum, r) => sum + r.generations, 0);
+    const fitnessProgress = results.map(r => r.bestFitness);
+    const refactorSuggestions = this._refactorSuggestions;
+    const versions = this._versionCount;
+
+    const avgFitness = fitnessProgress.length > 0
+      ? fitnessProgress.reduce((a, b) => a + b, 0) / fitnessProgress.length
+      : 0;
+    const maxFitness = fitnessProgress.length > 0 ? Math.max(...fitnessProgress) : 0;
+
+    const summary = [
+      `[SelfEvolutionHub] ${cycles}개 사이클, ${totalGenerations}세대 실행`,
+      `최고 적합도: ${maxFitness.toFixed(4)}, 평균: ${avgFitness.toFixed(4)}`,
+      `리팩토링 제안: ${refactorSuggestions}개, 버전: ${versions}개`,
+    ].join(" | ");
+
+    return {
+      timestamp: new Date(),
+      cycles,
+      totalGenerations,
+      fitnessProgress,
+      refactorSuggestions,
+      versions,
+      summary,
+    };
+  }
+
+  // ── 자기 개선 ──────────────────────────────────────────────────────────────
+
+  selfImprove(baseConfig: Partial<EvolutionCycleConfig>): {
+    optimized: EvolutionCycleConfig;
+    improvement: number;
+  } {
+    const base: EvolutionCycleConfig = { ...DEFAULT_CYCLE_CONFIG, ...baseConfig };
+
+    // 여러 설정 후보로 테스트
+    const candidates: EvolutionCycleConfig[] = [
+      { ...base },
+      { ...base, mutationRate: Math.min(0.5, base.mutationRate * 1.5) },
+      { ...base, mutationRate: Math.max(0.01, base.mutationRate * 0.7) },
+      { ...base, populationSize: Math.min(100, base.populationSize * 2) },
+      { ...base, eliteRatio: Math.min(0.5, base.eliteRatio * 1.5) },
+      { ...base, pruneThreshold: Math.max(0.05, base.pruneThreshold * 0.8) },
+    ];
+
+    let bestConfig = base;
+    let baseScore = 0;
+    let bestScore = 0;
+
+    // 간단한 테스트: 고정 타겟으로 적합도 비교
+    const testTarget = [1, 2, 3, 4, 5];
+
+    candidates.forEach((cfg, idx) => {
+      const result = this.evolveNumbers(testTarget, { ...cfg, generations: 10 });
+      if (idx === 0) {
+        baseScore = result.bestFitness;
+        bestScore = baseScore;
+        bestConfig = cfg;
+      } else if (result.bestFitness > bestScore) {
+        bestScore = result.bestFitness;
+        bestConfig = cfg;
+      }
+    });
+
+    const improvement = baseScore > 0 ? (bestScore - baseScore) / baseScore : 0;
+
+    return {
+      optimized: bestConfig,
+      improvement: Math.max(0, improvement),
+    };
+  }
+
+  // ── 내부 헬퍼 ─────────────────────────────────────────────────────────────
+
+  private _emptyResult(cfg: EvolutionCycleConfig): EvolutionCycleResult {
+    return {
+      best: null,
+      bestFitness: 0,
+      generations: 0,
+      improvements: 0,
+      prunedCount: 0,
+      report: "[SelfEvolutionHub] 빈 population — 진화 없음",
+    };
+  }
+
+  private _buildReport(info: {
+    bestFitness: number;
+    generations: number;
+    improvements: number;
+    prunedCount: number;
+    benchmarkMs?: number;
+    versionId?: string;
+    refactorCount?: number;
+  }): string {
+    const parts = [
+      `[SelfEvolutionHub] 최고 적합도=${info.bestFitness.toFixed(4)}`,
+      `세대=${info.generations}`,
+      `개선=${info.improvements}`,
+      `가지치기=${info.prunedCount}`,
+    ];
+    if (info.benchmarkMs !== undefined) parts.push(`실행시간=${info.benchmarkMs}ms`);
+    if (info.versionId) parts.push(`버전ID=${info.versionId.slice(0, 8)}...`);
+    if (info.refactorCount !== undefined && info.refactorCount > 0) {
+      parts.push(`리팩토링제안=${info.refactorCount}개`);
+    }
+    return parts.join(", ");
+  }
+
+  // ── 통계 접근자 ────────────────────────────────────────────────────────────
+
+  get cycleCount(): number { return this._cycleCount; }
+  get totalGenerations(): number { return this._totalGenerations; }
+  get refactorSuggestions(): number { return this._refactorSuggestions; }
+  get versionCount(): number { return this._versionCount; }
+  get fitnessHistory(): number[] { return [...this._fitnessHistory]; }
+}
+
+// ── 싱글톤 ────────────────────────────────────────────────────────────────────
+
+export const globalSelfEvolution = new SelfEvolutionHub();