patchwarden 1.5.0 → 1.6.1

package/README.md

@@ -8,20 +8,27 @@
 [![Node.js](https://img.shields.io/badge/Node.js-%3E%3D18-339933.svg)](https://nodejs.org/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 
-当前源码版本：**v1.5.0**。查看
-[CHANGELOG](CHANGELOG.md)、[迁移指南](docs/migration-from-safe-bifrost.md)和
-[发布检查清单](docs/release-checklist.md)。GitHub Release / npm 发布状态需要在发布前单独核对。
+**让 ChatGPT、Codex 等 MCP 客户端负责规划与验收，让本地编程 Agent 在明确的安全边界内执行，并留下可审计证据。**
 
 PatchWarden 是一个面向本地编程 Agent 的安全 MCP 桥接器。上游的
 ChatGPT、Codex、OpenCode 或其他 MCP 客户端负责规划与验收，
 PatchWarden 负责把计划保存成工作区内任务，再由预先配置的本地 Agent
 执行，并返回结果、代码差异和独立测试记录。
 
-统一英文定位：
+[下载 Windows 安装版 v1.6.0](https://github.com/jiezeng2004-design/PatchWarden/releases/download/v1.6.0/PatchWarden-Setup-1.6.0-x64.exe)
+· [免安装 ZIP](https://github.com/jiezeng2004-design/PatchWarden/releases/download/v1.6.0/PatchWarden-Portable-1.6.0-x64.zip)
+· [校验文件](https://github.com/jiezeng2004-design/PatchWarden/releases/download/v1.6.0/PatchWarden-Desktop-SHA256SUMS.txt)
+· [三分钟快速开始](#三分钟快速开始)
+· [Discussions](https://github.com/jiezeng2004-design/PatchWarden/discussions)
+
+![PatchWarden Desktop 真实首启界面](docs/assets/patchwarden-desktop-onboarding.png)
 
-> PatchWarden is a local-first MCP safety and verification layer for AI coding agents, with workspace confinement, command allowlists, scope-violation detection, and auditable task evidence.
+<sub>PatchWarden Desktop 真实首启界面，来自隐私安全的桌面 smoke 验收；截图未使用真实工作区、账号或凭据。</sub>
 
-![PatchWarden ChatGPT connector demo](docs/assets/patchwarden-chatgpt-demo.svg)
+当前源码版本：**v1.6.1**；当前 Windows Release：**v1.6.0**；npm `latest`：**v1.5.1**。
+Windows 首次体验推荐上面的安装版；npm/CLI 用户请固定已发布版本。查看
+[CHANGELOG](CHANGELOG.md)、[迁移指南](docs/migration-from-safe-bifrost.md)和
+[发布检查清单](docs/release-checklist.md)。
 
 > [!IMPORTANT]
 > PatchWarden 不是通用远程 Shell。MCP 客户端不能随意执行命令：
@@ -33,7 +40,7 @@ PatchWarden 负责把计划保存成工作区内任务，再由预先配置的
 - [它解决什么问题](#它解决什么问题)
 - [运行结构](#运行结构)
 - [环境要求](#环境要求)
-- [五分钟快速开始](#五分钟快速开始)
+- [三分钟快速开始](#三分钟快速开始)
 - [完整配置说明](#完整配置说明)
 - [接入 OpenCode](#接入-opencode)
 - [接入 Codex](#接入-codex)
@@ -44,6 +51,7 @@ PatchWarden 负责把计划保存成工作区内任务，再由预先配置的
 - [诊断与健康检查](#诊断与健康检查)
 - [踩坑记录与故障排查](#踩坑记录与故障排查)
 - [Direct 模式：ChatGPT 直接开发](#direct-模式chatgpt-直接开发)
+- [生态适配](#生态适配)
 - [安全边界与本地数据](#安全边界与本地数据)
 - [升级与旧版本迁移](#升级与旧版本迁移)
 - [开发与发布验证](#开发与发布验证)
@@ -57,9 +65,9 @@ PatchWarden 负责把计划保存成工作区内任务，再由预先配置的
 - 每个任务必须指定位于 `workspaceRoot` 内的 `repo_path`。
 - Agent 启动命令来自本地配置，而不是来自模型输入。
 - 测试命令必须精确匹配 `allowedTestCommands`。
-- 任务完成后保存结构化结果、完整差异、文件统计和独立验证记录。
+- 任务完成后保存结构化结果、有界且脱敏的差异、文件统计和独立验证记录。
 - 工作区外出现变化时，任务会标记为作用域违规，而不是悄悄接受。
-- `.env`、Token、SSH 密钥、Cookie、凭据文件等敏感路径默认不可读。
+- `.patchwarden/` 不是敏感路径豁免区；`.env`、Token、SSH 密钥、Cookie、凭据文件等敏感名称无论位于哪一层目录都不可读。
 
 适合的场景：
 
@@ -133,9 +141,33 @@ where.exe codex
 应用程序，它不一定是可供 PatchWarden 调用的 Codex CLI。请安装或指定真正的
 CLI，或者先把 OpenCode 配置为执行 Agent。
 
-## 五分钟快速开始
+## 三分钟快速开始
+
+如果已经安装 Node.js 18+ 和至少一个本地编程 Agent，这条 Windows 路径的目标是
+在三分钟内完成首次只读健康检查。首次体验不需要配置 ChatGPT Tunnel。
+
+### 方案 A：Windows 安装版（首次体验推荐）
+
+1. 下载 [Windows 安装版 v1.6.0](https://github.com/jiezeng2004-design/PatchWarden/releases/download/v1.6.0/PatchWarden-Setup-1.6.0-x64.exe)
+   和 [SHA256 校验文件](https://github.com/jiezeng2004-design/PatchWarden/releases/download/v1.6.0/PatchWarden-Desktop-SHA256SUMS.txt)。
+2. 在 PowerShell 中校验安装包：
+
+```powershell
+Get-FileHash .\PatchWarden-Setup-1.6.0-x64.exe -Algorithm SHA256
+```
 
-### 方案 A：从源码运行（推荐）
+当前发布值应为 `77d655545925ae283a0caed0fff12554debac15b54c5decf1ae8f3867703058e`；
+仍应以同一 Release 的校验文件为准。安装包尚未代码签名，Windows SmartScreen
+可能显示“未知发布者”。
+
+3. 安装并打开 PatchWarden Desktop，选择一个只包含项目的专用工作区。
+4. 首屏选择 **本地 MCP**，确认检测到的 Agent，让只读健康检查完成。
+
+成功标志：向导能够进入只读控制台，显示所选工作区，并完成 Agent 与运行环境检查。
+安装成功或遇到阻塞时，请到 [Discussions](https://github.com/jiezeng2004-design/PatchWarden/discussions)
+记录操作系统、Node.js 版本、使用的 Agent 和卡住的步骤。
+
+### 方案 B：从源码运行（开发者）
 
 源码方式最适合完整使用 Watcher、Windows 一键启动器和诊断脚本。
 
@@ -170,7 +202,7 @@ npm.cmd run watch
 
 保持该窗口运行，再按照后文配置 OpenCode、Codex 或 ChatGPT Connector。
 
-### 方案 B：使用 npm 包
+### 方案 C：使用 npm 包
 
 npm 包适合让 MCP 客户端通过固定版本启动 PatchWarden。为了执行任务，
 仍然必须另外启动 Watcher。
@@ -212,11 +244,13 @@ Copy-Item .\examples\config.example.json .\patchwarden.config.json
   "agents": {
     "opencode": {
       "command": "opencode",
-      "args": ["run", "{prompt}"]
+      "args": ["run", "{prompt}"],
+      "envAllowlist": []
     },
     "codex": {
       "command": "codex",
-      "args": ["exec", "--cd", "{repo}", "{prompt}"]
+      "args": ["exec", "--cd", "{repo}", "{prompt}"],
+      "envAllowlist": []
     }
   },
   "allowedTestCommands": [
@@ -245,6 +279,7 @@ Copy-Item .\examples\config.example.json .\patchwarden.config.json
 | `tasksDir` | 是 | 任务和结果目录，通常使用 `.patchwarden/tasks`。 |
 | `toolProfile` | 否 | `full`、`chatgpt_core`、`chatgpt_direct` 或 `chatgpt_search`；本地客户端推荐 `full`，动态工具发现场景使用 `chatgpt_search`。 |
 | `agents` | 是 | 可执行 Agent 白名单；支持 `{repo}` 和 `{prompt}` 占位符。 |
+| `agents.<name>.envAllowlist` | 否 | 显式传给该 Agent 的 provider 环境变量名；默认不继承。Tunnel owner token 禁止透传。 |
 | `allowedTestCommands` | 是 | 独立验证命令白名单，调用时必须精确匹配。 |
 | `repoAllowedTestCommands` | 否 | 按工作区相对仓库路径增加精确验证命令；不支持通配符。 |
 | `maxReadFileBytes` | 是 | MCP 单次文件读取上限。 |
@@ -368,6 +403,21 @@ PATCHWARDEN_TOOL_PROFILE = "full"
 
 ## 接入 ChatGPT Connector
 
+> 当前 ChatGPT 术语为 **developer-mode app / Plugins**；旧版文档与部分界面曾称为 Connector。新配置请以 Plugins 为准。
+
+### 桌面版八步新手流程
+
+1. 确认 OpenAI Platform 账号具有 Tunnel 权限，并在目标 ChatGPT workspace 开启 developer mode。
+2. 打开 [Platform Tunnel 设置](https://platform.openai.com/settings/organization/tunnels)，创建 Tunnel，并关联目标 ChatGPT workspace。
+3. 启动 PatchWarden Desktop，在“设置 → MCP 与隧道”检测或选择现有的 `tunnel-client.exe`；应用不会自动下载或执行新软件。
+4. 输入 Core Tunnel ID 与专用 Tunnel runtime API key。该凭据对应 `CONTROL_PLANE_API_KEY`，**不是**普通应用使用的 `OPENAI_API_KEY`。
+5. 配置环境代理、无代理或不含凭据的 HTTP/HTTPS/SOCKS5（Mixed）代理，并先确认代理端口可达。
+6. 点击“配置并验证 Core”。桌面端初始化 `patchwarden` profile，运行 `tunnel-client doctor --explain --json`，验证成功后才用 Windows DPAPI 保存凭据；随后启动 Core。
+7. 在“开始使用”确认 Tunnel ready、Watcher healthy，并确认 `chatgpt_core` 发现固定的 26 个工具。Direct 是设置页中的可选高级能力，未启用时“全部启动”只启动 Core。
+8. 在 ChatGPT **Settings → Plugins** 创建 developer-mode app，选择刚创建的 Tunnel；重新连接后新建对话，调用 `health_check` 验证。
+
+首次引导也可选择“本地 MCP”。该路线只配置安全工作区和本地 MCP 客户端，可以跳过第 1、2、4、5、7、8 步中的 Platform/ChatGPT Tunnel 操作。
+
 推荐的 Windows 链路：
 
 ```text
@@ -571,19 +621,25 @@ ChatGPT 任务应优先选择前三个守护模板：只读诊断使用 `inspect
 | `progress.md` | Agent 写入的进度记录。 |
 | `result.md` | 人类可读的执行报告。 |
 | `result.json` | 结构化结果、路径、变更、警告和后续建议。 |
-| `diff.patch` | 完整任务差异证据。 |
+| `diff.patch` | 最多 20 MiB 的任务差异证据；疑似凭据会在落盘前脱敏，超限会明确标记截断。 |
 | `artifact_manifest.json` | 构建或发布产物的路径、类型、大小与 SHA-256。 |
 | `file-stats.json` | 文件级增删统计。 |
 | `verify.json` | 每条独立验证命令的结构化记录。 |
 | `verify.log` | 独立验证的可读日志。 |
 | `test.log` | Agent 执行过程中产生的测试输出。 |
 
+面向客户端的任务产物读取受 `maxReadFileBytes` 限制；diff、summary 与日志 tail
+只读取有界前缀或尾部。`audit_task` 最多扫描 200 个 Markdown 文件和 4 MiB 文档内容，
+达到预算会返回 warning。invocation/reconcile 等持续日志使用跨进程锁内的有界追加，
+超限时保留最近内容并写入明确的截断标记。
+
 本地 Agent 声称“已推送”“已发布”不属于可靠的远程证据。GitHub、npm、
 Tag 和 Release 必须再用对应平台的实时状态核验。
 
 ## HTTP MCP 模式
 
-HTTP Server 只绑定 `127.0.0.1`，默认端口 7331，不会直接监听局域网。
+HTTP Server 只绑定 `127.0.0.1`，默认端口 7331，不会直接监听局域网；
+HTTP MCP 与 Control Center 同时拒绝非 `127.0.0.1`/`localhost` 的 Host，防止 DNS rebinding 绕过回环边界。
 
 终端 1，启动 Watcher：
 
@@ -658,10 +714,43 @@ Direct 两种模式的启动、停止、重启与状态。也可以在 PowerShel
 .\PatchWarden.cmd restart all
 .\PatchWarden.cmd status all
 .\PatchWarden.cmd kill all
-.\Stop-PatchWarden.cmd
+.\scripts\launchers\Stop-PatchWarden.cmd
 ```
 
-日常桌面入口：`PatchWarden-Desktop.cmd` 启动托盘并确保 Control Center 可用，不自动打开额外浏览器窗口。只有调试托盘时才使用 `PatchWarden-Control-Tray.cmd --foreground`；需要完整 Web 控制台时打开 `PatchWarden-Control.cmd`；需要一键收尾时使用 `Stop-PatchWarden.cmd` 关闭 Core/Direct、Control Center 和托盘。
+日常桌面入口：`scripts\launchers\PatchWarden-Desktop.cmd` 启动托盘并确保 Control Center 可用，不自动打开额外浏览器窗口。只有调试托盘时才使用 `scripts\launchers\PatchWarden-Control-Tray.cmd --foreground`；需要完整 Web 控制台时打开 `scripts\launchers\PatchWarden-Control.cmd`；需要一键收尾时使用 `scripts\launchers\Stop-PatchWarden.cmd` 关闭 Core/Direct、Control Center 和托盘。
+
+### Windows 安装版
+
+公开分发可以构建 PatchWarden Desktop 安装包和免安装 ZIP。它提供 Electron
+独立窗口、首次工作区引导、系统托盘和设置页，同时继续复用相同的
+loopback Control Center 与安全控制 API。桌面依赖隔离在私有的
+`desktop/` 子包中，不进入 `patchwarden` npm 包。
+
+安装版仍要求 Windows x64、Node.js 18+ 和 tunnel-client。首次启动会在
+`PATH`、当前用户目录和工作区附近做有界检测；未找到时可进入只读控制台，
+再从“设置 -> MCP 与隧道”选择 `tunnel-client.exe` 并查看 SHA256 校验步骤。
+应用不会自动下载或运行新软件。设置页还提供 Direct 显式开关，以及环境代理、
+无代理、手动代理三种模式；手动代理只接受不含凭据的 http/https/socks5 URL。
+启动和重启只有在 health/ready 与 Core Watcher 验证通过后才会报告成功。
+桌面端支持 Codex、OpenCode、Claude Code、Gemini CLI、GitHub Copilot CLI、
+Qwen Code、Kimi Code 和 Aider；只读取各 Agent 配置中的模型字段，不读取凭据。
+
+```powershell
+npm.cmd install --prefix desktop --cache .\.npm-cache
+npm.cmd run desktop:test
+npm.cmd run desktop:preflight
+npm.cmd run desktop:package
+```
+
+安装包、免安装 ZIP 与 SHA256 文件输出到 `release\desktop`。首版不包含自动更新或
+代码签名，Windows SmartScreen 可能提示未知发布者；发布前必须核对
+GitHub Release 来源和 SHA256。完整安装、运行与卸载说明见
+[docs/desktop-app.md](docs/desktop-app.md)。
+
+`desktop:preflight` 会使用唯一目录完成 clean build、完整单测、桌面测试、npm 包面、
+Electron 目录包、仓库外 26-tool manifest 与隔离 unpacked UI/单实例验收，并生成
+`preflight-report.json` / `preflight-report.md`。正式发布前必须在干净 checkout 运行
+`npm.cmd run desktop:preflight:release`；该命令发现未提交路径时会直接阻断。
 
 旧的单用途入口保留在 `scripts/launchers/` 作为兼容层；个人入口位于
 `.local/launchers/`，并继续被 Git 和发布包排除。`stop` / `restart` 会同时检查
@@ -751,6 +840,31 @@ powershell.exe -NoProfile -ExecutionPolicy Bypass -File "%CD%\scripts\control\st
 `chatgpt_core` / `patchwarden` → `127.0.0.1:8080`，
 `chatgpt_direct` / `patchwarden-direct` → `127.0.0.1:8081`。
 
+## Dashboard 主要页面与推荐工作流
+
+PatchWarden Dashboard (Control Center) 提供以下主要页面：
+
+- **控制台 (Dashboard)**: 系统总览，包含 Repo selector、Health Score、服务状态、Release 卡片、Project Policy、Lineage、Evidence Pack、Stale 任务提示、最近任务列表、系统状态（含 Copy diagnostics）。
+- **任务面板 (Tasks)**: 任务列表，支持按 repo_path / status / acceptance_status / warning type / agent / date range 过滤，每行提供 safe_result / safe_audit / safe_test_summary / safe_diff_summary 快捷操作。
+- **任务详情 (Task Detail)**: 默认展示 safe 摘要（safe_result / safe_test_summary / safe_diff_summary / safe_audit），配置上限内的 result / diff / test log 在折叠的高级区按需加载。
+- **Direct 会话 (Direct Sessions)**: 按 active / finalized / audited / expired 分组，提供 safe_direct_summary / safe_finalize_direct_session / safe_audit_direct_session 快捷操作。
+- **审计日志 / Warnings (Audit)**: 按 warning 类型聚合，显示 affected tasks / severity / recommended action。
+- **工作区 (Workspace)**: workspace 一级目录与项目列表。
+- **日志 (Logs)**: Core / Direct / Watcher / Control Center 日志尾部。
+
+推荐工作流：
+
+1. 在 Dashboard 顶部选择目标 repo。
+2. 查看 Health Score 确认系统健康。
+3. 在最近任务列表点击 safe_result 快捷查看任务摘要。
+4. 打开 Task Detail 进行 safe-first 验收，仅在需要时展开高级区查看有界日志。
+5. 使用 Lineage Detail 查看 run_task_loop 的成功/失败原因。
+6. 验收完成后导出 Evidence Pack。
+7. Direct 会话用于独立验证，完成后 finalize + audit。
+8. 遇到问题时点击 Copy diagnostics 复制诊断信息发给 ChatGPT / Codex / opencode 排查。
+
+> 详细说明见 [docs/dashboard-overview.md](docs/dashboard-overview.md)、[docs/task-safe-review-workflow.md](docs/task-safe-review-workflow.md)、[docs/lineage-evidence-pack-workflow.md](docs/lineage-evidence-pack-workflow.md)、[docs/direct-session-workflow.md](docs/direct-session-workflow.md)。
+
 ## 踩坑记录与故障排查
 
 ### 快速对照表
@@ -868,6 +982,12 @@ creation. `export_task_evidence_pack` writes bounded `evidence.json` and
 `EVIDENCE.md` files under `.patchwarden/evidence-packs/<lineage_id>/` without
 stdout/stderr tails, full diffs, verification logs, or sensitive file content.
 
+Goal Session 的状态变更通过共享的跨进程 mutation lock 串行化并原子落盘；
+非空 Goal 的所有子目标都被 `accept_subgoal` 接受后，Goal 会自动转为 `completed`。
+`create_subgoal_task` 以 Goal 已保存的 `repo_path` 为权威，调用方传入其他仓库会以
+`goal_repo_mismatch` 拒绝；隔离 worktree 也从该仓库创建，且 create/merge/discard
+共用仓库级 lifecycle lock。
+
 `get_project_policy` 是 v1.3 的只读策略入口，返回 `.patchwarden/project-policy.json`
 的有界 effective policy 与 release readiness，不会扩大命令白名单。v1.3 的
 `release_check`、`release_prepare`、`release_verify`、`release_cleanup` 仅在 `full`
@@ -971,12 +1091,26 @@ Direct 模式在受控 session 内执行，具有以下硬性限制：
 - 禁止修改 `node_modules`
 - 禁止手动修改 release/dist
 - 禁止修改二进制文件
+- 只修改大小受限的 UTF-8 文本；补丁按 UTF-8 字节计数
+- 补丁或同步结果包含疑似凭据时拒绝写入
+- 同一 session 的 patch、sync、verify、finalize、audit 串行化
 - 所有操作限制在 `workspaceRoot` 和 session repo 内
 
 ### 不支持内容
 
 Direct 模式不支持：shell、delete、rename、commit、push、publish、deployment。
 
+## 生态适配
+
+- [为什么需要 PatchWarden](docs/why-patchwarden.md)
+- [Evidence Pack v2 文件结构](docs/evidence-pack-schema.md)
+- [Spec Kit 集成模式](docs/spec-kit-integration.md)
+- [AgentSeal 集成模式](docs/agentseal-integration.md)
+- [MCP Inspector 测试](docs/mcp-inspector-testing.md)
+- [OpenCode worker 集成](docs/opencode-worker.md)
+- [OpenHands worker 集成](docs/openhands-worker.md)
+- [威胁模型](docs/threat-model.md)
+
 ## 安全边界与本地数据
 
 PatchWarden 的主要保护：
@@ -985,9 +1119,9 @@ PatchWarden 的主要保护：
 - Agent 命令和参数模板必须预先配置。
 - 验证命令必须精确匹配白名单。
 - 文件访问被限制在 `workspaceRoot` 内。
-- 敏感文件名和明显的凭据读取计划会被阻止。
-- 任务产物中的疑似密钥值会被脱敏。
-- HTTP Server 只绑定 `127.0.0.1`。
+- 敏感文件名和明显的凭据读取计划会被阻止；`.patchwarden/` 不会绕过该检查。
+- 任务差异中的疑似密钥值会在落盘前脱敏，并把任务标记为策略违规。
+- HTTP 服务只绑定 `127.0.0.1`，并拒绝非回环 Host。
 - Runner 不会自动 commit、push、发布或重置仓库。
 
 需要保护的本地路径：
@@ -1081,6 +1215,10 @@ Release 和发布资产校验值。
 - [ChatGPT 调用规范](docs/chatgpt-usage.md)
 - [旧版本迁移指南](docs/migration-from-safe-bifrost.md)
 - [ChatGPT Connector 演示](docs/demo.md)
+- [Dashboard 概览](docs/dashboard-overview.md)
+- [任务 safe 验收工作流](docs/task-safe-review-workflow.md)
+- [Lineage 与 Evidence Pack 工作流](docs/lineage-evidence-pack-workflow.md)
+- [Direct 会话工作流](docs/direct-session-workflow.md)
 - [OpenAI Tunnel 示例](examples/openai-tunnel/README.md)
 - [ChatGPT 测试提示词](examples/openai-tunnel/chatgpt-test-prompt.md)
 
@@ -1096,7 +1234,7 @@ Release 和发布资产校验值。
 - [x] Release Gate（发布前五阶段校验）
 - [x] Worktree 隔离
 - [x] 多 Agent 路由
-- [ ] 本地 Dashboard
+- [x] 本地 Dashboard
 
 ## License
 

package/dist/assessments/agentAssessor.d.ts

@@ -12,4 +12,4 @@ export interface AgentAssessorInput {
     maxOutputBytes: number;
     config: PatchWardenConfig;
 }
-export declare function runAgentAssessment(input: AgentAssessorInput): AgentAssessmentSummary;
+export declare function runAgentAssessment(input: AgentAssessorInput): Promise<AgentAssessmentSummary>;

package/dist/assessments/agentAssessor.js

@@ -1,10 +1,11 @@
-import { writeFileSync } from "node:fs";
-import { resolve, relative, isAbsolute } from "node:path";
+import { resolve, relative, isAbsolute, sep } from "node:path";
 import { buildAgentInvocation, buildAssessmentPrompt } from "../runner/agentInvocation.js";
 import { runSimpleProcessSync } from "../runner/simpleProcess.js";
 import { captureRepoSnapshot, compareSnapshots } from "../runner/changeCapture.js";
+import { atomicWriteFileSync, atomicWriteJsonFileSync } from "../utils/atomicFile.js";
+import { redactSensitiveContent } from "../security/contentRedaction.js";
 const ASSESSMENT_MARKER = "===ASSESSMENT_JSON===";
-export function runAgentAssessment(input) {
+export async function runAgentAssessment(input) {
     const logPaths = {
         stdout: resolve(input.assessmentDir, "agent-assessment-stdout.log"),
         stderr: resolve(input.assessmentDir, "agent-assessment-stderr.log"),
@@ -26,14 +27,16 @@ export function runAgentAssessment(input) {
         log_paths: logPaths,
     };
     // ── 1. Build prompt and write to file for {prompt_file} support ──
-    const assessmentPrompt = buildAssessmentPrompt(input.goal, input.planContent, input.repoPath);
+    const safeGoal = redactSensitiveContent(input.goal).content.slice(0, 10_000);
+    const safePlan = redactSensitiveContent(input.planContent).content.slice(0, 1024 * 1024);
+    const assessmentPrompt = buildAssessmentPrompt(safeGoal, safePlan, input.repoPath);
     const promptFilePath = resolve(input.assessmentDir, "agent-assessment-prompt.md");
-    writeFileSync(promptFilePath, assessmentPrompt, "utf-8");
+    atomicWriteFileSync(promptFilePath, assessmentPrompt);
     logPaths.prompt = promptFilePath;
     // ── 2. Before snapshot (repo-scoped) ──
     let repoBefore;
     try {
-        repoBefore = captureRepoSnapshot(input.repoPath);
+        repoBefore = await captureRepoSnapshot(input.repoPath);
     }
     catch {
         // If we can't capture before snapshot, conservatively skip agent assessment
@@ -68,12 +71,14 @@ export function runAgentAssessment(input) {
         maxStderrBytes: Math.max(16384, Math.floor(input.maxOutputBytes / 4)),
         stdoutPath: logPaths.stdout,
         stderrPath: logPaths.stderr,
+        environmentVariableNames: invocation.environmentVariableNames,
+        blockedEnvironmentVariableNames: invocation.blockedEnvironmentVariableNames,
     });
     // ── 5. After snapshot + read-only violation check ──
     let readOnlyViolation = false;
     let violationFiles = [];
     try {
-        const repoAfter = captureRepoSnapshot(input.repoPath);
+        const repoAfter = await captureRepoSnapshot(input.repoPath);
         const changes = compareSnapshots(repoBefore, repoAfter);
         if (changes.length > 0) {
             readOnlyViolation = true;
@@ -101,11 +106,11 @@ export function runAgentAssessment(input) {
             stderr_truncated: result.stderrTruncated,
             log_paths: { ...logPaths, violation: resolve(input.assessmentDir, "agent-assessment-violation.json") },
         };
-        writeFileSync(summary.log_paths.violation, JSON.stringify({
+        atomicWriteJsonFileSync(summary.log_paths.violation, {
             violation: "read_only_violation",
             files: violationFiles,
             exit_code: result.exitCode,
-        }, null, 2), "utf-8");
+        });
         writeSummary(logPaths.assessment, summary);
         return summary;
     }
@@ -216,13 +221,17 @@ function parseAssessmentJson(stdout, repoPath) {
     const jsonEnd = jsonText.lastIndexOf("}");
     if (jsonStart < 0 || jsonEnd < 0 || jsonEnd <= jsonStart)
         return { output: null, sanitized_reasons };
-    let parsed;
+    let parsedValue;
     try {
-        parsed = JSON.parse(jsonText.slice(jsonStart, jsonEnd + 1));
+        parsedValue = JSON.parse(jsonText.slice(jsonStart, jsonEnd + 1));
     }
     catch {
         return { output: null, sanitized_reasons };
     }
+    if (!parsedValue || typeof parsedValue !== "object" || Array.isArray(parsedValue)) {
+        return { output: null, sanitized_reasons };
+    }
+    const parsed = parsedValue;
     // ── Strict validation ──
     if (parsed.risk_level !== "low" && parsed.risk_level !== "medium" && parsed.risk_level !== "high") {
         return { output: null, sanitized_reasons };
@@ -235,7 +244,7 @@ function parseAssessmentJson(stdout, repoPath) {
         return { output: null, sanitized_reasons };
     if (parsed.reason_codes.length > 50)
         return { output: null, sanitized_reasons };
-    const reasonCodes = parsed.reason_codes.filter((r) => typeof r === "string" && r.length <= 100);
+    const reasonCodes = parsed.reason_codes.filter((reason) => typeof reason === "string" && reason.length <= 100);
     if (reasonCodes.length !== parsed.reason_codes.length) {
         sanitized_reasons.push("reason_codes_filtered");
     }
@@ -257,7 +266,7 @@ function parseAssessmentJson(stdout, repoPath) {
         }
         const resolved = resolve(repoPath, p);
         const rel = relative(repoPath, resolved);
-        if (rel.startsWith("..")) {
+        if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
             pathsSanitized = true;
             continue;
         }
@@ -270,7 +279,7 @@ function parseAssessmentJson(stdout, repoPath) {
         return { output: null, sanitized_reasons };
     if (parsed.destructive_actions.length > 20)
         return { output: null, sanitized_reasons };
-    const destructiveActions = parsed.destructive_actions.filter((d) => typeof d === "string" && d.length <= 200);
+    const destructiveActions = parsed.destructive_actions.filter((action) => typeof action === "string" && action.length <= 200);
     if (typeof parsed.requires_user_confirm !== "boolean")
         return { output: null, sanitized_reasons };
     const notes = typeof parsed.notes === "string" ? parsed.notes.slice(0, 2000) : "";
@@ -289,5 +298,5 @@ function parseAssessmentJson(stdout, repoPath) {
     };
 }
 function writeSummary(path, summary) {
-    writeFileSync(path, JSON.stringify(summary, null, 2), "utf-8");
+    atomicWriteJsonFileSync(path, summary);
 }

package/dist/assessments/assessmentStore.d.ts

@@ -117,7 +117,7 @@ export declare function validateAssessmentFreshness(assessmentId: string, curren
  * This is intentionally not registered as an MCP tool: a remote client may
  * request confirmation, but it cannot grant confirmation to itself.
  */
-export declare function confirmAssessment(assessmentId: string): AssessmentConfirmationResult;
+export declare function confirmAssessment(assessmentId: string): Promise<AssessmentConfirmationResult>;
 export declare function computeWorkspaceFingerprint(snapshot: RepoSnapshot): string;
 interface PolicyHashInput {
     change_policy: ChangePolicy;

package/dist/assessments/assessmentStore.js

@@ -1,11 +1,14 @@
-import { mkdirSync, writeFileSync, existsSync, readFileSync, renameSync, } from "node:fs";
+import { mkdirSync, existsSync, readFileSync, } from "node:fs";
 import { createHash, randomBytes } from "node:crypto";
 import { resolve, join } from "node:path";
 import { getAssessmentsDir, getConfig, getRepoAllowedTestCommands } from "../config.js";
 import { guardPath } from "../security/pathGuard.js";
 import { PatchWardenError } from "../errors.js";
+import { redactSensitiveContent } from "../security/contentRedaction.js";
+import { atomicWriteJsonFileSync } from "../utils/atomicFile.js";
+import { withFileLockSync } from "../utils/lockedJsonFile.js";
 import { TOOL_SCHEMA_EPOCH } from "../version.js";
-import { getLastToolCatalogSnapshot } from "../tools/toolCatalog.js";
+import { getLastToolCatalogSnapshot } from "../tools/catalog/toolCatalog.js";
 import { captureRepoSnapshot } from "../runner/changeCapture.js";
 const SENSITIVE_PATH_RULES_SIGNATURE = "v1";
 const ARTIFACT_RULES_SIGNATURE = "v1";
@@ -71,7 +74,7 @@ export function createAssessment(input) {
         repo_path: input.repo_path,
         resolved_repo_path: input.resolved_repo_path,
         template: input.template || null,
-        goal: input.goal || null,
+        goal: input.goal ? redactSensitiveContent(input.goal).content : null,
         test_command: input.test_command || null,
         verify_commands: input.verify_commands || [],
         agent: input.agent,
@@ -83,7 +86,7 @@ export function createAssessment(input) {
         confirm_code: null,
         agent_assessment_summary: input.agent_assessment_summary || null,
     };
-    writeFileSync(join(dir, "assessment.json"), JSON.stringify(record, null, 2), "utf-8");
+    atomicWriteJsonFileSync(join(dir, "assessment.json"), record);
     return record;
 }
 export function readAssessment(assessmentId) {
@@ -156,48 +159,53 @@ export function validateAssessmentFreshness(assessmentId, currentSnapshot, optio
  * This is intentionally not registered as an MCP tool: a remote client may
  * request confirmation, but it cannot grant confirmation to itself.
  */
-export function confirmAssessment(assessmentId) {
+export async function confirmAssessment(assessmentId) {
     if (!/^assessment_\d{8}_\d{6}_[0-9a-f]{32}$/.test(assessmentId)) {
         throw new PatchWardenError("assessment_id_invalid", "Local confirmation requires the full assessment_id (32 hexadecimal random characters).", "Copy the complete assessment_id from the assess_only response; assessment_short_id is display-only.");
     }
+    const config = getConfig();
+    const assessmentFile = resolve(getAssessmentsDir(config), assessmentId, "assessment.json");
+    guardPath(assessmentFile, config.workspaceRoot, config.assessmentsDir);
     const assessment = readAssessment(assessmentId);
     if (assessment.decision !== "needs_confirm" || !assessment.requires_confirm) {
         throw new PatchWardenError("assessment_confirmation_not_allowed", `Assessment "${assessmentId}" has decision "${assessment.decision}" and cannot be locally confirmed.`, assessment.decision === "blocked"
             ? "Fix the hard-rule finding and run assess_only again."
             : "This assessment does not require confirmation; execute it with the minimal assessment_id call.");
     }
-    const snapshot = captureRepoSnapshot(assessment.resolved_repo_path);
-    const validation = validateAssessmentFreshness(assessmentId, snapshot, {
-        allow_unconfirmed: true,
-        // A standalone CLI has no active MCP profile snapshot. The execute path
-        // still performs the full tool-manifest check before creating the task.
-        skip_tool_manifest: true,
+    const snapshot = await captureRepoSnapshot(assessment.resolved_repo_path);
+    // Re-read and write while holding one cross-process lock. Concurrent local
+    // confirmers may compute snapshots in parallel, but they cannot replace one
+    // another's confirmation metadata from a stale assessment record.
+    return withFileLockSync(assessmentFile, () => {
+        const validation = validateAssessmentFreshness(assessmentId, snapshot, {
+            allow_unconfirmed: true,
+            // A standalone CLI has no active MCP profile snapshot. The execute path
+            // still performs the full tool-manifest check before creating the task.
+            skip_tool_manifest: true,
+        });
+        if (!validation.valid || !validation.assessment) {
+            throw new PatchWardenError(validation.failure_reason || "assessment_validation_failed", `Assessment "${assessmentId}" cannot be confirmed: ${validation.failure_reason || "validation_failed"}.`, "Run create_task with execution_mode=assess_only again, then confirm the new assessment locally.");
+        }
+        if (validation.assessment.decision !== "needs_confirm" || !validation.assessment.requires_confirm) {
+            throw new PatchWardenError("assessment_confirmation_not_allowed", `Assessment "${assessmentId}" is no longer eligible for local confirmation.`, "Run create_task with execution_mode=assess_only again.");
+        }
+        const confirmedAt = validation.assessment.confirmed_at || new Date().toISOString();
+        const confirmedRecord = {
+            ...validation.assessment,
+            confirmed: true,
+            confirmed_at: confirmedAt,
+            confirm_code: validation.assessment.confirm_code || randomBytes(8).toString("hex"),
+        };
+        atomicWriteJsonFileSync(assessmentFile, confirmedRecord);
+        return {
+            assessment_id: assessmentId,
+            decision: "needs_confirm",
+            confirmed: true,
+            confirmed_at: confirmedAt,
+            expires_at: confirmedRecord.expires_at,
+            next_action: "Call create_task with only execution_mode=execute and this full assessment_id.",
+        };
     });
-    if (!validation.valid || !validation.assessment) {
-        throw new PatchWardenError(validation.failure_reason || "assessment_validation_failed", `Assessment "${assessmentId}" cannot be confirmed: ${validation.failure_reason || "validation_failed"}.`, "Run create_task with execution_mode=assess_only again, then confirm the new assessment locally.");
-    }
-    const confirmedAt = validation.assessment.confirmed_at || new Date().toISOString();
-    const confirmedRecord = {
-        ...validation.assessment,
-        confirmed: true,
-        confirmed_at: confirmedAt,
-        confirm_code: validation.assessment.confirm_code || randomBytes(8).toString("hex"),
-    };
-    const config = getConfig();
-    const assessmentFile = resolve(getAssessmentsDir(config), assessmentId, "assessment.json");
-    guardPath(assessmentFile, config.workspaceRoot, config.assessmentsDir);
-    const temporaryFile = `${assessmentFile}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
-    guardPath(temporaryFile, config.workspaceRoot, config.assessmentsDir);
-    writeFileSync(temporaryFile, JSON.stringify(confirmedRecord, null, 2), "utf-8");
-    renameSync(temporaryFile, assessmentFile);
-    return {
-        assessment_id: assessmentId,
-        decision: "needs_confirm",
-        confirmed: true,
-        confirmed_at: confirmedAt,
-        expires_at: confirmedRecord.expires_at,
-        next_action: "Call create_task with only execution_mode=execute and this full assessment_id.",
-    };
 }
 export function computeWorkspaceFingerprint(snapshot) {
     const fileHashes = Object.entries(snapshot.files)

package/dist/assessments/confirmCli.js

@@ -9,18 +9,19 @@
 import { loadConfig } from "../config.js";
 import { confirmAssessment } from "./assessmentStore.js";
 import { errorPayload } from "../errors.js";
+import { logger } from "../logging.js";
 loadConfig();
 const assessmentId = process.argv[2];
 if (!assessmentId || process.argv.length !== 3) {
-    console.error("Usage: patchwarden-confirm <full_assessment_id>");
-    console.error("The display-only assessment_short_id is not accepted.");
+    logger.info("Usage: patchwarden-confirm <full_assessment_id>");
+    logger.info("The display-only assessment_short_id is not accepted.");
     process.exit(1);
 }
 try {
-    const result = confirmAssessment(assessmentId);
+    const result = await confirmAssessment(assessmentId);
     console.log(JSON.stringify(result, null, 2));
 }
 catch (error) {
-    console.error(JSON.stringify(errorPayload(error), null, 2));
+    logger.error("confirm_assessment_failed", { error: errorPayload(error) });
     process.exit(1);
 }

package/dist/config.d.ts

@@ -1,6 +1,9 @@
 export interface AgentConfig {
     command: string;
     args: string[];
+    envAllowlist?: string[];
+    adapter?: string;
+    model?: string;
 }
 export interface PatchWardenConfig {
     workspaceRoot: string;
@@ -17,11 +20,30 @@ export interface PatchWardenConfig {
     watcherStaleSeconds: number;
     toolProfile?: "full" | "chatgpt_core" | "chatgpt_direct" | "chatgpt_search";
     repoAliases?: Record<string, string>;
+    httpPort?: number;
+    http?: {
+        port?: number;
+        host?: string;
+        ownerTokenEnv?: string;
+    };
+    enableRunTaskTool?: boolean;
     enableAgentAssessment?: boolean;
     agentAssessmentTimeoutSeconds?: number;
     agentAssessmentMaxOutputBytes?: number;
     agentAssessmentAgentName?: string;
     enableDirectProfile?: boolean;
+    tunnelClientPath?: string;
+    tunnelProxy?: {
+        scope: "shared" | "separate";
+        core: {
+            mode: "environment" | "none" | "manual";
+            url?: string;
+        };
+        direct: {
+            mode: "environment" | "none" | "manual";
+            url?: string;
+        };
+    };
     directSessionsDir: string;
     directSessionTtlSeconds: number;
     directMaxPatchBytes: number;