skyloom 1.13.6 → 1.13.8

package/tests/skymd.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { loadProjectMemory, appendQuickMemory, parseVerifyCommands, projectMemoryFile } from "../src/core/skymd";
+import { resolveVerifyConfig, runVerify } from "../src/core/verify";
+import { loadHooks, matches, runPreToolHooks } from "../src/core/hooks";
+import { expandFileRefs, isBangCommand, bangCommand, runBang, isHashMemory, hashNote } from "../src/cli/input_macros";
+
+let tmp: string;
+beforeEach(() => { tmp = fs.mkdtempSync(path.join(os.tmpdir(), "skymd-")); });
+afterEach(() => { fs.rmSync(tmp, { recursive: true, force: true }); });
+
+describe("项目记忆 SKY.md", () => {
+  it("loads the project layer and reports contributing files", () => {
+    fs.writeFileSync(path.join(tmp, "SKY.md"), "构建: npm run build");
+    const mem = loadProjectMemory(tmp);
+    expect(mem.text).toContain("构建: npm run build");
+    expect(mem.files.some(f => f.endsWith("SKY.md"))).toBe(true);
+  });
+
+  it("falls back to CLAUDE.md / AGENTS.md for compatibility", () => {
+    fs.writeFileSync(path.join(tmp, "AGENTS.md"), "agents 约定");
+    expect(projectMemoryFile(tmp)).toContain("AGENTS.md");
+    expect(loadProjectMemory(tmp).text).toContain("agents 约定");
+    // SKY.md wins over AGENTS.md when both exist
+    fs.writeFileSync(path.join(tmp, "SKY.md"), "sky 约定");
+    expect(projectMemoryFile(tmp)).toContain("SKY.md");
+  });
+
+  it("layers SKY.local.md after the project file", () => {
+    fs.writeFileSync(path.join(tmp, "SKY.md"), "shared");
+    fs.writeFileSync(path.join(tmp, "SKY.local.md"), "personal");
+    const text = loadProjectMemory(tmp).text;
+    expect(text.indexOf("shared")).toBeLessThan(text.indexOf("personal"));
+  });
+
+  it("clamps oversized files", () => {
+    fs.writeFileSync(path.join(tmp, "SKY.md"), "x".repeat(50000));
+    expect(loadProjectMemory(tmp).text.length).toBeLessThan(15000);
+  });
+
+  it("appendQuickMemory creates SKY.md with a header, then appends", () => {
+    const f1 = appendQuickMemory("测试必须用 vitest", tmp);
+    expect(fs.readFileSync(f1, "utf-8")).toContain("- 测试必须用 vitest");
+    appendQuickMemory("禁止 any", tmp);
+    const content = fs.readFileSync(f1, "utf-8");
+    expect(content).toContain("- 禁止 any");
+    expect(content.indexOf("vitest")).toBeLessThan(content.indexOf("禁止 any"));
+  });
+
+  it("appendQuickMemory targets an existing CLAUDE.md", () => {
+    fs.writeFileSync(path.join(tmp, "CLAUDE.md"), "# rules\n");
+    const f = appendQuickMemory("note", tmp);
+    expect(f).toContain("CLAUDE.md");
+  });
+
+  it("parseVerifyCommands extracts the fenced block under ## Verify", () => {
+    const text = "# SKY\n\n## Verify\n```bash\nnpm test\n# comment\nnpm run lint\n```\n\n## Other\n";
+    expect(parseVerifyCommands(text)).toEqual(["npm test", "npm run lint"]);
+    expect(parseVerifyCommands("no section")).toEqual([]);
+  });
+});
+
+describe("验证闭环", () => {
+  it("passes when every command exits 0", () => {
+    const r = runVerify({ commands: ["node -e \"process.exit(0)\""], maxFixRounds: 2, timeoutS: 30 }, tmp);
+    expect(r.ok).toBe(true);
+    expect(r.report).toContain("✓");
+  });
+
+  it("stops at the first failure and captures output", () => {
+    const r = runVerify({
+      commands: ["node -e \"console.error('boom'); process.exit(3)\"", "node -e \"process.exit(0)\""],
+      maxFixRounds: 2, timeoutS: 30,
+    }, tmp);
+    expect(r.ok).toBe(false);
+    expect(r.report).toContain("boom");
+    expect(r.report).toContain("exit 3");
+    expect(r.report).not.toContain("✓ node -e \"process.exit(0)\"");
+  });
+
+  it("resolveVerifyConfig prefers config over SKY.md", () => {
+    const cfg = resolveVerifyConfig({ verify: { commands: ["a"], max_fix_rounds: 5 } }, tmp);
+    expect(cfg.commands).toEqual(["a"]);
+    expect(cfg.maxFixRounds).toBe(5);
+  });
+});
+
+describe("hooks", () => {
+  it("loads and normalizes config shapes", () => {
+    const h = loadHooks({ hooks: { session_start: ["echo hi"], pre_tool: [{ matcher: "run_bash", command: "true" }], post_tool: ["echo done"] } });
+    expect(h.sessionStart).toEqual(["echo hi"]);
+    expect(h.preTool[0].matcher).toBe("run_bash");
+    expect(h.postTool[0].command).toBe("echo done");
+  });
+
+  it("matcher is a regex on the tool name (missing matcher = all)", () => {
+    expect(matches({ matcher: "write_|edit_", command: "x" }, "write_file")).toBe(true);
+    expect(matches({ matcher: "write_|edit_", command: "x" }, "read_file")).toBe(false);
+    expect(matches({ command: "x" }, "anything")).toBe(true);
+  });
+
+  it("pre_tool hook blocks on non-zero exit", () => {
+    const h = loadHooks({ hooks: { pre_tool: [{ matcher: "danger", command: "node -e \"console.log('nope'); process.exit(1)\"" }] } });
+    const blocked = runPreToolHooks(h, "danger_tool", {}, "fog");
+    expect(blocked.allowed).toBe(false);
+    expect(blocked.reason).toContain("nope");
+    const allowed = runPreToolHooks(h, "read_file", {}, "fog");
+    expect(allowed.allowed).toBe(true);
+  });
+});
+
+describe("输入宏", () => {
+  it("# quick memory detection", () => {
+    expect(isHashMemory("# 用 pnpm")).toBe(true);
+    expect(isHashMemory("#用 pnpm")).toBe(true);
+    expect(isHashMemory("## markdown heading")).toBe(false);
+    expect(isHashMemory("正文 # 不算")).toBe(false);
+    expect(hashNote("#  用 pnpm ")).toBe("用 pnpm");
+  });
+
+  it("! shell detection and execution", () => {
+    expect(isBangCommand("!git status")).toBe(true);
+    expect(isBangCommand("hello!")).toBe(false);
+    expect(bangCommand("! echo hi")).toBe("echo hi");
+    const r = runBang("node -e \"console.log('out')\"", tmp);
+    expect(r.ok).toBe(true);
+    expect(r.output).toBe("out");
+    expect(runBang("node -e \"process.exit(2)\"", tmp).ok).toBe(false);
+  });
+
+  it("@file expands existing files into fenced attachments", () => {
+    fs.writeFileSync(path.join(tmp, "a.txt"), "file content here");
+    const r = expandFileRefs("看一下 @a.txt 的内容", tmp);
+    expect(r.attached).toEqual(["a.txt"]);
+    expect(r.text).toContain("file content here");
+    expect(r.text).toContain("看一下 @a.txt 的内容"); // original preserved
+  });
+
+  it("@file leaves missing files untouched", () => {
+    const r = expandFileRefs("ping @nonexistent.ts", tmp);
+    expect(r.attached).toEqual([]);
+    expect(r.text).toBe("ping @nonexistent.ts");
+  });
+});

