patchwarden 0.4.0 → 0.6.0

package/package.json

@@ -1,25 +1,27 @@
 {
   "name": "patchwarden",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "A secure local MCP bridge: clients save plans, local agents execute tasks, and results are returned through workspace-scoped files.",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
     "patchwarden": "dist/index.js",
+    "patchwarden-confirm": "dist/assessments/confirmCli.js",
     "patchwarden-runner": "dist/runner/cli.js"
   },
   "files": [
     "dist/",
     "docs/",
+    "!docs/optimization-proposal.md",
     "src/",
     "examples/",
     "scripts/",
-    "Start-PatchWarden-Tunnel.cmd",
-    "Restart-PatchWarden.cmd",
-    "Check-PatchWarden-Health.cmd",
-    "Reset-PatchWarden-Tunnel-Key.cmd",
+    "!scripts/kill-patchwarden.ps1",
+    "!scripts/launchers/Kill-PatchWarden.cmd",
+    "PatchWarden.cmd",
     "README.md",
+    "README.en.md",
     "LICENSE",
     "tsconfig.json"
   ],
@@ -31,25 +33,27 @@
     "runner": "node dist/runner/cli.js",
     "watch": "node dist/runner/watch.js",
     "doctor": "node dist/doctor.js",
-    "test": "node dist/smoke-test.js && node scripts/lifecycle-smoke.js && node scripts/doctor-smoke.js && node scripts/tunnel-supervisor-smoke.js && node scripts/watcher-supervisor-smoke.js && node scripts/mcp-manifest-check.js && node scripts/brand-check.js",
+    "doctor:ci": "node dist/doctor.js --allow-default-config",
+    "test": "node dist/smoke-test.js && node scripts/lifecycle-smoke.js && node scripts/doctor-smoke.js && node scripts/tunnel-supervisor-smoke.js && node scripts/watcher-supervisor-smoke.js && node scripts/control-smoke.js && node scripts/mcp-manifest-check.js && node scripts/brand-check.js",
     "test:lifecycle": "npm run build && node scripts/lifecycle-smoke.js",
     "test:doctor": "npm run build && node scripts/doctor-smoke.js",
     "test:tunnel-supervisor": "npm run build && node scripts/tunnel-supervisor-smoke.js",
     "test:watcher-supervisor": "npm run build && node scripts/watcher-supervisor-smoke.js",
     "check:tool-manifest": "npm run build && node scripts/mcp-manifest-check.js",
+    "check:direct-tool-manifest": "npm run build && node scripts/mcp-manifest-check.js --profile chatgpt_direct",
     "check:brand": "node scripts/brand-check.js",
     "test:mcp": "npm run build && node scripts/mcp-smoke.js",
     "test:http-mcp": "npm run build && node scripts/http-mcp-smoke.js",
     "pretest": "npm run build",
     "pack:clean": "npm run build && node scripts/pack-clean.js",
