oh-pi 0.1.69 → 0.1.71

package/pi-package/extensions/ant-colony/index.ts

@@ -18,10 +18,19 @@ import { runColony, resumeColony, type QueenCallbacks } from "./queen.js";
 import { Nest } from "./nest.js";
 import type { ColonyState, ColonyMetrics, AntStreamEvent } from "./types.js";
 
-import { formatDuration, formatCost, formatTokens, statusIcon, casteIcon } from "./ui.js";
+import { formatDuration, formatCost, formatTokens, statusIcon, casteIcon, buildReport } from "./ui.js";
 
 // ═══ Background colony state ═══
 
+/** Ensure .ant-colony/ is in .gitignore */
+function ensureGitignore(cwd: string) {
+  const gitignorePath = join(cwd, ".gitignore");
+  const content = existsSync(gitignorePath) ? readFileSync(gitignorePath, "utf-8") : "";
+  if (!content.includes(".ant-colony/")) {
+    appendFileSync(gitignorePath, `${content.length && !content.endsWith("\n") ? "\n" : ""}.ant-colony/\n`);
+  }
+}
+
 interface AntStreamState {
   antId: string;
   caste: string;
@@ -42,6 +51,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
 
   // 当前运行中的后台蚁群（同时只允许一个）
   let activeColony: BackgroundColony | null = null;
+  let uiListenersRegistered = false;
 
   // ─── Status 渲染 ───
 
@@ -55,6 +65,9 @@ export default function antColonyExtension(pi: ExtensionAPI) {
 
   // 监听事件来更新 UI（确保在有 ctx 的上下文中）
   pi.on("session_start", async (_event, ctx) => {
+    if (uiListenersRegistered) return;
+    uiListenersRegistered = true;
+
     pi.events.on("ant-colony:render", () => {
       if (!activeColony) return;
       const { state } = activeColony;
@@ -89,11 +102,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
     cwd: string;
     modelRegistry?: any;
   }, signal?: AbortSignal | null) {
-    const gitignorePath = join(params.cwd, ".gitignore");
-    const gitContent = existsSync(gitignorePath) ? readFileSync(gitignorePath, "utf-8") : "";
-    if (!gitContent.includes(".ant-colony/")) {
-      appendFileSync(gitignorePath, `${gitContent.length && !gitContent.endsWith("\n") ? "\n" : ""}.ant-colony/\n`);
-    }
+    ensureGitignore(params.cwd);
 
     const callbacks: QueenCallbacks = {};
 
@@ -110,24 +119,8 @@ export default function antColonyExtension(pi: ExtensionAPI) {
         modelRegistry: params.modelRegistry,
       });
 
-      const m = state.metrics;
-      const elapsed = state.finishedAt ? formatDuration(state.finishedAt - state.createdAt) : "?";
-      const report = [
-        `## 🐜 Ant Colony Report`,
-        `**Goal:** ${state.goal}`,
-        `**Status:** ${statusIcon(state.status)} ${state.status} │ ${elapsed} │ ${formatCost(m.totalCost)}`,
-        `**Tasks:** ${m.tasksDone}/${m.tasksTotal} done${m.tasksFailed > 0 ? `, ${m.tasksFailed} failed` : ""}`,
-        ``,
-        ...state.tasks.filter(t => t.status === "done").map(t =>
-          `- ✓ **${t.title}**`
-        ),
-        ...state.tasks.filter(t => t.status === "failed").map(t =>
-          `- ✗ **${t.title}** — ${t.error?.slice(0, 80) || "unknown"}`
-        ),
-      ].join("\n");
-
       return {
-        content: [{ type: "text" as const, text: report }],
+        content: [{ type: "text" as const, text: buildReport(state) }],
         isError: state.status === "failed" || state.status === "budget_exceeded",
       };
     } catch (e) {
@@ -226,11 +219,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
     };
 
     // Ensure .ant-colony/ is in .gitignore
-    const gitignorePath = join(params.cwd, ".gitignore");
-    const gitContent = existsSync(gitignorePath) ? readFileSync(gitignorePath, "utf-8") : "";
-    if (!gitContent.includes(".ant-colony/")) {
-      appendFileSync(gitignorePath, `${gitContent.length && !gitContent.endsWith("\n") ? "\n" : ""}.ant-colony/\n`);
-    }
+    ensureGitignore(params.cwd);
 
     const colonyOpts = {
       cwd: params.cwd,
@@ -251,23 +240,9 @@ export default function antColonyExtension(pi: ExtensionAPI) {
 
     // 后台等待完成，注入结果
     colony.promise.then((state) => {
-      const m = state.metrics;
-      const elapsed = state.finishedAt ? formatDuration(state.finishedAt - state.createdAt) : "?";
       const ok = state.status === "done";
-
-      const report = [
-        `## 🐜 Ant Colony Report`,
-        `**Goal:** ${state.goal}`,
-        `**Status:** ${statusIcon(state.status)} ${state.status} │ ${elapsed} │ ${formatCost(m.totalCost)}`,
-        `**Tasks:** ${m.tasksDone}/${m.tasksTotal} done${m.tasksFailed > 0 ? `, ${m.tasksFailed} failed` : ""}`,
-        ``,
-        ...state.tasks.filter(t => t.status === "done").map(t =>
-          `- ✓ **${t.title}**`
-        ),
-        ...state.tasks.filter(t => t.status === "failed").map(t =>
-          `- ✗ **${t.title}** — ${t.error?.slice(0, 80) || "unknown"}`
-        ),
-      ].join("\n");
+      const report = buildReport(state);
+      const m = state.metrics;
 
       // 清理 UI
       pi.events.emit("ant-colony:clear-ui");
@@ -594,6 +569,14 @@ export default function antColonyExtension(pi: ExtensionAPI) {
   pi.on("session_shutdown", async () => {
     if (activeColony) {
       activeColony.abortController.abort();
+      // Wait for colony to finish gracefully (max 5s)
+      try {
+        await Promise.race([
+          activeColony.promise,
+          new Promise(r => setTimeout(r, 5000)),
+        ]);
+      } catch { /* ignore */ }
+      pi.events.emit("ant-colony:clear-ui");
       activeColony = null;
     }
   });

package/pi-package/extensions/ant-colony/nest.ts

@@ -22,6 +22,9 @@ export class Nest {
   private pheromoneOffset: number = 0;
   private taskCache: Map<string, Task> = new Map();
   private stateCache: ColonyState | null = null;
+  private gcCounter: number = 0;
+  private pheromoneByFile: Map<string, Pheromone[]> = new Map();
+  private pheromoneIndexDirty: boolean = true;
 
   constructor(private cwd: string, private colonyId: string) {
     this.dir = path.join(cwd, ".ant-colony", colonyId);
@@ -51,6 +54,14 @@ export class Nest {
     return base;
   }
 
+  /** 轻量版 getState：只返回 stateCache + tasks，不触发 pheromone 读取 */
+  getStateLight(): ColonyState {
+    if (!this.stateCache) {
+      this.stateCache = this.readJson<ColonyState>(this.stateFile);
+    }
+    return { ...this.stateCache, tasks: this.getAllTasks() };
+  }
+
   updateState(patch: Partial<Pick<ColonyState, "status" | "concurrency" | "metrics" | "ants" | "finishedAt">>): void {
     this.withStateLock(() => {
       if (!this.stateCache) {
@@ -90,12 +101,50 @@ export class Nest {
   }
 
   claimTask(taskId: string, antId: string): boolean {
-    const task = this.getTask(taskId);
-    if (!task || task.status !== "pending") return false;
-    task.status = "claimed";
-    task.claimedBy = antId;
-    this.writeTask(task);
-    return true;
+    return this.withStateLock(() => {
+      const task = this.getTask(taskId);
+      if (!task || task.status !== "pending") return false;
+      task.status = "claimed";
+      task.claimedBy = antId;
+      this.writeTask(task);
+      return true;
+    });
+  }
+
+  /** 原子选取并 claim 下一个任务，消灭 nextPendingTask+claimTask 之间的竞态窗口 */
+  claimNextTask(caste: "scout" | "worker" | "soldier" | "drone", antId: string): Task | null {
+    return this.withStateLock(() => {
+      const tasks = this.getAllTasks().filter(t => t.status === "pending" && t.caste === caste);
+      if (tasks.length === 0) return null;
+
+      this.getAllPheromones();
+      let chosen: Task;
+      if (tasks.length > 1 && Math.random() < 0.1) {
+        chosen = tasks[Math.floor(Math.random() * tasks.length)];
+      } else {
+        const scored = tasks.map(t => {
+          let pScore = 0;
+          const seen = new Set<Pheromone>();
+          for (const f of t.files) {
+            for (const p of this.pheromoneByFile.get(f) ?? []) {
+              if (seen.has(p) || p.strength <= 0.1) continue;
+              seen.add(p);
+              if (p.type === "discovery" || p.type === "completion") pScore += p.strength;
+              else if (p.type === "repellent") pScore -= p.strength * 3;
+              else if (p.type === "warning") pScore -= p.strength;
+            }
+          }
+          return { task: t, score: (6 - t.priority) + pScore };
+        });
+        scored.sort((a, b) => b.score - a.score);
+        chosen = scored[0].task;
+      }
+
+      chosen.status = "claimed";
+      chosen.claimedBy = antId;
+      this.writeTask(chosen);
+      return chosen;
+    });
   }
 
   updateTaskStatus(taskId: string, status: TaskStatus, result?: string, error?: string): void {
@@ -118,37 +167,11 @@ export class Nest {
     }
   }
 
-  /** 获取下一个可领取的任务（按优先级 + 信息素强度 - repellent负信息素排序，ε-greedy 随机觅食） */
-  nextPendingTask(caste: "scout" | "worker" | "soldier"): Task | null {
-    const tasks = this.getAllTasks()
-      .filter(t => t.status === "pending" && t.caste === caste);
-    if (tasks.length === 0) return null;
-
-    // ε-greedy：10% 概率随机选任务，避免蚂蚁全挤同一条路
-    if (tasks.length > 1 && Math.random() < 0.1) {
-      return tasks[Math.floor(Math.random() * tasks.length)];
-    }
-
-    // 信息素加权：discovery/completion 加分，warning/repellent 减分（负信息素）
-    const pheromones = this.getAllPheromones();
-    const scored = tasks.map(t => {
-      let pScore = 0;
-      for (const p of pheromones) {
-        if (!p.files.some(f => t.files.includes(f)) || p.strength <= 0.1) continue;
-        if (p.type === "discovery" || p.type === "completion") pScore += p.strength;
-        else if (p.type === "repellent") pScore -= p.strength * 3;  // repellent 负信息素惩罚最重
-        else if (p.type === "warning") pScore -= p.strength;
-      }
-      return { task: t, score: (6 - t.priority) + pScore };
-    });
-    scored.sort((a, b) => b.score - a.score);
-    return scored[0]?.task ?? null;
-  }
-
   // ═══ Pheromones ═══
 
   dropPheromone(p: Pheromone): void {
     fs.appendFileSync(this.pheromoneFile, JSON.stringify(p) + "\n");
+    this.pheromoneIndexDirty = true;
   }
 
   getAllPheromones(): Pheromone[] {
@@ -171,10 +194,36 @@ export class Nest {
     }
 
     // 衰减 + 过滤弱信息素
+    const beforeLen = this.pheromoneCache.length;
     this.pheromoneCache = this.pheromoneCache.filter(p => {
-      p.strength = p.strength * Math.pow(0.5, (now - p.createdAt) / HALF_LIFE);
+      p.strength = Math.pow(0.5, (now - p.createdAt) / HALF_LIFE);
       return p.strength > 0.05;
     });
+    const hadGarbage = this.pheromoneCache.length < beforeLen;
+    if (hadGarbage) this.pheromoneIndexDirty = true;
+
+    // 重建文件索引（仅在 dirty 时）
+    if (this.pheromoneIndexDirty) {
+      this.pheromoneByFile.clear();
+      for (const p of this.pheromoneCache) {
+        for (const f of p.files) {
+          let arr = this.pheromoneByFile.get(f);
+          if (!arr) { arr = []; this.pheromoneByFile.set(f, arr); }
+          arr.push(p);
+        }
+      }
+      this.pheromoneIndexDirty = false;
+    }
+
+    // GC：每 10 次调用，若有弱条目被过滤则重写文件
+    this.gcCounter++;
+    if (this.gcCounter >= 10 && hadGarbage) {
+      this.gcCounter = 0;
+      const tmp = this.pheromoneFile + ".tmp";
+      fs.writeFileSync(tmp, this.pheromoneCache.map(p => JSON.stringify(p)).join("\n") + (this.pheromoneCache.length ? "\n" : ""));
+      fs.renameSync(tmp, this.pheromoneFile);
+      this.pheromoneOffset = fs.statSync(this.pheromoneFile).size;
+    }
 
     return this.pheromoneCache;
   }
@@ -230,23 +279,29 @@ export class Nest {
 
   private withStateLock<T>(fn: () => T): T {
     const MAX_WAIT = 3000;
-    const SPIN_MS = 1;
+    const SPIN_MS = 5;
     const start = Date.now();
     while (true) {
       try {
-        fs.writeFileSync(this.lockFile, `${process.pid}`, { flag: "wx" });
+        fs.writeFileSync(this.lockFile, `${process.pid}:${Date.now()}`, { flag: "wx" });
         break;
       } catch {
         if (Date.now() - start > MAX_WAIT) {
-          // 超时：检查锁持有者是否存活
           try {
-            const holder = parseInt(fs.readFileSync(this.lockFile, "utf-8"), 10);
-            try { process.kill(holder, 0); } catch { /* 进程已死，清除死锁 */ fs.unlinkSync(this.lockFile); continue; }
-          } catch { /* 读取失败，强制清除 */ try { fs.unlinkSync(this.lockFile); } catch {} }
-          continue;
+            const content = fs.readFileSync(this.lockFile, "utf-8");
+            const [pidStr, tsStr] = content.split(":");
+            const holder = parseInt(pidStr, 10);
+            const lockTime = parseInt(tsStr, 10);
+            // 超过 30s 的锁视为过期
+            if (lockTime && Date.now() - lockTime > 30_000) { fs.unlinkSync(this.lockFile); continue; }
+            // 进程存活检查作为第二道防线
+            try { process.kill(holder, 0); } catch { fs.unlinkSync(this.lockFile); continue; }
+          } catch { try { fs.unlinkSync(this.lockFile); } catch {} }
+          // 进程存活且锁未过期，放弃等待
+          throw new Error(`[Nest] withStateLock timeout after ${MAX_WAIT}ms`);
         }
-        // 简单 busy-wait，避免 SharedArrayBuffer 依赖
-        const until = Date.now() + SPIN_MS + Math.random() * SPIN_MS;
+        // 简单 busy-wait + jitter，避免 SharedArrayBuffer 依赖
+        const until = Date.now() + SPIN_MS + Math.random() * SPIN_MS * 2;
         while (Date.now() < until) { /* spin */ }
       }
     }
@@ -294,5 +349,13 @@ export class Nest {
         this.writeTask(task);
       }
     }
+    // 将 orphaned working/idle ants 标记为 failed
+    for (const ant of this.stateCache.ants) {
+      if (ant.status === "working" || ant.status === "idle") {
+        ant.status = "failed";
+        ant.finishedAt = Date.now();
+      }
+    }
+    this.writeJson(this.stateFile, this.stateCache);
   }
 }

package/pi-package/extensions/ant-colony/parser.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect, vi } from "vitest";
+
+vi.mock("@mariozechner/pi-coding-agent", () => ({
+  AuthStorage: class {},
+  createAgentSession: vi.fn(),
+  createReadTool: vi.fn(), createBashTool: vi.fn(), createEditTool: vi.fn(),
+  createWriteTool: vi.fn(), createGrepTool: vi.fn(), createFindTool: vi.fn(),
+  createLsTool: vi.fn(), ModelRegistry: class {}, SessionManager: { inMemory: vi.fn() },
+  SettingsManager: { inMemory: vi.fn() }, createExtensionRuntime: vi.fn(),
+}));
+vi.mock("@mariozechner/pi-ai", () => ({ getModel: vi.fn() }));
+vi.mock("./spawner.js", async () => {
+  const actual = await vi.importActual<any>("./spawner.js");
+  return { ...actual, makePheromoneId: () => "p-test" };
+});
+
+import { parseSubTasks, extractPheromones } from "./parser.js";
+
+describe("parseSubTasks", () => {
+  it("parses markdown TASK blocks", () => {
+    const output = `## Recommended Tasks
+### TASK: Fix login
+- description: Fix the login bug
+- files: src/auth.ts
+- caste: worker
+- priority: 2`;
+    const tasks = parseSubTasks(output);
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0].title).toBe("Fix login");
+    expect(tasks[0].description).toBe("Fix the login bug");
+    expect(tasks[0].files).toEqual(["src/auth.ts"]);
+    expect(tasks[0].caste).toBe("worker");
+    expect(tasks[0].priority).toBe(2);
+  });
+
+  it("parses JSON block", () => {
+    const output = '```json\n[{"title":"Task A","description":"Do A","files":["a.ts"],"caste":"scout","priority":1}]\n```';
+    const tasks = parseSubTasks(output);
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0].title).toBe("Task A");
+    expect(tasks[0].caste).toBe("scout");
+  });
+
+  it("defaults caste to worker for invalid", () => {
+    const tasks = parseSubTasks('```json\n[{"title":"X","caste":"invalid"}]\n```');
+    expect(tasks[0].caste).toBe("worker");
+  });
+
+  it("defaults priority to 3", () => {
+    const tasks = parseSubTasks('```json\n[{"title":"X"}]\n```');
+    expect(tasks[0].priority).toBe(3);
+  });
+
+  it("returns empty for no tasks", () => {
+    expect(parseSubTasks("no tasks here")).toEqual([]);
+  });
+
+  it("parses multiple markdown tasks", () => {
+    const output = `### TASK: A
+- description: Do A
+- files: a.ts
+- caste: worker
+- priority: 1
+
+### TASK: B
+- description: Do B
+- files: b.ts
+- caste: soldier
+- priority: 2`;
+    const tasks = parseSubTasks(output);
+    expect(tasks).toHaveLength(2);
+  });
+
+  it("parses context field", () => {
+    const output = `### TASK: Fix it
+- description: Fix bug
+- files: x.ts
+- caste: worker
+- priority: 3
+- context: some relevant code`;
+    const tasks = parseSubTasks(output);
+    expect(tasks[0].context).toBeTruthy();
+  });
+});
+
+describe("extractPheromones", () => {
+  it("extracts discovery section", () => {
+    const p = extractPheromones("ant-1", "scout", "t-1", "## Discoveries\n- Found auth\n\n## Other\nstuff", ["a.ts"]);
+    expect(p.some(x => x.type === "discovery")).toBe(true);
+  });
+
+  it("extracts warning section", () => {
+    const p = extractPheromones("ant-1", "scout", "t-1", "## Warnings\n- Conflict\n", []);
+    expect(p.some(x => x.type === "warning")).toBe(true);
+  });
+
+  it("adds repellent on failure", () => {
+    const p = extractPheromones("ant-1", "worker", "t-1", "output", ["a.ts"], true);
+    expect(p.some(x => x.type === "repellent")).toBe(true);
+  });
+
+  it("returns empty for no matching sections", () => {
+    expect(extractPheromones("ant-1", "worker", "t-1", "nothing", [])).toEqual([]);
+  });
+
+  it("extracts Files Changed as completion", () => {
+    const p = extractPheromones("ant-1", "worker", "t-1", "## Files Changed\n- src/foo.ts\n", ["src/foo.ts"]);
+    expect(p.some(x => x.type === "completion")).toBe(true);
+  });
+});

package/pi-package/extensions/ant-colony/parser.ts

@@ -1,6 +1,8 @@
 import type { AntCaste, Pheromone, PheromoneType } from "./types.js";
 import { makePheromoneId } from "./spawner.js";
 
+const VALID_CASTES = new Set(["scout", "worker", "soldier", "drone"]);
+
 export interface ParsedSubTask {
   title: string;
   description: string;
@@ -11,21 +13,41 @@ export interface ParsedSubTask {
 }
 
 export function parseSubTasks(output: string): ParsedSubTask[] {
+  // Try JSON block first
+  const jsonMatch = output.match(/```json\s*([\s\S]*?)```/);
+  if (jsonMatch?.[1]) {
+    try {
+      const parsed = JSON.parse(jsonMatch[1].trim());
+      const arr = Array.isArray(parsed) ? parsed : [parsed];
+      return arr.map((t: Record<string, unknown>) => ({
+        title: String(t.title || "Untitled"),
+        description: String(t.description || t.title || ""),
+        files: Array.isArray(t.files) ? t.files.map(String) : String(t.files || "").split(",").map((f: string) => f.trim()).filter(Boolean),
+        caste: (VALID_CASTES.has(String(t.caste)) ? String(t.caste) : "worker") as AntCaste,
+        priority: (Math.min(5, Math.max(1, parseInt(String(t.priority || "3")))) as 1 | 2 | 3 | 4 | 5),
+        context: t.context ? String(t.context) : undefined,
+      }));
+    } catch { /* fallback to regex */ }
+  }
+
+  // Fallback: regex parsing with per-task try-catch
   const tasks: ParsedSubTask[] = [];
   const regex = /### TASK:\s*(.+)\n(?:- description:\s*(.+)\n)?(?:- files:\s*(.+)\n)?(?:- caste:\s*(\w+)\n)?(?:- priority:\s*(\d))?/g;
   const taskBlocks = output.split(/(?=### TASK:)/);
   for (const m of output.matchAll(regex)) {
-    const block = taskBlocks.find(b => b.includes(`### TASK: ${m[1]?.trim()}`)) || "";
-    const ctxMatch = block.match(/- context:\s*([\s\S]*?)(?=### TASK:|## |\n\n|$)/);
-    const context = ctxMatch?.[1]?.trim() || undefined;
-    tasks.push({
-      title: m[1]?.trim() || "Untitled",
-      description: m[2]?.trim() || m[1]?.trim() || "",
-      files: (m[3]?.trim() || "").split(",").map((f: string) => f.trim()).filter(Boolean),
-      caste: (m[4]?.trim() as AntCaste) || "worker",
-      priority: (parseInt(m[5] || "3") as 1 | 2 | 3 | 4 | 5) || 3,
-      context,
-    });
+    try {
+      const block = taskBlocks.find(b => b.includes(`### TASK: ${m[1]?.trim()}`)) || "";
+      const ctxMatch = block.match(/- context:\s*([\s\S]*?)(?=### TASK:|## |\n\n|$)/);
+      const context = ctxMatch?.[1]?.trim() || undefined;
+      tasks.push({
+        title: m[1]?.trim() || "Untitled",
+        description: m[2]?.trim() || m[1]?.trim() || "",
+        files: (m[3]?.trim() || "").split(",").map((f: string) => f.trim()).filter(Boolean),
+        caste: (VALID_CASTES.has(m[4]?.trim() ?? "") ? m[4]!.trim() : "worker") as AntCaste,
+        priority: (parseInt(m[5] || "3") as 1 | 2 | 3 | 4 | 5) || 3,
+        context,
+      });
+    } catch { /* skip malformed task, continue */ }
   }
   return tasks;
 }
@@ -35,7 +57,7 @@ export function extractPheromones(antId: string, caste: AntCaste, taskId: string
   const now = Date.now();
   const sections = ["Discoveries", "Pheromone", "Files Changed", "Warnings", "Review"];
   for (const section of sections) {
-    const regex = new RegExp(`## ${section}\\n([\\s\\S]*?)(?=\\n## |$)`, "i");
+    const regex = new RegExp(`#{1,2} ${section}\\n([\\s\\S]*?)(?=\\n#{1,2} |$)`, "i");
     const match = output.match(regex);
     if (match?.[1]?.trim()) {
       const type: PheromoneType =

package/pi-package/extensions/ant-colony/prompts.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from "vitest";
+import { CASTE_PROMPTS, buildPrompt } from "./prompts.js";
+import type { Task } from "./types.js";
+
+const mkTask = (overrides: Partial<Task> = {}): Task => ({
+  id: "t-1", parentId: null, title: "Test task", description: "Do something",
+  caste: "worker", status: "pending", priority: 3, files: [], claimedBy: null,
+  result: null, error: null, spawnedTasks: [], createdAt: 0, startedAt: null, finishedAt: null,
+  ...overrides,
+});
+
+describe("CASTE_PROMPTS", () => {
+  it("has all castes", () => {
+    for (const c of ["scout", "worker", "soldier"] as const) {
+      expect(typeof CASTE_PROMPTS[c]).toBe("string");
+      expect(CASTE_PROMPTS[c].length).toBeGreaterThan(0);
+    }
+  });
+});
+
+describe("buildPrompt", () => {
+  it("includes task title and description", () => {
+    const r = buildPrompt(mkTask(), "", "System");
+    expect(r).toContain("Test task");
+    expect(r).toContain("Do something");
+  });
+
+  it("includes pheromone context", () => {
+    const r = buildPrompt(mkTask(), "Found auth at src/auth.ts", "System");
+    expect(r).toContain("Found auth at src/auth.ts");
+  });
+
+  it("includes files scope", () => {
+    const r = buildPrompt(mkTask({ files: ["a.ts", "b.ts"] }), "", "System");
+    expect(r).toContain("a.ts, b.ts");
+  });
+
+  it("includes turn limit when provided", () => {
+    const r = buildPrompt(mkTask(), "", "System", 10);
+    expect(r).toContain("10");
+    expect(r).toContain("Turn Limit");
+  });
+
+  it("omits turn limit when not provided", () => {
+    expect(buildPrompt(mkTask(), "", "System")).not.toContain("Turn Limit");
+  });
+
+  it("includes pre-loaded context", () => {
+    const r = buildPrompt(mkTask({ context: "code snippet" }), "", "System");
+    expect(r).toContain("code snippet");
+  });
+
+  it("adds Chinese hint for Chinese descriptions", () => {
+    const r = buildPrompt(mkTask({ description: "修复登录问题" }), "", "System");
+    expect(r).toContain("Chinese");
+  });
+});