skyloom 1.16.2 → 1.18.0

package/src/tools/spawn.ts

@@ -0,0 +1,92 @@
+/**
+ * spawn_agent tool — launch a general-purpose, isolated-context subagent to
+ * handle one focused, self-contained task and return only its final report.
+ *
+ * This is sky's analogue of Claude Code's Task tool. Subagent types are
+ * discovered from built-ins plus `.claude/agents` / `.sky/agents` definition
+ * files (see core/subagent). Subagents never receive spawn_agent themselves,
+ * so there is no recursive fan-out.
+ */
+
+import type { ToolDefinition } from '../core/tool';
+import type { ToolRegistry } from '../core/tool';
+import type { SkillRegistry } from '../core/skill';
+import type { LLMClient } from '../core/llm';
+import type { MessageBus } from '../core/bus';
+import { loadSubagentDefinitions, runSubagent } from '../core/subagent';
+
+export function createSpawnAgentTool(opts: {
+  config: any;
+  llm: LLMClient;
+  bus: MessageBus;
+  baseToolRegistry: ToolRegistry;
+  baseSkillRegistry: SkillRegistry;
+  cwd?: string;
+}): ToolDefinition {
+  const cwd = opts.cwd || process.cwd();
+
+  const buildDescription = (): string => {
+    const defs = loadSubagentDefinitions(cwd);
+    const lines = [...defs.values()].map((d) => `  - ${d.name}: ${d.description}`);
+    return (
+      '派生一个隔离上下文的子智能体来独立完成一个聚焦、自洽的任务,只返回它的最终报告。' +
+      '当任务需要大量搜索/调研、或你想把一段独立工作从主上下文里隔离出去时使用。' +
+      '子智能体看不到你的对话历史,所以 task 必须自带全部所需上下文(目标、相关文件、约束)。' +
+      '它无法反问你,会一次性完成并汇报。可并行派生多个互不依赖的子智能体。\n\n可用子智能体类型:\n' +
+      lines.join('\n')
+    );
+  };
+
+  return {
+    name: 'spawn_agent',
+    description: buildDescription(),
+    parameters: [
+      {
+        name: 'agent_type',
+        type: 'string',
+        description: '子智能体类型(见工具描述中的可用类型,如 general-purpose / explore 或自定义)',
+        required: true,
+      },
+      {
+        name: 'task',
+        type: 'string',
+        description: '完整、自洽的任务描述。子智能体看不到对话历史,必须在此写清目标、相关文件路径与约束。',
+        required: true,
+      },
+      {
+        name: 'description',
+        type: 'string',
+        description: '可选:对该任务的简短(3-5 词)标签,用于展示。',
+        required: false,
+      },
+    ],
+    // Long-running by nature (full nested agent loop); give it generous headroom.
+    timeout: 600000,
+    handler: async (params) => {
+      const agentType = String(params.agent_type || '').trim();
+      const task = String(params.task || '').trim();
+      if (!agentType) return '[spawn_agent error] agent_type is required.';
+      if (!task) return '[spawn_agent error] task is required.';
+
+      const defs = loadSubagentDefinitions(cwd);
+      const def = defs.get(agentType);
+      if (!def) {
+        const available = [...defs.keys()].join(', ');
+        return `[spawn_agent error] unknown agent_type '${agentType}'. Available: ${available}`;
+      }
+
+      const report = await runSubagent({
+        def,
+        task,
+        config: opts.config,
+        llm: opts.llm,
+        bus: opts.bus,
+        baseToolRegistry: opts.baseToolRegistry,
+        baseSkillRegistry: opts.baseSkillRegistry,
+      });
+
+      const header = `[subagent ${def.name} 完成]`;
+      return `${header}\n${report}`;
+    },
+  };
+}

