oh-pi 0.1.76 → 0.1.78

package/README.md

@@ -157,7 +157,7 @@ Use `/colony-stop` to abort a running colony.
 
 ### Signal Protocol
 
-The colony communicates with the main conversation via structured signals, so the model never has to guess background state:
+The colony communicates with the main conversation via structured signals, so the model never has to guess background state. Updates are passively pushed (non-blocking), so polling is optional:
 
 | Signal | Meaning |
 |--------|---------|

package/README.zh.md

@@ -163,7 +163,7 @@ pi（主进程）
 
 ### 信号协议
 
-蚁群通过结构化信号与主对话通信，让模型无需猜测后台状态：
+蚁群通过结构化信号与主对话通信，让模型无需猜测后台状态。更新采用被动推送（非阻塞），轮询仅在手动排障时需要：
 
 | 信号 | 含义 |
 |------|------|

package/dist/index.js

@@ -43,7 +43,7 @@ async function quickFlow(env) {
         providers,
         theme: "dark",
         keybindings: "default",
-        extensions: ["safe-guard", "git-guard", "auto-session-name", "custom-footer", "compact-header", "auto-update", "smart-compact"],
+        extensions: ["safe-guard", "git-guard", "auto-session-name", "custom-footer", "compact-header", "auto-update"],
         prompts: ["review", "fix", "explain", "commit", "test"],
         agents: "general-developer",
         thinking: "medium",

package/dist/registry.js

@@ -49,7 +49,6 @@ export const EXTENSIONS = [
     { name: "compact-header", label: "⚡ Compact Header — Dense startup info replacing verbose output", default: true },
     { name: "ant-colony", label: "🐜 Ant Colony — Autonomous multi-agent swarm with adaptive concurrency", default: false },
     { name: "auto-update", label: "🔄 Auto Update — Check for oh-pi updates on startup and notify", default: true },
-    { name: "smart-compact", label: "🗜️  Smart Compact — Trim large tool outputs and old messages in-flight", default: true },
     { name: "bg-process", label: "⏳ Bg Process — Auto-background long-running commands (dev servers, etc.)", default: false },
 ];
 /** 快捷键绑定方案（default / vim / emacs） */

package/dist/utils/writers.js

@@ -3,6 +3,15 @@ import { join } from "node:path";
 import { KEYBINDING_SCHEMES, MODEL_CAPABILITIES, PROVIDERS } from "../registry.js";
 import { resources } from "./resources.js";
 import { ensureDir, syncDir } from "./install.js";
+const ANT_COLONY_AUTOTRIGGER_GUIDE = `## Ant Colony Auto-Trigger
+If the ant_colony tool is available, automatically use it when the task is complex:
+- 3 or more files likely need changes
+- 2 or more independent workstreams exist
+- large refactor / migration / feature implementation
+
+For simple one-file tasks, execute directly without colony overhead.
+After launching ant_colony, use passive mode: wait for COLONY_SIGNAL updates and do not poll bg_colony_status unless the user explicitly asks for a manual snapshot.
+`;
 /** 步骤 1-2: 生成 auth.json + settings.json */
 export function writeProviderEnv(agentDir, config) {
     // auth.json
@@ -103,6 +112,9 @@ export function writeAgents(agentDir, config) {
             const lang = langNames[config.locale] ?? config.locale;
             content = `## Language\nAlways respond in ${lang}. Use the user's language for all conversations and explanations. Code, commands, and technical terms can remain in English.\n\n${content}`;
         }
+        if (config.extensions.includes("ant-colony") && config.agents !== "colony-operator") {
+            content = `${content.trimEnd()}\n\n${ANT_COLONY_AUTOTRIGGER_GUIDE}`;
+        }
         writeFileSync(join(agentDir, "AGENTS.md"), content);
     }
     catch { /* template not found, skip */ }

package/dist/utils/writers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/writers.test.js

@@ -0,0 +1,60 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { writeAgents } from "./writers.js";
+const tempDirs = [];
+function makeTempDir() {
+    const dir = mkdtempSync(join(tmpdir(), "oh-pi-writers-"));
+    tempDirs.push(dir);
+    return dir;
+}
+function makeConfig(overrides) {
+    return {
+        providers: [],
+        theme: "dark",
+        keybindings: "default",
+        extensions: [],
+        prompts: [],
+        agents: "general-developer",
+        thinking: "medium",
+        ...overrides,
+    };
+}
+afterEach(() => {
+    for (const dir of tempDirs.splice(0)) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe("writeAgents", () => {
+    it("appends ant-colony auto-trigger guidance for non-colony operator agents", () => {
+        const dir = makeTempDir();
+        writeAgents(dir, makeConfig({
+            agents: "general-developer",
+            extensions: ["ant-colony"],
+        }));
+        const content = readFileSync(join(dir, "AGENTS.md"), "utf8");
+        expect(content).toContain("## Ant Colony Auto-Trigger");
+        expect(content).toContain("automatically use it when the task is complex");
+        expect(content).toContain("COLONY_SIGNAL");
+    });
+    it("does not append guidance when ant-colony extension is disabled", () => {
+        const dir = makeTempDir();
+        writeAgents(dir, makeConfig({
+            agents: "general-developer",
+            extensions: [],
+        }));
+        const content = readFileSync(join(dir, "AGENTS.md"), "utf8");
+        expect(content).not.toContain("## Ant Colony Auto-Trigger");
+    });
+    it("does not append duplicate guidance for colony-operator template", () => {
+        const dir = makeTempDir();
+        writeAgents(dir, makeConfig({
+            agents: "colony-operator",
+            extensions: ["ant-colony"],
+        }));
+        const content = readFileSync(join(dir, "AGENTS.md"), "utf8");
+        expect(content).not.toContain("## Ant Colony Auto-Trigger");
+        expect(content).toContain("You command an autonomous ant colony");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-pi",
-  "version": "0.1.76",
+  "version": "0.1.78",
   "description": "One-click setup for pi-coding-agent. Like oh-my-zsh for pi.",
   "type": "module",
   "bin": {
@@ -10,7 +10,9 @@
   "files": [
     "dist",
     "pi-package",
-    "README.md"
+    "README.md",
+    "!**/*.test.ts",
+    "!**/*.spec.ts"
   ],
   "scripts": {
     "build": "tsc",

package/pi-package/agents/colony-operator.md

@@ -17,8 +17,9 @@ You command an autonomous ant colony. Complex tasks are delegated to the swarm,
 ## Workflow
 1. Assess task scope
 2. If colony-worthy → use `ant_colony` tool with clear goal
-3. If simple → do it directly
-4. Review colony output, fix gaps manually if needed
+3. After launch, use passive mode: wait for `COLONY_SIGNAL:*` updates; do not poll `bg_colony_status` unless user explicitly asks
+4. If simple → do it directly
+5. Review colony output, fix gaps manually if needed
 
 ## Code Standards
 - Follow existing conventions

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

@@ -59,6 +59,44 @@ export default function antColonyExtension(pi: ExtensionAPI) {
   // 当前运行中的后台蚁群（同时只允许一个）
   let activeColony: BackgroundColony | null = null;
 
+  // 防止主进程主动轮询导致阻塞：仅允许显式请求的手动快照，并加冷却
+  let lastBgStatusSnapshotAt = 0;
+  const STATUS_SNAPSHOT_COOLDOWN_MS = 15_000;
+
+  const extractMessageText = (message: any): string => {
+    const c = message?.content;
+    if (typeof c === "string") return c;
+    if (Array.isArray(c)) {
+      return c.map((p: any) => {
+        if (typeof p === "string") return p;
+        if (typeof p?.text === "string") return p.text;
+        if (typeof p?.content === "string") return p.content;
+        return "";
+      }).join("\n");
+    }
+    return "";
+  };
+
+  const lastUserMessageText = (ctx: any): string => {
+    try {
+      const branch = ctx?.sessionManager?.getBranch?.() ?? [];
+      for (let i = branch.length - 1; i >= 0; i--) {
+        const e = branch[i];
+        if (e?.type === "message" && e.message?.role === "user") {
+          return extractMessageText(e.message).trim();
+        }
+      }
+    } catch {
+      // ignore
+    }
+    return "";
+  };
+
+  const isExplicitStatusRequest = (ctx: any): boolean => {
+    const text = lastUserMessageText(ctx);
+    return /(?:\/colony-status|bg_colony_status)|(?:(?:蚁群|colony).{0,20}(?:状态|进度|进展|汇报|快照|status|progress|snapshot|update|check))|(?:(?:状态|进度|进展|汇报|快照|status|progress|snapshot|update|check).{0,20}(?:蚁群|colony))/i.test(text);
+  };
+
   const calcProgress = (m?: ColonyMetrics | null) => {
     if (!m || m.tasksTotal <= 0) return 0;
     return Math.max(0, Math.min(1, m.tasksDone / m.tasksTotal));
@@ -280,6 +318,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
     colony.promise = resume ? resumeColony(colonyOpts) : runColony(colonyOpts);
 
     activeColony = colony;
+    lastBgStatusSnapshotAt = 0;
     throttledRender();
 
     // 后台等待完成，注入结果
@@ -627,7 +666,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
       launchBackgroundColony(colonyParams);
 
       return {
-        content: [{ type: "text", text: `[COLONY_SIGNAL:LAUNCHED]\n🐜 Colony launched in background.\nGoal: ${params.goal}\n\nThe colony is now running autonomously. Results will be injected when it finishes.` }],
+        content: [{ type: "text", text: `[COLONY_SIGNAL:LAUNCHED]\n🐜 Colony launched in background.\nGoal: ${params.goal}\n\nThe colony runs autonomously in passive mode. Progress is pushed via [COLONY_SIGNAL:*] follow-up messages. Do not poll bg_colony_status unless the user explicitly asks for a manual snapshot.` }],
       };
     },
 
@@ -689,9 +728,40 @@ export default function antColonyExtension(pi: ExtensionAPI) {
   pi.registerTool({
     name: "bg_colony_status",
     label: "Colony Status",
-    description: "Check the status of a running background ant colony. Use this instead of bg_status to monitor colony progress.",
+    description: "Optional manual snapshot for a running colony. Progress is pushed passively via COLONY_SIGNAL follow-up messages; call this only when the user explicitly asks.",
     parameters: Type.Object({}),
-    async execute() {
+    async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+      if (!activeColony) {
+        return {
+          content: [{ type: "text" as const, text: "No colony is currently running." }],
+        };
+      }
+
+      const explicit = isExplicitStatusRequest(ctx);
+      if (!explicit) {
+        return {
+          content: [{
+            type: "text" as const,
+            text: "Passive mode is active. Colony progress is already pushed via [COLONY_SIGNAL:*] follow-up messages. Skipping bg_colony_status polling to avoid blocking the main process. Ask explicitly for a manual snapshot if needed.",
+          }],
+          isError: true,
+        };
+      }
+
+      const now = Date.now();
+      const delta = now - lastBgStatusSnapshotAt;
+      if (delta < STATUS_SNAPSHOT_COOLDOWN_MS) {
+        const waitSec = Math.ceil((STATUS_SNAPSHOT_COOLDOWN_MS - delta) / 1000);
+        return {
+          content: [{
+            type: "text" as const,
+            text: `Manual status snapshot is rate-limited. Please wait ${waitSec}s to avoid active polling loops.`,
+          }],
+          isError: true,
+        };
+      }
+
+      lastBgStatusSnapshotAt = now;
       return {
         content: [{ type: "text" as const, text: buildStatusText() }],
       };

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

@@ -1,70 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { defaultConcurrency, adapt } from "./concurrency.js";
-import type { ConcurrencyConfig, ConcurrencySample } from "./types.js";
-
-const mkSample = (o: Partial<ConcurrencySample> = {}): ConcurrencySample => ({
-  timestamp: Date.now(), concurrency: 2, cpuLoad: 0.3, memFree: 4e9, throughput: 1, ...o,
-});
-
-describe("defaultConcurrency", () => {
-  it("returns valid config", () => {
-    const c = defaultConcurrency();
-    expect(c.current).toBe(2);
-    expect(c.min).toBe(1);
-    expect(c.max).toBeGreaterThanOrEqual(1);
-    expect(c.max).toBeLessThanOrEqual(8);
-    expect(c.history).toEqual([]);
-  });
-});
-
-describe("adapt", () => {
-  it("drops to min when no pending tasks", () => {
-    const cfg: ConcurrencyConfig = { current: 4, min: 1, max: 8, optimal: 3, history: [mkSample(), mkSample()] };
-    expect(adapt(cfg, 0).current).toBe(1);
-  });
-
-  it("cold start gives half max", () => {
-    const cfg: ConcurrencyConfig = { current: 2, min: 1, max: 8, optimal: 3, history: [mkSample()] };
-    expect(adapt(cfg, 10).current).toBe(4);
-  });
-
-  it("reduces when CPU > 85%", () => {
-    const s = mkSample({ cpuLoad: 0.9 });
-    const cfg: ConcurrencyConfig = { current: 4, min: 1, max: 8, optimal: 3, history: [s, s, s] };
-    expect(adapt(cfg, 10).current).toBeLessThan(4);
-  });
-
-  it("reduces when memory low", () => {
-    const s = mkSample({ memFree: 100 * 1024 * 1024 });
-    const cfg: ConcurrencyConfig = { current: 4, min: 1, max: 8, optimal: 3, history: [s, s] };
-    expect(adapt(cfg, 10).current).toBeLessThan(4);
-  });
-
-  it("increases during exploration when throughput rising", () => {
-    const s1 = mkSample({ throughput: 1 });
-    const s2 = mkSample({ throughput: 2 });
-    const cfg: ConcurrencyConfig = { current: 3, min: 1, max: 8, optimal: 3, history: [s1, s2] };
-    expect(adapt(cfg, 10).current).toBeGreaterThanOrEqual(3);
-  });
-
-  it("does not exceed max", () => {
-    const s1 = mkSample({ throughput: 1 });
-    const s2 = mkSample({ throughput: 5 });
-    const cfg: ConcurrencyConfig = { current: 8, min: 1, max: 8, optimal: 3, history: [s1, s2] };
-    expect(adapt(cfg, 100).current).toBeLessThanOrEqual(8);
-  });
-
-  it("does not exceed pending task count", () => {
-    const s1 = mkSample({ throughput: 1 });
-    const s2 = mkSample({ throughput: 5 });
-    const cfg: ConcurrencyConfig = { current: 3, min: 1, max: 8, optimal: 3, history: [s1, s2] };
-    expect(adapt(cfg, 2).current).toBeLessThanOrEqual(2);
-  });
-
-  it("respects rate limit cooldown", () => {
-    const s1 = mkSample({ throughput: 1 });
-    const s2 = mkSample({ throughput: 2 });
-    const cfg: ConcurrencyConfig = { current: 3, min: 1, max: 8, optimal: 3, history: [s1, s2], lastRateLimitAt: Date.now() };
-    expect(adapt(cfg, 10).current).toBeLessThanOrEqual(3);
-  });
-});

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

@@ -1,62 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { buildImportGraph, dependencyDepth, taskDependsOn } from "./deps.js";
-import type { ImportGraph } from "./deps.js";
-
-describe("buildImportGraph", () => {
-  it("returns empty graph for empty files", () => {
-    const graph = buildImportGraph([], "/tmp");
-    expect(graph.imports.size).toBe(0);
-    expect(graph.importedBy.size).toBe(0);
-  });
-
-  it("returns empty graph for nonexistent files", () => {
-    const graph = buildImportGraph(["nonexistent.ts"], "/tmp");
-    expect(graph.imports.size).toBe(0);
-  });
-});
-
-describe("dependencyDepth", () => {
-  it("returns 0 for file with no dependents", () => {
-    const graph: ImportGraph = { imports: new Map(), importedBy: new Map() };
-    expect(dependencyDepth("a.ts", graph)).toBe(0);
-  });
-
-  it("counts direct dependents", () => {
-    const graph: ImportGraph = {
-      imports: new Map([["b.ts", new Set(["a.ts"])]]),
-      importedBy: new Map([["a.ts", new Set(["b.ts"])]]),
-    };
-    expect(dependencyDepth("a.ts", graph)).toBe(1);
-  });
-
-  it("counts transitive dependents", () => {
-    const graph: ImportGraph = {
-      imports: new Map([["b.ts", new Set(["a.ts"])], ["c.ts", new Set(["b.ts"])]]),
-      importedBy: new Map([["a.ts", new Set(["b.ts"])], ["b.ts", new Set(["c.ts"])]]),
-    };
-    expect(dependencyDepth("a.ts", graph)).toBe(2);
-  });
-});
-
-describe("taskDependsOn", () => {
-  it("returns true when taskA imports taskB file", () => {
-    const graph: ImportGraph = {
-      imports: new Map([["a.ts", new Set(["b.ts"])]]),
-      importedBy: new Map([["b.ts", new Set(["a.ts"])]]),
-    };
-    expect(taskDependsOn(["a.ts"], ["b.ts"], graph)).toBe(true);
-  });
-
-  it("returns false when no dependency", () => {
-    const graph: ImportGraph = {
-      imports: new Map([["a.ts", new Set(["c.ts"])]]),
-      importedBy: new Map(),
-    };
-    expect(taskDependsOn(["a.ts"], ["b.ts"], graph)).toBe(false);
-  });
-
-  it("returns false for empty file lists", () => {
-    const graph: ImportGraph = { imports: new Map(), importedBy: new Map() };
-    expect(taskDependsOn([], [], graph)).toBe(false);
-  });
-});

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

@@ -1,130 +0,0 @@
-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/parser.test.ts

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