oh-pi 0.1.77 → 0.1.78

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.77",
+  "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/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);
-  });
-});

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

@@ -1,99 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { CASTE_PROMPTS, buildPrompt } from "./prompts.js";
-import type { Task } from "./types.js";
-
-const mkTask = (overrides: Partial<Task> = {}): Task => ({
-  id: "t-1", parentId: null, title: "Test task", description: "Do something",
-  caste: "worker", status: "pending", priority: 3, files: [], claimedBy: null,
-  result: null, error: null, spawnedTasks: [], createdAt: 0, startedAt: null, finishedAt: null,
-  ...overrides,
-});
-
-describe("CASTE_PROMPTS", () => {
-  it("has all castes", () => {
-    for (const c of ["scout", "worker", "soldier"] as const) {
-      expect(typeof CASTE_PROMPTS[c]).toBe("string");
-      expect(CASTE_PROMPTS[c].length).toBeGreaterThan(0);
-    }
-  });
-});
-
-describe("buildPrompt", () => {
-  it("includes task title and description", () => {
-    const r = buildPrompt(mkTask(), "", "System");
-    expect(r).toContain("Test task");
-    expect(r).toContain("Do something");
-  });
-
-  it("includes pheromone context", () => {
-    const r = buildPrompt(mkTask(), "Found auth at src/auth.ts", "System");
-    expect(r).toContain("Found auth at src/auth.ts");
-  });
-
-  it("includes files scope", () => {
-    const r = buildPrompt(mkTask({ files: ["a.ts", "b.ts"] }), "", "System");
-    expect(r).toContain("a.ts, b.ts");
-  });
-
-  it("includes turn limit when provided", () => {
-    const r = buildPrompt(mkTask(), "", "System", 10);
-    expect(r).toContain("10");
-    expect(r).toContain("Turn Limit");
-  });
-
-  it("omits turn limit when not provided", () => {
-    expect(buildPrompt(mkTask(), "", "System")).not.toContain("Turn Limit");
-  });
-
-  it("includes pre-loaded context", () => {
-    const r = buildPrompt(mkTask({ context: "code snippet" }), "", "System");
-    expect(r).toContain("code snippet");
-  });
-
-  it("adds Chinese hint for Chinese descriptions", () => {
-    const r = buildPrompt(mkTask({ description: "修复登录问题" }), "", "System");
-    expect(r).toContain("Chinese");
-  });
-
-  // Bio 3: 串联觅食 — tandem context
-  it("includes tandem parent result when provided", () => {
-    const r = buildPrompt(mkTask(), "", "System", 10, { parentResult: "Parent found auth module at src/auth.ts" });
-    expect(r).toContain("Tandem Context");
-    expect(r).toContain("Parent found auth module");
-  });
-
-  it("includes tandem prior error when provided", () => {
-    const r = buildPrompt(mkTask(), "", "System", 10, { priorError: "TypeError: cannot read property" });
-    expect(r).toContain("Prior Attempt Failed");
-    expect(r).toContain("TypeError: cannot read property");
-  });
-
-  it("includes both tandem fields when provided", () => {
-    const r = buildPrompt(mkTask(), "", "System", 10, {
-      parentResult: "Scout found files",
-      priorError: "Build failed",
-    });
-    expect(r).toContain("Tandem Context");
-    expect(r).toContain("Prior Attempt Failed");
-  });
-
-  it("omits tandem sections when not provided", () => {
-    const r = buildPrompt(mkTask(), "", "System", 10);
-    expect(r).not.toContain("Tandem Context");
-    expect(r).not.toContain("Prior Attempt Failed");
-  });
-
-  it("omits tandem sections when empty object", () => {
-    const r = buildPrompt(mkTask(), "", "System", 10, {});
-    expect(r).not.toContain("Tandem Context");
-    expect(r).not.toContain("Prior Attempt Failed");
-  });
-
-  it("truncates long parent result", () => {
-    const longResult = "x".repeat(5000);
-    const r = buildPrompt(mkTask(), "", "System", 10, { parentResult: longResult });
-    expect(r).toContain("Tandem Context");
-    // Should be truncated to 3000 chars
-    expect(r.length).toBeLessThan(longResult.length);
-  });
-});

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

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

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

@@ -1,44 +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() }));
-
-import { makeAntId, makePheromoneId, makeTaskId } from "./spawner.js";
-
-describe("makeAntId", () => {
-  it("includes caste name", () => {
-    expect(makeAntId("scout")).toContain("scout");
-    expect(makeAntId("worker")).toContain("worker");
-  });
-
-  it("returns unique ids", () => {
-    expect(makeAntId("worker")).not.toBe(makeAntId("worker"));
-  });
-});
-
-describe("makePheromoneId", () => {
-  it("starts with p-", () => {
-    expect(makePheromoneId()).toMatch(/^p-/);
-  });
-
-  it("returns unique ids", () => {
-    expect(makePheromoneId()).not.toBe(makePheromoneId());
-  });
-});
-
-describe("makeTaskId", () => {
-  it("starts with t-", () => {
-    expect(makeTaskId()).toMatch(/^t-/);
-  });
-
-  it("returns unique ids", () => {
-    expect(makeTaskId()).not.toBe(makeTaskId());
-  });
-});

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

