patchwarden 0.4.0 → 0.6.1

package/scripts/lifecycle-smoke.js

@@ -39,8 +39,8 @@ async function test(name, fn) {
   }
 }
 
-function git(args) {
-  const result = spawnSync("git", args, { cwd: repoPath, encoding: "utf-8" });
+function git(args, cwd = repoPath) {
+  const result = spawnSync("git", args, { cwd, encoding: "utf-8" });
   if (result.status !== 0) throw new Error(`git ${args.join(" ")} failed: ${result.stderr}`);
 }
 
@@ -53,6 +53,18 @@ async function waitForRunning(getTaskStatus, taskId) {
   throw new Error(`Task ${taskId} did not enter running state`);
 }
 
+async function raceWithTimeout(promise, ms, msg) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(msg)), ms);
+  });
+  try {
+    return await Promise.race([promise, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 console.log("\n=== PatchWarden Lifecycle Smoke Tests ===\n");
 
 try {
@@ -70,10 +82,14 @@ try {
   writeFileSync(join(repoPath, "main.js"), "console.log('fixture');\n", "utf-8");
   writeFileSync(join(repoPath, "second.js"), "console.log('second');\n", "utf-8");
   writeFileSync(join(repoPath, "delete-me.txt"), "delete fixture\n", "utf-8");
+  writeFileSync(join(repoPath, ".gitignore"), "dist/\nrelease/\nsync-store.json\n*.log\n", "utf-8");
+  mkdirSync(join(repoPath, "release"), { recursive: true });
+  writeFileSync(join(repoPath, "release", "tracked.txt"), "tracked artifact fixture\n", "utf-8");
   mkdirSync(plainRepoPath, { recursive: true });
   writeFileSync(join(plainRepoPath, "README.md"), "# Non-Git fixture\n", "utf-8");
   git(["init"]);
-  git(["add", "README.md", "main.js", "second.js", "delete-me.txt"]);
+  git(["add", "README.md", "main.js", "second.js", "delete-me.txt", ".gitignore"]);
+  git(["add", "-f", "release/tracked.txt"]);
   git(["-c", "user.name=PatchWarden Test", "-c", "user.email=test@example.invalid", "commit", "-m", "fixture"]);
 
   writeFileSync(
@@ -114,6 +130,13 @@ try {
           command: process.execPath,
           args: ["-e", "require('fs').writeFileSync('fixture.bin',Buffer.from([0,1,2,3,255,0,10]))"],
         },
+        artifactwriter: {
+          command: process.execPath,
+          args: [
+            "-e",
+            "const fs=require('fs');fs.mkdirSync('dist',{recursive:true});fs.writeFileSync('dist/app.exe','build');fs.writeFileSync('sync-store.json','{}');fs.appendFileSync('release/tracked.txt','changed\\n');fs.writeFileSync('generated.exe','review')",
+          ],
+        },
       },
       allowedTestCommands: ["node --check main.js", "node --check second.js", "node --check missing.js"],
       maxReadFileBytes: 200000,
@@ -133,12 +156,14 @@ try {
   const { getDiff } = await import("../dist/tools/taskOutputs.js");
   const { listAgents } = await import("../dist/tools/listAgents.js");
   const { getTaskSummary } = await import("../dist/tools/getTaskSummary.js");
+  const { auditTask } = await import("../dist/tools/auditTask.js");
   const { waitForTask } = await import("../dist/tools/waitForTask.js");
   const { runTask } = await import("../dist/runner/runTask.js");
+  const { reloadConfig } = await import("../dist/config.js");
 
   await test("list_agents reports configured executables", async () => {
     const result = listAgents();
-    if (result.total !== 7 || result.agents.some((agent) => !agent.available)) {
+    if (result.total !== 8 || result.agents.some((agent) => !agent.available)) {
       throw new Error(`Unexpected agent availability: ${JSON.stringify(result)}`);
     }
   });
@@ -295,6 +320,35 @@ try {
     }
   });
 
+  await test("artifact hygiene separates source, ignored output, runtime data, and suspicious changes", async () => {
+    const plan = savePlan({ title: "Artifact hygiene", content: "Generate representative task outputs." });
+    const task = createTask({ plan_id: plan.plan_id, agent: "artifactwriter", repo_path: "repo" });
+    const result = await runTask(task.task_id);
+    if (result.status !== "done") throw new Error(`Artifact task failed: ${JSON.stringify(result)}`);
+    const standard = getTaskSummary(task.task_id);
+    const compact = getTaskSummary(task.task_id, { view: "compact", max_items: 1 });
+    const counts = standard.artifact_hygiene?.counts || {};
+    if (
+      counts.tracked_build_artifacts < 1 ||
+      counts.ignored_untracked_artifacts < 2 ||
+      counts.runtime_generated_files < 1 ||
+      counts.suspicious_changes < 2
+    ) {
+      throw new Error(`Artifact classification mismatch: ${JSON.stringify(standard.artifact_hygiene)}`);
+    }
+    if (compact.view !== "compact" || "log_tails" in compact || compact.artifact_hygiene.max_items !== 1) {
+      throw new Error(`Compact summary leaked standard detail: ${JSON.stringify(compact)}`);
+    }
+    if (!Array.isArray(standard.changed_files) || standard.changed_files.length < 4) {
+      throw new Error("Standard summary no longer preserves full changed-file evidence");
+    }
+    const audit = auditTask(task.task_id);
+    const hygieneCheck = audit.checks.find((check) => check.name === "artifact_hygiene");
+    if (!hygieneCheck || hygieneCheck.result !== "warn") {
+      throw new Error(`Audit did not surface suspicious artifact evidence: ${JSON.stringify(audit)}`);
+    }
+  });
+
   await test("deleted tracked files are identified with file stats", async () => {
     const plan = savePlan({ title: "Delete fixture", content: "Delete the designated fixture file." });
     const task = createTask({ plan_id: plan.plan_id, agent: "deleter", repo_path: "repo" });
@@ -311,10 +365,13 @@ try {
     const task = createTask({ plan_id: plan.plan_id, agent: "writer", repo_path: "repo" });
     const running = runTask(task.task_id);
     const waited = await waitForTask(task.task_id, 5);
-    await running;
+    await raceWithTimeout(running, 15000, "wait_for_task loop did not terminate within 15s");
     if (!waited.terminal || waited.continuation_required || !waited.summary) {
       throw new Error(`Unexpected wait response: ${JSON.stringify(waited)}`);
     }
+    if (waited.summary.view !== "compact" || "log_tails" in waited.summary) {
+      throw new Error(`Terminal wait should embed compact evidence: ${JSON.stringify(waited.summary)}`);
+    }
   });
 
   await test("wait_for_task explicitly requires another call when the task is not terminal", async () => {
@@ -338,7 +395,7 @@ try {
       throw new Error(`Running summary incomplete: ${JSON.stringify(summary)}`);
     }
     cancelTask(task.task_id);
-    await running;
+    await raceWithTimeout(running, 15000, "running summary cancel did not terminate within 15s");
   });
 
   await test("verification failure produces failed_verification and structured evidence", async () => {
@@ -398,6 +455,339 @@ try {
     }
   });
 
+  // ═══════════════════════════════════════════════════════════
+  // Phase 4: Tracked external dirty tests (separate workspace)
+  // ═══════════════════════════════════════════════════════════
+
+  await test("pre-existing tracked external dirty unchanged → warning only, done", async () => {
+    // Create a separate workspace with git at the root
+    const ws2 = join(tempRoot, "workspace-tracked-dirty");
+    const repo2 = join(ws2, "repo");
+    const ext2 = join(ws2, "external");
+    mkdirSync(repo2, { recursive: true });
+    mkdirSync(ext2, { recursive: true });
+    mkdirSync(join(ws2, ".patchwarden"), { recursive: true });
+    writeFileSync(join(ws2, ".patchwarden", "watcher-heartbeat.json"), JSON.stringify({
+      status: "running", pid: process.pid, instance_id: "td-watcher", launcher_pid: process.pid,
+      started_at: new Date().toISOString(), last_heartbeat_at: new Date().toISOString(),
+    }), "utf-8");
+
+    writeFileSync(join(repo2, "main.js"), "console.log('main');\n", "utf-8");
+    writeFileSync(join(ext2, "external-tracked.txt"), "external tracked content\n", "utf-8");
+
+    git(["init"], ws2);
+    git(["add", "repo/main.js", "external/external-tracked.txt"], ws2);
+    git(["-c", "user.name=T", "-c", "user.email=t@e", "commit", "-m", "init"], ws2);
+
+    // Now modify external file to create pre-existing dirty state
+    writeFileSync(join(ext2, "external-tracked.txt"), "pre-existing dirty content\n", "utf-8");
+
+    const cfg2 = join(tempRoot, "config-tracked-dirty.json");
+    writeFileSync(cfg2, JSON.stringify({
+      workspaceRoot: ws2,
+      plansDir: ".patchwarden/plans",
+      tasksDir: ".patchwarden/tasks",
+      agents: {
+        noop: { command: process.execPath, args: ["-e", "console.log('noop')"] },
+      },
+      allowedTestCommands: ["node --check main.js"],
+      maxReadFileBytes: 200000,
+      defaultTaskTimeoutSeconds: 10,
+      watcherStaleSeconds: 3600,
+    }, null, 2), "utf-8");
+
+    const oldConfig = process.env.PATCHWARDEN_CONFIG;
+    process.env.PATCHWARDEN_CONFIG = cfg2;
+    reloadConfig(cfg2);
+
+    const plan = savePlan({ title: "Noop with external dirty", content: "Do nothing." });
+    const task = createTask({ plan_id: plan.plan_id, agent: "noop", repo_path: "repo", verify_commands: ["node --check main.js"] });
+    const result = await runTask(task.task_id);
+
+    if (result.status !== "done") {
+      throw new Error(`Expected done, got: ${JSON.stringify(result)}`);
+    }
+    const structured = JSON.parse(readFileSync(join(task.path, "result.json"), "utf-8"));
+
+    // Must have pre-existing external dirty warning
+    if (!structured.warnings?.some((w) => w.includes("Pre-existing external dirty"))) {
+      throw new Error(`Missing pre-existing dirty warning: ${JSON.stringify(structured.warnings)}`);
+    }
+
+    // new_out_of_scope_changes must be empty (file didn't change during task)
+    if (structured.new_out_of_scope_changes?.length > 0) {
+      throw new Error(`Should have no new out-of-scope changes: ${JSON.stringify(structured.new_out_of_scope_changes)}`);
+    }
+
+    // verify_status should NOT be failed
+    if (structured.verify_status === "failed") {
+      throw new Error(`verify_status should not be failed: ${structured.verify_status}`);
+    }
+
+    // get_task_summary acceptance_status should NOT be failed
+    const summary = getTaskSummary(task.task_id);
+    if (summary.acceptance_status === "failed") {
+      throw new Error(`acceptance_status should not be failed: ${summary.acceptance_status}`);
+    }
+
+    // audit_task should NOT fail scope_changes
+    const audit = auditTask(task.task_id);
+    const scopeCheck = audit.checks.find((c) => c.name === "scope_changes");
+    if (!scopeCheck || scopeCheck.result !== "pass") {
+      throw new Error(`audit scope_changes should pass: ${JSON.stringify(scopeCheck)}`);
+    }
+
+    // Restore config AFTER all assertions
+    process.env.PATCHWARDEN_CONFIG = oldConfig;
+    reloadConfig(oldConfig);
+
+    // Print result.json key fields for reporting
+    console.log(`    [result.json] status=${structured.status}, verify_status=${structured.verify_status}, new_out_of_scope=${JSON.stringify(structured.new_out_of_scope_changes)}, preexisting=${JSON.stringify(structured.preexisting_external_dirty_files)}, warnings=${JSON.stringify(structured.warnings)}`);
+  });
+
+  await test("pre-existing tracked external dirty changed during task → failed_scope_violation", async () => {
+    const ws2 = join(tempRoot, "workspace-tracked-dirty2");
+    const repo2 = join(ws2, "repo");
+    const ext2 = join(ws2, "external");
+    mkdirSync(repo2, { recursive: true });
+    mkdirSync(ext2, { recursive: true });
+    mkdirSync(join(ws2, ".patchwarden"), { recursive: true });
+    writeFileSync(join(ws2, ".patchwarden", "watcher-heartbeat.json"), JSON.stringify({
+      status: "running", pid: process.pid, instance_id: "td-watcher2", launcher_pid: process.pid,
+      started_at: new Date().toISOString(), last_heartbeat_at: new Date().toISOString(),
+    }), "utf-8");
+
+    writeFileSync(join(repo2, "main.js"), "console.log('main');\n", "utf-8");
+    writeFileSync(join(ext2, "external-tracked.txt"), "external tracked content\n", "utf-8");
+
+    git(["init"], ws2);
+    git(["add", "repo/main.js", "external/external-tracked.txt"], ws2);
+    git(["-c", "user.name=T", "-c", "user.email=t@e", "commit", "-m", "init"], ws2);
+
+    // Modify external file BEFORE task (pre-existing dirty)
+    writeFileSync(join(ext2, "external-tracked.txt"), "pre-existing dirty content\n", "utf-8");
+
+    const cfg2 = join(tempRoot, "config-tracked-dirty2.json");
+    writeFileSync(cfg2, JSON.stringify({
+      workspaceRoot: ws2,
+      plansDir: ".patchwarden/plans",
+      tasksDir: ".patchwarden/tasks",
+      agents: {
+        extmod: { command: process.execPath, args: ["-e", "require('fs').appendFileSync('../external/external-tracked.txt',' modified by task\\n')"] },
+      },
+      allowedTestCommands: ["node --check main.js"],
+      maxReadFileBytes: 200000,
+      defaultTaskTimeoutSeconds: 10,
+      watcherStaleSeconds: 3600,
+    }, null, 2), "utf-8");
+
+    const oldConfig = process.env.PATCHWARDEN_CONFIG;
+    process.env.PATCHWARDEN_CONFIG = cfg2;
+    reloadConfig(cfg2);
+
+    const plan = savePlan({ title: "External dirty modifier", content: "Modify external tracked file." });
+    const task = createTask({ plan_id: plan.plan_id, agent: "extmod", repo_path: "repo", verify_commands: ["node --check main.js"] });
+    const result = await runTask(task.task_id);
+
+    if (result.status !== "failed_scope_violation") {
+      throw new Error(`Expected failed_scope_violation, got: ${JSON.stringify(result)}`);
+    }
+    const structured = JSON.parse(readFileSync(join(task.path, "result.json"), "utf-8"));
+
+    // new_out_of_scope_changes must contain the external tracked file
+    if (!structured.new_out_of_scope_changes?.some((f) => f.path.includes("external-tracked.txt"))) {
+      throw new Error(`Missing new out-of-scope change: ${JSON.stringify(structured.new_out_of_scope_changes)}`);
+    }
+
+    // verify_status must be failed
+    if (structured.verify_status !== "failed") {
+      throw new Error(`verify_status must be failed: ${structured.verify_status}`);
+    }
+
+    // rollback plan must contain the file
+    const rollbackPath = join(task.path, "rollback_scope_violation_plan.md");
+    if (!existsSync(rollbackPath)) throw new Error("rollback_scope_violation_plan.md missing");
+    const rollback = readFileSync(rollbackPath, "utf-8");
+    if (!rollback.includes("external-tracked.txt")) {
+      throw new Error(`Rollback plan missing external-tracked.txt: ${rollback}`);
+    }
+
+    // get_task_summary acceptance_status must be failed
+    const summary = getTaskSummary(task.task_id);
+    if (summary.acceptance_status !== "failed") {
+      throw new Error(`acceptance_status must be failed: ${summary.acceptance_status}`);
+    }
+
+    // audit_task verdict must be fail
+    const audit = auditTask(task.task_id);
+    if (audit.verdict !== "fail") {
+      throw new Error(`audit verdict must be fail: ${audit.verdict}`);
+    }
+
+    // Restore config AFTER all assertions
+    process.env.PATCHWARDEN_CONFIG = oldConfig;
+    reloadConfig(oldConfig);
+
+    console.log(`    [result.json] status=${structured.status}, verify_status=${structured.verify_status}, new_out_of_scope=${JSON.stringify(structured.new_out_of_scope_changes)}, preexisting=${JSON.stringify(structured.preexisting_external_dirty_files)}, warnings=${JSON.stringify(structured.warnings)}`);
+  });
+
+  await test("clean tracked external file changed during task → failed_scope_violation", async () => {
+    const ws2 = join(tempRoot, "workspace-tracked-dirty3");
+    const repo2 = join(ws2, "repo");
+    const ext2 = join(ws2, "external");
+    mkdirSync(repo2, { recursive: true });
+    mkdirSync(ext2, { recursive: true });
+    mkdirSync(join(ws2, ".patchwarden"), { recursive: true });
+    writeFileSync(join(ws2, ".patchwarden", "watcher-heartbeat.json"), JSON.stringify({
+      status: "running", pid: process.pid, instance_id: "td-watcher3", launcher_pid: process.pid,
+      started_at: new Date().toISOString(), last_heartbeat_at: new Date().toISOString(),
+    }), "utf-8");
+
+    writeFileSync(join(repo2, "main.js"), "console.log('main');\n", "utf-8");
+    writeFileSync(join(ext2, "external-tracked.txt"), "external tracked content\n", "utf-8");
+
+    git(["init"], ws2);
+    git(["add", "repo/main.js", "external/external-tracked.txt"], ws2);
+    git(["-c", "user.name=T", "-c", "user.email=t@e", "commit", "-m", "init"], ws2);
+
+    // External file is clean (committed state) — no pre-existing dirty
+
+    const cfg2 = join(tempRoot, "config-tracked-dirty3.json");
+    writeFileSync(cfg2, JSON.stringify({
+      workspaceRoot: ws2,
+      plansDir: ".patchwarden/plans",
+      tasksDir: ".patchwarden/tasks",
+      agents: {
+        extmod: { command: process.execPath, args: ["-e", "require('fs').appendFileSync('../external/external-tracked.txt',' modified by task\\n')"] },
+      },
+      allowedTestCommands: ["node --check main.js"],
+      maxReadFileBytes: 200000,
+      defaultTaskTimeoutSeconds: 10,
+      watcherStaleSeconds: 3600,
+    }, null, 2), "utf-8");
+
+    const oldConfig = process.env.PATCHWARDEN_CONFIG;
+    process.env.PATCHWARDEN_CONFIG = cfg2;
+    reloadConfig(cfg2);
+
+    const plan = savePlan({ title: "Clean external modifier", content: "Modify clean external tracked file." });
+    const task = createTask({ plan_id: plan.plan_id, agent: "extmod", repo_path: "repo", verify_commands: ["node --check main.js"] });
+    const result = await runTask(task.task_id);
+
+    if (result.status !== "failed_scope_violation") {
+      throw new Error(`Expected failed_scope_violation, got: ${JSON.stringify(result)}`);
+    }
+    const structured = JSON.parse(readFileSync(join(task.path, "result.json"), "utf-8"));
+
+    // new_out_of_scope_changes must contain the external tracked file (clean→dirty)
+    if (!structured.new_out_of_scope_changes?.some((f) => f.path.includes("external-tracked.txt"))) {
+      throw new Error(`Missing new out-of-scope change: ${JSON.stringify(structured.new_out_of_scope_changes)}`);
+    }
+
+    // verify_status must be failed
+    if (structured.verify_status !== "failed") {
+      throw new Error(`verify_status must be failed: ${structured.verify_status}`);
+    }
+
+    // get_task_summary acceptance_status must be failed
+    const summary = getTaskSummary(task.task_id);
+    if (summary.acceptance_status !== "failed") {
+      throw new Error(`acceptance_status must be failed: ${summary.acceptance_status}`);
+    }
+
+    // audit_task verdict must be fail
+    const audit = auditTask(task.task_id);
+    if (audit.verdict !== "fail") {
+      throw new Error(`audit verdict must be fail: ${audit.verdict}`);
+    }
+
+    // Restore config AFTER all assertions
+    process.env.PATCHWARDEN_CONFIG = oldConfig;
+    reloadConfig(oldConfig);
+
+    console.log(`    [result.json] status=${structured.status}, verify_status=${structured.verify_status}, new_out_of_scope=${JSON.stringify(structured.new_out_of_scope_changes)}, preexisting=${JSON.stringify(structured.preexisting_external_dirty_files)}, warnings=${JSON.stringify(structured.warnings)}`);
+  });
+
+  await test("tracked external file rename → failed_scope_violation", async () => {
+    const ws2 = join(tempRoot, "workspace-tracked-rename");
+    const repo2 = join(ws2, "repo");
+    const ext2 = join(ws2, "external");
+    mkdirSync(repo2, { recursive: true });
+    mkdirSync(ext2, { recursive: true });
+    mkdirSync(join(ws2, ".patchwarden"), { recursive: true });
+    writeFileSync(join(ws2, ".patchwarden", "watcher-heartbeat.json"), JSON.stringify({
+      status: "running", pid: process.pid, instance_id: "td-watcher-rename", launcher_pid: process.pid,
+      started_at: new Date().toISOString(), last_heartbeat_at: new Date().toISOString(),
+    }), "utf-8");
+
+    writeFileSync(join(repo2, "main.js"), "console.log('main');\n", "utf-8");
+    writeFileSync(join(ext2, "external-tracked.txt"), "external tracked content\n", "utf-8");
+
+    git(["init"], ws2);
+    git(["add", "repo/main.js", "external/external-tracked.txt"], ws2);
+    git(["-c", "user.name=T", "-c", "user.email=t@e", "commit", "-m", "init"], ws2);
+
+    // External file is clean (committed state) — no pre-existing dirty
+
+    const cfg2 = join(tempRoot, "config-tracked-rename.json");
+    writeFileSync(cfg2, JSON.stringify({
+      workspaceRoot: ws2,
+      plansDir: ".patchwarden/plans",
+      tasksDir: ".patchwarden/tasks",
+      agents: {
+        extrenamer: { command: process.execPath, args: ["-e", "require('fs').renameSync('../external/external-tracked.txt','../external/external-renamed.txt')"] },
+      },
+      allowedTestCommands: ["node --check main.js"],
+      maxReadFileBytes: 200000,
+      defaultTaskTimeoutSeconds: 10,
+      watcherStaleSeconds: 3600,
+    }, null, 2), "utf-8");
+
+    const oldConfig = process.env.PATCHWARDEN_CONFIG;
+    process.env.PATCHWARDEN_CONFIG = cfg2;
+    reloadConfig(cfg2);
+
+    const plan = savePlan({ title: "External rename", content: "Rename external tracked file." });
+    const task = createTask({ plan_id: plan.plan_id, agent: "extrenamer", repo_path: "repo", verify_commands: ["node --check main.js"] });
+    const result = await runTask(task.task_id);
+
+    if (result.status !== "failed_scope_violation") {
+      throw new Error(`Expected failed_scope_violation, got: ${JSON.stringify(result)}`);
+    }
+    const structured = JSON.parse(readFileSync(join(task.path, "result.json"), "utf-8"));
+
+    // new_out_of_scope_changes must contain rename evidence (old or new path)
+    const hasRenameEvidence = structured.new_out_of_scope_changes?.some(
+      (f) => f.path.includes("external-renamed.txt") || f.path.includes("external-tracked.txt") || f.change === "renamed"
+    );
+    if (!hasRenameEvidence) {
+      throw new Error(`Missing rename evidence in new_out_of_scope_changes: ${JSON.stringify(structured.new_out_of_scope_changes)}`);
+    }
+
+    // verify_status must be failed
+    if (structured.verify_status !== "failed") {
+      throw new Error(`verify_status must be failed: ${structured.verify_status}`);
+    }
+
+    // get_task_summary acceptance_status must be failed
+    const summary = getTaskSummary(task.task_id);
+    if (summary.acceptance_status !== "failed") {
+      throw new Error(`acceptance_status must be failed: ${summary.acceptance_status}`);
+    }
+
+    // audit_task verdict must be fail
+    const audit = auditTask(task.task_id);
+    if (audit.verdict !== "fail") {
+      throw new Error(`audit verdict must be fail: ${audit.verdict}`);
+    }
+
+    // Restore config AFTER all assertions
+    process.env.PATCHWARDEN_CONFIG = oldConfig;
+    reloadConfig(oldConfig);
+
+    console.log(`    [result.json] status=${structured.status}, verify_status=${structured.verify_status}, new_out_of_scope=${JSON.stringify(structured.new_out_of_scope_changes)}, preexisting=${JSON.stringify(structured.preexisting_external_dirty_files)}, warnings=${JSON.stringify(structured.warnings)}`);
+  });
+
   await test("timeout terminates a long-running agent", async () => {
     const plan = savePlan({ title: "Timeout", content: "Wait." });
     const task = createTask({ plan_id: plan.plan_id, agent: "slow", repo_path: "repo", timeout_seconds: 1 });
@@ -423,7 +813,7 @@ try {
     if (!request.cancel_requested || request.force_kill_requested) {
       throw new Error(`Unexpected cancel response: ${JSON.stringify(request)}`);
     }
-    const result = await running;
+    const result = await raceWithTimeout(running, 15000, "cancel_task did not terminate within 15s");
     if (result.status !== "canceled") throw new Error(`Expected canceled, got ${JSON.stringify(result)}`);
   });
 
@@ -434,7 +824,7 @@ try {
     await waitForRunning(getTaskStatus, task.task_id);
     const request = killTask(task.task_id);
     if (!request.force_kill_requested) throw new Error(`Unexpected kill response: ${JSON.stringify(request)}`);
-    const result = await running;
+    const result = await raceWithTimeout(running, 15000, "kill_task did not terminate within 15s");
     if (result.status !== "canceled" || !result.error?.includes("kill_task")) {
       throw new Error(`Expected killed/canceled result, got ${JSON.stringify(result)}`);
     }
@@ -451,3 +841,7 @@ console.log(`${"=".repeat(50)}\n`);
 
 if (failed > 0) process.exit(1);
 console.log("ALL LIFECYCLE TESTS PASSED\n");
+
+// Safety: force exit after cleanup in case any stray timer/handle keeps the event loop alive.
+// All child processes are killed by the runner; this only guards against OS-level pipe drains.
+process.exit(0);