package/tests/bgproc.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from "vitest";
+import { getBackgroundManager } from "../src/core/bgproc";
+
+const NODE = `"${process.execPath}"`;
+
+async function waitFor(pred: () => boolean, timeoutMs = 5000): Promise<boolean> {
+  const t0 = Date.now();
+  while (Date.now() - t0 < timeoutMs) {
+    if (pred()) return true;
+    await new Promise((r) => setTimeout(r, 25));
+  }
+  return pred();
+}
+
+describe("bgproc · background process manager", () => {
+  it("runs a command to completion and captures its output", async () => {
+    const mgr = getBackgroundManager();
+    const { id, error } = mgr.start(`${NODE} -e "process.stdout.write('BGHELLO')"`);
+    expect(error).toBeUndefined();
+    expect(id).toBeTruthy();
+
+    const done = await waitFor(() => mgr.get(id!)?.status !== "running");
+    expect(done).toBe(true);
+    await new Promise((r) => setTimeout(r, 50)); // let final stdout flush
+
+    const r = mgr.read(id!);
+    expect(r.ok).toBe(true);
+    expect(r.text).toContain("BGHELLO");
+    expect(mgr.get(id!)?.status).toBe("exited");
+  });
+
+  it("incremental read advances the cursor (second read is empty)", async () => {
+    const mgr = getBackgroundManager();
+    const { id } = mgr.start(`${NODE} -e "process.stdout.write('ONCE')"`);
+    await waitFor(() => mgr.get(id!)?.status !== "running");
+    await new Promise((r) => setTimeout(r, 50));
+    expect(mgr.read(id!).text).toContain("ONCE");
+    expect(mgr.read(id!).text).toBe(""); // already consumed
+  });
+
+  it("lists jobs and kills a long-running one", async () => {
+    const mgr = getBackgroundManager();
+    const { id } = mgr.start(`${NODE} -e "setInterval(()=>{},1000)"`);
+    expect(mgr.list().some((j) => j.id === id)).toBe(true);
+    expect(mgr.get(id!)?.status).toBe("running");
+
+    const k = mgr.kill(id!);
+    expect(k.ok).toBe(true);
+    const killed = await waitFor(() => mgr.get(id!)?.status === "killed");
+    expect(killed).toBe(true);
+  });
+
+  it("blocks red-line commands before spawning", () => {
+    const mgr = getBackgroundManager();
+    const { id, error } = mgr.start("rm -rf /");
+    expect(id).toBeUndefined();
+    expect(error).toMatch(/BLOCKED|REDLINE/);
+  });
+
+  it("errors on read/kill of an unknown job", () => {
+    const mgr = getBackgroundManager();
+    expect(mgr.read("nope").ok).toBe(false);
+    expect(mgr.kill("nope").ok).toBe(false);
+  });
+});

