patchwarden 1.6.1 → 1.6.2

package/docs/open-source-application.md

@@ -56,24 +56,24 @@ evidence packs.
 
 ## Current Public Evidence
 
-Remote snapshot checked on 2026-07-19:
+Remote snapshot checked on 2026-07-23:
 
 - GitHub repository: `jiezeng2004-design/PatchWarden`
 - Stars: 2
 - Forks: 0
-- Open issues: 9
-- Open pull requests: 4
-- GitHub latest release: `v1.6.0`, published on 2026-07-16
-- npm latest dist-tag: `patchwarden@1.5.1`
+- Open issues: 5
+- Open pull requests: 1
+- GitHub latest release: `v1.6.1`, published on 2026-07-23
+- npm latest dist-tag: `patchwarden@1.6.1`
 
 Local workspace facts, kept separate from the public snapshot:
 
 - Local source version in `package.json`: `1.6.1`
-- Local working branch: `codex/windows-desktop-tunnel-fixes`
+- Verified release commit: `2ab2b7405d89b12c4ef10febf56404de59c04053`
 
-Local source is `v1.6.1`; the 2026-07-19 remote snapshot still records GitHub
-Release `v1.6.0` and npm `latest` `1.5.1`. Treat the publication surfaces as out
-of sync; local builds do not establish that either remote surface was updated.
+The local source, GitHub Release, and npm `latest` are synchronized at `v1.6.1`.
+The GitHub Release contains reviewed Core and Windows Desktop assets plus
+SHA-256 manifests.
 
 ## Existing Project Evidence
 
@@ -117,9 +117,8 @@ Known gaps before submission:
 - collect 3 to 5 real user reports through GitHub issues or discussions
 - record a live screencast if stronger evidence is needed; a privacy-safe
   scripted GIF now exists for the public maintainer workflow
-- resolve the release lag through the reviewed workflow; local source is
-  `1.6.1`, while the last verified GitHub Release is `1.6.0` and npm `latest`
-  / `dist-tags.latest` are `1.5.1`
+- keep future source, GitHub Release, and npm publication facts synchronized
+  through the reviewed release workflow
 - add small contributor-friendly roadmap issues such as macOS docs, Codex CLI
   examples, and a minimal demo repository
 

package/docs/release-evidence.md

@@ -5,28 +5,24 @@ before submitting external applications or publishing a release.
 
 ## Current Snapshot
 
-Remote facts checked on 2026-07-19. Local source and branch values were read
-from the PatchWarden workspace and are not evidence that a public package was
-published.
+Remote facts checked on 2026-07-23 after the v1.6.1 release completed.
 
 | Surface | Current evidence |
 | --- | --- |
-| Local branch | `codex/windows-desktop-tunnel-fixes` |
+| Verified merge commit | `2ab2b7405d89b12c4ef10febf56404de59c04053` |
 | Local `package.json` | `patchwarden@1.6.1` |
-| GitHub latest release | `v1.6.0` |
-| GitHub release URL | https://github.com/jiezeng2004-design/PatchWarden/releases/tag/v1.6.0 |
-| GitHub release published on | 2026-07-16 |
-| npm latest | `patchwarden@1.5.1` |
-| npm `dist-tags.latest` | `1.5.1` |
+| GitHub latest release | `v1.6.1` |
+| GitHub release URL | https://github.com/jiezeng2004-design/PatchWarden/releases/tag/v1.6.1 |
+| GitHub release published on | 2026-07-23 |
+| npm latest | `patchwarden@1.6.1` |
+| npm `dist-tags.latest` | `1.6.1` |
 | GitHub stars | 2 |
 | GitHub forks | 0 |
-| Open issues | 9 |
-| Open pull requests | 4 |
+| Open issues | 5 |
+| Open pull requests | 1 |
 
-Conclusion: local source is `v1.6.1`; the last verified GitHub Release is
-`v1.6.0`, while npm `latest` remains `1.5.1`. Do not describe the public
-release surfaces as synchronized until GitHub, npm, and `dist-tags.latest` are
-independently verified at the intended version.
+Conclusion: source, Git tag, GitHub Release, npm package version, and
+`dist-tags.latest` are independently verified at `v1.6.1`.
 
 ## Commands Used
 
