patchwarden 0.6.0 → 0.6.4

package/scripts/{control-smoke.js → checks/control-smoke.js}

@@ -11,8 +11,8 @@ if (process.platform !== "win32") {
 }
 
 const scriptDir = resolve(fileURLToPath(new URL(".", import.meta.url)));
-const root = resolve(scriptDir, "..");
-const manager = join(scriptDir, "manage-patchwarden.ps1");
+const root = resolve(scriptDir, "..", "..");
+const manager = join(root, "scripts", "control", "manage-patchwarden.ps1");
 const temp = mkdtempSync(join(tmpdir(), "patchwarden-control-smoke-"));
 const mockConfig = join(temp, "patchwarden.config.json");
 writeFileSync(mockConfig, JSON.stringify({
@@ -139,7 +139,13 @@ try {
 
   const expectedFiles = [
     "PatchWarden.cmd",
-    "scripts/manage-patchwarden.ps1",
+    "PatchWarden-Control.cmd",
+    "PatchWarden-Control-Tray.cmd",
+    "PatchWarden-Desktop.cmd",
+    "Restart-PatchWarden-Control.cmd",
+    "Stop-PatchWarden.cmd",
+    "scripts/control/manage-patchwarden.ps1",
+    "scripts/control/stop-patchwarden.ps1",
     "scripts/launchers/Start-PatchWarden-Tunnel.cmd",
     "scripts/launchers/Start-PatchWarden-Direct-Tunnel.cmd",
   ];
@@ -152,6 +158,14 @@ try {
   if (!rootEntry.includes("manage-patchwarden.ps1")) {
     throw new Error("PatchWarden.cmd does not invoke the consolidated manager");
   }
+  const stopEntry = readFileSync(join(root, "Stop-PatchWarden.cmd"), "utf8");
+  if (!stopEntry.includes("scripts\\control\\stop-patchwarden.ps1")) {
+    throw new Error("Stop-PatchWarden.cmd does not invoke the one-click shutdown script");
+  }
+  const desktopEntry = readFileSync(join(root, "PatchWarden-Desktop.cmd"), "utf8");
+  if (!desktopEntry.includes("control-center-tray.ps1") || !desktopEntry.includes("WindowStyle Hidden")) {
+    throw new Error("PatchWarden-Desktop.cmd must launch the tray hidden as the daily desktop entry");
+  }
   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();

package/scripts/{doctor-smoke.js → checks/doctor-smoke.js}

@@ -5,7 +5,7 @@ import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
-const root = resolve(fileURLToPath(new URL("..", import.meta.url)));
+const root = resolve(fileURLToPath(new URL("../..", import.meta.url)));
 const tempRoot = mkdtempSync(join(tmpdir(), "patchwarden-doctor-"));
 const workspaceRoot = join(tempRoot, "workspace");
 const configPath = join(tempRoot, "patchwarden.config.json");

package/scripts/{http-mcp-smoke.js → checks/http-mcp-smoke.js}

@@ -11,10 +11,10 @@ import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { setTimeout as sleep } from "node:timers/promises";
-import { CHATGPT_CORE_TOOL_NAMES } from "../dist/tools/toolCatalog.js";
+import { CHATGPT_CORE_TOOL_NAMES } from "../../dist/tools/toolCatalog.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const root = resolve(__dirname, "..");
+const root = resolve(__dirname, "..", "..");
 const serverPath = resolve(root, "dist", "httpServer.js");
 
 const host = "127.0.0.1";
@@ -139,7 +139,7 @@ try {
     serverStderr += chunk.toString();
   });
 
-  await sleep(1000);
+  await sleep(3000);
   if (serverProcess.exitCode !== null) {
     throw new Error(`HTTP server exited early: ${serverStderr}`);
   }
@@ -274,7 +274,15 @@ try {
     stdio: ["ignore", "ignore", "pipe"],
   });
   serverProcess.stderr.on("data", (chunk) => { serverStderr += chunk.toString(); });
-  await sleep(1000);
+  await sleep(3000);
+  // Wait for server to be ready
+  for (let i = 0; i < 10; i++) {
+    try {
+      const r = await fetch(`${mcpUrl}/healthz`);
+      if (r.status === 200) break;
+    } catch {}
+    await sleep(500);
+  }
 
   await test("token: no token returns 401", async () => {
     try {

package/scripts/{lifecycle-smoke.js → checks/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}`);
 }
 
@@ -148,17 +148,18 @@ try {
   );
   process.env.PATCHWARDEN_CONFIG = configPath;
 
-  const { savePlan } = await import("../dist/tools/savePlan.js");
-  const { createTask } = await import("../dist/tools/createTask.js");
-  const { getTaskStatus } = await import("../dist/tools/getTaskStatus.js");
-  const { cancelTask } = await import("../dist/tools/cancelTask.js");
-  const { killTask } = await import("../dist/tools/killTask.js");
-  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 { savePlan } = await import("../../dist/tools/savePlan.js");
+  const { createTask } = await import("../../dist/tools/createTask.js");
+  const { getTaskStatus } = await import("../../dist/tools/getTaskStatus.js");
+  const { cancelTask } = await import("../../dist/tools/cancelTask.js");
+  const { killTask } = await import("../../dist/tools/killTask.js");
+  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();
@@ -454,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 });

package/scripts/{mcp-manifest-check.js → checks/mcp-manifest-check.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync, rmSync } from "node:fs";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { CHATGPT_CORE_TOOL_NAMES, CHATGPT_DIRECT_TOOL_NAMES } from "../dist/tools/toolCatalog.js";
+import { CHATGPT_CORE_TOOL_NAMES, CHATGPT_DIRECT_TOOL_NAMES } from "../../dist/tools/toolCatalog.js";
 
-const root = resolve(fileURLToPath(new URL("..", import.meta.url)));
+const root = resolve(fileURLToPath(new URL("../..", import.meta.url)));
 const jsonOnly = process.argv.includes("--json");
 const profileIndex = process.argv.indexOf("--profile");
 const profile = profileIndex >= 0 ? process.argv[profileIndex + 1] : "chatgpt_core";
@@ -21,12 +21,32 @@ const transportEnv = {
   ...process.env,
   PATCHWARDEN_TOOL_PROFILE: profile,
 };
-if (process.env.PATCHWARDEN_CONFIG) {
-  transportEnv.PATCHWARDEN_CONFIG = process.env.PATCHWARDEN_CONFIG;
-} else if (existsSync(defaultConfigPath)) {
-  transportEnv.PATCHWARDEN_CONFIG = defaultConfigPath;
-} else {
-  delete transportEnv.PATCHWARDEN_CONFIG;
+
+// When checking chatgpt_direct profile, ensure enableDirectProfile is true
+// by creating a temporary config if needed.
+let tempConfigPath = null;
+if (profile === "chatgpt_direct") {
+  const baseConfig = existsSync(defaultConfigPath)
+    ? JSON.parse(readFileSync(defaultConfigPath, "utf-8"))
+    : {};
+  if (!baseConfig.enableDirectProfile) {
+    const { mkdtempSync, writeFileSync, rmSync } = await import("node:fs");
+    const { tmpdir } = await import("node:os");
+    const { join } = await import("node:path");
+    tempConfigPath = join(mkdtempSync(join(tmpdir(), "pw-direct-")), "config.json");
+    writeFileSync(tempConfigPath, JSON.stringify({ ...baseConfig, enableDirectProfile: true }, null, 2), "utf-8");
+    transportEnv.PATCHWARDEN_CONFIG = tempConfigPath;
+  }
+}
+
+if (!transportEnv.PATCHWARDEN_CONFIG) {
+  if (process.env.PATCHWARDEN_CONFIG) {
+    transportEnv.PATCHWARDEN_CONFIG = process.env.PATCHWARDEN_CONFIG;
+  } else if (existsSync(defaultConfigPath)) {
+    transportEnv.PATCHWARDEN_CONFIG = defaultConfigPath;
+  } else {
+    delete transportEnv.PATCHWARDEN_CONFIG;
+  }
 }
 
 const transport = new StdioClientTransport({
@@ -159,4 +179,7 @@ try {
   process.exitCode = 1;
 } finally {
   await client.close().catch(() => {});
+  if (tempConfigPath) {
+    try { rmSync(tempConfigPath, { force: true }); } catch {}
+  }
 }

package/scripts/{mcp-smoke.js → checks/mcp-smoke.js}

@@ -14,7 +14,9 @@ import { fileURLToPath } from "node:url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 
-const root = resolve(fileURLToPath(new URL("..", import.meta.url)));
+const root = resolve(fileURLToPath(new URL("../..", import.meta.url)));
+const packageJson = JSON.parse(readFileSync(join(root, "package.json"), "utf-8"));
+const expectedServerVersion = packageJson.version;
 const tempRoot = mkdtempSync(join(tmpdir(), "patchwarden-mcp-"));
 const workspaceRoot = join(tempRoot, "workspace");
 const configPath = join(tempRoot, "patchwarden.config.json");
@@ -126,8 +128,10 @@ try {
     "read_workspace_file",
     "retry_task",
     "run_verification",
+    "safe_status",
     "save_plan",
     "search_workspace",
+    "sync_file",
     "wait_for_task",
   ];
   if (JSON.stringify(names) !== JSON.stringify(expected)) {
@@ -139,7 +143,7 @@ try {
   if (!tools._meta || typeof tools._meta.tool_manifest_sha256 !== "string" || tools._meta.tool_manifest_sha256.length !== 64) {
     throw new Error(`tools/list _meta missing manifest hash: ${JSON.stringify(tools._meta || null)}`);
   }
-  if (tools._meta.tool_profile !== "full" || tools._meta.tool_count !== 28) {
+  if (tools._meta.tool_profile !== "full" || tools._meta.tool_count !== 30) {
     throw new Error(`tools/list _meta profile/count mismatch: ${JSON.stringify(tools._meta)}`);
   }
   if (typeof tools._meta.schema_epoch !== "string" || typeof tools._meta.server_version !== "string") {
@@ -210,7 +214,7 @@ try {
     test_command: "npm test",
   });
   if (
-    task.server_version !== "0.6.0" ||
+    task.server_version !== expectedServerVersion ||
     !/^[a-f0-9]{64}$/.test(task.tool_manifest_sha256 || "") ||
     task.next_tool_call?.name !== "wait_for_task" ||
     task.next_tool_call?.arguments?.timeout_seconds !== 25
@@ -389,7 +393,7 @@ try {
   await disabledClient.close();
   ok("chatgpt_direct disabled exposes only health_check with diagnostic");
 
-  // 2. chatgpt_direct enabled: 9 tools + minimal create_direct_session
+  // 2. chatgpt_direct enabled: 10 tools + minimal create_direct_session
   const enabledConfigPath = join(tempRoot, "direct-enabled.json");
   const directRepo = join(workspaceRoot, "direct-fixture");
   mkdirSync(join(directRepo, "src"), { recursive: true });
@@ -447,12 +451,13 @@ try {
     "read_workspace_file",
     "run_verification",
     "search_workspace",
+    "sync_file",
   ];
   if (JSON.stringify(enabledNames) !== JSON.stringify(expectedDirect)) {
     throw new Error(`chatgpt_direct enabled tools mismatch: ${enabledNames.join(", ")}`);
   }
-  if (enabledTools._meta.tool_count !== 9) {
-    throw new Error(`chatgpt_direct enabled tool_count should be 9, got ${enabledTools._meta.tool_count}`);
+  if (enabledTools._meta.tool_count !== 10) {
+    throw new Error(`chatgpt_direct enabled tool_count should be 10, got ${enabledTools._meta.tool_count}`);
   }
 
   // Minimal create_direct_session
@@ -472,12 +477,12 @@ try {
   if (enabledHealth.direct_profile_enabled !== true) {
     throw new Error(`direct_profile_enabled should be true, got ${enabledHealth.direct_profile_enabled}`);
   }
-  if (enabledHealth.direct_tool_count !== 9) {
-    throw new Error(`direct_tool_count should be 9, got ${enabledHealth.direct_tool_count}`);
+  if (enabledHealth.direct_tool_count !== 10) {
+    throw new Error(`direct_tool_count should be 10, got ${enabledHealth.direct_tool_count}`);
   }
 
   await enabledClient.close();
-  ok("chatgpt_direct enabled exposes 9 tools and create_direct_session works");
+  ok("chatgpt_direct enabled exposes 10 tools and create_direct_session works");
 } catch (error) {
   fail("MCP smoke test", error);
 } finally {

package/scripts/{package-manifest-check.js → checks/package-manifest-check.js}

@@ -45,7 +45,8 @@ if (leaked.length > 0) {
 
 const required = [
   "PatchWarden.cmd",
-  "scripts/manage-patchwarden.ps1",
+  "PatchWarden-Desktop.cmd",
+  "scripts/control/manage-patchwarden.ps1",
   "scripts/launchers/Start-PatchWarden-Tunnel.cmd",
   "scripts/launchers/Start-PatchWarden-Direct-Tunnel.cmd",
 ];

package/scripts/{tunnel-supervisor-smoke.js → checks/tunnel-supervisor-smoke.js}

@@ -10,7 +10,7 @@ if (process.platform !== "win32") {
   process.exit(0);
 }
 
-const root = resolve(fileURLToPath(new URL("..", import.meta.url)));
+const root = resolve(fileURLToPath(new URL("../..", import.meta.url)));
 const temp = mkdtempSync(join(tmpdir(), "patchwarden-tunnel-smoke-"));
 const mockJs = join(temp, "mock-tunnel-client.js");
 const mockCmd = join(temp, "mock-tunnel-client.cmd");
@@ -57,7 +57,7 @@ if(command==='run'){
     MOCK_TUNNEL_STATE: stateFile,
   };
   const result = spawnSync("powershell.exe", [
-    "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", join(root, "scripts", "start-patchwarden-tunnel.ps1"),
+    "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", join(root, "scripts", "control", "start-patchwarden-tunnel.ps1"),
     "-TunnelId", "tunnel_smoke_fixture",
     "-TunnelClientExe", mockCmd,
     "-ConfigPath", mockConfig,