package/tests/diagnostics.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import {
+  getDiagnostics,
+  getTypeScriptDiagnostics,
+  parseDiagnosticOutput,
+  formatDiagnostics,
+} from "../src/core/diagnostics";
+
+describe("diagnostics · TypeScript compiler API", () => {
+  let dir: string;
+  beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), "sky-diag-")); });
+  afterEach(() => { try { fs.rmSync(dir, { recursive: true, force: true }); } catch {} });
+
+  function write(name: string, content: string): string {
+    const p = path.join(dir, name);
+    fs.writeFileSync(p, content);
+    return p;
+  }
+
+  it("reports a type error with line:col and TS code", () => {
+    const p = write("bad.ts", "const x: number = 'hello';\n");
+    const res = getTypeScriptDiagnostics(p);
+    expect(Array.isArray(res)).toBe(true);
+    const diags = res as any[];
+    expect(diags.length).toBeGreaterThan(0);
+    const err = diags[0];
+    expect(err.severity).toBe("error");
+    expect(err.line).toBe(1);
+    expect(err.code).toMatch(/^TS\d+/);
+    expect(err.source).toBe("ts");
+  });
+
+  it("returns an empty array for a clean file", () => {
+    const p = write("ok.ts", "export const y: number = 5;\n");
+    const res = getTypeScriptDiagnostics(p);
+    expect(Array.isArray(res)).toBe(true);
+    expect((res as any[]).length).toBe(0);
+  });
+
+  it("getDiagnostics dispatches TS files to the compiler API", () => {
+    const p = write("d.ts", "let n: string = 42;\n");
+    const res = getDiagnostics(p, {});
+    expect(Array.isArray(res)).toBe(true);
+    expect((res as any[]).length).toBeGreaterThan(0);
+  });
+
+  it("returns unavailable for an unconfigured non-TS extension", () => {
+    const p = write("script.rb", "puts 'hi'\n");
+    const res = getDiagnostics(p, {});
+    expect(Array.isArray(res)).toBe(false);
+    expect((res as any).unavailable).toContain("no diagnostics provider");
+  });
+
+  it("returns unavailable for a missing file", () => {
+    const res = getDiagnostics(path.join(dir, "nope.ts"), {});
+    expect((res as any).unavailable).toContain("not found");
+  });
+});
+
+describe("diagnostics · external output parsing", () => {
+  it("parses path:line:col: severity message lines", () => {
+    const out = "src/a.py:3:5: error: undefined name 'x'\nsrc/a.py:7:1: warning: unused import";
+    const diags = parseDiagnosticOutput(out, "ruff");
+    expect(diags.length).toBe(2);
+    expect(diags[0]).toMatchObject({ line: 3, column: 5, severity: "error" });
+    expect(diags[1].severity).toBe("warning");
+    expect(diags[0].source).toBe("ruff");
+  });
+});
+
+describe("diagnostics · formatting", () => {
+  it("formats a clean result", () => {
+    expect(formatDiagnostics("a.ts", [])).toContain("no diagnostics");
+  });
+  it("formats errors with counts", () => {
+    const s = formatDiagnostics("a.ts", [
+      { line: 2, column: 3, severity: "error", message: "boom", code: "TS1", source: "ts" },
+    ]);
+    expect(s).toContain("1 error");
+    expect(s).toContain("2:3");
+    expect(s).toContain("boom");
+  });
+});

