skyloom 1.13.5 → 1.13.7

package/tests/memory.test.ts

@@ -1,170 +1,170 @@
-import { describe, it, expect, afterEach } from "vitest";
-import * as os from "os";
-import * as path from "path";
-import * as fs from "fs";
-import { Memory } from "../src/core/memory";
-
-/** addMessage mutates shortTerm through an async mutex — let microtasks flush. */
-const flush = () => new Promise((r) => setTimeout(r, 15));
-
-let tmpDirs: string[] = [];
-function tmpConfig(shortTermLimit = 100) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sky-mem-"));
-  tmpDirs.push(dir);
-  return { dbPath: path.join(dir, "memory.db"), shortTermLimit, maxPersistedMessages: 2000 };
-}
-
-afterEach(() => {
-  for (const d of tmpDirs) { try { fs.rmSync(d, { recursive: true, force: true }); } catch { /* ignore */ } }
-  tmpDirs = [];
-});
-
-describe("Memory · short-term (in-memory, no DB)", () => {
-  it("makes a message visible SYNCHRONOUSLY (regression: first-turn crash)", () => {
-    // Previously addMessage pushed inside an async mutex, so getMessages() in the
-    // same tick missed the message — crashing chatImpl/chatStreamImpl on a fresh
-    // session's first user message. The push must be synchronous.
-    const mem = new Memory(tmpConfig(), "fog");
-    mem.addMessage("user", "first message");
-    const msgs = mem.getMessages(); // no flush!
-    expect(msgs).toHaveLength(1);
-    expect(msgs[0]).toMatchObject({ role: "user", content: "first message" });
-  });
-
-  it("records and returns messages in order", async () => {
-    const mem = new Memory(tmpConfig(), "fog");
-    mem.addMessage("user", "hello");
-    mem.addMessage("assistant", "hi there");
-    await flush();
-    const msgs = mem.getMessages();
-    expect(msgs.map((m) => m.role)).toEqual(["user", "assistant"]);
-    expect(msgs[0].content).toBe("hello");
-  });
-
-  it("preserves tool-call metadata in getMessages", async () => {
-    const mem = new Memory(tmpConfig(), "fog");
-    mem.addMessage("assistant", "", { toolCalls: [{ id: "t1", function: { name: "x" } }] });
-    mem.addMessage("tool", "result", { name: "x", toolCallId: "t1" });
-    await flush();
-    const msgs = mem.getMessages();
-    const toolMsg = msgs.find((m) => m.role === "tool");
-    expect(toolMsg?.tool_call_id).toBe("t1");
-    expect(toolMsg?.name).toBe("x");
-  });
-
-  it("prunes past the short-term limit but keeps system messages", async () => {
-    const mem = new Memory(tmpConfig(3), "fog");
-    mem.addMessage("system", "persona");
-    for (let i = 0; i < 5; i++) mem.addMessage("user", `m${i}`);
-    await flush();
-    const msgs = mem.getMessages();
-    expect(msgs.length).toBeLessThanOrEqual(3);
-    expect(msgs.some((m) => m.role === "system" && m.content === "persona")).toBe(true);
-    // most recent user message survives
-    expect(msgs[msgs.length - 1].content).toBe("m4");
-  });
-
-  it("clearShortTerm keeps system messages", async () => {
-    const mem = new Memory(tmpConfig(), "fog");
-    mem.addMessage("system", "persona");
-    mem.addMessage("user", "hello");
-    await flush();
-    await mem.clearShortTerm();
-    const msgs = mem.getMessages();
-    expect(msgs).toHaveLength(1);
-    expect(msgs[0].role).toBe("system");
-  });
-});
-
-describe("Memory · context window estimation", () => {
-  it("counts CJK as heavier than ascii", async () => {
-    const mem = new Memory(tmpConfig(), "fog");
-    mem.addMessage("user", "你好世界"); // 4 CJK chars
-    await flush();
-    const usage = mem.getContextWindowUsage();
-    expect(usage.messageCount).toBe(1);
-    expect(usage.totalChars).toBe(4);
-    // CJK weight is 2/char => >= 8
-    expect(usage.estimatedTokens).toBeGreaterThanOrEqual(8);
-  });
-});
-
-describe("Memory · working memory", () => {
-  it("set/get/clear round-trips", () => {
-    const mem = new Memory(tmpConfig(), "fog");
-    mem.setWorking("plan", { step: 1 });
-    expect(mem.getWorking("plan")).toEqual({ step: 1 });
-    expect(mem.getWorking("missing", "fallback")).toBe("fallback");
-    mem.clearWorking();
-    expect(mem.getWorking("plan")).toBeNull();
-  });
-});
-
-describe("Memory · long-term (SQLite)", () => {
-  it("remember / recall / forget round-trips", async () => {
-    const mem = new Memory(tmpConfig(), "fog");
-    await mem.initDb();
-    try {
-      await mem.remember("favorite_lang", "typescript", "pref");
-      const hits = await mem.recall("favorite_lang");
-      expect(hits).toHaveLength(1);
-      expect(hits[0].value).toBe("typescript");
-      expect(hits[0].category).toBe("pref");
-
-      await mem.forget("favorite_lang");
-      expect(await mem.recall("favorite_lang")).toHaveLength(0);
-    } finally {
-      await mem.close();
-    }
-  });
-
-  it("recall filters by category", async () => {
-    const mem = new Memory(tmpConfig(), "fog");
-    await mem.initDb();
-    try {
-      await mem.remember("a", 1, "x");
-      await mem.remember("b", 2, "y");
-      const xs = await mem.recall(null, "x");
-      expect(xs).toHaveLength(1);
-      expect(xs[0].key).toBe("a");
-    } finally {
-      await mem.close();
-    }
-  });
-
-  it("persists sessions + messages to disk and reloads across instances (regression)", async () => {
-    // Previously persistDb() was never called, so nothing survived a restart and
-    // session resume was impossible. close() must save; a fresh instance must reload.
-    const cfg = tmpConfig(); // shared dbPath for both instances
-    const a = new Memory(cfg, "fog");
-    await a.initDb();
-    const sid = await a.createSession("s1");
-    a.addMessage("user", "the sky is blue");
-    a.addMessage("assistant", "noted: sky is blue");
-    await a.remember("fact1", "value1", "auto");
-    await a.close(); // must flush to disk
-
-    const b = new Memory(cfg, "fog");
-    await b.initDb();
-    const sessions = await b.listSessions();
-    expect(sessions.some((s) => s.id === sid)).toBe(true);
-    expect(await b.loadSession(sid)).toBe(true);
-    const msgs = b.getMessages().filter((m) => m.role !== "system");
-    expect(msgs.some((m) => String(m.content).includes("sky is blue"))).toBe(true);
-    expect((await b.recall("fact1"))[0]?.value).toBe("value1"); // long-term memory survived too
-    await b.close();
-  });
-
-  it("getMemoryStats returns a populated object", async () => {
-    const mem = new Memory(tmpConfig(), "fog");
-    await mem.initDb();
-    try {
-      await mem.remember("k", "v");
-      const stats = await mem.getMemoryStats();
-      expect(typeof stats).toBe("object");
-      expect(stats).not.toBeNull();
-    } finally {
-      await mem.close();
-    }
-  });
-});
+import { describe, it, expect, afterEach } from "vitest";
+import * as os from "os";
+import * as path from "path";
+import * as fs from "fs";
+import { Memory } from "../src/core/memory";
+
+/** addMessage mutates shortTerm through an async mutex — let microtasks flush. */
+const flush = () => new Promise((r) => setTimeout(r, 15));
+
+let tmpDirs: string[] = [];
+function tmpConfig(shortTermLimit = 100) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sky-mem-"));
+  tmpDirs.push(dir);
+  return { dbPath: path.join(dir, "memory.db"), shortTermLimit, maxPersistedMessages: 2000 };
+}
+
+afterEach(() => {
+  for (const d of tmpDirs) { try { fs.rmSync(d, { recursive: true, force: true }); } catch { /* ignore */ } }
+  tmpDirs = [];
+});
+
+describe("Memory · short-term (in-memory, no DB)", () => {
+  it("makes a message visible SYNCHRONOUSLY (regression: first-turn crash)", () => {
+    // Previously addMessage pushed inside an async mutex, so getMessages() in the
+    // same tick missed the message — crashing chatImpl/chatStreamImpl on a fresh
+    // session's first user message. The push must be synchronous.
+    const mem = new Memory(tmpConfig(), "fog");
+    mem.addMessage("user", "first message");
+    const msgs = mem.getMessages(); // no flush!
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]).toMatchObject({ role: "user", content: "first message" });
+  });
+
+  it("records and returns messages in order", async () => {
+    const mem = new Memory(tmpConfig(), "fog");
+    mem.addMessage("user", "hello");
+    mem.addMessage("assistant", "hi there");
+    await flush();
+    const msgs = mem.getMessages();
+    expect(msgs.map((m) => m.role)).toEqual(["user", "assistant"]);
+    expect(msgs[0].content).toBe("hello");
+  });
+
+  it("preserves tool-call metadata in getMessages", async () => {
+    const mem = new Memory(tmpConfig(), "fog");
+    mem.addMessage("assistant", "", { toolCalls: [{ id: "t1", function: { name: "x" } }] });
+    mem.addMessage("tool", "result", { name: "x", toolCallId: "t1" });
+    await flush();
+    const msgs = mem.getMessages();
+    const toolMsg = msgs.find((m) => m.role === "tool");
+    expect(toolMsg?.tool_call_id).toBe("t1");
+    expect(toolMsg?.name).toBe("x");
+  });
+
+  it("prunes past the short-term limit but keeps system messages", async () => {
+    const mem = new Memory(tmpConfig(3), "fog");
+    mem.addMessage("system", "persona");
+    for (let i = 0; i < 5; i++) mem.addMessage("user", `m${i}`);
+    await flush();
+    const msgs = mem.getMessages();
+    expect(msgs.length).toBeLessThanOrEqual(3);
+    expect(msgs.some((m) => m.role === "system" && m.content === "persona")).toBe(true);
+    // most recent user message survives
+    expect(msgs[msgs.length - 1].content).toBe("m4");
+  });
+
+  it("clearShortTerm keeps system messages", async () => {
+    const mem = new Memory(tmpConfig(), "fog");
+    mem.addMessage("system", "persona");
+    mem.addMessage("user", "hello");
+    await flush();
+    await mem.clearShortTerm();
+    const msgs = mem.getMessages();
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0].role).toBe("system");
+  });
+});
+
+describe("Memory · context window estimation", () => {
+  it("counts CJK as heavier than ascii", async () => {
+    const mem = new Memory(tmpConfig(), "fog");
+    mem.addMessage("user", "你好世界"); // 4 CJK chars
+    await flush();
+    const usage = mem.getContextWindowUsage();
+    expect(usage.messageCount).toBe(1);
+    expect(usage.totalChars).toBe(4);
+    // CJK weight is 2/char => >= 8
+    expect(usage.estimatedTokens).toBeGreaterThanOrEqual(8);
+  });
+});
+
+describe("Memory · working memory", () => {
+  it("set/get/clear round-trips", () => {
+    const mem = new Memory(tmpConfig(), "fog");
+    mem.setWorking("plan", { step: 1 });
+    expect(mem.getWorking("plan")).toEqual({ step: 1 });
+    expect(mem.getWorking("missing", "fallback")).toBe("fallback");
+    mem.clearWorking();
+    expect(mem.getWorking("plan")).toBeNull();
+  });
+});
+
+describe("Memory · long-term (SQLite)", () => {
+  it("remember / recall / forget round-trips", async () => {
+    const mem = new Memory(tmpConfig(), "fog");
+    await mem.initDb();
+    try {
+      await mem.remember("favorite_lang", "typescript", "pref");
+      const hits = await mem.recall("favorite_lang");
+      expect(hits).toHaveLength(1);
+      expect(hits[0].value).toBe("typescript");
+      expect(hits[0].category).toBe("pref");
+
+      await mem.forget("favorite_lang");
+      expect(await mem.recall("favorite_lang")).toHaveLength(0);
+    } finally {
+      await mem.close();
+    }
+  });
+
+  it("recall filters by category", async () => {
+    const mem = new Memory(tmpConfig(), "fog");
+    await mem.initDb();
+    try {
+      await mem.remember("a", 1, "x");
+      await mem.remember("b", 2, "y");
+      const xs = await mem.recall(null, "x");
+      expect(xs).toHaveLength(1);
+      expect(xs[0].key).toBe("a");
+    } finally {
+      await mem.close();
+    }
+  });
+
+  it("persists sessions + messages to disk and reloads across instances (regression)", async () => {
+    // Previously persistDb() was never called, so nothing survived a restart and
+    // session resume was impossible. close() must save; a fresh instance must reload.
+    const cfg = tmpConfig(); // shared dbPath for both instances
+    const a = new Memory(cfg, "fog");
+    await a.initDb();
+    const sid = await a.createSession("s1");
+    a.addMessage("user", "the sky is blue");
+    a.addMessage("assistant", "noted: sky is blue");
+    await a.remember("fact1", "value1", "auto");
+    await a.close(); // must flush to disk
+
+    const b = new Memory(cfg, "fog");
+    await b.initDb();
+    const sessions = await b.listSessions();
+    expect(sessions.some((s) => s.id === sid)).toBe(true);
+    expect(await b.loadSession(sid)).toBe(true);
+    const msgs = b.getMessages().filter((m) => m.role !== "system");
+    expect(msgs.some((m) => String(m.content).includes("sky is blue"))).toBe(true);
+    expect((await b.recall("fact1"))[0]?.value).toBe("value1"); // long-term memory survived too
+    await b.close();
+  });
+
+  it("getMemoryStats returns a populated object", async () => {
+    const mem = new Memory(tmpConfig(), "fog");
+    await mem.initDb();
+    try {
+      await mem.remember("k", "v");
+      const stats = await mem.getMemoryStats();
+      expect(typeof stats).toBe("object");
+      expect(stats).not.toBeNull();
+    } finally {
+      await mem.close();
+    }
+  });
+});