package/tests/task.test.ts

@@ -1,60 +1,60 @@
-import { describe, it, expect } from "vitest";
-import { Task, TaskState, TaskResult, VALID_TRANSITIONS } from "../src/core/agent/task";
-// Also assert the re-export path stays stable for external importers.
-import { Task as TaskViaAgent, TaskState as TaskStateViaAgent } from "../src/core/agent";
-
-describe("Task domain model", () => {
-  it("applies sensible defaults", () => {
-    const t = new Task({ id: "1", description: "do a thing" });
-    expect(t.status).toBe(TaskState.PENDING);
-    expect(t.assignedTo).toBeNull();
-    expect(t.dependsOn).toEqual([]);
-    expect(t.priority).toBe(0);
-  });
-
-  it("allows PENDING -> RUNNING -> COMPLETED", () => {
-    const t = new Task({ id: "1", description: "x" });
-    t.transitionTo(TaskState.RUNNING);
-    expect(t.status).toBe(TaskState.RUNNING);
-    t.transitionTo(TaskState.COMPLETED);
-    expect(t.status).toBe(TaskState.COMPLETED);
-  });
-
-  it("rejects illegal transitions", () => {
-    const t = new Task({ id: "1", description: "x" });
-    // PENDING -> COMPLETED is not allowed (must go through RUNNING)
-    expect(() => t.transitionTo(TaskState.COMPLETED)).toThrow(/Invalid task state transition/);
-  });
-
-  it("treats COMPLETED as terminal", () => {
-    expect(VALID_TRANSITIONS[TaskState.COMPLETED].size).toBe(0);
-    expect(VALID_TRANSITIONS[TaskState.SKIPPED].size).toBe(0);
-  });
-
-  it("allows FAILED -> RUNNING (retry) and FAILED -> SKIPPED", () => {
-    const t = new Task({ id: "1", description: "x", status: TaskState.FAILED });
-    expect(() => t.transitionTo(TaskState.RUNNING)).not.toThrow();
-    const t2 = new Task({ id: "2", description: "y", status: TaskState.FAILED });
-    expect(() => t2.transitionTo(TaskState.SKIPPED)).not.toThrow();
-  });
-
-  it("allDeps merges parentId with dependsOn without duplicates", () => {
-    const t = new Task({ id: "3", description: "z", parentId: "1", dependsOn: ["1", "2"] });
-    expect(t.allDeps.sort()).toEqual(["1", "2"]);
-    const t2 = new Task({ id: "4", description: "z", parentId: "9", dependsOn: ["2"] });
-    expect(t2.allDeps.sort()).toEqual(["2", "9"]);
-  });
-
-  it("TaskResult carries success/content/data", () => {
-    const ok = new TaskResult(true, "done", { x: 1 });
-    expect(ok.success).toBe(true);
-    expect(ok.content).toBe("done");
-    expect(ok.data).toEqual({ x: 1 });
-    expect(new TaskResult(false, "oops").data).toEqual({});
-  });
-
-  it("re-export from ../core/agent stays identical", () => {
-    expect(TaskViaAgent).toBe(Task);
-    expect(TaskStateViaAgent).toBe(TaskState);
-  });
-});
+import { describe, it, expect } from "vitest";
+import { Task, TaskState, TaskResult, VALID_TRANSITIONS } from "../src/core/agent/task";
+// Also assert the re-export path stays stable for external importers.
+import { Task as TaskViaAgent, TaskState as TaskStateViaAgent } from "../src/core/agent";
+
+describe("Task domain model", () => {
+  it("applies sensible defaults", () => {
+    const t = new Task({ id: "1", description: "do a thing" });
+    expect(t.status).toBe(TaskState.PENDING);
+    expect(t.assignedTo).toBeNull();
+    expect(t.dependsOn).toEqual([]);
+    expect(t.priority).toBe(0);
+  });
+
+  it("allows PENDING -> RUNNING -> COMPLETED", () => {
+    const t = new Task({ id: "1", description: "x" });
+    t.transitionTo(TaskState.RUNNING);
+    expect(t.status).toBe(TaskState.RUNNING);
+    t.transitionTo(TaskState.COMPLETED);
+    expect(t.status).toBe(TaskState.COMPLETED);
+  });
+
+  it("rejects illegal transitions", () => {
+    const t = new Task({ id: "1", description: "x" });
+    // PENDING -> COMPLETED is not allowed (must go through RUNNING)
+    expect(() => t.transitionTo(TaskState.COMPLETED)).toThrow(/Invalid task state transition/);
+  });
+
+  it("treats COMPLETED as terminal", () => {
+    expect(VALID_TRANSITIONS[TaskState.COMPLETED].size).toBe(0);
+    expect(VALID_TRANSITIONS[TaskState.SKIPPED].size).toBe(0);
+  });
+
+  it("allows FAILED -> RUNNING (retry) and FAILED -> SKIPPED", () => {
+    const t = new Task({ id: "1", description: "x", status: TaskState.FAILED });
+    expect(() => t.transitionTo(TaskState.RUNNING)).not.toThrow();
+    const t2 = new Task({ id: "2", description: "y", status: TaskState.FAILED });
+    expect(() => t2.transitionTo(TaskState.SKIPPED)).not.toThrow();
+  });
+
+  it("allDeps merges parentId with dependsOn without duplicates", () => {
+    const t = new Task({ id: "3", description: "z", parentId: "1", dependsOn: ["1", "2"] });
+    expect(t.allDeps.sort()).toEqual(["1", "2"]);
+    const t2 = new Task({ id: "4", description: "z", parentId: "9", dependsOn: ["2"] });
+    expect(t2.allDeps.sort()).toEqual(["2", "9"]);
+  });
+
+  it("TaskResult carries success/content/data", () => {
+    const ok = new TaskResult(true, "done", { x: 1 });
+    expect(ok.success).toBe(true);
+    expect(ok.content).toBe("done");
+    expect(ok.data).toEqual({ x: 1 });
+    expect(new TaskResult(false, "oops").data).toEqual({});
+  });
+
+  it("re-export from ../core/agent stays identical", () => {
+    expect(TaskViaAgent).toBe(Task);
+    expect(TaskStateViaAgent).toBe(TaskState);
+  });
+});