package/tests/edit_diff.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { unifiedDiff, countOccurrences } from "../src/core/diff";
+import { ToolRegistry } from "../src/core/tool";
+import { registerBuiltinTools } from "../src/tools/builtin";
+
+describe("diff · unifiedDiff", () => {
+  it("returns empty for identical input", () => {
+    const d = unifiedDiff("a\nb\nc", "a\nb\nc");
+    expect(d.text).toBe("");
+    expect(d.stat).toEqual({ added: 0, removed: 0 });
+  });
+
+  it("shows a single changed line with context and a +/- stat", () => {
+    const d = unifiedDiff("a\nb\nc\nd\ne", "a\nb\nX\nd\ne");
+    expect(d.stat).toEqual({ added: 1, removed: 1 });
+    expect(d.text).toContain("-c");
+    expect(d.text).toContain("+X");
+    expect(d.text).toContain(" b"); // context line
+    expect(d.text).toMatch(/@@ -\d+,\d+ \+\d+,\d+ @@/);
+  });
+
+  it("counts added and removed lines for multi-line changes", () => {
+    const d = unifiedDiff("x\n1\n2\ny", "x\n1\n2\n3\ny");
+    expect(d.stat.added).toBe(1);
+    expect(d.stat.removed).toBe(0);
+  });
+});
+
+describe("diff · countOccurrences", () => {
+  it("counts non-overlapping occurrences", () => {
+    expect(countOccurrences("aaaa", "aa")).toBe(2);
+    expect(countOccurrences("abcabc", "abc")).toBe(2);
+    expect(countOccurrences("abc", "z")).toBe(0);
+    expect(countOccurrences("abc", "")).toBe(0);
+  });
+});
+
+describe("edit_file · Claude Code-style semantics", () => {
+  let dir: string;
+  let edit: any;
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), "sky-edit-"));
+    const reg = new ToolRegistry();
+    registerBuiltinTools(reg);
+    edit = reg.get("edit_file")!.handler!;
+  });
+  afterEach(() => { try { fs.rmSync(dir, { recursive: true, force: true }); } catch {} });
+
+  function write(name: string, content: string): string {
+    const p = path.join(dir, name);
+    fs.writeFileSync(p, content);
+    return p;
+  }
+
+  it("replaces a unique match and returns a diff", async () => {
+    const p = write("a.txt", "line1\nfoo\nline3\n");
+    const out = await edit({ path: p, old_text: "foo", new_text: "bar" });
+    expect(out).toContain("Successfully edited");
+    expect(out).toContain("-foo");
+    expect(out).toContain("+bar");
+    expect(fs.readFileSync(p, "utf8")).toBe("line1\nbar\nline3\n");
+  });
+
+  it("refuses an ambiguous edit when old_text is not unique", async () => {
+    const p = write("b.txt", "x\nx\n");
+    const out = await edit({ path: p, old_text: "x", new_text: "y" });
+    expect(out).toContain("appears 2 times");
+    expect(out).toContain("replace_all");
+    // file unchanged
+    expect(fs.readFileSync(p, "utf8")).toBe("x\nx\n");
+  });
+
+  it("replace_all changes every occurrence", async () => {
+    const p = write("c.txt", "x\nx\nx\n");
+    const out = await edit({ path: p, old_text: "x", new_text: "y", replace_all: true });
+    expect(out).toContain("3 occurrences");
+    expect(fs.readFileSync(p, "utf8")).toBe("y\ny\ny\n");
+  });
+
+  it("errors when old_text is missing from the file", async () => {
+    const p = write("d.txt", "hello\n");
+    const out = await edit({ path: p, old_text: "nope", new_text: "x" });
+    expect(out).toContain("not found");
+    expect(fs.readFileSync(p, "utf8")).toBe("hello\n");
+  });
+
+  it("rejects a no-op edit (old_text === new_text)", async () => {
+    const p = write("e.txt", "same\n");
+    const out = await edit({ path: p, old_text: "same", new_text: "same" });
+    expect(out).toContain("identical");
+  });
+
+  it("treats $-patterns in new_text literally (no String.replace interpretation)", async () => {
+    const p = write("f.txt", "value = OLD\n");
+    const out = await edit({ path: p, old_text: "OLD", new_text: "$1$&dollar" });
+    expect(out).toContain("Successfully edited");
+    expect(fs.readFileSync(p, "utf8")).toBe("value = $1$&dollar\n");
+  });
+});

package/tests/envcontext.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { gitInfo, buildEnvBlock } from "../src/core/envcontext";
+
+describe("envcontext · gitInfo", () => {
+  let dir: string;
+  beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), "sky-git-")); });
+  afterEach(() => { try { fs.rmSync(dir, { recursive: true, force: true }); } catch {} });
+
+  it("reads the branch from a .git directory HEAD", () => {
+    fs.mkdirSync(path.join(dir, ".git"));
+    fs.writeFileSync(path.join(dir, ".git", "HEAD"), "ref: refs/heads/feature-x\n");
+    const info = gitInfo(dir);
+    expect(info.repo).toBe(true);
+    expect(info.branch).toBe("feature-x");
+  });
+
+  it("falls back to a short sha for a detached HEAD", () => {
+    fs.mkdirSync(path.join(dir, ".git"));
+    fs.writeFileSync(path.join(dir, ".git", "HEAD"), "0123456789abcdef\n");
+    expect(gitInfo(dir).branch).toBe("01234567");
+  });
+
+  it("resolves a worktree .git file pointing at the real gitdir", () => {
+    const real = path.join(dir, "realgit");
+    fs.mkdirSync(real);
+    fs.writeFileSync(path.join(real, "HEAD"), "ref: refs/heads/wt-branch\n");
+    fs.writeFileSync(path.join(dir, ".git"), `gitdir: ${real}\n`);
+    const info = gitInfo(dir);
+    expect(info.repo).toBe(true);
+    expect(info.branch).toBe("wt-branch");
+  });
+
+  it("reports no repo when there is no .git up the tree", () => {
+    const nested = path.join(dir, "a", "b");
+    fs.mkdirSync(nested, { recursive: true });
+    expect(gitInfo(nested).repo).toBe(false);
+  });
+});
+
+describe("envcontext · buildEnvBlock", () => {
+  it("includes cwd, platform, node, git branch and an injectable date (zh)", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sky-env-"));
+    try {
+      fs.mkdirSync(path.join(dir, ".git"));
+      fs.writeFileSync(path.join(dir, ".git", "HEAD"), "ref: refs/heads/main\n");
+      const block = buildEnvBlock({ cwd: dir, lang: "zh", now: new Date("2026-06-14T08:00:00Z") });
+      expect(block).toContain("运行环境");
+      expect(block).toContain(dir);
+      expect(block).toContain(process.version);
+      expect(block).toContain(process.platform);
+      expect(block).toContain("main");
+      expect(block).toContain("2026-06-14");
+    } finally {
+      try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+    }
+  });
+
+  it("renders an English block", () => {
+    const block = buildEnvBlock({ cwd: os.tmpdir(), lang: "en", now: new Date("2026-01-02T00:00:00Z") });
+    expect(block).toContain("## Environment");
+    expect(block).toContain("Working directory");
+    expect(block).toContain("2026-01-02");
+  });
+});

