oh-pi 0.1.70 → 0.1.71

package/dist/i18n.test.d.ts

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

package/dist/i18n.test.js

@@ -0,0 +1,56 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { t, setLocale, getLocale } from "./i18n.js";
+afterEach(() => setLocale("en"));
+describe("t", () => {
+    it("returns known en key", () => {
+        expect(t("welcome.title")).toContain("oh-pi");
+    });
+    it("interpolates vars", () => {
+        const result = t("welcome.piDetected", { version: "1.0" });
+        expect(result).toContain("1.0");
+    });
+    it("falls back to en when zh key missing", () => {
+        setLocale("zh");
+        const enVal = t("welcome.title");
+        expect(enVal).toBeTruthy();
+        expect(enVal).not.toBe("welcome.title");
+    });
+    it("falls back to key string when key missing in all locales", () => {
+        expect(t("nonexistent.key.xyz")).toBe("nonexistent.key.xyz");
+    });
+    it("setLocale/getLocale round-trip en", () => {
+        setLocale("en");
+        expect(getLocale()).toBe("en");
+    });
+    it("setLocale/getLocale round-trip zh", () => {
+        setLocale("zh");
+        expect(getLocale()).toBe("zh");
+    });
+    it("setLocale/getLocale round-trip fr", () => {
+        setLocale("fr");
+        expect(getLocale()).toBe("fr");
+    });
+    it("returns zh translation after setLocale zh", () => {
+        const enResult = t("welcome.title");
+        setLocale("zh");
+        const zhResult = t("welcome.title");
+        expect(zhResult).toContain("oh-pi");
+        expect(zhResult).not.toBe(enResult);
+    });
+    it("interpolates multiple vars", () => {
+        const result = t("welcome.envInfo", { terminal: "xterm", os: "linux", node: "v20" });
+        expect(result).toContain("xterm");
+        expect(result).toContain("linux");
+    });
+    it("returns string without vars unchanged", () => {
+        expect(typeof t("cancelled")).toBe("string");
+    });
+    it("does not crash with empty vars", () => {
+        expect(t("welcome.title", {})).toContain("oh-pi");
+    });
+    it("fr locale returns fr translation", () => {
+        setLocale("fr");
+        const result = t("welcome.title");
+        expect(result).toContain("oh-pi");
+    });
+});

package/dist/registry.test.d.ts

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

package/dist/registry.test.js

@@ -0,0 +1,68 @@
+import { describe, it, expect } from "vitest";
+import { MODEL_CAPABILITIES, PROVIDERS, THEMES, EXTENSIONS, KEYBINDING_SCHEMES } from "./registry.js";
+describe("MODEL_CAPABILITIES", () => {
+    it("has entries", () => {
+        expect(Object.keys(MODEL_CAPABILITIES).length).toBeGreaterThan(0);
+    });
+    it("each entry has required fields", () => {
+        for (const [, cap] of Object.entries(MODEL_CAPABILITIES)) {
+            expect(cap).toHaveProperty("contextWindow");
+            expect(cap).toHaveProperty("maxTokens");
+            expect(cap).toHaveProperty("reasoning");
+            expect(cap).toHaveProperty("input");
+            expect(cap.contextWindow).toBeGreaterThan(0);
+            expect(cap.maxTokens).toBeGreaterThan(0);
+        }
+    });
+});
+describe("PROVIDERS", () => {
+    const expected = ["anthropic", "openai", "google", "groq", "openrouter", "xai", "mistral"];
+    it("has 7 providers", () => {
+        expect(Object.keys(PROVIDERS)).toHaveLength(7);
+    });
+    it("contains all expected providers", () => {
+        for (const name of expected) {
+            expect(PROVIDERS).toHaveProperty(name);
+        }
+    });
+    it("each provider has env/label/models", () => {
+        for (const [, info] of Object.entries(PROVIDERS)) {
+            expect(info.env).toMatch(/_API_KEY$|_KEY$/);
+            expect(info.label).toBeTruthy();
+            expect(Array.isArray(info.models)).toBe(true);
+        }
+    });
+});
+describe("THEMES", () => {
+    it("is array with entries", () => {
+        expect(Array.isArray(THEMES)).toBe(true);
+        expect(THEMES.length).toBeGreaterThan(0);
+    });
+    it("each has name/label/style", () => {
+        for (const theme of THEMES) {
+            expect(theme).toHaveProperty("name");
+            expect(theme).toHaveProperty("label");
+            expect(theme).toHaveProperty("style");
+        }
+    });
+});
+describe("EXTENSIONS", () => {
+    it("is array with entries", () => {
+        expect(Array.isArray(EXTENSIONS)).toBe(true);
+        expect(EXTENSIONS.length).toBeGreaterThan(0);
+    });
+    it("each has name/label/default", () => {
+        for (const ext of EXTENSIONS) {
+            expect(ext).toHaveProperty("name");
+            expect(ext).toHaveProperty("label");
+            expect(ext).toHaveProperty("default");
+        }
+    });
+});
+describe("KEYBINDING_SCHEMES", () => {
+    it("has default/vim/emacs", () => {
+        expect(KEYBINDING_SCHEMES).toHaveProperty("default");
+        expect(KEYBINDING_SCHEMES).toHaveProperty("vim");
+        expect(KEYBINDING_SCHEMES).toHaveProperty("emacs");
+    });
+});

