patchwarden 1.5.0 → 1.5.1

package/dist/test/unit/goal-tools-registry.test.js

@@ -6,7 +6,7 @@ import { tmpdir } from "node:os";
 import { getToolDefs, handleToolCall } from "../../tools/registry.js";
 import { reloadConfig } from "../../config.js";
 import { PatchWardenError } from "../../errors.js";
-// ── 9 个 Goal Session MCP 工具名 ──────────────────────────────────
+// ── 11 个 Goal Session MCP 工具名 ─────────────────────────────────
 const GOAL_TOOL_NAMES = [
     "create_goal",
     "list_goals",
@@ -17,6 +17,8 @@ const GOAL_TOOL_NAMES = [
     "suggest_next_subgoal",
     "summarize_goal_progress",
     "export_handoff",
+    "export_goal_report",
+    "import_speckit_tasks",
 ];
 // ── 测试环境隔离：使用临时 workspaceRoot + full profile ───────────
 let tempDir;
@@ -56,21 +58,21 @@ afterEach(() => {
 // ── Tests ─────────────────────────────────────────────────────────
 describe("goal tools registry", () => {
     describe("getToolDefs — 工具定义", () => {
-        it("包含全部 9 个 goal 工具", () => {
+        it("包含全部 11 个 goal 工具", () => {
             const tools = getToolDefs();
             const names = new Set(tools.map((t) => t.name));
             for (const name of GOAL_TOOL_NAMES) {
                 assert.ok(names.has(name), `Missing tool definition: ${name}`);
             }
         });
-        it("每个 goal 工具描述以 v0.8.0 开头且 inputSchema.type 为 object", () => {
+        it("每个 goal 工具描述非空且 inputSchema.type 为 object", () => {
             const tools = getToolDefs();
             const byName = new Map(tools.map((t) => [t.name, t]));
             for (const name of GOAL_TOOL_NAMES) {
                 const tool = byName.get(name);
                 assert.ok(tool, `Tool not found: ${name}`);
                 assert.equal(tool.inputSchema.type, "object", `${name} schema type should be object`);
-                assert.ok(tool.description.startsWith("v0.8.0:"), `${name} description should start with v0.8.0:`);
+                assert.ok(typeof tool.description === "string" && tool.description.length > 0, `${name} description should be a non-empty string`);
             }
         });
         it("create_goal required 字段为 title/goal_description/repo_path", () => {

package/dist/test/unit/path-guard.test.js

@@ -69,6 +69,30 @@ describe("guardPath", () => {
             rmSync(target, { recursive: true, force: true });
         }
     });
+    it("rejects Windows junction escape", { skip: process.platform !== "win32" ? "Windows-only test" : undefined }, () => {
+        const target = mkdtempSync(join(tmpdir(), "pw-junction-target-"));
+        try {
+            const linkPath = join(tempDir, "escape-junction");
+            symlinkSync(target, linkPath, "junction");
+            assert.throws(() => guardPath("escape-junction/secret.txt", tempDir), PatchWardenError);
+        }
+        finally {
+            rmSync(target, { recursive: true, force: true });
+        }
+    });
+    it("rejects intermediate symlink escape (TOCTOU defense)", { skip: process.platform === "win32" ? "Windows symlink permissions unstable" : undefined }, () => {
+        const target = mkdtempSync(join(tmpdir(), "pw-toctou-target-"));
+        try {
+            const linkPath = join(tempDir, "escape-link");
+            symlinkSync(target, linkPath);
+            mkdirSync(join(target, "subdir"), { recursive: true });
+            writeFileSync(join(target, "subdir", "secret.txt"), "secret", "utf-8");
+            assert.throws(() => guardPath("escape-link/subdir/secret.txt", tempDir), PatchWardenError);
+        }
+        finally {
+            rmSync(target, { recursive: true, force: true });
+        }
+    });
 });
 describe("guardWorkspacePath", () => {
     let tempDir;

package/dist/test/unit/spec-kit-import.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/unit/spec-kit-import.test.js

@@ -0,0 +1,341 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import { strict as assert } from "node:assert";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { createGoal, readGoalStatus } from "../../goal/goalStore.js";
+import { importSpecKitTasks, parseSpecKitJson, } from "../../goal/specKitImport.js";
+import { PatchWardenError } from "../../errors.js";
+// ── Helpers ───────────────────────────────────────────────────────
+let tempDir;
+let goalId;
+beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "pw-speckit-"));
+    const result = createGoal("repo", "Spec Kit Test Goal", "desc", tempDir);
+    goalId = result.goal_id;
+});
+afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+});
+function makeStandardInput() {
+    return {
+        spec: "feature-auth",
+        tasks: [
+            {
+                id: "T1",
+                desc: "Set up database schema",
+                files: ["src/db/schema.ts"],
+            },
+            {
+                id: "T2",
+                desc: "Implement auth service",
+                files: ["src/auth/service.ts", "src/auth/types.ts"],
+            },
+            {
+                id: "T3",
+                desc: "Write integration tests",
+                files: ["test/auth.test.ts"],
+            },
+        ],
+    };
+}
+// ── Tests ─────────────────────────────────────────────────────────
+describe("specKitImport", () => {
+    describe("parseSpecKitJson", () => {
+        it("解析合法 JSON 返回 SpecKitInput", () => {
+            const json = JSON.stringify({
+                spec: "my-spec",
+                tasks: [
+                    { id: "T1", desc: "Task one", files: ["a.ts"] },
+                    { id: "T2", desc: "Task two", depends_on: ["T1"] },
+                ],
+                acceptance: ["T1 passes", "T2 passes"],
+            });
+            const input = parseSpecKitJson(json);
+            assert.equal(input.spec, "my-spec");
+            assert.equal(input.tasks.length, 2);
+            assert.equal(input.tasks[0].id, "T1");
+            assert.equal(input.tasks[0].desc, "Task one");
+            assert.deepEqual(input.tasks[0].files, ["a.ts"]);
+            assert.deepEqual(input.tasks[1].depends_on, ["T1"]);
+            assert.deepEqual(input.acceptance, ["T1 passes", "T2 passes"]);
+        });
+        it("缺 spec 字段抛出错误", () => {
+            const json = JSON.stringify({ tasks: [] });
+            assert.throws(() => parseSpecKitJson(json), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_spec_kit_input");
+                return true;
+            });
+        });
+        it("spec 为空字符串抛出错误", () => {
+            const json = JSON.stringify({ spec: "", tasks: [] });
+            assert.throws(() => parseSpecKitJson(json), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_spec_kit_input");
+                return true;
+            });
+        });
+        it("缺 tasks 字段抛出错误", () => {
+            const json = JSON.stringify({ spec: "my-spec" });
+            assert.throws(() => parseSpecKitJson(json), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_spec_kit_input");
+                return true;
+            });
+        });
+        it("tasks 不是数组抛出错误", () => {
+            const json = JSON.stringify({ spec: "my-spec", tasks: "not-an-array" });
+            assert.throws(() => parseSpecKitJson(json), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_spec_kit_input");
+                return true;
+            });
+        });
+        it("task 缺 id 抛出错误", () => {
+            const json = JSON.stringify({
+                spec: "my-spec",
+                tasks: [{ desc: "no id" }],
+            });
+            assert.throws(() => parseSpecKitJson(json), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_spec_kit_input");
+                return true;
+            });
+        });
+        it("无效 JSON 文本抛出错误", () => {
+            assert.throws(() => parseSpecKitJson("{ not valid json"), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_spec_kit_json");
+                return true;
+            });
+        });
+    });
+    describe("importSpecKitTasks — 标准导入", () => {
+        it("3 个无依赖 task → created_count=3, existing_count=0", () => {
+            const input = makeStandardInput();
+            const result = importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            assert.equal(result.created_count, 3);
+            assert.equal(result.existing_count, 0);
+            assert.equal(result.subgoal_ids.length, 3);
+            assert.equal(result.spec_name, "feature-auth");
+            assert.equal(result.goal_id, goalId);
+        });
+        it("每个 subgoal 的 title = task.desc", () => {
+            const input = makeStandardInput();
+            const result = importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 3);
+            assert.equal(status.subgoals[0].title, "Set up database schema");
+            assert.equal(status.subgoals[1].title, "Implement auth service");
+            assert.equal(status.subgoals[2].title, "Write integration tests");
+        });
+        it("每个 subgoal 的 external_ref = task.id", () => {
+            const input = makeStandardInput();
+            importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals[0].external_ref, "T1");
+            assert.equal(status.subgoals[1].external_ref, "T2");
+            assert.equal(status.subgoals[2].external_ref, "T3");
+        });
+        it("task.files 映射到 scope_hints", () => {
+            const input = makeStandardInput();
+            importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.deepEqual(status.subgoals[0].scope_hints, ["src/db/schema.ts"]);
+            assert.deepEqual(status.subgoals[1].scope_hints, [
+                "src/auth/service.ts",
+                "src/auth/types.ts",
+            ]);
+            assert.deepEqual(status.subgoals[2].scope_hints, ["test/auth.test.ts"]);
+        });
+        it("subgoal_ids 对应新创建的 subgoal id", () => {
+            const input = makeStandardInput();
+            const result = importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            assert.deepEqual(result.subgoal_ids, ["subgoal-001", "subgoal-002", "subgoal-003"]);
+        });
+    });
+    describe("importSpecKitTasks — 依赖关系导入", () => {
+        it("T2 depends_on T1 → T2 的 depends_on 含 T1 的 subgoal_id（非 external_ref）", () => {
+            const input = {
+                spec: "feature-deps",
+                tasks: [
+                    { id: "T1", desc: "Foundation task" },
+                    { id: "T2", desc: "Dependent task", depends_on: ["T1"] },
+                ],
+            };
+            const result = importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            assert.equal(result.created_count, 2);
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 2);
+            const t1Subgoal = status.subgoals[0];
+            const t2Subgoal = status.subgoals[1];
+            assert.equal(t1Subgoal.external_ref, "T1");
+            assert.equal(t2Subgoal.external_ref, "T2");
+            // T2 depends_on 应包含 T1 的 subgoal_id，而非 external_ref
+            assert.ok(t2Subgoal.depends_on.includes(t1Subgoal.id));
+            assert.ok(!t2Subgoal.depends_on.includes("T1"));
+        });
+        it("多级依赖 T3 → T2 → T1 全部正确解析", () => {
+            const input = {
+                spec: "multi-level",
+                tasks: [
+                    { id: "T1", desc: "Level 1" },
+                    { id: "T2", desc: "Level 2", depends_on: ["T1"] },
+                    { id: "T3", desc: "Level 3", depends_on: ["T2"] },
+                ],
+            };
+            importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 3);
+            assert.deepEqual(status.subgoals[0].depends_on, []);
+            assert.deepEqual(status.subgoals[1].depends_on, ["subgoal-001"]);
+            assert.deepEqual(status.subgoals[2].depends_on, ["subgoal-002"]);
+        });
+        it("依赖不存在的 task → 忽略该依赖并继续创建", () => {
+            const input = {
+                spec: "missing-dep",
+                tasks: [
+                    { id: "T1", desc: "Task with missing dep", depends_on: ["NONEXISTENT"] },
+                ],
+            };
+            const result = importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            assert.equal(result.created_count, 1);
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 1);
+            assert.deepEqual(status.subgoals[0].depends_on, []);
+        });
+    });
+    describe("importSpecKitTasks — 验收标准映射", () => {
+        it("input.acceptance 写入 GoalStatus.acceptance_criteria", () => {
+            const input = {
+                spec: "feature-acceptance",
+                tasks: [{ id: "T1", desc: "Task one" }],
+                acceptance: ["T1 passes", "T2 passes"],
+            };
+            importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.deepEqual(status.acceptance_criteria, ["T1 passes", "T2 passes"]);
+        });
+        it("无 acceptance → GoalStatus.acceptance_criteria 不存在", () => {
+            const input = {
+                spec: "no-acceptance",
+                tasks: [{ id: "T1", desc: "Task one" }],
+            };
+            importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.acceptance_criteria, undefined);
+        });
+        it("空 acceptance 数组 → GoalStatus.acceptance_criteria 不存在", () => {
+            const input = {
+                spec: "empty-acceptance",
+                tasks: [{ id: "T1", desc: "Task one" }],
+                acceptance: [],
+            };
+            importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.acceptance_criteria, undefined);
+        });
+    });
+    describe("importSpecKitTasks — 幂等去重", () => {
+        it("重复导入相同 JSON → 第二次 created_count=0, existing_count=3", () => {
+            const input = makeStandardInput();
+            // 第一次导入
+            const result1 = importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            assert.equal(result1.created_count, 3);
+            assert.equal(result1.existing_count, 0);
+            // 第二次导入相同 JSON
+            const result2 = importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            assert.equal(result2.created_count, 0);
+            assert.equal(result2.existing_count, 3);
+            assert.deepEqual(result2.subgoal_ids, []);
+        });
+        it("重复导入后 subgoal 总数仍为 3", () => {
+            const input = makeStandardInput();
+            importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 3);
+        });
+        it("部分新 task 导入：只创建新增的", () => {
+            // 第一次导入 T1, T2
+            const input1 = {
+                spec: "partial",
+                tasks: [
+                    { id: "T1", desc: "Task one" },
+                    { id: "T2", desc: "Task two" },
+                ],
+            };
+            const result1 = importSpecKitTasks(goalId, input1, { workspaceRoot: tempDir });
+            assert.equal(result1.created_count, 2);
+            // 第二次导入 T1, T2, T3（T1/T2 已存在）
+            const input2 = {
+                spec: "partial",
+                tasks: [
+                    { id: "T1", desc: "Task one" },
+                    { id: "T2", desc: "Task two" },
+                    { id: "T3", desc: "Task three" },
+                ],
+            };
+            const result2 = importSpecKitTasks(goalId, input2, { workspaceRoot: tempDir });
+            assert.equal(result2.created_count, 1);
+            assert.equal(result2.existing_count, 2);
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 3);
+        });
+    });
+    describe("importSpecKitTasks — 无效输入", () => {
+        it("spec 为空 → 抛出错误且不创建 subgoal", () => {
+            const input = { spec: "", tasks: [] };
+            assert.throws(() => importSpecKitTasks(goalId, input, { workspaceRoot: tempDir }), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_spec_kit_input");
+                return true;
+            });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 0);
+        });
+        it("tasks 不是数组 → 抛出错误且不创建 subgoal", () => {
+            const input = { spec: "test", tasks: "not-array" };
+            assert.throws(() => importSpecKitTasks(goalId, input, { workspaceRoot: tempDir }), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_spec_kit_input");
+                return true;
+            });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 0);
+        });
+        it("tasks 缺失 → 抛出错误且不创建 subgoal", () => {
+            const input = { spec: "test" };
+            assert.throws(() => importSpecKitTasks(goalId, input, { workspaceRoot: tempDir }), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_spec_kit_input");
+                return true;
+            });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 0);
+        });
+    });
+    describe("importSpecKitTasks — JSON 文本端到端", () => {
+        it("parseSpecKitJson + importSpecKitTasks 完整流程", () => {
+            const json = JSON.stringify({
+                spec: "e2e-spec",
+                tasks: [
+                    { id: "T1", desc: "First task", files: ["a.ts"] },
+                    { id: "T2", desc: "Second task", depends_on: ["T1"] },
+                ],
+                acceptance: ["All tests pass"],
+            });
+            const input = parseSpecKitJson(json);
+            const result = importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            assert.equal(result.created_count, 2);
+            assert.equal(result.spec_name, "e2e-spec");
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 2);
+            assert.equal(status.subgoals[0].external_ref, "T1");
+            assert.equal(status.subgoals[1].external_ref, "T2");
+            assert.deepEqual(status.subgoals[1].depends_on, ["subgoal-001"]);
+            assert.deepEqual(status.acceptance_criteria, ["All tests pass"]);
+        });
+    });
+});

