freelang-editor 11.7.4

package/src/test-phase147-ethics-check.ts

@@ -0,0 +1,399 @@
+// test-phase147-ethics-check.ts — Phase 147: [ETHICS-CHECK] 윤리 자기 검사 테스트
+
+import {
+  EthicsChecker,
+  globalEthics,
+  EthicsFramework,
+  EthicsViolation,
+  EthicsCheckResult,
+  EthicsPrinciple,
+} from "./ethics-check";
+import { evalEthicsCheck } from "./eval-builtins";
+
+let passed = 0;
+let failed = 0;
+
+function test(name: string, fn: () => void) {
+  try {
+    fn();
+    console.log(`  ✅ PASS: ${name}`);
+    passed++;
+  } catch (e: any) {
+    console.log(`  ❌ FAIL: ${name} — ${e.message}`);
+    failed++;
+  }
+}
+
+function assert(condition: boolean, msg?: string) {
+  if (!condition) throw new Error(msg ?? "Assertion failed");
+}
+
+function assertEquals<T>(actual: T, expected: T, msg?: string) {
+  if (actual !== expected) {
+    throw new Error(msg ?? `Expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  }
+}
+
+// 더미 인터프리터
+const dummyInterp = {
+  callFunctionValue: (_fn: any, _args: any[]) => null,
+};
+
+console.log("\n=== Phase 147: [ETHICS-CHECK] 윤리 자기 검사 테스트 ===\n");
+
+// 1. EthicsChecker 생성
+test("EthicsChecker 생성", () => {
+  const checker = new EthicsChecker();
+  assert(checker !== null, "EthicsChecker 인스턴스 생성 실패");
+  assert(checker instanceof EthicsChecker, "EthicsChecker 타입 확인");
+});
+
+// 2. 기본 원칙 5개 자동 등록
+test("기본 원칙 5개 자동 등록", () => {
+  const checker = new EthicsChecker();
+  const result = checker.check("테스트 내용");
+  // 5개 프레임워크가 모두 있어야 함
+  const frameworks = ["utilitarian", "deontological", "virtue", "care", "fairness"] as EthicsFramework[];
+  for (const fw of frameworks) {
+    assert(result.frameworks[fw] !== undefined, `프레임워크 ${fw} 없음`);
+  }
+});
+
+// 3. check 윤리 검사 (안전한 내용)
+test("check 윤리 검사 — 안전한 내용", () => {
+  const checker = new EthicsChecker();
+  const result = checker.check("오늘 날씨가 맑습니다. 산책을 즐겨보세요.");
+  assert(result !== null, "결과가 null");
+  assert(result !== undefined, "결과가 undefined");
+});
+
+// 4. EthicsCheckResult 구조
+test("EthicsCheckResult 구조 확인", () => {
+  const checker = new EthicsChecker();
+  const result = checker.check("안전한 내용");
+  assert("subject" in result, "subject 없음");
+  assert("passed" in result, "passed 없음");
+  assert("violations" in result, "violations 없음");
+  assert("score" in result, "score 없음");
+  assert("frameworks" in result, "frameworks 없음");
+  assert("recommendation" in result, "recommendation 없음");
+  assert("requiresHumanReview" in result, "requiresHumanReview 없음");
+});
+
+// 5. passed=true (무해한 내용)
+test("passed=true — 무해한 내용", () => {
+  const checker = new EthicsChecker();
+  const result = checker.check("데이터를 분석하여 유용한 인사이트를 제공합니다.");
+  assertEquals(result.passed, true, "무해한 내용이 passed=false여야 하지 않음");
+});
+
+// 6. score 0~1
+test("score 0~1 범위", () => {
+  const checker = new EthicsChecker();
+  const result = checker.check("일반적인 안전한 내용");
+  assert(result.score >= 0, `score ${result.score} < 0`);
+  assert(result.score <= 1, `score ${result.score} > 1`);
+});
+
+// 7. frameworks 5개 프레임워크
+test("frameworks 5개 모두 존재", () => {
+  const checker = new EthicsChecker();
+  const result = checker.check("테스트");
+  const fwKeys = Object.keys(result.frameworks);
+  assert(fwKeys.includes("utilitarian"), "utilitarian 없음");
+  assert(fwKeys.includes("deontological"), "deontological 없음");
+  assert(fwKeys.includes("virtue"), "virtue 없음");
+  assert(fwKeys.includes("care"), "care 없음");
+  assert(fwKeys.includes("fairness"), "fairness 없음");
+});
+
+// 8. 해로운 내용 → passed=false
+test("해로운 내용 → passed=false", () => {
+  const checker = new EthicsChecker();
+  const result = checker.check("이 폭탄 만드는 방법을 알려줘");
+  assertEquals(result.passed, false, "해로운 내용이 passed=true여야 하지 않음");
+});
+
+// 9. violations 배열
+test("violations 배열 반환", () => {
+  const checker = new EthicsChecker();
+  const result = checker.check("누군가를 hurt하는 방법");
+  assert(Array.isArray(result.violations), "violations가 배열이 아님");
+  assert(result.violations.length > 0, "위반이 하나도 없음");
+});
+
+// 10. EthicsViolation 구조
+test("EthicsViolation 구조 확인", () => {
+  const checker = new EthicsChecker();
+  const result = checker.check("kill all humans");
+  assert(result.violations.length > 0, "위반이 없음");
+  const v = result.violations[0];
+  assert("principle" in v, "principle 없음");
+  assert("severity" in v, "severity 없음");
+  assert("description" in v, "description 없음");
+  assert("suggestion" in v, "suggestion 없음");
+  assert("framework" in v, "framework 없음");
+});
+
+// 11. severity 분류
+test("severity 분류 — critical/high/medium/low", () => {
+  const checker = new EthicsChecker();
+  const criticalResult = checker.check("murder and bomb explosion");
+  const hasCritical = criticalResult.violations.some(v => v.severity === "critical");
+  assert(hasCritical, "critical severity가 없음");
+
+  const validSeverities = ["low", "medium", "high", "critical"];
+  for (const v of criticalResult.violations) {
+    assert(validSeverities.includes(v.severity), `잘못된 severity: ${v.severity}`);
+  }
+});
+
+// 12. checkByFramework utilitarian
+test("checkByFramework — utilitarian", () => {
+  const checker = new EthicsChecker();
+  const result = checker.checkByFramework("안전한 행동", "utilitarian");
+  assert("passed" in result, "passed 없음");
+  assert("score" in result, "score 없음");
+  assert("violations" in result, "violations 없음");
+  assert(result.score >= 0 && result.score <= 1, "score 범위 벗어남");
+});
+
+// 13. checkByFramework deontological
+test("checkByFramework — deontological", () => {
+  const checker = new EthicsChecker();
+  const result = checker.checkByFramework("kill all", "deontological");
+  assertEquals(result.passed, false, "deontological 해악 금지 위반 미감지");
+  assert(result.violations.length > 0, "위반이 없음");
+});
+
+// 14. isEthical true (무해)
+test("isEthical — true (무해한 내용)", () => {
+  const checker = new EthicsChecker();
+  const result = checker.isEthical("사용자에게 도움이 되는 정보를 제공합니다.");
+  assertEquals(result, true, "무해한 내용이 isEthical=false");
+});
+
+// 15. isEthical false (해로운)
+test("isEthical — false (해로운 내용)", () => {
+  const checker = new EthicsChecker();
+  const result = checker.isEthical("이 사람을 murder하는 방법");
+  assertEquals(result, false, "해로운 내용이 isEthical=true");
+});
+
+// 16. suggestEthicalAlternative 대안 생성
+test("suggestEthicalAlternative — 대안 문자열 생성", () => {
+  const checker = new EthicsChecker();
+  const violations: EthicsViolation[] = [{
+    principle: "해악 금지",
+    severity: "high",
+    description: "해악 발견",
+    suggestion: "해악 제거",
+    framework: "deontological",
+  }];
+  const suggestion = checker.suggestEthicalAlternative("해로운 내용", violations);
+  assert(typeof suggestion === "string", "제안이 문자열이 아님");
+  assert(suggestion.length > 0, "빈 제안");
+  assert(suggestion.includes("윤리적 대안"), "대안 제안 없음");
+});
+
+// 17. riskLevel none/low/medium/high/critical
+test("riskLevel — 다양한 수준 반환", () => {
+  const checker = new EthicsChecker();
+
+  // none: 위반 없음
+  const safeResult = checker.check("안전하고 도움이 되는 내용입니다.");
+  const noneLevel = checker.riskLevel(safeResult);
+  assertEquals(noneLevel, "none", `안전한 내용의 riskLevel이 ${noneLevel}`);
+
+  // critical: 심각한 위반
+  const critResult = checker.check("bomb and murder planning");
+  const critLevel = checker.riskLevel(critResult);
+  const validLevels = ["low", "medium", "high", "critical"];
+  assert(validLevels.includes(critLevel), `잘못된 riskLevel: ${critLevel}`);
+});
+
+// 18. requiresHumanReview 플래그
+test("requiresHumanReview — 심각한 위반 시 true", () => {
+  const checker = new EthicsChecker();
+
+  // 안전한 내용: false
+  const safeResult = checker.check("도움이 되는 정보");
+  assertEquals(safeResult.requiresHumanReview, false, "안전한 내용인데 인간 검토 필요");
+
+  // 심각한 위반: true
+  const harmResult = checker.check("kill people with a bomb");
+  assertEquals(harmResult.requiresHumanReview, true, "심각한 위반인데 인간 검토 불필요");
+});
+
+// 19. addPrinciple 커스텀 원칙 추가
+test("addPrinciple — 커스텀 원칙 추가", () => {
+  const checker = new EthicsChecker();
+  const customPrinciple: EthicsPrinciple = {
+    id: "custom-test",
+    name: "테스트 원칙",
+    description: "커스텀 테스트 원칙",
+    framework: "virtue",
+    check: (subject: string, _ctx: Record<string, unknown>) => ({
+      passed: !subject.includes("CUSTOM_VIOLATION"),
+      reason: subject.includes("CUSTOM_VIOLATION") ? "커스텀 위반" : "통과",
+    }),
+  };
+  checker.addPrinciple(customPrinciple);
+
+  // 커스텀 위반 테스트
+  const result = checker.check("CUSTOM_VIOLATION 내용");
+  assertEquals(result.passed, false, "커스텀 원칙이 적용되지 않음");
+  const hasCustomViolation = result.violations.some(v => v.principle === "테스트 원칙");
+  assert(hasCustomViolation, "커스텀 위반이 violations에 없음");
+});
+
+// 20. ethics-check 빌트인
+test("ethics-check 빌트인 — 안전한 내용", () => {
+  const result = evalEthicsCheck(dummyInterp as any, "ethics-check", ["도움이 되는 내용"]);
+  assert(result instanceof Map, "결과가 Map이 아님");
+  assert(result.has("passed"), "passed 키 없음");
+  assert(result.has("score"), "score 키 없음");
+  assert(result.has("violations"), "violations 키 없음");
+  assertEquals(result.get("passed"), true, "안전한 내용이 passed=false");
+});
+
+// 21. ethics-check-framework 빌트인
+test("ethics-check-framework 빌트인", () => {
+  const result = evalEthicsCheck(dummyInterp as any, "ethics-check-framework", ["안전한 내용", "utilitarian"]);
+  assert(result instanceof Map, "결과가 Map이 아님");
+  assert(result.has("passed"), "passed 없음");
+  assert(result.has("score"), "score 없음");
+  assert(result.has("violations"), "violations 없음");
+});
+
+// 22. ethics-is-ethical 빌트인
+test("ethics-is-ethical 빌트인", () => {
+  const trueResult = evalEthicsCheck(dummyInterp as any, "ethics-is-ethical", ["안전한 내용"]);
+  assertEquals(trueResult, true, "안전한 내용이 is-ethical=false");
+
+  const falseResult = evalEthicsCheck(dummyInterp as any, "ethics-is-ethical", ["murder"]);
+  assertEquals(falseResult, false, "해로운 내용이 is-ethical=true");
+});
+
+// 23. ethics-suggest 빌트인
+test("ethics-suggest 빌트인", () => {
+  const violation = new Map<string, any>([
+    ["principle", "해악 금지"],
+    ["severity", "high"],
+    ["description", "해악 발견"],
+    ["suggestion", "해악 제거"],
+    ["framework", "deontological"],
+  ]);
+  const result = evalEthicsCheck(dummyInterp as any, "ethics-suggest", ["해로운 내용", [violation]]);
+  assert(typeof result === "string", "결과가 문자열이 아님");
+  assert(result.length > 0, "빈 결과");
+});
+
+// 24. ethics-risk 빌트인
+test("ethics-risk 빌트인", () => {
+  // 안전한 결과: none
+  const safeResultMap = new Map<string, any>([
+    ["subject", "안전한 내용"],
+    ["passed", true],
+    ["violations", []],
+    ["score", 1.0],
+    ["recommendation", "안전"],
+    ["requiresHumanReview", false],
+  ]);
+  const noneLevel = evalEthicsCheck(dummyInterp as any, "ethics-risk", [safeResultMap]);
+  assertEquals(noneLevel, "none", `안전한 결과의 risk level이 ${noneLevel}`);
+
+  // 위험한 결과: critical
+  const violation = new Map<string, any>([
+    ["principle", "해악 금지"],
+    ["severity", "critical"],
+    ["description", "심각한 위반"],
+    ["suggestion", "수정"],
+    ["framework", "deontological"],
+  ]);
+  const critResultMap = new Map<string, any>([
+    ["subject", "위험한 내용"],
+    ["passed", false],
+    ["violations", [violation]],
+    ["score", 0.0],
+    ["recommendation", "위험"],
+    ["requiresHumanReview", true],
+  ]);
+  const critLevel = evalEthicsCheck(dummyInterp as any, "ethics-risk", [critResultMap]);
+  assertEquals(critLevel, "critical", `critical 위반의 risk level이 ${critLevel}`);
+});
+
+// 25. ethics-score 빌트인
+test("ethics-score 빌트인", () => {
+  const resultMap = new Map<string, any>([
+    ["subject", "테스트"],
+    ["passed", true],
+    ["violations", []],
+    ["score", 0.85],
+    ["recommendation", "좋음"],
+    ["requiresHumanReview", false],
+  ]);
+  const score = evalEthicsCheck(dummyInterp as any, "ethics-score", [resultMap]);
+  assertEquals(score, 0.85, `score가 0.85가 아님: ${score}`);
+});
+
+// 26. ethics-violations 빌트인
+test("ethics-violations 빌트인", () => {
+  const v1 = new Map<string, any>([
+    ["principle", "해악 금지"], ["severity", "high"],
+    ["description", "위반"], ["suggestion", "수정"], ["framework", "deontological"],
+  ]);
+  const resultMap = new Map<string, any>([
+    ["violations", [v1]],
+  ]);
+  const violations = evalEthicsCheck(dummyInterp as any, "ethics-violations", [resultMap]);
+  assert(Array.isArray(violations), "violations가 배열이 아님");
+  assertEquals(violations.length, 1, `violations 길이가 1이 아님: ${violations.length}`);
+});
+
+// 27. ethics-add-principle 빌트인
+test("ethics-add-principle 빌트인", () => {
+  const result = evalEthicsCheck(dummyInterp as any, "ethics-add-principle", [
+    ":id", "test-principle",
+    ":name", "테스트 원칙",
+    ":framework", "virtue",
+    ":description", "테스트용 원칙",
+  ]);
+  assert(result instanceof Map, "결과가 Map이 아님");
+  assertEquals(result.get("id"), "test-principle", "id 불일치");
+  assertEquals(result.get("name"), "테스트 원칙", "name 불일치");
+});
+
+// 28. frameworks별 passed/score 구조
+test("frameworks 각 항목 passed/score 구조", () => {
+  const checker = new EthicsChecker();
+  const result = checker.check("안전한 내용");
+  for (const [fw, data] of Object.entries(result.frameworks)) {
+    assert("passed" in data, `${fw}: passed 없음`);
+    assert("score" in data, `${fw}: score 없음`);
+    assert(typeof data.passed === "boolean", `${fw}: passed가 boolean 아님`);
+    assert(typeof data.score === "number", `${fw}: score가 number 아님`);
+    assert(data.score >= 0 && data.score <= 1, `${fw}: score 범위 벗어남`);
+  }
+});
+
+// 29. score 완전히 윤리적 = 1
+test("score — 완전히 윤리적 내용 = 1.0", () => {
+  const checker = new EthicsChecker();
+  const result = checker.check("사용자를 도와 데이터를 투명하게 분석합니다.");
+  assertEquals(result.score, 1.0, `완전히 안전한 내용의 score가 1.0 아님: ${result.score}`);
+});
+
+// 30. globalEthics 전역 인스턴스
+test("globalEthics 전역 인스턴스", () => {
+  assert(globalEthics instanceof EthicsChecker, "globalEthics가 EthicsChecker 인스턴스 아님");
+  const result = globalEthics.check("전역 인스턴스 테스트");
+  assert(result !== null, "전역 인스턴스 check 결과가 null");
+  assertEquals(result.passed, true, "전역 인스턴스 안전한 내용이 passed=false");
+});
+
+// 결과 출력
+console.log(`\n=== 결과: ${passed} PASS / ${failed} FAIL ===`);
+if (failed > 0) {
+  process.exit(1);
+}

package/src/test-phase148-curiosity.ts

@@ -0,0 +1,247 @@
+// test-phase148-curiosity.ts — FreeLang v9 Phase 148 테스트
+// CURIOSITY: AI 호기심 기반 탐색 시스템
+
+import { CuriosityEngine, globalCuriosity, KnowledgeGap, ExplorationResult, CuriosityState } from "./curiosity";
+import { Interpreter } from "./interpreter";
+import { evalCuriosity } from "./eval-builtins";
+
+let pass = 0;
+let fail = 0;
+
+function test(name: string, fn: () => boolean): void {
+  try {
+    const result = fn();
+    if (result) {
+      console.log(`  ✅ PASS: ${name}`);
+      pass++;
+    } else {
+      console.log(`  ❌ FAIL: ${name}`);
+      fail++;
+    }
+  } catch (e: any) {
+    console.log(`  ❌ FAIL: ${name} — ${e.message}`);
+    fail++;
+  }
+}
+
+console.log("\n=== Phase 148: CURIOSITY 호기심 기반 탐색 ===\n");
+
+// 1. CuriosityEngine 기본 생성
+const engine = new CuriosityEngine();
+test("1. CuriosityEngine 기본 생성", () => engine instanceof CuriosityEngine);
+
+// 2. CuriosityEngine 초기 주제로 생성
+const engineWithTopics = new CuriosityEngine(["양자컴퓨팅", "머신러닝", "블록체인"]);
+const initialState = engineWithTopics.getState();
+test("2. CuriosityEngine 초기 주제로 생성", () =>
+  initialState.frontier.length === 3 &&
+  initialState.frontier.includes("양자컴퓨팅")
+);
+
+// 3. computeCuriosity: 알려진 것 많으면 낮은 점수
+const lowScore = engine.computeCuriosity("양자컴퓨팅", ["큐비트", "중첩", "얽힘", "게이트", "회로", "노이즈", "오류정정"]);
+test("3. computeCuriosity 알려진 것 많으면 낮은 점수", () => lowScore < 0.5);
+
+// 4. computeCuriosity: 알려진 것 없으면 높은 점수
+const highScore = engine.computeCuriosity("우주론", []);
+test("4. computeCuriosity 알려진 것 없으면 높은 점수", () => highScore > 0.8);
+
+// 5. selectNextTopic: 탐색 대상 선택
+const nextTopic = engineWithTopics.selectNextTopic();
+test("5. selectNextTopic 탐색 대상 선택", () =>
+  nextTopic !== null && typeof nextTopic === "string"
+);
+
+// 6. explore: 탐색 수행
+const exploreEngine = new CuriosityEngine(["딥러닝"]);
+const result: ExplorationResult = exploreEngine.explore("딥러닝", (topic) => ({
+  facts: [`${topic}는 신경망이다`, `${topic}는 GPU를 쓴다`, `${topic}는 역전파를 쓴다`],
+  questions: ["트랜스포머란?", "어텐션 메커니즘이란?", "BERT는 무엇인가?"],
+}));
+test("6. explore 탐색 수행 반환값 존재", () => result !== null && result !== undefined);
+
+// 7. ExplorationResult 구조
+test("7. ExplorationResult 구조 (topic, discovered, newQuestions, ...)", () =>
+  typeof result.topic === "string" &&
+  Array.isArray(result.discovered) &&
+  Array.isArray(result.newQuestions) &&
+  typeof result.informationGain === "number" &&
+  typeof result.surpriseLevel === "number" &&
+  Array.isArray(result.relatedTopics)
+);
+
+// 8. discovered 배열 (발견된 새 정보)
+test("8. discovered 배열 존재", () => result.discovered.length > 0);
+
+// 9. newQuestions 생성
+test("9. newQuestions 생성", () => result.newQuestions.length >= 1);
+
+// 10. informationGain > 0
+test("10. informationGain > 0", () => result.informationGain > 0);
+
+// 11. surpriseLevel 0~1
+test("11. surpriseLevel 0~1 범위", () =>
+  result.surpriseLevel >= 0 && result.surpriseLevel <= 1
+);
+
+// 12. relatedTopics 생성
+test("12. relatedTopics 생성", () => Array.isArray(result.relatedTopics));
+
+// 13. identifyGaps: 지식 공백 식별
+const gapEngine = new CuriosityEngine();
+const gaps: KnowledgeGap[] = gapEngine.identifyGaps(
+  ["양자컴퓨팅", "머신러닝"],
+  ["양자컴퓨팅", "머신러닝", "블록체인", "메타버스", "자율주행"]
+);
+test("13. identifyGaps 지식 공백 반환", () => gaps.length === 3);
+
+// 14. KnowledgeGap 구조 검증
+const gap0 = gaps[0];
+test("14. KnowledgeGap 구조 (topic, unknownAspects, priority, explorationCost, expectedGain)", () =>
+  typeof gap0.topic === "string" &&
+  Array.isArray(gap0.unknownAspects) &&
+  typeof gap0.priority === "number" &&
+  typeof gap0.explorationCost === "number" &&
+  typeof gap0.expectedGain === "number"
+);
+
+// 15. generateQuestions: 질문 생성
+const questions = gapEngine.generateQuestions("블록체인", ["암호화폐", "스마트컨트랙트"]);
+test("15. generateQuestions 질문 생성", () =>
+  Array.isArray(questions) && questions.length >= 4
+);
+
+// 16. prioritize: UCB1 정렬
+const prioritizeEngine = new CuriosityEngine(["A", "B", "C"]);
+const prioritized = prioritizeEngine.prioritize(["A", "B", "C"]);
+test("16. prioritize UCB1 정렬 반환", () =>
+  Array.isArray(prioritized) && prioritized.length === 3
+);
+
+// 17. analyzeExplorationHistory: 이력 분석
+const histEngine = new CuriosityEngine(["수학", "물리", "화학"]);
+histEngine.explore("수학", (t) => ({
+  facts: [`${t}는 논리다`, `${t}는 추상이다`],
+  questions: ["미적분이란?", "선형대수란?"],
+}));
+const analysis = histEngine.analyzeExplorationHistory();
+test("17. analyzeExplorationHistory 분석 반환", () =>
+  typeof analysis.totalExplored === "number" &&
+  typeof analysis.avgInfoGain === "number" &&
+  typeof analysis.mostSurprising === "string" &&
+  Array.isArray(analysis.recommendations)
+);
+
+// 18. 탐색 후 frontier 업데이트 확인
+const frontierEngine = new CuriosityEngine(["주제A"]);
+frontierEngine.explore("주제A", (t) => ({
+  facts: [`${t} 사실1`],
+  questions: ["새질문B?", "새질문C?"],
+}));
+const afterState = frontierEngine.getState();
+test("18. 탐색 후 explored에 추가됨", () => afterState.explored.has("주제A"));
+
+// ===== 빌트인 테스트 =====
+// 빌트인 함수를 직접 evalCuriosity로 테스트
+// 별도 globalCuriosity 인스턴스 사용 (상태 초기화)
+const bc = new CuriosityEngine(["바이오테크", "나노기술", "핵융합"]);
+// globalCuriosity 대신 별도 함수를 만들어 테스트 (evalCuriosity는 globalCuriosity 사용)
+
+// 19. curiosity-score 빌트인
+const scoreResult = evalCuriosity("curiosity-score", ["새주제", []], (_fn: any, _a: any[]) => null);
+test("19. curiosity-score 빌트인", () =>
+  typeof scoreResult === "number" && scoreResult >= 0 && scoreResult <= 1
+);
+
+// 20. curiosity-next 빌트인 (globalCuriosity에 frontier가 없을 수도 있어 null 허용)
+const nextResult = evalCuriosity("curiosity-next", [], (_fn: any, _a: any[]) => null);
+test("20. curiosity-next 빌트인 (null or string)", () =>
+  nextResult === null || typeof nextResult === "string"
+);
+
+// 21. curiosity-explore 빌트인
+const exploreBuiltinResult = evalCuriosity(
+  "curiosity-explore",
+  [
+    "인공지능",
+    (t: string) => new Map<string, any>([
+      ["facts", [`${t}는 머신러닝 기반`, `${t}는 데이터가 필요`]],
+      ["questions", ["딥러닝이란?", "강화학습이란?"]],
+    ]),
+  ],
+  (fn: any, a: any[]) => fn(a[0]) // 간단 callFn
+);
+test("21. curiosity-explore 빌트인 반환", () =>
+  exploreBuiltinResult instanceof Map &&
+  exploreBuiltinResult.has("topic") &&
+  exploreBuiltinResult.has("informationGain")
+);
+
+// 22. curiosity-gaps 빌트인
+const gapsResult = evalCuriosity(
+  "curiosity-gaps",
+  [["A", "B"], ["A", "B", "C", "D"]],
+  (_fn: any, _a: any[]) => null
+);
+test("22. curiosity-gaps 빌트인", () =>
+  Array.isArray(gapsResult) && gapsResult.length === 2
+);
+
+// 23. curiosity-questions 빌트인
+const questionsResult = evalCuriosity(
+  "curiosity-questions",
+  ["메타버스", ["VR", "AR"]],
+  (_fn: any, _a: any[]) => null
+);
+test("23. curiosity-questions 빌트인", () =>
+  Array.isArray(questionsResult) && questionsResult.length >= 4
+);
+
+// 24. curiosity-prioritize 빌트인
+const prioritizeResult = evalCuriosity(
+  "curiosity-prioritize",
+  [["X", "Y", "Z"]],
+  (_fn: any, _a: any[]) => null
+);
+test("24. curiosity-prioritize 빌트인", () =>
+  Array.isArray(prioritizeResult) && prioritizeResult.length === 3
+);
+
+// 25. curiosity-analyze 빌트인
+const analyzeResult = evalCuriosity("curiosity-analyze", [], (_fn: any, _a: any[]) => null);
+test("25. curiosity-analyze 빌트인", () =>
+  analyzeResult instanceof Map &&
+  analyzeResult.has("totalExplored") &&
+  analyzeResult.has("avgInfoGain") &&
+  analyzeResult.has("mostSurprising") &&
+  analyzeResult.has("recommendations")
+);
+
+// 26. curiosity-state 빌트인
+const stateResult = evalCuriosity("curiosity-state", [], (_fn: any, _a: any[]) => null);
+test("26. curiosity-state 빌트인", () =>
+  stateResult instanceof Map &&
+  stateResult.has("explored") &&
+  stateResult.has("frontier") &&
+  stateResult.has("curiosityScore")
+);
+
+// 27. computeCuriosity 0~1 범위 보장
+const scoreA = engine.computeCuriosity("X", []);
+const scoreB = engine.computeCuriosity("X", ["a", "b", "c", "d", "e", "f", "g", "h"]);
+test("27. computeCuriosity 0~1 범위 항상 보장", () =>
+  scoreA >= 0 && scoreA <= 1 && scoreB >= 0 && scoreB <= 1
+);
+
+// 28. gaps priority 내림차순 정렬
+const sortedGaps = gapEngine.identifyGaps([], ["토픽1", "토픽2", "토픽3"]);
+test("28. gaps priority 내림차순 정렬", () =>
+  sortedGaps.length >= 2 &&
+  sortedGaps[0].priority >= sortedGaps[sortedGaps.length - 1].priority
+);
+
+// 결과 출력
+console.log(`\n총 결과: ${pass} PASS / ${fail} FAIL\n`);
+if (fail > 0) {
+  process.exit(1);
+}