patchwarden 0.6.4 → 1.5.0

package/src/test/unit/discovery-token-store.test.ts

@@ -0,0 +1,181 @@
+import { describe, it, beforeEach } from "node:test";
+import { strict as assert } from "node:assert";
+import {
+  issueToken,
+  consumeToken,
+  peekToken,
+  revokeToken,
+  clearAllTokens,
+  getActiveTokenCount,
+  type IssueTokenInput,
+} from "../../security/discoveryTokenStore.js";
+import { PatchWardenError } from "../../errors.js";
+
+// ── Helpers ───────────────────────────────────────────────────────
+
+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}`;
+}
+
+function sampleInput(overrides: Partial<IssueTokenInput> = {}): IssueTokenInput {
+  return {
+    toolName: "read_workspace_file",
+    risk: "workspace_read_sensitive",
+    query: "read file",
+    schemaDigest: "sha256:abc123",
+    profile: "full",
+    ...overrides,
+  };
+}
+
+// ── Tests ─────────────────────────────────────────────────────────
+
+describe("discoveryTokenStore", () => {
+  beforeEach(() => {
+    clearAllTokens();
+  });
+
+  describe("issueToken", () => {
+    it("返回 dst_ 前缀 + 日期 + 12 位 hex 格式", () => {
+      const token = issueToken(sampleInput());
+      const regex = new RegExp(`^dst_${todayDatePart()}_[a-f0-9]{12}$`);
+      assert.ok(regex.test(token), `token "${token}" should match dst_YYYYMMDD_hex12`);
+    });
+
+    it("默认 expiresAt 为 issuedAt + 10 分钟", () => {
+      const token = issueToken(sampleInput());
+      const record = peekToken(token);
+      assert.ok(record, "record should exist");
+      const diff = Date.parse(record!.expiresAt) - Date.parse(record!.issuedAt);
+      // 允许 50ms 容差（两次 Date.now 调用间微小差异）
+      assert.ok(
+        Math.abs(diff - 600000) <= 50,
+        `expected diff ~600000ms, got ${diff}ms`
+      );
+    });
+
+    it("自定义 ttlMs 反映到 expiresAt", () => {
+      const token = issueToken(sampleInput({ ttlMs: 30000 }));
+      const record = peekToken(token);
+      assert.ok(record);
+      const diff = Date.parse(record!.expiresAt) - Date.parse(record!.issuedAt);
+      assert.ok(
+        Math.abs(diff - 30000) <= 50,
+        `expected diff ~30000ms, got ${diff}ms`
+      );
+    });
+
+    it("保存 record 字段完整", () => {
+      const token = issueToken(sampleInput({ allowedScope: ["src/"] }));
+      const record = peekToken(token);
+      assert.ok(record);
+      assert.equal(record!.token, token);
+      assert.equal(record!.toolName, "read_workspace_file");
+      assert.equal(record!.risk, "workspace_read_sensitive");
+      assert.deepEqual(record!.allowedScope, ["src/"]);
+      assert.equal(record!.query, "read file");
+      assert.equal(record!.schemaDigest, "sha256:abc123");
+      assert.equal(record!.profile, "full");
+    });
+  });
+
+  describe("consumeToken", () => {
+    it("成功返回 record 并删除（单次使用）", () => {
+      const token = issueToken(sampleInput());
+      const record = consumeToken(token);
+      assert.equal(record.token, token);
+      // 再次 consume 应抛 token_not_found
+      assert.throws(
+        () => consumeToken(token),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError);
+          assert.equal(err.reason, "token_not_found");
+          return true;
+        }
+      );
+    });
+
+    it("不存在抛 token_not_found", () => {
+      assert.throws(
+        () => consumeToken("dst_nonexistent_000000000000"),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError);
+          assert.equal(err.reason, "token_not_found");
+          return true;
+        }
+      );
+    });
+
+    it("过期抛 token_expired", () => {
+      // 用负 ttlMs 构造已过期 token
+      const token = issueToken(sampleInput({ ttlMs: -1000 }));
+      assert.throws(
+        () => consumeToken(token),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError);
+          assert.equal(err.reason, "token_expired");
+          return true;
+        }
+      );
+    });
+
+    it("过期 token 被消费后从 store 删除", () => {
+      const token = issueToken(sampleInput({ ttlMs: -1000 }));
+      assert.throws(() => consumeToken(token));
+      // peek 应返回 null（已删除）
+      assert.equal(peekToken(token), null);
+    });
+  });
+
+  describe("peekToken", () => {
+    it("不消费 token（peek 后 consume 仍成功）", () => {
+      const token = issueToken(sampleInput());
+      const peeked = peekToken(token);
+      assert.ok(peeked);
+      assert.equal(peeked!.token, token);
+      // peek 后 consume 仍能成功
+      const consumed = consumeToken(token);
+      assert.equal(consumed.token, token);
+    });
+
+    it("不存在返回 null", () => {
+      assert.equal(peekToken("dst_nonexistent_000000000000"), null);
+    });
+  });
+
+  describe("revokeToken", () => {
+    it("删除 token，返回 true", () => {
+      const token = issueToken(sampleInput());
+      assert.equal(revokeToken(token), true);
+      assert.equal(peekToken(token), null);
+    });
+
+    it("不存在返回 false", () => {
+      assert.equal(revokeToken("dst_nonexistent_000000000000"), false);
+    });
+  });
+
+  describe("clearAllTokens", () => {
+    it("清空所有 token", () => {
+      issueToken(sampleInput());
+      issueToken(sampleInput());
+      assert.equal(getActiveTokenCount(), 2);
+      clearAllTokens();
+      assert.equal(getActiveTokenCount(), 0);
+    });
+  });
+
+  describe("getActiveTokenCount", () => {
+    it("正确返回当前 token 数量", () => {
+      assert.equal(getActiveTokenCount(), 0);
+      issueToken(sampleInput());
+      assert.equal(getActiveTokenCount(), 1);
+      issueToken(sampleInput());
+      assert.equal(getActiveTokenCount(), 2);
+    });
+  });
+});

package/src/test/unit/evidence-pack.test.ts

@@ -0,0 +1,142 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import { strict as assert } from "node:assert";
+import { mkdtempSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { reloadConfig } from "../../config.js";
+import { recommendAgentForTask } from "../../tools/recommendAgentForTask.js";
+import { exportTaskEvidencePack, listEvidencePacks, readEvidencePack } from "../../tools/evidencePack.js";
+import { writeTaskLineage } from "../../tools/taskLineage.js";
+
+let tempDir: string;
+let prevConfigEnv: string | undefined;
+
+function writeConfig() {
+  const configPath = join(tempDir, "patchwarden.config.json");
+  writeFileSync(
+    configPath,
+    JSON.stringify({
+      workspaceRoot: tempDir,
+      tasksDir: ".patchwarden/tasks",
+      plansDir: ".patchwarden/plans",
+      assessmentsDir: ".patchwarden/assessments",
+      agents: {
+        codex: { command: "codex", args: [] },
+        opencode: { command: "opencode", args: [] },
+      },
+      allowedTestCommands: ["npm test", "npm run build"],
+      defaultTaskTimeoutSeconds: 30,
+      maxTaskTimeoutSeconds: 120,
+    }),
+    "utf-8"
+  );
+  prevConfigEnv = process.env.PATCHWARDEN_CONFIG;
+  process.env.PATCHWARDEN_CONFIG = configPath;
+  reloadConfig();
+}
+
+describe("v1.5 evidence packs and agent recommendations", () => {
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "pw-evidence-"));
+    writeConfig();
+  });
+
+  afterEach(() => {
+    if (prevConfigEnv === undefined) delete process.env.PATCHWARDEN_CONFIG;
+    else process.env.PATCHWARDEN_CONFIG = prevConfigEnv;
+    reloadConfig();
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("recommends an agent without creating task evidence", () => {
+    const recommendation = recommendAgentForTask({
+      repo_path: ".",
+      goal: "Refactor two modules safely",
+      scope_files: ["src/a.ts", "src/b.ts"],
+    });
+
+    assert.equal(recommendation.bounded, true);
+    assert.ok(["codex", "opencode"].includes(recommendation.recommended_agent));
+    assert.ok(Array.isArray(recommendation.suggested_verify_commands));
+    const payload = JSON.stringify(recommendation);
+    assert.ok(!payload.includes("stdout"));
+    assert.ok(!payload.includes("stderr"));
+    assert.ok(!payload.includes("diff"));
+  });
+
+  it("exports bounded BOM-free evidence pack from lineage", () => {
+    writeTaskLineage({
+      lineage_id: "lineage_v15_pack",
+      goal: "Export evidence",
+      repo_path: ".",
+      created_at: "2026-07-05T12:00:00.000Z",
+      updated_at: "2026-07-05T12:01:00.000Z",
+      final_status: "accepted",
+      stop_reason: "success",
+      next_action: "accept",
+      main_task: "task-main",
+      fix_tasks: [],
+      cleanup_tasks: [],
+      direct_sessions: [{
+        session_id: "direct-one",
+        status: "passed",
+        command_count: 1,
+        passed_commands: 1,
+        failed_commands: 0,
+        timed_out_commands: 0,
+        audit_decision: "pass",
+        changed_files_total: 0,
+        next_action: "accept",
+      }],
+      rounds: [{
+        iteration: 1,
+        task_id: "task-main",
+        role: "main",
+        status: "done_by_agent",
+        terminal: true,
+        verification_status: "passed",
+        audit_verdict: "pass",
+        fail_checks: [],
+        warn_checks: [],
+        next_action: "accept",
+      }],
+      warnings: [],
+      errors: [],
+      worktree: {
+        isolation_mode: "worktree",
+        worktree_id: "wt-one",
+        worktree_path: join(tempDir, "_workspacetrees", "wt-one"),
+        branch: "pw-test",
+        cleanup: "keep",
+        status: "active",
+        next_action: "merge or discard explicitly",
+      },
+      agent_routing: {
+        requested_agent: "auto",
+        selected_agent: "codex",
+        reason: "test route",
+        fallback: false,
+      },
+    });
+
+    const pack = exportTaskEvidencePack({ lineage_id: "lineage_v15_pack" });
+    assert.equal(pack.bounded, true);
+    assert.equal(pack.lineage.worktree.worktree_id, "wt-one");
+    assert.equal(pack.lineage.agent_routing?.selected_agent, "codex");
+    const raw = readFileSync(pack.files.json);
+    assert.notEqual(raw[0], 0xef);
+    JSON.parse(raw.toString("utf-8"));
+
+    const payload = JSON.stringify(pack);
+    assert.ok(!payload.includes("stdout_tail"));
+    assert.ok(!payload.includes("stderr_tail"));
+    assert.ok(!payload.includes("diff.patch"));
+    assert.ok(!payload.includes("verification.log"));
+
+    const readBack = readEvidencePack("lineage_v15_pack");
+    assert.equal(readBack?.lineage_id, "lineage_v15_pack");
+    const listed = listEvidencePacks();
+    assert.equal(listed.total, 1);
+    assert.equal(listed.evidence_packs[0].lineage_id, "lineage_v15_pack");
+  });
+});

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

@@ -0,0 +1,347 @@
+import { describe, it } from "node:test";
+import { strict as assert } from "node:assert";
+import {
+  getReadySubgoals,
+  getBlockedSubgoals,
+  suggestNextSubgoal,
+  detectCycle,
+  topologicalSort,
+} from "../../goal/goalGraph.js";
+import type { GoalStatus, Subgoal, SubgoalStatus } from "../../goal/goalStatus.js";
+import { PatchWardenError } from "../../errors.js";
+
+// ── Helpers ───────────────────────────────────────────────────────
+
+function makeSubgoal(overrides: Partial<Subgoal> & { id: string }): Subgoal {
+  return {
+    title: "Subgoal " + overrides.id,
+    status: "ready",
+    depends_on: [],
+    task_ids: [],
+    ...overrides,
+  };
+}
+
+function makeGoalStatus(subgoals: Subgoal[], overrides: Partial<GoalStatus> = {}): GoalStatus {
+  const now = new Date().toISOString();
+  return {
+    goal_id: "goal_test_001",
+    title: "Test Goal",
+    status: "active",
+    repo_path: "/repo/test",
+    created_at: now,
+    updated_at: now,
+    subgoals,
+    ...overrides,
+  };
+}
+
+// ── Tests ─────────────────────────────────────────────────────────
+
+describe("goalGraph", () => {
+
+  describe("getReadySubgoals", () => {
+
+    it("无 subgoal 返回空数组", () => {
+      const goal = makeGoalStatus([]);
+      assert.deepEqual(getReadySubgoals(goal), []);
+    });
+
+    it("ready 且无依赖 → 返回", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", depends_on: [] }),
+      ]);
+      const ready = getReadySubgoals(goal);
+      assert.equal(ready.length, 1);
+      assert.equal(ready[0].id, "subgoal-001");
+    });
+
+    it("ready 但依赖未 accepted → 不返回", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", status: "running" }),
+        makeSubgoal({ id: "subgoal-002", depends_on: ["subgoal-001"] }),
+      ]);
+      const ready = getReadySubgoals(goal);
+      assert.equal(ready.length, 0);
+    });
+
+    it("ready 且依赖已 accepted → 返回", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", status: "accepted", accepted_at: "2026-01-01T00:00:00.000Z" }),
+        makeSubgoal({ id: "subgoal-002", depends_on: ["subgoal-001"] }),
+      ]);
+      const ready = getReadySubgoals(goal);
+      assert.equal(ready.length, 1);
+      assert.equal(ready[0].id, "subgoal-002");
+    });
+
+    it("非 ready 状态（running 等）→ 不返回", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", status: "running" }),
+        makeSubgoal({ id: "subgoal-002", status: "done_by_agent" }),
+        makeSubgoal({ id: "subgoal-003", status: "accepted" }),
+      ]);
+      const ready = getReadySubgoals(goal);
+      assert.equal(ready.length, 0);
+    });
+
+    it("依赖引用不存在的 subgoal → 不返回", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", depends_on: ["subgoal-999"] }),
+      ]);
+      const ready = getReadySubgoals(goal);
+      assert.equal(ready.length, 0);
+    });
+
+    it("不修改传入的 goalStatus（不可变）", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", depends_on: [] }),
+      ]);
+      const snapshot = JSON.stringify(goal);
+      getReadySubgoals(goal);
+      assert.equal(JSON.stringify(goal), snapshot);
+    });
+  });
+
+  describe("getBlockedSubgoals", () => {
+
+    it("无 blocked 返回空数组", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", depends_on: [] }),
+        makeSubgoal({ id: "subgoal-002", status: "running" }),
+      ]);
+      assert.deepEqual(getBlockedSubgoals(goal), []);
+    });
+
+    it("ready 但依赖 running → 返回，blocked_by 包含该 id", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", status: "running" }),
+        makeSubgoal({ id: "subgoal-002", depends_on: ["subgoal-001"] }),
+      ]);
+      const blocked = getBlockedSubgoals(goal);
+      assert.equal(blocked.length, 1);
+      assert.equal(blocked[0].subgoal.id, "subgoal-002");
+      assert.deepEqual(blocked[0].blocked_by, ["subgoal-001"]);
+    });
+
+    it("依赖引用不存在 → blocked_by 包含该不存在的 id", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", depends_on: ["subgoal-999"] }),
+      ]);
+      const blocked = getBlockedSubgoals(goal);
+      assert.equal(blocked.length, 1);
+      assert.equal(blocked[0].subgoal.id, "subgoal-001");
+      assert.deepEqual(blocked[0].blocked_by, ["subgoal-999"]);
+    });
+
+    it("依赖部分 accepted 部分 running → blocked_by 只含未 accepted 的", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", status: "accepted", accepted_at: "2026-01-01T00:00:00.000Z" }),
+        makeSubgoal({ id: "subgoal-002", status: "running" }),
+        makeSubgoal({ id: "subgoal-003", depends_on: ["subgoal-001", "subgoal-002"] }),
+      ]);
+      const blocked = getBlockedSubgoals(goal);
+      assert.equal(blocked.length, 1);
+      assert.deepEqual(blocked[0].blocked_by, ["subgoal-002"]);
+    });
+
+    it("非 ready 状态的 subgoal 不计入 blocked", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", status: "running", depends_on: ["subgoal-999"] }),
+      ]);
+      const blocked = getBlockedSubgoals(goal);
+      assert.equal(blocked.length, 0);
+    });
+  });
+
+  describe("suggestNextSubgoal", () => {
+
+    it("有 ready → 返回第一个 ready", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", depends_on: [] }),
+      ]);
+      const suggestion = suggestNextSubgoal(goal);
+      assert.equal(suggestion.subgoal_id, "subgoal-001");
+      assert.equal(suggestion.title, "Subgoal subgoal-001");
+      assert.deepEqual(suggestion.depends_on, []);
+      assert.equal(suggestion.reason, undefined);
+    });
+
+    it("无 ready 有 blocked → 返回 null + blocked_by", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", status: "running" }),
+        makeSubgoal({ id: "subgoal-002", depends_on: ["subgoal-001"] }),
+      ]);
+      const suggestion = suggestNextSubgoal(goal);
+      assert.equal(suggestion.subgoal_id, null);
+      assert.equal(suggestion.reason, "dependencies_not_met");
+      assert.deepEqual(suggestion.blocked_by, ["subgoal-002"]);
+    });
+
+    it("无 ready 无 blocked → 返回 null + no_ready_subgoal", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", status: "accepted", accepted_at: "2026-01-01T00:00:00.000Z" }),
+        makeSubgoal({ id: "subgoal-002", status: "running" }),
+      ]);
+      const suggestion = suggestNextSubgoal(goal);
+      assert.equal(suggestion.subgoal_id, null);
+      assert.equal(suggestion.reason, "no_ready_subgoal");
+      assert.equal(suggestion.blocked_by, undefined);
+    });
+
+    it("多个 ready → 返回数组顺序第一个", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", depends_on: [] }),
+        makeSubgoal({ id: "subgoal-002", depends_on: [] }),
+        makeSubgoal({ id: "subgoal-003", depends_on: [] }),
+      ]);
+      const suggestion = suggestNextSubgoal(goal);
+      assert.equal(suggestion.subgoal_id, "subgoal-001");
+    });
+
+    it("空 subgoals → no_ready_subgoal", () => {
+      const goal = makeGoalStatus([]);
+      const suggestion = suggestNextSubgoal(goal);
+      assert.equal(suggestion.subgoal_id, null);
+      assert.equal(suggestion.reason, "no_ready_subgoal");
+    });
+  });
+
+  describe("detectCycle", () => {
+
+    it("无依赖无环", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", depends_on: [] }),
+        makeSubgoal({ id: "subgoal-002", depends_on: [] }),
+      ]);
+      assert.equal(detectCycle(goal), null);
+    });
+
+    it("线性依赖 A→B 无环（B depends_on A）", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "A", depends_on: [] }),
+        makeSubgoal({ id: "B", depends_on: ["A"] }),
+      ]);
+      assert.equal(detectCycle(goal), null);
+    });
+
+    it("A→B→A 有环，返回环路径", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "A", depends_on: ["B"] }),
+        makeSubgoal({ id: "B", depends_on: ["A"] }),
+      ]);
+      const cycle = detectCycle(goal);
+      assert.ok(cycle !== null);
+      assert.ok(cycle.length >= 2);
+      assert.ok(cycle.includes("A"));
+      assert.ok(cycle.includes("B"));
+    });
+
+    it("自环 A→A 有环", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "A", depends_on: ["A"] }),
+      ]);
+      const cycle = detectCycle(goal);
+      assert.ok(cycle !== null);
+      assert.ok(cycle.includes("A"));
+    });
+
+    it("引用不存在的 subgoal 不算环", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "A", depends_on: ["nonexistent"] }),
+      ]);
+      assert.equal(detectCycle(goal), null);
+    });
+
+    it("三节点环 A→B→C→A", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "A", depends_on: ["C"] }),
+        makeSubgoal({ id: "B", depends_on: ["A"] }),
+        makeSubgoal({ id: "C", depends_on: ["B"] }),
+      ]);
+      const cycle = detectCycle(goal);
+      assert.ok(cycle !== null);
+      assert.ok(cycle.includes("A"));
+      assert.ok(cycle.includes("B"));
+      assert.ok(cycle.includes("C"));
+    });
+
+    it("无环的复杂依赖图", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "A", depends_on: [] }),
+        makeSubgoal({ id: "B", depends_on: ["A"] }),
+        makeSubgoal({ id: "C", depends_on: ["A"] }),
+        makeSubgoal({ id: "D", depends_on: ["B", "C"] }),
+      ]);
+      assert.equal(detectCycle(goal), null);
+    });
+  });
+
+  describe("topologicalSort", () => {
+
+    it("线性 A→B（B 依赖 A）→ 返回 [A, B]", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "A", depends_on: [] }),
+        makeSubgoal({ id: "B", depends_on: ["A"] }),
+      ]);
+      const sorted = topologicalSort(goal);
+      assert.equal(sorted.length, 2);
+      const aIndex = sorted.indexOf("A");
+      const bIndex = sorted.indexOf("B");
+      assert.ok(aIndex < bIndex, "A should come before B");
+    });
+
+    it("有环抛错", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "A", depends_on: ["B"] }),
+        makeSubgoal({ id: "B", depends_on: ["A"] }),
+      ]);
+      assert.throws(
+        () => topologicalSort(goal),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError);
+          assert.equal(err.reason, "dependency_cycle");
+          return true;
+        }
+      );
+    });
+
+    it("单节点无依赖", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "A", depends_on: [] }),
+      ]);
+      assert.deepEqual(topologicalSort(goal), ["A"]);
+    });
+
+    it("菱形依赖：D 依赖 B、C，B/C 依赖 A → A 最前，D 最后", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "A", depends_on: [] }),
+        makeSubgoal({ id: "B", depends_on: ["A"] }),
+        makeSubgoal({ id: "C", depends_on: ["A"] }),
+        makeSubgoal({ id: "D", depends_on: ["B", "C"] }),
+      ]);
+      const sorted = topologicalSort(goal);
+      assert.equal(sorted.length, 4);
+      const aIndex = sorted.indexOf("A");
+      const bIndex = sorted.indexOf("B");
+      const cIndex = sorted.indexOf("C");
+      const dIndex = sorted.indexOf("D");
+      assert.ok(aIndex < bIndex, "A before B");
+      assert.ok(aIndex < cIndex, "A before C");
+      assert.ok(bIndex < dIndex, "B before D");
+      assert.ok(cIndex < dIndex, "C before D");
+    });
+
+    it("引用不存在的 subgoal 不影响排序", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "A", depends_on: ["nonexistent"] }),
+        makeSubgoal({ id: "B", depends_on: ["A"] }),
+      ]);
+      const sorted = topologicalSort(goal);
+      assert.equal(sorted.length, 2);
+      const aIndex = sorted.indexOf("A");
+      const bIndex = sorted.indexOf("B");
+      assert.ok(aIndex < bIndex, "A before B");
+    });
+  });
+});