package/tests/patch.test.ts

@@ -0,0 +1,128 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { parsePatch, applyPatch } from "../src/core/patch";
+
+describe("patch · parsePatch", () => {
+  it("parses update / add / delete operations", () => {
+    const text = [
+      "*** Begin Patch",
+      "*** Update File: a.ts",
+      "<<<<<<< SEARCH",
+      "const x = 1;",
+      "=======",
+      "const x = 2;",
+      ">>>>>>> REPLACE",
+      "*** Add File: b.ts",
+      "export const y = 3;",
+      "*** Delete File: c.ts",
+      "*** End Patch",
+    ].join("\n");
+    const r = parsePatch(text) as any;
+    expect(r.error).toBeUndefined();
+    expect(r.ops).toHaveLength(3);
+    expect(r.ops[0]).toMatchObject({ op: "update", path: "a.ts" });
+    expect(r.ops[0].blocks[0]).toEqual({ search: "const x = 1;", replace: "const x = 2;" });
+    expect(r.ops[1]).toMatchObject({ op: "add", path: "b.ts", content: "export const y = 3;\n" });
+    expect(r.ops[2]).toMatchObject({ op: "delete", path: "c.ts" });
+  });
+
+  it("errors on an unterminated SEARCH", () => {
+    const text = "*** Update File: a.ts\n<<<<<<< SEARCH\nfoo\n";
+    expect((parsePatch(text) as any).error).toContain("Unterminated SEARCH");
+  });
+
+  it("errors on stray content outside a file section", () => {
+    expect((parsePatch("hello world") as any).error).toContain("Unexpected line");
+  });
+});
+
+describe("patch · applyPatch (atomic, multi-file)", () => {
+  let dir: string;
+  beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), "sky-patch-")); });
+  afterEach(() => { try { fs.rmSync(dir, { recursive: true, force: true }); } catch {} });
+
+  function write(name: string, content: string) {
+    const p = path.join(dir, name);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, content);
+  }
+  const read = (name: string) => fs.readFileSync(path.join(dir, name), "utf8");
+
+  it("applies update + add + delete in one shot", () => {
+    write("a.ts", "const x = 1;\nkeep me\n");
+    write("c.ts", "delete me\n");
+    const patch = [
+      "*** Update File: a.ts",
+      "<<<<<<< SEARCH",
+      "const x = 1;",
+      "=======",
+      "const x = 42;",
+      ">>>>>>> REPLACE",
+      "*** Add File: sub/b.ts",
+      "export const y = 3;",
+      "*** Delete File: c.ts",
+    ].join("\n");
+    const out = applyPatch(patch, { cwd: dir });
+    expect(out).toContain("Applied patch");
+    expect(read("a.ts")).toBe("const x = 42;\nkeep me\n");
+    expect(read("sub/b.ts")).toBe("export const y = 3;\n");
+    expect(fs.existsSync(path.join(dir, "c.ts"))).toBe(false);
+  });
+
+  it("applies multiple blocks to one file", () => {
+    write("m.ts", "alpha\nbeta\ngamma\n");
+    const patch = [
+      "*** Update File: m.ts",
+      "<<<<<<< SEARCH", "alpha", "=======", "ALPHA", ">>>>>>> REPLACE",
+      "<<<<<<< SEARCH", "gamma", "=======", "GAMMA", ">>>>>>> REPLACE",
+    ].join("\n");
+    applyPatch(patch, { cwd: dir });
+    expect(read("m.ts")).toBe("ALPHA\nbeta\nGAMMA\n");
+  });
+
+  it("is atomic: a failing block leaves ALL files untouched", () => {
+    write("a.ts", "good\n");
+    write("b.ts", "target\n");
+    const patch = [
+      "*** Update File: a.ts",
+      "<<<<<<< SEARCH", "good", "=======", "changed", ">>>>>>> REPLACE",
+      "*** Update File: b.ts",
+      "<<<<<<< SEARCH", "NOT THERE", "=======", "x", ">>>>>>> REPLACE",
+    ].join("\n");
+    const out = applyPatch(patch, { cwd: dir });
+    expect(out).toContain("SEARCH block not found");
+    expect(read("a.ts")).toBe("good\n");   // first file NOT written
+    expect(read("b.ts")).toBe("target\n");
+  });
+
+  it("rejects an ambiguous SEARCH block", () => {
+    write("d.ts", "dup\ndup\n");
+    const patch = ["*** Update File: d.ts", "<<<<<<< SEARCH", "dup", "=======", "x", ">>>>>>> REPLACE"].join("\n");
+    expect(applyPatch(patch, { cwd: dir })).toContain("ambiguous");
+  });
+
+  it("refuses to Add over an existing file", () => {
+    write("exists.ts", "already\n");
+    const patch = "*** Add File: exists.ts\nnew content\n";
+    const out = applyPatch(patch, { cwd: dir });
+    expect(out).toContain("already exists");
+    expect(read("exists.ts")).toBe("already\n");
+  });
+
+  it("treats $-patterns in replacement literally", () => {
+    write("e.ts", "VAL\n");
+    const patch = ["*** Update File: e.ts", "<<<<<<< SEARCH", "VAL", "=======", "$1$&x", ">>>>>>> REPLACE"].join("\n");
+    applyPatch(patch, { cwd: dir });
+    expect(read("e.ts")).toBe("$1$&x\n");
+  });
+
+  it("honors the fence check by aborting", () => {
+    write("a.ts", "good\n");
+    const patch = ["*** Update File: a.ts", "<<<<<<< SEARCH", "good", "=======", "bad", ">>>>>>> REPLACE"].join("\n");
+    const out = applyPatch(patch, { cwd: dir, fenceCheck: () => "路径越界" });
+    expect(out).toContain("路径越界");
+    expect(read("a.ts")).toBe("good\n");
+  });
+});