package/tests/model_config.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import * as yaml from "yaml";
+import {
+  providerOfModel, setAgentModel, clearAgentModel, setUnifiedModel,
+  setAgentApiKey, clearAgentApiKey, describeAgentLLM,
+} from "../src/core/model_config";
+import { createModelTools } from "../src/tools/model_tool";
+
+let tmp: string;
+let cfg: any;
+const savedEnv = { ...process.env };
+
+beforeEach(() => {
+  tmp = fs.mkdtempSync(path.join(os.tmpdir(), "skymodel-"));
+  cfg = { agents: {}, default_model: "gpt-4o" };
+  delete process.env.DEEPSEEK_API_KEY;
+  delete process.env.OPENAI_API_KEY;
+});
+afterEach(() => {
+  fs.rmSync(tmp, { recursive: true, force: true });
+  process.env = { ...savedEnv };
+});
+
+const userYaml = () => yaml.parse(fs.readFileSync(path.join(tmp, "config.yaml"), "utf-8"));
+
+describe("模型配置 — 统一 + 独立覆盖", () => {
+  it("providerOfModel resolves catalog models and prefixed ids", () => {
+    expect(providerOfModel("deepseek-chat")).toBe("deepseek");
+    expect(providerOfModel("anthropic/claude-sonnet-4-6")).toBe("anthropic");
+    expect(providerOfModel("no-such-model")).toBeNull();
+  });
+
+  it("setAgentModel mutates runtime config AND persists a narrow patch", () => {
+    const r = setAgentModel(cfg, "fog", "deepseek-chat", tmp);
+    expect(r.ok).toBe(true);
+    expect(r.provider).toBe("deepseek");
+    // 热生效：运行时对象即刻更新（LLMClient.getModel 走同一引用）
+    expect(cfg.agents.fog.model).toBe("deepseek-chat");
+    // 持久化：只写覆盖项，不把合并后的默认配置泄漏进用户文件
+    const u = userYaml();
+    expect(u.agents.fog.model).toBe("deepseek-chat");
+    expect(u.default_model).toBeUndefined();
+  });
+
+  it("rejects models not in the catalog, with suggestions", () => {
+    const r = setAgentModel(cfg, "fog", "gpt-99-ultra", tmp);
+    expect(r.ok).toBe(false);
+    expect(cfg.agents.fog?.model).toBeUndefined();
+  });
+
+  it("clearAgentModel falls back to the unified default", () => {
+    setAgentModel(cfg, "fog", "deepseek-chat", tmp);
+    clearAgentModel(cfg, "fog", tmp);
+    expect(cfg.agents.fog?.model).toBeUndefined();
+    expect(describeAgentLLM(cfg, "fog", tmp).model).toBe("gpt-4o");
+    expect(userYaml().agents?.fog).toBeUndefined();
+  });
+
+  it("setUnifiedModel changes the default for every non-overridden agent", () => {
+    setAgentModel(cfg, "rain", "deepseek-chat", tmp);
+    const r = setUnifiedModel(cfg, "gpt-4o-mini", tmp);
+    expect(r.ok).toBe(true);
+    expect(describeAgentLLM(cfg, "fog", tmp).model).toBe("gpt-4o-mini");   // 跟随统一
+    expect(describeAgentLLM(cfg, "rain", tmp).model).toBe("deepseek-chat"); // 保持独立
+    expect(userYaml().default_model).toBe("gpt-4o-mini");
+  });
+
+  it("per-agent api key: set/clear + keySource resolution", () => {
+    setAgentApiKey(cfg, "fog", "sk-fog-own", tmp);
+    expect(cfg.agents.fog.api_key).toBe("sk-fog-own");
+    expect(describeAgentLLM(cfg, "fog", tmp).keySource).toBe("agent");
+    expect(userYaml().agents.fog.api_key).toBe("sk-fog-own");
+
+    clearAgentApiKey(cfg, "fog", tmp);
+    expect(describeAgentLLM(cfg, "fog", tmp).keySource).toBe("missing");
+
+    process.env.OPENAI_API_KEY = "sk-env";
+    expect(describeAgentLLM(cfg, "fog", tmp).keySource).toBe("env");
+  });
+
+  it("describeAgentLLM reports source agent vs unified", () => {
+    expect(describeAgentLLM(cfg, "fog", tmp).source).toBe("unified");
+    setAgentModel(cfg, "fog", "deepseek-chat", tmp);
+    const d = describeAgentLLM(cfg, "fog", tmp);
+    expect(d.source).toBe("agent");
+    expect(d.provider).toBe("deepseek");
+  });
+});
+
+describe("agent 自助换模型工具", () => {
+  it("set_my_model rejects unknown ids without touching config", async () => {
+    const tools = createModelTools("fog", cfg);
+    const setModel = tools.find(t => t.name === "set_my_model")!;
+    const out = await setModel.handler({ model: "gpt-99-ultra" });
+    expect(String(out)).toContain("✗");
+    expect(cfg.agents.fog?.model).toBeUndefined();
+  });
+
+  it("list_models reports current model and catalog entries", async () => {
+    const tools = createModelTools("fog", cfg);
+    const list = tools.find(t => t.name === "list_models")!;
+    const out = String(await list.handler({}));
+    expect(out).toContain("Current: gpt-4o");
+    expect(out).toContain("deepseek-chat");
+  });
+});

