patchwarden 0.6.4 → 1.5.0

package/dist/watcherStatus.js

@@ -157,7 +157,7 @@ export function derivePendingReason(task, watcher) {
             return "queued_but_watcher_unreadable";
         return "queued_waiting_for_watcher";
     }
-    if (task.status !== "running")
+    if (task.status !== "running" && task.status !== "collecting_artifacts")
         return null;
     if (task.phase === "executing_agent")
         return "agent_running";
@@ -167,3 +167,94 @@ export function derivePendingReason(task, watcher) {
         return "collecting_artifacts";
     return "preparing";
 }
+// ── v0.7.0: Watcher ownership helpers ─────────────────────────────
+/**
+ * Read the current watcher's instance_id from the heartbeat file.
+ * Returns null when the heartbeat is missing or unreadable.
+ *
+ * This is the source of truth for "which watcher is currently alive".
+ * Tasks whose runtime.watcher_instance_id differs from this value are
+ * considered orphaned by the diagnosis layer.
+ */
+export function readWatcherInstanceId(config = getConfig()) {
+    const heartbeatPath = getWatcherHeartbeatPath(config);
+    if (!existsSync(heartbeatPath))
+        return null;
+    try {
+        const raw = readFileSync(heartbeatPath, "utf-8");
+        const data = JSON.parse(raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw);
+        return typeof data.instance_id === "string" ? data.instance_id : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * v0.7.0: Determine whether the current watcher still owns a task.
+ *
+ * Ownership is established by comparing the watcher_instance_id recorded in
+ * the task's runtime.json with the instance_id of the currently alive
+ * watcher. A task is considered "owned" only when:
+ *   - the current watcher heartbeat is healthy, AND
+ *   - the task runtime recorded a watcher_instance_id, AND
+ *   - both instance IDs match.
+ *
+ * If the task has no recorded watcher_instance_id (legacy tasks created
+ * before v0.7.0), ownership cannot be confirmed and this returns false.
+ * The diagnosis layer treats "no owner" as a stale signal, not as active.
+ */
+export function isWatcherOwningTask(taskDir, config = getConfig()) {
+    const runtimePath = join(taskDir, "runtime.json");
+    let taskWatcherInstanceId = null;
+    if (existsSync(runtimePath)) {
+        try {
+            const runtime = JSON.parse(readFileSync(runtimePath, "utf-8"));
+            if (typeof runtime.watcher_instance_id === "string") {
+                taskWatcherInstanceId = runtime.watcher_instance_id;
+            }
+        }
+        catch {
+            // corrupted runtime — treat as no record
+        }
+    }
+    if (!taskWatcherInstanceId) {
+        return {
+            owned: false,
+            reason: "no_runtime_record",
+            task_watcher_instance_id: null,
+            current_watcher_instance_id: null,
+        };
+    }
+    const watcher = readWatcherStatus(config);
+    if (watcher.status !== "healthy") {
+        return {
+            owned: false,
+            reason: watcher.status === "missing" ? "watcher_missing" : "watcher_unhealthy",
+            task_watcher_instance_id: taskWatcherInstanceId,
+            current_watcher_instance_id: watcher.instance_id,
+        };
+    }
+    const currentInstanceId = watcher.instance_id;
+    if (!currentInstanceId) {
+        return {
+            owned: false,
+            reason: "watcher_missing",
+            task_watcher_instance_id: taskWatcherInstanceId,
+            current_watcher_instance_id: null,
+        };
+    }
+    if (currentInstanceId !== taskWatcherInstanceId) {
+        return {
+            owned: false,
+            reason: "instance_mismatch",
+            task_watcher_instance_id: taskWatcherInstanceId,
+            current_watcher_instance_id: currentInstanceId,
+        };
+    }
+    return {
+        owned: true,
+        reason: "owned",
+        task_watcher_instance_id: taskWatcherInstanceId,
+        current_watcher_instance_id: currentInstanceId,
+    };
+}

package/docs/chatgpt-usage.md

@@ -92,6 +92,37 @@ safety boundaries and complete evidence.
 7. Changes remain uncommitted for review; commit, push, and publish are outside
    the ordinary task scope.
 
+For routine guarded work, `run_task_loop` can perform the assess-only preflight,
+task creation, waiting, safe summary review, audit, and bounded `fix_tests`
+follow-up cycle in one tool call. It still uses the existing Watcher and
+allow-listed verification commands, stops at local confirmation boundaries, and
+returns a `lineage_id` for `get_task_lineage` instead of full logs or diffs.
+
+For v1.4 Direct-assisted verification, set `direct_verify=true` only when the
+local Direct profile is enabled and the desired Direct verification commands are
+already allow-listed. The loop creates a Direct session after the normal task
+and audit have succeeded, runs verification, safe-finalizes, safe-audits, and
+stores bounded Direct evidence in lineage. It does not call Direct patching
+tools, publish, push, tag, create releases, or restart live services.
+
+For v1.5 isolated loop work, set `agent="auto"` when you want PatchWarden to
+pick from configured local agents using bounded routing, and set
+`isolation_mode="worktree"` only when the target repo is a git repository and
+you want the task to run in an isolated worktree. Worktree mode records evidence
+in lineage but never auto-merges or auto-deletes the worktree. After a loop
+finishes, call `export_task_evidence_pack(lineage_id)` to write bounded
+`evidence.json` and `EVIDENCE.md` files without stdout/stderr tails, full diffs,
+verification logs, or sensitive file content.
+
+For v1.3 policy-aware work, call `get_project_policy` before release-oriented
+changes. It reads the bounded effective `.patchwarden/project-policy.json`
+summary and release readiness without granting new command permissions. Release
+mode tools are full-profile only: `release_check` wraps the existing release
+gate, `release_prepare` runs only already allow-listed local commands,
+`release_verify` performs read-only npm/GitHub/CI checks, and `release_cleanup`
+defaults to dry run. None of these tools publish, push, tag, create GitHub
+Releases, restart live tunnels/watchers, or return full logs/diffs.
+
 `needs_confirm` assessments must be confirmed locally with
 `patchwarden-confirm <full_assessment_id>`. The confirmation command is not an
 MCP tool. A `blocked` assessment cannot be confirmed.

package/docs/control-center/README.md

@@ -27,6 +27,15 @@ automation-friendly commands.
 
 ## Design Notes
 
+- v1.3 Dashboard panels show bounded task lineage, project policy, and release
+  readiness summaries. The backing APIs are read-only and do not expose full
+  stdout/stderr, full diffs, long logs, or secret-bearing files.
+- v1.4 extends the lineage panel with Direct-assisted verification status and
+  exposes a safe Direct session summary API without stdout/stderr tails or diffs.
+- v1.5 adds an Evidence Pack dashboard card plus read-only
+  `/api/evidence-packs` and `/api/evidence-packs/:lineage_id` routes. These
+  APIs return bounded lineage/policy/catalog evidence and omit stdout/stderr,
+  full diffs, verification logs, and sensitive file content.
 - `control-center-mvp.md`: first Web dashboard scope.
 - `control-center-phase2.md`: follow-up management and diagnostics scope.
 - `control-center-daily-driver.md`: current daily-use contract.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "patchwarden",
-  "version": "0.6.4",
-  "description": "A secure local MCP bridge: clients save plans, local agents execute tasks, and results are returned through workspace-scoped files.",
+  "version": "1.5.0",
+  "description": "Secure local MCP bridge for ChatGPT and local agents, with workspace-scoped task loops, safe summaries, audits, and Direct editing.",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -50,6 +50,7 @@
     "test:watcher-supervisor": "npm run build && node scripts/checks/watcher-supervisor-smoke.js",
     "check:tool-manifest": "npm run build && node scripts/checks/mcp-manifest-check.js",
     "check:direct-tool-manifest": "npm run build && node scripts/checks/mcp-manifest-check.js --profile chatgpt_direct",
+    "check:search-tool-manifest": "npm run build && node scripts/checks/mcp-manifest-check.js --profile chatgpt_search",
     "check:brand": "node scripts/checks/brand-check.js",
     "test:mcp": "npm run build && node scripts/checks/mcp-smoke.js",
     "test:http-mcp": "npm run build && node scripts/checks/http-mcp-smoke.js",

package/scripts/checks/control-center-smoke.js

@@ -229,6 +229,7 @@ async function testStaticFiles() {
     if (!rootCt.includes("text/html")) checks.push(`GET / -> Content-Type ${rootCt} (expected text/html)`);
     if (!root.body.includes("setup-checklist-card")) checks.push("dashboard missing setup checklist card");
     if (!root.body.includes("Show Core / Direct log tails")) checks.push("dashboard activity log is not collapsed behind a summary");
+    if (!root.body.includes("evidence-pack-card")) checks.push("dashboard missing v1.5 evidence pack card");
 
     if (vendor.status !== 200) checks.push(`GET /vendor/tailwindcss-browser.js -> status ${vendor.status}`);
     const vendorCt = vendor.headers["content-type"] || "";
@@ -667,6 +668,92 @@ async function testOtherGetApis() {
     problems.push(`/api/audit error: ${err.message}`);
   }
 
+  // /api/lineages
+  try {
+    const res = await httpGet(`${BASE_URL}/api/lineages`);
+    if (res.status !== 200) problems.push(`/api/lineages -> ${res.status} (expected 200)`);
+    else {
+      const json = tryJson(res.body);
+      if (!json || !Array.isArray(json.lineages) || typeof json.total !== "number") {
+        problems.push(`/api/lineages missing bounded lineage summary fields: ${res.body.slice(0, 120)}`);
+      }
+    }
+  } catch (err) {
+    problems.push(`/api/lineages error: ${err.message}`);
+  }
+
+  // /api/project-policy
+  try {
+    const res = await httpGet(`${BASE_URL}/api/project-policy?repo_path=.`);
+    if (res.status !== 200) problems.push(`/api/project-policy -> ${res.status} (expected 200)`);
+    else {
+      const json = tryJson(res.body);
+      if (!json || !("effective_policy" in json) || !Array.isArray(json.issues)) {
+        problems.push(`/api/project-policy missing policy summary fields: ${res.body.slice(0, 120)}`);
+      }
+      const text = res.body.toLowerCase();
+      if (text.includes("stdout") || text.includes("stderr") || text.includes("diff_patch")) {
+        problems.push("/api/project-policy leaked log/diff-shaped fields");
+      }
+    }
+  } catch (err) {
+    problems.push(`/api/project-policy error: ${err.message}`);
+  }
+
+  // /api/release/status
+  try {
+    const res = await httpGet(`${BASE_URL}/api/release/status?repo_path=.`);
+    if (res.status !== 200) problems.push(`/api/release/status -> ${res.status} (expected 200)`);
+    else {
+      const json = tryJson(res.body);
+      if (!json || !("release_readiness" in json) || json.remote_write_performed !== false) {
+        problems.push(`/api/release/status missing read-only release status fields: ${res.body.slice(0, 120)}`);
+      }
+      const text = res.body.toLowerCase();
+      if (text.includes("stdout") || text.includes("stderr") || text.includes("diff_patch")) {
+        problems.push("/api/release/status leaked log/diff-shaped fields");
+      }
+    }
+  } catch (err) {
+    problems.push(`/api/release/status error: ${err.message}`);
+  }
+
+  // /api/evidence-packs
+  try {
+    const res = await httpGet(`${BASE_URL}/api/evidence-packs`);
+    if (res.status !== 200) problems.push(`/api/evidence-packs -> ${res.status} (expected 200)`);
+    else {
+      const json = tryJson(res.body);
+      if (!json || !Array.isArray(json.evidence_packs) || typeof json.total !== "number") {
+        problems.push(`/api/evidence-packs missing bounded evidence summary fields: ${res.body.slice(0, 120)}`);
+      }
+      const text = res.body.toLowerCase();
+      if (text.includes("stdout_tail") || text.includes("stderr_tail") || text.includes("diff.patch") || text.includes("verification.log")) {
+        problems.push("/api/evidence-packs leaked log/diff-shaped fields");
+      }
+    }
+  } catch (err) {
+    problems.push(`/api/evidence-packs error: ${err.message}`);
+  }
+
+  // /api/direct-sessions/:id/summary (safe, bounded route; missing id is still non-leaky)
+  try {
+    const res = await httpGet(`${BASE_URL}/api/direct-sessions/direct_missing_summary/summary`);
+    if (res.status !== 200) problems.push(`/api/direct-sessions/:id/summary -> ${res.status} (expected 200)`);
+    else {
+      const json = tryJson(res.body);
+      if (!json || json.session_id !== "direct_missing_summary") {
+        problems.push(`/api/direct-sessions/:id/summary missing safe summary envelope: ${res.body.slice(0, 120)}`);
+      }
+      const text = res.body.toLowerCase();
+      if (text.includes("stdout_tail") || text.includes("stderr_tail") || text.includes("diff_patch") || text.includes("verification.log")) {
+        problems.push("/api/direct-sessions/:id/summary leaked log/diff-shaped fields");
+      }
+    }
+  } catch (err) {
+    problems.push(`/api/direct-sessions/:id/summary error: ${err.message}`);
+  }
+
   // /api/logs/core
   try {
     const res = await httpGet(`${BASE_URL}/api/logs/core`);

package/scripts/checks/control-smoke.js

@@ -76,7 +76,7 @@ try {
     ready: false,
     pid: null,
     tool_profile: "chatgpt_direct",
-    tool_count: 9,
+    tool_count: 14,
     tools_ready: true,
   }), "utf8");
   writeFileSync(join(directRuntime, "tunnel-client.pid"), String(fakeTunnel.pid), "utf8");
@@ -114,7 +114,7 @@ try {
     reason_code: "stale_fixture",
     last_error: "stale failure",
     tool_profile: "chatgpt_core",
-    tool_count: 16,
+    tool_count: 26,
     tools_ready: true,
   }), "utf8");
   healthServer = spawn(

package/scripts/checks/doctor-smoke.js

@@ -42,6 +42,7 @@ try {
     "[OK]   Task directory writable",
     "[OK]   Example task directory read/write",
     "[OK]   allowedTestCommands is non-empty",
+    "[OK]   Release gate module loadable",
   ];
   for (const line of requiredLines) {
     if (!result.stdout.includes(line)) throw new Error(`doctor output missing stable line: ${line}`);

package/scripts/checks/lifecycle-smoke.js

@@ -12,6 +12,10 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 
+// v0.7.2: tasks complete with "done_by_agent" (pending acceptance) instead of "done".
+// Both are valid successful completion statuses for lifecycle smoke tests.
+const isDoneStatus = (s) => s === "done" || s === "done_by_agent";
+
 const tempRoot = mkdtempSync(join(tmpdir(), "patchwarden-lifecycle-"));
 const workspaceRoot = join(tempRoot, "workspace");
 const repoPath = join(workspaceRoot, "repo");
@@ -178,7 +182,7 @@ try {
       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}`);
+    if (!isDoneStatus(result.status)) 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")) {
@@ -253,7 +257,7 @@ try {
     });
     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) {
+    if (!isDoneStatus(result.status) || 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])) {
@@ -265,7 +269,7 @@ try {
     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)}`);
+    if (!isDoneStatus(result.status)) 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)}`);
@@ -286,7 +290,7 @@ try {
     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)}`);
