oh-pi 0.1.69 → 0.1.70

package/dist/tui/provider-setup.js

@@ -12,6 +12,36 @@ const PROVIDER_API_URLS = {
     xai: "https://api.x.ai",
     mistral: "https://api.mistral.ai",
 };
+/** Block internal/private IPs to prevent SSRF */
+function isUnsafeUrl(urlStr) {
+    try {
+        const u = new URL(urlStr);
+        const host = u.hostname;
+        // Allow localhost for local dev servers (Ollama, vLLM, etc.)
+        if (host === "localhost" || host === "127.0.0.1" || host === "::1")
+            return false;
+        // Block private IP ranges
+        if (/^10\./.test(host))
+            return true;
+        if (/^172\.(1[6-9]|2\d|3[01])\./.test(host))
+            return true;
+        if (/^192\.168\./.test(host))
+            return true;
+        if (/^0\./.test(host) || host === "0.0.0.0")
+            return true;
+        if (host.includes(":") || host.startsWith("["))
+            return true;
+        if (/^169\.254\./.test(host))
+            return true;
+        // Block non-https for remote hosts
+        if (u.protocol !== "https:")
+            return true;
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
 /**
  * 动态获取模型列表，依次尝试 Anthropic、Google、OpenAI 兼容 API 风格。
  * @param provider - 提供商名称
@@ -85,7 +115,7 @@ async function fetchModels(provider, baseUrl, apiKey) {
                     api: "openai-completions",
                     models: data.map((m) => ({
                         id: m.id,
-                        reasoning: m.thinking_enabled ?? m.id.includes("o3") ?? false,
+                        reasoning: m.thinking_enabled ?? m.id.includes("o3"),
                         input: ["text", "image"],
                         contextWindow: m.context_window ?? m.max_tokens ?? 128000,
                         maxTokens: m.max_output ?? 16384,
@@ -158,7 +188,7 @@ export async function setupProviders(env) {
             const url = await p.text({
                 message: t("provider.baseUrl", { label: info.label }),
                 placeholder: "https://proxy.example.com",
-                validate: (v) => (!v || !v.startsWith("http")) ? t("provider.baseUrlValidation") : undefined,
+                validate: (v) => (!v || !v.startsWith("http")) ? t("provider.baseUrlValidation") : isUnsafeUrl(v) ? "URL must use HTTPS for remote hosts (private IPs blocked)" : undefined,
             });
             if (p.isCancel(url)) {
                 p.cancel(t("cancelled"));
@@ -203,7 +233,7 @@ async function setupCustomProvider() {
     const baseUrl = await p.text({
         message: t("provider.baseUrlCustom"),
         placeholder: t("provider.baseUrlCustomPlaceholder"),
-        validate: (v) => (!v || !v.startsWith("http")) ? t("provider.baseUrlValidation") : undefined,
+        validate: (v) => (!v || !v.startsWith("http")) ? t("provider.baseUrlValidation") : isUnsafeUrl(v) ? "URL must use HTTPS for remote hosts (private IPs blocked)" : undefined,
     });
     if (p.isCancel(baseUrl)) {
         p.cancel(t("cancelled"));

package/package.json

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

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

@@ -76,18 +76,27 @@ export function adapt(config: ConcurrencyConfig, pendingTasks: number): Concurre
   const latest = samples[samples.length - 1];
   const prev = samples[samples.length - 2];
 
-  // 硬约束：系统过载立即减少
-  if (latest.cpuLoad > 0.85 || latest.memFree < 500 * 1024 * 1024) {
+  // CPU 滑动窗口：最近 3 次采样平均值
+  const recentCpuSamples = samples.slice(-3);
+  const avgCpu = recentCpuSamples.reduce((s, x) => s + x.cpuLoad, 0) / recentCpuSamples.length;
+
+  // 429 冷却：30s 内不允许增加并发
+  const inRateLimitCooldown = config.lastRateLimitAt != null && Date.now() - config.lastRateLimitAt < 30000;
+
+  // 硬约束：系统过载立即减少（滞回带：>85% 减，60%-85% 保持）
+  if (avgCpu > 0.85 || latest.memFree < 500 * 1024 * 1024) {
     next.current = Math.max(config.min, config.current - 1);
     return next;
   }
 
+  // 滞回带：CPU 在 60%-85% 之间保持不变
+  const canIncrease = avgCpu < 0.6 && !inRateLimitCooldown;
+
   // 探索期：样本不足，逐步提升
   if (samples.length < 10) {
-    if (latest.throughput >= prev.throughput) {
-      // 吞吐量还在涨，继续探索
+    if (latest.throughput >= prev.throughput && canIncrease) {
       next.current = Math.min(config.current + 1, taskCap);
-    } else {
+    } else if (latest.throughput < prev.throughput) {
       // 吞吐量下降，找到拐点
       next.optimal = prev.concurrency;
       next.current = prev.concurrency;
@@ -99,20 +108,17 @@ export function adapt(config: ConcurrencyConfig, pendingTasks: number): Concurre
   const recentThroughput = samples.slice(-5).reduce((s, x) => s + x.throughput, 0) / 5;
   const olderThroughput = samples.slice(-10, -5).reduce((s, x) => s + x.throughput, 0) / 5;
 
-  if (recentThroughput > olderThroughput * 1.1 && latest.cpuLoad < 0.7) {
-    // 吞吐量上升且 CPU 有余量，尝试+1
+  if (recentThroughput > olderThroughput * 1.1 && canIncrease) {
     next.current = Math.min(config.current + 1, taskCap);
     if (recentThroughput > olderThroughput * 1.2) {
-      next.optimal = next.current; // 更新最优值
+      next.optimal = next.current;
     }
   } else if (recentThroughput < olderThroughput * 0.8) {
-    // 吞吐量下降，回退
     next.current = Math.max(config.min, config.optimal);
   }
-  // 否则保持不变
 
   // 429 recovery: restore to optimal when CPU is underutilized (e.g. after backoff)
-  if (latest.cpuLoad < 0.5 && next.current < config.optimal) {
+  if (avgCpu < 0.5 && next.current < config.optimal && !inRateLimitCooldown) {
     next.current = config.optimal;
   }
 

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;
@@ -89,11 +98,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 +115,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 +215,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 +236,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 +565,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,8 @@ 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();
 
   constructor(private cwd: string, private colonyId: string) {
     this.dir = path.join(cwd, ".ant-colony", colonyId);
@@ -90,12 +92,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 {
@@ -129,15 +169,21 @@ export class Nest {
       return tasks[Math.floor(Math.random() * tasks.length)];
     }
 
-    // 信息素加权：discovery/completion 加分，warning/repellent 减分（负信息素）
-    const pheromones = this.getAllPheromones();
+    // 信息素加权：用索引查询而非全量扫描
+    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;
+      const seen = new Set<Pheromone>();
+      for (const f of t.files) {
+        const related = this.pheromoneByFile.get(f);
+        if (!related) continue;
+        for (const p of related) {
+          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 };
     });
@@ -171,10 +217,32 @@ 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;
+
+    // 重建文件索引
+    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);
+      }
+    }
+
+    // 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;
   }
@@ -234,16 +302,22 @@ export class Nest {
     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;
@@ -294,5 +368,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.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/queen.ts

@@ -167,7 +167,8 @@ async function runAntWave(opts: WaveOptions): Promise<"ok" | "budget"> {
 
   let backoffMs = 0; // 429 退避时间
   let consecutiveRateLimits = 0; // 连续限流计数
-  const retriedTasks = new Set<string>(); // 防止重复重试
+  const retryCount = new Map<string, number>(); // taskId → retry count
+  const MAX_RETRIES = 2;
 
   const runOne = async (): Promise<"done" | "empty" | "rate_limited" | "budget"> => {
     // Budget 刹车：预算用完就不出发（drone 免费，不检查）
@@ -177,9 +178,8 @@ async function runAntWave(opts: WaveOptions): Promise<"ok" | "budget"> {
       if (spent >= state.maxCost) return "budget";
     }
 
-    const task = nest.nextPendingTask(caste);
+    const task = nest.claimNextTask(caste, "queen");
     if (!task) return "empty";
-    if (!nest.claimTask(task.id, "queen")) return "empty";
 
     const ant: Ant = {
       id: "", caste, status: "idle", taskId: task.id,
@@ -190,15 +190,35 @@ async function runAntWave(opts: WaveOptions): Promise<"ok" | "budget"> {
     callbacks.onAntSpawn?.(ant, task);
 
     try {
-      const result = caste === "drone"
-        ? await runDrone(cwd, nest, task)
-        : await spawnAnt(cwd, nest, task, config, signal, callbacks.onAntStream, opts.authStorage, opts.modelRegistry);
+      const ANT_TIMEOUT = 5 * 60 * 1000; // 5 min hard timeout per ant
+      const antAbort = new AbortController();
+      signal?.addEventListener("abort", () => antAbort.abort(), { once: true });
+      const antSignal = antAbort.signal;
+      const antPromise = caste === "drone"
+        ? runDrone(cwd, nest, task)
+        : spawnAnt(cwd, nest, task, config, antSignal, callbacks.onAntStream, opts.authStorage, opts.modelRegistry);
+      let timeoutId: ReturnType<typeof setTimeout>;
+      const result = await Promise.race([
+        antPromise.finally(() => clearTimeout(timeoutId)),
+        new Promise<never>((_, reject) => {
+          timeoutId = setTimeout(() => { antAbort.abort(); reject(new Error("Ant timeout (5min)")); }, ANT_TIMEOUT);
+        }),
+      ]);
       callbacks.onAntDone?.(result.ant, task, result.output);
 
       if (result.rateLimited) {
         return "rate_limited";
       }
 
+      // 成本预警：超 80% 预算时发信号
+      const curState = nest.getState();
+      if (curState.maxCost != null) {
+        const spent = curState.ants.reduce((s, a) => s + a.usage.cost, 0);
+        if (spent >= curState.maxCost * 0.8) {
+          emitSignal("working", `Budget warning: ${(spent / curState.maxCost * 100).toFixed(0)}% used`);
+        }
+      }
+
       // 蚂蚁产生的子任务加入巢穴（限制繁殖上限，防止任务膨胀）
       const MAX_TOTAL_TASKS = 30;
       const MAX_SUB_PER_TASK = 5;
@@ -237,8 +257,11 @@ async function runAntWave(opts: WaveOptions): Promise<"ok" | "budget"> {
 
       return "done";
     } catch (e) {
-      if (!retriedTasks.has(task.id)) {
-        retriedTasks.add(task.id);
+      const errStr = String(e);
+      const isRetryable = errStr.includes("timeout") || errStr.includes("Timeout") || errStr.includes("ECONNRESET") || errStr.includes("429");
+      const count = retryCount.get(task.id) ?? 0;
+      if (isRetryable && count < MAX_RETRIES) {
+        retryCount.set(task.id, count + 1);
         nest.updateTaskStatus(task.id, "pending");
       } else {
         // 负信息素：失败任务释放 warning，阻止后续蚂蚁走同一条路
@@ -270,7 +293,7 @@ async function runAntWave(opts: WaveOptions): Promise<"ok" | "budget"> {
     }
 
     // 解除 blocked 任务（如果锁定文件和依赖文件都已释放）
-    const activeTasks = state.tasks.filter(t => t.status === "active");
+    const activeTasks = state.tasks.filter(t => t.status === "active" || t.status === "claimed");
     const activeFiles = new Set(activeTasks.flatMap(t => t.files));
     for (const t of state.tasks.filter(t => t.status === "blocked" && t.caste === caste)) {
       const fileConflict = t.files.some(f => activeFiles.has(f));
@@ -321,12 +344,12 @@ async function runAntWave(opts: WaveOptions): Promise<"ok" | "budget"> {
       return "budget";
     }
 
-    // 429 处理：降低并发 + 渐进退避（2s → 5s → 10s，上限 10s）
+    // 429 处理：降低并发 + 渐进退避（2s → 5s → 10s，上限 10s）+ 记录时间戳
     if (results.includes("rate_limited")) {
       consecutiveRateLimits++;
       const cur = nest.getState().concurrency;
       const reduced = Math.max(cur.min, cur.current - 1); // 每次只减 1，不砍半
-      nest.updateState({ concurrency: { ...cur, current: reduced } });
+      nest.updateState({ concurrency: { ...cur, current: reduced, lastRateLimitAt: Date.now() } });
       backoffMs = Math.min(consecutiveRateLimits * 2000, 10000);
     } else {
       consecutiveRateLimits = 0;
@@ -371,13 +394,6 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
 
   nest.init(initialState);
   const { signal, callbacks } = opts;
-  const waveBase: Omit<WaveOptions, "caste"> & { importGraph?: ImportGraph } = {
-    nest, cwd: opts.cwd, signal, callbacks, emitSignal,
-    currentModel: opts.currentModel,
-    modelOverrides: opts.modelOverrides,
-    authStorage: opts.authStorage,
-    modelRegistry: opts.modelRegistry,
-  };
 
   const cleanup = () => {
     nest.destroy();
@@ -389,12 +405,21 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
   };
 
   const emitSignal = (phase: ColonyState["status"], message: string) => {
-    const m = nest.getState().metrics;
-    const active = nest.getState().ants.filter(a => a.status === "working").length;
+    const state = nest.getState();
+    const m = state.metrics;
+    const active = state.ants.filter(a => a.status === "working").length;
     const progress = m.tasksTotal > 0 ? m.tasksDone / m.tasksTotal : 0;
     callbacks.onSignal?.({ phase, progress, active, cost: m.totalCost, message });
   };
 
+  const waveBase: Omit<WaveOptions, "caste"> & { importGraph?: ImportGraph } = {
+    nest, cwd: opts.cwd, signal, callbacks, emitSignal,
+    currentModel: opts.currentModel,
+    modelOverrides: opts.modelOverrides,
+    authStorage: opts.authStorage,
+    modelRegistry: opts.modelRegistry,
+  };
+
   try {
     // ═══ Phase 1: 侦察（快速单次，不再多轮接力） ═══
     callbacks.onPhase?.("scouting", "Dispatching scout ant to explore codebase...");
@@ -490,7 +515,7 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
     // ═══ 持续探索：Worker 完成后检查是否有新发现，有则再派 Scout ═══
     const discoveries = nest.getAllPheromones().filter(p => p.type === "discovery");
     const allDone = nest.getAllTasks().filter(t => t.status === "done");
-    if (discoveries.length > allDone.length && nest.getState().maxCost != null) {
+    if (discoveries.length > allDone.length) {
       const spent = nest.getState().ants.reduce((s, a) => s + a.usage.cost, 0);
       if (spent < (nest.getState().maxCost ?? Infinity)) {
         callbacks.onPhase?.("scouting", "Re-exploring based on new discoveries...");
@@ -563,7 +588,8 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
     emitSignal("failed", String(e).slice(0, 100));
     return failState;
   } finally {
-    cleanup();
+    const finalStatus = nest.getState().status;
+    if (finalStatus === "done") cleanup();
   }
 }
 
@@ -580,8 +606,9 @@ export async function resumeColony(opts: QueenOptions): Promise<ColonyState> {
   const { signal, callbacks } = opts;
 
   const emitSignal = (phase: ColonyState["status"], message: string) => {
-    const m = nest.getState().metrics;
-    const active = nest.getState().ants.filter(a => a.status === "working").length;
+    const state = nest.getState();
+    const m = state.metrics;
+    const active = state.ants.filter(a => a.status === "working").length;
     const progress = m.tasksTotal > 0 ? m.tasksDone / m.tasksTotal : 0;
     callbacks.onSignal?.({ phase, progress, active, cost: m.totalCost, message });
   };
@@ -623,6 +650,26 @@ export async function resumeColony(opts: QueenOptions): Promise<ColonyState> {
       }
     }
 
+    // Soldier review for resumed colony（条件与 runColony 对齐）
+    let tscPassed = true;
+    try {
+      const { execSync } = await import("node:child_process");
+      execSync("npx tsc --noEmit", { cwd: opts.cwd, timeout: 30000, stdio: "pipe" });
+    } catch { tscPassed = false; }
+
+    const completedWorkerTasks = nest.getAllTasks().filter(t => t.caste === "worker" && t.status === "done");
+    if (completedWorkerTasks.length > 0 && (!tscPassed || completedWorkerTasks.length > 3)) {
+      nest.updateState({ status: "reviewing" });
+      const reviewTask = makeReviewTask(completedWorkerTasks);
+      nest.writeTask(reviewTask);
+      await runAntWave({ ...waveBase, caste: "soldier" });
+      const fixTasks = nest.getAllTasks().filter(t => t.caste === "worker" && t.status === "pending" && t.parentId !== null);
+      if (fixTasks.length > 0) {
+        nest.updateState({ status: "working" });
+        await runAntWave({ ...waveBase, caste: "worker" });
+      }
+    }
+
     const finalMetrics = updateMetrics(nest);
     nest.updateState({ status: "done", finishedAt: Date.now(), metrics: finalMetrics });
     const finalState = nest.getState();
@@ -637,6 +684,7 @@ export async function resumeColony(opts: QueenOptions): Promise<ColonyState> {
     emitSignal("failed", String(e).slice(0, 100));
     return failState;
   } finally {
-    cleanup();
+    const finalStatus = nest.getState().status;
+    if (finalStatus === "done") cleanup();
   }
 }

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

@@ -120,7 +120,14 @@ export async function runDrone(
 
   try {
     const { execSync } = await import("node:child_process");
-    const cmd = task.description;
+    // 优先从 context 代码块提取 bash 命令，fallback 到 description
+    const ctxMatch = task.context?.match(/```(?:bash|sh)?\s*\n?([\s\S]*?)```/);
+    const cmd = ctxMatch?.[1]?.trim() || task.description;
+    // 基本危险命令校验
+    const DANGEROUS = /\brm\s+-rf\s+\/|mkfs\b|dd\s+if=|chmod\s+777\s+\/|>\s*\/dev\/sd/i;
+    if (DANGEROUS.test(cmd)) {
+      throw new Error(`Drone refused dangerous command: ${cmd.slice(0, 80)}`);
+    }
     const output = execSync(cmd, { cwd, encoding: "utf-8", timeout: 30000, stdio: "pipe" }).trim();
 
     ant.status = "done";
@@ -191,9 +198,10 @@ export async function spawnAnt(
 
   let accumulatedText = "";
   let rateLimited = false;
+  let session: any = null;
 
   try {
-    const { session } = await createAgentSession({
+    const created = await createAgentSession({
       cwd,
       model,
       thinkingLevel: "off",
@@ -204,6 +212,7 @@ export async function spawnAnt(
       sessionManager: SessionManager.inMemory(),
       settingsManager,
     });
+    session = created.session;
 
     session.subscribe((event: AgentSessionEvent) => {
       if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
@@ -241,8 +250,9 @@ export async function spawnAnt(
 
     const userPrompt = `Execute this task: ${task.title}\n\n${task.description}`;
 
+    let onAbort: (() => void) | undefined;
     if (signal) {
-      const onAbort = () => session.abort();
+      onAbort = () => session.abort();
       if (signal.aborted) {
         await session.abort();
       } else {
@@ -250,7 +260,13 @@ export async function spawnAnt(
       }
     }
 
-    await session.prompt(userPrompt);
+    try {
+      await session.prompt(userPrompt);
+    } finally {
+      if (signal && onAbort) {
+        signal.removeEventListener("abort", onAbort);
+      }
+    }
 
     const messages = session.messages;
     let finalOutput = accumulatedText;
@@ -278,7 +294,6 @@ export async function spawnAnt(
     for (const p of pheromones) nest.dropPheromone(p);
 
     nest.updateTaskStatus(task.id, "done", finalOutput);
-    session.dispose();
 
     return { ant, output: finalOutput, newTasks, pheromones, rateLimited: false };
 
@@ -305,5 +320,7 @@ export async function spawnAnt(
     nest.updateTaskStatus(task.id, "failed", accumulatedText, errStr);
 
     return { ant, output: accumulatedText, newTasks, pheromones, rateLimited: false };
+  } finally {
+    try { session?.dispose(); } catch { /* ignore dispose errors */ }
   }
 }

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

@@ -113,6 +113,7 @@ export interface ConcurrencyConfig {
   max: number;
   optimal: number;       // 自适应计算的最优值
   history: ConcurrencySample[];
+  lastRateLimitAt?: number; // 最近一次 429 的时间戳
 }
 
 export interface ConcurrencySample {