patchwarden 1.5.1 → 1.6.2

package/src/test/unit/wait-for-task.test.ts

@@ -1,176 +0,0 @@
-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: string;
-let tasksDir: string;
-let prevConfigEnv: string | undefined;
-
-function writeConfig(): void {
-  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: string, status: Record<string, unknown>): string {
-  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: string, overrides: Record<string, unknown> = {}): Record<string, unknown> {
-  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/src/test/unit/watcher-status.test.ts

@@ -1,190 +0,0 @@
-import { describe, it, beforeEach, afterEach } from "node:test";
-import { strict as assert } from "node:assert";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync, existsSync, mkdir } from "node:fs";
-import { join, dirname } from "node:path";
-import { tmpdir } from "node:os";
-import type { PatchWardenConfig } from "../../config.js";
-import { readWatcherStatus, getWatcherHeartbeatPath } from "../../watcherStatus.js";
-
-function makeConfig(workspaceRoot: string): PatchWardenConfig {
-  return {
-    workspaceRoot,
-    plansDir: ".patchwarden/plans",
-    tasksDir: ".patchwarden/tasks",
-    assessmentsDir: ".patchwarden/assessments",
-    assessmentTtlSeconds: 3600,
-    agents: { codex: { command: "codex", args: ["exec", "{prompt}"] } },
-    allowedTestCommands: ["npm test"],
-    repoAllowedTestCommands: {},
-    maxReadFileBytes: 200_000,
-    defaultTaskTimeoutSeconds: 900,
-    maxTaskTimeoutSeconds: 3600,
-    watcherStaleSeconds: 30,
-    directSessionsDir: ".patchwarden/direct-sessions",
-    directSessionTtlSeconds: 3600,
-    directMaxPatchBytes: 200_000,
-    directMaxFileBytes: 500_000,
-  };
-}
-
-describe("readWatcherStatus — watcher stale fallback", () => {
-  let tempDir: string;
-  let config: PatchWardenConfig;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), "pw-watcher-test-"));
-    config = makeConfig(tempDir);
-    mkdirSync(join(tempDir, ".patchwarden", "tasks"), { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  it("returns missing when no heartbeat and no running task", () => {
-    const result = readWatcherStatus(config, Date.now());
-    assert.equal(result.status, "missing");
-    assert.equal(result.available, false);
-    assert.equal(result.activity, null);
-  });
-
-  it("returns healthy when watcher heartbeat is fresh", () => {
-    const heartbeatPath = getWatcherHeartbeatPath(config);
-    mkdirSync(dirname(heartbeatPath), { recursive: true });
-    writeFileSync(heartbeatPath, JSON.stringify({
-      status: "running",
-      pid: process.pid,
-      last_heartbeat_at: new Date().toISOString(),
-    }), "utf-8");
-
-    const result = readWatcherStatus(config, Date.now());
-    assert.equal(result.status, "healthy");
-    assert.equal(result.available, true);
-    assert.equal(result.activity, null);
-  });
-
-  it("returns stale when watcher heartbeat is old and no running task", () => {
-    const heartbeatPath = getWatcherHeartbeatPath(config);
-    mkdirSync(dirname(heartbeatPath), { recursive: true });
-    const oldTime = new Date(Date.now() - 120_000).toISOString();
-    writeFileSync(heartbeatPath, JSON.stringify({
-      status: "running",
-      pid: process.pid,
-      last_heartbeat_at: oldTime,
-    }), "utf-8");
-
-    const result = readWatcherStatus(config, Date.now());
-    assert.equal(result.status, "stale");
-    assert.equal(result.available, false);
-    assert.equal(result.activity, null);
-  });
-
-  it("returns healthy when watcher heartbeat is stale but a running task has fresh heartbeat", () => {
-    // Write stale watcher heartbeat
-    const heartbeatPath = getWatcherHeartbeatPath(config);
-    mkdirSync(dirname(heartbeatPath), { recursive: true });
-    const oldTime = new Date(Date.now() - 120_000).toISOString();
-    writeFileSync(heartbeatPath, JSON.stringify({
-      status: "running",
-      pid: process.pid,
-      last_heartbeat_at: oldTime,
-    }), "utf-8");
-
-    // Create a running task with fresh heartbeat
-    const taskDir = join(tempDir, ".patchwarden", "tasks", "test-task-001");
-    mkdirSync(taskDir, { recursive: true });
-    writeFileSync(join(taskDir, "status.json"), JSON.stringify({
-      status: "running",
-      task_id: "test-task-001",
-    }), "utf-8");
-    writeFileSync(join(taskDir, "runtime.json"), JSON.stringify({
-      phase: "executing_agent",
-      last_heartbeat_at: new Date().toISOString(),
-      current_command: "codex exec",
-    }), "utf-8");
-
-    const result = readWatcherStatus(config, Date.now());
-    assert.equal(result.status, "healthy");
-    assert.equal(result.available, true);
-    assert.ok(result.activity);
-    assert.match(result.activity!, /test-task-001/);
-  });
-
-  it("returns healthy when watcher heartbeat is missing but a running task has fresh heartbeat", () => {
-    // No watcher heartbeat file at all
-    // Create a running task with fresh heartbeat
-    const taskDir = join(tempDir, ".patchwarden", "tasks", "test-task-002");
-    mkdirSync(taskDir, { recursive: true });
-    writeFileSync(join(taskDir, "status.json"), JSON.stringify({
-      status: "running",
-      task_id: "test-task-002",
-    }), "utf-8");
-    writeFileSync(join(taskDir, "runtime.json"), JSON.stringify({
-      phase: "running_tests",
-      last_heartbeat_at: new Date().toISOString(),
-      current_command: "npm test",
-    }), "utf-8");
-
-    const result = readWatcherStatus(config, Date.now());
-    assert.equal(result.status, "healthy");
-    assert.equal(result.available, true);
-    assert.ok(result.activity);
-    assert.match(result.activity!, /test-task-002/);
-  });
-
-  it("returns stale when both watcher heartbeat and task heartbeat are old", () => {
-    const heartbeatPath = getWatcherHeartbeatPath(config);
-    mkdirSync(dirname(heartbeatPath), { recursive: true });
-    const oldTime = new Date(Date.now() - 120_000).toISOString();
-    writeFileSync(heartbeatPath, JSON.stringify({
-      status: "running",
-      pid: process.pid,
-      last_heartbeat_at: oldTime,
-    }), "utf-8");
-
-    const taskDir = join(tempDir, ".patchwarden", "tasks", "test-task-003");
-    mkdirSync(taskDir, { recursive: true });
-    writeFileSync(join(taskDir, "status.json"), JSON.stringify({
-      status: "running",
-      task_id: "test-task-003",
-    }), "utf-8");
-    writeFileSync(join(taskDir, "runtime.json"), JSON.stringify({
-      phase: "executing_agent",
-      last_heartbeat_at: oldTime,
-      current_command: "codex exec",
-    }), "utf-8");
-
-    const result = readWatcherStatus(config, Date.now());
-    assert.equal(result.status, "stale");
-    assert.equal(result.available, false);
-    assert.equal(result.activity, null);
-  });
-
-  it("does not fall back to non-running tasks", () => {
-    const heartbeatPath = getWatcherHeartbeatPath(config);
-    mkdirSync(dirname(heartbeatPath), { recursive: true });
-    const oldTime = new Date(Date.now() - 120_000).toISOString();
-    writeFileSync(heartbeatPath, JSON.stringify({
-      status: "running",
-      pid: process.pid,
-      last_heartbeat_at: oldTime,
-    }), "utf-8");
-
-    // Done task with fresh heartbeat should not trigger fallback
-    const taskDir = join(tempDir, ".patchwarden", "tasks", "test-task-004");
-    mkdirSync(taskDir, { recursive: true });
-    writeFileSync(join(taskDir, "status.json"), JSON.stringify({
-      status: "done",
-      task_id: "test-task-004",
-    }), "utf-8");
-    writeFileSync(join(taskDir, "runtime.json"), JSON.stringify({
-      phase: "completed",
-      last_heartbeat_at: new Date().toISOString(),
-      current_command: null,
-    }), "utf-8");
-
-    const result = readWatcherStatus(config, Date.now());
-    assert.equal(result.status, "stale");
-    assert.equal(result.available, false);
-  });
-});

