patchwarden 0.6.1 → 1.1.0

package/src/test/unit/goal-status.test.ts

@@ -0,0 +1,270 @@
+import { describe, it } from "node:test";
+import { strict as assert } from "node:assert";
+import {
+  createInitialGoalStatus,
+  addSubgoal,
+  updateSubgoalStatus,
+  linkTaskToSubgoal,
+  type GoalStatus,
+} from "../../goal/goalStatus.js";
+import { PatchWardenError } from "../../errors.js";
+
+// ── Helpers ───────────────────────────────────────────────────────
+
+function makeInitialStatus(): GoalStatus {
+  return createInitialGoalStatus("goal_test_001", "Test Goal", "/repo/test");
+}
+
+// ── Tests ─────────────────────────────────────────────────────────
+
+describe("goalStatus", () => {
+
+  describe("createInitialGoalStatus", () => {
+    it("返回正确的初始字段", () => {
+      const status = createInitialGoalStatus("goal_20260101_my_goal", "My Goal", "/repo/path");
+      assert.equal(status.goal_id, "goal_20260101_my_goal");
+      assert.equal(status.title, "My Goal");
+      assert.equal(status.status, "active");
+      assert.equal(status.repo_path, "/repo/path");
+      assert.ok(status.created_at.length > 0);
+      assert.equal(status.created_at, status.updated_at);
+      assert.deepEqual(status.subgoals, []);
+    });
+  });
+
+  describe("addSubgoal", () => {
+    it("成功生成 subgoal-001", () => {
+      const initial = makeInitialStatus();
+      const { goalStatus, subgoalId } = addSubgoal(initial, "First subgoal");
+      assert.equal(subgoalId, "subgoal-001");
+      assert.equal(goalStatus.subgoals.length, 1);
+      const sub = goalStatus.subgoals[0];
+      assert.equal(sub.id, "subgoal-001");
+      assert.equal(sub.title, "First subgoal");
+      assert.equal(sub.status, "ready");
+      assert.deepEqual(sub.depends_on, []);
+      assert.deepEqual(sub.task_ids, []);
+    });
+
+    it("多个 subgoal 编号递增", () => {
+      const initial = makeInitialStatus();
+      const r1 = addSubgoal(initial, "A");
+      const r2 = addSubgoal(r1.goalStatus, "B");
+      const r3 = addSubgoal(r2.goalStatus, "C");
+      assert.equal(r1.subgoalId, "subgoal-001");
+      assert.equal(r2.subgoalId, "subgoal-002");
+      assert.equal(r3.subgoalId, "subgoal-003");
+      assert.equal(r3.goalStatus.subgoals.length, 3);
+    });
+
+    it("三位补零到 010", () => {
+      let status = makeInitialStatus();
+      for (let i = 1; i <= 10; i++) {
+        const r = addSubgoal(status, `Sub ${i}`);
+        status = r.goalStatus;
+        if (i === 10) {
+          assert.equal(r.subgoalId, "subgoal-010");
+        }
+      }
+    });
+
+    it("无效依赖抛出 invalid_dependency", () => {
+      const initial = makeInitialStatus();
+      assert.throws(
+        () => addSubgoal(initial, "Bad dep", ["subgoal-999"]),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError);
+          assert.equal(err.reason, "invalid_dependency");
+          return true;
+        }
+      );
+    });
+
+    it("有效依赖成功添加", () => {
+      const initial = makeInitialStatus();
+      const r1 = addSubgoal(initial, "Parent");
+      const r2 = addSubgoal(r1.goalStatus, "Child", ["subgoal-001"]);
+      assert.equal(r2.subgoalId, "subgoal-002");
+      assert.deepEqual(r2.goalStatus.subgoals[1].depends_on, ["subgoal-001"]);
+    });
+
+    it("不修改原 goalStatus（不可变）", () => {
+      const initial = makeInitialStatus();
+      const originalLen = initial.subgoals.length;
+      addSubgoal(initial, "New");
+      assert.equal(initial.subgoals.length, originalLen);
+    });
+
+    it("更新 updated_at", () => {
+      const initial = makeInitialStatus();
+      const originalUpdatedAt = initial.updated_at;
+      const { goalStatus } = addSubgoal(initial, "New");
+      // updated_at 应该是新的 ISO 时间字符串
+      assert.ok(goalStatus.updated_at >= originalUpdatedAt);
+    });
+  });
+
+  describe("updateSubgoalStatus", () => {
+    it("合法转换 ready → running", () => {
+      let status = makeInitialStatus();
+      const r = addSubgoal(status, "Sub");
+      status = r.goalStatus;
+      const updated = updateSubgoalStatus(status, "subgoal-001", "running");
+      assert.equal(updated.subgoals[0].status, "running");
+    });
+
+    it("合法完整链路 ready → running → done_by_agent → accepted", () => {
+      let status = makeInitialStatus();
+      status = addSubgoal(status, "Sub").goalStatus;
+      status = updateSubgoalStatus(status, "subgoal-001", "running");
+      status = updateSubgoalStatus(status, "subgoal-001", "done_by_agent");
+      status = updateSubgoalStatus(status, "subgoal-001", "accepted");
+      assert.equal(status.subgoals[0].status, "accepted");
+      assert.ok(status.subgoals[0].accepted_at !== undefined);
+      assert.ok(status.subgoals[0].accepted_at!.length > 0);
+    });
+
+    it("done_by_agent → rejected 需要 reason", () => {
+      let status = makeInitialStatus();
+      status = addSubgoal(status, "Sub").goalStatus;
+      status = updateSubgoalStatus(status, "subgoal-001", "running");
+      status = updateSubgoalStatus(status, "subgoal-001", "done_by_agent");
+
+      // 缺少 reason 抛错
+      assert.throws(
+        () => updateSubgoalStatus(status, "subgoal-001", "rejected"),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError);
+          assert.equal(err.reason, "invalid_status_transition");
+          return true;
+        }
+      );
+
+      // 提供 reason 成功
+      const updated = updateSubgoalStatus(status, "subgoal-001", "rejected", {
+        rejected_reason: "Tests failed",
+      });
+      assert.equal(updated.subgoals[0].status, "rejected");
+      assert.equal(updated.subgoals[0].rejected_reason, "Tests failed");
+    });
+
+    it("合法分支 done_by_agent → needs_fix → running", () => {
+      let status = makeInitialStatus();
+      status = addSubgoal(status, "Sub").goalStatus;
+      status = updateSubgoalStatus(status, "subgoal-001", "running");
+      status = updateSubgoalStatus(status, "subgoal-001", "done_by_agent");
+      status = updateSubgoalStatus(status, "subgoal-001", "needs_fix");
+      assert.equal(status.subgoals[0].status, "needs_fix");
+      status = updateSubgoalStatus(status, "subgoal-001", "running");
+      assert.equal(status.subgoals[0].status, "running");
+    });
+
+    it("非法转换 ready → accepted 抛错", () => {
+      const initial = makeInitialStatus();
+      const status = addSubgoal(initial, "Sub").goalStatus;
+      assert.throws(
+        () => updateSubgoalStatus(status, "subgoal-001", "accepted"),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError);
+          assert.equal(err.reason, "invalid_status_transition");
+          return true;
+        }
+      );
+    });
+
+    it("非法转换 running → ready 抛错", () => {
+      let status = makeInitialStatus();
+      status = addSubgoal(status, "Sub").goalStatus;
+      status = updateSubgoalStatus(status, "subgoal-001", "running");
+      assert.throws(
+        () => updateSubgoalStatus(status, "subgoal-001", "ready"),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError);
+          assert.equal(err.reason, "invalid_status_transition");
+          return true;
+        }
+      );
+    });
+
+    it("终态 accepted → running 抛错", () => {
+      let status = makeInitialStatus();
+      status = addSubgoal(status, "Sub").goalStatus;
+      status = updateSubgoalStatus(status, "subgoal-001", "running");
+      status = updateSubgoalStatus(status, "subgoal-001", "done_by_agent");
+      status = updateSubgoalStatus(status, "subgoal-001", "accepted");
+      assert.throws(
+        () => updateSubgoalStatus(status, "subgoal-001", "running"),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError);
+          assert.equal(err.reason, "invalid_status_transition");
+          return true;
+        }
+      );
+    });
+
+    it("subgoal 不存在抛出 subgoal_not_found", () => {
+      const initial = makeInitialStatus();
+      assert.throws(
+        () => updateSubgoalStatus(initial, "subgoal-999", "running"),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError);
+          assert.equal(err.reason, "subgoal_not_found");
+          return true;
+        }
+      );
+    });
+
+    it("不修改原 goalStatus（不可变）", () => {
+      let status = makeInitialStatus();
+      status = addSubgoal(status, "Sub").goalStatus;
+      const originalStatus = status.subgoals[0].status;
+      updateSubgoalStatus(status, "subgoal-001", "running");
+      assert.equal(status.subgoals[0].status, originalStatus);
+    });
+  });
+
+  describe("linkTaskToSubgoal", () => {
+    it("成功追加 taskId", () => {
+      let status = makeInitialStatus();
+      status = addSubgoal(status, "Sub").goalStatus;
+      const updated = linkTaskToSubgoal(status, "subgoal-001", "task_abc");
+      assert.deepEqual(updated.subgoals[0].task_ids, ["task_abc"]);
+    });
+
+    it("追加多个 taskId", () => {
+      let status = makeInitialStatus();
+      status = addSubgoal(status, "Sub").goalStatus;
+      status = linkTaskToSubgoal(status, "subgoal-001", "task_a");
+      status = linkTaskToSubgoal(status, "subgoal-001", "task_b");
+      assert.deepEqual(status.subgoals[0].task_ids, ["task_a", "task_b"]);
+    });
+
+    it("去重：相同 taskId 不重复添加", () => {
+      let status = makeInitialStatus();
+      status = addSubgoal(status, "Sub").goalStatus;
+      status = linkTaskToSubgoal(status, "subgoal-001", "task_a");
+      status = linkTaskToSubgoal(status, "subgoal-001", "task_a");
+      assert.deepEqual(status.subgoals[0].task_ids, ["task_a"]);
+    });
+
+    it("subgoal 不存在抛出 subgoal_not_found", () => {
+      const initial = makeInitialStatus();
+      assert.throws(
+        () => linkTaskToSubgoal(initial, "subgoal-999", "task_a"),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError);
+          assert.equal(err.reason, "subgoal_not_found");
+          return true;
+        }
+      );
+    });
+
+    it("不修改原 goalStatus（不可变）", () => {
+      let status = makeInitialStatus();
+      status = addSubgoal(status, "Sub").goalStatus;
+      const originalLen = status.subgoals[0].task_ids.length;
+      linkTaskToSubgoal(status, "subgoal-001", "task_a");
+      assert.equal(status.subgoals[0].task_ids.length, originalLen);
+    });
+  });
+});

