oh-pi 0.1.71 → 0.1.73

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-pi",
-  "version": "0.1.71",
+  "version": "0.1.73",
   "description": "One-click setup for pi-coding-agent. Like oh-my-zsh for pi.",
   "type": "module",
   "bin": {

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

@@ -0,0 +1,130 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { Nest } from "./nest.js";
+import type { ColonyState, Pheromone } from "./types.js";
+
+const mkState = (overrides: Partial<ColonyState> = {}): ColonyState => ({
+  id: "test-colony", goal: "test", status: "working",
+  tasks: [], ants: [], pheromones: [],
+  concurrency: { current: 2, min: 1, max: 4, optimal: 3, history: [] },
+  metrics: { tasksTotal: 0, tasksDone: 0, tasksFailed: 0, antsSpawned: 0, totalCost: 0, totalTokens: 0, startTime: Date.now(), throughputHistory: [] },
+  maxCost: null, modelOverrides: {}, createdAt: Date.now(), finishedAt: null,
+  ...overrides,
+});
+
+const mkPheromone = (overrides: Partial<Pheromone> = {}): Pheromone => ({
+  id: `p-${Math.random().toString(36).slice(2)}`, type: "warning", antId: "ant-1", antCaste: "worker",
+  taskId: "t-1", content: "test", files: ["a.ts"], strength: 1.0, createdAt: Date.now(),
+  ...overrides,
+});
+
+let tmpDir: string;
+let nest: Nest;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "nest-test-"));
+  nest = new Nest(tmpDir, "test-colony");
+  nest.init(mkState());
+});
+
+afterEach(() => {
+  try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+describe("getStateLight", () => {
+  it("returns state without triggering pheromone read", () => {
+    nest.dropPheromone(mkPheromone());
+    const light = nest.getStateLight();
+    expect(light.id).toBe("test-colony");
+    expect(light.tasks).toEqual([]);
+    // pheromones should not be populated by getStateLight
+    // (it returns stateCache which has empty pheromones from init)
+  });
+
+  it("includes tasks from cache", () => {
+    nest.writeTask({
+      id: "t-1", parentId: null, title: "Test", description: "desc",
+      caste: "worker", status: "pending", priority: 3, files: [],
+      claimedBy: null, result: null, error: null, spawnedTasks: [],
+      createdAt: Date.now(), startedAt: null, finishedAt: null,
+    });
+    const light = nest.getStateLight();
+    expect(light.tasks).toHaveLength(1);
+    expect(light.tasks[0].id).toBe("t-1");
+  });
+});
+
+describe("countWarnings", () => {
+  it("returns 0 when no pheromones", () => {
+    expect(nest.countWarnings(["a.ts"])).toBe(0);
+  });
+
+  it("counts warning pheromones for matching files", () => {
+    nest.dropPheromone(mkPheromone({ type: "warning", files: ["a.ts"] }));
+    nest.dropPheromone(mkPheromone({ type: "warning", files: ["a.ts"] }));
+    nest.dropPheromone(mkPheromone({ type: "completion", files: ["a.ts"] }));
+    expect(nest.countWarnings(["a.ts"])).toBe(2);
+  });
+
+  it("counts repellent pheromones", () => {
+    nest.dropPheromone(mkPheromone({ type: "repellent", files: ["b.ts"] }));
+    expect(nest.countWarnings(["b.ts"])).toBe(1);
+  });
+
+  it("returns 0 for unrelated files", () => {
+    nest.dropPheromone(mkPheromone({ type: "warning", files: ["a.ts"] }));
+    expect(nest.countWarnings(["c.ts"])).toBe(0);
+  });
+});
+
+describe("pheromone dirty flag", () => {
+  it("rebuilds index after dropPheromone", () => {
+    nest.dropPheromone(mkPheromone({ type: "discovery", files: ["x.ts"] }));
+    const pheromones = nest.getAllPheromones();
+    expect(pheromones.length).toBe(1);
+    expect(pheromones[0].type).toBe("discovery");
+  });
+
+  it("does not rebuild index when nothing changed", () => {
+    nest.dropPheromone(mkPheromone({ files: ["x.ts"] }));
+    nest.getAllPheromones(); // builds index, clears dirty
+    // Second call should use cached index (no new data, no GC)
+    const p2 = nest.getAllPheromones();
+    expect(p2.length).toBe(1);
+  });
+});
+
+describe("claimNextTask", () => {
+  it("claims highest scored pending task", () => {
+    nest.writeTask({
+      id: "t-low", parentId: null, title: "Low", description: "",
+      caste: "worker", status: "pending", priority: 5, files: [],
+      claimedBy: null, result: null, error: null, spawnedTasks: [],
+      createdAt: Date.now(), startedAt: null, finishedAt: null,
+    });
+    nest.writeTask({
+      id: "t-high", parentId: null, title: "High", description: "",
+      caste: "worker", status: "pending", priority: 1, files: [],
+      claimedBy: null, result: null, error: null, spawnedTasks: [],
+      createdAt: Date.now(), startedAt: null, finishedAt: null,
+    });
+    const claimed = nest.claimNextTask("worker", "ant-1");
+    expect(claimed).not.toBeNull();
+    expect(claimed!.id).toBe("t-high");
+    expect(claimed!.status).toBe("claimed");
+  });
+
+  it("returns null when no pending tasks", () => {
+    expect(nest.claimNextTask("worker", "ant-1")).toBeNull();
+  });
+});
+
+describe("withStateLock spin", () => {
+  it("updateState works under normal conditions", () => {
+    nest.updateState({ status: "reviewing" });
+    const state = nest.getStateLight();
+    expect(state.status).toBe("reviewing");
+  });
+});

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

@@ -228,6 +228,18 @@ export class Nest {
     return this.pheromoneCache;
   }
 
+  /** 统计指定文件相关的 warning/repellent 信息素数量 */
+  countWarnings(files: string[]): number {
+    this.getAllPheromones();
+    let count = 0;
+    for (const f of files) {
+      for (const p of this.pheromoneByFile.get(f) ?? []) {
+        if (p.type === "warning" || p.type === "repellent") count++;
+      }
+    }
+    return count;
+  }
+
   /** 读取与特定文件相关的信息素摘要 */
   getPheromoneContext(files: string[], limit = 20): string {
     const relevant = this.getAllPheromones()

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

@@ -54,4 +54,46 @@ describe("buildPrompt", () => {
     const r = buildPrompt(mkTask({ description: "修复登录问题" }), "", "System");
     expect(r).toContain("Chinese");
   });
+
+  // Bio 3: 串联觅食 — tandem context
+  it("includes tandem parent result when provided", () => {
+    const r = buildPrompt(mkTask(), "", "System", 10, { parentResult: "Parent found auth module at src/auth.ts" });
+    expect(r).toContain("Tandem Context");
+    expect(r).toContain("Parent found auth module");
+  });
+
+  it("includes tandem prior error when provided", () => {
+    const r = buildPrompt(mkTask(), "", "System", 10, { priorError: "TypeError: cannot read property" });
+    expect(r).toContain("Prior Attempt Failed");
+    expect(r).toContain("TypeError: cannot read property");
+  });
+
+  it("includes both tandem fields when provided", () => {
+    const r = buildPrompt(mkTask(), "", "System", 10, {
+      parentResult: "Scout found files",
+      priorError: "Build failed",
+    });
+    expect(r).toContain("Tandem Context");
+    expect(r).toContain("Prior Attempt Failed");
+  });
+
+  it("omits tandem sections when not provided", () => {
+    const r = buildPrompt(mkTask(), "", "System", 10);
+    expect(r).not.toContain("Tandem Context");
+    expect(r).not.toContain("Prior Attempt Failed");
+  });
+
+  it("omits tandem sections when empty object", () => {
+    const r = buildPrompt(mkTask(), "", "System", 10, {});
+    expect(r).not.toContain("Tandem Context");
+    expect(r).not.toContain("Prior Attempt Failed");
+  });
+
+  it("truncates long parent result", () => {
+    const longResult = "x".repeat(5000);
+    const r = buildPrompt(mkTask(), "", "System", 10, { parentResult: longResult });
+    expect(r).toContain("Tandem Context");
+    // Should be truncated to 3000 chars
+    expect(r.length).toBeLessThan(longResult.length);
+  });
 });

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

@@ -76,7 +76,7 @@ Output format (MUST follow exactly):
 PASS or FAIL with summary.`,
 };
 
-export function buildPrompt(task: Task, pheromoneContext: string, castePrompt: string, maxTurns?: number): string {
+export function buildPrompt(task: Task, pheromoneContext: string, castePrompt: string, maxTurns?: number, tandem?: { parentResult?: string; priorError?: string }): string {
   let prompt = castePrompt + "\n\n";
   if (maxTurns) {
     prompt += `## ⚠️ Turn Limit\nYou have a MAXIMUM of ${maxTurns} turns. Plan accordingly — reserve your LAST turn to output the structured result format above. Do NOT waste turns on unnecessary exploration.\n\n`;
@@ -84,6 +84,12 @@ export function buildPrompt(task: Task, pheromoneContext: string, castePrompt: s
   if (pheromoneContext) {
     prompt += `## Colony Pheromone Trail (intelligence from other ants)\n${pheromoneContext}\n\n`;
   }
+  if (tandem?.parentResult) {
+    prompt += `## Tandem Context (from parent task)\n${tandem.parentResult.slice(0, 3000)}\n\n`;
+  }
+  if (tandem?.priorError) {
+    prompt += `## ⚠️ Prior Attempt Failed\nA previous ant failed on this task. Learn from their mistake:\n${tandem.priorError.slice(0, 1500)}\n\n`;
+  }
   prompt += `## Your Assignment\n**Task:** ${task.title}\n**Description:** ${task.description}\n`;
   if (task.files.length > 0) {
     prompt += `**Files scope:** ${task.files.join(", ")}\n`;

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

@@ -0,0 +1,193 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+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() }));
+
+import { classifyError, quorumMergeTasks } from "./queen.js";
+import { Nest } from "./nest.js";
+import type { ColonyState, Task } from "./types.js";
+
+// ═══ classifyError ═══
+
+describe("classifyError", () => {
+  it("classifies TypeError", () => {
+    expect(classifyError("TypeError: cannot read property 'x'")).toBe("type_error");
+  });
+
+  it("classifies TS errors", () => {
+    expect(classifyError("TS2345: Argument of type")).toBe("type_error");
+  });
+
+  it("classifies permission errors", () => {
+    expect(classifyError("EACCES: permission denied")).toBe("permission");
+  });
+
+  it("classifies 401", () => {
+    expect(classifyError("Error: 401 Unauthorized")).toBe("permission");
+  });
+
+  it("classifies timeout", () => {
+    expect(classifyError("Error: Timeout after 5000ms")).toBe("timeout");
+  });
+
+  it("classifies ETIMEDOUT", () => {
+    expect(classifyError("connect ETIMEDOUT 1.2.3.4")).toBe("timeout");
+  });
+
+  it("classifies ENOENT", () => {
+    expect(classifyError("ENOENT: no such file or directory")).toBe("not_found");
+  });
+
+  it("classifies Cannot find module", () => {
+    expect(classifyError("Cannot find module './foo'")).toBe("not_found");
+  });
+
+  it("classifies syntax errors", () => {
+    expect(classifyError("SyntaxError: Unexpected token")).toBe("syntax");
+  });
+
+  it("classifies rate limit", () => {
+    expect(classifyError("Error: 429 Too Many Requests")).toBe("rate_limit");
+  });
+
+  it("returns unknown for unrecognized errors", () => {
+    expect(classifyError("Something completely different")).toBe("unknown");
+  });
+
+  it("handles empty string", () => {
+    expect(classifyError("")).toBe("unknown");
+  });
+});
+
+// ═══ quorumMergeTasks ═══
+
+const mkState = (overrides: Partial<ColonyState> = {}): ColonyState => ({
+  id: "test-colony", goal: "test", status: "working",
+  tasks: [], ants: [], pheromones: [],
+  concurrency: { current: 2, min: 1, max: 4, optimal: 3, history: [] },
+  metrics: { tasksTotal: 0, tasksDone: 0, tasksFailed: 0, antsSpawned: 0, totalCost: 0, totalTokens: 0, startTime: Date.now(), throughputHistory: [] },
+  maxCost: null, modelOverrides: {}, createdAt: Date.now(), finishedAt: null,
+  ...overrides,
+});
+
+const mkTask = (overrides: Partial<Task> = {}): Task => ({
+  id: `t-${Math.random().toString(36).slice(2)}`, parentId: null,
+  title: "Test task", description: "Do something",
+  caste: "worker", status: "pending", priority: 3, files: [],
+  claimedBy: null, result: null, error: null, spawnedTasks: [],
+  createdAt: Date.now(), startedAt: null, finishedAt: null,
+  ...overrides,
+});
+
+let tmpDir: string;
+let nest: Nest;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "queen-test-"));
+  nest = new Nest(tmpDir, "test-colony");
+  nest.init(mkState());
+});
+
+afterEach(() => {
+  try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+describe("quorumMergeTasks", () => {
+  it("does nothing with 0-1 tasks", () => {
+    const t1 = mkTask({ files: ["a.ts"], priority: 3 });
+    nest.writeTask(t1);
+    quorumMergeTasks(nest);
+    const tasks = nest.getAllTasks().filter(t => t.status === "pending");
+    expect(tasks).toHaveLength(1);
+  });
+
+  it("merges duplicate tasks with same files", () => {
+    const t1 = mkTask({ id: "t-1", title: "Fix auth", files: ["a.ts", "b.ts"], priority: 3 });
+    const t2 = mkTask({ id: "t-2", title: "Fix auth v2", files: ["a.ts", "b.ts"], priority: 3 });
+    nest.writeTask(t1);
+    nest.writeTask(t2);
+    quorumMergeTasks(nest);
+    const pending = nest.getAllTasks().filter(t => t.status === "pending");
+    const done = nest.getAllTasks().filter(t => t.status === "done");
+    expect(pending).toHaveLength(1);
+    expect(done).toHaveLength(1);
+    expect(done[0].result).toContain("quorum");
+  });
+
+  it("boosts priority of merged task", () => {
+    const t1 = mkTask({ id: "t-1", files: ["x.ts"], priority: 3 });
+    const t2 = mkTask({ id: "t-2", files: ["x.ts"], priority: 3 });
+    nest.writeTask(t1);
+    nest.writeTask(t2);
+    quorumMergeTasks(nest);
+    const pending = nest.getAllTasks().filter(t => t.status === "pending");
+    expect(pending[0].priority).toBe(2); // boosted from 3 to 2
+  });
+
+  it("does not merge tasks with different files", () => {
+    const t1 = mkTask({ id: "t-1", files: ["a.ts"] });
+    const t2 = mkTask({ id: "t-2", files: ["b.ts"] });
+    nest.writeTask(t1);
+    nest.writeTask(t2);
+    quorumMergeTasks(nest);
+    const pending = nest.getAllTasks().filter(t => t.status === "pending");
+    expect(pending).toHaveLength(2);
+  });
+
+  it("merges context from duplicate tasks", () => {
+    const t1 = mkTask({ id: "t-1", files: ["a.ts"], context: "context A" });
+    const t2 = mkTask({ id: "t-2", files: ["a.ts"], context: "context B" });
+    nest.writeTask(t1);
+    nest.writeTask(t2);
+    quorumMergeTasks(nest);
+    const pending = nest.getAllTasks().filter(t => t.status === "pending");
+    expect(pending[0].context).toContain("context A");
+    expect(pending[0].context).toContain("context B");
+  });
+
+  it("handles three duplicates", () => {
+    const t1 = mkTask({ id: "t-1", files: ["a.ts"], priority: 4 });
+    const t2 = mkTask({ id: "t-2", files: ["a.ts"], priority: 4 });
+    const t3 = mkTask({ id: "t-3", files: ["a.ts"], priority: 4 });
+    nest.writeTask(t1);
+    nest.writeTask(t2);
+    nest.writeTask(t3);
+    quorumMergeTasks(nest);
+    const pending = nest.getAllTasks().filter(t => t.status === "pending");
+    const done = nest.getAllTasks().filter(t => t.status === "done");
+    expect(pending).toHaveLength(1);
+    expect(done).toHaveLength(2);
+    expect(pending[0].priority).toBe(3); // boosted from 4 to 3
+  });
+
+  it("skips non-pending tasks", () => {
+    const t1 = mkTask({ id: "t-1", files: ["a.ts"], status: "done" });
+    const t2 = mkTask({ id: "t-2", files: ["a.ts"], status: "pending" });
+    nest.writeTask(t1);
+    nest.writeTask(t2);
+    quorumMergeTasks(nest);
+    // Only 1 pending, so no merge
+    const pending = nest.getAllTasks().filter(t => t.status === "pending");
+    expect(pending).toHaveLength(1);
+  });
+
+  it("does not boost priority below 1", () => {
+    const t1 = mkTask({ id: "t-1", files: ["a.ts"], priority: 1 });
+    const t2 = mkTask({ id: "t-2", files: ["a.ts"], priority: 1 });
+    nest.writeTask(t1);
+    nest.writeTask(t2);
+    quorumMergeTasks(nest);
+    const pending = nest.getAllTasks().filter(t => t.status === "pending");
+    expect(pending[0].priority).toBe(1); // stays at 1
+  });
+});

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

@@ -98,6 +98,44 @@ function childTaskFromParsed(
   };
 }
 
+/**
+ * Bio 5: 蚁群投票 — 合并多 Scout 产生的重复任务
+ * 相同文件集合的任务合并，被多 Scout 提及的任务 priority 提升
+ */
+export function quorumMergeTasks(nest: Nest): void {
+  const tasks = nest.getAllTasks().filter(t =>
+    (t.caste === "worker" || t.caste === "drone") && t.status === "pending"
+  );
+  if (tasks.length < 2) return;
+
+  // 按文件集合分组（排序后 join 作为 key）
+  const groups = new Map<string, Task[]>();
+  for (const t of tasks) {
+    const key = [...t.files].sort().join("|") || t.title;
+    const arr = groups.get(key) ?? [];
+    arr.push(t);
+    groups.set(key, arr);
+  }
+
+  for (const [, group] of groups) {
+    if (group.length < 2) continue;
+    // 保留第一个，删除重复的，合并 description
+    const keeper = group[0];
+    // Quorum 达成：被多 Scout 提及 → priority 提升
+    keeper.priority = Math.max(1, keeper.priority - 1) as 1 | 2 | 3 | 4 | 5;
+    // 合并其他任务的 context 到 keeper
+    for (let i = 1; i < group.length; i++) {
+      const dup = group[i];
+      if (dup.context && dup.context !== keeper.context) {
+        keeper.context = (keeper.context || "") + "\n\n--- Additional scout context ---\n" + dup.context;
+      }
+      // 标记重复任务为 done（已合并）
+      nest.updateTaskStatus(dup.id, "done", `Merged into ${keeper.id} (quorum)`);
+    }
+    nest.writeTask(keeper);
+  }
+}
+
 function makeReviewTask(completedTasks: Task[]): Task {
   const files = [...new Set(completedTasks.flatMap(t => t.files))];
   return {
@@ -157,25 +195,49 @@ interface WaveOptions {
   importGraph?: ImportGraph;
 }
 
+/**
+ * Bio 6: 尸体清理 — 错误模式分类
+ */
+export function classifyError(errStr: string): string {
+  if (errStr.includes("TypeError") || errStr.includes("type") || errStr.includes("TS")) return "type_error";
+  if (errStr.includes("permission") || errStr.includes("401") || errStr.includes("EACCES")) return "permission";
+  if (errStr.includes("timeout") || errStr.includes("Timeout") || errStr.includes("ETIMEDOUT")) return "timeout";
+  if (errStr.includes("ENOENT") || errStr.includes("not found") || errStr.includes("Cannot find")) return "not_found";
+  if (errStr.includes("syntax") || errStr.includes("SyntaxError") || errStr.includes("Unexpected")) return "syntax";
+  if (errStr.includes("429") || errStr.includes("rate limit")) return "rate_limit";
+  return "unknown";
+}
+
 /**
  * 并发执行一批蚂蚁，自适应调节并发度
  */
 async function runAntWave(opts: WaveOptions): Promise<"ok" | "budget"> {
   const { nest, cwd, caste, signal, callbacks, currentModel, emitSignal } = opts;
   const casteModel = opts.modelOverrides?.[caste] || currentModel;
-  const config = { ...DEFAULT_ANT_CONFIGS[caste], model: casteModel };
+  const baseConfig = { ...DEFAULT_ANT_CONFIGS[caste], model: casteModel };
 
   let backoffMs = 0; // 429 退避时间
   let consecutiveRateLimits = 0; // 连续限流计数
   const retryCount = new Map<string, number>(); // taskId → retry count
   const MAX_RETRIES = 2;
 
+  // Bio 6: 尸体清理 — 错误模式追踪
+  const errorPatterns = new Map<string, { count: number; files: Set<string>; errors: string[] }>();
+
   const runOne = async (): Promise<"done" | "empty" | "rate_limited" | "budget"> => {
     // Budget 刹车：预算用完就不出发（drone 免费，不检查）
     const state = nest.getStateLight();
     if (state.maxCost != null && caste !== "drone") {
       const spent = state.ants.reduce((s, a) => s + a.usage.cost, 0);
       if (spent >= state.maxCost) return "budget";
+
+      // Bio 4: 巢穴温度 — 成本渐进调控
+      const temperature = spent / state.maxCost;
+      if (temperature > 0.9) {
+        // 紧急模式：只跑 priority 1 任务
+        const pending = state.tasks.filter(t => t.status === "pending" && t.caste === caste);
+        if (!pending.some(t => t.priority === 1)) return "budget";
+      }
     }
 
     const task = nest.claimNextTask(caste, "queen");
@@ -194,6 +256,14 @@ async function runAntWave(opts: WaveOptions): Promise<"ok" | "budget"> {
       const antAbort = new AbortController();
       signal?.addEventListener("abort", () => antAbort.abort(), { once: true });
       const antSignal = antAbort.signal;
+      // Bio 7: 年龄多态 — 前期保守，后期收敛
+      const progress = state.metrics.tasksTotal > 0 ? state.metrics.tasksDone / state.metrics.tasksTotal : 0;
+      const config = { ...baseConfig };
+      if (progress < 0.3) {
+        config.maxTurns = Math.max(baseConfig.maxTurns - 3, 5); // 前期保守
+      } else if (progress > 0.7) {
+        config.maxTurns = Math.max(baseConfig.maxTurns - 5, 5); // 后期收敛，只修复收尾
+      }
       const antPromise = caste === "drone"
         ? runDrone(cwd, nest, task)
         : spawnAnt(cwd, nest, task, config, antSignal, callbacks.onAntStream, opts.authStorage, opts.modelRegistry);
@@ -220,8 +290,11 @@ async function runAntWave(opts: WaveOptions): Promise<"ok" | "budget"> {
       }
 
       // 蚂蚁产生的子任务加入巢穴（限制繁殖上限，防止任务膨胀）
+      // Bio 7: 年龄多态 — 后期限制子任务生成
+      const m = curState.metrics;
+      const colonyProgress = m.tasksTotal > 0 ? m.tasksDone / m.tasksTotal : 0;
       const MAX_TOTAL_TASKS = 30;
-      const MAX_SUB_PER_TASK = 5;
+      const MAX_SUB_PER_TASK = colonyProgress > 0.7 ? 2 : 5; // 后期收敛
       const accepted = result.newTasks.slice(0, MAX_SUB_PER_TASK);
       for (const sub of accepted) {
         if (nest.getAllTasks().length >= MAX_TOTAL_TASKS) break;
@@ -240,13 +313,14 @@ async function runAntWave(opts: WaveOptions): Promise<"ok" | "budget"> {
         nest.addSubTask(task.id, child);
       }
 
-      // 路径强化：成功完成释放 completion 信息素，强化相关文件路径
+      // 路径强化：成功完成释放 completion 信息素，强度与任务规模成正比（招募信号）
       if (task.files.length > 0) {
+        const recruitStrength = Math.min(1.0, 0.5 + task.files.length * 0.1 + result.newTasks.length * 0.15);
         nest.dropPheromone({
           id: makePheromoneId(), type: "completion", antId: result.ant.id,
           antCaste: caste, taskId: task.id,
           content: `Success: ${task.title}`,
-          files: task.files, strength: 1.0, createdAt: Date.now(),
+          files: task.files, strength: recruitStrength, createdAt: Date.now(),
         });
       }
 
@@ -264,16 +338,49 @@ async function runAntWave(opts: WaveOptions): Promise<"ok" | "budget"> {
         retryCount.set(task.id, count + 1);
         nest.updateTaskStatus(task.id, "pending");
       } else {
-        // 负信息素：失败任务释放 warning，阻止后续蚂蚁走同一条路
+        // 负信息素：失败任务释放 warning，强度与任务规模成正比
         if (task.files.length > 0) {
+          const warnStrength = Math.min(1.0, 0.5 + task.files.length * 0.1);
           nest.dropPheromone({
             id: makePheromoneId(), type: "warning", antId: "queen",
             antCaste: caste, taskId: task.id,
             content: `Failed: ${task.title} — ${String(e).slice(0, 100)}`,
-            files: task.files, strength: 1.0, createdAt: Date.now(),
+            files: task.files, strength: warnStrength, createdAt: Date.now(),
           });
         }
         nest.updateTaskStatus(task.id, "failed", undefined, String(e));
+
+        // Bio 6: 尸体清理 — 错误模式追踪 + 诊断任务
+        const pattern = classifyError(errStr);
+        const entry = errorPatterns.get(pattern) ?? { count: 0, files: new Set<string>(), errors: [] };
+        entry.count++;
+        for (const f of task.files) entry.files.add(f);
+        entry.errors.push(errStr.slice(0, 200));
+        errorPatterns.set(pattern, entry);
+
+        if (entry.count >= 2 && entry.files.size > 0) {
+          const affectedFiles = [...entry.files];
+          // 释放 repellent 信息素
+          nest.dropPheromone({
+            id: makePheromoneId(), type: "repellent", antId: "queen",
+            antCaste: caste, taskId: task.id,
+            content: `Recurring ${pattern} errors (${entry.count}x): ${entry.errors[0]?.slice(0, 80)}`,
+            files: affectedFiles, strength: 1.0, createdAt: Date.now(),
+          });
+          // 生成诊断任务（仅首次触发）
+          if (entry.count === 2 && nest.getAllTasks().length < 30) {
+            const diagTask: Task = {
+              id: makeTaskId(), parentId: null,
+              title: `Diagnose recurring ${pattern} errors`,
+              description: `Multiple ants failed with ${pattern} errors on these files:\n${affectedFiles.map(f => `- ${f}`).join("\n")}\n\nErrors:\n${entry.errors.map(e => `- ${e}`).join("\n")}\n\nInvestigate root cause and generate fix tasks.`,
+              caste: "scout", status: "pending", priority: 1,
+              files: affectedFiles, claimedBy: null, result: null, error: null,
+              spawnedTasks: [], createdAt: Date.now(), startedAt: null, finishedAt: null,
+            };
+            nest.writeTask(diagTask);
+            emitSignal("working", `Diagnosing recurring ${pattern} errors...`);
+          }
+        }
       }
       return "done";
     }
@@ -422,11 +529,38 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
   };
 
   try {
-    // ═══ Phase 1: 侦察（快速单次，不再多轮接力） ═══
-    callbacks.onPhase?.("scouting", "Dispatching scout ant to explore codebase...");
-    emitSignal("scouting", "Exploring codebase...");
+    // ═══ Phase 1: 侦察（Bio 5: 蚁群投票 — 复杂目标派多 Scout） ═══
+    const scoutCount = opts.goal.length > 500 ? 3 : opts.goal.length > 200 ? 2 : 1;
+    if (scoutCount > 1) {
+      // 多 Scout 并行：为每只 Scout 创建独立任务
+      for (let i = 1; i < scoutCount; i++) {
+        const extraScout: Task = {
+          id: makeTaskId(),
+          parentId: null,
+          title: `Scout ${i + 1}: explore codebase for goal`,
+          description: `Explore the codebase from a different angle and identify files, modules, and dependencies relevant to this goal:\n\n${opts.goal}\n\nFocus on areas other scouts might miss. Be thorough.`,
+          caste: "scout",
+          status: "pending",
+          priority: 1,
+          files: [],
+          claimedBy: null,
+          result: null,
+          error: null,
+          spawnedTasks: [],
+          createdAt: Date.now(),
+          startedAt: null,
+          finishedAt: null,
+        };
+        nest.writeTask(extraScout);
+      }
+    }
+    callbacks.onPhase?.("scouting", `Dispatching ${scoutCount} scout ant(s) to explore codebase...`);
+    emitSignal("scouting", `${scoutCount} scouts exploring...`);
     await runAntWave({ ...waveBase, caste: "scout" });
 
+    // Bio 5: 合并多 Scout 产生的重复任务
+    if (scoutCount > 1) quorumMergeTasks(nest);
+
     let workerTasks = nest.getAllTasks().filter(t => (t.caste === "worker" || t.caste === "drone") && t.status === "pending");
 
     // 只在完全没有 worker 任务时才重试一次
@@ -514,11 +648,14 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
     }
 
     // ═══ 持续探索：Worker 完成后检查是否有新发现，有则再派 Scout ═══
+    // Bio 4: 巢穴温度 — 超过 50% 预算禁止新 Scout 探索
     const discoveries = nest.getAllPheromones().filter(p => p.type === "discovery");
     const allDone = nest.getAllTasks().filter(t => t.status === "done");
-    if (discoveries.length > allDone.length) {
-      const spent = nest.getStateLight().ants.reduce((s, a) => s + a.usage.cost, 0);
-      if (spent < (nest.getStateLight().maxCost ?? Infinity)) {
+    const preExploreSpent = nest.getStateLight().ants.reduce((s, a) => s + a.usage.cost, 0);
+    const preExploreBudget = nest.getStateLight().maxCost ?? Infinity;
+    const costTemperature = preExploreSpent / preExploreBudget;
+    if (discoveries.length > allDone.length && costTemperature < 0.5) {
+      if (preExploreSpent < preExploreBudget) {
         callbacks.onPhase?.("scouting", "Re-exploring based on new discoveries...");
         emitSignal("scouting", "Re-exploring...");
         await runAntWave({ ...waveBase, caste: "scout" });

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

@@ -181,9 +181,22 @@ export async function spawnAnt(
   nest.updateAnt(ant);
   nest.updateTaskStatus(task.id, "active");
 
+  // Bio 2: 任务难度感知 — 动态 maxTurns
+  const warnings = nest.countWarnings(task.files);
+  const difficultyTurns = Math.min(25, (antConfig.maxTurns || 15) + task.files.length + warnings * 2);
+  const effectiveMaxTurns = antConfig.caste === "drone" ? 1 : difficultyTurns;
+
+  // Bio 3: 串联觅食 — 继承父任务 result 和失败前任 error
+  const tandem: { parentResult?: string; priorError?: string } = {};
+  if (task.parentId) {
+    const parent = nest.getTask(task.parentId);
+    if (parent?.result) tandem.parentResult = parent.result;
+  }
+  if (task.error) tandem.priorError = task.error;
+
   const pheromoneCtx = nest.getPheromoneContext(task.files);
   const castePrompt = CASTE_PROMPTS[antConfig.caste];
-  const systemPrompt = buildPrompt(task, pheromoneCtx, castePrompt, antConfig.maxTurns);
+  const systemPrompt = buildPrompt(task, pheromoneCtx, castePrompt, effectiveMaxTurns, tandem);
 
   const auth = authStorage ?? new AuthStorage();
   const registry = modelRegistry ?? new ModelRegistry(auth);