freelang-editor 11.7.4

package/src/test-phase125-swarm.ts

@@ -0,0 +1,321 @@
+// test-phase125-swarm.ts — FreeLang v9 Phase 125: SWARM 군집 지능
+// 최소 25개 PASS 목표
+
+import { Swarm, Particle, SwarmResult, globalSwarm } from "./swarm";
+import { Interpreter } from "./interpreter";
+
+let passed = 0;
+let failed = 0;
+const results: string[] = [];
+
+function test(name: string, fn: () => void) {
+  try {
+    fn();
+    passed++;
+    results.push(`  ✅ PASS: ${name}`);
+  } catch (e: any) {
+    failed++;
+    results.push(`  ❌ FAIL: ${name} — ${e.message}`);
+  }
+}
+
+function assert(cond: boolean, msg: string) {
+  if (!cond) throw new Error(msg);
+}
+
+function assertEq<T>(a: T, b: T, msg?: string) {
+  if (a !== b) throw new Error(msg ?? `Expected ${JSON.stringify(b)}, got ${JSON.stringify(a)}`);
+}
+
+function assertDefined(v: any, msg?: string) {
+  if (v === undefined || v === null) throw new Error(msg ?? `Expected defined value, got ${v}`);
+}
+
+function assertApprox(a: number, b: number, delta: number, msg?: string) {
+  if (Math.abs(a - b) > delta) throw new Error(msg ?? `Expected ${a} ≈ ${b} (delta=${delta})`);
+}
+
+console.log("\n=== Phase 125: SWARM 군집 지능 ===\n");
+
+// ─── 1. Swarm 생성 ──────────────────────────────────────────────────────────
+
+test("1. Swarm 생성", () => {
+  const sw = new Swarm();
+  assertDefined(sw, "Swarm 인스턴스 없음");
+  assert(typeof sw.optimize === "function", "optimize 메서드 없음");
+});
+
+// ─── 2. optimize() 기본 동작 ───────────────────────────────────────────────
+
+test("2. optimize() 기본 동작", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({ objective: (x) => -x * x });
+  assertDefined(result, "결과 없음");
+  assert("bestPosition" in result, "bestPosition 없음");
+  assert("bestScore" in result, "bestScore 없음");
+  assert("iterations" in result, "iterations 없음");
+  assert("particles" in result, "particles 없음");
+  assert("converged" in result, "converged 없음");
+});
+
+// ─── 3. bestPosition 범위 내 ───────────────────────────────────────────────
+
+test("3. bestPosition 범위 내", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({ objective: (x) => x, bounds: [0, 5] });
+  assert(result.bestPosition >= 0 && result.bestPosition <= 5,
+    `bestPosition=${result.bestPosition} 범위 초과`);
+});
+
+// ─── 4. bestScore 최대화 (양수 목적함수) ────────────────────────────────────
+
+test("4. bestScore 양수 (최대화)", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({ objective: (x) => x, bounds: [0, 1] });
+  assert(result.bestScore > 0, `bestScore=${result.bestScore} 양수여야 함`);
+});
+
+// ─── 5. iterations 기록 ────────────────────────────────────────────────────
+
+test("5. iterations 기록", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({ objective: (x) => x, iterations: 20 });
+  assert(result.iterations >= 1 && result.iterations <= 20,
+    `iterations=${result.iterations} 범위 초과`);
+});
+
+// ─── 6. converged 플래그 ───────────────────────────────────────────────────
+
+test("6. converged 플래그 (boolean)", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({ objective: (x) => 1.0 }); // 항상 동일 → 수렴 빠름
+  assert(typeof result.converged === "boolean", "converged가 boolean이 아님");
+});
+
+// ─── 7. particles 배열 반환 ────────────────────────────────────────────────
+
+test("7. particles 배열 반환", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({ objective: (x) => x, particles: 5 });
+  assert(Array.isArray(result.particles), "particles가 배열이 아님");
+  assertEq(result.particles.length, 5, "particles 수 불일치");
+});
+
+// ─── 8. n=1 단일 입자 ──────────────────────────────────────────────────────
+
+test("8. n=1 단일 입자", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({ objective: (x) => x, particles: 1 });
+  assertEq(result.particles.length, 1, "단일 입자 수 불일치");
+  assertDefined(result.bestPosition, "bestPosition 없음");
+});
+
+// ─── 9. iterations=1 ───────────────────────────────────────────────────────
+
+test("9. iterations=1", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({ objective: (x) => x, iterations: 1 });
+  assert(result.iterations >= 1, "iterations=1 이상이어야 함");
+});
+
+// ─── 10. bounds 적용 ───────────────────────────────────────────────────────
+
+test("10. bounds 적용 [-5, 5]", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({ objective: (x) => -Math.abs(x), bounds: [-5, 5], particles: 10, iterations: 30 });
+  assert(result.bestPosition >= -5 && result.bestPosition <= 5,
+    `bestPosition=${result.bestPosition} 범위 초과`);
+});
+
+// ─── 11. tolerance 수렴 ────────────────────────────────────────────────────
+
+test("11. tolerance 수렴 (constant fn → 빠른 수렴)", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({ objective: () => 42, tolerance: 0.0001, iterations: 50 });
+  // 상수 함수: 모든 입자 동일 score → 빠른 수렴
+  assert(result.converged || result.iterations <= 50, "수렴 또는 최대 반복 내 종료");
+});
+
+// ─── 12. 단순 함수 -x² (최댓값 x=0) ────────────────────────────────────────
+
+test("12. 단순 함수 x → -x² (최댓값 0 근처)", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({ objective: (x) => -x * x, bounds: [-1, 1], particles: 20, iterations: 100, tolerance: 1e-6 });
+  // bestPosition이 0에 근접해야 함
+  assertApprox(result.bestPosition, 0, 0.3, `bestPosition=${result.bestPosition} 0에 너무 멀리 있음`);
+});
+
+// ─── 13. 단순 함수 x (최댓값 = bound max) ──────────────────────────────────
+
+test("13. 단순 함수 x → x (최댓값 bound max에 근접)", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({ objective: (x) => x, bounds: [0, 10], particles: 20, iterations: 100 });
+  assert(result.bestScore >= 5, `bestScore=${result.bestScore} 5 이상이어야 함`);
+});
+
+// ─── 14. 각 particle id 고유 ────────────────────────────────────────────────
+
+test("14. 각 particle id 고유", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({ objective: (x) => x, particles: 8 });
+  const ids = result.particles.map((p) => p.id);
+  const unique = new Set(ids);
+  assertEq(unique.size, ids.length, "particle id 중복 존재");
+});
+
+// ─── 15. bestPosition과 bestScore 독립 ─────────────────────────────────────
+
+test("15. bestPosition과 bestScore 독립적", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({ objective: (x) => x * 2, bounds: [0, 1] });
+  // bestScore ≈ bestPosition * 2
+  assertApprox(result.bestScore, result.bestPosition * 2, 0.5, "bestScore ≈ bestPosition*2");
+});
+
+// ─── 16. globalSwarm 싱글톤 ─────────────────────────────────────────────────
+
+test("16. globalSwarm 싱글톤", () => {
+  assertDefined(globalSwarm, "globalSwarm 없음");
+  assert(globalSwarm instanceof Swarm, "globalSwarm이 Swarm 인스턴스가 아님");
+  const result = globalSwarm.optimize({ objective: (x) => x });
+  assertDefined(result, "globalSwarm.optimize() 결과 없음");
+});
+
+// ─── 17~19. 내장함수 테스트 ─────────────────────────────────────────────────
+
+const interp = new Interpreter();
+
+function runFL(code: string): any {
+  const ctx = (interp as any).run(code);
+  return (ctx as any).lastValue;
+}
+
+test("17. swarm-optimize 내장함수", () => {
+  const result = runFL(`(swarm-optimize (fn [$x] (* $x 2)) 5 20)`);
+  assertDefined(result, "swarm-optimize 결과 없음");
+  assert(typeof result === "number", `swarm-optimize 결과가 숫자여야 함, got ${typeof result}`);
+});
+
+test("18. swarm-best-score 내장함수", () => {
+  const result = runFL(`(swarm-best-score (fn [$x] (* $x $x)) 5 20)`);
+  assertDefined(result, "swarm-best-score 결과 없음");
+  assert(typeof result === "number", `swarm-best-score 결과가 숫자여야 함, got ${typeof result}`);
+});
+
+test("19. swarm-converged? 내장함수", () => {
+  const result = runFL(`(swarm-converged? (fn [$x] 1.0))`);
+  assert(typeof result === "boolean", `swarm-converged? 결과가 boolean이어야 함, got ${typeof result}`);
+});
+
+// ─── 20. 수렴 후 추가 반복 없음 ─────────────────────────────────────────────
+
+test("20. 수렴 후 추가 반복 없음", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({ objective: () => 1.0, iterations: 100, tolerance: 0.0001 });
+  // 상수 함수이므로 100 반복 이전에 수렴해야 함
+  assert(result.converged || result.iterations <= 100, "수렴하거나 maxIter 이내 종료");
+  if (result.converged) {
+    assert(result.iterations < 100, `수렴 시 조기 종료해야 함, iterations=${result.iterations}`);
+  }
+});
+
+// ─── 21. velocity 업데이트 (0 아님) ─────────────────────────────────────────
+
+test("21. velocity 업데이트 (particles에 velocity 있음)", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({ objective: (x) => x, particles: 5, iterations: 10 });
+  // 모든 particle에 velocity 필드 존재
+  for (const p of result.particles) {
+    assert("velocity" in p, `particle ${p.id}에 velocity 없음`);
+    assert(typeof p.velocity === "number", `velocity가 숫자여야 함`);
+  }
+});
+
+// ─── 22. particle.bestScore >= 초기 score ─────────────────────────────────
+
+test("22. particle.bestScore >= 초기 score (monotonic)", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({ objective: (x) => x * x, particles: 5, iterations: 20 });
+  // bestScore는 항상 최소 초기 score 이상
+  for (const p of result.particles) {
+    assert(p.bestScore >= 0, `bestScore=${p.bestScore} 음수 불가 (x² >= 0)`);
+  }
+});
+
+// ─── 23. global best 업데이트 ───────────────────────────────────────────────
+
+test("23. global best = particles 중 최대 bestScore", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({ objective: (x) => x, particles: 10, iterations: 30 });
+  const maxParticleScore = Math.max(...result.particles.map((p) => p.bestScore));
+  assert(result.bestScore >= maxParticleScore - 1e-9,
+    `globalBest=${result.bestScore} < particle max=${maxParticleScore}`);
+});
+
+// ─── 24. Math.random 기반 (범위만 확인) ─────────────────────────────────────
+
+test("24. 결과가 합리적 범위 내 (비결정론적)", () => {
+  const sw = new Swarm();
+  // 두 번 실행 결과가 같지 않을 수 있음 (정상) — 범위만 확인
+  const r1 = sw.optimize({ objective: (x) => x, bounds: [0, 1] });
+  const r2 = sw.optimize({ objective: (x) => x, bounds: [0, 1] });
+  assert(r1.bestPosition >= 0 && r1.bestPosition <= 1, "r1 범위 초과");
+  assert(r2.bestPosition >= 0 && r2.bestPosition <= 1, "r2 범위 초과");
+});
+
+// ─── 25. 통합: 10입자 50반복 최적화 ─────────────────────────────────────────
+
+test("25. 통합: 10입자 50반복 최적화", () => {
+  const sw = new Swarm();
+  const result = sw.optimize({
+    objective: (x) => -Math.pow(x - 0.5, 2), // 최댓값 x=0.5
+    particles: 10,
+    iterations: 50,
+    bounds: [0, 1],
+    tolerance: 1e-4,
+  });
+  assertDefined(result.bestPosition, "bestPosition 없음");
+  assertDefined(result.bestScore, "bestScore 없음");
+  assert(result.particles.length === 10, "particles 수 불일치");
+  assert(result.iterations >= 1 && result.iterations <= 50, "iterations 범위 초과");
+  assert(typeof result.converged === "boolean", "converged 타입 오류");
+  // x=0.5 근처가 bestPosition이어야 함
+  assertApprox(result.bestPosition, 0.5, 0.4, `bestPosition=${result.bestPosition} 0.5에 너무 멀리 있음`);
+});
+
+// ─── 결과 출력 ──────────────────────────────────────────────────────────────
+
+console.log(results.join("\n"));
+console.log(`\n총 결과: ${passed} PASS, ${failed} FAIL`);
+
+// ─── Regression: Phase 56 렉시컬 스코프 ──────────────────────────────────────
+// 원본 test-phase56-lexical-scope.ts 실행으로 검증
+
+console.log("\n=== Regression: Phase 56 렉시컬 스코프 14/14 ===\n");
+
+import { execSync } from "child_process";
+
+let regPassed = 0;
+let regFailed = 0;
+
+try {
+  const regOutput = execSync(
+    "npx ts-node src/test-phase56-lexical-scope.ts",
+    { cwd: "/home/kimjin/kim/Desktop/kim/01_Active_Projects/freelang-v9", encoding: "utf8", timeout: 30000 }
+  );
+  const match = regOutput.match(/Phase 56 렉시컬 스코프: (\d+) passed, (\d+) failed/);
+  if (match) {
+    regPassed = parseInt(match[1]);
+    regFailed = parseInt(match[2]);
+  }
+  console.log(`  Regression 결과: ${regPassed}/14 PASS, ${regFailed} FAIL`);
+} catch (e: any) {
+  console.log(`  ❌ Regression 실행 실패: ${e.message?.slice(0, 100)}`);
+  regFailed = 14;
+}
+
+console.log(`\nRegression 결과: ${regPassed}/14 PASS`);
+
+if (failed > 0) {
+  process.exit(1);
+}