@@ -1,36 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { DEFAULT_ANT_CONFIGS } from "./types.js";
-import type { AntCaste } from "./types.js";
-
-describe("DEFAULT_ANT_CONFIGS", () => {
-  const castes: AntCaste[] = ["scout", "worker", "soldier", "drone"];
-
-  it("has all castes", () => {
-    for (const c of castes) expect(DEFAULT_ANT_CONFIGS).toHaveProperty(c);
-  });
-
-  it("each config has caste/model/tools/maxTurns", () => {
-    for (const c of castes) {
-      const cfg = DEFAULT_ANT_CONFIGS[c];
-      expect(cfg.caste).toBe(c);
-      expect(typeof cfg.model).toBe("string");
-      expect(Array.isArray(cfg.tools)).toBe(true);
-      expect(cfg.maxTurns).toBeGreaterThan(0);
-    }
-  });
-
-  it("scout has no write tools", () => {
-    expect(DEFAULT_ANT_CONFIGS.scout.tools).not.toContain("edit");
-    expect(DEFAULT_ANT_CONFIGS.scout.tools).not.toContain("write");
-  });
-
-  it("worker has edit and write", () => {
-    expect(DEFAULT_ANT_CONFIGS.worker.tools).toContain("edit");
-    expect(DEFAULT_ANT_CONFIGS.worker.tools).toContain("write");
-  });
-
-  it("drone only has bash with 1 turn", () => {
-    expect(DEFAULT_ANT_CONFIGS.drone.tools).toEqual(["bash"]);
-    expect(DEFAULT_ANT_CONFIGS.drone.maxTurns).toBe(1);
-  });
-});

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

@@ -1,84 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { formatDuration, formatCost, formatTokens, statusIcon, statusLabel, progressBar, casteIcon, buildReport } from "./ui.js";
-import type { ColonyState } from "./types.js";
-
-describe("formatDuration", () => {
-  it("0ms", () => expect(formatDuration(0)).toBe("0s"));
-  it("5000ms", () => expect(formatDuration(5000)).toBe("5s"));
-  it("59000ms", () => expect(formatDuration(59000)).toBe("59s"));
-  it("60000ms", () => expect(formatDuration(60000)).toBe("1m0s"));
-  it("90000ms", () => expect(formatDuration(90000)).toBe("1m30s"));
-});
-
-describe("formatCost", () => {
-  it("0.001", () => expect(formatCost(0.001)).toBe("$0.0010"));
-  it("0.009", () => expect(formatCost(0.009)).toBe("$0.0090"));
-  it("0.01", () => expect(formatCost(0.01)).toBe("$0.01"));
-  it("1.5", () => expect(formatCost(1.5)).toBe("$1.50"));
-});
-
-describe("formatTokens", () => {
-  it("500", () => expect(formatTokens(500)).toBe("500"));
-  it("999", () => expect(formatTokens(999)).toBe("999"));
-  it("1500", () => expect(formatTokens(1500)).toBe("1.5k"));
-  it("1500000", () => expect(formatTokens(1500000)).toBe("1.5M"));
-});
-
-describe("statusIcon", () => {
-  it("launched", () => expect(statusIcon("launched")).toBe("🚀"));
-  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("task_done", () => expect(statusIcon("task_done")).toBe("✅"));
-  it("done", () => expect(statusIcon("done")).toBe("✅"));
-  it("failed", () => expect(statusIcon("failed")).toBe("❌"));
-  it("budget_exceeded", () => expect(statusIcon("budget_exceeded")).toBe("💰"));
-  it("unknown", () => expect(statusIcon("xyz")).toBe("🐜"));
-});
-
-describe("statusLabel", () => {
-  it("launched", () => expect(statusLabel("launched")).toBe("LAUNCHED"));
-  it("scouting", () => expect(statusLabel("scouting")).toBe("SCOUTING"));
-  it("planning_recovery", () => expect(statusLabel("planning_recovery")).toBe("PLANNING_RECOVERY"));
-  it("task_done", () => expect(statusLabel("task_done")).toBe("TASK_DONE"));
-  it("budget_exceeded", () => expect(statusLabel("budget_exceeded")).toBe("BUDGET_EXCEEDED"));
-  it("unknown", () => expect(statusLabel("custom")).toBe("CUSTOM"));
-});
-
-describe("progressBar", () => {
-  it("0%", () => expect(progressBar(0, 10)).toBe("[----------]"));
-  it("50%", () => expect(progressBar(0.5, 10)).toBe("[#####-----]"));
-  it("100%", () => expect(progressBar(1, 10)).toBe("[##########]"));
-});
-
-describe("casteIcon", () => {
-  it("scout", () => expect(casteIcon("scout")).toBe("🔍"));
-  it("soldier", () => expect(casteIcon("soldier")).toBe("🛡️"));
-  it("drone", () => expect(casteIcon("drone")).toBe("⚙️"));
-  it("worker", () => expect(casteIcon("worker")).toBe("⚒️"));
-  it("unknown", () => expect(casteIcon("xyz")).toBe("⚒️"));
-});
-
-describe("buildReport", () => {
-  it("builds report with goal, status, cost, tasks", () => {
-    const state: ColonyState = {
-      id: "c-1", goal: "Test goal", status: "done",
-      tasks: [
-        { id: "t1", parentId: null, title: "Task A", description: "", caste: "worker", status: "done", priority: 3, files: [], claimedBy: null, result: null, error: null, spawnedTasks: [], createdAt: 0, startedAt: 0, finishedAt: 1000 },
-        { id: "t2", parentId: null, title: "Task B", description: "", caste: "worker", status: "failed", priority: 3, files: [], claimedBy: null, result: null, error: "some error", spawnedTasks: [], createdAt: 0, startedAt: 0, finishedAt: 1000 },
-      ],
-      ants: [], pheromones: [],
-      concurrency: { current: 2, min: 1, max: 4, optimal: 3, history: [] },
-      metrics: { tasksTotal: 2, tasksDone: 1, tasksFailed: 1, antsSpawned: 2, totalCost: 0.05, totalTokens: 1000, startTime: 0, throughputHistory: [] },
-      maxCost: null, modelOverrides: {}, createdAt: 0, finishedAt: 5000,
-    };
-    const report = buildReport(state);
-    expect(report).toContain("Test goal");
-    expect(report).toContain("✅");
-    expect(report).toContain("$0.05");
-    expect(report).toContain("Task A");
-    expect(report).toContain("Task B");
-    expect(report).toContain("some error");
-  });
-});

