oh-pi 0.1.70 → 0.1.72

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.72",
   "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 次调用，若有弱条目被过滤则重写文件
@@ -247,6 +228,18 @@ export class Nest {
     return this.pheromoneCache;
   }
 
+  /** 统计指定文件相关的 warning/repellent 信息素数量 */
+  countWarnings(files: string[]): number {
+    this.getAllPheromones();
+    let count = 0;
+    for (const f of files) {
+      for (const p of this.pheromoneByFile.get(f) ?? []) {
+        if (p.type === "warning" || p.type === "repellent") count++;
+      }
+    }
+    return count;
+  }
+
   /** 读取与特定文件相关的信息素摘要 */
   getPheromoneContext(files: string[], limit = 20): string {
     const relevant = this.getAllPheromones()
@@ -298,7 +291,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 +312,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 */ }
       }
     }