oh-pi 0.1.73 → 0.1.75

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-pi",
-  "version": "0.1.73",
+  "version": "0.1.75",
   "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

@@ -51,7 +51,6 @@ export default function antColonyExtension(pi: ExtensionAPI) {
 
   // 当前运行中的后台蚁群（同时只允许一个）
   let activeColony: BackgroundColony | null = null;
-  let uiListenersRegistered = false;
 
   // ─── Status 渲染 ───
 
@@ -63,12 +62,18 @@ export default function antColonyExtension(pi: ExtensionAPI) {
     pi.events.emit("ant-colony:render");
   };
 
-  // 监听事件来更新 UI（确保在有 ctx 的上下文中）
+  // 每次 session_start 重新绑定事件，确保 ctx 始终是最新的
+  let renderHandler: (() => void) | null = null;
+  let clearHandler: (() => void) | null = null;
+  let notifyHandler: ((data: { msg: string; level: "info" | "success" | "warning" | "error" }) => void) | null = null;
+
   pi.on("session_start", async (_event, ctx) => {
-    if (uiListenersRegistered) return;
-    uiListenersRegistered = true;
+    // 移除旧监听器（session 重启 / /reload 时 ctx 已失效）
+    if (renderHandler) pi.events.off("ant-colony:render", renderHandler);
+    if (clearHandler) pi.events.off("ant-colony:clear-ui", clearHandler);
+    if (notifyHandler) pi.events.off("ant-colony:notify", notifyHandler);
 
-    pi.events.on("ant-colony:render", () => {
+    renderHandler = () => {
       if (!activeColony) return;
       const { state } = activeColony;
       const elapsed = state ? formatDuration(Date.now() - state.createdAt) : "0s";
@@ -81,14 +86,17 @@ export default function antColonyExtension(pi: ExtensionAPI) {
       parts.push(elapsed);
 
       ctx.ui.setStatus("ant-colony", parts.join(" │ "));
-    });
-
-    pi.events.on("ant-colony:clear-ui", () => {
+    };
+    clearHandler = () => {
       ctx.ui.setStatus("ant-colony", undefined);
-    });
-    pi.events.on("ant-colony:notify", (data: { msg: string; level: "info" | "success" | "warning" | "error" }) => {
+    };
+    notifyHandler = (data) => {
       ctx.ui.notify(data.msg, data.level);
-    });
+    };
+
+    pi.events.on("ant-colony:render", renderHandler);
+    pi.events.on("ant-colony:clear-ui", clearHandler);
+    pi.events.on("ant-colony:notify", notifyHandler);
   });
 
   // ─── 同步模式（print mode）：阻塞等待蚁群完成 ───
@@ -162,14 +170,14 @@ export default function antColonyExtension(pi: ExtensionAPI) {
     const callbacks: QueenCallbacks = {
       onSignal(signal) {
         colony.phase = signal.message;
-        // 阶段切换时注入消息到主进程对话流
+        // 阶段切换时注入消息到主进程对话流（display: true 让 LLM 下次可见，无需轮询）
         if (signal.phase !== lastPhase) {
           lastPhase = signal.phase;
           const pct = Math.round(signal.progress * 100);
           pi.sendMessage({
             customType: "ant-colony-progress",
             content: `[COLONY_SIGNAL:${signal.phase.toUpperCase()}] 🐜 ${signal.message} (${pct}%, ${formatCost(signal.cost)})`,
-            display: false,
+            display: true,
           }, { triggerTurn: false, deliverAs: "followUp" });
         }
         throttledRender();
@@ -194,7 +202,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
         pi.sendMessage({
           customType: "ant-colony-progress",
           content: `[COLONY_SIGNAL:TASK_DONE] 🐜 ${icon} ${task.title.slice(0, 60)} (${progress}, ${cost})`,
-          display: false,
+          display: true,
         }, { triggerTurn: false, deliverAs: "followUp" });
         throttledRender();
       },
@@ -367,12 +375,14 @@ export default function antColonyExtension(pi: ExtensionAPI) {
         };
 
         // 定时刷新
-        const timer = setInterval(() => {
+        let timer: ReturnType<typeof setInterval> | null = setInterval(() => {
           cachedWidth = undefined;
           cachedLines = undefined;
           tui.requestRender();
         }, 1000);
 
+        const cleanup = () => { if (timer) { clearInterval(timer); timer = null; } };
+
         return {
           render(width: number): string[] {
             if (cachedLines && cachedWidth === width) return cachedLines;
@@ -380,10 +390,10 @@ export default function antColonyExtension(pi: ExtensionAPI) {
             cachedWidth = width;
             return cachedLines;
           },
-          invalidate() { cachedWidth = undefined; cachedLines = undefined; },
+          invalidate() { cachedWidth = undefined; cachedLines = undefined; cleanup(); },
           handleInput(data: string) {
             if (matchesKey(data, "escape")) {
-              clearInterval(timer);
+              cleanup();
               done(undefined);
             }
           },

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

@@ -81,6 +81,39 @@ describe("parseSubTasks", () => {
     const tasks = parseSubTasks(output);
     expect(tasks[0].context).toBeTruthy();
   });
+
+  it("parses chinese task format with full-width colon", () => {
+    const output = `### 任务：生成重启检查报告
+- 描述：创建重启检查文档
+- 文件：docs/ant-colony-restart-check.md
+- 角色：worker
+- 优先级：1`;
+    const tasks = parseSubTasks(output);
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0].title).toContain("重启检查报告");
+    expect(tasks[0].files).toEqual(["docs/ant-colony-restart-check.md"]);
+    expect(tasks[0].caste).toBe("worker");
+    expect(tasks[0].priority).toBe(1);
+  });
+
+  it("does not infer tasks from plain next-step narrative", () => {
+    const output = `目前发现如下\n\n下一步我会继续定位：
+- 写入 docs/ant-colony-restart-check.md
+- 校验 src/index.ts 的入口流程`;
+    const tasks = parseSubTasks(output);
+    expect(tasks).toEqual([]);
+  });
+
+  it("parses bold markdown field keys", () => {
+    const output = `### TASK: Harden parser
+- **description**: support bold fields
+- **files**: pi-package/extensions/ant-colony/parser.ts
+- **caste**: worker
+- **priority**: 2`;
+    const tasks = parseSubTasks(output);
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0].files).toEqual(["pi-package/extensions/ant-colony/parser.ts"]);
+  });
 });
 
 describe("extractPheromones", () => {

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

@@ -2,6 +2,7 @@ import type { AntCaste, Pheromone, PheromoneType } from "./types.js";
 import { makePheromoneId } from "./spawner.js";
 
 const VALID_CASTES = new Set(["scout", "worker", "soldier", "drone"]);
+const TASK_HEADER_RE = /^\s*#{2,6}\s*(?:task|任务)\s*[：:]\s*(.+?)\s*$/i;
 
 export interface ParsedSubTask {
   title: string;
@@ -12,44 +13,138 @@ export interface ParsedSubTask {
   context?: string;
 }
 
+function normalizePriority(v: unknown): 1 | 2 | 3 | 4 | 5 {
+  const n = parseInt(String(v ?? "3"), 10);
+  return Math.min(5, Math.max(1, Number.isNaN(n) ? 3 : n)) as 1 | 2 | 3 | 4 | 5;
+}
+
+function normalizeCaste(v: unknown): AntCaste {
+  const raw = String(v ?? "worker").trim().toLowerCase();
+  if (VALID_CASTES.has(raw)) return raw as AntCaste;
+  if (raw.includes("侦察") || raw.includes("scout")) return "scout";
+  if (raw.includes("工") || raw.includes("worker")) return "worker";
+  if (raw.includes("兵") || raw.includes("review") || raw.includes("soldier")) return "soldier";
+  if (raw.includes("drone") || raw.includes("bash") || raw.includes("shell")) return "drone";
+  return "worker";
+}
+
+function extractFileLike(value: string): string[] {
+  const normalized = value.replace(/[，、；;]/g, ",").replace(/["']/g, "").replace(/`/g, "");
+  const tokens = normalized.split(",").map(s => s.trim()).filter(Boolean);
+  const fileish = tokens
+    .map(t => t.replace(/^\.?\//, ""))
+    .filter(t => /[./\\]/.test(t) || /\.[a-z0-9]+$/i.test(t));
+  return [...new Set(fileish)];
+}
+
+function normalizeJsonTasks(parsed: unknown): ParsedSubTask[] {
+  const arr = (Array.isArray(parsed) ? parsed : [parsed]) as Array<Record<string, unknown>>;
+  return arr.map((t) => ({
+    title: String(t.title || "Untitled"),
+    description: String(t.description || t.title || ""),
+    files: Array.isArray(t.files)
+      ? t.files.map(String).map(f => f.trim()).filter(Boolean)
+      : extractFileLike(String(t.files || "")),
+    caste: normalizeCaste(t.caste),
+    priority: normalizePriority(t.priority),
+    context: t.context ? String(t.context) : undefined,
+  }));
+}
+
+function parseTasksFromStructuredLines(output: string): ParsedSubTask[] {
+  const lines = output.split(/\r?\n/);
+  const tasks: ParsedSubTask[] = [];
+
+  let current: ParsedSubTask | null = null;
+
+  const flushCurrent = () => {
+    if (!current) return;
+    current.title = current.title.trim() || "Untitled";
+    current.description = current.description.trim() || current.title;
+    current.files = [...new Set(current.files.map(f => f.trim()).filter(Boolean))];
+    current.priority = normalizePriority(current.priority);
+    current.caste = normalizeCaste(current.caste);
+    if (current.context) current.context = current.context.trim();
+    tasks.push(current);
+    current = null;
+  };
+
+  const fieldMatch = (line: string) => {
+    return line.match(/^\s*(?:[-*]|\d+\.)?\s*(?:\*\*|__)?\s*(description|desc|描述|说明|files?|文件|路径|caste|role|角色|priority|prio|优先级|context|上下文)\s*(?:\*\*|__)?\s*[：:]\s*(.*)$/i);
+  };
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    const header = line.match(TASK_HEADER_RE);
+    if (header) {
+      flushCurrent();
+      current = {
+        title: header[1]?.trim() || "Untitled",
+        description: "",
+        files: [],
+        caste: "worker",
+        priority: 3,
+      };
+      continue;
+    }
+
+    if (!current) continue;
+
+    const m = fieldMatch(line);
+    if (!m) continue;
+
+    const key = m[1].toLowerCase();
+    const value = (m[2] || "").trim();
+
+    if (["description", "desc", "描述", "说明"].includes(key)) {
+      current.description = value;
+      continue;
+    }
+
+    if (["files", "file", "文件", "路径"].includes(key)) {
+      current.files.push(...extractFileLike(value));
+      continue;
+    }
+
+    if (["caste", "role", "角色"].includes(key)) {
+      current.caste = normalizeCaste(value);
+      continue;
+    }
+
+    if (["priority", "prio", "优先级"].includes(key)) {
+      current.priority = normalizePriority(value);
+      continue;
+    }
+
+    if (["context", "上下文"].includes(key)) {
+      const contextLines = [value];
+      while (i + 1 < lines.length) {
+        const next = lines[i + 1];
+        if (TASK_HEADER_RE.test(next) || fieldMatch(next)) break;
+        if (/^\s*#{1,6}\s+/.test(next)) break;
+        contextLines.push(next);
+        i++;
+      }
+      current.context = contextLines.join("\n").trim();
+    }
+  }
+
+  flushCurrent();
+  return tasks;
+}
+
 export function parseSubTasks(output: string): ParsedSubTask[] {
-  // Try JSON block first
-  const jsonMatch = output.match(/```json\s*([\s\S]*?)```/);
+  // 1) JSON fenced block
+  const jsonMatch = output.match(/```json\s*([\s\S]*?)```/i);
   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 */ }
+      return normalizeJsonTasks(JSON.parse(jsonMatch[1].trim()));
+    } catch { /* fallback */ }
   }
 
-  // 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)) {
-    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;
+  // 2) Structured markdown task blocks (English/Chinese)
+  return parseTasksFromStructuredLines(output);
 }
 
 export function extractPheromones(antId: string, caste: AntCaste, taskId: string, output: string, files: string[], failed = false): Pheromone[] {

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

@@ -13,7 +13,7 @@ vi.mock("@mariozechner/pi-coding-agent", () => ({
 }));
 vi.mock("@mariozechner/pi-ai", () => ({ getModel: vi.fn() }));
 
-import { classifyError, quorumMergeTasks } from "./queen.js";
+import { classifyError, quorumMergeTasks, shouldUseScoutQuorum, validateExecutionPlan } from "./queen.js";
 import { Nest } from "./nest.js";
 import type { ColonyState, Task } from "./types.js";
 
@@ -69,6 +69,40 @@ describe("classifyError", () => {
   });
 });
 
+describe("shouldUseScoutQuorum", () => {
+  it("returns true for multi-step goals", () => {
+    expect(shouldUseScoutQuorum("1) scan repo; 2) write report; 3) review output")).toBe(true);
+  });
+
+  it("returns false for simple single-step goals", () => {
+    expect(shouldUseScoutQuorum("List top-level files")).toBe(false);
+  });
+});
+
+describe("validateExecutionPlan", () => {
+  it("accepts well-formed worker tasks", () => {
+    const plan = validateExecutionPlan([
+      mkTask({ id: "t-plan-1", caste: "worker", title: "Do x", description: "desc", priority: 1, files: ["a.ts"] }),
+    ]);
+    expect(plan.ok).toBe(true);
+    expect(plan.issues).toEqual([]);
+  });
+
+  it("rejects empty plans", () => {
+    const plan = validateExecutionPlan([]);
+    expect(plan.ok).toBe(false);
+    expect(plan.issues).toContain("no_pending_worker_tasks");
+  });
+
+  it("flags non-worker cates as invalid for execution phase", () => {
+    const plan = validateExecutionPlan([
+      mkTask({ id: "t-plan-2", caste: "scout" as any }),
+    ]);
+    expect(plan.ok).toBe(false);
+    expect(plan.issues.some(i => i.includes("invalid_caste"))).toBe(true);
+  });
+});
+
 // ═══ quorumMergeTasks ═══
 
 const mkState = (overrides: Partial<ColonyState> = {}): ColonyState => ({

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

@@ -136,6 +136,88 @@ export function quorumMergeTasks(nest: Nest): void {
   }
 }
 
+export interface PlanValidation {
+  ok: boolean;
+  issues: string[];
+  warnings: string[];
+}
+
+export function shouldUseScoutQuorum(goal: string): boolean {
+  // 多步骤/复合目标更适合至少 2 个 Scout 投票
+  return /(\n\s*\d+[\.)]|[;；]| and |以及|并且|同时|步骤|phase|then|之后)/i.test(goal);
+}
+
+export function validateExecutionPlan(tasks: Task[]): PlanValidation {
+  const issues: string[] = [];
+  const warnings: string[] = [];
+
+  if (tasks.length === 0) {
+    issues.push("no_pending_worker_tasks");
+    return { ok: false, issues, warnings };
+  }
+
+  for (const t of tasks) {
+    if (!t.title?.trim()) issues.push(`task:${t.id}:missing_title`);
+    if (!t.description?.trim()) issues.push(`task:${t.id}:missing_description`);
+    if (t.caste !== "worker" && t.caste !== "drone") issues.push(`task:${t.id}:invalid_caste:${t.caste}`);
+    if (t.priority < 1 || t.priority > 5) issues.push(`task:${t.id}:invalid_priority:${t.priority}`);
+    if (t.files.length === 0) warnings.push(`task:${t.id}:broad_scope`);
+  }
+
+  return { ok: issues.length === 0, issues, warnings };
+}
+
+function collectScoutIntelligence(nest: Nest, maxChars = 6000): string {
+  const scoutResults = nest.getAllTasks()
+    .filter(t => t.caste === "scout" && t.status === "done" && t.result)
+    .map(t => `## ${t.title}\n${t.result}`)
+    .join("\n\n");
+  return scoutResults.slice(0, maxChars);
+}
+
+function makeRecoveryScoutTask(goal: string, attempt: number, planIssues: string[], intel: string): Task {
+  const issueText = planIssues.length > 0 ? planIssues.map(i => `- ${i}`).join("\n") : "- no parseable worker/drone tasks generated";
+  return {
+    id: makeTaskId(),
+    parentId: null,
+    title: `Scout recovery ${attempt}: structure executable plan`,
+    description: [
+      "Previous scout output could not pass plan validation.",
+      "Transform existing intelligence into a VALID structured execution plan.",
+      "",
+      "Goal:",
+      goal,
+      "",
+      "Validation issues:",
+      issueText,
+      "",
+      "Intelligence from prior scouts:",
+      intel || "(none)",
+      "",
+      "Output requirements (STRICT):",
+      "- Return at least ONE task block",
+      "### TASK: <title>",
+      "- description: <what to do>",
+      "- files: <comma-separated file paths>",
+      "- caste: worker",
+      "- priority: <1-5>",
+      "",
+      "Do NOT execute changes. Only planning.",
+    ].join("\n"),
+    caste: "scout",
+    status: "pending",
+    priority: 1,
+    files: [],
+    claimedBy: null,
+    result: null,
+    error: null,
+    spawnedTasks: [],
+    createdAt: Date.now(),
+    startedAt: null,
+    finishedAt: null,
+  };
+}
+
 function makeReviewTask(completedTasks: Task[]): Task {
   const files = [...new Set(completedTasks.flatMap(t => t.files))];
   return {
@@ -530,7 +612,8 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
 
   try {
     // ═══ Phase 1: 侦察（Bio 5: 蚁群投票 — 复杂目标派多 Scout） ═══
-    const scoutCount = opts.goal.length > 500 ? 3 : opts.goal.length > 200 ? 2 : 1;
+    const scoutCountBase = opts.goal.length > 500 ? 3 : opts.goal.length > 200 ? 2 : 1;
+    const scoutCount = shouldUseScoutQuorum(opts.goal) ? Math.max(2, scoutCountBase) : scoutCountBase;
     if (scoutCount > 1) {
       // 多 Scout 并行：为每只 Scout 创建独立任务
       for (let i = 1; i < scoutCount; i++) {
@@ -561,43 +644,36 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
     // Bio 5: 合并多 Scout 产生的重复任务
     if (scoutCount > 1) quorumMergeTasks(nest);
 
-    let workerTasks = nest.getAllTasks().filter(t => (t.caste === "worker" || t.caste === "drone") && t.status === "pending");
-
-    // 只在完全没有 worker 任务时才重试一次
-    if (workerTasks.length === 0) {
-      const pheromones = nest.getAllPheromones();
-      const hasDiscoveries = pheromones.some(p => p.type === "discovery");
-      const relayTask: Task = {
-        id: makeTaskId(),
-        parentId: null,
-        title: "Scout relay: generate worker tasks",
-        description: hasDiscoveries
-          ? `Previous scout found information but didn't generate worker tasks. Generate concrete worker tasks based on discoveries.\n\nGoal:\n${opts.goal}`
-          : `Explore the codebase for this goal and generate worker tasks:\n\n${opts.goal}`,
-        caste: "scout",
-        status: "pending",
-        priority: 1,
-        files: [],
-        claimedBy: null,
-        result: null,
-        error: null,
-        spawnedTasks: [],
-        createdAt: Date.now(),
-        startedAt: null,
-        finishedAt: null,
-      };
-      nest.writeTask(relayTask);
-      callbacks.onPhase?.("scouting", "Scout relay: generating worker tasks...");
-      emitSignal("scouting", "Retrying scout...");
+    const getPendingExecutionTasks = () => nest.getAllTasks().filter(t => (t.caste === "worker" || t.caste === "drone") && t.status === "pending");
+
+    let workerTasks = getPendingExecutionTasks();
+    let plan = validateExecutionPlan(workerTasks);
+
+    // 计划恢复回路：Scout 输出不可执行时，不直接造 Worker，先让 Scout 结构化重组
+    const MAX_PLAN_RECOVERY_ROUNDS = 2;
+    let recoveryRound = 0;
+    while (!plan.ok && recoveryRound < MAX_PLAN_RECOVERY_ROUNDS) {
+      recoveryRound++;
+      nest.updateState({ status: "planning_recovery" });
+
+      const intel = collectScoutIntelligence(nest);
+      const recoveryTask = makeRecoveryScoutTask(opts.goal, recoveryRound, plan.issues, intel);
+      nest.writeTask(recoveryTask);
+
+      callbacks.onPhase?.("planning_recovery", `Plan recovery ${recoveryRound}/${MAX_PLAN_RECOVERY_ROUNDS}: restructuring scout intelligence...`);
+      emitSignal("planning_recovery", `Recovering plan (${recoveryRound}/${MAX_PLAN_RECOVERY_ROUNDS})`);
       await runAntWave({ ...waveBase, caste: "scout" });
-      workerTasks = nest.getAllTasks().filter(t => (t.caste === "worker" || t.caste === "drone") && t.status === "pending");
+      quorumMergeTasks(nest);
+
+      workerTasks = getPendingExecutionTasks();
+      plan = validateExecutionPlan(workerTasks);
     }
 
-    if (workerTasks.length === 0) {
+    if (!plan.ok) {
       nest.updateState({ status: "failed", finishedAt: Date.now() });
       const finalState = nest.getState();
       callbacks.onComplete?.(finalState);
-      emitSignal("failed", "No tasks generated");
+      emitSignal("failed", `No valid execution plan: ${plan.issues.slice(0, 3).join(", ")}`);
       return finalState;
     }
 

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

@@ -95,7 +95,7 @@ export interface AntStreamEvent {
 export interface ColonyState {
   id: string;
   goal: string;
-  status: "scouting" | "working" | "reviewing" | "done" | "failed" | "budget_exceeded";
+  status: "scouting" | "planning_recovery" | "working" | "reviewing" | "done" | "failed" | "budget_exceeded";
   tasks: Task[];
   ants: Ant[];
   pheromones: Pheromone[];

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

@@ -27,6 +27,7 @@ describe("formatTokens", () => {
 describe("statusIcon", () => {
   it("scouting", () => expect(statusIcon("scouting")).toBe("🔍"));
   it("working", () => expect(statusIcon("working")).toBe("⚒️"));
+  it("planning_recovery", () => expect(statusIcon("planning_recovery")).toBe("♻️"));
   it("reviewing", () => expect(statusIcon("reviewing")).toBe("🛡️"));
   it("done", () => expect(statusIcon("done")).toBe("✅"));
   it("failed", () => expect(statusIcon("failed")).toBe("❌"));

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

@@ -17,7 +17,7 @@ export function formatTokens(n: number): string {
 
 export function statusIcon(status: string): string {
   const icons: Record<string, string> = {
-    scouting: "🔍", working: "⚒️", reviewing: "🛡️",
+    scouting: "🔍", planning_recovery: "♻️", working: "⚒️", reviewing: "🛡️",
     done: "✅", failed: "❌", budget_exceeded: "💰",
   };
   return icons[status] || "🐜";
@@ -33,7 +33,8 @@ export function buildReport(state: ColonyState): string {
   return [
     `## 🐜 Ant Colony Report`,
     `**Goal:** ${state.goal}`,
-    `**Status:** ${statusIcon(state.status)} ${state.status} │ ${elapsed} │ ${formatCost(m.totalCost)}`,
+    `**Status:** ${statusIcon(state.status)} ${state.status} │ ${formatCost(m.totalCost)}`,
+    `**Duration:** ${elapsed}`,
     `**Tasks:** ${m.tasksDone}/${m.tasksTotal} done${m.tasksFailed > 0 ? `, ${m.tasksFailed} failed` : ""}`,
     ``,
     ...state.tasks.filter(t => t.status === "done").map(t =>

package/pi-package/extensions/bg-process.ts

@@ -2,13 +2,14 @@
  * oh-pi Background Process Extension
  *
  * 任何 bash 命令超时未完成时，自动送到后台执行。
+ * 进程完成后自动通过 sendMessage 通知 LLM，无需轮询。
  * 提供 bg_status 工具让 LLM 查看/停止后台进程。
  */
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
 import { StringEnum } from "@mariozechner/pi-ai";
 import { spawn, execSync } from "node:child_process";
-import { writeFileSync, readFileSync, existsSync } from "node:fs";
+import { writeFileSync, readFileSync, appendFileSync, existsSync } from "node:fs";
 
 /** 超时阈值（毫秒），超过此时间自动后台化 */
 const BG_TIMEOUT_MS = 10_000;
@@ -18,6 +19,8 @@ interface BgProcess {
   command: string;
   logFile: string;
   startedAt: number;
+  finished: boolean;
+  exitCode: number | null;
 }
 
 export default function (pi: ExtensionAPI) {
@@ -41,6 +44,7 @@ export default function (pi: ExtensionAPI) {
         let stdout = "";
         let stderr = "";
         let settled = false;
+        let backgrounded = false;
 
         const child = spawn("bash", ["-c", command], {
           cwd: process.cwd(),
@@ -48,36 +52,58 @@ export default function (pi: ExtensionAPI) {
           stdio: ["ignore", "pipe", "pipe"],
         });
 
-        child.stdout?.on("data", (d: Buffer) => { stdout += d.toString(); });
-        child.stderr?.on("data", (d: Buffer) => { stderr += d.toString(); });
+        child.stdout?.on("data", (d: Buffer) => {
+          const chunk = d.toString();
+          stdout += chunk;
+          // 后台化后追加写入日志
+          if (backgrounded) {
+            try { appendFileSync(bgProcesses.get(child.pid!)?.logFile ?? "", chunk); } catch {}
+          }
+        });
+        child.stderr?.on("data", (d: Buffer) => {
+          const chunk = d.toString();
+          stderr += chunk;
+          if (backgrounded) {
+            try { appendFileSync(bgProcesses.get(child.pid!)?.logFile ?? "", chunk); } catch {}
+          }
+        });
 
-        // 超时处理：分离进程，送到后台
+        // 超时处理：保持管道，标记为后台
         const timer = setTimeout(() => {
           if (settled) return;
           settled = true;
+          backgrounded = true;
 
-          // 分离子进程，让它继续运行
-          child.stdout?.removeAllListeners();
-          child.stderr?.removeAllListeners();
-          child.removeAllListeners();
           child.unref();
 
           const logFile = `/tmp/oh-pi-bg-${Date.now()}.log`;
           const pid = child.pid!;
 
-          // 启动一个 tail 进程把后续输出写入日志
-          try {
-            const tailCmd = `(echo ${JSON.stringify(stdout + stderr)}; tail --pid=${pid} -f /proc/${pid}/fd/1 2>/dev/null) > ${logFile} 2>&1 &`;
-            spawn("bash", ["-c", tailCmd], { detached: true, stdio: "ignore" }).unref();
-          } catch {
-            // fallback: 至少把已有输出写入日志
-            writeFileSync(logFile, stdout + stderr);
-          }
-
-          bgProcesses.set(pid, { pid, command, logFile, startedAt: Date.now() });
+          // 把已有输出写入日志
+          writeFileSync(logFile, stdout + stderr);
+
+          const proc: BgProcess = { pid, command, logFile, startedAt: Date.now(), finished: false, exitCode: null };
+          bgProcesses.set(pid, proc);
+
+          // 监听完成事件，自动通知 LLM
+          child.on("close", (code) => {
+            proc.finished = true;
+            proc.exitCode = code;
+            const tail = (stdout + stderr).slice(-3000);
+            const truncated = (stdout + stderr).length > 3000 ? "[...truncated]\n" + tail : tail;
+            // 最终输出写入日志
+            try { writeFileSync(logFile, stdout + stderr); } catch {}
+
+            pi.sendMessage({
+              content: `[BG_PROCESS_DONE] PID ${pid} finished (exit ${code ?? "?"})\nCommand: ${command}\n\nOutput (last 3000 chars):\n${truncated}`,
+              display: true,
+              triggerTurn: true,
+              deliverAs: "followUp",
+            });
+          });
 
           const preview = (stdout + stderr).slice(0, 500);
-          const text = `Command still running after ${effectiveTimeout / 1000}s, moved to background.\nPID: ${pid}\nLog: ${logFile}\nView output: tail -f ${logFile}\nStop: kill ${pid}\n\nOutput so far:\n${preview}`;
+          const text = `Command still running after ${effectiveTimeout / 1000}s, moved to background.\nPID: ${pid}\nLog: ${logFile}\nStop: kill ${pid}\n\nOutput so far:\n${preview}\n\n⏳ You will be notified automatically when it finishes. No need to poll.`;
 
           resolve({
             content: [{ type: "text", text }],
@@ -85,7 +111,7 @@ export default function (pi: ExtensionAPI) {
           });
         }, effectiveTimeout);
 
-        // 正常结束
+        // 正常结束（超时前）
         child.on("close", (code) => {
           if (settled) return;
           settled = true;
@@ -146,8 +172,7 @@ export default function (pi: ExtensionAPI) {
           return { content: [{ type: "text", text: "No background processes." }], details: {} };
         }
         const lines = [...bgProcesses.values()].map((p) => {
-          const alive = isAlive(p.pid);
-          const status = alive ? "🟢 running" : "⚪ stopped";
+          const status = p.finished ? `⚪ stopped (exit ${p.exitCode ?? "?"})` : (isAlive(p.pid) ? "🟢 running" : "⚪ stopped");
           return `PID: ${p.pid} | ${status} | Log: ${p.logFile}\n  Cmd: ${p.command}`;
         });
         return { content: [{ type: "text", text: lines.join("\n\n") }], details: {} };
@@ -171,13 +196,7 @@ export default function (pi: ExtensionAPI) {
             return { content: [{ type: "text", text: `Error reading log: ${e.message}` }], details: {}, isError: true };
           }
         }
-        // fallback: 直接读 /proc
-        try {
-          const out = execSync(`tail -20 /proc/${pid}/fd/1 2>/dev/null || echo "(cannot read output)"`, { timeout: 3000 }).toString();
-          return { content: [{ type: "text", text: out }], details: {} };
-        } catch {
-          return { content: [{ type: "text", text: "No log available for this PID." }], details: {} };
-        }
+        return { content: [{ type: "text", text: "No log available for this PID." }], details: {} };
       }
 
       if (action === "stop") {
@@ -197,8 +216,10 @@ export default function (pi: ExtensionAPI) {
 
   // 清理：退出时杀掉所有后台进程
   pi.on("session_shutdown", async () => {
-    for (const [pid] of bgProcesses) {
-      try { process.kill(pid, "SIGTERM"); } catch {}
+    for (const [pid, proc] of bgProcesses) {
+      if (!proc.finished) {
+        try { process.kill(pid, "SIGTERM"); } catch {}
+      }
     }
     bgProcesses.clear();
   });