patchwarden 1.1.0 → 1.5.1

package/docs/user-feedback.md

@@ -0,0 +1,40 @@
+# PatchWarden User Feedback
+
+This file tracks real feedback only. Do not add invented users, fake adoption,
+or private conversations that cannot be shared.
+
+## Current Status
+
+No third-party feedback has been imported into this repository yet.
+
+Before using this file as application evidence, collect public feedback through
+GitHub issues or discussions from real testers who have tried at least one of
+the documented flows.
+
+## Feedback To Collect
+
+Ask testers to include:
+
+- operating system
+- Node.js version
+- MCP client used, such as ChatGPT, Codex, OpenCode, or another MCP client
+- whether `npm.cmd run doctor` or the documented setup passed
+- what task they attempted
+- whether task evidence, safe summaries, or audit output helped
+- confusing setup steps
+- feature requests
+
+## Public Feedback Log
+
+| Date | Source | Tester context | Result | Follow-up |
+| --- | --- | --- | --- | --- |
+| Pending | Pending GitHub issue or discussion | Pending | Pending | Pending |
+
+## Maintainer Response Rules
+
+- Keep feedback public when possible.
+- Redact local paths, logs, keys, tokens, cookies, `.env` contents, and account
+  identifiers.
+- Convert recurring friction into issues with `documentation`, `good first
+  issue`, `help wanted`, or `security` labels when appropriate.
+- Close the loop by linking fixes, docs, or release notes back to the feedback.

package/docs/why-patchwarden.md