package/tests/router.test.ts

@@ -1,86 +1,86 @@
-/**
- * Tests for the complexity router.
- */
-import { describe, it, expect } from 'vitest';
-import { classify, pickAgentForGoal } from '../src/core/router';
-
-describe('classify', () => {
-  it.each([
-    '你好',
-    'hi',
-    '在吗',
-    '谢谢',
-    '什么是 RAG?',
-    '为什么天空是蓝的？',
-    '1 + 1 = ?',
-    '解释一下闭包',
-  ])('returns "direct" for simple questions: %s', (goal) => {
-    expect(classify(goal)).toBe('direct');
-  });
-
-  it.each([
-    '帮我写一个二分查找函数',
-    '搜一下今天的天气',
-    '审查 src/foo.py 的安全问题',
-    '把这段中文翻译成英文：我喜欢猫',
-  ])('returns "single" for focused tasks: %s', (goal) => {
-    expect(classify(goal)).toBe('single');
-  });
-
-  it.each([
-    '先帮我分析这段代码，然后重构它，最后写测试',
-    '首先调研一下市场上有哪些方案，其次对比性能，最后给出推荐',
-    '1. 创建数据库迁移\n2. 写 API\n3. 加测试\n4. 部署',
-  ])('returns "orchestrate" for multi-step: %s', (goal) => {
-    expect(classify(goal)).toBe('orchestrate');
-  });
-
-  it('empty goal returns direct', () => {
-    expect(classify('')).toBe('direct');
-    expect(classify('   ')).toBe('direct');
-  });
-
-  it('inline enumerated list is orchestrate', () => {
-    expect(classify('1. 拉数据 2. 分析 3. 出图')).toBe('orchestrate');
-    expect(classify('先做 1. xxx 2. yyy 3. zzz 4. www')).toBe('orchestrate');
-  });
-
-  it('two inline items is not orchestrate', () => {
-    expect(classify('1. 你好 2. 谢谢')).not.toBe('orchestrate');
-  });
-});
-
-describe('pickAgentForGoal', () => {
-  const allAgents = new Set(['fog', 'rain', 'frost', 'snow', 'dew', 'fair']);
-
-  it('security keyword picks frost', () => {
-    expect(pickAgentForGoal('帮我做安全审查', allAgents)).toBe('frost');
-  });
-
-  it('research keyword picks fog', () => {
-    expect(pickAgentForGoal('搜一下最新的 React 文档', allAgents)).toBe('fog');
-  });
-
-  it('greeting picks fair', () => {
-    expect(pickAgentForGoal('你好啊', allAgents)).toBe('fair');
-  });
-
-  it('falls back to rain', () => {
-    expect(pickAgentForGoal('处理这个东西', allAgents)).toBe('rain');
-  });
-
-  it('binary search picks rain not fog', () => {
-    expect(pickAgentForGoal('帮我写一个二分查找', allAgents)).toBe('rain');
-    expect(pickAgentForGoal('实现一个排序函数', allAgents)).toBe('rain');
-  });
-
-  it('skips missing agents', () => {
-    const available = new Set(['rain', 'snow']);
-    const result = pickAgentForGoal('做安全审查', available);
-    expect(available.has(result)).toBe(true);
-  });
-
-  it('single agent available', () => {
-    expect(pickAgentForGoal('anything', new Set(['rain']))).toBe('rain');
-  });
-});
+/**
+ * Tests for the complexity router.
+ */
+import { describe, it, expect } from 'vitest';
+import { classify, pickAgentForGoal } from '../src/core/router';
+
+describe('classify', () => {
+  it.each([
+    '你好',
+    'hi',
+    '在吗',
+    '谢谢',
+    '什么是 RAG?',
+    '为什么天空是蓝的？',
+    '1 + 1 = ?',
+    '解释一下闭包',
+  ])('returns "direct" for simple questions: %s', (goal) => {
+    expect(classify(goal)).toBe('direct');
+  });
+
+  it.each([
+    '帮我写一个二分查找函数',
+    '搜一下今天的天气',
+    '审查 src/foo.py 的安全问题',
+    '把这段中文翻译成英文：我喜欢猫',
+  ])('returns "single" for focused tasks: %s', (goal) => {
+    expect(classify(goal)).toBe('single');
+  });
+
+  it.each([
+    '先帮我分析这段代码，然后重构它，最后写测试',
+    '首先调研一下市场上有哪些方案，其次对比性能，最后给出推荐',
+    '1. 创建数据库迁移\n2. 写 API\n3. 加测试\n4. 部署',
+  ])('returns "orchestrate" for multi-step: %s', (goal) => {
+    expect(classify(goal)).toBe('orchestrate');
+  });
+
+  it('empty goal returns direct', () => {
+    expect(classify('')).toBe('direct');
+    expect(classify('   ')).toBe('direct');
+  });
+
+  it('inline enumerated list is orchestrate', () => {
+    expect(classify('1. 拉数据 2. 分析 3. 出图')).toBe('orchestrate');
+    expect(classify('先做 1. xxx 2. yyy 3. zzz 4. www')).toBe('orchestrate');
+  });
+
+  it('two inline items is not orchestrate', () => {
+    expect(classify('1. 你好 2. 谢谢')).not.toBe('orchestrate');
+  });
+});
+
+describe('pickAgentForGoal', () => {
+  const allAgents = new Set(['fog', 'rain', 'frost', 'snow', 'dew', 'fair']);
+
+  it('security keyword picks frost', () => {
+    expect(pickAgentForGoal('帮我做安全审查', allAgents)).toBe('frost');
+  });
+
+  it('research keyword picks fog', () => {
+    expect(pickAgentForGoal('搜一下最新的 React 文档', allAgents)).toBe('fog');
+  });
+
+  it('greeting picks fair', () => {
+    expect(pickAgentForGoal('你好啊', allAgents)).toBe('fair');
+  });
+
+  it('falls back to rain', () => {
+    expect(pickAgentForGoal('处理这个东西', allAgents)).toBe('rain');
+  });
+
+  it('binary search picks rain not fog', () => {
+    expect(pickAgentForGoal('帮我写一个二分查找', allAgents)).toBe('rain');
+    expect(pickAgentForGoal('实现一个排序函数', allAgents)).toBe('rain');
+  });
+
+  it('skips missing agents', () => {
+    const available = new Set(['rain', 'snow']);
+    const result = pickAgentForGoal('做安全审查', available);
+    expect(available.has(result)).toBe(true);
+  });
+
+  it('single agent available', () => {
+    expect(pickAgentForGoal('anything', new Set(['rain']))).toBe('rain');
+  });
+});