package/dist/tui/confirm-apply.d.ts

@@ -1,5 +1,12 @@
 import type { OhPConfig } from "../types.js";
 import type { EnvInfo } from "../utils/detect.js";
+/**
+ * 统计已有配置中指定目录下的文件数量。
+ * @param env - 环境信息
+ * @param dir - 目录名称前缀
+ * @returns 匹配的文件数
+ */
+export declare function countExisting(env: EnvInfo, dir: string): number;
 /**
  * 展示配置摘要，处理已有配置的备份/覆盖，安装 pi（如需），并应用最终配置。
  * @param config - 用户选择的配置对象

package/dist/tui/confirm-apply.js

@@ -8,7 +8,7 @@ import { applyConfig, installPi, backupConfig } from "../utils/install.js";
  * @param dir - 目录名称前缀
  * @returns 匹配的文件数
  */
-function countExisting(env, dir) {
+export function countExisting(env, dir) {
     return env.existingFiles.filter(f => f.startsWith(dir + "/")).length;
 }
 /**

package/dist/tui/confirm-apply.test.d.ts

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

package/dist/tui/confirm-apply.test.js

@@ -0,0 +1,20 @@
+import { describe, it, expect } from "vitest";
+import { countExisting } from "./confirm-apply.js";
+const mkEnv = (files) => ({ existingFiles: files });
+describe("countExisting", () => {
+    it("counts files matching prefix", () => {
+        expect(countExisting(mkEnv(["extensions/a", "extensions/b", "prompts/c"]), "extensions")).toBe(2);
+    });
+    it("returns 0 when no match", () => {
+        expect(countExisting(mkEnv(["extensions/a"]), "themes")).toBe(0);
+    });
+    it("returns 0 for empty existingFiles", () => {
+        expect(countExisting(mkEnv([]), "extensions")).toBe(0);
+    });
+    it("counts different prefix", () => {
+        expect(countExisting(mkEnv(["extensions/a", "extensions/b", "prompts/c"]), "prompts")).toBe(1);
+    });
+    it("does not match without slash separator", () => {
+        expect(countExisting(mkEnv(["extensionsX"]), "extensions")).toBe(0);
+    });
+});

package/dist/tui/provider-setup.d.ts

@@ -1,5 +1,7 @@
 import type { ProviderConfig } from "../types.js";
 import type { EnvInfo } from "../utils/detect.js";
+/** Block internal/private IPs to prevent SSRF */
+export declare function isUnsafeUrl(urlStr: string): boolean;
 /**
  * Interactively configure API providers, detecting existing keys, allowing multi-select, and supporting custom endpoints.
  * @param env - Current environment info with detected providers

package/dist/tui/provider-setup.js

@@ -13,7 +13,7 @@ const PROVIDER_API_URLS = {
     mistral: "https://api.mistral.ai",
 };
 /** Block internal/private IPs to prevent SSRF */
-function isUnsafeUrl(urlStr) {
+export function isUnsafeUrl(urlStr) {
     try {
         const u = new URL(urlStr);
         const host = u.hostname;

package/dist/tui/provider-setup.test.d.ts

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

package/dist/tui/provider-setup.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect } from "vitest";
+import { isUnsafeUrl } from "./provider-setup.js";
+describe("isUnsafeUrl", () => {
+    it("https remote is safe", () => {
+        expect(isUnsafeUrl("https://api.example.com")).toBe(false);
+    });
+    it("http localhost is safe", () => {
+        expect(isUnsafeUrl("http://localhost:11434")).toBe(false);
+    });
+    it("http 127.0.0.1 is safe", () => {
+        expect(isUnsafeUrl("http://127.0.0.1:8080")).toBe(false);
+    });
+    it("http [::1] is blocked (contains colon in hostname)", () => {
+        expect(isUnsafeUrl("http://[::1]:8080")).toBe(true);
+    });
+    it("10.x private is unsafe", () => {
+        expect(isUnsafeUrl("https://10.0.0.1/api")).toBe(true);
+    });
+    it("172.16.x private is unsafe", () => {
+        expect(isUnsafeUrl("https://172.16.0.1/api")).toBe(true);
+    });
+    it("192.168.x private is unsafe", () => {
+        expect(isUnsafeUrl("https://192.168.1.1/api")).toBe(true);
+    });
+    it("http remote is unsafe", () => {
+        expect(isUnsafeUrl("http://api.example.com")).toBe(true);
+    });
+    it("0.0.0.0 is unsafe", () => {
+        expect(isUnsafeUrl("https://0.0.0.0")).toBe(true);
+    });
+    it("169.254.x link-local is unsafe", () => {
+        expect(isUnsafeUrl("https://169.254.1.1")).toBe(true);
+    });
+    it("invalid url is unsafe", () => {
+        expect(isUnsafeUrl("not-a-url")).toBe(true);
+    });
+    it("empty string is unsafe", () => {
+        expect(isUnsafeUrl("")).toBe(true);
+    });
+});

package/dist/tui/welcome.d.ts

@@ -4,3 +4,9 @@ import type { EnvInfo } from "../utils/detect.js";
  * @param {EnvInfo} env - 当前检测到的环境信息
  */
 export declare function welcome(env: EnvInfo): void;
+/**
+ * 按顶层目录分类统计文件数量，返回格式化字符串。
+ * @param {string[]} files - 文件相对路径列表
+ * @returns {string} 分类统计字符串，如 "extensions (3)  prompts (5)"
+ */
+export declare function categorize(files: string[]): string;

package/dist/tui/welcome.js

@@ -28,7 +28,7 @@ export function welcome(env) {
  * @param {string[]} files - 文件相对路径列表
  * @returns {string} 分类统计字符串，如 "extensions (3)  prompts (5)"
  */
-function categorize(files) {
+export function categorize(files) {
     const cats = {};
     for (const f of files) {
         const cat = f.includes("/") ? f.split("/")[0] : f;

package/dist/tui/welcome.test.d.ts

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

package/dist/tui/welcome.test.js

@@ -0,0 +1,25 @@
+import { describe, it, expect } from "vitest";
+import { categorize } from "./welcome.js";
+describe("categorize", () => {
+    it("groups by directory", () => {
+        const result = categorize(["ext/a.ts", "ext/b.ts", "prompts/c.md"]);
+        expect(result).toContain("ext (2)");
+        expect(result).toContain("prompts (1)");
+    });
+    it("empty array returns empty string", () => {
+        expect(categorize([])).toBe("");
+    });
+    it("files without directory use filename", () => {
+        const result = categorize(["a.ts", "b.ts"]);
+        expect(result).toContain("a.ts (1)");
+        expect(result).toContain("b.ts (1)");
+    });
+    it("single file", () => {
+        expect(categorize(["foo/bar.ts"])).toBe("foo (1)");
+    });
+    it("mixed files with and without directory", () => {
+        const result = categorize(["a.ts", "dir/b.ts"]);
+        expect(result).toContain("a.ts (1)");
+        expect(result).toContain("dir (1)");
+    });
+});

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

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

package/dist/utils/resources.test.js

@@ -0,0 +1,39 @@
+import { describe, it, expect } from "vitest";
+import { resources } from "./resources.js";
+describe("resources", () => {
+    it("agent returns correct path", () => {
+        const p = resources.agent("foo");
+        expect(p).toContain("agents/foo.md");
+        expect(p.startsWith("/")).toBe(true);
+    });
+    it("extension returns correct path", () => {
+        const p = resources.extension("bar");
+        expect(p).toContain("extensions/bar");
+        expect(p.startsWith("/")).toBe(true);
+    });
+    it("extensionFile returns correct path", () => {
+        const p = resources.extensionFile("baz");
+        expect(p).toContain("extensions/baz.ts");
+        expect(p.startsWith("/")).toBe(true);
+    });
+    it("prompt returns correct path", () => {
+        const p = resources.prompt("test");
+        expect(p).toContain("prompts/test.md");
+        expect(p.startsWith("/")).toBe(true);
+    });
+    it("skill returns correct path", () => {
+        const p = resources.skill("sk");
+        expect(p).toContain("skills/sk");
+        expect(p.startsWith("/")).toBe(true);
+    });
+    it("skillsDir returns correct path", () => {
+        const p = resources.skillsDir();
+        expect(p).toContain("skills");
+        expect(p.startsWith("/")).toBe(true);
+    });
+    it("theme returns correct path", () => {
+        const p = resources.theme("dark");
+        expect(p).toContain("themes/dark.json");
+        expect(p.startsWith("/")).toBe(true);
+    });
+});

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "oh-pi",
-  "version": "0.1.70",
+  "version": "0.1.71",
   "description": "One-click setup for pi-coding-agent. Like oh-my-zsh for pi.",
   "type": "module",
   "bin": {
-    "oh-pi": "./dist/bin/oh-pi.js"
+    "oh-pi": "dist/bin/oh-pi.js"
   },
   "main": "./dist/index.js",
   "files": [
@@ -16,6 +16,7 @@
     "build": "tsc",
     "dev": "tsc --watch",
     "start": "node dist/bin/oh-pi.js",
+    "test": "vitest run",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -46,7 +47,8 @@
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
-    "typescript": "^5.7.0"
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
   },
   "engines": {
     "node": ">=20.0.0"

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

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,62 @@
+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/index.ts

@@ -51,6 +51,7 @@ export default function antColonyExtension(pi: ExtensionAPI) {
 
   // 当前运行中的后台蚁群（同时只允许一个）
   let activeColony: BackgroundColony | null = null;
+  let uiListenersRegistered = false;
 
   // ─── Status 渲染 ───
 
@@ -64,6 +65,9 @@ export default function antColonyExtension(pi: ExtensionAPI) {
 
   // 监听事件来更新 UI（确保在有 ctx 的上下文中）
   pi.on("session_start", async (_event, ctx) => {
+    if (uiListenersRegistered) return;
+    uiListenersRegistered = true;
+
     pi.events.on("ant-colony:render", () => {
       if (!activeColony) return;
       const { state } = activeColony;

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

@@ -24,6 +24,7 @@ export class Nest {
   private stateCache: ColonyState | null = null;
   private gcCounter: number = 0;
   private pheromoneByFile: Map<string, Pheromone[]> = new Map();
+  private pheromoneIndexDirty: boolean = true;
 
   constructor(private cwd: string, private colonyId: string) {
     this.dir = path.join(cwd, ".ant-colony", colonyId);
@@ -53,6 +54,14 @@ export class Nest {
     return base;
   }
 
+  /** 轻量版 getState：只返回 stateCache + tasks，不触发 pheromone 读取 */
+  getStateLight(): ColonyState {
+    if (!this.stateCache) {
+      this.stateCache = this.readJson<ColonyState>(this.stateFile);
+    }
+    return { ...this.stateCache, tasks: this.getAllTasks() };
+  }
+
   updateState(patch: Partial<Pick<ColonyState, "status" | "concurrency" | "metrics" | "ants" | "finishedAt">>): void {
     this.withStateLock(() => {
       if (!this.stateCache) {
@@ -158,43 +167,11 @@ export class Nest {
     }
   }
 
-  /** 获取下一个可领取的任务（按优先级 + 信息素强度 - repellent负信息素排序，ε-greedy 随机觅食） */
-  nextPendingTask(caste: "scout" | "worker" | "soldier"): Task | null {
-    const tasks = this.getAllTasks()
-      .filter(t => t.status === "pending" && t.caste === caste);
-    if (tasks.length === 0) return null;
-
-    // ε-greedy：10% 概率随机选任务，避免蚂蚁全挤同一条路
-    if (tasks.length > 1 && Math.random() < 0.1) {
-      return tasks[Math.floor(Math.random() * tasks.length)];
-    }
-
-    // 信息素加权：用索引查询而非全量扫描
-    this.getAllPheromones(); // 确保索引已建立
-    const scored = tasks.map(t => {
-      let pScore = 0;
-      const seen = new Set<Pheromone>();
-      for (const f of t.files) {
-        const related = this.pheromoneByFile.get(f);
-        if (!related) continue;
-        for (const p of related) {
-          if (seen.has(p) || p.strength <= 0.1) continue;
-          seen.add(p);
-          if (p.type === "discovery" || p.type === "completion") pScore += p.strength;
-          else if (p.type === "repellent") pScore -= p.strength * 3;
-          else if (p.type === "warning") pScore -= p.strength;
-        }
-      }
-      return { task: t, score: (6 - t.priority) + pScore };
-    });
-    scored.sort((a, b) => b.score - a.score);
-    return scored[0]?.task ?? null;
-  }
-
   // ═══ Pheromones ═══
 
   dropPheromone(p: Pheromone): void {
     fs.appendFileSync(this.pheromoneFile, JSON.stringify(p) + "\n");
+    this.pheromoneIndexDirty = true;
   }
 
   getAllPheromones(): Pheromone[] {
@@ -223,15 +200,19 @@ export class Nest {
       return p.strength > 0.05;
     });
     const hadGarbage = this.pheromoneCache.length < beforeLen;
-
-    // 重建文件索引
-    this.pheromoneByFile.clear();
-    for (const p of this.pheromoneCache) {
-      for (const f of p.files) {
-        let arr = this.pheromoneByFile.get(f);
-        if (!arr) { arr = []; this.pheromoneByFile.set(f, arr); }
-        arr.push(p);
+    if (hadGarbage) this.pheromoneIndexDirty = true;
+
+    // 重建文件索引（仅在 dirty 时）
+    if (this.pheromoneIndexDirty) {
+      this.pheromoneByFile.clear();
+      for (const p of this.pheromoneCache) {
+        for (const f of p.files) {
+          let arr = this.pheromoneByFile.get(f);
+          if (!arr) { arr = []; this.pheromoneByFile.set(f, arr); }
+          arr.push(p);
+        }
       }
+      this.pheromoneIndexDirty = false;
     }
 
     // GC：每 10 次调用，若有弱条目被过滤则重写文件
@@ -298,7 +279,7 @@ export class Nest {
 
   private withStateLock<T>(fn: () => T): T {
     const MAX_WAIT = 3000;
-    const SPIN_MS = 1;
+    const SPIN_MS = 5;
     const start = Date.now();
     while (true) {
       try {
@@ -319,8 +300,8 @@ export class Nest {
           // 进程存活且锁未过期，放弃等待
           throw new Error(`[Nest] withStateLock timeout after ${MAX_WAIT}ms`);
         }
-        // 简单 busy-wait，避免 SharedArrayBuffer 依赖
-        const until = Date.now() + SPIN_MS + Math.random() * SPIN_MS;
+        // 简单 busy-wait + jitter，避免 SharedArrayBuffer 依赖
+        const until = Date.now() + SPIN_MS + Math.random() * SPIN_MS * 2;
         while (Date.now() < until) { /* spin */ }
       }
     }

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

@@ -0,0 +1,110 @@
+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();
+  });
+});
+
+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

@@ -0,0 +1,57 @@
+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");
+  });
+});

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

@@ -20,7 +20,7 @@ import type {
 } from "./types.js";
 import { DEFAULT_ANT_CONFIGS } from "./types.js";
 import { Nest } from "./nest.js";
-import { spawnAnt, runDrone, makeTaskId, makePheromoneId } from "./spawner.js";
+import { spawnAnt, runDrone, makeTaskId, makePheromoneId, resetAntCounter } from "./spawner.js";
 import { adapt, sampleSystem, defaultConcurrency } from "./concurrency.js";
 import { buildImportGraph, taskDependsOn, type ImportGraph } from "./deps.js";
 import type { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
@@ -120,8 +120,8 @@ function makeReviewTask(completedTasks: Task[]): Task {
 }
 
 function updateMetrics(nest: Nest): ColonyMetrics {
-  const tasks = nest.getAllTasks();
-  const state = nest.getState();
+  const state = nest.getStateLight();
+  const tasks = state.tasks;
   const now = Date.now();
   const elapsed = (now - state.metrics.startTime) / 60000; // minutes
 
@@ -172,7 +172,7 @@ async function runAntWave(opts: WaveOptions): Promise<"ok" | "budget"> {
 
   const runOne = async (): Promise<"done" | "empty" | "rate_limited" | "budget"> => {
     // Budget 刹车：预算用完就不出发（drone 免费，不检查）
-    const state = nest.getState();
+    const state = nest.getStateLight();
     if (state.maxCost != null && caste !== "drone") {
       const spent = state.ants.reduce((s, a) => s + a.usage.cost, 0);
       if (spent >= state.maxCost) return "budget";
@@ -211,7 +211,7 @@ async function runAntWave(opts: WaveOptions): Promise<"ok" | "budget"> {
       }
 
       // 成本预警：超 80% 预算时发信号
-      const curState = nest.getState();
+      const curState = nest.getStateLight();
       if (curState.maxCost != null) {
         const spent = curState.ants.reduce((s, a) => s + a.usage.cost, 0);
         if (spent >= curState.maxCost * 0.8) {
@@ -282,7 +282,7 @@ async function runAntWave(opts: WaveOptions): Promise<"ok" | "budget"> {
   // 调度循环：持续派蚂蚁直到没有待处理任务
   let lastSampleTime = 0;
   while (!signal?.aborted) {
-    const state = nest.getState();
+    const state = nest.getStateLight();
     const pending = state.tasks.filter(t => t.status === "pending" && t.caste === caste);
     if (pending.length === 0) break;
 
@@ -347,7 +347,7 @@ async function runAntWave(opts: WaveOptions): Promise<"ok" | "budget"> {
     // 429 处理：降低并发 + 渐进退避（2s → 5s → 10s，上限 10s）+ 记录时间戳
     if (results.includes("rate_limited")) {
       consecutiveRateLimits++;
-      const cur = nest.getState().concurrency;
+      const cur = nest.getStateLight().concurrency;
       const reduced = Math.max(cur.min, cur.current - 1); // 每次只减 1，不砍半
       nest.updateState({ concurrency: { ...cur, current: reduced, lastRateLimitAt: Date.now() } });
       backoffMs = Math.min(consecutiveRateLimits * 2000, 10000);
@@ -366,6 +366,7 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
   if (!opts.goal || !opts.goal.trim()) {
     throw new Error("Colony goal is empty or undefined. Please provide a clear goal.");
   }
+  resetAntCounter();
   const colonyId = makeColonyId();
   const nest = new Nest(opts.cwd, colonyId);
 
@@ -405,7 +406,7 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
   };
 
   const emitSignal = (phase: ColonyState["status"], message: string) => {
-    const state = nest.getState();
+    const state = nest.getStateLight();
     const m = state.metrics;
     const active = state.ants.filter(a => a.status === "working").length;
     const progress = m.tasksTotal > 0 ? m.tasksDone / m.tasksTotal : 0;
@@ -516,8 +517,8 @@ export async function runColony(opts: QueenOptions): Promise<ColonyState> {
     const discoveries = nest.getAllPheromones().filter(p => p.type === "discovery");
     const allDone = nest.getAllTasks().filter(t => t.status === "done");
     if (discoveries.length > allDone.length) {
-      const spent = nest.getState().ants.reduce((s, a) => s + a.usage.cost, 0);
-      if (spent < (nest.getState().maxCost ?? Infinity)) {
+      const spent = nest.getStateLight().ants.reduce((s, a) => s + a.usage.cost, 0);
+      if (spent < (nest.getStateLight().maxCost ?? Infinity)) {
         callbacks.onPhase?.("scouting", "Re-exploring based on new discoveries...");
         emitSignal("scouting", "Re-exploring...");
         await runAntWave({ ...waveBase, caste: "scout" });
@@ -606,7 +607,7 @@ export async function resumeColony(opts: QueenOptions): Promise<ColonyState> {
   const { signal, callbacks } = opts;
 
   const emitSignal = (phase: ColonyState["status"], message: string) => {
-    const state = nest.getState();
+    const state = nest.getStateLight();
     const m = state.metrics;
     const active = state.ants.filter(a => a.status === "working").length;
     const progress = m.tasksTotal > 0 ? m.tasksDone / m.tasksTotal : 0;

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

@@ -0,0 +1,44 @@
+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/spawner.ts

@@ -32,6 +32,8 @@ import { parseSubTasks, extractPheromones, type ParsedSubTask } from "./parser.j
 
 let antCounter = 0;
 
+export function resetAntCounter(): void { antCounter = 0; }
+
 export function makeAntId(caste: AntCaste): string {
   return `${caste}-${++antCounter}-${Date.now().toString(36)}`;
 }

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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,66 @@
+import { describe, it, expect } from "vitest";
+import { formatDuration, formatCost, formatTokens, statusIcon, 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("scouting", () => expect(statusIcon("scouting")).toBe("🔍"));
+  it("working", () => expect(statusIcon("working")).toBe("⚒️"));
+  it("reviewing", () => expect(statusIcon("reviewing")).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("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

@@ -0,0 +1,15 @@
+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/auto-update.ts

@@ -39,7 +39,7 @@ function getCurrentVersion(): string | null {
   } catch { return null; }
 }
 
-function isNewer(latest: string, current: string): boolean {
+export function isNewer(latest: string, current: string): boolean {
   const a = latest.split(".").map(Number);
   const b = current.split(".").map(Number);
   for (let i = 0; i < 3; i++) {

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

@@ -0,0 +1,26 @@
+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));
+});

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

@@ -5,7 +5,7 @@
  */
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 
-const DANGEROUS_PATTERNS = [
+export const DANGEROUS_PATTERNS = [
   /\brm\s+(-[a-zA-Z]*f[a-zA-Z]*\s+|.*-rf\b|.*--force\b)/,
   /\bsudo\s+rm\b/,
   /\b(DROP|TRUNCATE|DELETE\s+FROM)\b/i,
@@ -15,7 +15,7 @@ const DANGEROUS_PATTERNS = [
   />\s*\/dev\/sd[a-z]/,
 ];
 
-const PROTECTED_PATHS = [".env", ".git/", "node_modules/", ".pi/", "id_rsa", ".ssh/"];
+export const PROTECTED_PATHS = [".env", ".git/", "node_modules/", ".pi/", "id_rsa", ".ssh/"];
 
 export default function (pi: ExtensionAPI) {
   pi.on("tool_call", async (event, ctx) => {

package/pi-package/extensions/smart-compact.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from "vitest";
+import { truncateText, compactContent } from "./smart-compact";
+
+const longMultiline = (lines: number, lineLen = 100) =>
+  Array.from({ length: lines }, (_, i) => "x".repeat(lineLen) + i).join("\n");
+
+describe("truncateText", () => {
+  it("short text returns unchanged", () => {
+    expect(truncateText("hello", 8000)).toBe("hello");
+  });
+
+  it("few lines but long chars returns unchanged", () => {
+    const text = "x".repeat(9000) + "\n" + "y".repeat(9000);
+    expect(truncateText(text, 8000)).toBe(text);
+  });
+
+  it("long text with many lines gets truncated", () => {
+    const text = longMultiline(200);
+    const result = truncateText(text, 8000);
+    expect(result).toContain("[...truncated");
+  });
+
+  it("preserves head and tail", () => {
+    const text = longMultiline(200);
+    const result = truncateText(text, 8000);
+    expect(result.startsWith(text.slice(0, 1500))).toBe(true);
+    expect(result.endsWith(text.slice(-2500))).toBe(true);
+  });
+
+  it("custom head/tail params work", () => {
+    const text = longMultiline(200);
+    const result = truncateText(text, 100, 50, 50);
+    expect(result).toContain("[...truncated");
+    expect(result.startsWith(text.slice(0, 50))).toBe(true);
+    expect(result.endsWith(text.slice(-50))).toBe(true);
+  });
+});
+
+describe("compactContent", () => {
+  it("short string returns unchanged", () => {
+    expect(compactContent("short")).toBe("short");
+  });
+
+  it("long string gets truncated", () => {
+    const text = longMultiline(200);
+    expect(compactContent(text)).toContain("[...truncated");
+  });
+
+  it("array text block gets truncated", () => {
+    const text = longMultiline(200);
+    const result = compactContent([{ type: "text", text }]);
+    expect(result[0].text).toContain("[...truncated");
+  });
+
+  it("array non-text block returned unchanged", () => {
+    const block = { type: "image", url: "x" };
+    expect(compactContent([block])).toEqual([block]);
+  });
+
+  it("non-array non-string returned as-is", () => {
+    expect(compactContent(42)).toBe(42);
+    expect(compactContent({ a: 1 })).toEqual({ a: 1 });
+  });
+});

package/pi-package/extensions/smart-compact.ts

@@ -12,7 +12,7 @@ const MAX_USER_BLOCK_CHARS = 12000;
 const KEEP_HEAD = 1500;
 const KEEP_TAIL = 2500;
 
-function truncateText(text: string, max: number, head = KEEP_HEAD, tail = KEEP_TAIL): string {
+export function truncateText(text: string, max: number, head = KEEP_HEAD, tail = KEEP_TAIL): string {
   if (text.length <= max) return text;
   const lines = text.split("\n");
   if (lines.length <= 10) return text; // 短文本不裁
@@ -22,7 +22,7 @@ function truncateText(text: string, max: number, head = KEEP_HEAD, tail = KEEP_T
   return `${headText}\n\n[...truncated ${removedLines} lines...]\n\n${tailText}`;
 }
 
-function compactContent(content: any): any {
+export function compactContent(content: any): any {
   if (typeof content === "string") {
     return truncateText(content, MAX_TOOL_OUTPUT_CHARS);
   }