-    "verify:package": "npm run build && npm pack --dry-run"
+    "verify:package": "npm run build && node scripts/package-manifest-check.js"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
-    "typescript": "^5.0.0"
+    "typescript": "^6.0.3"
   },
   "engines": {
     "node": ">=18.0.0"

package/scripts/brand-check.js

@@ -1,25 +1,45 @@
 #!/usr/bin/env node
 import { execFileSync } from "node:child_process";
-import { readFileSync } from "node:fs";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
 
 const allowedLegacyFiles = new Set([
   ".gitignore",
   ".npmignore",
   "README.md",
+  "README.en.md",
   "docs/migration-from-safe-bifrost.md",
   "docs/release-v0.3.0.md",
   "docs/release-v0.4.0.md",
+  "docs/release-v0.6.0.md",
   "scripts/brand-check.js",
   "scripts/pack-clean.js",
 ]);
 const legacyPattern = /safe-bifrost|Safe-Bifrost|SAFE_BIFROST|SafeBifrost|safe_bifrost/;
-const trackedFiles = execFileSync(
-  "git",
-  ["ls-files", "--cached", "--others", "--exclude-standard"],
-  { encoding: "utf-8" }
-)
-  .split(/\r?\n/)
-  .filter(Boolean);
+
+const EXCLUDE_DIRS = new Set(["node_modules", ".npm-cache", "dist", "release", ".patchwarden", ".git", "logs", "tmp", "coverage", "build", "out", ".next"]);
+
+let trackedFiles;
+let inGit = false;
+try {
+  trackedFiles = execFileSync(
+    "git",
+    ["ls-files", "--cached", "--others", "--exclude-standard"],
+    { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+  )
+    .split(/\r?\n/)
+    .filter(Boolean);
+  inGit = true;
+} catch {
+  // Not a git repository — fall back to filesystem walk
+  console.warn("[brand-check] Not a Git repository; using filesystem walk.");
+  trackedFiles = walkFiles(".");
+  if (trackedFiles.length === 0) {
+    console.warn("[brand-check] WARNING: no files found in non-Git walk. Exiting cleanly.");
+    process.exit(0);
+  }
+}
+
 const failures = [];
 
 for (const file of trackedFiles) {
@@ -29,9 +49,13 @@ for (const file of trackedFiles) {
     failures.push(`${normalized}: legacy brand in path`);
     continue;
   }
-  const content = readFileSync(file);
-  if (!content.includes(0) && legacyPattern.test(content.toString("utf-8"))) {
-    failures.push(`${normalized}: legacy brand in content`);
+  try {
+    const content = readFileSync(file);
+    if (!content.includes(0) && legacyPattern.test(content.toString("utf-8"))) {
+      failures.push(`${normalized}: legacy brand in content`);
+    }
+  } catch {
+    // skip unreadable files
   }
 }
 
@@ -41,4 +65,26 @@ if (failures.length > 0) {
   process.exit(1);
 }
 
-console.log(`[brand-check] OK: ${trackedFiles.length} tracked files checked.`);
+const label = inGit ? "tracked files checked" : "files scanned (non-Git fallback)";
+console.log(`[brand-check] OK: ${trackedFiles.length} ${label}.`);
+
+function walkFiles(root) {
+  const results = [];
+  const visit = (dir) => {
+    if (results.length > 10000) return;
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (results.length > 10000) break;
+      if (e.isDirectory()) {
+        if (EXCLUDE_DIRS.has(e.name)) continue;
+        visit(join(dir, e.name));
+      } else if (e.isFile()) {
+        const rel = relative(root, join(dir, e.name)).replace(/\\/g, "/");
+        results.push(rel);
+      }
+    }
+  };
+  visit(root);
+  return results;
+}

package/scripts/control-smoke.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+if (process.platform !== "win32") {
+  console.log("ok - PatchWarden control smoke skipped outside Windows");
+  process.exit(0);
+}
+
+const scriptDir = resolve(fileURLToPath(new URL(".", import.meta.url)));
+const root = resolve(scriptDir, "..");
+const manager = join(scriptDir, "manage-patchwarden.ps1");
+const temp = mkdtempSync(join(tmpdir(), "patchwarden-control-smoke-"));
+const mockConfig = join(temp, "patchwarden.config.json");
+writeFileSync(mockConfig, JSON.stringify({
+  workspaceRoot: temp,
+  plansDir: ".patchwarden/plans",
+  tasksDir: ".patchwarden/tasks",
+}), "utf8");
+const env = {
+  ...process.env,
+  LOCALAPPDATA: join(temp, "LocalAppData"),
+  APPDATA: join(temp, "AppData"),
+  TEMP: join(temp, "Temp"),
+  TMP: join(temp, "Temp"),
+  PATCHWARDEN_CONFIG: mockConfig,
+};
+let fakeTunnel = null;
+let fakeWatcher = null;
+let healthServer = null;
+
+try {
+  const statusOutput = run(["status", "all", "-Json"]);
+  const statuses = JSON.parse(statusOutput);
+  if (!Array.isArray(statuses) || statuses.length !== 2) {
+    throw new Error(`expected two status rows, got: ${statusOutput}`);
+  }
+  const byMode = new Map(statuses.map((entry) => [entry.mode, entry]));
+  if (byMode.get("core")?.tool_profile !== "chatgpt_core") {
+    throw new Error("Core status did not report chatgpt_core");
+  }
+  if (byMode.get("direct")?.tool_profile !== "chatgpt_direct") {
+    throw new Error("Direct status did not report chatgpt_direct");
+  }
+
+  const startPlan = run(["start", "all", "-WhatIf"]);
+  requireText(startPlan, "start:core");
+  requireText(startPlan, "start:direct");
+
+  const restartPlan = run(["restart", "direct", "-WhatIf", "-SkipBuild"]);
+  requireText(restartPlan, "stop:direct");
+  requireText(restartPlan, "start:direct");
+
+  const fakeDirectory = join(temp, "fake-tunnel");
+  const fakeExecutable = join(fakeDirectory, "tunnel-client.exe");
+  const fakeScript = join(fakeDirectory, "sleep.ps1");
+  const systemPowerShell = join(process.env.SystemRoot || "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+  mkdirSync(fakeDirectory, { recursive: true });
+  copyFileSync(systemPowerShell, fakeExecutable);
+  writeFileSync(fakeScript, "Start-Sleep -Seconds 120\r\n", "utf8");
+  fakeTunnel = spawn(
+    fakeExecutable,
+    ["-NoProfile", "-File", fakeScript, "run", "--profile", "patchwarden-direct"],
+    { stdio: "ignore", windowsHide: true }
+  );
+  await delay(500);
+  if (fakeTunnel.exitCode !== null) throw new Error("fake Tunnel process exited before stop test");
+  const directRuntime = join(env.LOCALAPPDATA, "patchwarden", "runtime-direct");
+  mkdirSync(directRuntime, { recursive: true });
+  mkdirSync(env.TEMP, { recursive: true });
+  writeFileSync(join(directRuntime, "tunnel-status.json"), JSON.stringify({
+    status: "stopped",
+    ready: false,
+    pid: null,
+    tool_profile: "chatgpt_direct",
+    tool_count: 9,
+    tools_ready: true,
+  }), "utf8");
+  writeFileSync(join(directRuntime, "tunnel-client.pid"), String(fakeTunnel.pid), "utf8");
+  writeFileSync(join(directRuntime, "tunnel-health-url.txt"), "http://127.0.0.1:8081", "utf8");
+  const legacyDirectPid = join(env.TEMP, "patchwarden-direct.pid");
+  const legacyDirectUrl = join(env.TEMP, "patchwarden-direct-health.url");
+  writeFileSync(legacyDirectPid, String(fakeTunnel.pid), "utf8");
+  writeFileSync(legacyDirectUrl, "http://127.0.0.1:8081", "utf8");
+  const stopOutput = run(["stop", "direct"]);
+  requireText(stopOutput, `Stopped PID ${fakeTunnel.pid}`);
+  await waitForExit(fakeTunnel, 5000);
+  if (fakeTunnel.exitCode === null) throw new Error("manager did not stop the owned Direct fixture process");
+  for (const stalePath of [join(directRuntime, "tunnel-client.pid"), join(directRuntime, "tunnel-health-url.txt"), legacyDirectPid, legacyDirectUrl]) {
+    if (existsSync(stalePath)) throw new Error(`manager did not clean stale runtime file: ${stalePath}`);
+  }
+
+  fakeWatcher = spawn(
+    process.execPath,
+    ["-e", "setTimeout(()=>{},120000)", join(root, "dist", "runner", "watch.js")],
+    { stdio: "ignore", windowsHide: true }
+  );
+  await delay(500);
+  if (fakeWatcher.exitCode !== null) throw new Error("fake watcher exited before kill test");
+  const killOutput = run(["kill", "core"]);
+  requireText(killOutput, `Stopped PID ${fakeWatcher.pid}`);
+  await waitForExit(fakeWatcher, 5000);
+  if (fakeWatcher.exitCode === null) throw new Error("kill core did not stop the project-scoped watcher fixture");
+
+  const coreRuntime = join(env.LOCALAPPDATA, "patchwarden", "runtime");
+  mkdirSync(coreRuntime, { recursive: true });
+  writeFileSync(join(coreRuntime, "tunnel-status.json"), JSON.stringify({
+    status: "stopped",
+    ready: false,
+    pid: null,
+    reason_code: "stale_fixture",
+    last_error: "stale failure",
+    tool_profile: "chatgpt_core",
+    tool_count: 16,
+    tools_ready: true,
+  }), "utf8");
+  healthServer = spawn(
+    process.execPath,
+    ["-e", "require('http').createServer((req,res)=>{res.writeHead(200,{'content-type':'application/json'});res.end(JSON.stringify({ok:true}))}).listen(8080,'127.0.0.1')"],
+    { stdio: "ignore", windowsHide: true }
+  );
+  await delay(750);
+  if (healthServer.exitCode !== null) throw new Error("health fallback fixture could not listen on 127.0.0.1:8080");
+  const coreStatusRaw = run(["status", "core", "-Json"]);
+  const coreStatusValue = JSON.parse(coreStatusRaw);
+  const coreStatus = Array.isArray(coreStatusValue) ? coreStatusValue[0] : coreStatusValue;
+  if (coreStatus.status !== "running" || coreStatus.ready !== true || coreStatus.health_alive !== true || coreStatus.reason_code !== "health_endpoint_ready") {
+    throw new Error(`health fallback did not override stale runtime JSON: ${coreStatusRaw}`);
+  }
+  const conflict = runFailure(["restart", "core", "-WhatIf", "-SkipBuild"]);
+  requireText(`${conflict.stdout}\n${conflict.stderr}`, "Unsafe health-port conflict");
+  if (healthServer.exitCode !== null) throw new Error("manager killed an unrelated health-port owner");
+  const scopedKill = run(["kill", "core"]);
+  requireText(scopedKill, "No matching Core Agent process");
+  if (healthServer.exitCode !== null) throw new Error("kill core terminated an unrelated process");
+
+  const expectedFiles = [
+    "PatchWarden.cmd",
+    "scripts/manage-patchwarden.ps1",
+    "scripts/launchers/Start-PatchWarden-Tunnel.cmd",
+    "scripts/launchers/Start-PatchWarden-Direct-Tunnel.cmd",
+  ];
+  for (const relativePath of expectedFiles) {
+    if (!existsSync(join(root, relativePath))) {
+      throw new Error(`missing consolidated control file: ${relativePath}`);
+    }
+  }
+  const rootEntry = readFileSync(join(root, "PatchWarden.cmd"), "utf8");
+  if (!rootEntry.includes("manage-patchwarden.ps1")) {
+    throw new Error("PatchWarden.cmd does not invoke the consolidated manager");
+  }
+  console.log("ok - control handles orphan cleanup, scoped kill, port conflicts, health fallback, and Core/Direct lifecycle actions");
+} finally {
+  if (fakeTunnel?.exitCode === null) fakeTunnel.kill();
+  if (fakeWatcher?.exitCode === null) fakeWatcher.kill();
+  if (healthServer?.exitCode === null) healthServer.kill();
+  rmSync(temp, { recursive: true, force: true });
+}
+
+function run(args) {
+  const result = spawnSync(
+    "powershell.exe",
+    ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", manager, ...args],
+    { cwd: root, env, encoding: "utf8" }
+  );
+  if (result.status !== 0) {
+    throw new Error(`manager failed (${args.join(" ")}):\n${result.stdout}\n${result.stderr}`);
+  }
+  return result.stdout.trim();
+}
+
+function runFailure(args) {
+  const result = spawnSync(
+    "powershell.exe",
+    ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", manager, ...args],
+    { cwd: root, env, encoding: "utf8" }
+  );
+  if (result.status === 0) {
+    throw new Error(`manager unexpectedly succeeded (${args.join(" ")}):\n${result.stdout}\n${result.stderr}`);
+  }
+  return result;
+}
+
+function requireText(value, expected) {
+  if (!value.toLowerCase().includes(expected.toLowerCase())) {
+    throw new Error(`expected ${JSON.stringify(expected)} in output:\n${value}`);
+  }
+}
+
+function delay(milliseconds) {
+  return new Promise((resolvePromise) => setTimeout(resolvePromise, milliseconds));
+}
+
+function waitForExit(child, timeoutMilliseconds) {
+  if (child.exitCode !== null) return Promise.resolve();
+  return new Promise((resolvePromise, rejectPromise) => {
+    const timer = setTimeout(() => rejectPromise(new Error("timed out waiting for fixture process to exit")), timeoutMilliseconds);
+    child.once("exit", () => {
+      clearTimeout(timer);
+      resolvePromise();
+    });
+  });
+}

package/scripts/launchers/Check-PatchWarden-Health.cmd

@@ -0,0 +1,6 @@
+@echo off
+setlocal
+cd /d "%~dp0..\.."
+powershell.exe -NoProfile -ExecutionPolicy Bypass -File "%~dp0..\manage-patchwarden.ps1" status all
+echo.
+pause

package/scripts/launchers/Reset-PatchWarden-Tunnel-Key.cmd

@@ -0,0 +1,6 @@
+@echo off
+setlocal
+cd /d "%~dp0..\.."
+powershell.exe -NoProfile -ExecutionPolicy Bypass -File "%~dp0..\start-patchwarden-tunnel.ps1" -ForgetSavedApiKey
+echo.
+pause

package/scripts/launchers/Restart-PatchWarden.cmd

@@ -0,0 +1,6 @@
+@echo off
+setlocal
+cd /d "%~dp0..\.."
+powershell.exe -NoProfile -ExecutionPolicy Bypass -File "%~dp0..\manage-patchwarden.ps1" restart core
+echo.
+pause

package/scripts/launchers/Start-PatchWarden-Direct-Tunnel.cmd

@@ -0,0 +1,7 @@
+@echo off
+setlocal
+cd /d "%~dp0..\.."
+powershell.exe -NoProfile -ExecutionPolicy Bypass -File "%~dp0..\start-patchwarden-tunnel.ps1" -ToolProfile chatgpt_direct -Profile patchwarden-direct -HealthListenAddr 127.0.0.1:8081 -SkipWatcher
+echo.
+echo PatchWarden Direct tunnel launcher exited.
+pause

package/scripts/launchers/Start-PatchWarden-Tunnel.cmd

@@ -0,0 +1,7 @@
+@echo off
+setlocal
+cd /d "%~dp0..\.."
+powershell.exe -NoProfile -ExecutionPolicy Bypass -File "%~dp0..\start-patchwarden-tunnel.ps1" -ToolProfile chatgpt_core -Profile patchwarden -HealthListenAddr 127.0.0.1:8080
+echo.
+echo PatchWarden Core tunnel launcher exited.
+pause

package/scripts/lifecycle-smoke.js

@@ -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,13 @@ 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");
 
   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 +319,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 +364,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 +394,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 () => {
@@ -423,7 +479,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 +490,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 +507,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);