package/pi-package/extensions/auto-update.test.ts

@@ -1,15 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-
-vi.mock("@mariozechner/pi-coding-agent", () => ({}));
-
-import { isNewer } from "./auto-update";
-
-describe("isNewer", () => {
-  it("patch newer", () => expect(isNewer("1.0.1", "1.0.0")).toBe(true));
-  it("minor newer", () => expect(isNewer("1.1.0", "1.0.0")).toBe(true));
-  it("major newer", () => expect(isNewer("2.0.0", "1.9.9")).toBe(true));
-  it("equal", () => expect(isNewer("1.0.0", "1.0.0")).toBe(false));
-  it("older", () => expect(isNewer("1.0.0", "1.0.1")).toBe(false));
-  it("0.1.70 > 0.1.69", () => expect(isNewer("0.1.70", "0.1.69")).toBe(true));
-  it("0.1.69 < 0.1.70", () => expect(isNewer("0.1.69", "0.1.70")).toBe(false));
-});

package/pi-package/extensions/safe-guard.test.ts

@@ -1,26 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { DANGEROUS_PATTERNS, PROTECTED_PATHS } from "./safe-guard";
-
-describe("DANGEROUS_PATTERNS", () => {
-  const matches = (cmd: string) => DANGEROUS_PATTERNS.some((p) => p.test(cmd));
-
-  it("matches rm -rf /", () => expect(matches("rm -rf /")).toBe(true));
-  it("matches rm -f file.txt", () => expect(matches("rm -f file.txt")).toBe(true));
-  it("matches rm --force file", () => expect(matches("rm --force file")).toBe(true));
-  it("matches sudo rm file", () => expect(matches("sudo rm file")).toBe(true));
-  it("matches DROP TABLE users", () => expect(matches("DROP TABLE users")).toBe(true));
-  it("matches TRUNCATE TABLE foo", () => expect(matches("TRUNCATE TABLE foo")).toBe(true));
-  it("matches DELETE FROM users", () => expect(matches("DELETE FROM users")).toBe(true));
-  it("matches chmod 777 /tmp", () => expect(matches("chmod 777 /tmp")).toBe(true));
-  it("matches mkfs /dev/sda", () => expect(matches("mkfs /dev/sda")).toBe(true));
-  it("matches dd if=/dev/zero", () => expect(matches("dd if=/dev/zero")).toBe(true));
-  it("does not match ls -la", () => expect(matches("ls -la")).toBe(false));
-  it("does not match echo hello", () => expect(matches("echo hello")).toBe(false));
-});
-
-describe("PROTECTED_PATHS", () => {
-  it("contains all expected paths", () => {
-    expect(PROTECTED_PATHS).toEqual([".env", ".git/", "node_modules/", ".pi/", "id_rsa", ".ssh/"]);
-  });
-  it("has length 6", () => expect(PROTECTED_PATHS).toHaveLength(6));
-});