freelang-editor 11.7.4

package/src/test-phase142-causal.ts

@@ -0,0 +1,384 @@
+// test-phase142-causal.ts — Phase 142: CAUSAL 인과 추론 테스트
+// 최소 25 PASS
+
+import { CausalGraph, CausalNode, CausalEdge, CausalChain, CausalExplanation, globalCausal, whyCaused } from "./causal";
+import { Interpreter } from "./interpreter";
+import { lex } from "./lexer";
+import { parse } from "./parser";
+
+// ── 테스트 유틸 ────────────────────────────────────────────────────────────────
+
+let passed = 0;
+let failed = 0;
+
+function test(name: string, fn: () => void): void {
+  try {
+    fn();
+    console.log(`  ✅ PASS: ${name}`);
+    passed++;
+  } catch (e: any) {
+    console.log(`  ❌ FAIL: ${name} — ${e.message ?? e}`);
+    failed++;
+  }
+}
+
+function assert(cond: boolean, msg: string): void {
+  if (!cond) throw new Error(msg);
+}
+
+function evalFL(interp: Interpreter, code: string): any {
+  const tokens = lex(code);
+  const ast = parse(tokens);
+  let result: any;
+  for (const node of ast) result = (interp as any).eval(node);
+  return result;
+}
+
+// ── 시나리오 설정: 비 → 젖은 도로 → 사고 ─────────────────────────────────────
+
+console.log("\n=== Phase 142: CAUSAL 인과 추론 테스트 ===\n");
+
+// ── 1. CausalGraph 생성 ────────────────────────────────────────────────────────
+console.log("[ CausalGraph 기본 기능 ]");
+
+test("1. CausalGraph 생성", () => {
+  const g = new CausalGraph();
+  assert(g !== null && g !== undefined, "CausalGraph 인스턴스 생성 실패");
+});
+
+// ── 2. addNode 노드 추가 ──────────────────────────────────────────────────────
+test("2. addNode 노드 추가", () => {
+  const g = new CausalGraph();
+  g.addNode({ id: "rain", name: "비", description: "강수" });
+  g.addNode({ id: "wet-road", name: "젖은 도로", description: "도로 표면 습윤" });
+  g.addNode({ id: "accident", name: "사고", description: "교통 사고" });
+  // getDirectCauses 호출 시 에러 없으면 성공
+  const causes = g.getDirectCauses("wet-road");
+  assert(Array.isArray(causes), "getDirectCauses가 배열을 반환해야 함");
+});
+
+// ── 3. addEdge 인과 에지 추가 ─────────────────────────────────────────────────
+test("3. addEdge 인과 에지 추가", () => {
+  const g = new CausalGraph();
+  g.addNode({ id: "rain", name: "비", description: "강수" });
+  g.addNode({ id: "wet-road", name: "젖은 도로", description: "도로 표면 습윤" });
+  g.addEdge({ from: "rain", to: "wet-road", strength: 0.9, confidence: 0.95, mechanism: "물리적 접촉" });
+  const causes = g.getDirectCauses("wet-road");
+  assert(causes.length === 1, `직접 원인이 1개여야 함, got ${causes.length}`);
+  assert(causes[0].from === "rain", "원인이 rain이어야 함");
+});
+
+// ── 4. getDirectCauses 직접 원인 ─────────────────────────────────────────────
+test("4. getDirectCauses 직접 원인", () => {
+  const g = new CausalGraph();
+  g.addNode({ id: "rain", name: "비", description: "강수" });
+  g.addNode({ id: "wet-road", name: "젖은 도로", description: "도로 표면 습윤" });
+  g.addNode({ id: "fog", name: "안개", description: "시야 제한" });
+  g.addEdge({ from: "rain", to: "wet-road", strength: 0.9, confidence: 0.95 });
+  g.addEdge({ from: "fog", to: "wet-road", strength: 0.3, confidence: 0.5 });
+  const causes = g.getDirectCauses("wet-road");
+  assert(causes.length === 2, `직접 원인이 2개여야 함, got ${causes.length}`);
+});
+
+// ── 5. getDirectEffects 직접 결과 ────────────────────────────────────────────
+test("5. getDirectEffects 직접 결과", () => {
+  const g = new CausalGraph();
+  g.addNode({ id: "rain", name: "비", description: "강수" });
+  g.addNode({ id: "wet-road", name: "젖은 도로", description: "도로 표면 습윤" });
+  g.addNode({ id: "flood", name: "홍수", description: "침수" });
+  g.addEdge({ from: "rain", to: "wet-road", strength: 0.9, confidence: 0.95 });
+  g.addEdge({ from: "rain", to: "flood", strength: 0.6, confidence: 0.7 });
+  const effects = g.getDirectEffects("rain");
+  assert(effects.length === 2, `직접 결과가 2개여야 함, got ${effects.length}`);
+});
+
+// ── 6. findCausalChains 인과 체인 ────────────────────────────────────────────
+test("6. findCausalChains 인과 체인", () => {
+  const g = new CausalGraph();
+  g.addNode({ id: "rain", name: "비", description: "강수" });
+  g.addNode({ id: "wet-road", name: "젖은 도로", description: "도로 표면 습윤" });
+  g.addNode({ id: "accident", name: "사고", description: "교통 사고" });
+  g.addEdge({ from: "rain", to: "wet-road", strength: 0.9, confidence: 0.95 });
+  g.addEdge({ from: "wet-road", to: "accident", strength: 0.7, confidence: 0.8 });
+  const chains = g.findCausalChains("rain", "accident");
+  assert(chains.length > 0, "인과 체인이 존재해야 함");
+  assert(chains[0].path[0] === "rain", "체인 시작이 rain이어야 함");
+  assert(chains[0].path[chains[0].path.length - 1] === "accident", "체인 끝이 accident여야 함");
+});
+
+// ── 7. CausalChain 구조 검증 ─────────────────────────────────────────────────
+test("7. CausalChain 구조 검증", () => {
+  const g = new CausalGraph();
+  g.addNode({ id: "rain", name: "비", description: "강수" });
+  g.addNode({ id: "accident", name: "사고", description: "교통 사고" });
+  g.addEdge({ from: "rain", to: "accident", strength: 0.8, confidence: 0.9 });
+  const chains = g.findCausalChains("rain", "accident");
+  assert(chains.length > 0, "체인이 존재해야 함");
+  const c = chains[0];
+  assert(Array.isArray(c.path), "path가 배열이어야 함");
+  assert(typeof c.totalStrength === "number", "totalStrength가 숫자여야 함");
+  assert(typeof c.explanation === "string", "explanation이 문자열이어야 함");
+  assert(typeof c.confidence === "number", "confidence가 숫자여야 함");
+});
+
+// ── 8. explain 인과 설명 ──────────────────────────────────────────────────────
+test("8. explain 인과 설명", () => {
+  const g = new CausalGraph();
+  g.addNode({ id: "rain", name: "비", description: "강수" });
+  g.addNode({ id: "wet-road", name: "젖은 도로", description: "도로 표면 습윤" });
+  g.addNode({ id: "accident", name: "사고", description: "교통 사고" });
+  g.addEdge({ from: "rain", to: "wet-road", strength: 0.9, confidence: 0.95 });
+  g.addEdge({ from: "wet-road", to: "accident", strength: 0.7, confidence: 0.8 });
+  const expl = g.explain("accident");
+  assert(expl !== null, "설명이 null이 아니어야 함");
+  assert(expl.effect === "accident", "effect가 accident여야 함");
+});
+
+// ── 9. CausalExplanation 구조 ────────────────────────────────────────────────
+test("9. CausalExplanation 구조", () => {
+  const g = new CausalGraph();
+  g.addNode({ id: "rain", name: "비", description: "강수" });
+  g.addNode({ id: "accident", name: "사고", description: "교통 사고" });
+  g.addEdge({ from: "rain", to: "accident", strength: 0.9, confidence: 0.95 });
+  const expl = g.explain("accident");
+  assert(typeof expl.effect === "string", "effect가 문자열이어야 함");
+  assert(Array.isArray(expl.causes), "causes가 배열이어야 함");
+  assert(typeof expl.primaryCause === "string", "primaryCause가 문자열이어야 함");
+  assert(typeof expl.explanation === "string", "explanation이 문자열이어야 함");
+  assert(typeof expl.confidence === "number", "confidence가 숫자여야 함");
+});
+
+// ── 10. primaryCause 정확성 ───────────────────────────────────────────────────
+test("10. primaryCause 정확성", () => {
+  const g = new CausalGraph();
+  g.addNode({ id: "rain", name: "비", description: "강수" });
+  g.addNode({ id: "minor-cause", name: "작은 원인", description: "약한 원인" });
+  g.addNode({ id: "accident", name: "사고", description: "교통 사고" });
+  g.addEdge({ from: "rain", to: "accident", strength: 0.9, confidence: 0.95 });
+  g.addEdge({ from: "minor-cause", to: "accident", strength: 0.1, confidence: 0.5 });
+  const expl = g.explain("accident");
+  assert(expl.primaryCause === "rain", `주요 원인이 rain이어야 함, got ${expl.primaryCause}`);
+});
+
+// ── 11. findRootCauses 루트 원인 ─────────────────────────────────────────────
+test("11. findRootCauses 루트 원인", () => {
+  const g = new CausalGraph();
+  g.addNode({ id: "climate", name: "기후", description: "기후 변화" });
+  g.addNode({ id: "rain", name: "비", description: "강수" });
+  g.addNode({ id: "accident", name: "사고", description: "교통 사고" });
+  g.addEdge({ from: "climate", to: "rain", strength: 0.8, confidence: 0.9 });
+  g.addEdge({ from: "rain", to: "accident", strength: 0.9, confidence: 0.95 });
+  const roots = g.findRootCauses("accident");
+  assert(roots.includes("climate"), `루트 원인에 climate가 포함되어야 함, got ${JSON.stringify(roots)}`);
+  assert(!roots.includes("rain"), "rain은 루트 원인이 아니어야 함 (더 깊은 원인이 있음)");
+});
+
+// ── 12. simulate 개입 시뮬레이션 ─────────────────────────────────────────────
+test("12. simulate 개입 시뮬레이션", () => {
+  const g = new CausalGraph();
+  g.addNode({ id: "rain", name: "비", description: "강수", value: 0 });
+  g.addNode({ id: "wet-road", name: "젖은 도로", description: "도로 표면 습윤", value: 0 });
+  g.addEdge({ from: "rain", to: "wet-road", strength: 0.9, confidence: 0.95 });
+  const result = g.simulate({ rain: 1.0 });
+  assert("rain" in result, "rain이 결과에 포함되어야 함");
+  assert("wet-road" in result, "wet-road가 파급효과로 포함되어야 함");
+  assert(result["wet-road"] > 0, `wet-road의 값이 양수여야 함, got ${result["wet-road"]}`);
+});
+
+// ── 13. 음수 strength (억제 관계) ────────────────────────────────────────────
+test("13. 음수 strength (억제 관계)", () => {
+  const g = new CausalGraph();
+  g.addNode({ id: "anti-slip", name: "미끄럼 방지", description: "타이어 마찰", value: 0 });
+  g.addNode({ id: "accident", name: "사고", description: "교통 사고", value: 0 });
+  g.addEdge({ from: "anti-slip", to: "accident", strength: -0.8, confidence: 0.9 });
+  const result = g.simulate({ "anti-slip": 1.0 });
+  assert("accident" in result, "accident가 결과에 포함되어야 함");
+  assert(result["accident"] < 0, `억제 관계로 accident 값이 음수여야 함, got ${result["accident"]}`);
+});
+
+// ── 14. confidence 전파 ───────────────────────────────────────────────────────
+test("14. confidence 전파", () => {
+  const g = new CausalGraph();
+  g.addNode({ id: "rain", name: "비", description: "강수" });
+  g.addNode({ id: "wet-road", name: "젖은 도로", description: "도로 표면 습윤" });
+  g.addNode({ id: "accident", name: "사고", description: "교통 사고" });
+  g.addEdge({ from: "rain", to: "wet-road", strength: 0.9, confidence: 0.9 });
+  g.addEdge({ from: "wet-road", to: "accident", strength: 0.7, confidence: 0.8 });
+  const chains = g.findCausalChains("rain", "accident");
+  assert(chains.length > 0, "체인이 존재해야 함");
+  // 체인 confidence = 0.9 * 0.8 = 0.72
+  const expectedConf = 0.9 * 0.8;
+  assert(Math.abs(chains[0].confidence - expectedConf) < 0.01,
+    `confidence가 ${expectedConf}여야 함, got ${chains[0].confidence}`);
+});
+
+// ── Built-in 함수 테스트 ─────────────────────────────────────────────────────
+console.log("\n[ causal-* 빌트인 함수 테스트 ]");
+
+// 빌트인 테스트에는 별도 그래프를 사용 (globalCausal)
+const interp = new Interpreter();
+
+test("15. causal-add-node 빌트인", () => {
+  const result = evalFL(interp, `(causal-add-node :id "rain" :name "비" :desc "강수")`);
+  assert(result instanceof Map, "결과가 Map이어야 함");
+  assert(result.get("id") === "rain", `id가 rain이어야 함, got ${result.get("id")}`);
+  assert(result.get("name") === "비", `name이 비여야 함, got ${result.get("name")}`);
+});
+
+test("16. causal-add-edge 빌트인", () => {
+  evalFL(interp, `(causal-add-node :id "wet-road" :name "젖은 도로" :desc "도로 습윤")`);
+  const result = evalFL(interp, `(causal-add-edge :from "rain" :to "wet-road" :strength 0.9 :confidence 0.95)`);
+  assert(result instanceof Map, "결과가 Map이어야 함");
+  assert(result.get("from") === "rain", `from이 rain이어야 함`);
+  assert(result.get("to") === "wet-road", `to가 wet-road여야 함`);
+  assert(Math.abs(result.get("strength") - 0.9) < 0.01, `strength가 0.9여야 함`);
+});
+
+test("17. causal-explain 빌트인", () => {
+  evalFL(interp, `(causal-add-node :id "accident" :name "사고" :desc "교통 사고")`);
+  evalFL(interp, `(causal-add-edge :from "wet-road" :to "accident" :strength 0.7 :confidence 0.8)`);
+  const result = evalFL(interp, `(causal-explain "accident")`);
+  assert(result instanceof Map, "결과가 Map이어야 함");
+  assert(result.get("effect") === "accident", "effect가 accident여야 함");
+  assert(typeof result.get("explanation") === "string", "explanation이 문자열이어야 함");
+});
+
+test("18. causal-chains 빌트인", () => {
+  const result = evalFL(interp, `(causal-chains "rain" "accident")`);
+  assert(Array.isArray(result), "결과가 배열이어야 함");
+  assert(result.length > 0, "인과 체인이 존재해야 함");
+  const chain = result[0];
+  assert(chain instanceof Map, "체인이 Map이어야 함");
+  assert(Array.isArray(chain.get("path")), "path가 배열이어야 함");
+});
+
+test("19. causal-causes 빌트인", () => {
+  const result = evalFL(interp, `(causal-causes "wet-road")`);
+  assert(Array.isArray(result), "결과가 배열이어야 함");
+  assert(result.length > 0, "직접 원인이 있어야 함");
+  assert(result[0].get("from") === "rain", "원인이 rain이어야 함");
+});
+
+test("20. causal-effects 빌트인", () => {
+  const result = evalFL(interp, `(causal-effects "rain")`);
+  assert(Array.isArray(result), "결과가 배열이어야 함");
+  assert(result.length > 0, "직접 결과가 있어야 함");
+});
+
+test("21. causal-roots 빌트인", () => {
+  const result = evalFL(interp, `(causal-roots "accident")`);
+  assert(Array.isArray(result), "결과가 배열이어야 함");
+  // rain은 더 이상 원인이 없으므로 루트 원인
+  assert(result.includes("rain"), `루트 원인에 rain이 포함되어야 함, got ${JSON.stringify(result)}`);
+});
+
+test("22. causal-simulate 빌트인", () => {
+  // globalCausal에 rain2→mud 엣지가 있음 (위에서 추가됨)
+  // evalBuiltin을 직접 호출 (interp 없이)
+  const { evalBuiltin } = require("./eval-builtins");
+  const inputMap = new Map<string, any>([["rain2", 1.0]]);
+  const result = evalBuiltin((interp as any), "causal-simulate", [inputMap], {});
+  assert(result instanceof Map, "결과가 Map이어야 함");
+  assert(result.has("mud") || result.has("rain2"), `파급효과가 있어야 함, keys: ${JSON.stringify(Array.from(result.keys()))}`);
+});
+
+test("23. causal-why 빌트인", () => {
+  const result = evalFL(interp, `(causal-why "accident" "rain")`);
+  assert(result instanceof Map, "결과가 Map이어야 함");
+  assert(Array.isArray(result.get("path")), "path가 배열이어야 함");
+  assert(result.get("path").includes("rain"), "path에 rain이 포함되어야 함");
+  assert(result.get("path").includes("accident"), "path에 accident가 포함되어야 함");
+});
+
+test("24. causal-summary 빌트인", () => {
+  const result = evalFL(interp, `(causal-summary "rain")`);
+  assert(typeof result === "string", "결과가 문자열이어야 함");
+  assert(result.length > 0, "요약이 비어있지 않아야 함");
+  assert(result.includes("비"), "요약에 노드 이름이 포함되어야 함");
+});
+
+// ── 25. 순환 인과 감지 ───────────────────────────────────────────────────────
+console.log("\n[ 고급 기능 ]");
+
+test("25. 순환 인과 감지 (A→B→A)", () => {
+  const g = new CausalGraph();
+  g.addNode({ id: "A", name: "A", description: "노드 A" });
+  g.addNode({ id: "B", name: "B", description: "노드 B" });
+  g.addEdge({ from: "A", to: "B", strength: 0.8, confidence: 0.9 });
+  g.addEdge({ from: "B", to: "A", strength: 0.8, confidence: 0.9 }); // 순환
+  // findCausalChains가 무한 루프 없이 종료되어야 함
+  const chains = g.findCausalChains("A", "A");
+  // 순환이 있어도 방문 추적으로 안전하게 처리
+  assert(typeof chains.length === "number", "체인 탐색이 안전하게 종료되어야 함");
+});
+
+// ── 추가 테스트 ────────────────────────────────────────────────────────────────
+test("26. 다중 경로 인과 체인", () => {
+  const g = new CausalGraph();
+  g.addNode({ id: "rain", name: "비", description: "강수" });
+  g.addNode({ id: "fog", name: "안개", description: "시야 제한" });
+  g.addNode({ id: "wet-road", name: "젖은 도로", description: "도로 습윤" });
+  g.addNode({ id: "accident", name: "사고", description: "교통 사고" });
+  g.addEdge({ from: "rain", to: "wet-road", strength: 0.9, confidence: 0.95 });
+  g.addEdge({ from: "fog", to: "accident", strength: 0.6, confidence: 0.7 });
+  g.addEdge({ from: "wet-road", to: "accident", strength: 0.7, confidence: 0.8 });
+  const expl = g.explain("accident");
+  assert(expl.causes.length >= 2, `원인이 2개 이상이어야 함, got ${expl.causes.length}`);
+});
+
+test("27. totalStrength 계산 (체인 곱)", () => {
+  const g = new CausalGraph();
+  g.addNode({ id: "A", name: "A", description: "" });
+  g.addNode({ id: "B", name: "B", description: "" });
+  g.addNode({ id: "C", name: "C", description: "" });
+  g.addEdge({ from: "A", to: "B", strength: 0.8, confidence: 1.0 });
+  g.addEdge({ from: "B", to: "C", strength: 0.5, confidence: 1.0 });
+  const chains = g.findCausalChains("A", "C");
+  assert(chains.length > 0, "체인이 있어야 함");
+  const expected = 0.8 * 0.5;
+  assert(Math.abs(chains[0].totalStrength - expected) < 0.01,
+    `totalStrength가 ${expected}여야 함, got ${chains[0].totalStrength}`);
+});
+
+test("28. whyCaused 전역 함수", () => {
+  // globalCausal에 이미 rain→wet-road→accident 추가됨
+  const chain = whyCaused("accident", "rain");
+  assert(chain !== null, "체인이 null이 아니어야 함");
+  if (chain) {
+    assert(chain.path.includes("rain"), "path에 rain이 포함되어야 함");
+  }
+});
+
+test("29. findRootCauses 복잡한 체인", () => {
+  const g = new CausalGraph();
+  g.addNode({ id: "L1", name: "Level1", description: "" });
+  g.addNode({ id: "L2", name: "Level2", description: "" });
+  g.addNode({ id: "L3", name: "Level3", description: "" });
+  g.addNode({ id: "L4", name: "Level4", description: "" });
+  g.addEdge({ from: "L1", to: "L2", strength: 0.9, confidence: 0.9 });
+  g.addEdge({ from: "L2", to: "L3", strength: 0.8, confidence: 0.8 });
+  g.addEdge({ from: "L3", to: "L4", strength: 0.7, confidence: 0.7 });
+  const roots = g.findRootCauses("L4");
+  assert(roots.includes("L1"), "L1이 루트 원인이어야 함");
+  assert(!roots.includes("L2"), "L2는 루트 원인이 아니어야 함");
+});
+
+test("30. summarize 출력 형식", () => {
+  const g = new CausalGraph();
+  g.addNode({ id: "rain", name: "비", description: "강수" });
+  g.addNode({ id: "wet-road", name: "젖은 도로", description: "도로 습윤" });
+  g.addEdge({ from: "rain", to: "wet-road", strength: 0.9, confidence: 0.95 });
+  const summary = g.summarize("rain");
+  assert(typeof summary === "string", "요약이 문자열이어야 함");
+  assert(summary.includes("비"), "요약에 노드 이름이 포함되어야 함");
+  assert(summary.includes("직접결과"), "요약에 직접결과 항목이 포함되어야 함");
+});
+
+// ── 결과 요약 ─────────────────────────────────────────────────────────────────
+console.log(`\n=== 결과: ${passed} PASS / ${failed} FAIL ===\n`);
+
+if (failed > 0) {
+  process.exit(1);
+} else {
+  process.exit(0);
+}