package/src/test/unit/worktree-manager.test.ts

@@ -1,247 +0,0 @@
-import { describe, it, before, after } from "node:test";
-import { strict as assert } from "node:assert";
-import {
-  mkdtempSync,
-  rmSync,
-  writeFileSync,
-  readFileSync,
-  existsSync,
-  readdirSync,
-  unlinkSync,
-} from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { execSync } from "node:child_process";
-import {
-  createWorktree,
-  mergeWorktree,
-  discardWorktree,
-  readWorktreeStatus,
-  getWorktreesDir,
-  type WorktreeStatus,
-} from "../../goal/worktreeManager.js";
-import { PatchWardenError } from "../../errors.js";
-
-// ── Test fixtures ─────────────────────────────────────────────────
-
-/**
- * 在 dir 创建一个真实的 git 仓库：git init + 配置 user + 初始 commit。
- * createWorktree 要求 workspaceRoot 是一个至少有一个 commit 的 git 仓库。
- */
-function initGitRepo(dir: string): void {
-  execSync("git init", { cwd: dir, stdio: "ignore" });
-  execSync('git config user.email "test@patchwarden.local"', { cwd: dir, stdio: "ignore" });
-  execSync('git config user.name "PatchWarden Test"', { cwd: dir, stdio: "ignore" });
-  execSync('git config commit.gpgsign false', { cwd: dir, stdio: "ignore" });
-  writeFileSync(join(dir, "README.md"), "init\n", "utf-8");
-  execSync("git add README.md", { cwd: dir, stdio: "ignore" });
-  execSync("git commit -m init", { cwd: dir, stdio: "ignore" });
-}
-
-function gitBranchList(cwd: string): string {
-  return execSync("git branch --list", { cwd, stdio: ["pipe", "pipe", "ignore"] }).toString("utf-8");
-}
-
-function assertPatchWardenError(fn: () => void, reason: string): void {
-  try {
-    fn();
-    assert.fail(`expected PatchWardenError("${reason}") to be thrown`);
-  } catch (err) {
-    assert.ok(err instanceof PatchWardenError, `expected PatchWardenError, got: ${err}`);
-    assert.equal((err as PatchWardenError).reason, reason);
-  }
-}
-
-// ── Tests ─────────────────────────────────────────────────────────
-
-describe("worktreeManager", () => {
-  let workspaceRoot: string;
-
-  before(() => {
-    workspaceRoot = mkdtempSync(join(tmpdir(), "pw-wt-"));
-    initGitRepo(workspaceRoot);
-  });
-
-  after(() => {
-    rmSync(workspaceRoot, { recursive: true, force: true });
-  });
-
-  // ── 1. createWorktree 成功 ──
-  it("createWorktree creates an active worktree with valid status.json", () => {
-    const result = createWorktree("goal_20260101_demo", "subgoal-001", workspaceRoot);
-
-    assert.ok(result.worktreeId.startsWith("wt_"), `worktreeId should start with "wt_", got: ${result.worktreeId}`);
-    assert.ok(result.branch.startsWith("pw-goal_20260101_demo-subgoal-001"), `branch should be pw-<goal>-<subgoal>, got: ${result.branch}`);
-    assert.ok(existsSync(result.worktreePath), "worktreePath should exist");
-
-    const statusFile = join(result.worktreePath, "worktree_status.json");
-    assert.ok(existsSync(statusFile), "worktree_status.json should exist");
-
-    // 原子写：不应残留 .tmp 文件
-    assert.ok(!existsSync(statusFile + ".tmp"), "status.json.tmp should not remain after atomic write");
-
-    // JSON 合法且字段正确
-    const status = JSON.parse(readFileSync(statusFile, "utf-8")) as WorktreeStatus;
-    assert.equal(status.worktree_id, result.worktreeId);
-    assert.equal(status.goal_id, "goal_20260101_demo");
-    assert.equal(status.subgoal_id, "subgoal-001");
-    assert.equal(status.status, "active");
-    assert.equal(status.branch, result.branch);
-    assert.equal(status.path, result.worktreePath);
-    assert.ok(typeof status.created_at === "string" && status.created_at.length > 0);
-
-    // worktree 内应检出主仓库的文件（README.md）
-    assert.ok(existsSync(join(result.worktreePath, "README.md")), "worktree should check out README.md");
-
-    // branch 应在 git 中存在
-    assert.ok(gitBranchList(workspaceRoot).includes(result.branch), "branch should exist in git");
-
-    // readWorktreeStatus 应返回一致的状态
-    const readBack = readWorktreeStatus(result.worktreeId, workspaceRoot);
-    assert.ok(readBack !== null);
-    assert.equal(readBack.status, "active");
-  });
-
-  // ── 2. createWorktree git 命令失败清理 ──
-  it("createWorktree cleans up and throws when git fails (non-git workspaceRoot)", () => {
-    const nonGitDir = mkdtempSync(join(tmpdir(), "pw-wt-nogit-"));
-    try {
-      // 非 git 目录 → git worktree add 失败
-      assertPatchWardenError(
-        () => createWorktree("goal_x", "subgoal-001", nonGitDir),
-        "worktree_create_failed"
-      );
-
-      // 不应残留任何 worktree 目录
-      const worktreesDir = getWorktreesDir(nonGitDir);
-      if (existsSync(worktreesDir)) {
-        // 若 _workspacetrees 被创建，应为空（无半成品 worktree）
-        const entries = readdirSync(worktreesDir);
-        assert.equal(entries.length, 0, "no leftover worktree directories should remain after failure");
-      }
-    } finally {
-      rmSync(nonGitDir, { recursive: true, force: true });
-    }
-  });
-
-  // ── 3. mergeWorktree 成功 ──
-  it("mergeWorktree merges the branch back and marks status merged", () => {
-    const created = createWorktree("goal_merge", "subgoal-001", workspaceRoot);
-
-    // 在 worktree 中产生一个新 commit，使 merge 有实际内容
-    writeFileSync(join(created.worktreePath, "feature.txt"), "merged feature\n", "utf-8");
-    execSync("git add feature.txt", { cwd: created.worktreePath, stdio: "ignore" });
-    execSync("git commit -m feature", { cwd: created.worktreePath, stdio: "ignore" });
-
-    const result = mergeWorktree(created.worktreeId, workspaceRoot);
-    assert.equal(result.status, "merged");
-
-    // 主工作区应出现 feature.txt（fast-forward 合并）
-    assert.ok(existsSync(join(workspaceRoot, "feature.txt")), "feature.txt should appear in main workspace after merge");
-
-    // status 应更新为 merged，merged_at 非空
-    const status = readWorktreeStatus(created.worktreeId, workspaceRoot);
-    assert.ok(status !== null);
-    assert.equal(status.status, "merged");
-    assert.ok(typeof status.merged_at === "string" && status.merged_at.length > 0, "merged_at should be set");
-  });
-
-  // ── 4. discardWorktree 成功 ──
-  it("discardWorktree removes worktree, deletes branch, and archives status", () => {
-    const created = createWorktree("goal_discard", "subgoal-001", workspaceRoot);
-    const branch = created.branch;
-    const worktreePath = created.worktreePath;
-
-    const result = discardWorktree(created.worktreeId, workspaceRoot);
-    assert.equal(result.status, "discarded");
-
-    // worktree 目录应被移除
-    assert.ok(!existsSync(worktreePath), "worktree directory should be removed after discard");
-
-    // 临时 branch 应被删除
-    assert.ok(!gitBranchList(workspaceRoot).includes(branch), "temporary branch should be deleted after discard");
-
-    // 归档文件应存在且 status="discarded"
-    const archiveFile = join(workspaceRoot, ".patchwarden", "worktree-archive", `${created.worktreeId}.json`);
-    assert.ok(existsSync(archiveFile), "archived status file should exist");
-    const archived = JSON.parse(readFileSync(archiveFile, "utf-8")) as WorktreeStatus;
-    assert.equal(archived.status, "discarded");
-    assert.ok(typeof archived.discarded_at === "string" && archived.discarded_at.length > 0, "discarded_at should be set");
-    assert.equal(archived.worktree_id, created.worktreeId);
-  });
-
-  // ── 5. 路径逃逸拦截 ──
-  it("blocks path escape via worktreeId containing ..", () => {
-    // worktreeId 在 read/merge/discard 中由调用方提供，构造逃逸路径
-    assertPatchWardenError(
-      () => readWorktreeStatus("../../../outside", workspaceRoot),
-      "workspace_path_escape"
-    );
-    assertPatchWardenError(
-      () => mergeWorktree("../../../outside", workspaceRoot),
-      "workspace_path_escape"
-    );
-    assertPatchWardenError(
-      () => discardWorktree("../../../outside", workspaceRoot),
-      "workspace_path_escape"
-    );
-  });
-
-  // ── 6. 敏感路径拦截 ──
-  it("blocks sensitive worktreeId via guardSensitivePath", () => {
-    // "credentials" 命中 sensitiveGuard 的敏感模式
-    assertPatchWardenError(
-      () => readWorktreeStatus("credentials", workspaceRoot),
-      "sensitive_path_blocked"
-    );
-    assertPatchWardenError(
-      () => mergeWorktree("credentials", workspaceRoot),
-      "sensitive_path_blocked"
-    );
-    assertPatchWardenError(
-      () => discardWorktree("credentials", workspaceRoot),
-      "sensitive_path_blocked"
-    );
-  });
-
-  // ── 7. readWorktreeStatus 返回 null 当 status 不存在 ──
-  it("readWorktreeStatus returns null when status file does not exist", () => {
-    // 创建一个 worktree 目录但不含 status 文件
-    const created = createWorktree("goal_missing", "subgoal-001", workspaceRoot);
-    // 手动删除 status 文件模拟缺失
-    unlinkSync(join(created.worktreePath, "worktree_status.json"));
-    assert.equal(readWorktreeStatus(created.worktreeId, workspaceRoot), null);
-    // 清理：删除该 worktree（避免污染后续测试）
-    try {
-      execSync(`git worktree remove --force "${created.worktreePath}"`, { cwd: workspaceRoot, stdio: "ignore" });
-    } catch { /* ignore */ }
-    try {
-      execSync(`git branch -D ${created.branch}`, { cwd: workspaceRoot, stdio: "ignore" });
-    } catch { /* ignore */ }
-  });
-
-  // ── 8. 非法状态转换：merge/discard 已 merged 的 worktree 抛错 ──
-  it("rejects merge/discard on non-active worktree", () => {
-    // 复用 #3 已 merged 的 worktree（goal_merge/subgoal-001）
-    // 先找到它的 worktreeId：扫描 _workspacetrees 目录
-    const worktreesDir = getWorktreesDir(workspaceRoot);
-    let mergedId: string | null = null;
-    for (const entry of readdirSync(worktreesDir)) {
-      const s = readWorktreeStatus(entry, workspaceRoot);
-      if (s && s.status === "merged" && s.goal_id === "goal_merge") {
-        mergedId = entry;
-        break;
-      }
-    }
-    assert.ok(mergedId !== null, "should find the merged worktree from the merge test");
-
-    assertPatchWardenError(
-      () => mergeWorktree(mergedId as string, workspaceRoot),
-      "invalid_worktree_state"
-    );
-    assertPatchWardenError(
-      () => discardWorktree(mergedId as string, workspaceRoot),
-      "invalid_worktree_state"
-    );
-  });
-});

