patchwarden 0.4.0

package/scripts/lifecycle-smoke.js

@@ -0,0 +1,453 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+
+const tempRoot = mkdtempSync(join(tmpdir(), "patchwarden-lifecycle-"));
+const workspaceRoot = join(tempRoot, "workspace");
+const repoPath = join(workspaceRoot, "repo");
+const plainRepoPath = join(workspaceRoot, "plain-repo");
+const configPath = join(tempRoot, "patchwarden.config.json");
+let passed = 0;
+let failed = 0;
+
+function ok(name) {
+  console.log(`  ok - ${name}`);
+  passed++;
+}
+
+function fail(name, error) {
+  console.error(`  not ok - ${name}: ${error instanceof Error ? error.message : String(error)}`);
+  failed++;
+}
+
+async function test(name, fn) {
+  try {
+    await fn();
+    ok(name);
+  } catch (error) {
+    fail(name, error);
+  }
+}
+
+function git(args) {
+  const result = spawnSync("git", args, { cwd: repoPath, encoding: "utf-8" });
+  if (result.status !== 0) throw new Error(`git ${args.join(" ")} failed: ${result.stderr}`);
+}
+
+async function waitForRunning(getTaskStatus, taskId) {
+  for (let attempt = 0; attempt < 50; attempt++) {
+    const status = getTaskStatus(taskId);
+    if (status.status === "running") return status;
+    await sleep(100);
+  }
+  throw new Error(`Task ${taskId} did not enter running state`);
+}
+
+console.log("\n=== PatchWarden Lifecycle Smoke Tests ===\n");
+
+try {
+  mkdirSync(repoPath, { recursive: true });
+  mkdirSync(join(workspaceRoot, ".patchwarden"), { recursive: true });
+  writeFileSync(join(workspaceRoot, ".patchwarden", "watcher-heartbeat.json"), JSON.stringify({
+    status: "running",
+    pid: process.pid,
+    instance_id: "lifecycle-smoke-watcher",
+    launcher_pid: process.pid,
+    started_at: new Date().toISOString(),
+    last_heartbeat_at: new Date().toISOString(),
+  }), "utf-8");
+  writeFileSync(join(repoPath, "README.md"), "# Lifecycle fixture\n", "utf-8");
+  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");
+  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(["-c", "user.name=PatchWarden Test", "-c", "user.email=test@example.invalid", "commit", "-m", "fixture"]);
+
+  writeFileSync(
+    configPath,
+    JSON.stringify({
+      workspaceRoot,
+      plansDir: ".patchwarden/plans",
+      tasksDir: ".patchwarden/tasks",
+      agents: {
+        writer: {
+          command: process.execPath,
+          args: [
+            "-e",
+            "const fs=require('fs');fs.appendFileSync('README.md','task change\\n');fs.writeFileSync('new-file.txt','new file\\n')",
+          ],
+        },
+        slow: {
+          command: process.execPath,
+          args: ["-e", "setTimeout(()=>console.log('finished'),30000)"],
+        },
+        scopebreaker: {
+          command: process.execPath,
+          args: ["-e", "require('fs').writeFileSync('../outside-scope.txt','unexpected\\n')"],
+        },
+        noop: {
+          command: process.execPath,
+          args: ["-e", "console.log('no changes')"],
+        },
+        largewriter: {
+          command: process.execPath,
+          args: ["-e", "require('fs').writeFileSync('large.txt','x'.repeat(260000)+'\\n')"],
+        },
+        deleter: {
+          command: process.execPath,
+          args: ["-e", "require('fs').unlinkSync('delete-me.txt')"],
+        },
+        binarywriter: {
+          command: process.execPath,
+          args: ["-e", "require('fs').writeFileSync('fixture.bin',Buffer.from([0,1,2,3,255,0,10]))"],
+        },
+      },
+      allowedTestCommands: ["node --check main.js", "node --check second.js", "node --check missing.js"],
+      maxReadFileBytes: 200000,
+      defaultTaskTimeoutSeconds: 10,
+      maxTaskTimeoutSeconds: 60,
+      watcherStaleSeconds: 3600,
+    }, null, 2),
+    "utf-8"
+  );
+  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 { 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)) {
+      throw new Error(`Unexpected agent availability: ${JSON.stringify(result)}`);
+    }
+  });
+
+  await test("git diff captures tracked and untracked task changes", async () => {
+    writeFileSync(join(repoPath, "preexisting-user-file.txt"), "preexisting and untouched\n", "utf-8");
+    const plan = savePlan({ title: "Change capture", content: "Modify fixture files." });
+    const task = createTask({
+      plan_id: plan.plan_id,
+      agent: "writer",
+      repo_path: "repo",
+      verify_commands: ["node --check main.js", "node --check second.js"],
+    });
+    const result = await runTask(task.task_id);
+    if (result.status !== "done") throw new Error(`Writer task ended ${result.status}: ${result.error}`);
+    const status = getTaskStatus(task.task_id);
+    const changed = status.changed_files || [];
+    if (!changed.some((file) => file.path === "README.md" && file.change === "modified")) {
+      throw new Error(`README.md modification missing: ${JSON.stringify(changed)}`);
+    }
+    if (!changed.some((file) => file.path === "new-file.txt" && file.change === "added")) {
+      throw new Error(`new-file.txt addition missing: ${JSON.stringify(changed)}`);
+    }
+    const diff = getDiff(task.task_id);
+    if (diff.patch_mode !== "textual" || diff.unavailable_reason !== null) {
+      throw new Error(`Expected textual Git patch: ${JSON.stringify(diff)}`);
+    }
+    if (!diff.content.includes("README.md") || !diff.content.includes("new-file.txt")) {
+      throw new Error("git.diff did not include both tracked and untracked evidence");
+    }
+    if (diff.content.includes("preexisting-user-file.txt")) {
+      throw new Error("Task diff included an unchanged pre-existing user file");
+    }
+    if (!status.diff_available) throw new Error("diff_available should be true");
+    if (!diff.file_stats?.some((file) => file.path === "new-file.txt" && file.status === "added" && file.additions > 0)) {
+      throw new Error(`Missing added file stats: ${JSON.stringify(diff.file_stats)}`);
+    }
+    for (const artifact of ["result.json", "verify.json", "verify.log", "diff.patch", "file-stats.json"]) {
+      if (!existsSync(join(task.path, artifact))) throw new Error(`${artifact} missing`);
+    }
+    const summary = getTaskSummary(task.task_id);
+    if (summary.verify_status !== "passed" || summary.verify_commands.length !== 2 || summary.acceptance_status !== "ready_for_review") {
+      throw new Error(`Unexpected summary: ${JSON.stringify(summary)}`);
+    }
+    const structured = JSON.parse(readFileSync(join(task.path, "result.json"), "utf-8"));
+    if (structured.verify_status !== "passed" || !Array.isArray(structured.errors) || !Array.isArray(structured.commands_observed)) {
+      throw new Error(`result.json contract mismatch: ${JSON.stringify(structured)}`);
+    }
+    for (const artifact of ["result.json", "diff.patch", "git.diff", "test.log"]) {
+      rmSync(join(task.path, artifact), { force: true });
+    }
+    const degraded = getTaskSummary(task.task_id);
+    if (degraded.result_json_available || degraded.diff_available || degraded.test_log_available) {
+      throw new Error(`Missing artifacts were not exposed: ${JSON.stringify(degraded)}`);
+    }
+    if (!degraded.warnings.some((warning) => warning.includes("result.json is missing")) ||
+        !degraded.warnings.some((warning) => warning.includes("diff.patch is missing")) ||
+        !degraded.warnings.some((warning) => warning.includes("test.log is missing"))) {
+      throw new Error(`Missing artifact warnings incomplete: ${JSON.stringify(degraded.warnings)}`);
+    }
+  });
+
+  await test("inspect_only template fails when the agent changes repository files", async () => {
+    const task = createTask({
+      template: "inspect_only",
+      goal: "Inspect the fixture without modifying files",
+      agent: "writer",
+      repo_path: "repo",
+    });
+    const result = await runTask(task.task_id);
+    if (result.status !== "failed_policy_violation") {
+      throw new Error(`Expected failed_policy_violation: ${JSON.stringify(result)}`);
+    }
+    const summary = getTaskSummary(task.task_id);
+    if (summary.change_policy !== "no_changes" || summary.suggested_next_action !== "review_unexpected_changes") {
+      throw new Error(`Unexpected policy summary: ${JSON.stringify(summary)}`);
+    }
+  });
+
+  await test("legacy test_command becomes one independent verification command", async () => {
+    const plan = savePlan({ title: "Legacy verification", content: "No changes." });
+    const task = createTask({
+      plan_id: plan.plan_id,
+      agent: "noop",
+      repo_path: "repo",
+      test_command: "node --check main.js",
+    });
+    const result = await runTask(task.task_id);
+    const verify = JSON.parse(readFileSync(join(task.path, "verify.json"), "utf-8"));
+    if (result.status !== "done" || verify.status !== "passed" || verify.commands.length !== 1) {
+      throw new Error(`Legacy verification mismatch: ${JSON.stringify({ result, verify })}`);
+    }
+    if (verify.commands[0].cwd !== repoPath || !("stdout_tail" in verify.commands[0]) || !("stderr_tail" in verify.commands[0])) {
+      throw new Error(`Verification command evidence incomplete: ${JSON.stringify(verify.commands[0])}`);
+    }
+  });
+
+  await test("no-change task returns an explicit empty diff result", async () => {
+    const plan = savePlan({ title: "No diff", content: "Do not change files." });
+    const task = createTask({ plan_id: plan.plan_id, agent: "noop", repo_path: "repo" });
+    const result = await runTask(task.task_id);
+    if (result.status !== "done") throw new Error(`No-op task failed: ${JSON.stringify(result)}`);
+    const diff = getDiff(task.task_id);
+    const verify = JSON.parse(readFileSync(join(task.path, "verify.json"), "utf-8"));
+    if (verify.status !== "skipped") throw new Error(`Expected skipped verification: ${JSON.stringify(verify)}`);
+    if (diff.diff_available !== false || diff.changed_files?.length !== 0 || diff.message !== "No task file changes detected") {
+      throw new Error(`No-diff response unclear: ${JSON.stringify(diff)}`);
+    }
+    if (diff.patch_mode !== "no_changes" || diff.unavailable_reason !== null) {
+      throw new Error(`Expected explicit no_changes patch mode: ${JSON.stringify(diff)}`);
+    }
+    rmSync(join(task.path, "result.json"), { force: true });
+    const fallback = getTaskSummary(task.task_id);
+    if (!fallback.terminal || fallback.result_json_available || !fallback.summary) {
+      throw new Error(`Summary fallback failed: ${JSON.stringify(fallback)}`);
+    }
+  });
+
+  await test("large diff response is truncated while diff.patch remains complete", async () => {
+    const plan = savePlan({ title: "Large diff", content: "Create a large text file." });
+    const task = createTask({ plan_id: plan.plan_id, agent: "largewriter", repo_path: "repo" });
+    const result = await runTask(task.task_id);
+    if (result.status !== "done") throw new Error(`Large task failed: ${JSON.stringify(result)}`);
+    const diff = getDiff(task.task_id);
+    const patchSize = readFileSync(join(task.path, "diff.patch"), "utf-8").length;
+    if (!diff.truncated || !diff.patch_head || !diff.diff_patch_path || patchSize <= diff.content.length) {
+      throw new Error(`Large diff contract mismatch: ${JSON.stringify({ diff, patchSize })}`);
+    }
+  });
+
+  await test("non-Git repositories return hash-only evidence with a reason", async () => {
+    const plan = savePlan({ title: "Non-Git evidence", content: "Modify files in a non-Git repository." });
+    const task = createTask({ plan_id: plan.plan_id, agent: "writer", repo_path: "plain-repo" });
+    const result = await runTask(task.task_id);
+    if (result.status !== "done") throw new Error(`Non-Git task failed: ${JSON.stringify(result)}`);
+    const diff = getDiff(task.task_id);
+    if (
+      diff.patch_mode !== "hash_only" ||
+      !diff.unavailable_reason?.includes("not a Git worktree") ||
+      !diff.changed_files?.some((file) => file.path === "README.md")
+    ) {
+      throw new Error(`Non-Git diff evidence mismatch: ${JSON.stringify(diff)}`);
+    }
+  });
+
+  await test("binary Git changes remain reviewable as a textual Git binary patch", async () => {
+    const plan = savePlan({ title: "Binary evidence", content: "Create a binary fixture." });
+    const task = createTask({ plan_id: plan.plan_id, agent: "binarywriter", repo_path: "repo" });
+    const result = await runTask(task.task_id);
+    if (result.status !== "done") throw new Error(`Binary task failed: ${JSON.stringify(result)}`);
+    const diff = getDiff(task.task_id);
+    if (diff.patch_mode !== "textual" || !diff.content.includes("GIT binary patch")) {
+      throw new Error(`Binary patch evidence mismatch: ${JSON.stringify(diff)}`);
+    }
+  });
+
+  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" });
+    const result = await runTask(task.task_id);
+    if (result.status !== "done") throw new Error(`Delete task failed: ${JSON.stringify(result)}`);
+    const diff = getDiff(task.task_id);
+    if (!diff.file_stats?.some((file) => file.path === "delete-me.txt" && file.status === "deleted")) {
+      throw new Error(`Deleted file stats missing: ${JSON.stringify(diff.file_stats)}`);
+    }
+  });
+
+  await test("wait_for_task stays in the tool loop and returns terminal acceptance", async () => {
+    const plan = savePlan({ title: "Wait loop", content: "Finish normally." });
+    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;
+    if (!waited.terminal || waited.continuation_required || !waited.summary) {
+      throw new Error(`Unexpected wait response: ${JSON.stringify(waited)}`);
+    }
+  });
+
+  await test("wait_for_task explicitly requires another call when the task is not terminal", async () => {
+    const plan = savePlan({ title: "Pending wait", content: "Remain queued for this check." });
+    const task = createTask({ plan_id: plan.plan_id, agent: "slow", repo_path: "repo" });
+    const waited = await waitForTask(task.task_id, 1);
+    if (waited.terminal || !waited.timed_out || !waited.continuation_required) {
+      throw new Error(`Expected continuation response: ${JSON.stringify(waited)}`);
+    }
+    cancelTask(task.task_id);
+  });
+
+  await test("running task summary includes heartbeat, phase, command, and elapsed time", async () => {
+    const plan = savePlan({ title: "Running summary", content: "Wait." });
+    const task = createTask({ plan_id: plan.plan_id, agent: "slow", repo_path: "repo", timeout_seconds: 30 });
+    const running = runTask(task.task_id);
+    await waitForRunning(getTaskStatus, task.task_id);
+    await sleep(50);
+    const summary = getTaskSummary(task.task_id);
+    if (summary.terminal || !summary.last_heartbeat_at || !summary.phase || !summary.current_command || summary.elapsed_ms < 0) {
+      throw new Error(`Running summary incomplete: ${JSON.stringify(summary)}`);
+    }
+    cancelTask(task.task_id);
+    await running;
+  });
+
+  await test("verification failure produces failed_verification and structured evidence", async () => {
+    const plan = savePlan({ title: "Verify failure", content: "Finish normally." });
+    const task = createTask({
+      plan_id: plan.plan_id,
+      agent: "writer",
+      repo_path: "repo",
+      verify_commands: ["node --check missing.js"],
+    });
+    const result = await runTask(task.task_id);
+    if (result.status !== "failed_verification") throw new Error(`Unexpected result: ${JSON.stringify(result)}`);
+    const verify = JSON.parse(readFileSync(join(task.path, "verify.json"), "utf-8"));
+    if (verify.status !== "failed" || verify.commands?.[0]?.exit_code === 0) {
+      throw new Error(`Verification evidence mismatch: ${JSON.stringify(verify)}`);
+    }
+    const resultMd = readFileSync(join(task.path, "result.md"), "utf-8");
+    const resultJson = JSON.parse(readFileSync(join(task.path, "result.json"), "utf-8"));
+    if (!resultMd.includes("node --check missing.js") || !resultJson.summary.includes("node --check missing.js")) {
+      throw new Error("Failed verification command missing from result artifacts");
+    }
+    const summary = getTaskSummary(task.task_id);
+    if (
+      resultJson.failed_command !== "node --check missing.js" ||
+      resultJson.suggested_next_action !== "create_followup_task" ||
+      !resultJson.safe_followup_prompt?.includes("Do not change unrelated files") ||
+      summary.suggested_next_action !== "create_followup_task"
+    ) {
+      throw new Error(`Failure follow-up evidence missing: ${JSON.stringify(resultJson)}`);
+    }
+  });
+
+  await test("out-of-scope workspace changes fail the task and generate a rollback plan", async () => {
+    const plan = savePlan({ title: "Scope violation", content: "Do not leave the repository." });
+    const task = createTask({
+      plan_id: plan.plan_id,
+      agent: "scopebreaker",
+      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(`Unexpected result: ${JSON.stringify(result)}`);
+    const structured = JSON.parse(readFileSync(join(task.path, "result.json"), "utf-8"));
+    if (!structured.out_of_scope_changes?.some((file) => file.path === "outside-scope.txt")) {
+      throw new Error(`Missing scope evidence: ${JSON.stringify(structured.out_of_scope_changes)}`);
+    }
+    if (structured.verify_status !== "failed") throw new Error(`Scope violation verify status must fail: ${structured.verify_status}`);
+    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("outside-scope.txt") || rollback.includes("README.md") || rollback.includes("new-file.txt")) {
+      throw new Error(`Rollback plan contains wrong files: ${rollback}`);
+    }
+    const summary = getTaskSummary(task.task_id);
+    if (summary.verify_status !== "failed" || summary.out_of_scope_changes.length === 0 || summary.acceptance_status !== "failed") {
+      throw new Error(`Scope summary mismatch: ${JSON.stringify(summary)}`);
+    }
+  });
+
+  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 });
+    const started = Date.now();
+    const result = await runTask(task.task_id);
+    if (result.status !== "failed" || !result.error?.includes("timed out")) {
+      throw new Error(`Expected timeout failure, got ${JSON.stringify(result)}`);
+    }
+    if (Date.now() - started > 10000) throw new Error("Timeout took too long to stop the process");
+    const status = getTaskStatus(task.task_id);
+    if (status.phase !== "failed" || !status.last_heartbeat_at) {
+      throw new Error(`Missing timeout phase/heartbeat: ${JSON.stringify(status)}`);
+    }
+    if (!existsSync(join(task.path, "progress.md"))) throw new Error("progress.md missing");
+  });
+
+  await test("cancel_task safely stops a running agent", async () => {
+    const plan = savePlan({ title: "Cancel", content: "Wait." });
+    const task = createTask({ plan_id: plan.plan_id, agent: "slow", repo_path: "repo", timeout_seconds: 30 });
+    const running = runTask(task.task_id);
+    await waitForRunning(getTaskStatus, task.task_id);
+    const request = cancelTask(task.task_id);
+    if (!request.cancel_requested || request.force_kill_requested) {
+      throw new Error(`Unexpected cancel response: ${JSON.stringify(request)}`);
+    }
+    const result = await running;
+    if (result.status !== "canceled") throw new Error(`Expected canceled, got ${JSON.stringify(result)}`);
+  });
+
+  await test("kill_task immediately stops a running agent", async () => {
+    const plan = savePlan({ title: "Kill", content: "Wait." });
+    const task = createTask({ plan_id: plan.plan_id, agent: "slow", repo_path: "repo", timeout_seconds: 30 });
+    const running = runTask(task.task_id);
+    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;
+    if (result.status !== "canceled" || !result.error?.includes("kill_task")) {
+      throw new Error(`Expected killed/canceled result, got ${JSON.stringify(result)}`);
+    }
+  });
+} catch (error) {
+  fail("lifecycle smoke setup", error);
+} finally {
+  try { rmSync(tempRoot, { recursive: true, force: true }); } catch {}
+}
+
+console.log(`\n${"=".repeat(50)}`);
+console.log(`${passed} passed, ${failed} failed, ${passed + failed} total`);
+console.log(`${"=".repeat(50)}\n`);
+
+if (failed > 0) process.exit(1);
+console.log("ALL LIFECYCLE TESTS PASSED\n");