package/tests/todo_toolstats.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect } from "vitest";
+import { parseTodoItems, renderTodoList, createTodoTool, TODO_WORKING_KEY } from "../src/tools/todo";
+import { clampToolResult } from "../src/core/agent";
+import { ToolRegistry } from "../src/core/tool";
+
+describe("todo_write 任务清单", () => {
+  it("parses a JSON array with status validation and defaults", () => {
+    const { items, error } = parseTodoItems('[{"text":"调研","status":"done"},{"text":"实现","status":"active"},{"text":"测试"}]');
+    expect(error).toBe("");
+    expect(items).toEqual([
+      { text: "调研", status: "done" },
+      { text: "实现", status: "active" },
+      { text: "测试", status: "pending" },
+    ]);
+    // plain string items are accepted as pending
+    expect(parseTodoItems('["a","b"]').items).toEqual([
+      { text: "a", status: "pending" },
+      { text: "b", status: "pending" },
+    ]);
+  });
+
+  it("rejects malformed input", () => {
+    expect(parseTodoItems("not json").items).toBeNull();
+    expect(parseTodoItems('{"text":"x"}').items).toBeNull();
+    expect(parseTodoItems('[{"text":""}]').items).toBeNull();
+    expect(parseTodoItems(JSON.stringify(Array(25).fill({ text: "x" }))).items).toBeNull();
+  });
+
+  it("renderTodoList shows progress and per-item marks", () => {
+    const out = renderTodoList([
+      { text: "调研", status: "done" },
+      { text: "实现", status: "active" },
+      { text: "测试", status: "pending" },
+    ]);
+    expect(out).toContain("任务清单 1/3");
+    expect(out).toContain("✓ 调研");
+    expect(out).toContain("◐ 实现");
+    expect(out).toContain("· 测试");
+  });
+
+  it("the tool stores the list in working memory (survives compaction)", async () => {
+    const working: Record<string, any> = {};
+    const fakeAgent = { memory: { setWorking: (k: string, v: any) => { working[k] = v; } } };
+    const tool = createTodoTool(fakeAgent);
+    const out = String(await tool.handler!({ items: '[{"text":"步骤一","status":"active"}]' }));
+    expect(out).toContain("✓ 任务清单 0/1");
+    expect(working[TODO_WORKING_KEY]).toEqual([{ text: "步骤一", status: "active" }]);
+    expect(String(await tool.handler!({ items: "bad" }))).toContain("✗");
+  });
+});
+
+describe("工具结果上下文保护", () => {
+  it("passes small results through untouched", () => {
+    expect(clampToolResult("short", 100)).toBe("short");
+  });
+
+  it("clamps oversized results keeping head + tail with a hint", () => {
+    const big = "H".repeat(9000) + "M".repeat(9000) + "T".repeat(9000);
+    const out = clampToolResult(big, 12000);
+    expect(out.length).toBeLessThan(13000);
+    expect(out.startsWith("HHHH")).toBe(true);
+    expect(out.endsWith("TTTT")).toBe(true);
+    expect(out).toContain("中间省略");
+    expect(out).toContain("offset");
+  });
+});
+
+describe("ToolRegistry 运行时统计", () => {
+  it("tracks calls / failures / cache hits / avg duration", async () => {
+    const reg = new ToolRegistry();
+    reg.register({
+      name: "ok_tool", description: "test tool", parameters: [], cacheable: true,
+      handler: async () => "fine",
+    });
+    reg.register({
+      name: "bad_tool", description: "failing test tool", parameters: [], maxRetries: 0,
+      handler: async () => { throw new Error("boom"); },
+    });
+
+    await reg.execute("ok_tool", { q: 1 });
+    await reg.execute("ok_tool", { q: 1 }); // cache hit
+    await reg.execute("bad_tool", {});
+
+    const stats = reg.getStats();
+    const ok = stats.find(s => s.name === "ok_tool")!;
+    expect(ok.calls).toBe(1);
+    expect(ok.cacheHits).toBe(1);
+    expect(ok.failures).toBe(0);
+    const bad = stats.find(s => s.name === "bad_tool")!;
+    expect(bad.calls).toBe(1);
+    expect(bad.failures).toBe(1);
+    expect(bad.breaker).toBeDefined();
+  });
+});