package/src/test/unit/goal-store.test.ts

@@ -0,0 +1,318 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import { strict as assert } from "node:assert";
+import { mkdtempSync, rmSync, existsSync, readdirSync, readFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  generateGoalId,
+  getGoalsDir,
+  getGoalDir,
+  createGoal,
+  listGoals,
+  readGoal,
+  writeGoalStatus,
+  readGoalStatus,
+} from "../../goal/goalStore.js";
+import { addSubgoal, updateSubgoalStatus } from "../../goal/goalStatus.js";
+import { PatchWardenError } from "../../errors.js";
+
+// ── Helpers ───────────────────────────────────────────────────────
+
+let tempDir: string;
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), "pw-goalstore-"));
+});
+
+afterEach(() => {
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+function todayDatePart(): string {
+  const now = new Date();
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  return `${y}${m}${d}`;
+}
+
+// ── Tests ─────────────────────────────────────────────────────────
+
+describe("goalStore", () => {
+
+  describe("generateGoalId", () => {
+    it("正常 title 生成 goal_{date}_{slug}", () => {
+      const id = generateGoalId("Implement Feature X", []);
+      assert.equal(id, `goal_${todayDatePart()}_implement_feature_x`);
+    });
+
+    it("特殊字符 title 转换为 slug", () => {
+      const id = generateGoalId("Fix: Bug #123 & Refactor!", []);
+      assert.equal(id, `goal_${todayDatePart()}_fix_bug_123_refactor`);
+    });
+
+    it("空 title 用 untitled 代替", () => {
+      const id = generateGoalId("", []);
+      assert.equal(id, `goal_${todayDatePart()}_untitled`);
+    });
+
+    it("纯符号 title 用 untitled 代替", () => {
+      const id = generateGoalId("!!!@#$%^&*()", []);
+      assert.equal(id, `goal_${todayDatePart()}_untitled`);
+    });
+
+    it("title 截断到 30 字符 slug", () => {
+      const longTitle = "abcdefghijklmnopqrstuvwxyz0123456789";
+      const id = generateGoalId(longTitle, []);
+      const slug = id.split("_").slice(2).join("_");
+      assert.ok(slug.length <= 30, `slug length should be <= 30, got ${slug.length}`);
+    });
+
+    it("冲突时追加 _2", () => {
+      const base = `goal_${todayDatePart()}_implement_feature_x`;
+      const id = generateGoalId("Implement Feature X", [base]);
+      assert.equal(id, `${base}_2`);
+    });
+
+    it("多次冲突递增 _3", () => {
+      const base = `goal_${todayDatePart()}_implement_feature_x`;
+      const id = generateGoalId("Implement Feature X", [base, `${base}_2`]);
+      assert.equal(id, `${base}_3`);
+    });
+
+    it("不冲突时不追加后缀", () => {
+      const base = `goal_${todayDatePart()}_implement_feature_x`;
+      const other = `goal_${todayDatePart()}_other_goal`;
+      const id = generateGoalId("Implement Feature X", [other]);
+      assert.equal(id, base);
+    });
+  });
+
+  describe("getGoalsDir / getGoalDir", () => {
+    it("getGoalsDir 返回 .patchwarden/goals 路径", () => {
+      const dir = getGoalsDir(tempDir);
+      assert.equal(dir, join(tempDir, ".patchwarden", "goals"));
+    });
+
+    it("getGoalDir 返回 {goalsDir}/{goalId}", () => {
+      const dir = getGoalDir("goal_001", tempDir);
+      assert.equal(dir, join(tempDir, ".patchwarden", "goals", "goal_001"));
+    });
+  });
+
+  describe("createGoal", () => {
+    it("成功创建目录结构和文件", () => {
+      const repoRel = "my-repo";
+      const { goal_id, goal_dir } = createGoal(repoRel, "Test Goal", "A test description", tempDir);
+      assert.ok(goal_id.startsWith(`goal_${todayDatePart()}_test_goal`));
+      assert.equal(goal_dir, join(tempDir, ".patchwarden", "goals", goal_id));
+
+      // 验证目录结构
+      assert.ok(existsSync(goal_dir), "goal_dir exists");
+      assert.ok(existsSync(join(goal_dir, "tasks")), "tasks/ exists");
+      assert.ok(existsSync(join(goal_dir, "artifacts")), "artifacts/ exists");
+
+      // 验证 GOAL.md
+      const goalMd = readFileSync(join(goal_dir, "GOAL.md"), "utf-8");
+      assert.ok(goalMd.includes("# Test Goal"));
+      assert.ok(goalMd.includes("A test description"));
+      assert.ok(goalMd.includes("- Status: active"));
+      assert.ok(goalMd.includes("- Repo:"));
+
+      // 验证 GOALS.md
+      const goalsMd = readFileSync(join(goal_dir, "GOALS.md"), "utf-8");
+      assert.ok(goalsMd.includes("# Subgoals: Test Goal"));
+      assert.ok(goalsMd.includes("_No subgoals yet._"));
+
+      // 验证 goal_status.json
+      const statusPath = join(goal_dir, "goal_status.json");
+      assert.ok(existsSync(statusPath));
+      const status = JSON.parse(readFileSync(statusPath, "utf-8"));
+      assert.equal(status.goal_id, goal_id);
+      assert.equal(status.title, "Test Goal");
+      assert.equal(status.status, "active");
+      assert.deepEqual(status.subgoals, []);
+    });
+
+    it("repo_path 越界抛出 workspace_path_escape", () => {
+      const outside = process.platform === "win32" ? "C:\\Windows\\System32" : "/etc";
+      assert.throws(
+        () => createGoal(outside, "Bad", "desc", tempDir),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError);
+          assert.equal(err.reason, "workspace_path_escape");
+          return true;
+        }
+      );
+    });
+
+    it("相同 title 创建多个 goal 时 id 不冲突", () => {
+      const r1 = createGoal("repo", "Same Title", "d1", tempDir);
+      const r2 = createGoal("repo", "Same Title", "d2", tempDir);
+      assert.notEqual(r1.goal_id, r2.goal_id);
+      assert.ok(r2.goal_id.endsWith("_2"));
+    });
+  });
+
+  describe("listGoals", () => {
+    it("空目录返回空数组", () => {
+      const list = listGoals(tempDir);
+      assert.deepEqual(list, []);
+    });
+
+    it("goals 目录不存在返回空数组", () => {
+      // tempDir 中没有 .patchwarden/goals
+      const list = listGoals(tempDir);
+      assert.deepEqual(list, []);
+    });
+
+    it("返回多个 goal 的摘要", () => {
+      createGoal("repo", "Goal A", "desc A", tempDir);
+      createGoal("repo", "Goal B", "desc B", tempDir);
+      const list = listGoals(tempDir);
+      assert.equal(list.length, 2);
+      const titles = list.map((g) => g.title).sort();
+      assert.deepEqual(titles, ["Goal A", "Goal B"]);
+    });
+
+    it("按 updated_at 降序排列", async () => {
+      const r1 = createGoal("repo", "Older", "desc", tempDir);
+      // 等待一小段时间确保 updated_at 不同
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      const r2 = createGoal("repo", "Newer", "desc", tempDir);
+
+      // 修改 older 的 status，使其 updated_at 更新
+      const olderStatus = readGoalStatus(r1.goal_id, tempDir);
+      const newerStatus = readGoalStatus(r2.goal_id, tempDir);
+
+      // 让 older 的 updated_at 比 newer 更晚
+      const future = new Date(Date.now() + 10000).toISOString();
+      writeGoalStatus(r1.goal_id, { ...olderStatus, updated_at: future }, tempDir);
+
+      const list = listGoals(tempDir);
+      assert.equal(list.length, 2);
+      assert.equal(list[0].goal_id, r1.goal_id);
+      assert.equal(list[1].goal_id, r2.goal_id);
+      assert.ok(list[0].updated_at >= list[1].updated_at);
+    });
+
+    it("subgoal 摘要正确计算", () => {
+      const { goal_id } = createGoal("repo", "With Subs", "desc", tempDir);
+      let status = readGoalStatus(goal_id, tempDir);
+      status = addSubgoal(status, "S1").goalStatus;
+      status = updateSubgoalStatus(status, "subgoal-001", "running");
+      status = addSubgoal(status, "S2").goalStatus;
+      status = updateSubgoalStatus(status, "subgoal-002", "running");
+      status = updateSubgoalStatus(status, "subgoal-002", "done_by_agent");
+      status = updateSubgoalStatus(status, "subgoal-002", "accepted");
+      writeGoalStatus(goal_id, status, tempDir);
+
+      const list = listGoals(tempDir);
+      assert.equal(list.length, 1);
+      const item = list[0];
+      assert.equal(item.subgoal_total, 2);
+      assert.equal(item.subgoal_accepted, 1);
+      assert.equal(item.subgoal_running, 1);
+    });
+
+    it("跳过无法解析的目录", () => {
+      // 创建一个有效的 goal
+      createGoal("repo", "Valid", "desc", tempDir);
+      // 创建一个无效的目录（没有 goal_status.json）
+      const goalsDir = getGoalsDir(tempDir);
+      const badDir = join(goalsDir, "goal_bad_9999_invalid");
+      mkdirSync(badDir, { recursive: true });
+
+      const list = listGoals(tempDir);
+      assert.equal(list.length, 1);
+      assert.equal(list[0].title, "Valid");
+    });
+  });
+
+  describe("readGoal", () => {
+    it("返回完整详情", () => {
+      const { goal_id } = createGoal("repo", "Read Me", "description here", tempDir);
+      const detail = readGoal(goal_id, tempDir);
+      assert.equal(detail.goal_id, goal_id);
+      assert.equal(detail.title, "Read Me");
+      assert.equal(detail.status, "active");
+      assert.equal(detail.created_at, detail.updated_at);
+      assert.ok(detail.goal_description.includes("# Read Me"));
+      assert.ok(detail.goal_description.includes("description here"));
+      assert.deepEqual(detail.subgoals, []);
+    });
+
+    it("goal 不存在抛出 goal_not_found", () => {
+      assert.throws(
+        () => readGoal("goal_nonexistent", tempDir),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError);
+          assert.equal(err.reason, "goal_not_found");
+          return true;
+        }
+      );
+    });
+
+    it("goal_status.json 不存在抛出 goal_not_found", () => {
+      // 手动创建一个 goal 目录但不写 status
+      const goalsDir = getGoalsDir(tempDir);
+      const emptyGoalDir = join(goalsDir, "goal_empty");
+      mkdirSync(emptyGoalDir, { recursive: true });
+      assert.throws(
+        () => readGoal("goal_empty", tempDir),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError);
+          assert.equal(err.reason, "goal_not_found");
+          return true;
+        }
+      );
+    });
+  });
+
+  describe("writeGoalStatus + readGoalStatus", () => {
+    it("写入后读取一致", () => {
+      const { goal_id } = createGoal("repo", "Round Trip", "desc", tempDir);
+      const original = readGoalStatus(goal_id, tempDir);
+      const withSub = addSubgoal(original, "New Sub").goalStatus;
+      writeGoalStatus(goal_id, withSub, tempDir);
+
+      const read = readGoalStatus(goal_id, tempDir);
+      assert.equal(read.subgoals.length, 1);
+      assert.equal(read.subgoals[0].id, "subgoal-001");
+      assert.equal(read.subgoals[0].title, "New Sub");
+      assert.equal(read.subgoals[0].status, "ready");
+    });
+
+    it("原子写：tmp 文件不留", () => {
+      const { goal_id, goal_dir } = createGoal("repo", "Atomic", "desc", tempDir);
+      const status = readGoalStatus(goal_id, tempDir);
+      writeGoalStatus(goal_id, status, tempDir);
+
+      const entries = readdirSync(goal_dir);
+      assert.ok(!entries.includes("goal_status.json.tmp"), "tmp file should not remain");
+      assert.ok(entries.includes("goal_status.json"), "final file should exist");
+    });
+
+    it("readGoalStatus 文件不存在抛出 goal_not_found", () => {
+      assert.throws(
+        () => readGoalStatus("goal_nonexistent", tempDir),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError);
+          assert.equal(err.reason, "goal_not_found");
+          return true;
+        }
+      );
+    });
+
+    it("JSON 格式化（2 空格缩进 + 末尾换行）", () => {
+      const { goal_id, goal_dir } = createGoal("repo", "Format", "desc", tempDir);
+      const status = readGoalStatus(goal_id, tempDir);
+      writeGoalStatus(goal_id, status, tempDir);
+      const raw = readFileSync(join(goal_dir, "goal_status.json"), "utf-8");
+      // 末尾换行
+      assert.ok(raw.endsWith("\n"), "should end with newline");
+      // 2 空格缩进
+      assert.ok(raw.includes('\n  "goal_id"'), "should use 2-space indent");
+    });
+  });
+});

