skyloom 1.14.6 → 1.15.0

package/tests/skymd.test.ts

@@ -1,146 +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");
-  });
-});
+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/ssrf.test.ts

@@ -1,38 +1,38 @@
-import { describe, it, expect, afterEach } from "vitest";
-import { isPrivateIp, assertFetchAllowed } from "../src/tools/builtin";
-
-describe("SSRF guard — isPrivateIp", () => {
-  it("flags loopback, private, link-local and metadata addresses", () => {
-    for (const ip of ["127.0.0.1", "10.0.0.5", "172.16.3.4", "172.31.255.255",
-                       "192.168.1.1", "169.254.169.254", "100.64.0.1", "0.0.0.0",
-                       "::1", "::", "fc00::1", "fd12::3", "fe80::1", "::ffff:127.0.0.1"]) {
-      expect(isPrivateIp(ip), ip).toBe(true);
-    }
-  });
-  it("allows public addresses", () => {
-    for (const ip of ["8.8.8.8", "1.1.1.1", "172.32.0.1", "192.169.0.1", "2606:4700::1"]) {
-      expect(isPrivateIp(ip), ip).toBe(false);
-    }
-  });
-});
-
-describe("SSRF guard — assertFetchAllowed", () => {
-  afterEach(() => { delete process.env.SKYLOOM_ALLOW_PRIVATE_FETCH; });
-
-  it("rejects non-http(s) schemes", async () => {
-    await expect(assertFetchAllowed("file:///etc/passwd")).rejects.toThrow(/scheme/);
-    await expect(assertFetchAllowed("gopher://x")).rejects.toThrow(/scheme/);
-  });
-  it("rejects IP-literal private targets", async () => {
-    await expect(assertFetchAllowed("http://169.254.169.254/latest/meta-data/")).rejects.toThrow(/private/);
-    await expect(assertFetchAllowed("http://127.0.0.1:6379/")).rejects.toThrow(/private/);
-    await expect(assertFetchAllowed("http://[::1]/")).rejects.toThrow(/private/);
-  });
-  it("honors the opt-out env var", async () => {
-    process.env.SKYLOOM_ALLOW_PRIVATE_FETCH = "1";
-    await expect(assertFetchAllowed("http://127.0.0.1/")).resolves.toBeUndefined();
-  });
-  it("rejects an invalid URL", async () => {
-    await expect(assertFetchAllowed("not a url")).rejects.toThrow(/invalid URL/);
-  });
-});
+import { describe, it, expect, afterEach } from "vitest";
+import { isPrivateIp, assertFetchAllowed } from "../src/tools/builtin";
+
+describe("SSRF guard — isPrivateIp", () => {
+  it("flags loopback, private, link-local and metadata addresses", () => {
+    for (const ip of ["127.0.0.1", "10.0.0.5", "172.16.3.4", "172.31.255.255",
+                       "192.168.1.1", "169.254.169.254", "100.64.0.1", "0.0.0.0",
+                       "::1", "::", "fc00::1", "fd12::3", "fe80::1", "::ffff:127.0.0.1"]) {
+      expect(isPrivateIp(ip), ip).toBe(true);
+    }
+  });
+  it("allows public addresses", () => {
+    for (const ip of ["8.8.8.8", "1.1.1.1", "172.32.0.1", "192.169.0.1", "2606:4700::1"]) {
+      expect(isPrivateIp(ip), ip).toBe(false);
+    }
+  });
+});
+
+describe("SSRF guard — assertFetchAllowed", () => {
+  afterEach(() => { delete process.env.SKYLOOM_ALLOW_PRIVATE_FETCH; });
+
+  it("rejects non-http(s) schemes", async () => {
+    await expect(assertFetchAllowed("file:///etc/passwd")).rejects.toThrow(/scheme/);
+    await expect(assertFetchAllowed("gopher://x")).rejects.toThrow(/scheme/);
+  });
+  it("rejects IP-literal private targets", async () => {
+    await expect(assertFetchAllowed("http://169.254.169.254/latest/meta-data/")).rejects.toThrow(/private/);
+    await expect(assertFetchAllowed("http://127.0.0.1:6379/")).rejects.toThrow(/private/);
+    await expect(assertFetchAllowed("http://[::1]/")).rejects.toThrow(/private/);
+  });
+  it("honors the opt-out env var", async () => {
+    process.env.SKYLOOM_ALLOW_PRIVATE_FETCH = "1";
+    await expect(assertFetchAllowed("http://127.0.0.1/")).resolves.toBeUndefined();
+  });
+  it("rejects an invalid URL", async () => {
+    await expect(assertFetchAllowed("not a url")).rejects.toThrow(/invalid URL/);
+  });
+});