package/scripts/mcp-manifest-check.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+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 } from "../dist/tools/toolCatalog.js";
+
+const root = resolve(fileURLToPath(new URL("..", import.meta.url)));
+const jsonOnly = process.argv.includes("--json");
+const expectedTools = [...CHATGPT_CORE_TOOL_NAMES];
+
+const transport = process.platform === "win32"
+  ? new StdioClientTransport({
+      command: "cmd.exe",
+      args: ["/d", "/c", resolve(root, "scripts", "patchwarden-mcp-stdio.cmd")],
+      cwd: root,
+      stderr: "pipe",
+    })
+  : new StdioClientTransport({
+      command: process.execPath,
+      args: [resolve(root, "dist", "index.js")],
+      cwd: root,
+      env: {
+        ...process.env,
+        PATCHWARDEN_CONFIG: resolve(root, "patchwarden.config.json"),
+        PATCHWARDEN_TOOL_PROFILE: "chatgpt_core",
+      },
+      stderr: "pipe",
+    });
+
+const client = new Client(
+  { name: "patchwarden-manifest-check", version: "0.4.0" },
+  { capabilities: {} }
+);
+
+try {
+  await client.connect(transport);
+  const listed = await client.listTools();
+  const names = listed.tools.map((tool) => tool.name);
+  if (JSON.stringify(names) !== JSON.stringify(expectedTools)) {
+    throw new Error(`chatgpt_core tool list mismatch. Expected ${expectedTools.join(", ")}; got ${names.join(", ")}`);
+  }
+  // Layer 2: tools/list must carry _meta with manifest hash for catalog sync
+  if (!listed._meta || listed._meta.tool_profile !== "chatgpt_core" || listed._meta.tool_count !== expectedTools.length) {
+    throw new Error(`tools/list _meta missing or wrong profile/count: ${JSON.stringify(listed._meta || null)}`);
+  }
+  if (typeof listed._meta.tool_manifest_sha256 !== "string" || listed._meta.tool_manifest_sha256.length !== 64) {
+    throw new Error(`tools/list _meta manifest hash invalid: ${JSON.stringify(listed._meta)}`);
+  }
+  if (typeof listed._meta.schema_epoch !== "string" || typeof listed._meta.server_version !== "string") {
+    throw new Error(`tools/list _meta missing schema_epoch/server_version: ${JSON.stringify(listed._meta)}`);
+  }
+  const createTask = listed.tools.find((tool) => tool.name === "create_task");
+  const createProperties = Object.keys(createTask?.inputSchema?.properties || {});
+  for (const requiredProperty of ["inline_plan", "verify_commands"]) {
+    if (!createProperties.includes(requiredProperty)) {
+      throw new Error(`create_task schema is missing ${requiredProperty}`);
+    }
+  }
+  const waitTool = listed.tools.find((tool) => tool.name === "wait_for_task");
+  const waitProperties = Object.keys(waitTool?.inputSchema?.properties || {});
+  if (!waitProperties.includes("timeout_seconds") || !waitProperties.includes("wait_seconds")) {
+    throw new Error("wait_for_task schema must expose timeout_seconds and wait_seconds");
+  }
+  const healthProperties = Object.keys(listed.tools.find((tool) => tool.name === "health_check")?.inputSchema?.properties || {});
+  if (!healthProperties.includes("detail")) throw new Error("health_check schema must expose detail");
+  const listTaskProperties = Object.keys(listed.tools.find((tool) => tool.name === "list_tasks")?.inputSchema?.properties || {});
+  if (!listTaskProperties.includes("repo_path") || !listTaskProperties.includes("active_only")) {
+    throw new Error("list_tasks schema must expose repo_path and active_only");
+  }
+  const healthResult = await client.callTool({ name: "health_check", arguments: {} });
+  if (healthResult.isError) throw new Error(String(healthResult.content?.[0]?.text || "health_check failed"));
+  const health = JSON.parse(String(healthResult.content?.[0]?.text || "{}"));
+  if (
+    health.tool_profile !== "chatgpt_core" ||
+    health.tool_count !== expectedTools.length ||
+    !health.tool_manifest_sha256
+  ) {
+    throw new Error(`health_check catalog mismatch: ${JSON.stringify(health)}`);
+  }
+  const hiddenResult = await client.callTool({ name: "get_plan", arguments: { plan_id: "stale-client-probe" } });
+  const hiddenPayload = JSON.parse(String(hiddenResult.content?.[0]?.text || "{}"));
+  if (
+    !hiddenResult.isError ||
+    hiddenPayload.reason !== "tool_catalog_mismatch" ||
+    hiddenPayload.refresh_required !== true ||
+    hiddenPayload.tool_manifest_sha256 !== health.tool_manifest_sha256
+  ) {
+    throw new Error(`hidden tool mismatch guidance is incomplete: ${JSON.stringify(hiddenPayload)}`);
+  }
+  // Layer 3: mismatch error must carry next_tool_call and connector_refresh_steps for self-healing
+  if (hiddenPayload.next_tool_call?.name !== "health_check" || hiddenPayload.next_tool_call?.arguments?.detail !== "self_diagnostic") {
+    throw new Error(`mismatch next_tool_call missing or wrong: ${JSON.stringify(hiddenPayload.next_tool_call || null)}`);
+  }
+  if (!Array.isArray(hiddenPayload.connector_refresh_steps) || hiddenPayload.connector_refresh_steps.length < 3) {
+    throw new Error(`mismatch connector_refresh_steps missing or too short: ${JSON.stringify(hiddenPayload.connector_refresh_steps || null)}`);
+  }
+  const output = {
+    ok: true,
+    server_version: health.server_version,
+    schema_epoch: health.schema_epoch,
+    tool_profile: health.tool_profile,
+    tool_count: health.tool_count,
+    tool_names: health.tool_names,
+    tool_manifest_sha256: health.tool_manifest_sha256,
+    required_schema: {
+      create_task: ["inline_plan", "verify_commands"],
+      wait_for_task: ["timeout_seconds", "wait_seconds"],
+      health_check: ["detail"],
+      list_tasks: ["repo_path", "active_only"],
+    },
+  };
+  console.log(jsonOnly ? JSON.stringify(output) : JSON.stringify(output, null, 2));
+} catch (error) {
+  const failure = { ok: false, error: error instanceof Error ? error.message : String(error) };
+  console.error(jsonOnly ? JSON.stringify(failure) : JSON.stringify(failure, null, 2));
+  process.exitCode = 1;
+} finally {
+  await client.close().catch(() => {});
+}