package/dist/test/unit/wait-for-task.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/unit/wait-for-task.test.js

@@ -0,0 +1,144 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import { strict as assert } from "node:assert";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { reloadConfig } from "../../config.js";
+import { waitForTask } from "../../tools/waitForTask.js";
+let tempDir;
+let tasksDir;
+let prevConfigEnv;
+function writeConfig() {
+    const configPath = join(tempDir, "patchwarden.config.json");
+    writeFileSync(configPath, JSON.stringify({
+        workspaceRoot: tempDir,
+        tasksDir: ".patchwarden/tasks",
+        plansDir: ".patchwarden/plans",
+        assessmentsDir: ".patchwarden/assessments",
+        directSessionsDir: ".patchwarden/direct-sessions",
+        agents: { codex: { command: "codex", args: ["exec", "{prompt}"] } },
+        allowedTestCommands: ["npm test"],
+    }), "utf-8");
+    prevConfigEnv = process.env.PATCHWARDEN_CONFIG;
+    process.env.PATCHWARDEN_CONFIG = configPath;
+    reloadConfig();
+}
+function writeTaskStatus(taskId, status) {
+    const taskDir = join(tasksDir, taskId);
+    mkdirSync(taskDir, { recursive: true });
+    writeFileSync(join(taskDir, "status.json"), JSON.stringify(status, null, 2), "utf-8");
+    return taskDir;
+}
+function baseStatus(taskId, overrides = {}) {
+    return {
+        task_id: taskId,
+        plan_id: "plan-001",
+        agent: "codex",
+        workspace_root: tempDir,
+        repo_path: "repo",
+        resolved_repo_path: join(tempDir, "repo"),
+        created_at: "2026-07-12T10:00:00Z",
+        started_at: "2026-07-12T10:00:05Z",
+        finished_at: "2026-07-12T10:05:00Z",
+        updated_at: "2026-07-12T10:05:00Z",
+        timeout_seconds: 900,
+        error: null,
+        ...overrides,
+    };
+}
+describe("waitForTask", () => {
+    beforeEach(() => {
+        tempDir = mkdtempSync(join(tmpdir(), "pw-waitfortask-"));
+        tasksDir = join(tempDir, ".patchwarden", "tasks");
+        mkdirSync(tasksDir, { recursive: true });
+        writeConfig();
+    });
+    afterEach(() => {
+        if (prevConfigEnv === undefined)
+            delete process.env.PATCHWARDEN_CONFIG;
+        else
+            process.env.PATCHWARDEN_CONFIG = prevConfigEnv;
+        reloadConfig();
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    // ── already terminal: done ──
+    it("returns immediately when task is already done", async () => {
+        writeTaskStatus("task-done-001", baseStatus("task-done-001", {
+            status: "done",
+            phase: "completed",
+            verify_status: "passed",
+        }));
+        const result = await waitForTask("task-done-001", 5);
+        assert.equal(result.task_id, "task-done-001");
+        assert.equal(result.status, "done");
+        assert.equal(result.terminal, true);
+        assert.equal(result.timed_out, false);
+        assert.equal(result.continuation_required, false);
+        // terminal → includes compact summary, next tool is audit_task
+        assert.ok(result.summary);
+        assert.equal(result.next_tool_call.name, "audit_task");
+        assert.equal(result.progress_summary, undefined);
+    });
+    // ── already terminal: failed ──
+    it("returns immediately when task is already failed", async () => {
+        writeTaskStatus("task-failed-001", baseStatus("task-failed-001", {
+            status: "failed",
+            phase: "failed",
+            error: "Agent exited with code 1",
+        }));
+        const result = await waitForTask("task-failed-001", 5);
+        assert.equal(result.terminal, true);
+        assert.equal(result.status, "failed");
+        assert.equal(result.timed_out, false);
+        assert.equal(result.continuation_required, false);
+        assert.ok(result.summary);
+        assert.equal(result.next_tool_call.name, "audit_task");
+    });
+    // ── running + timeout → continuation_required ──
+    it("returns continuation_required when running task times out", async () => {
+        writeTaskStatus("task-running-001", baseStatus("task-running-001", {
+            status: "running",
+            phase: "executing_agent",
+            finished_at: undefined,
+        }));
+        const result = await waitForTask("task-running-001", 1);
+        assert.equal(result.task_id, "task-running-001");
+        assert.equal(result.status, "running");
+        assert.equal(result.terminal, false);
+        assert.equal(result.timed_out, true);
+        assert.equal(result.continuation_required, true);
+        // non-terminal → includes progress_summary, next tool is wait_for_task
+        assert.ok(result.progress_summary);
+        assert.equal(result.next_tool_call.name, "wait_for_task");
+        assert.equal(result.summary, undefined);
+        // waited approximately 1 second
+        assert.ok(result.waited_ms >= 900 && result.waited_ms <= 3000);
+    });
+    // ── canceled (terminal) ──
+    it("returns terminal result for canceled task", async () => {
+        writeTaskStatus("task-canceled-001", baseStatus("task-canceled-001", {
+            status: "canceled",
+            phase: "canceled",
+        }));
+        const result = await waitForTask("task-canceled-001", 5);
+        assert.equal(result.terminal, true);
+        assert.equal(result.status, "canceled");
+        assert.equal(result.timed_out, false);
+        assert.equal(result.continuation_required, false);
+        assert.ok(result.summary);
+        assert.equal(result.next_tool_call.name, "audit_task");
+    });
+    // ── task not found ──
+    it("throws when task does not exist", async () => {
+        await assert.rejects(() => waitForTask("non-existent-task", 1), /(File not found|Task not found)/);
+    });
+    // ── invalid wait_seconds ──
+    it("throws when wait_seconds is out of range", async () => {
+        writeTaskStatus("task-validate-001", baseStatus("task-validate-001", {
+            status: "done",
+            phase: "completed",
+        }));
+        await assert.rejects(() => waitForTask("task-validate-001", 0), /wait_seconds must be an integer from 1 to 30/);
+        await assert.rejects(() => waitForTask("task-validate-001", 31), /wait_seconds must be an integer from 1 to 30/);
+    });
+});

package/dist/tools/auditTask.d.ts

@@ -32,97 +32,42 @@ export interface AuditTaskOutput {
     manual_verification_items: string[];
     recommended_next_actions: string[];
 }
+import type { ChangedFile } from "../runner/changeCapture.js";
 /**
  * Check 1: forbidden_scope_violation (fail level).
  * Returns null when no forbidden patterns are configured (skip).
  * Returns pass when changed files do not match any forbidden pattern.
  * Returns fail when any changed file path (or old_path) matches a forbidden glob.
  */
-export declare function checkForbiddenScope(changedFiles: any, forbidden: any): {
-    name: string;
-    result: string;
-    detail: string;
-} | null;
+export declare function checkForbiddenScope(changedFiles: ChangedFile[], forbidden: string[] | null): AuditCheck | null;
 /**
  * Check 2: done_evidence_missing (warn level).
  * Returns null when no done_evidence list is configured (skip).
  * Returns pass when all listed files exist in the task directory.
  * Returns warn when any listed file is missing.
  */
-export declare function checkDoneEvidenceMissing(taskDir: any, doneEvidence: any): {
-    name: string;
-    result: string;
-    detail: string;
-} | null;
+export declare function checkDoneEvidenceMissing(taskDir: string, doneEvidence: string[] | null): AuditCheck | null;
 /**
  * Check 3: readme_changelog_sync (warn level).
  * Returns null when no code files (by extension) were changed (skip).
  * Returns pass when README.md or CHANGELOG.md (basename, case-insensitive) is also changed.
  * Returns warn when code changed but neither documentation file was updated.
  */
-export declare function checkReadmeChangelogSync(changedFiles: any): {
-    name: string;
-    result: string;
-    detail: string;
-} | null;
+export declare function checkReadmeChangelogSync(changedFiles: ChangedFile[]): AuditCheck | null;
 /**
  * Check 4: package_manifest_consistency (warn level).
  * Returns null when package.json is not among changed files (skip).
  * Returns pass when package.json parses as JSON and has non-empty name and version strings.
  * Returns warn otherwise.
  */
-export declare function checkPackageManifestConsistency(changedFiles: any, repoPathSafe: any): {
-    name: string;
-    result: string;
-    detail: string;
-} | null;
+export declare function checkPackageManifestConsistency(changedFiles: ChangedFile[], repoPathSafe: string): AuditCheck | null;
 /**
  * Check 5: sensitive_path_access (fail level).
  * Returns null when there are no changed files (skip).
  * Returns pass when no changed file path (or old_path) is sensitive.
  * Returns fail when any changed file path is flagged by isSensitivePath.
  */
-export declare function checkSensitivePathAccess(changedFiles: any): {
-    name: string;
-    result: string;
-    detail: string;
-} | null;
-export declare function checkUnrecordedCommandExecution(testLogContent: string | null, resultMdContent: string | null, verifyCommands: string[], testCommand: string | null, repoPath?: string | null): {
-    name: string;
-    result: string;
-    detail: string;
-} | null;
-export declare function auditTask(taskId: any): {
-    task_id: any;
-    verdict: string;
-    acceptance: {
-        verdict: import("../goal/acceptanceEngine.js").AcceptanceVerdict;
-        status: string;
-        reason: string;
-        reasons: string[];
-        required_evidence: string[];
-        next_suggested_task: string;
-        fail_checks: import("../goal/acceptanceEngine.js").AcceptanceCheck[];
-        warn_checks: import("../goal/acceptanceEngine.js").AcceptanceCheck[];
-    };
-    summary: string;
-    checks: {
-        name: string;
-        result: string;
-        detail: string;
-    }[];
-    risks: {
-        severity: string;
-        description: string;
-    }[];
-    confirmed_failures: {
-        name: string;
-        result: string;
-        detail: string;
-    }[];
-    possible_false_positives: any[];
-    manual_verification_required: boolean;
-    manual_verification_items: any[];
-    recommended_next_actions: string[];
-};
+export declare function checkSensitivePathAccess(changedFiles: ChangedFile[]): AuditCheck | null;
+export declare function checkUnrecordedCommandExecution(testLogContent: string | null, resultMdContent: string | null, verifyCommands: string[], testCommand: string | null, repoPath?: string | null): AuditCheck | null;
+export declare function auditTask(taskId: string): AuditTaskOutput;
 export {};