package/src/test-phase126-orchestrate.ts

@@ -0,0 +1,343 @@
+// test-phase126-orchestrate.ts — FreeLang v9 Phase 126: ORCHESTRATE 에이전트 오케스트레이터
+// 위상 정렬 기반 멀티 에이전트 오케스트레이터
+// 최소 25개 PASS 목표
+
+import {
+  Orchestrator,
+  OrchestrateTask,
+  OrchestrateAgent,
+  OrchestrateResult,
+  globalOrchestrator,
+  createOrchestrateBuiltins,
+} from "./orchestrate";
+import { Interpreter } from "./interpreter";
+
+let passed = 0;
+let failed = 0;
+const results: string[] = [];
+
+function test(name: string, fn: () => void) {
+  try {
+    fn();
+    passed++;
+    results.push(`  ✅ PASS: ${name}`);
+  } catch (e: any) {
+    failed++;
+    results.push(`  ❌ FAIL: ${name} — ${e.message}`);
+  }
+}
+
+function assert(cond: boolean, msg: string) {
+  if (!cond) throw new Error(msg);
+}
+
+function assertEq<T>(a: T, b: T, msg?: string) {
+  if (a !== b) throw new Error(msg ?? `Expected ${JSON.stringify(b)}, got ${JSON.stringify(a)}`);
+}
+
+function assertDefined(v: any, msg?: string) {
+  if (v === undefined || v === null) throw new Error(msg ?? `Expected defined value, got ${v}`);
+}
+
+console.log("\n=== Phase 126: ORCHESTRATE 에이전트 오케스트레이터 ===\n");
+
+// ─── 1. 기본 인스턴스 ─────────────────────────────────────────────────────
+
+test("1. Orchestrator 생성", () => {
+  const orch = new Orchestrator();
+  assertDefined(orch, "Orchestrator 인스턴스 없음");
+});
+
+test("2. register() 에이전트 등록", () => {
+  const orch = new Orchestrator();
+  orch.register({ id: "agent-a", run: (x: any) => x });
+  assert(orch.list().includes("agent-a"), "agent-a가 목록에 없음");
+});
+
+test("3. list() 목록 반환", () => {
+  const orch = new Orchestrator();
+  orch.register({ id: "x", run: (v: any) => v });
+  orch.register({ id: "y", run: (v: any) => v });
+  const lst = orch.list();
+  assert(lst.includes("x") && lst.includes("y"), "list()에 x, y가 없음");
+  assertEq(lst.length, 2, "list() 길이 2 예상");
+});
+
+// ─── 2. 단일/다중 태스크 실행 ────────────────────────────────────────────
+
+test("4. run() 단일 태스크", () => {
+  const orch = new Orchestrator();
+  orch.register({ id: "t1", run: (x: any) => x * 2 });
+  const result = orch.run([{ id: "t1", input: 5 }]);
+  assertEq(result.outputs["t1"], 10, "단일 태스크 출력 10 예상");
+});
+
+test("5. run() 여러 태스크", () => {
+  const orch = new Orchestrator();
+  orch.register({ id: "a", run: (x: any) => x + 1 });
+  orch.register({ id: "b", run: (x: any) => x + 2 });
+  const result = orch.run([
+    { id: "a", input: 10 },
+    { id: "b", input: 20 },
+  ]);
+  assertEq(result.outputs["a"], 11, "a=11 예상");
+  assertEq(result.outputs["b"], 22, "b=22 예상");
+});
+
+test("6. outputs taskId 키 구조", () => {
+  const orch = new Orchestrator();
+  orch.register({ id: "task1", run: (x: any) => "result-" + x });
+  const result = orch.run([{ id: "task1", input: "hello" }]);
+  assert("task1" in result.outputs, "outputs에 task1 키 없음");
+  assertEq(result.outputs["task1"], "result-hello", "출력값 불일치");
+});
+
+test("7. order 배열 반환", () => {
+  const orch = new Orchestrator();
+  orch.register({ id: "m", run: (x: any) => x });
+  const result = orch.run([{ id: "m", input: 0 }]);
+  assert(Array.isArray(result.order), "order가 배열이 아님");
+  assert(result.order.includes("m"), "order에 m 없음");
+});
+
+test("8. duration 기록", () => {
+  const orch = new Orchestrator();
+  orch.register({ id: "d", run: (x: any) => x });
+  const result = orch.run([{ id: "d", input: 1 }]);
+  assert(typeof result.duration === "number", "duration이 숫자가 아님");
+  assert(result.duration >= 0, "duration이 음수");
+});
+
+test("9. success=true 정상 실행", () => {
+  const orch = new Orchestrator();
+  orch.register({ id: "s", run: (x: any) => x });
+  const result = orch.run([{ id: "s", input: 42 }]);
+  assertEq(result.success, true, "success가 true가 아님");
+});
+
+// ─── 3. 의존성 처리 ──────────────────────────────────────────────────────
+
+test("10. 의존성 없는 태스크 — 등록 순서대로 실행", () => {
+  const orch = new Orchestrator();
+  const exec: string[] = [];
+  orch.register({ id: "p", run: (x: any) => { exec.push("p"); return x; } });
+  orch.register({ id: "q", run: (x: any) => { exec.push("q"); return x; } });
+  orch.run([{ id: "p", input: 1 }, { id: "q", input: 2 }]);
+  assert(exec.length === 2, "두 태스크 모두 실행되어야 함");
+});
+
+test("11. dependsOn → 선행 후 실행", () => {
+  const orch = new Orchestrator();
+  const exec: string[] = [];
+  orch.register({ id: "first", run: (x: any) => { exec.push("first"); return x + 10; } });
+  orch.register({ id: "second", run: (x: any) => { exec.push("second"); return x; } });
+  orch.run([
+    { id: "first", input: 5 },
+    { id: "second", input: 0, dependsOn: ["first"] },
+  ]);
+  assertEq(exec[0], "first", "first가 먼저 실행되어야 함");
+  assertEq(exec[1], "second", "second가 나중에 실행되어야 함");
+});
+
+test("12. depOutputs input에 전달", () => {
+  const orch = new Orchestrator();
+  orch.register({ id: "src", run: (_: any) => 99 });
+  orch.register({ id: "dst", run: (x: any) => x.deps[0] + 1 });
+  const result = orch.run([
+    { id: "src", input: null },
+    { id: "dst", input: {}, dependsOn: ["src"] },
+  ]);
+  assertEq(result.outputs["dst"], 100, "deps[0]=99 → dst=100 예상");
+});
+
+test("13. 위상 정렬 순서 검증 (A→B→C)", () => {
+  const orch = new Orchestrator();
+  const exec: string[] = [];
+  orch.register({ id: "A", run: (x: any) => { exec.push("A"); return x; } });
+  orch.register({ id: "B", run: (x: any) => { exec.push("B"); return x; } });
+  orch.register({ id: "C", run: (x: any) => { exec.push("C"); return x; } });
+  orch.run([
+    { id: "A", input: 1 },
+    { id: "B", input: 0, dependsOn: ["A"] },
+    { id: "C", input: 0, dependsOn: ["B"] },
+  ]);
+  assertEq(exec[0], "A", "A 먼저");
+  assertEq(exec[1], "B", "B 두 번째");
+  assertEq(exec[2], "C", "C 마지막");
+});
+
+test("14. 에러 → success=false", () => {
+  const orch = new Orchestrator();
+  orch.register({ id: "err", run: (_: any) => { throw new Error("의도적 에러"); } });
+  const result = orch.run([{ id: "err", input: null }]);
+  assertEq(result.success, false, "에러 시 success=false 예상");
+});
+
+test("15. globalOrchestrator 싱글톤", () => {
+  assertDefined(globalOrchestrator, "globalOrchestrator가 undefined");
+  assert(globalOrchestrator instanceof Orchestrator, "globalOrchestrator가 Orchestrator 인스턴스가 아님");
+});
+
+// ─── 4. 내장 함수 ────────────────────────────────────────────────────────
+
+test("16. orchestrate-register 내장함수", () => {
+  const freshOrch = new Orchestrator();
+  // createOrchestrateBuiltins가 globalOrchestrator에 등록하므로
+  // 별도로 로컬 등록 검증
+  freshOrch.register({ id: "builtin-test", run: (x: any) => x });
+  assert(freshOrch.list().includes("builtin-test"), "builtin-test 등록 실패");
+});
+
+test("17. orchestrate 내장함수 (tasks → outputs)", () => {
+  const interp = new Interpreter();
+  const builtins = createOrchestrateBuiltins(interp as any);
+  // 미리 globalOrchestrator에 등록
+  globalOrchestrator.register({ id: "fn-a", run: (x: any) => (x ?? 0) + 100 });
+  const tasks = [{ id: "fn-a", input: 5 }];
+  const outputs = builtins["orchestrate"](tasks);
+  assertDefined(outputs, "orchestrate builtin 반환값 없음");
+  assert(typeof outputs === "object", "outputs가 객체가 아님");
+});
+
+test("18. orchestrate-order 내장함수", () => {
+  const interp = new Interpreter();
+  const builtins = createOrchestrateBuiltins(interp as any);
+  const tasks = [
+    { id: "step1", input: null },
+    { id: "step2", input: null, dependsOn: ["step1"] },
+  ];
+  const order = builtins["orchestrate-order"](tasks);
+  assert(Array.isArray(order), "order가 배열이 아님");
+  assert(order.indexOf("step1") < order.indexOf("step2"), "step1이 step2보다 먼저 와야 함");
+});
+
+test("19. orchestrate-list 내장함수", () => {
+  const interp = new Interpreter();
+  const builtins = createOrchestrateBuiltins(interp as any);
+  globalOrchestrator.register({ id: "list-test-agent", run: (x: any) => x });
+  const lst = builtins["orchestrate-list"]();
+  assert(Array.isArray(lst), "list가 배열이 아님");
+  assert(lst.includes("list-test-agent"), "list-test-agent가 목록에 없음");
+});
+
+// ─── 5. 체인 & 병렬 시나리오 ─────────────────────────────────────────────
+
+test("20. A→B→C 체인 순서 (getOrder)", () => {
+  const orch = new Orchestrator();
+  const order = orch.getOrder([
+    { id: "A", input: null },
+    { id: "B", input: null, dependsOn: ["A"] },
+    { id: "C", input: null, dependsOn: ["B"] },
+  ]);
+  assertEq(order[0], "A", "A 먼저");
+  assertEq(order[1], "B", "B 두 번째");
+  assertEq(order[2], "C", "C 마지막");
+});
+
+test("21. A,B 병렬 → C 순서 (C는 A,B 다음)", () => {
+  const orch = new Orchestrator();
+  const order = orch.getOrder([
+    { id: "A", input: null },
+    { id: "B", input: null },
+    { id: "C", input: null, dependsOn: ["A", "B"] },
+  ]);
+  const idxA = order.indexOf("A");
+  const idxB = order.indexOf("B");
+  const idxC = order.indexOf("C");
+  assert(idxA < idxC, "A가 C보다 먼저 와야 함");
+  assert(idxB < idxC, "B가 C보다 먼저 와야 함");
+});
+
+test("22. 빈 tasks → outputs={}, success=true", () => {
+  const orch = new Orchestrator();
+  const result = orch.run([]);
+  assertEq(Object.keys(result.outputs).length, 0, "빈 tasks는 outputs={}");
+  assertEq(result.success, true, "빈 tasks도 success=true");
+});
+
+test("23. 순환 의존성 — 방문 체크로 무한루프 방지", () => {
+  const orch = new Orchestrator();
+  orch.register({ id: "X", run: (x: any) => x });
+  orch.register({ id: "Y", run: (x: any) => x });
+  // X→Y→X 순환: 방문 체크로 한번만 방문
+  let threw = false;
+  try {
+    const order = orch.getOrder([
+      { id: "X", input: null, dependsOn: ["Y"] },
+      { id: "Y", input: null, dependsOn: ["X"] },
+    ]);
+    assert(Array.isArray(order), "order가 배열이어야 함");
+  } catch {
+    threw = true;
+  }
+  assert(!threw, "순환 의존성에서 예외 발생 — visited 체크로 방지해야 함");
+});
+
+test("24. 선행 output이 다음 input의 deps[0]에 포함", () => {
+  const orch = new Orchestrator();
+  orch.register({ id: "producer", run: (_: any) => { return { value: 777 }; } });
+  orch.register({
+    id: "consumer",
+    run: (x: any) => {
+      return x.deps[0].value * 2;
+    }
+  });
+  const result = orch.run([
+    { id: "producer", input: null },
+    { id: "consumer", input: {}, dependsOn: ["producer"] },
+  ]);
+  assertEq(result.outputs["consumer"], 1554, "777*2=1554 예상");
+});
+
+// ─── 6. 통합: 3단계 파이프라인 ───────────────────────────────────────────
+
+test("25. 통합: 3단계 파이프라인 (파싱→변환→포맷)", () => {
+  const orch = new Orchestrator();
+
+  // 파싱 에이전트: 문자열을 숫자 배열로
+  orch.register({
+    id: "parse",
+    run: (input: any) => {
+      return (input.raw as string).split(",").map(Number);
+    }
+  });
+
+  // 변환 에이전트: 각 값 제곱
+  orch.register({
+    id: "transform",
+    run: (input: any) => {
+      const nums: number[] = input.deps[0];
+      return nums.map((n: number) => n * n);
+    }
+  });
+
+  // 포맷 에이전트: 합산 후 문자열
+  orch.register({
+    id: "format",
+    run: (input: any) => {
+      const squared: number[] = input.deps[0];
+      const total = squared.reduce((a: number, b: number) => a + b, 0);
+      return `total=${total}`;
+    }
+  });
+
+  const result = orch.run([
+    { id: "parse", input: { raw: "1,2,3,4" } },
+    { id: "transform", input: {}, dependsOn: ["parse"] },
+    { id: "format", input: {}, dependsOn: ["transform"] },
+  ]);
+
+  // 1^2+2^2+3^2+4^2 = 1+4+9+16 = 30
+  assertEq(result.outputs["format"], "total=30", "3단계 파이프라인 결과 total=30 예상");
+  assertEq(result.success, true, "파이프라인 success=true 예상");
+  assertEq(result.order.length, 3, "order 길이 3 예상");
+});
+
+// ─── 결과 출력 ───────────────────────────────────────────────────────────
+
+console.log(results.join("\n"));
+console.log(`\n총 ${passed + failed}개 테스트: ${passed} PASS, ${failed} FAIL`);
+
+if (failed > 0) {
+  process.exit(1);
+}