@@ -0,0 +1,110 @@
+# 为什么需要 PatchWarden
+
+> 本文基于 v1.5.1 源码编写；安装时请使用已验证发布的 <published-version>。
+> 面向：使用 ChatGPT、Codex、OpenCode 等 MCP 客户端但需要安全边界的开发者
+
+## 背景：本地 Agent 的安全缺口
+
+当前主流的本地编程 Agent（如 ChatGPT 桌面端、Codex CLI、OpenCode、OpenHands）
+在带来生产力提升的同时，也引入了新的攻击面：
+
+- Agent 可执行本地命令，一旦被 prompt injection 或上下文污染，可能执行越权操作。
+- 通用远程 Shell 模式将完整命令执行能力暴露给 MCP 客户端，缺乏边界。
+- 任务产物分散在 stdout / stderr / diff 中，难以审计与验收。
+- `.env`、token、SSH key、cookie、浏览器状态等敏感文件缺乏强制隔离。
+
+PatchWarden 不是另一个通用 Shell。它定位为本地优先的 MCP 安全与验证层
+（local-first MCP safety and verification layer for AI coding agents），
+在不牺牲 Agent 能力的前提下提供可审计的安全边界。
+
+## 核心价值
+
+### 1. Workspace Confinement（工作区隔离）
+
+所有仓库路径必须位于配置的 `workspaceRoot` 之下。PatchWarden 会阻断：
+
+- 越出 workspace 的文件读写。
+- 对敏感文件名（如 `.env`、`id_rsa`、`cookies.db`）的访问。
+- 跨仓库的非授权改动。
+
+### 2. Command Allowlists（命令允许列表）
+
+PatchWarden 采用精确命令匹配，而非宽松的 glob 或前缀匹配：
+
+- 只有显式注册的命令才能执行。
+- 参数变化同样受约束，避免命令注入绕过。
+- 不存在“允许 `git` 即允许任意 git 子命令”的隐式放大。
+
+### 3. Scope-Violation Detection（范围违规检测）
+
+Agent 提出的任务若超出声明的 scope（例如修改了未授权文件、执行了未注册命令），
+PatchWarden 会在执行前或执行中识别并阻断，而不是事后才在日志里发现。
+
+### 4. Auditable Task Evidence（可审计任务证据）
+
+每个任务通过 Evidence Pack v2 导出 8 个有界文件：
+
+| 文件 | 用途 |
+| --- | --- |
+| `evidence.json` | 完整有界证据包（机器可读） |
+| `EVIDENCE.md` | 人类可读的 Markdown 摘要 |
+| `risk.json` | 聚合的风险项与严重度 |
+| `verify.json` | 每轮迭代的结构化验证记录 |
+| `diffstat.json` | 文件级增删统计（不含完整 diff） |
+| `lineage.json` | 任务谱系与上下文链 |
+| `attestation.json` | 任务签名与证明 |
+| `redactions.json` | 已脱敏内容清单 |
+
+这些文件只包含有界摘要，**不**包含完整 stdout/stderr、完整 diff、
+secrets、token、cookie 或凭据路径。
+
+## 与通用远程 Shell 的区别
+
+| 维度 | 通用远程 Shell | PatchWarden |
+| --- | --- | --- |
+| 命令执行 | 任意命令 | 精确允许列表 |
+| 路径访问 | 通常无约束 | 强制 workspace 隔离 |
+| 敏感文件 | 取决于调用方自觉 | 强制阻断 |
+| 任务证据 | 散落在日志 | 8 个有界文件可审计 |
+| 范围违规 | 事后发现 | 执行前/中阻断 |
+| MCP 客户端权限 | 全权委托 | 受约束代理 |
+
+PatchWarden 假设上游模型或 MCP 客户端可能出错、过度宽泛或被 prompt injection。
+它不应被信任以无约束方式执行命令。
+
+## 适用场景
+
+- 使用 ChatGPT / Codex / OpenCode / OpenHands 等 MCP 客户端进行本地代码维护。
+- 需要对 Agent 任务进行可审计验收的团队或个人。
+- 希望将 Agent 限制在特定 workspace 内的开发工作流。
+- 需要生成 spec 验收证据的 spec-driven 开发流程。
+
+## 不适用场景
+
+- 需要任意远程 shell 访问的场景（PatchWarden 刻意不提供）。
+- 需要读取或修改 `.env`、SSH key、浏览器状态等敏感文件的工作流。
+- 需要 Agent 跨多个不受信任 workspace 自由移动的场景。
+- 不接受命令允许列表约束的通用任务执行需求。
+
+## 目标用户
+
+- 使用 ChatGPT 桌面端、Codex CLI、OpenCode 等 MCP 客户端的开发者。
+- 在本地维护多个仓库并希望统一安全边界的维护者。
+- 需要为 Agent 任务生成可审计证据的团队。
+- 对 prompt injection 风险敏感、希望有执行前阻断机制的安全工程师。
+
+## 安全契约要点
+
+PatchWarden 的安全契约（详见 `docs/threat-model.md`）包括：
+
+- 不暴露通用远程 shell，不弱化精确命令匹配。
+- 所有仓库路径保持在 `workspaceRoot` 下，阻断敏感名与越界改动。
+- 不读取或持久化 token、cookie、浏览器状态、`.env`、SSH key、凭据文件。
+- 不无差别 kill watcher 或 tunnel，仅监督 launcher 拥有的进程。
+- 保留结构化任务证据、心跳状态、Git before/after 快照、改动文件记录与脱敏。
+
+## 下一步
+
+- 阅读 `docs/threat-model.md` 了解完整威胁模型。
+- 阅读 `docs/evidence-pack-schema.md` 了解证据包文件结构。
+- 阅读 `docs/dashboard-overview.md` 了解 Control Center 工作流。

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "patchwarden",
-  "version": "1.1.0",
-  "description": "Secure local MCP bridge for ChatGPT and local agents, with workspace-scoped tasks, safe summaries, audits, and Direct editing.",
+  "version": "1.5.1",
+  "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",
@@ -62,7 +62,7 @@
     "@modelcontextprotocol/sdk": "^1.0.0"
   },
   "devDependencies": {
-    "@types/node": "^20.0.0",
+    "@types/node": "^26.1.0",
     "typescript": "^6.0.3"
   },
   "engines": {

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`);
@@ -1001,6 +1088,351 @@ async function testControlCenterStatusApi() {
   }
 }
 
+// ── Test 21: GET /api/workspace/repos returns valid JSON with repos array ──
+async function testWorkspaceReposApi() {
+  const name = "Test 21: /api/workspace/repos returns valid JSON with repos array";
+  try {
+    const res = await httpGet(`${BASE_URL}/api/workspace/repos`);
+    if (res.status !== 200) {
+      record(name, false, `status ${res.status} (expected 200)`);
+      return;
+    }
+    const json = tryJson(res.body);
+    if (!json || !isObject(json)) {
+      record(name, false, `body is not a JSON object: ${res.body.slice(0, 200)}`);
+      return;
+    }
+    const problems = [];
+    if (!Array.isArray(json.repos)) problems.push("'repos' is not an array");
+    if (typeof json.workspace_root !== "string" && json.workspace_root !== null) {
+      problems.push("'workspace_root' is neither string nor null");
+    }
+    if (Array.isArray(json.repos)) {
+      for (let i = 0; i < json.repos.length; i++) {
+        const repo = json.repos[i];
+        if (!isObject(repo)) {
+          problems.push(`repos[${i}] is not an object`);
+          continue;
+        }
+        if (typeof repo.name !== "string") problems.push(`repos[${i}].name not string`);
+        if (typeof repo.path !== "string") problems.push(`repos[${i}].path not string`);
+        if (typeof repo.has_package_json !== "boolean") problems.push(`repos[${i}].has_package_json not boolean`);
+      }
+    }
+    if (problems.length === 0) {
+      record(name, true);
+    } else {
+      record(name, false, problems.join("; "));
+    }
+  } catch (err) {
+    record(name, false, `error: ${err.message}`);
+  }
+}
+
+// ── Test 22: /api/release/status no longer mentions release_prepare and has ready_state ──
+async function testReleaseStatusFields() {
+  const name = "Test 22: /api/release/status has ready_state and no release_prepare text";
+  try {
+    const res = await httpGet(`${BASE_URL}/api/release/status?repo_path=.`);
+    if (res.status !== 200) {
+      record(name, false, `status ${res.status} (expected 200)`);
+      return;
+    }
+    const json = tryJson(res.body);
+    if (!json || !isObject(json)) {
+      record(name, false, `body is not a JSON object: ${res.body.slice(0, 200)}`);
+      return;
+    }
+    const problems = [];
+    if (!("ready_state" in json)) problems.push("missing 'ready_state' field");
+    if (typeof json.ready_state !== "string") problems.push("'ready_state' is not a string");
+    if (!("package_name" in json)) problems.push("missing 'package_name' field");
+    if (!("version_source" in json)) problems.push("missing 'version_source' field");
+    if (!("version_consistent" in json)) problems.push("missing 'version_consistent' field");
+    if (!Array.isArray(json.required_commands)) problems.push("'required_commands' is not an array");
+    if (typeof json.commands_blocked_count !== "number") problems.push("'commands_blocked_count' is not a number");
+    // The old misleading "release_prepare" text must no longer appear.
+    if (res.body.includes("release_prepare")) {
+      problems.push("response still contains 'release_prepare' text");
+    }
+    if (Array.isArray(json.required_commands)) {
+      for (let i = 0; i < json.required_commands.length; i++) {
+        const cmd = json.required_commands[i];
+        if (!isObject(cmd)) {
+          problems.push(`required_commands[${i}] is not an object`);
+          continue;
+        }
+        if (typeof cmd.command !== "string") problems.push(`required_commands[${i}].command not string`);
+        if (typeof cmd.allowed !== "boolean") problems.push(`required_commands[${i}].allowed not boolean`);
+        if (!("blocked_reason" in cmd)) problems.push(`required_commands[${i}] missing 'blocked_reason'`);
+      }
+    }
+    if (problems.length === 0) {
+      record(name, true);
+    } else {
+      record(name, false, problems.join("; "));
+    }
+  } catch (err) {
+    record(name, false, `error: ${err.message}`);
+  }
+}
+
+// ── Test 23: Safe task endpoints return valid JSON without full content ──
+async function testSafeTaskEndpoints() {
+  const name = "Test 23: safe task endpoints return valid JSON without stdout/stderr/diff";
+  const endpoints = [
+    "safe-result",
+    "safe-audit",
+    "safe-test-summary",
+    "safe-diff-summary",
+  ];
+  const problems = [];
+  for (const ep of endpoints) {
+    try {
+      const res = await httpGet(`${BASE_URL}/api/tasks/nonexistent-smoke-task/${ep}`);
+      if (res.status !== 200) {
+        problems.push(`/api/tasks/:id/${ep} -> status ${res.status} (expected 200, not 500)`);
+        continue;
+      }
+      const json = tryJson(res.body);
+      if (!json || !isObject(json)) {
+        problems.push(`/api/tasks/:id/${ep} body is not a JSON object: ${res.body.slice(0, 120)}`);
+        continue;
+      }
+      // Safe endpoints must NOT expose full stdout/stderr/diff content.
+      const text = res.body.toLowerCase();
+      if (text.includes('"stdout"') && text.includes('"stderr"')) {
+        // Some safe endpoints may include a "stdout" key as a bounded field; the
+        // invariant we care about is that they don't return the full raw logs.
+        // We only flag if both stdout AND stderr appear together (log-shaped).
+        problems.push(`/api/tasks/:id/${ep} may leak stdout+stderr shaped fields`);
+      }
+      if (text.includes('"diff_patch"')) {
+        problems.push(`/api/tasks/:id/${ep} leaks 'diff_patch' field`);
+      }
+    } catch (err) {
+      problems.push(`/api/tasks/:id/${ep} error: ${err.message}`);
+    }
+  }
+  if (problems.length === 0) {
+    record(name, true);
+  } else {
+    record(name, false, problems.join("; "));
+  }
+}
+
+// ── Test 24: /api/tasks?status=running returns valid filtered JSON ──
+async function testTasksFilter() {
+  const name = "Test 24: /api/tasks?status=running returns valid filtered JSON";
+  try {
+    const res = await httpGet(`${BASE_URL}/api/tasks?status=running`);
+    if (res.status !== 200) {
+      record(name, false, `status ${res.status} (expected 200)`);
+      return;
+    }
+    const json = tryJson(res.body);
+    if (!json || !isObject(json)) {
+      record(name, false, `body is not a JSON object: ${res.body.slice(0, 200)}`);
+      return;
+    }
+    const problems = [];
+    if (!Array.isArray(json.tasks)) problems.push("'tasks' is not an array");
+    if (typeof json.total !== "number") problems.push("'total' is not a number");
+    if (typeof json.returned !== "number") problems.push("'returned' is not a number");
+    // Every returned task must match the filter (if any tasks exist).
+    if (Array.isArray(json.tasks)) {
+      for (let i = 0; i < json.tasks.length; i++) {
+        if (json.tasks[i].status !== "running") {
+          problems.push(`tasks[${i}].status is '${json.tasks[i].status}' (expected 'running')`);
+        }
+      }
+      if (json.tasks.length !== json.total) {
+        problems.push(`tasks.length (${json.tasks.length}) != total (${json.total})`);
+      }
+    }
+    if (problems.length === 0) {
+      record(name, true);
+    } else {
+      record(name, false, problems.join("; "));
+    }
+  } catch (err) {
+    record(name, false, `error: ${err.message}`);
+  }
+}
+
+// ── Test 25: /api/tasks/stale has explanation and next_action on stale tasks ──
+async function testStaleTasksExplanation() {
+  const name = "Test 25: /api/tasks/stale stale tasks have explanation and next_action";
+  try {
+    const res = await httpGet(`${BASE_URL}/api/tasks/stale`);
+    if (res.status !== 200) {
+      record(name, false, `status ${res.status} (expected 200)`);
+      return;
+    }
+    const json = tryJson(res.body);
+    if (!json || !isObject(json)) {
+      record(name, false, `body is not a JSON object: ${res.body.slice(0, 200)}`);
+      return;
+    }
+    const problems = [];
+    if (!Array.isArray(json.stale_tasks)) problems.push("'stale_tasks' is not an array");
+    if (Array.isArray(json.stale_tasks) && json.stale_tasks.length > 0) {
+      for (let i = 0; i < json.stale_tasks.length; i++) {
+        const t = json.stale_tasks[i];
+        if (!isObject(t)) {
+          problems.push(`stale_tasks[${i}] is not an object`);
+          continue;
+        }
+        if (typeof t.explanation !== "string" || t.explanation.length === 0) {
+          problems.push(`stale_tasks[${i}] missing 'explanation' string`);
+        }
+        if (typeof t.next_action !== "string" || t.next_action.length === 0) {
+          problems.push(`stale_tasks[${i}] missing 'next_action' string`);
+        }
+        if (typeof t.reason_code !== "string") {
+          problems.push(`stale_tasks[${i}] missing 'reason_code' string`);
+        }
+      }
+    }
+    if (problems.length === 0) {
+      record(name, true);
+    } else {
+      record(name, false, problems.join("; "));
+    }
+  } catch (err) {
+    record(name, false, `error: ${err.message}`);
+  }
+}
+
+// ── Test 26: POST /api/tasks/:taskId/hide-stale token gate + valid response ──
+async function testHideStaleNoToken() {
+  const name = "Test 26: POST /api/tasks/:taskId/hide-stale without token -> 403";
+  try {
+    const res = await httpPost(`${BASE_URL}/api/tasks/nonexistent/hide-stale`, {});
+    if (res.status !== 403) {
+      record(name, false, `status ${res.status} (expected 403 — token gate must fire before hide-stale runs)`);
+      return;
+    }
+    const json = tryJson(res.body);
+    if (!json || typeof json.error !== "string") {
+      record(name, false, `response body missing 'error' field: ${res.body.slice(0, 200)}`);
+      return;
+    }
+    record(name, true);
+  } catch (err) {
+    record(name, false, `error: ${err.message}`);
+  }
+}
+
+async function testHideStaleWithToken(token) {
+  const name = "Test 27: POST /api/tasks/:taskId/hide-stale with token returns valid JSON";
+  try {
+    const res = await httpPost(`${BASE_URL}/api/tasks/nonexistent/hide-stale`, {
+      "X-PatchWarden-Control-Token": token,
+    });
+    if (res.status !== 200) {
+      record(name, false, `status ${res.status} (expected 200)`);
+      return;
+    }
+    const json = tryJson(res.body);
+    if (!json || !isObject(json)) {
+      record(name, false, `body is not a JSON object: ${res.body.slice(0, 200)}`);
+      return;
+    }
+    if (json.ok !== true) {
+      record(name, false, `expected ok=true, got: ${res.body.slice(0, 200)}`);
+      return;
+    }
+    if (json.hidden !== "nonexistent") {
+      record(name, false, `expected hidden='nonexistent', got: ${json.hidden}`);
+      return;
+    }
+    record(name, true);
+  } catch (err) {
+    record(name, false, `error: ${err.message}`);
+  }
+}
+
+// ── Test 28: GET /api/warnings returns valid JSON ───────────────
+async function testWarningsApi() {
+  const name = "Test 28: /api/warnings returns valid JSON with warnings array";
+  try {
+    const res = await httpGet(`${BASE_URL}/api/warnings`);
+    if (res.status !== 200) {
+      record(name, false, `status ${res.status} (expected 200)`);
+      return;
+    }
+    const json = tryJson(res.body);
+    if (!json || !isObject(json)) {
+      record(name, false, `body is not a JSON object: ${res.body.slice(0, 200)}`);
+      return;
+    }
+    const problems = [];
+    if (!Array.isArray(json.warnings)) problems.push("'warnings' is not an array");
+    if (typeof json.total !== "number") problems.push("'total' is not a number");
+    if (Array.isArray(json.warnings)) {
+      for (let i = 0; i < json.warnings.length; i++) {
+        const w = json.warnings[i];
+        if (!isObject(w)) {
+          problems.push(`warnings[${i}] is not an object`);
+          continue;
+        }
+        if (typeof w.type !== "string") problems.push(`warnings[${i}].type is not a string`);
+        if (typeof w.severity !== "string") problems.push(`warnings[${i}].severity is not a string`);
+        if (typeof w.affected_tasks_count !== "number") problems.push(`warnings[${i}].affected_tasks_count is not a number`);
+        if (typeof w.recommended_action !== "string") problems.push(`warnings[${i}].recommended_action is not a string`);
+      }
+    }
+    if (problems.length === 0) {
+      record(name, true);
+    } else {
+      record(name, false, problems.join("; "));
+    }
+  } catch (err) {
+    record(name, false, `error: ${err.message}`);
+  }
+}
+
+// ── Test 29: GET /api/diagnostics returns valid JSON with redaction ─
+async function testDiagnosticsApi() {
+  const name = "Test 29: /api/diagnostics returns valid JSON with required fields and redaction";
+  try {
+    const res = await httpGet(`${BASE_URL}/api/diagnostics`);
+    if (res.status !== 200) {
+      record(name, false, `status ${res.status} (expected 200)`);
+      return;
+    }
+    const json = tryJson(res.body);
+    if (!json || !isObject(json)) {
+      record(name, false, `body is not a JSON object: ${res.body.slice(0, 200)}`);
+      return;
+    }
+    const problems = [];
+    if (typeof json.server_version !== "string") problems.push("'server_version' is not a string");
+    if (typeof json.schema_epoch !== "string") problems.push("'schema_epoch' is not a string");
+    if (typeof json.watcher_status !== "string") problems.push("'watcher_status' is not a string");
+    if (typeof json.workspace_root !== "string" && json.workspace_root !== null) {
+      problems.push("'workspace_root' is neither string nor null");
+    }
+    if (typeof json.direct_profile_enabled !== "boolean") problems.push("'direct_profile_enabled' is not a boolean");
+    // Redaction: response body must not contain sensitive keywords
+    const lower = res.body.toLowerCase();
+    const forbidden = ["token", "password", "secret", "credential", "api_key"];
+    for (const word of forbidden) {
+      if (lower.includes(word)) {
+        problems.push(`response body contains forbidden word '${word}' (redaction failure)`);
+      }
+    }
+    if (problems.length === 0) {
+      record(name, true);
+    } else {
+      record(name, false, problems.join("; "));
+    }
+  } catch (err) {
+    record(name, false, `error: ${err.message}`);
+  }
+}
+
 async function main() {
   // Sanity: ensure the compiled server exists before spawning.
   if (!existsSync(serverPath) || !statSync(serverPath).isFile()) {
@@ -1072,6 +1504,17 @@ async function main() {
     await testControlCenterLogApi();
     await testRestartAllNoToken();
     await testControlCenterStatusApi();
+    // v1.5.1 Dashboard UI optimization coverage
+    await testWorkspaceReposApi();
+    await testReleaseStatusFields();
+    await testSafeTaskEndpoints();
+    await testTasksFilter();
+    await testStaleTasksExplanation();
+    await testHideStaleNoToken();
+    if (token) await testHideStaleWithToken(token);
+    // P1 Task 10/11 coverage
+    await testWarningsApi();
+    await testDiagnosticsApi();
 
     // Use token to silence unused-var linters and confirm we actually fetched it.
     if (token) {

package/scripts/checks/control-smoke.js

@@ -76,7 +76,7 @@ try {
     ready: false,
     pid: null,
     tool_profile: "chatgpt_direct",
-    tool_count: 13,
+    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: 21,
+    tool_count: 26,
     tools_ready: true,
   }), "utf8");
   healthServer = spawn(