oh-pi 0.1.58 → 0.1.60

package/package.json

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

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

@@ -60,7 +60,6 @@ interface BackgroundColony {
   abortController: AbortController;
   state: ColonyState | null;
   phase: string;
-  log: string[];
   antStreams: Map<string, AntStreamState>;
   promise: Promise<ColonyState>;
 }
@@ -84,20 +83,13 @@ export default function antColonyExtension(pi: ExtensionAPI) {
   pi.on("session_start", async (_event, ctx) => {
     pi.events.on("ant-colony:render", () => {
       if (!activeColony) return;
-      const { state, antStreams } = activeColony;
-      const active = antStreams.size;
+      const { state } = activeColony;
       const elapsed = state ? formatDuration(Date.now() - state.createdAt) : "0s";
       const m = state?.metrics;
       const colonyStatus = state?.status || "scouting";
-      const ants = state?.ants || [];
-      const turns = ants.reduce((s, a) => s + a.usage.turns, 0);
-      const outTok = ants.reduce((s, a) => s + a.usage.output, 0);
 
       const parts = [`🐜 ${statusIcon(colonyStatus)}`];
       if (m) parts.push(`${m.tasksDone}/${m.tasksTotal}`);
-      parts.push(`${active}⚡`);
-      parts.push(`${turns}↻`);
-      parts.push(formatTokens(outTok) + "↑");
       if (m) parts.push(formatCost(m.totalCost));
       parts.push(elapsed);
 
@@ -129,18 +121,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
       appendFileSync(gitignorePath, `${gitContent.length && !gitContent.endsWith("\n") ? "\n" : ""}.ant-colony/\n`);
     }
 
-    const log: string[] = [];
-    const callbacks: QueenCallbacks = {
-      onPhase(_phase, detail) { log.push(detail); },
-      onAntSpawn(ant, task) { log.push(`  ${casteIcon(ant.caste)} ${ant.caste} → ${task.title.slice(0, 50)}`); },
-      onAntDone(ant, task) {
-        const dur = ant.finishedAt ? formatDuration(ant.finishedAt - ant.startedAt) : "?";
-        log.push(`  ${ant.status === "done" ? "✓" : "✗"} ${ant.caste} (${dur}) → ${task.title.slice(0, 50)}`);
-      },
-      onAntStream() {},
-      onProgress() {},
-      onComplete() {},
-    };
+    const callbacks: QueenCallbacks = {};
 
     try {
       const state = await runColony({
@@ -160,14 +141,14 @@ export default function antColonyExtension(pi: ExtensionAPI) {
       const report = [
         `## 🐜 Ant Colony Report`,
         `**Goal:** ${state.goal}`,
-        `**Status:** ${statusIcon(state.status)} ${state.status} │ ${elapsed}`,
-        `**Metrics:** ${m.tasksDone}/${m.tasksTotal} tasks │ ${m.antsSpawned} ants │ ${formatTokens(m.totalTokens)} │ ${formatCost(m.totalCost)}`,
+        `**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}**${t.result ? `: ${t.result.split("\n")[0]?.slice(0, 100)}` : ""}`
+          `- ✓ **${t.title}**`
         ),
         ...state.tasks.filter(t => t.status === "failed").map(t =>
-          `- ✗ **${t.title}** — ${t.error?.slice(0, 100) || "unknown"}`
+          `- ✗ **${t.title}** — ${t.error?.slice(0, 80) || "unknown"}`
         ),
       ].join("\n");
 
@@ -205,32 +186,27 @@ export default function antColonyExtension(pi: ExtensionAPI) {
       abortController,
       state: null,
       phase: "initializing",
-      log: [],
       antStreams: new Map(),
       promise: null as any, // set below
     };
 
     const callbacks: QueenCallbacks = {
+      onSignal(signal) {
+        colony.phase = signal.message;
+        throttledRender();
+      },
       onPhase(phase, detail) {
         colony.phase = detail;
-        colony.log.push(`[${new Date().toLocaleTimeString()}] ${statusIcon(phase)} ${detail}`);
         throttledRender();
       },
       onAntSpawn(ant, task) {
         colony.antStreams.set(ant.id, {
-          antId: ant.id,
-          caste: ant.caste,
-          lastLine: "starting...",
-          tokens: 0,
+          antId: ant.id, caste: ant.caste, lastLine: "starting...", tokens: 0,
         });
-        colony.log.push(`  ${casteIcon(ant.caste)} ${ant.caste} ant dispatched → ${task.title.slice(0, 50)}`);
         throttledRender();
       },
-      onAntDone(ant, task) {
+      onAntDone(ant) {
         colony.antStreams.delete(ant.id);
-        const dur = ant.finishedAt ? formatDuration(ant.finishedAt - ant.startedAt) : "?";
-        const icon = ant.status === "done" ? "✓" : "✗";
-        colony.log.push(`  ${icon} ${ant.caste} finished (${dur}, ${formatCost(ant.usage.cost)}) → ${task.title.slice(0, 50)}`);
         throttledRender();
       },
       onAntStream(event: AntStreamEvent) {
@@ -240,7 +216,6 @@ export default function antColonyExtension(pi: ExtensionAPI) {
           const lines = event.totalText.split("\n").filter(l => l.trim());
           stream.lastLine = lines[lines.length - 1]?.trim() || "...";
         }
-        throttledRender();
       },
       onProgress(metrics) {
         if (colony.state) colony.state.metrics = metrics;
@@ -285,25 +260,15 @@ export default function antColonyExtension(pi: ExtensionAPI) {
 
       const report = [
         `## 🐜 Ant Colony Report`,
-        ``,
         `**Goal:** ${state.goal}`,
-        `**Status:** ${statusIcon(state.status)} ${state.status}`,
-        `**Duration:** ${elapsed}`,
-        ...(state.maxCost != null ? [`**Budget:** ${formatCost(m.totalCost)} / ${formatCost(state.maxCost)}`] : []),
-        ``,
-        `### Metrics`,
-        `- Tasks: ${m.tasksDone}/${m.tasksTotal} done, ${m.tasksFailed} failed`,
-        `- Ants spawned: ${m.antsSpawned}`,
-        `- Tokens: ${formatTokens(m.totalTokens)}`,
-        `- Cost: ${formatCost(m.totalCost)}`,
-        `- Peak concurrency: ${state.concurrency.optimal}`,
+        `**Status:** ${statusIcon(state.status)} ${state.status} │ ${elapsed} │ ${formatCost(m.totalCost)}`,
+        `**Tasks:** ${m.tasksDone}/${m.tasksTotal} done${m.tasksFailed > 0 ? `, ${m.tasksFailed} failed` : ""}`,
         ``,
-        `### Task Results`,
         ...state.tasks.filter(t => t.status === "done").map(t =>
-          `- ✓ **${t.title}** (${t.caste})${t.result ? `\n  ${t.result.split("\n")[0]?.slice(0, 100)}` : ""}`
+          `- ✓ **${t.title}**`
         ),
         ...state.tasks.filter(t => t.status === "failed").map(t =>
-          `- ✗ **${t.title}** — ${t.error?.slice(0, 100) || "unknown error"}`
+          `- ✗ **${t.title}** — ${t.error?.slice(0, 80) || "unknown"}`
         ),
       ].join("\n");
 
@@ -420,22 +385,10 @@ export default function antColonyExtension(pi: ExtensionAPI) {
           // ── Active Ants ──
           const streams = Array.from(c.antStreams.values());
           if (streams.length > 0) {
-            lines.push(theme.fg("accent", "  Active Ants"));
-            for (const s of streams) {
-              const line = s.lastLine.length > w - 20 ? s.lastLine.slice(0, w - 23) + "..." : s.lastLine;
-              lines.push(`  ${casteIcon(s.caste)} ${theme.fg("accent", s.antId.slice(0, 14))} ${theme.fg("dim", `${s.tokens}tok`)} ${theme.fg("muted", "▸")} ${line}`);
-            }
+            lines.push(theme.fg("accent", `  Active: ${streams.length} ants working`));
             lines.push("");
           }
 
-          // ── Log (last 8) ──
-          if (c.log.length > 0) {
-            lines.push(theme.fg("accent", "  Log"));
-            for (const l of c.log.slice(-8)) {
-              lines.push(theme.fg("dim", `  ${l.slice(0, w - 2)}`));
-            }
-          }
-
           lines.push("");
           lines.push(theme.fg("muted", "  esc close"));
           return lines;
@@ -566,38 +519,14 @@ export default function antColonyExtension(pi: ExtensionAPI) {
     const state = c.state;
     const elapsed = state ? formatDuration(Date.now() - state.createdAt) : "0s";
     const m = state?.metrics;
-    const tasks = state?.tasks || [];
-    const ants = state?.ants || [];
-    const streams = Array.from(c.antStreams.values());
+    const phase = state?.status || "scouting";
 
     const lines: string[] = [
-      `## 🐜 Colony Status`,
-      `**Goal:** ${c.goal}`,
-      `**Phase:** ${c.phase}`,
-      `**Duration:** ${elapsed}`,
+      `🐜 ${statusIcon(phase)} ${c.goal.slice(0, 80)}`,
+      `${phase} │ ${m ? `${m.tasksDone}/${m.tasksTotal} tasks` : "starting"} │ ${m ? formatCost(m.totalCost) : "$0"} │ ${elapsed}`,
     ];
 
-    if (m) {
-      lines.push(`**Tasks:** ${m.tasksDone}/${m.tasksTotal} done, ${m.tasksFailed} failed`);
-      lines.push(`**Ants spawned:** ${m.antsSpawned} | **Active:** ${streams.length}`);
-      lines.push(`**Cost:** ${formatCost(m.totalCost)} | **Tokens:** ${formatTokens(m.totalTokens)}`);
-    }
-
-    if (tasks.length > 0) {
-      lines.push("", "### Tasks");
-      for (const t of tasks) {
-        const icon = t.status === "done" ? "✓" : t.status === "failed" ? "✗" : t.status === "active" ? "●" : "○";
-        const dur = t.finishedAt && t.startedAt ? ` (${formatDuration(t.finishedAt - t.startedAt)})` : "";
-        lines.push(`- ${icon} [${t.caste}] ${t.title}${dur}`);
-      }
-    }
-
-    if (streams.length > 0) {
-      lines.push("", "### Active Ants");
-      for (const s of streams) {
-        lines.push(`- ${casteIcon(s.caste)} ${s.antId.slice(0, 14)} | ${s.tokens}tok | ${s.lastLine.slice(0, 60)}`);
-      }
-    }
+    if (m && m.tasksFailed > 0) lines.push(`⚠ ${m.tasksFailed} failed`);
 
     return lines.join("\n");
   }

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

@@ -15,7 +15,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type {
-  ColonyState, Task, Ant, AntCaste, ColonyMetrics,
+  ColonyState, Task, Ant, AntCaste, ColonyMetrics, ColonySignal,
   ConcurrencyConfig, TaskPriority, ModelOverrides, AntStreamEvent,
 } from "./types.js";
 import { DEFAULT_ANT_CONFIGS } from "./types.js";
@@ -26,12 +26,15 @@ import { buildImportGraph, taskDependsOn, type ImportGraph } from "./deps.js";
 import type { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
 
 export interface QueenCallbacks {
-  onPhase(phase: ColonyState["status"], detail: string): void;
-  onAntSpawn(ant: Ant, task: Task): void;
-  onAntDone(ant: Ant, task: Task, output: string): void;
+  /** 抽象信号 — 观察者只需实现这一个 */
+  onSignal?(signal: ColonySignal): void;
+  /** 以下为细粒度回调（verbose 模式，可选） */
+  onPhase?(phase: ColonyState["status"], detail: string): void;
+  onAntSpawn?(ant: Ant, task: Task): void;
+  onAntDone?(ant: Ant, task: Task, output: string): void;
   onAntStream?(event: AntStreamEvent): void;
-  onProgress(metrics: ColonyMetrics): void;
-  onComplete(state: ColonyState): void;
+  onProgress?(metrics: ColonyMetrics): void;
+  onComplete?(state: ColonyState): void;
 }
 
 export interface QueenOptions {
@@ -156,7 +159,7 @@ interface WaveOptions {
 /**
  * 并发执行一批蚂蚁，自适应调节并发度
  */
-async function runAntWave(opts: WaveOptions): Promise<"ok"> {
+async function runAntWave(opts: WaveOptions): Promise<"ok" | "budget"> {
   const { nest, cwd, caste, signal, callbacks, currentModel } = opts;
   const casteModel = opts.modelOverrides?.[caste] || currentModel;
   const config = { ...DEFAULT_ANT_CONFIGS[caste], model: casteModel };
@@ -165,7 +168,19 @@ async function runAntWave(opts: WaveOptions): Promise<"ok"> {
   let consecutiveRateLimits = 0; // 连续限流计数
   const retriedTasks = new Set<string>(); // 防止重复重试
 
-  const runOne = async (): Promise<"done" | "empty" | "rate_limited"> => {
+  const runOne = async (): Promise<"done" | "empty" | "rate_limited" | "budget"> => {
+    // Budget 刹车：剩余预算不够一只蚂蚁的预估成本就不出发
+    const state = nest.getState();
+    if (state.maxCost != null && caste !== "drone") {
+      const spent = state.ants.reduce((s, a) => s + a.usage.cost, 0);
+      const remaining = state.maxCost - spent;
+      const doneAnts = state.ants.filter(a => a.status === "done" && a.usage.cost > 0);
+      const avgCost = doneAnts.length > 0
+        ? doneAnts.reduce((s, a) => s + a.usage.cost, 0) / doneAnts.length
+        : 0.05;
+      if (remaining < avgCost * 1.5) return "budget";
+    }
+
     const task = nest.nextPendingTask(caste);
     if (!task) return "empty";
     if (!nest.claimTask(task.id, "queen")) return "empty";
@@ -176,13 +191,13 @@ async function runAntWave(opts: WaveOptions): Promise<"ok"> {
       usage: { input: 0, output: 0, cost: 0, turns: 0 },
       startedAt: Date.now(), finishedAt: null,
     };
-    callbacks.onAntSpawn(ant, task);
+    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);
-      callbacks.onAntDone(result.ant, task, result.output);
+      callbacks.onAntDone?.(result.ant, task, result.output);
 
       if (result.rateLimited) {
         return "rate_limited";
@@ -207,7 +222,8 @@ async function runAntWave(opts: WaveOptions): Promise<"ok"> {
 
       // 更新指标
       const metrics = updateMetrics(nest);
-      callbacks.onProgress(metrics);
+      callbacks.onProgress?.(metrics);
+      emitSignal("working", `${metrics.tasksDone}/${metrics.tasksTotal} tasks done`);
 
       return "done";
     } catch (e) {
@@ -230,7 +246,7 @@ async function runAntWave(opts: WaveOptions): Promise<"ok"> {
 
     // 429 退避：短暂等待后恢复，连续限流才逐步加长
     if (backoffMs > 0) {
-      callbacks.onPhase("working", `Rate limited (429). Waiting ${Math.round(backoffMs / 1000)}s...`);
+      callbacks.onPhase?.("working", `Rate limited (429). Waiting ${Math.round(backoffMs / 1000)}s...`);
       await new Promise(r => setTimeout(r, backoffMs));
     }
 
@@ -276,12 +292,16 @@ async function runAntWave(opts: WaveOptions): Promise<"ok"> {
     }
 
     const batch = Math.min(slotsAvailable, pending.length);
-    const promises: Promise<"done" | "empty" | "rate_limited">[] = [];
+    const promises: Promise<"done" | "empty" | "rate_limited" | "budget">[] = [];
     for (let i = 0; i < batch; i++) {
       promises.push(runOne());
     }
     const results = await Promise.all(promises);
 
+    if (results.includes("budget")) {
+      return "budget";
+    }
+
     // 429 处理：降低并发 + 渐进退避（2s → 5s → 10s，上限 10s）
     if (results.includes("rate_limited")) {
       consecutiveRateLimits++;
@@ -349,9 +369,17 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
     } catch { /* ignore */ }
   };
 
+  const emitSignal = (phase: ColonyState["status"], message: string) => {
+    const m = nest.getState().metrics;
+    const active = nest.getState().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 });
+  };
+
   try {
     // ═══ Phase 1: 侦察（快速单次，不再多轮接力） ═══
-    callbacks.onPhase("scouting", "Dispatching scout ant to explore codebase...");
+    callbacks.onPhase?.("scouting", "Dispatching scout ant to explore codebase...");
+    emitSignal("scouting", "Exploring codebase...");
     await runAntWave({ ...waveBase, caste: "scout" });
 
     let workerTasks = nest.getAllTasks().filter(t => (t.caste === "worker" || t.caste === "drone") && t.status === "pending");
@@ -380,7 +408,8 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
         finishedAt: null,
       };
       nest.writeTask(relayTask);
-      callbacks.onPhase("scouting", "Scout relay: generating worker tasks...");
+      callbacks.onPhase?.("scouting", "Scout relay: generating worker tasks...");
+      emitSignal("scouting", "Retrying scout...");
       await runAntWave({ ...waveBase, caste: "scout" });
       workerTasks = nest.getAllTasks().filter(t => (t.caste === "worker" || t.caste === "drone") && t.status === "pending");
     }
@@ -388,7 +417,8 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
     if (workerTasks.length === 0) {
       nest.updateState({ status: "failed", finishedAt: Date.now() });
       const finalState = nest.getState();
-      callbacks.onComplete(finalState);
+      callbacks.onComplete?.(finalState);
+      emitSignal("failed", "No tasks generated");
       return finalState;
     }
 
@@ -408,16 +438,17 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
     // 先执行 drone 任务（零 LLM 成本）
     const droneTasks = nest.getAllTasks().filter(t => t.caste === "drone" && t.status === "pending");
     if (droneTasks.length > 0) {
-      callbacks.onPhase("working", `${droneTasks.length} drone tasks. Executing rules...`);
+      callbacks.onPhase?.("working", `${droneTasks.length} drone tasks. Executing rules...`);
+      emitSignal("working", `${droneTasks.length} drone tasks`);
       await runAntWave({ ...waveBase, caste: "drone" });
     }
 
-    callbacks.onPhase("working", `${workerTasks.length} tasks discovered. Dispatching worker ants...`);
+    callbacks.onPhase?.("working", `${workerTasks.length} tasks discovered. Dispatching worker ants...`);
+    emitSignal("working", `${workerTasks.length} tasks to do`);
     await runAntWave({ ...waveBase, caste: "worker" });
 
-    // 处理工蚁产生的子任务（可能有多轮）
-    let rounds = 0;
-    while (rounds < 3) {
+    // 处理工蚁产生的子任务（budget 驱动，无硬限制）
+    while (true) {
       // 先跑 drone 子任务
       const pendingDrones = nest.getAllTasks().filter(t => t.caste === "drone" && t.status === "pending");
       if (pendingDrones.length > 0) await runAntWave({ ...waveBase, caste: "drone" });
@@ -426,9 +457,15 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
         t.caste === "worker" && (t.status === "pending" || t.status === "blocked")
       );
       if (remaining.length === 0) break;
-      rounds++;
-      callbacks.onPhase("working", `Round ${rounds + 1}: ${remaining.length} sub-tasks from workers...`);
-      await runAntWave({ ...waveBase, caste: "worker" });
+      callbacks.onPhase?.("working", `${remaining.length} sub-tasks from workers...`);
+      const result = await runAntWave({ ...waveBase, caste: "worker" });
+      if (result === "budget") {
+        nest.updateState({ status: "budget_exceeded", finishedAt: Date.now() });
+        emitSignal("budget_exceeded", "Budget exhausted");
+        const budgetState = nest.getState();
+        callbacks.onComplete?.(budgetState);
+        return budgetState;
+      }
     }
 
     // ═══ Auto-check: run tsc before soldier review ═══
@@ -444,7 +481,8 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
     const completedWorkerTasks = nest.getAllTasks().filter(t => t.caste === "worker" && t.status === "done");
     if (completedWorkerTasks.length > 0 && (!tscPassed || completedWorkerTasks.length > 3)) {
       nest.updateState({ status: "reviewing" });
-      callbacks.onPhase("reviewing", "Dispatching soldier ants to review changes...");
+      callbacks.onPhase?.("reviewing", "Dispatching soldier ants to review changes...");
+      emitSignal("reviewing", "Reviewing changes...");
       const reviewTask = makeReviewTask(completedWorkerTasks);
       nest.writeTask(reviewTask);
       await runAntWave({ ...waveBase, caste: "soldier" });
@@ -455,7 +493,7 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
       );
       if (fixTasks.length > 0) {
         nest.updateState({ status: "working" });
-        callbacks.onPhase("working", `${fixTasks.length} fix tasks from review. Dispatching workers...`);
+        callbacks.onPhase?.("working", `${fixTasks.length} fix tasks from review. Dispatching workers...`);
         await runAntWave({ ...waveBase, caste: "worker" });
       }
     }
@@ -464,13 +502,15 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
     const finalMetrics = updateMetrics(nest);
     nest.updateState({ status: "done", finishedAt: Date.now(), metrics: finalMetrics });
     const finalState = nest.getState();
-    callbacks.onComplete(finalState);
+    callbacks.onComplete?.(finalState);
+    emitSignal("done", `${finalMetrics.tasksDone}/${finalMetrics.tasksTotal} tasks done`);
     return finalState;
 
   } catch (e) {
     nest.updateState({ status: "failed", finishedAt: Date.now() });
     const failState = nest.getState();
-    callbacks.onComplete(failState);
+    callbacks.onComplete?.(failState);
+    emitSignal("failed", String(e).slice(0, 100));
     return failState;
   } finally {
     cleanup();

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

@@ -132,3 +132,12 @@ export interface ColonyMetrics {
   startTime: number;
   throughputHistory: number[];  // tasks/min 滑动窗口
 }
+
+/** 蚁群抽象信号 — 观察者只需关注这一个 */
+export interface ColonySignal {
+  phase: ColonyState["status"];
+  progress: number;       // 0-1
+  active: number;         // 当前工作中的蚂蚁数
+  cost: number;
+  message: string;        // 一句话描述
+}