package/src/test-phase143-counterfactual.ts

@@ -0,0 +1,280 @@
+// test-phase143-counterfactual.ts — FreeLang v9 Phase 143 테스트
+// 반사실 추론: "만약 비가 안 왔다면 사고가 났을까?"
+
+import { CounterfactualReasoner, Scenario, globalCounterfactual } from "./counterfactual";
+import { Interpreter } from "./interpreter";
+import { lex } from "./lexer";
+import { parse } from "./parser";
+
+let pass = 0;
+let fail = 0;
+
+function test(name: string, fn: () => boolean | void): void {
+  try {
+    const result = fn();
+    if (result !== false) {
+      console.log(`  ✅ PASS: ${name}`);
+      pass++;
+    } else {
+      console.log(`  ❌ FAIL: ${name}`);
+      fail++;
+    }
+  } catch (e: any) {
+    console.log(`  ❌ FAIL: ${name} — ${e.message}`);
+    fail++;
+  }
+}
+
+function assert(cond: boolean, msg?: string): void {
+  if (!cond) throw new Error(msg ?? "Assertion failed");
+}
+
+// 공통 outcome 함수: 비 + 속도 → 사고
+// rain=true && speed>50 → "accident", else "safe"
+function accidentOutcome(vars: Record<string, unknown>): string {
+  const rain = vars["rain"] as boolean;
+  const speed = vars["speed"] as number;
+  if (rain && speed > 50) return "accident";
+  return "safe";
+}
+
+// 수치 outcome: 사고 확률 0~1
+function riskScore(vars: Record<string, unknown>): number {
+  const rain = (vars["rain"] as boolean) ? 1 : 0;
+  const speed = (vars["speed"] as number) || 0;
+  return rain * 0.5 + (speed / 200);
+}
+
+console.log("\n=== Phase 143: COUNTERFACTUAL 반사실 추론 ===\n");
+
+// 1. CounterfactualReasoner 생성
+const reasoner = new CounterfactualReasoner();
+test("1. CounterfactualReasoner 생성", () => reasoner instanceof CounterfactualReasoner);
+
+// 2. registerScenario 시나리오 등록
+const scenario: Scenario = {
+  id: "s1",
+  name: "비오는날 사고",
+  variables: { rain: true, speed: 60, road: "wet" },
+  outcome: "accident",
+};
+reasoner.registerScenario(scenario);
+test("2. registerScenario 시나리오 등록", () => {
+  const cf = reasoner.createCounterfactual("s1", { rain: false }, accidentOutcome);
+  return cf !== null;
+});
+
+// 3. whatIf 단순 반사실
+const wf = reasoner.whatIf(
+  { rain: true, speed: 60 },
+  { rain: false },
+  accidentOutcome
+);
+test("3. whatIf 반환값 존재", () => wf !== null && wf !== undefined);
+
+// 4. Counterfactual 구조 검증
+test("4. Counterfactual 구조: id, baseScenario, intervention, counterfactualOutcome", () => {
+  return (
+    typeof wf.id === "string" &&
+    wf.baseScenario !== undefined &&
+    wf.intervention !== undefined &&
+    wf.counterfactualOutcome !== undefined
+  );
+});
+
+// 5. intervention 적용 확인
+test("5. intervention rain=false 적용", () => {
+  return wf.intervention["rain"] === false;
+});
+
+// 6. counterfactualOutcome 계산 (rain=false, speed=60 → safe)
+test("6. counterfactualOutcome = safe", () => {
+  return wf.counterfactualOutcome === "safe";
+});
+
+// 7. probability 범위 0~1
+test("7. probability 범위 0~1", () => {
+  return wf.probability >= 0 && wf.probability <= 1;
+});
+
+// 8. explanation 생성
+test("8. explanation 문자열 생성", () => {
+  return typeof wf.explanation === "string" && wf.explanation.length > 0;
+});
+
+// 9. analyze 다중 분석
+const analysis = reasoner.analyze(
+  "s1",
+  [
+    { rain: false },
+    { speed: 30 },
+    { rain: false, speed: 30 },
+  ],
+  accidentOutcome
+);
+test("9. analyze 다중 반사실 분석", () => analysis !== null && analysis !== undefined);
+
+// 10. CounterfactualAnalysis 구조
+test("10. CounterfactualAnalysis: original, counterfactuals, mostLikelyAlternative", () => {
+  return (
+    analysis.original !== undefined &&
+    Array.isArray(analysis.counterfactuals) &&
+    analysis.mostLikelyAlternative !== undefined
+  );
+});
+
+// 11. counterfactuals 개수 = 3
+test("11. counterfactuals 개수 = 3", () => analysis.counterfactuals.length === 3);
+
+// 12. mostLikelyAlternative 선택됨
+test("12. mostLikelyAlternative 선택", () => {
+  const best = analysis.mostLikelyAlternative;
+  return typeof best.probability === "number" && best.probability >= 0;
+});
+
+// 13. keyFactors 식별
+test("13. keyFactors 배열", () => Array.isArray(analysis.keyFactors));
+
+// 14. sensitivityAnalysis 민감도
+const sens = reasoner.sensitivityAnalysis(
+  { rain: true, speed: 60 },
+  riskScore
+);
+test("14. sensitivityAnalysis 반환값", () => sens !== null && typeof sens === "object");
+
+// 15. sensitivity에 rain, speed 포함
+test("15. sensitivity에 rain, speed 키 포함", () => {
+  return "rain" in sens && "speed" in sens;
+});
+
+// 16. findMinimalIntervention 최소 변경
+const minimal = reasoner.findMinimalIntervention("s1", "safe", accidentOutcome);
+test("16. findMinimalIntervention 결과 반환", () => minimal !== null);
+
+// 17. delta 계산 정확성
+const cf1 = reasoner.createCounterfactual("s1", { speed: 30 }, accidentOutcome);
+test("17. delta 계산: speed 변화 포함", () => {
+  return cf1.delta !== null && "speed" in cf1.delta;
+});
+
+// 18. baseScenario.outcome과 counterfactualOutcome 비교
+test("18. counterfactualOutcome ≠ baseScenario.outcome (speed=30 → safe)", () => {
+  return cf1.counterfactualOutcome === "safe" && cf1.baseScenario.outcome === "accident";
+});
+
+// === 빌트인 테스트 ===
+console.log("\n--- 빌트인 함수 테스트 ---\n");
+
+const interp = new Interpreter();
+
+function run(code: string): unknown {
+  interp.interpret(parse(lex(code)));
+  return (interp as any).context.lastValue;
+}
+
+// 19. cf-scenario 빌트인
+test("19. cf-scenario 빌트인", () => {
+  const result = run(`(cf-scenario :id "s2" :name "테스트시나리오" :vars {:x 10 :y 20} :outcome "result-A")`);
+  return result instanceof Map && (result as Map<string,any>).get("id") === "s2";
+});
+
+// 20. cf-what-if 빌트인 (인라인 fn)
+test("20. cf-what-if 빌트인", () => {
+  const result = run(`
+    (cf-what-if {:x 10 :y 5} {:x 3}
+      (fn [$vars] (if (>= (imm-get $vars :x) 10) "high" "low")))
+  `);
+  return result instanceof Map && (result as Map<string,any>).has("counterfactualOutcome");
+});
+
+// 21. cf-analyze 빌트인
+test("21. cf-analyze 빌트인", () => {
+  run(`(cf-scenario :id "s3" :name "분석테스트" :vars {:a 1 :b 2} :outcome "X")`);
+  const result = run(`
+    (cf-analyze "s3" [{:a 0} {:b 10}]
+      (fn [$vars] (if (> (imm-get $vars :a) 0) "X" "Y")))
+  `);
+  return result instanceof Map && (result as Map<string,any>).has("counterfactuals");
+});
+
+// 22. cf-minimal 빌트인
+test("22. cf-minimal 빌트인", () => {
+  run(`(cf-scenario :id "s4" :name "최소개입" :vars {:rain true :speed 60} :outcome "accident")`);
+  const result = run(`
+    (cf-minimal "s4" "safe"
+      (fn [$vars] (if (and (imm-get $vars :rain) (> (imm-get $vars :speed) 50)) "accident" "safe")))
+  `);
+  return result instanceof Map || result === null;
+});
+
+// 23. cf-sensitivity 빌트인
+test("23. cf-sensitivity 빌트인", () => {
+  const result = run(`
+    (cf-sensitivity {:rain true :speed 60}
+      (fn [$vars] (+ (* (if (imm-get $vars :rain) 1 0) 50) (imm-get $vars :speed))))
+  `);
+  return result instanceof Map && (result as Map<string,any>).has("speed");
+});
+
+// 24. cf-key-factors 빌트인
+test("24. cf-key-factors 빌트인", () => {
+  run(`(cf-scenario :id "s5" :name "키팩터" :vars {:p 1 :q 2} :outcome "A")`);
+  const result = run(`
+    (cf-key-factors
+      (cf-analyze "s5" [{:p 0} {:q 10}]
+        (fn [$vars] (if (> (imm-get $vars :p) 0) "A" "B"))))
+  `);
+  return Array.isArray(result);
+});
+
+// 25. cf-best-alt 빌트인
+test("25. cf-best-alt 빌트인", () => {
+  run(`(cf-scenario :id "s6" :name "최선대안" :vars {:m 5 :n 3} :outcome "OK")`);
+  const result = run(`
+    (cf-best-alt
+      (cf-analyze "s6" [{:m 0} {:n 10}]
+        (fn [$vars] (if (> (imm-get $vars :m) 3) "OK" "NG"))))
+  `);
+  return result instanceof Map && (result as Map<string,any>).has("probability");
+});
+
+// 26. cf-explain 빌트인
+test("26. cf-explain 빌트인", () => {
+  const result = run(`
+    (cf-explain
+      (cf-what-if {:rain true :speed 60} {:rain false}
+        (fn [$vars] (if (imm-get $vars :rain) "accident" "safe"))))
+  `);
+  return typeof result === "string" && (result as string).length > 0;
+});
+
+// 27. 빈 개입 → 동일 결과
+test("27. 빈 개입 whatIf → 동일 결과", () => {
+  const wfEmpty = reasoner.whatIf(
+    { rain: true, speed: 60 },
+    {},
+    accidentOutcome
+  );
+  return wfEmpty.counterfactualOutcome === "accident";
+});
+
+// 28. 여러 변수 동시 변경
+test("28. 여러 변수 동시 변경", () => {
+  const wfMulti = reasoner.whatIf(
+    { rain: true, speed: 60, road: "wet" },
+    { rain: false, speed: 30 },
+    accidentOutcome
+  );
+  return wfMulti.counterfactualOutcome === "safe" &&
+    Object.keys(wfMulti.intervention).length === 2;
+});
+
+// 결과 출력
+console.log(`\n=== 결과: ${pass}/${pass + fail} PASS ===`);
+if (fail > 0) {
+  console.log(`❌ FAIL: ${fail}개`);
+  process.exit(1);
+} else {
+  console.log("✅ 모두 통과!");
+  process.exit(0);
+}