package/tests/tool.test.ts

@@ -1,108 +1,108 @@
-/**
- * Tests for tool system.
- */
-import { describe, it, expect, vi } from 'vitest';
-import { ToolRegistry, type ToolDefinition } from '../src/core/tool';
-
-function makeTool(overrides: Partial<ToolDefinition> & { name: string }): ToolDefinition {
-  return {
-    name: overrides.name,
-    description: overrides.description ?? 'Test tool',
-    parameters: overrides.parameters ?? [],
-    handler: overrides.handler ?? vi.fn().mockResolvedValue('ok'),
-    dangerous: overrides.dangerous,
-    cacheable: overrides.cacheable,
-    maxRetries: overrides.maxRetries,
-    retryDelay: overrides.retryDelay,
-    timeout: overrides.timeout,
-  };
-}
-
-describe('ToolRegistry', () => {
-  let registry: ToolRegistry;
-
-  beforeEach(() => {
-    registry = new ToolRegistry();
-  });
-
-  it('register and get tool', () => {
-    const tool = makeTool({ name: 'test_tool' });
-    registry.register(tool);
-    expect(registry.get('test_tool')).toBe(tool);
-    expect(registry.get('nonexistent')).toBeUndefined();
-  });
-
-  it('list returns all tools', () => {
-    registry.register(makeTool({ name: 'a', description: 'A' }));
-    registry.register(makeTool({ name: 'b', description: 'B' }));
-    expect(registry.list()).toHaveLength(2);
-  });
-
-  it('listNames returns all names', () => {
-    registry.register(makeTool({ name: 'alpha', description: 'Alpha' }));
-    registry.register(makeTool({ name: 'beta', description: 'Beta' }));
-    const names = registry.listNames();
-    expect(names).toContain('alpha');
-    expect(names).toContain('beta');
-  });
-
-  it('getTools returns all tools', () => {
-    registry.register(makeTool({ name: 'x', description: 'X' }));
-    expect(registry.getTools()).toHaveLength(1);
-  });
-
-  it('reregister overrides existing', () => {
-    const t1 = makeTool({ name: 't', description: 'v1' });
-    const t2 = makeTool({ name: 't', description: 'v2' });
-    registry.register(t1);
-    registry.register(t2);
-    expect(registry.get('t')?.description).toBe('v2');
-  });
-
-  it('unregister removes tool', () => {
-    registry.register(makeTool({ name: 'temp', description: 'Temp' }));
-    expect(registry.get('temp')).toBeDefined();
-    registry.unregister('temp');
-    expect(registry.get('temp')).toBeUndefined();
-  });
-
-  it('has checks existence', () => {
-    registry.register(makeTool({ name: 'exists' }));
-    expect(registry.has('exists')).toBe(true);
-    expect(registry.has('missing')).toBe(false);
-  });
-
-  it('merge copies tools', () => {
-    const r2 = new ToolRegistry();
-    r2.register(makeTool({ name: 't2', description: 'T2' }));
-    registry.merge(r2);
-    expect(registry.get('t2')).toBeDefined();
-  });
-
-  it('execute returns result from handler', async () => {
-    const handler = vi.fn().mockResolvedValue('hello world');
-    registry.register(makeTool({ name: 'greet', handler }));
-    const result = await registry.execute('greet', { name: 'world' });
-    expect(result.success).toBe(true);
-    expect(result.result).toBe('hello world');
-  });
-
-  it('execute returns error for unknown tool', async () => {
-    const result = await registry.execute('unknown', {});
-    expect(result.success).toBe(false);
-    expect(result.error).toContain('not found');
-  });
-
-  it('execute validates required parameters', async () => {
-    const handler = vi.fn().mockResolvedValue('ok');
-    registry.register(makeTool({
-      name: 'needs_path',
-      parameters: [{ name: 'path', type: 'string', description: 'File path', required: true }],
-      handler,
-    }));
-    const result = await registry.execute('needs_path', {});
-    expect(result.success).toBe(false);
-    expect(result.error).toContain('required');
-    expect(handler).not.toHaveBeenCalled();
-  });
-});
+/**
+ * Tests for tool system.
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { ToolRegistry, type ToolDefinition } from '../src/core/tool';
+
+function makeTool(overrides: Partial<ToolDefinition> & { name: string }): ToolDefinition {
+  return {
+    name: overrides.name,
+    description: overrides.description ?? 'Test tool',
+    parameters: overrides.parameters ?? [],
+    handler: overrides.handler ?? vi.fn().mockResolvedValue('ok'),
+    dangerous: overrides.dangerous,
+    cacheable: overrides.cacheable,
+    maxRetries: overrides.maxRetries,
+    retryDelay: overrides.retryDelay,
+    timeout: overrides.timeout,
+  };
+}
+
+describe('ToolRegistry', () => {
+  let registry: ToolRegistry;
+
+  beforeEach(() => {
+    registry = new ToolRegistry();
+  });
+
+  it('register and get tool', () => {
+    const tool = makeTool({ name: 'test_tool' });
+    registry.register(tool);
+    expect(registry.get('test_tool')).toBe(tool);
+    expect(registry.get('nonexistent')).toBeUndefined();
+  });
+
+  it('list returns all tools', () => {
+    registry.register(makeTool({ name: 'a', description: 'A' }));
+    registry.register(makeTool({ name: 'b', description: 'B' }));
+    expect(registry.list()).toHaveLength(2);
+  });
+
+  it('listNames returns all names', () => {
+    registry.register(makeTool({ name: 'alpha', description: 'Alpha' }));
+    registry.register(makeTool({ name: 'beta', description: 'Beta' }));
+    const names = registry.listNames();
+    expect(names).toContain('alpha');
+    expect(names).toContain('beta');
+  });
+
+  it('getTools returns all tools', () => {
+    registry.register(makeTool({ name: 'x', description: 'X' }));
+    expect(registry.getTools()).toHaveLength(1);
+  });
+
+  it('reregister overrides existing', () => {
+    const t1 = makeTool({ name: 't', description: 'v1' });
+    const t2 = makeTool({ name: 't', description: 'v2' });
+    registry.register(t1);
+    registry.register(t2);
+    expect(registry.get('t')?.description).toBe('v2');
+  });
+
+  it('unregister removes tool', () => {
+    registry.register(makeTool({ name: 'temp', description: 'Temp' }));
+    expect(registry.get('temp')).toBeDefined();
+    registry.unregister('temp');
+    expect(registry.get('temp')).toBeUndefined();
+  });
+
+  it('has checks existence', () => {
+    registry.register(makeTool({ name: 'exists' }));
+    expect(registry.has('exists')).toBe(true);
+    expect(registry.has('missing')).toBe(false);
+  });
+
+  it('merge copies tools', () => {
+    const r2 = new ToolRegistry();
+    r2.register(makeTool({ name: 't2', description: 'T2' }));
+    registry.merge(r2);
+    expect(registry.get('t2')).toBeDefined();
+  });
+
+  it('execute returns result from handler', async () => {
+    const handler = vi.fn().mockResolvedValue('hello world');
+    registry.register(makeTool({ name: 'greet', handler }));
+    const result = await registry.execute('greet', { name: 'world' });
+    expect(result.success).toBe(true);
+    expect(result.result).toBe('hello world');
+  });
+
+  it('execute returns error for unknown tool', async () => {
+    const result = await registry.execute('unknown', {});
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('not found');
+  });
+
+  it('execute validates required parameters', async () => {
+    const handler = vi.fn().mockResolvedValue('ok');
+    registry.register(makeTool({
+      name: 'needs_path',
+      parameters: [{ name: 'path', type: 'string', description: 'File path', required: true }],
+      handler,
+    }));
+    const result = await registry.execute('needs_path', {});
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('required');
+    expect(handler).not.toHaveBeenCalled();
+  });
+});