@@ -34,49 +30,39 @@ Windows PowerShell:
 
 ```powershell
 gh repo view jiezeng2004-design/PatchWarden --json nameWithOwner,stargazerCount,forkCount,issues,pullRequests,defaultBranchRef,pushedAt,url,description,licenseInfo,repositoryTopics,latestRelease,hasDiscussionsEnabled,hasIssuesEnabled,securityPolicyUrl
-gh release view v1.6.0 --repo jiezeng2004-design/PatchWarden --json tagName,name,publishedAt,isDraft,isPrerelease,url
+gh release view v1.6.1 --repo jiezeng2004-design/PatchWarden --json tagName,name,publishedAt,isDraft,isPrerelease,url
 gh release view --repo jiezeng2004-design/PatchWarden --json tagName,name,publishedAt,isDraft,isPrerelease,url
 npm.cmd view patchwarden version dist-tags --json --cache .\.npm-cache
 ```
 
-The npm query was verified on 2026-07-19: `version=1.5.1` and
-`dist-tags.latest=1.5.1`.
+The npm query was verified on 2026-07-23: `version=1.6.1` and
+`dist-tags.latest=1.6.1`.
 
-## Local Verification Snapshot (Separate From Remote Truth)
+## v1.6.1 Verification Snapshot
 
-The following 2026-07-19 baseline checks describe the local working tree only.
-They do not prove GitHub/npm publication state, and the complete gate must be
-rerun after the current optimization work finishes.
-
-- Root TypeScript `--noEmit` and the Desktop TypeScript build: passed.
-- Targeted reliability/security tests: 49 passed; targeted Desktop backend
-  lifecycle tests: 8 passed.
-- `npm.cmd test`: passed on the second baseline run, including 139/139 security
-  checks, 747 passed and 2 skipped unit tests, 22/22 lifecycle checks, and
-  32/32 Control Center checks. An earlier run exposed one Git commit setup
-  flake; the test setup was then hardened.
-- `npm.cmd run test:mcp`: passed.
-- `npm.cmd run test:http-mcp`: 13 passed, 0 failed.
-- `npm.cmd run desktop:test`: 41 passed, 0 failed at the baseline snapshot.
+- GitHub CI: Node.js 18, Ubuntu Node.js 20, Windows Node.js 20, secret scan,
+  Windows Desktop installer, and final CI gate passed.
+- Core security smoke: 141/141; unit tests: 855 passed and 3 skipped;
+  lifecycle: 22/22; HTTP MCP: 17/17; MCP smoke and Doctor passed.
+- Desktop tests: 54/54; clean-source Desktop preflight and packaged UI smoke
+  passed from the verified merge commit.
 - Root and Desktop dependency audits: 0 known vulnerabilities.
-- `npm.cmd run pack:clean` was not run for this historical baseline. Current
-  versions recreate only `release/package/` plus the two root package archives;
-  Desktop and preflight siblings under `release/` are preserved. It still
-  overwrites those package artifacts, so run it only during explicitly approved
-  release preparation.
+- Clean release directory: 532 files; npm package manifest: 531 files.
+- GitHub Release: six reviewed assets with GitHub-computed and local SHA-256
+  digests; installer signature status is explicitly documented as unsigned.
 
 ## Release Verification Checklist
 
-- [ ] Confirm the target version in `package.json`.
-- [ ] Confirm `src/version.ts`, package metadata, README version text, and
+- [x] Confirm the target version in `package.json`.
+- [x] Confirm `src/version.ts`, package metadata, README version text, and
       changelog agree.
-- [ ] Run the complete local gate chain from `AGENTS.md`.
-- [ ] Open a PR and wait for the GitHub CI gate.
-- [ ] Merge only after review.
-- [ ] Create the tag from the verified merge commit.
-- [ ] Create the GitHub Release with reviewed artifacts and checksums.
-- [ ] Publish `patchwarden` to npm using process-scoped authentication.
-- [ ] Verify the remote tag, GitHub Release, npm package version, and
+- [x] Run the complete local gate chain from `AGENTS.md`.
+- [x] Open a PR and wait for the GitHub CI gate.
+- [x] Merge only after review.
+- [x] Create the tag from the verified merge commit.
+- [x] Create the GitHub Release with reviewed artifacts and checksums.
+- [x] Publish `patchwarden` to npm using process-scoped authentication.
+- [x] Verify the remote tag, GitHub Release, npm package version, and
       `dist-tags.latest`.
 
 Do not publish new versions under the frozen pre-rename package name.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchwarden",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "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",

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