package/tests/plugins.test.ts

@@ -0,0 +1,84 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { ToolRegistry } from "../src/core/tool";
+import { PluginLoader, type PluginContext } from "../src/plugins/loader";
+
+describe("PluginLoader · hook lifecycle", () => {
+  let reg: ToolRegistry;
+  let loader: PluginLoader;
+  beforeEach(() => {
+    reg = new ToolRegistry();
+    loader = new PluginLoader(reg, { foo: 1 });
+  });
+
+  it("activate-style plugin registers a scoped tool and an init hook", async () => {
+    let initFired = false;
+    loader.activatePlugin("p1", {
+      activate(ctx: PluginContext) {
+        expect(ctx.config).toEqual({ foo: 1 });
+        ctx.registerTool({ name: "p1_tool", description: "t", handler: async () => "ok" });
+        ctx.on("init", () => { initFired = true; });
+      },
+    });
+    expect(reg.has("p1_tool")).toBe(true);
+    expect(loader.list()).toContain("p1");
+    expect(loader.hookCount("init")).toBe(1);
+
+    await loader.emit("init");
+    expect(initFired).toBe(true);
+  });
+
+  it("unload removes the plugin's tools and hook handlers", async () => {
+    let fired = 0;
+    loader.activatePlugin("p", {
+      activate(ctx: PluginContext) {
+        ctx.registerTool({ name: "tmp_tool", description: "t", handler: async () => "ok" });
+        ctx.on("init", () => { fired++; });
+      },
+    });
+    expect(reg.has("tmp_tool")).toBe(true);
+
+    expect(loader.unload("p")).toBe(true);
+    expect(reg.has("tmp_tool")).toBe(false);
+    expect(loader.hookCount("init")).toBe(0);
+    expect(loader.list()).not.toContain("p");
+
+    await loader.emit("init");
+    expect(fired).toBe(0); // handler gone
+  });
+
+  it("fires hook handlers in registration order across plugins", async () => {
+    const order: string[] = [];
+    loader.activatePlugin("a", { activate: (c) => c.on("init", () => { order.push("a"); }) });
+    loader.activatePlugin("b", { activate: (c) => c.on("init", () => { order.push("b"); }) });
+    await loader.emit("init");
+    expect(order).toEqual(["a", "b"]);
+  });
+
+  it("reactivating a name unloads the previous instance (no duplicate tools)", () => {
+    loader.activatePlugin("dup", { activate: (c) => c.registerTool({ name: "x", description: "v1", handler: async () => "1" }) });
+    loader.activatePlugin("dup", { activate: (c) => c.registerTool({ name: "x", description: "v2", handler: async () => "2" }) });
+    expect(loader.list().filter((n) => n === "dup")).toHaveLength(1);
+    expect(reg.get("x")?.description).toBe("v2");
+  });
+
+  it("supports legacy register(registry) and tracks its tools for unload", () => {
+    loader.activatePlugin("legacy", {
+      register(r) { r.register({ name: "legacy_tool", description: "t", handler: async () => "ok" }); },
+    });
+    expect(reg.has("legacy_tool")).toBe(true);
+    loader.unload("legacy");
+    expect(reg.has("legacy_tool")).toBe(false);
+  });
+
+  it("isolates a throwing hook handler from the rest", async () => {
+    const ran: string[] = [];
+    loader.activatePlugin("a", { activate: (c) => c.on("evt", () => { throw new Error("boom"); }) });
+    loader.activatePlugin("b", { activate: (c) => c.on("evt", () => { ran.push("b"); }) });
+    await loader.emit("evt");
+    expect(ran).toEqual(["b"]); // b still ran despite a throwing
+  });
+
+  it("unload returns false for an unknown plugin", () => {
+    expect(loader.unload("nope")).toBe(false);
+  });
+});

package/tests/protocol.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from "vitest";
+import { engineeringProtocol } from "../src/core/protocol";
+
+describe("protocol · engineeringProtocol", () => {
+  it("zh protocol covers the senior-engineer discipline and names real tools", () => {
+    const p = engineeringProtocol("zh");
+    expect(p).toContain("工程标准");
+    expect(p).toContain("根因");          // root-cause, not symptom
+    expect(p).toContain("最小");          // minimal diffs
+    expect(p).toContain("先理解");        // understand before changing
+    expect(p).toContain("get_diagnostics"); // verify loop wired to real tool
+    expect(p).toContain("code_search");
+  });
+
+  it("en protocol mirrors the zh one", () => {
+    const p = engineeringProtocol("en");
+    expect(p).toContain("Engineering Standard");
+    expect(p).toContain("Root cause");
+    expect(p).toContain("Minimal");
+    expect(p).toContain("get_diagnostics");
+    expect(p).toContain("code_search");
+  });
+
+  it("defaults to zh", () => {
+    expect(engineeringProtocol()).toBe(engineeringProtocol("zh"));
+  });
+});