+    if (!isDoneStatus(result.status)) 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) {
@@ -298,7 +302,7 @@ try {
     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)}`);
+    if (!isDoneStatus(result.status)) throw new Error(`Non-Git task failed: ${JSON.stringify(result)}`);
     const diff = getDiff(task.task_id);
     if (
       diff.patch_mode !== "hash_only" ||
@@ -313,7 +317,7 @@ try {
     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)}`);
+    if (!isDoneStatus(result.status)) 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)}`);
@@ -324,7 +328,7 @@ try {
     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)}`);
+    if (!isDoneStatus(result.status)) 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 || {};
@@ -353,7 +357,7 @@ try {
     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)}`);
+    if (!isDoneStatus(result.status)) 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)}`);
@@ -504,7 +508,7 @@ try {
     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") {
+    if (!isDoneStatus(result.status)) {
       throw new Error(`Expected done, got: ${JSON.stringify(result)}`);
     }
     const structured = JSON.parse(readFileSync(join(task.path, "result.json"), "utf-8"));

package/scripts/checks/mcp-manifest-check.js

@@ -4,18 +4,20 @@ 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, CHATGPT_SEARCH_TOOL_NAMES } from "../../dist/tools/toolCatalog.js";
 
 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";
-if (profile !== "chatgpt_core" && profile !== "chatgpt_direct") {
+if (profile !== "chatgpt_core" && profile !== "chatgpt_direct" && profile !== "chatgpt_search") {
   throw new Error(`Unsupported manifest profile "${profile}".`);
 }
 const expectedTools = profile === "chatgpt_direct"
   ? [...CHATGPT_DIRECT_TOOL_NAMES]
-  : [...CHATGPT_CORE_TOOL_NAMES];
+  : profile === "chatgpt_search"
+    ? [...CHATGPT_SEARCH_TOOL_NAMES]
+    : [...CHATGPT_CORE_TOOL_NAMES];
 const defaultConfigPath = resolve(root, "patchwarden.config.json");
 const transportEnv = {
   ...process.env,
@@ -102,13 +104,37 @@ try {
     if (!summaryProperties.includes("view") || !summaryProperties.includes("max_items")) {
       throw new Error("get_task_summary schema must expose view and max_items");
     }
-  } else {
+    const safeRequirements = {
+      run_task_loop: ["repo_path", "goal", "verify_commands", "direct_verify", "isolation_mode", "worktree_cleanup"],
+      recommend_agent_for_task: ["repo_path", "goal"],
+      get_task_lineage: ["lineage_id"],
+      export_task_evidence_pack: ["lineage_id"],
+      get_project_policy: ["repo_path"],
+      safe_result: ["task_id"],
+      safe_audit: ["task_id"],
+      safe_test_summary: ["task_id"],
+      safe_diff_summary: ["task_id"],
+    };
+    for (const [toolName, requiredProperties] of Object.entries(safeRequirements)) {
+      const tool = listed.tools.find((entry) => entry.name === toolName);
+      const properties = Object.keys(tool?.inputSchema?.properties || {});
+      for (const property of requiredProperties) {
+        if (!properties.includes(property)) {
+          throw new Error(`${toolName} schema is missing ${property}`);
+        }
+      }
+    }
+  } else if (profile === "chatgpt_direct") {
     const directRequirements = {
       create_direct_session: ["repo_path"],
       apply_patch: ["session_id", "path", "expected_sha256", "operations"],
       run_verification: ["session_id", "command"],
+      run_direct_verification_bundle: ["session_id", "commands"],
       finalize_direct_session: ["session_id"],
       audit_session: ["session_id"],
+      safe_direct_summary: ["session_id"],
+      safe_finalize_direct_session: ["session_id"],
+      safe_audit_direct_session: ["session_id"],
     };
     for (const [toolName, requiredProperties] of Object.entries(directRequirements)) {
       const tool = listed.tools.find((entry) => entry.name === toolName);
@@ -119,6 +145,21 @@ try {
         }
       }
     }
+  } else {
+    const searchRequirements = {
+      discover_tools: ["query"],
+      explain_tool: ["name"],
+      invoke_discovered_tool: ["toolName", "arguments", "discoveryToken"],
+    };
+    for (const [toolName, requiredProperties] of Object.entries(searchRequirements)) {
+      const tool = listed.tools.find((entry) => entry.name === toolName);
+      const properties = Object.keys(tool?.inputSchema?.properties || {});
+      for (const property of requiredProperties) {
+        if (!properties.includes(property)) {
+          throw new Error(`${toolName} schema is missing ${property}`);
+        }
+      }
+    }
   }
   const healthResult = await client.callTool({ name: "health_check", arguments: {} });
   if (healthResult.isError) throw new Error(String(healthResult.content?.[0]?.text || "health_check failed"));
@@ -127,7 +168,8 @@ try {
     health.tool_profile !== profile ||
     health.tool_count !== expectedTools.length ||
     !health.tool_manifest_sha256 ||
-    (profile === "chatgpt_direct" && health.direct_profile_enabled !== true)
+    (profile === "chatgpt_direct" && health.direct_profile_enabled !== true) ||
+    (profile === "chatgpt_search" && health.search_tool_count !== expectedTools.length)
   ) {
     throw new Error(`health_check catalog mismatch: ${JSON.stringify(health)}`);
   }
@@ -164,12 +206,29 @@ try {
       health_check: ["detail"],
       list_tasks: ["repo_path", "active_only"],
       get_task_summary: ["view", "max_items"],
-    } : {
+      run_task_loop: ["repo_path", "goal", "verify_commands", "direct_verify", "isolation_mode", "worktree_cleanup"],
+      recommend_agent_for_task: ["repo_path", "goal"],
+      get_task_lineage: ["lineage_id"],
+      export_task_evidence_pack: ["lineage_id"],
+      get_project_policy: ["repo_path"],
+      safe_result: ["task_id"],
+      safe_audit: ["task_id"],
+      safe_test_summary: ["task_id"],
+      safe_diff_summary: ["task_id"],
+    } : profile === "chatgpt_direct" ? {
       create_direct_session: ["repo_path"],
       apply_patch: ["session_id", "path", "expected_sha256", "operations"],
       run_verification: ["session_id", "command"],
+      run_direct_verification_bundle: ["session_id", "commands"],
       finalize_direct_session: ["session_id"],
       audit_session: ["session_id"],
+      safe_direct_summary: ["session_id"],
+      safe_finalize_direct_session: ["session_id"],
+      safe_audit_direct_session: ["session_id"],
+    } : {
+      discover_tools: ["query"],
+      explain_tool: ["name"],
+      invoke_discovered_tool: ["toolName", "arguments", "discoveryToken"],
     },
   };
   console.log(jsonOnly ? JSON.stringify(output) : JSON.stringify(output, null, 2));