package/tests/structured_retry.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect } from "vitest";
+import { parseWithRetry, SchemaValidationError } from "../src/core/schemas";
+import { SnowAgent } from "../src/agents/snow";
+import { MessageBus } from "../src/core/bus";
+import { ToolRegistry } from "../src/core/tool";
+import { SkillRegistry } from "../src/core/skill";
+
+describe("parseWithRetry", () => {
+  it("returns the first valid parse without retrying", async () => {
+    let asks = 0;
+    const v = await parseWithRetry(
+      async () => { asks++; return '{"ok":1}'; },
+      (raw) => JSON.parse(raw),
+    );
+    expect(v).toEqual({ ok: 1 });
+    expect(asks).toBe(1);
+  });
+
+  it("feeds the parse error back and succeeds on a later attempt", async () => {
+    const replies = ["not json", "still bad", '{"ok":1}'];
+    const errors: string[] = [];
+    let lastPrior: string | null = "sentinel";
+    const v = await parseWithRetry(
+      async (priorError, attempt) => { lastPrior = priorError; return replies[attempt]; },
+      (raw) => { const d = JSON.parse(raw); return d; },
+      { retries: 2, onRetry: (_a, e) => errors.push(e) },
+    );
+    expect(v).toEqual({ ok: 1 });
+    expect(errors).toHaveLength(2);     // two failures before success
+    expect(lastPrior).not.toBeNull();   // third attempt received the prior error
+  });
+
+  it("throws after exhausting retries", async () => {
+    await expect(parseWithRetry(
+      async () => "nope",
+      (raw) => JSON.parse(raw),
+      { retries: 1 },
+    )).rejects.toBeInstanceOf(SchemaValidationError);
+  });
+});
+
+/** Mock LLM that yields scripted contents across successive llmLoop calls. */
+class ScriptedLLM {
+  calls = 0;
+  constructor(private contents: string[]) {}
+  async *streamWithTools(): AsyncGenerator<any> {
+    const c = this.contents[Math.min(this.calls, this.contents.length - 1)];
+    this.calls++;
+    yield { type: "content", text: c };
+    yield { type: "done", usage: { promptTokens: 1, completionTokens: 1 } };
+  }
+  async complete(): Promise<any> {
+    const c = this.contents[Math.min(this.calls, this.contents.length - 1)];
+    this.calls++;
+    return { content: c, toolCalls: [], model: "mock", usage: { promptTokens: 1, completionTokens: 1 }, cost: 0, truncated: false };
+  }
+  getTotalCost() { return 0; }
+  getModel() { return "mock"; }
+  setLogger() { /* noop */ }
+}
+
+function makeSnow(contents: string[]) {
+  const config = { agents: { snow: {} }, llm: { language: "zh" }, memory: { shortTermLimit: 100, dbPath: "/tmp/sky-test-snow" } };
+  return new SnowAgent(config as any, new ScriptedLLM(contents) as any, new MessageBus(), new ToolRegistry(), new SkillRegistry());
+}
+
+describe("snow.orchestrate · structured-output retry", () => {
+  const goodPlan = JSON.stringify({ goal: "g", steps: [
+    { id: "1", description: "research", agent: "fog" },
+    { id: "2", description: "code", agent: "rain" },
+  ]});
+
+  it("recovers a multi-step plan after a malformed first response", async () => {
+    const snow = makeSnow(["这是我的计划：不是 JSON", goodPlan]);
+    const tasks = await snow.orchestrate("build X");
+    expect(tasks).toHaveLength(2);
+    expect(tasks.map((t) => t.assignedTo)).toEqual(["fog", "rain"]);
+  });
+
+  it("falls back to a single task only after all retries fail", async () => {
+    const snow = makeSnow(["garbage", "still garbage", "nope not json either", "and again"]);
+    const tasks = await snow.orchestrate("build Y");
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0].assignedTo).toBe("rain");
+    expect(tasks[0].description).toBe("build Y");
+  });
+});

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);
+  });
+});