@@ -251,6 +251,7 @@ async function testStaticFiles() {
     const css = await httpGet(`${BASE_URL}/colors_and_type.css`);
     const desktopCss = await httpGet(`${BASE_URL}/desktop.css`);
     const desktopBridge = await httpGet(`${BASE_URL}/desktop-bridge.js`);
+    const logParser = await httpGet(`${BASE_URL}/log-parser.js`);
     const i18n = await httpGet(`${BASE_URL}/i18n.js`);
     const gettingStarted = await httpGet(`${BASE_URL}/pages/getting-started.html`);
     const gettingStartedJs = await httpGet(`${BASE_URL}/getting-started.js`);
@@ -280,6 +281,9 @@ async function testStaticFiles() {
     if (desktopBridge.status !== 200 || !(desktopBridge.headers["content-type"] || "").includes("javascript")) {
       checks.push("desktop bridge is not served as JavaScript");
     }
+    if (logParser.status !== 200 || !(logParser.headers["content-type"] || "").includes("javascript") || !logParser.body.includes("PatchWardenLogParser")) {
+      checks.push("log parser is not served as JavaScript");
+    }
     if (i18n.status !== 200 || !i18n.body.includes("applyTranslations") || !i18n.body.includes('"zh-CN"') || !i18n.body.includes("en:")) {
       checks.push("shared Chinese/English translation dictionary is unavailable");
     }
@@ -940,9 +944,9 @@ async function testReconcileNoToken() {
   }
 }
 
-// ── Test 14: GET /api/direct-sessions returns empty list (not 500)
+// ── Test 14: GET /api/direct-sessions returns a bounded list (not 500)
 async function testDirectSessionsEmptyList() {
-  const name = "Test 14: /api/direct-sessions returns empty list (not 500) when dir missing";
+  const name = "Test 14: /api/direct-sessions returns a bounded list (not 500)";
   try {
     const res = await httpGet(`${BASE_URL}/api/direct-sessions`);
     if (res.status !== 200) {
@@ -961,8 +965,11 @@ async function testDirectSessionsEmptyList() {
     if (!isObject(json.filters) || !isObject(json.filters.options)) problems.push("'filters' contract is missing");
     if (typeof json.direct_profile_enabled !== "boolean") problems.push("'direct_profile_enabled' is not a boolean");
     if (json.reason !== null && typeof json.reason !== "string") problems.push("'reason' is neither null nor string");
-    if (Array.isArray(json.sessions) && json.sessions.length !== json.total) {
-      problems.push(`sessions.length (${json.sessions.length}) != total (${json.total})`);
+    if (Array.isArray(json.sessions) && json.sessions.length > json.total) {
+      problems.push(`sessions.length (${json.sessions.length}) exceeds total (${json.total})`);
+    }
+    if (Array.isArray(json.sessions) && json.sessions.length < json.total && typeof json.nextCursor !== "string") {
+      problems.push("paginated direct sessions response is missing nextCursor");
     }
     const invalidDetail = await httpGet(`${BASE_URL}/api/direct-sessions/invalid.id`);
     const invalidSummary = await httpGet(`${BASE_URL}/api/direct-sessions/invalid.id/summary`);

package/scripts/checks/lifecycle-smoke.js

@@ -170,6 +170,9 @@ try {
     if (result.total !== 8 || result.agents.some((agent) => !agent.available)) {
       throw new Error(`Unexpected agent availability: ${JSON.stringify(result)}`);
     }
+    if (result.agents.some((agent) => agent.availability_scope !== "executable_only" || agent.provider_status !== "not_checked")) {
+      throw new Error(`Agent readiness scope was not explicit: ${JSON.stringify(result)}`);
+    }
   });
 
   await test("git diff captures tracked and untracked task changes", async () => {
@@ -803,12 +806,12 @@ try {
     const task = await 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")) {
+    if (result.status !== "timeout" || !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) {
+    if (status.phase !== "timeout" || status.termination_reason !== "timeout" || !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");

package/scripts/checks/mcp-smoke.js

@@ -14,7 +14,10 @@ import { fileURLToPath } from "node:url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 
-const root = resolve(fileURLToPath(new URL("../..", import.meta.url)));
+const sourceRoot = resolve(fileURLToPath(new URL("../..", import.meta.url)));
+const root = process.env.PATCHWARDEN_TEST_RUNTIME_ROOT
+  ? resolve(process.env.PATCHWARDEN_TEST_RUNTIME_ROOT)
+  : sourceRoot;
 const packageJson = JSON.parse(readFileSync(join(root, "package.json"), "utf-8"));
 const expectedServerVersion = packageJson.version;
 const tempRoot = mkdtempSync(join(tmpdir(), "patchwarden-mcp-"));
@@ -292,6 +295,33 @@ try {
   }
   ok("create_task accepts inline plans and guarded templates");
 
+  const assessment = await parseToolJson("create_task", {
+    execution_mode: "assess_only",
+    template: "inspect_only",
+    goal: "Inspect package metadata without changing files.",
+    agent: "codex",
+    repo_path: ".",
+    verify_commands: [],
+    scope: ["package.json"],
+    forbidden: ["release/**"],
+  });
+  const assessmentFile = join(workspaceRoot, ".patchwarden", "assessments", assessment.assessment_id, "assessment.json");
+  const assessmentRecord = JSON.parse(readFileSync(assessmentFile, "utf-8"));
+  if (
+    !/^[a-f0-9]{64}$/.test(assessmentRecord.execution_config_hash || "") ||
+    assessmentRecord.assessment_security_snapshot_version !== "assessment-security-v2"
+  ) {
+    throw new Error(`assessment security fingerprint missing: ${JSON.stringify(assessmentRecord)}`);
+  }
+  const assessedTask = await parseToolJson("create_task", {
+    execution_mode: "execute",
+    assessment_id: assessment.assessment_id,
+  });
+  if (assessedTask.status !== "pending" || !assessedTask.task_id) {
+    throw new Error(`two-stage assessment did not create a pending task: ${JSON.stringify(assessedTask)}`);
+  }
+  ok("assess_only then execute preserves the versioned security fingerprint");
+
   const blockedAgent = await client.callTool({
     name: "create_task",
     arguments: { plan_id: plan.plan_id, agent: "missing-agent", repo_path: "." },

package/scripts/checks/watcher-supervisor-smoke.js

@@ -36,8 +36,9 @@ try {
     }
   });
 
+  await runReusedPidLockScenario();
   await runExternalScenario();
-  console.log("ok - watcher supervisor isolates environment and handles exit, stale heartbeat, retry limit, and external ownership");
+  console.log("ok - watcher supervisor isolates environment and handles exit, stale heartbeat, PID reuse, retry limit, and external ownership");
 } finally {
   for (const child of children) {
     if (child.exitCode === null) child.kill("SIGKILL");
@@ -45,6 +46,32 @@ try {
   rmSync(temp, { recursive: true, force: true });
 }
 
+async function runReusedPidLockScenario() {
+  const fixture = createFixture("reused-pid-lock");
+  mkdirSync(dirname(fixture.lockPath), { recursive: true });
+  writeFileSync(fixture.lockPath, JSON.stringify({
+    pid: process.pid,
+    instance_id: "stale-reused-pid",
+    launcher_pid: 999999,
+    started_at: "2026-01-01T00:00:00.000Z",
+  }), "utf-8");
+  writeFileSync(fixture.heartbeatPath, JSON.stringify({
+    status: "running",
+    pid: process.pid,
+    instance_id: "stale-reused-pid",
+    launcher_pid: 999999,
+    started_at: "2026-01-01T00:00:00.000Z",
+    last_heartbeat_at: "2026-01-01T00:00:00.000Z",
+  }), "utf-8");
+
+  const result = runLauncher(fixture, "healthy", 1, 7_000);
+  if (result.error && result.error.code === "ETIMEDOUT") throw result.error;
+  const attempts = Number(readFileSync(fixture.watcherAttemptPath, "utf-8")) || 0;
+  if (attempts < 1 || !result.stdout.includes("Removed stale watcher lock after PID identity verification")) {
+    throw new Error(`Reused PID lock was not safely retired: ${JSON.stringify({ attempts, stdout: result.stdout, stderr: result.stderr })}`);
+  }
+}
+
 async function runScenario(label, mode, maxRestarts, lifetimeMs, assertState) {
   const fixture = createFixture(label.replace(/[^a-z0-9]+/gi, "-"));
   const result = runLauncher(fixture, mode, maxRestarts, lifetimeMs);
@@ -139,6 +166,7 @@ function createFixture(name) {
     watcherPath,
     watcherAttemptPath,
     heartbeatPath: join(workspace, ".patchwarden", "watcher-heartbeat.json"),
+    lockPath: join(workspace, ".patchwarden", "watcher.lock"),
     watcherStatusPath: join(localAppData, "patchwarden", "runtime", "watcher-status.json"),
     mockCmd,
     localAppData,

package/scripts/control/start-patchwarden-tunnel.ps1

@@ -80,6 +80,15 @@ if (-not $ConfigPath) {
 }
 $McpLauncherName = if ($ToolProfile -eq "chatgpt_direct") { "patchwarden-mcp-direct.cmd" } else { "patchwarden-mcp-stdio.cmd" }
 $McpStdioLauncher = Join-Path $ProjectRoot "scripts\mcp\$McpLauncherName"
+$McpEntryPath = Join-Path $ProjectRoot "dist\index.js"
+$WatcherEntryPath = Join-Path $ProjectRoot "dist\runner\watch.js"
+$RuntimeBuildLayout = if (Test-Path -LiteralPath (Join-Path $ProjectRoot ".git")) {
+  "git_worktree"
+} elseif ($ProjectRoot -match '(?i)[\\/]resources[\\/]core$') {
+  "desktop_packaged_core"
+} else {
+  "standalone_build"
+}
 $McpStdioLauncherForTunnel = $McpStdioLauncher -replace "\\", "/"
 $OpencodeConfigHome = Join-Path $env:LOCALAPPDATA "patchwarden\opencode-config"
 $ProfilePath = Join-Path $env:APPDATA "tunnel-client\$Profile.yaml"
@@ -243,6 +252,14 @@ function Get-LastDiagnosticLine {
   return $Fallback
 }
 
+function Get-MaskedTunnelId {
+  param([string]$Value)
+  if ([string]::IsNullOrWhiteSpace($Value)) { return $null }
+  $trimmed = $Value.Trim()
+  if ($trimmed.Length -le 8) { return "***" }
+  return "$($trimmed.Substring(0, 4))***$($trimmed.Substring($trimmed.Length - 4))"
+}
+
 function Write-TunnelStatus {
   param(
     [string]$Status,
@@ -263,6 +280,8 @@ function Write-TunnelStatus {
     status = $Status
     reason_code = $ReasonCode
     ready = $Ready
+    profile = $Profile
+    tunnel_id_masked = Get-MaskedTunnelId -Value $TunnelId
     attempt = $Attempt
     pid = $ProcessId
     checked_at = (Get-Date).ToUniversalTime().ToString("o")
@@ -281,6 +300,12 @@ function Write-TunnelStatus {
     tool_manifest_sha256 = if ($script:ToolManifest) { $script:ToolManifest.tool_manifest_sha256 } else { $null }
     tools_ready = [bool]($script:ToolManifest -and $script:ToolManifest.ok)
     core_tools_ready = [bool]($ToolProfile -eq "chatgpt_core" -and $script:ToolManifest -and $script:ToolManifest.ok)
+    project_root = $ProjectRoot
+    config_path = $ConfigPath
+    mcp_entry_path = $McpEntryPath
+    watcher_entry_path = $WatcherEntryPath
+    validator_module_path = (Join-Path $ProjectRoot "dist\assessments\assessmentStore.js")
+    runtime_build_layout = $RuntimeBuildLayout
   }
   $temporary = "$StatusFile.tmp"
   $payload | ConvertTo-Json -Depth 4 | Set-Content -LiteralPath $temporary -Encoding UTF8
@@ -344,6 +369,30 @@ function Get-WatcherHeartbeatState {
   }
 }
 
+function Repair-StaleWatcherLock {
+  $settings = Get-WatcherSettings
+  $lockPath = Join-Path (Split-Path -Parent $settings.HeartbeatPath) "watcher.lock"
+  if (-not (Test-Path -LiteralPath $lockPath)) { return "not_present" }
+  try {
+    $lock = Get-Content -LiteralPath $lockPath -Raw -Encoding UTF8 | ConvertFrom-Json
+    $lockPid = [int]$lock.pid
+    if ($lockPid -le 0) { return "unverified" }
+    $candidate = Get-CimInstance Win32_Process -Filter "ProcessId = $lockPid" -ErrorAction Stop
+    if ($candidate) {
+      $normalizedCommand = ([string]$candidate.CommandLine).Replace("/", "\")
+      $normalizedExpected = ([System.IO.Path]::GetFullPath($WatcherEntryPath)).Replace("/", "\")
+      $isExpectedWatcher = [string]$candidate.Name -ieq "node.exe" -and
+        $normalizedCommand.IndexOf($normalizedExpected, [StringComparison]::OrdinalIgnoreCase) -ge 0
+      if ($isExpectedWatcher) { return "expected_watcher_alive" }
+    }
+    Remove-Item -LiteralPath $lockPath -Force -ErrorAction Stop
+    Write-Host "[watch] Removed stale watcher lock after PID identity verification."
+    return "removed"
+  } catch {
+    return "unverified"
+  }
+}
+
 function Write-WatcherStatus {
   param([string]$Status, [string]$LastError = $null)
   New-Item -ItemType Directory -Force -Path $RuntimeDirectory | Out-Null
@@ -356,6 +405,11 @@ function Write-WatcherStatus {
     restart_attempts = $script:WatcherRestartAttempts
     checked_at = (Get-Date).ToUniversalTime().ToString("o")
     last_error = if ($LastError) { ($LastError -replace '[\r\n]+', ' ').Substring(0, [Math]::Min(500, ($LastError -replace '[\r\n]+', ' ').Length)) } else { $null }
+    project_root = $ProjectRoot
+    config_path = $ConfigPath
+    watcher_entry_path = $WatcherEntryPath
+    validator_module_path = (Join-Path $ProjectRoot "dist\assessments\assessmentStore.js")
+    runtime_build_layout = $RuntimeBuildLayout
   }
   $temporary = "$WatcherStatusFile.tmp"
   $payload | ConvertTo-Json -Depth 4 | Set-Content -LiteralPath $temporary -Encoding UTF8
@@ -379,6 +433,7 @@ function Start-OwnedWatcherProcess {
   $script:WatcherHealthySince = $null
   $previousWatcherInstanceId = $env:PATCHWARDEN_WATCHER_INSTANCE_ID
   $previousWatcherLauncherPid = $env:PATCHWARDEN_WATCHER_LAUNCHER_PID
+  $previousToolProfile = $env:PATCHWARDEN_TOOL_PROFILE
   $previousXdgConfigHome = $env:XDG_CONFIG_HOME
   $previousPath = $env:PATH
   $previousControlPlaneApiKey = $env:CONTROL_PLANE_API_KEY
@@ -386,17 +441,19 @@ function Start-OwnedWatcherProcess {
   try {
     $env:PATCHWARDEN_WATCHER_INSTANCE_ID = $script:WatcherInstanceId
     $env:PATCHWARDEN_WATCHER_LAUNCHER_PID = [string]$PID
+    $env:PATCHWARDEN_TOOL_PROFILE = $ToolProfile
     $env:XDG_CONFIG_HOME = $OpencodeConfigHome
     if ($OpencodeBin) { $env:PATH = "$OpencodeBin;$env:PATH" }
     Remove-Item Env:CONTROL_PLANE_API_KEY -ErrorAction SilentlyContinue
     Remove-Item Env:PATCHWARDEN_OWNER_TOKEN -ErrorAction SilentlyContinue
     $script:WatcherProcess = Start-Process -FilePath $node `
-      -ArgumentList @((Join-Path $ProjectRoot "dist\runner\watch.js")) `
+      -ArgumentList @($WatcherEntryPath) `
       -WorkingDirectory $ProjectRoot -PassThru -WindowStyle Hidden `
       -RedirectStandardOutput $stdout -RedirectStandardError $stderr
   } finally {
     if ($null -eq $previousWatcherInstanceId) { Remove-Item Env:PATCHWARDEN_WATCHER_INSTANCE_ID -ErrorAction SilentlyContinue } else { $env:PATCHWARDEN_WATCHER_INSTANCE_ID = $previousWatcherInstanceId }
     if ($null -eq $previousWatcherLauncherPid) { Remove-Item Env:PATCHWARDEN_WATCHER_LAUNCHER_PID -ErrorAction SilentlyContinue } else { $env:PATCHWARDEN_WATCHER_LAUNCHER_PID = $previousWatcherLauncherPid }
+    if ($null -eq $previousToolProfile) { Remove-Item Env:PATCHWARDEN_TOOL_PROFILE -ErrorAction SilentlyContinue } else { $env:PATCHWARDEN_TOOL_PROFILE = $previousToolProfile }
     if ($null -eq $previousXdgConfigHome) { Remove-Item Env:XDG_CONFIG_HOME -ErrorAction SilentlyContinue } else { $env:XDG_CONFIG_HOME = $previousXdgConfigHome }
     if ($null -eq $previousControlPlaneApiKey) { Remove-Item Env:CONTROL_PLANE_API_KEY -ErrorAction SilentlyContinue } else { $env:CONTROL_PLANE_API_KEY = $previousControlPlaneApiKey }
     if ($null -eq $previousOwnerToken) { Remove-Item Env:PATCHWARDEN_OWNER_TOKEN -ErrorAction SilentlyContinue } else { $env:PATCHWARDEN_OWNER_TOKEN = $previousOwnerToken }
@@ -414,6 +471,13 @@ function Start-PatchWardenWatcher {
     Write-Host "[watch] Existing watcher heartbeat is fresh; it remains external and will not be managed."
     return
   }
+  $lockRepair = Repair-StaleWatcherLock
+  if ($lockRepair -eq "expected_watcher_alive" -or $lockRepair -eq "unverified") {
+    $script:WatcherManaged = $false
+    Write-WatcherStatus -Status "external_stale" -LastError "A stale watcher lock could not be safely retired."
+    Write-Host "[watch] Stale watcher lock retained because process ownership could not be disproved."
+    return
+  }
   Start-OwnedWatcherProcess
 }
 

package/scripts/e2e/demo-runtime.mjs

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+
+const runtimeRoot = resolve(process.env.PATCHWARDEN_RUNTIME_ROOT || join(import.meta.dirname, "..", "..", "release", "desktop", "win-unpacked", "resources", "core"));
+const configPath = resolve(process.env.PATCHWARDEN_CONFIG || join(process.env.LOCALAPPDATA || "", "PatchWarden", "patchwarden.config.json"));
+const fixture = resolve(process.env.PATCHWARDEN_DEMO_FIXTURE || join(process.env.PATCHWARDEN_WORKSPACE || "D:/ai_agent/patchwarden_program", "patchwarden-demo-fixture"));
+const evidencePath = resolve(process.env.PATCHWARDEN_DEMO_EVIDENCE || join(process.env.PATCHWARDEN_WORKSPACE || "D:/ai_agent/patchwarden_program", ".patchwarden", "demo-runtime-evidence.json"));
+const mode = process.argv[2] || "core-prepare";
+const profile = mode === "direct" ? "chatgpt_direct" : "chatgpt_core";
+
+function decode(result) {
+  if (result?.isError) {
+    const message = result.content?.find((item) => item.type === "text")?.text || "MCP tool error";
+    throw new Error(message);
+  }
+  const text = result?.content?.find((item) => item.type === "text")?.text;
+  if (typeof text !== "string") return result;
+  try { return JSON.parse(text); } catch { return { text }; }
+}
+
+async function connect() {
+  const transport = new StdioClientTransport({
+    command: process.execPath,
+    args: [join(runtimeRoot, "dist", "index.js")],
+    cwd: runtimeRoot,
+    env: {
+      ...process.env,
+      PATCHWARDEN_CONFIG: configPath,
+      PATCHWARDEN_TOOL_PROFILE: profile,
+    },
+    stderr: "pipe",
+  });
+  const client = new Client({ name: "patchwarden-demo-e2e", version: "1.0.0" }, { capabilities: {} });
+  await client.connect(transport);
+  return client;
+}
+
+async function call(client, name, args = {}) {
+  return decode(await client.callTool({ name, arguments: args }));
+}
+
+async function waitForTask(client, taskId) {
+  for (;;) {
+    const result = await call(client, "wait_for_task", { task_id: taskId, wait_seconds: 30 });
+    if (!result?.continuation_required) return result;
+  }
+}
+
+function saveEvidence(value) {
+  mkdirSync(resolve(evidencePath, ".."), { recursive: true });
+  writeFileSync(evidencePath, JSON.stringify(value, null, 2), "utf8");
+}
+
+function loadEvidence() {
+  return JSON.parse(readFileSync(evidencePath, "utf8"));
+}
+
+async function runCorePrepare(client) {
+  const health = await call(client, "health_check", { detail: "self_diagnostic" });
+  const agents = await call(client, "list_agents");
+  const ordinary = await call(client, "create_task", {
+    template: "inspect_only",
+    goal: "Read the Demo fixture README and package.json, run the configured tests, and return a short verification summary. Do not modify files.",
+    repo_path: "patchwarden-demo-fixture",
+    agent: "codex",
+    verify_commands: ["npm test", "npm run lint"],
+    timeout_seconds: 180,
+  });
+  const ordinarySummary = await waitForTask(client, ordinary.task_id);
+  const ordinaryAudit = await call(client, "audit_task", { task_id: ordinary.task_id });
+  const assessmentArgs = {
+    execution_mode: "assess_only",
+    template: "inspect_only",
+    goal: "Read the Demo fixture README and package.json, run npm test and npm run lint, and return a short verification summary. Do not modify files.",
+    repo_path: "patchwarden-demo-fixture",
+    agent: "codex",
+    verify_commands: ["npm test", "npm run lint"],
+    timeout_seconds: 180,
+  };
+  const assessmentBeforeRestart = await call(client, "create_task", assessmentArgs);
+  const assessmentPolicyChange = await call(client, "create_task", assessmentArgs);
+  saveEvidence({
+    created_at: new Date().toISOString(),
+    profile,
+    runtime_root: runtimeRoot,
+    config_path: configPath,
+    fixture,
+    health,
+    agents,
+    ordinary_task_id: ordinary.task_id,
+    ordinary_summary: ordinarySummary,
+    ordinary_audit: ordinaryAudit,
+    assessment_before_restart: assessmentBeforeRestart,
+    assessment_policy_change: assessmentPolicyChange,
+  });
+  console.log(JSON.stringify({ ordinary_task_id: ordinary.task_id, assessment_before_restart: assessmentBeforeRestart, assessment_policy_change: assessmentPolicyChange }, null, 2));
+}
+
+async function runCoreExecute(client) {
+  const evidence = loadEvidence();
+  const first = evidence.assessment_before_restart;
+  const second = evidence.assessment_policy_change;
+  const execute = await call(client, "create_task", { execution_mode: "execute", assessment_id: first.assessment_id });
+  const summary = await waitForTask(client, execute.task_id);
+  const audit = await call(client, "audit_task", { task_id: execute.task_id });
+  const policyDir = join(fixture, ".patchwarden");
+  mkdirSync(policyDir, { recursive: true });
+  writeFileSync(join(policyDir, "project-policy.json"), JSON.stringify({ allowed_commands: ["node --check main.js"] }, null, 2), "utf8");
+  let stale = null;
+  try {
+    stale = await call(client, "create_task", { execution_mode: "execute", assessment_id: second.assessment_id });
+  } catch (error) {
+    stale = { error: error instanceof Error ? error.message : String(error) };
+  }
+  saveEvidence({ ...evidence, execute_task_id: execute.task_id, execute_summary: summary, execute_audit: audit, stale_after_policy_change: stale });
+  console.log(JSON.stringify({ execute_task_id: execute.task_id, execute_summary: summary, execute_audit: audit, stale_after_policy_change: stale }, null, 2));
+}
+
+async function runDirect(client) {
+  const health = await call(client, "health_check", { detail: "self_diagnostic" });
+  const session = await call(client, "create_direct_session", { repo_path: "patchwarden-demo-fixture", title: "PatchWarden Demo Direct verification" });
+  const file = await call(client, "read_workspace_file", { session_id: session.session_id, path: "main.js" });
+  const verification = await call(client, "run_direct_verification_bundle", {
+    session_id: session.session_id,
+    commands: ["npm test", "npm run lint", "node --check main.js"],
+    timeout_seconds: 120,
+  });
+  const finalized = await call(client, "finalize_direct_session", { session_id: session.session_id });
+  const audit = await call(client, "audit_session", { session_id: session.session_id });
+  saveEvidence({ direct_health: health, direct_session_id: session.session_id, direct_file: { sha256: file.sha256, bytes: file.bytes }, direct_verification: verification, direct_finalized: finalized, direct_audit: audit });
+  console.log(JSON.stringify({ direct_session_id: session.session_id, direct_verification: verification, direct_audit: audit }, null, 2));
+}
+
+async function runStatus(client) {
+  const health = await call(client, "health_check", { detail: "self_diagnostic" });
+  const agents = await call(client, "list_agents");
+  const tasks = await call(client, "list_tasks", { active_only: true, limit: 50 });
+  console.log(JSON.stringify({ health, agents, active_tasks: tasks }, null, 2));
+}
+
+const client = await connect();
+try {
+  if (mode === "core-prepare") await runCorePrepare(client);
+  else if (mode === "core-execute") await runCoreExecute(client);
+  else if (mode === "direct") await runDirect(client);
+  else if (mode === "status") await runStatus(client);
+  else throw new Error(`Unsupported demo mode: ${mode}`);
+} finally {
+  await client.close();
+}

package/scripts/release/desktop-preflight.js

@@ -183,7 +183,7 @@ try {
   const manifestOutput = run("isolated packaged runtime manifest", process.execPath, ["scripts/checks/mcp-manifest-check.js", "--profile", "chatgpt_core"], isolatedRoot);
   report.runtime_manifest = JSON.parse(manifestOutput);
   if (!report.runtime_manifest.ok || report.runtime_manifest.server_version !== rootPackage.version || report.runtime_manifest.tool_count !== 26) {
-    throw new Error("Packaged runtime manifest did not match the 1.6.1 26-tool contract.");
+    throw new Error(`Packaged runtime manifest did not match the ${rootPackage.version} 26-tool contract.`);
   }
 
   if (!skipUiSmoke) {