package/src/test/unit/goal-subgoal-task.test.ts

@@ -0,0 +1,72 @@
+import { describe, it } from "node:test";
+import { strict as assert } from "node:assert";
+import { createSubgoalTask } from "../../tools/goalSubgoalTask.js";
+import { PatchWardenError } from "../../errors.js";
+
+// ── Tests ─────────────────────────────────────────────────────────
+//
+// 说明：createSubgoalTask 内部调用 createTask，后者使用 getConfig()（无 workspaceRoot
+// 覆盖），因此 happy-path 依赖真实配置的工作区，留待集成测试覆盖。
+// 此处仅测试不触及 createTask 完整流程的错误路径：
+//   - invalid_execution_mode：在读取 goal 之前即抛错
+//   - goal_not_found：readGoalStatus 在默认工作区找不到 goal 即抛错
+
+describe("createSubgoalTask", () => {
+
+  describe("错误路径", () => {
+    it("execution_mode=assess_only 抛 invalid_execution_mode", () => {
+      assert.throws(
+        () =>
+          createSubgoalTask({
+            goal_id: "goal_nonexistent_test",
+            subgoal_title: "Sub A",
+            repo_path: "repo",
+            execution_mode: "assess_only",
+          }),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError);
+          assert.equal(err.reason, "invalid_execution_mode");
+          assert.equal(err.blocked, true);
+          return true;
+        }
+      );
+    });
+
+    it("goal_id 不存在抛 goal_not_found", () => {
+      assert.throws(
+        () =>
+          createSubgoalTask({
+            goal_id: "goal_definitely_does_not_exist_99999",
+            subgoal_title: "Sub A",
+            repo_path: "repo",
+          }),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError);
+          assert.equal(err.reason, "goal_not_found");
+          assert.equal(err.blocked, true);
+          assert.ok(err.details.goal_id === "goal_definitely_does_not_exist_99999");
+          return true;
+        }
+      );
+    });
+
+    it("assess_only 优先于 goal_not_found（在读取 goal 前校验）", () => {
+      // execution_mode=assess_only 应先抛 invalid_execution_mode，
+      // 而不是去读不存在的 goal
+      assert.throws(
+        () =>
+          createSubgoalTask({
+            goal_id: "goal_definitely_does_not_exist_99999",
+            subgoal_title: "Sub A",
+            repo_path: "repo",
+            execution_mode: "assess_only",
+          }),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError);
+          assert.equal(err.reason, "invalid_execution_mode");
+          return true;
+        }
+      );
+    });
+  });
+});