package/src/tools/cancelTask.ts

@@ -1,70 +0,0 @@
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { getTasksDir, getConfig } from "../config.js";
-import { guardReadPath } from "../security/pathGuard.js";
-import { writeTaskProgress } from "../taskProgress.js";
-import type { TaskStatus } from "./createTask.js";
-
-export function cancelTask(taskId: string) {
-  return requestTaskTermination(taskId, false);
-}
-
-export function requestTaskTermination(taskId: string, force: boolean) {
-  const config = getConfig();
-  const taskDir = join(getTasksDir(config), taskId);
-  const statusFile = join(taskDir, "status.json");
-  guardReadPath(statusFile, config.workspaceRoot, config.tasksDir);
-
-  if (!existsSync(statusFile)) throw new Error(`Task not found: "${taskId}"`);
-
-  const data = JSON.parse(readFileSync(statusFile, "utf-8"));
-  const currentStatus: TaskStatus = data.status;
-  if (["done", "done_by_agent", "failed", "failed_verification", "failed_scope_violation", "failed_policy_violation", "canceled"].includes(currentStatus)) {
-    return {
-      task_id: taskId,
-      previous_status: currentStatus,
-      new_status: currentStatus,
-      message: `Task is already ${currentStatus}. No action taken.`,
-    };
-  }
-
-  const now = new Date().toISOString();
-  if (currentStatus === "pending") {
-    data.status = "canceled";
-    data.phase = "canceled";
-    data.canceled_at = now;
-    data.cancel_reason = force ? "Killed before execution by user request." : "Canceled by user request.";
-    data.updated_at = now;
-    writeFileSync(statusFile, JSON.stringify(data, null, 2), "utf-8");
-    writeTaskProgress(taskDir, "canceled", { note: data.cancel_reason, heartbeatAt: now });
-    return {
-      task_id: taskId,
-      previous_status: "pending",
-      new_status: "canceled",
-      message: "Pending task canceled. It will not be executed by watcher.",
-    };
-  }
-
-  data.cancel_requested = true;
-  data.cancel_requested_at = now;
-  data.force_kill_requested = force;
-  if (force) data.kill_requested_at = now;
-  data.phase = force ? "terminating" : "canceling";
-  data.updated_at = now;
-  writeFileSync(statusFile, JSON.stringify(data, null, 2), "utf-8");
-  writeTaskProgress(taskDir, data.phase, {
-    note: force ? "Immediate termination requested." : "Graceful cancellation requested.",
-    heartbeatAt: now,
-  });
-
-  return {
-    task_id: taskId,
-    previous_status: "running",
-    new_status: "running",
-    cancel_requested: true,
-    force_kill_requested: force,
-    message: force
-      ? "Kill requested. The runner that owns the child process will terminate it."
-      : "Cancel requested. The runner will stop the child process safely.",
-  };
-}