From e4d828d3b5d53875cdb817bc012281c47d9dff17 Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Thu, 23 Apr 2026 12:52:54 -0400
Subject: [PATCH 01/11] Port ADE desktop to Windows and add ADE CLI launch
 support

Consolidates the windows-port-foundations work (MCP named pipes, CLI PATH,
portable shell usage, sandbox defaults, cmd worker shell, WMIC process list,
CLI resolution/sandbox hardening, process spawning) and the subsequent ADE
CLI launch + path handling polish into a single squashed commit on top of
the latest main.

Previously this lane consisted of:
  - c2a299f3 feat(windows): MCP named pipes, CLI PATH, portable shell usage
  - bd5eb3b4 feat(windows): sandbox defaults, cmd worker shell, WMIC process list
  - b8508fa3 fix(pr-160): address Greptile and CodeRabbit review comments
  - 1d528baf Harden Windows CLI resolution and sandbox checks
  - 5fa50fcc Fix Windows CLI process spawning
  - 0ecf0398 Merge origin/main (absorbed MCP proxy removal)
  - 8ada5605 Enable Windows ADE CLI launches and path handling

Squashed because main removed the MCP proxy (PR #166) after the earlier
Windows commits were authored, so replaying the original commits atop the
new main hits many modify/delete conflicts against files that no longer
exist. The final state here matches what the merge commit already
reconciled plus the subsequent ADE CLI launch work.
---
 apps/ade-cli/src/adeRpcServer.test.ts         |  17 +-
 apps/ade-cli/src/adeRpcServer.ts              |  52 ++--
 apps/ade-cli/src/bootstrap.ts                 |  40 ++-
 apps/ade-cli/src/cli.test.ts                  |   7 +-
 apps/ade-cli/src/cli.ts                       |  35 ++-
 apps/desktop/package.json                     |  16 ++
 apps/desktop/scripts/ade-cli-install-path.cmd |  36 +++
 .../scripts/ade-cli-windows-wrapper.cmd       |  35 +++
 .../scripts/after-pack-runtime-fixes.cjs      |  57 +++--
 apps/desktop/scripts/dev.cjs                  |  37 +--
 .../scripts/validate-win-artifacts.mjs        |  51 ++++
 apps/desktop/src/main/main.ts                 |  25 +-
 apps/desktop/src/main/packagedRuntimeSmoke.ts |   6 +-
 .../services/ai/cliExecutableResolver.test.ts | 115 ++++++++-
 .../main/services/ai/cliExecutableResolver.ts | 165 ++++++++++---
 .../services/ai/providerCredentialSources.ts  |  15 +-
 .../main/services/ai/providerTaskRunner.ts    |  18 +-
 .../main/services/ai/tools/globSearch.test.ts |  12 +
 .../src/main/services/ai/tools/globSearch.ts  |   4 +-
 .../services/ai/tools/universalTools.test.ts  |  89 ++++++-
 .../main/services/ai/tools/universalTools.ts  | 228 +++++++++++++----
 .../main/services/ai/tools/workflowTools.ts   |  14 +-
 .../automations/automationPlannerService.ts   |  37 +--
 .../services/automations/automationService.ts |   4 +-
 .../main/services/chat/agentChatService.ts    |  20 +-
 .../src/main/services/chat/cursorAcpPool.ts   |  40 ++-
 .../main/services/cli/adeCliService.test.ts   |  84 +++++++
 .../src/main/services/cli/adeCliService.ts    | 165 +++++++++++--
 .../services/computerUse/localComputerUse.ts  |   2 +-
 .../services/conflicts/conflictService.ts     |   6 +-
 .../src/main/services/ipc/registerIpc.ts      |  79 ++++--
 .../services/lanes/laneEnvironmentService.ts  |  48 +++-
 .../opencode/openCodeBinaryManager.ts         |  28 ++-
 .../main/services/opencode/openCodeRuntime.ts |   1 +
 .../opencode/openCodeServerManager.test.ts    |  98 ++++++--
 .../opencode/openCodeServerManager.ts         | 233 ++++++++++++++++--
 .../orchestrator/baseOrchestratorAdapter.ts   |  45 +++-
 .../orchestrator/orchestratorConstants.ts     |  41 +--
 .../orchestrator/orchestratorContext.ts       |  13 +-
 .../orchestrator/orchestratorService.ts       |  38 ++-
 .../providerOrchestratorAdapter.test.ts       |  67 +++++
 .../providerOrchestratorAdapter.ts            | 227 ++++++++++++++---
 .../src/main/services/pty/ptyService.test.ts  |  65 ++++-
 .../src/main/services/pty/ptyService.ts       |   6 +-
 .../services/shared/processExecution.test.ts  |  51 ++++
 .../main/services/shared/processExecution.ts  | 105 ++++++++
 .../desktop/src/main/services/shared/utils.ts |  19 +-
 apps/desktop/src/main/services/state/kvDb.ts  |   2 +
 .../src/main/services/sync/syncService.ts     |  14 +-
 .../src/main/services/tests/testService.ts    |  35 +--
 .../usage/usageTrackingService.test.ts        | 209 ++++++++++++++++
 .../services/usage/usageTrackingService.ts    |  95 ++++++-
 .../components/app/CommandPalette.tsx         |   2 +
 .../chat/AgentChatComposer.test.tsx           |  58 ++++-
 .../components/chat/AgentChatComposer.tsx     |   3 +-
 .../chat/AgentChatMessageList.test.tsx        | 203 +++++++++++++++
 .../components/chat/AgentChatMessageList.tsx  |  61 +++--
 .../components/chat/ChatComputerUsePanel.tsx  |  14 +-
 .../renderer/components/files/FilesPage.tsx   |  34 +--
 .../components/lanes/LaneGitActionsPane.tsx   |   3 +-
 .../components/prs/detail/PrDetailPane.tsx    |   5 +-
 .../components/settings/AdeCliSection.tsx     |   5 +-
 .../lib/dirtyWorkspaceBuffers.test.ts         |  35 +++
 .../src/renderer/lib/dirtyWorkspaceBuffers.ts |  47 +++-
 .../src/renderer/lib/pathUtils.test.ts        |  26 ++
 apps/desktop/src/renderer/lib/pathUtils.ts    |  75 ++++++
 apps/desktop/src/renderer/lib/platform.ts     |   1 +
 apps/desktop/src/renderer/lib/shell.test.ts   |  22 ++
 apps/desktop/src/renderer/lib/shell.ts        |  62 ++++-
 .../renderer/onboarding/tours/filesTour.ts    |   2 +-
 apps/desktop/src/shared/adeLayout.ts          |   3 +-
 apps/desktop/src/shared/adeMcpIpc.test.ts     |  48 ++++
 apps/desktop/src/shared/adeMcpIpc.ts          |  18 ++
 .../vendor/crsqlite/win32-x64/crsqlite.dll    | Bin 0 -> 1443655 bytes
 74 files changed, 3167 insertions(+), 511 deletions(-)
 create mode 100644 apps/desktop/scripts/ade-cli-install-path.cmd
 create mode 100644 apps/desktop/scripts/ade-cli-windows-wrapper.cmd
 create mode 100644 apps/desktop/scripts/validate-win-artifacts.mjs
 create mode 100644 apps/desktop/src/main/services/shared/processExecution.test.ts
 create mode 100644 apps/desktop/src/main/services/shared/processExecution.ts
 create mode 100644 apps/desktop/src/renderer/lib/dirtyWorkspaceBuffers.test.ts
 create mode 100644 apps/desktop/src/renderer/lib/pathUtils.test.ts
 create mode 100644 apps/desktop/src/renderer/lib/pathUtils.ts
 create mode 100644 apps/desktop/src/shared/adeMcpIpc.test.ts
 create mode 100644 apps/desktop/src/shared/adeMcpIpc.ts
 create mode 100644 apps/desktop/vendor/crsqlite/win32-x64/crsqlite.dll

diff --git a/apps/ade-cli/src/adeRpcServer.test.ts b/apps/ade-cli/src/adeRpcServer.test.ts
index f2763e853..9e44ea17a 100644
--- a/apps/ade-cli/src/adeRpcServer.test.ts
+++ b/apps/ade-cli/src/adeRpcServer.test.ts
@@ -1823,7 +1823,12 @@ describe("adeRpcServer", () => {
         cols: 120,
         rows: 36,
         tracked: true,
-        toolType: "claude-orchestrated"
+        toolType: "claude-orchestrated",
+        command: "claude",
+        args: expect.arrayContaining(["--model", "claude-sonnet-4-6", "--permission-mode", "default", "Implement API wiring"]),
+        env: expect.objectContaining({
+          ADE_DEFAULT_ROLE: "agent",
+        }),
       })
     );
     expect(response.structuredContent.startupCommand).toContain("claude");
@@ -1853,6 +1858,16 @@ describe("adeRpcServer", () => {
     expect(response.structuredContent.startupCommand).toContain("claude");
     expect(response.structuredContent.startupCommand).toContain("ADE_RUN_ID=run-1");
     expect(response.structuredContent.startupCommand).toContain("ADE_ATTEMPT_ID=attempt-workspace-roots");
+    expect(fixture.runtime.ptyService.create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        command: "claude",
+        env: expect.objectContaining({
+          ADE_RUN_ID: "run-1",
+          ADE_ATTEMPT_ID: "attempt-workspace-roots",
+          ADE_DEFAULT_ROLE: "agent",
+        }),
+      })
+    );
   });
 
   it("rejects config-toml permission mode for Claude spawn_agent sessions", async () => {
diff --git a/apps/ade-cli/src/adeRpcServer.ts b/apps/ade-cli/src/adeRpcServer.ts
index 9e2b23cfd..d4211b4a1 100644
--- a/apps/ade-cli/src/adeRpcServer.ts
+++ b/apps/ade-cli/src/adeRpcServer.ts
@@ -5886,46 +5886,63 @@ async function runTool(args: {
     }
     const finalPrompt = promptSegments.join("\n").trim();
 
-    const commandParts: string[] = [provider];
+    const commandArgs: string[] = [];
+    const commandPreviewParts: string[] = [provider];
     if (model) {
-      commandParts.push("--model", shellEscapeArg(model));
+      commandArgs.push("--model", model);
+      commandPreviewParts.push("--model", shellEscapeArg(model));
     }
     if (provider === "codex") {
       if (permissionMode === "full-auto") {
-        commandParts.push("--dangerously-bypass-approvals-and-sandbox");
+        commandArgs.push("--dangerously-bypass-approvals-and-sandbox");
+        commandPreviewParts.push("--dangerously-bypass-approvals-and-sandbox");
       } else if (permissionMode === "default") {
-        commandParts.push("--full-auto");
+        commandArgs.push("--full-auto");
+        commandPreviewParts.push("--full-auto");
       } else if (permissionMode === "config-toml") {
         // No explicit Codex permission flags; let the host config.toml decide.
       } else if (permissionMode === "plan") {
-        commandParts.push("--sandbox", "read-only", "--ask-for-approval", "on-request");
+        commandArgs.push("--sandbox", "read-only", "--ask-for-approval", "on-request");
+        commandPreviewParts.push("--sandbox", "read-only", "--ask-for-approval", "on-request");
       } else {
-        commandParts.push("--sandbox", "workspace-write", "--ask-for-approval", "untrusted");
+        commandArgs.push("--sandbox", "workspace-write", "--ask-for-approval", "untrusted");
+        commandPreviewParts.push("--sandbox", "workspace-write", "--ask-for-approval", "untrusted");
       }
     } else {
       const claudePermission =
         permissionMode === "plan" ? "plan" : permissionMode === "full-auto" ? "bypassPermissions" : permissionMode === "edit" ? "acceptEdits" : "default";
-      commandParts.push("--permission-mode", claudePermission);
+      commandArgs.push("--permission-mode", claudePermission);
+      commandPreviewParts.push("--permission-mode", shellEscapeArg(claudePermission));
 
       // ADE-owned actions are exposed through the `ade` CLI. Child agent
       // sessions receive identity env vars below instead of an attached server.
     }
     if (finalPrompt) {
-      commandParts.push(shellEscapeArg(finalPrompt));
+      commandArgs.push(finalPrompt);
+      commandPreviewParts.push(shellEscapeArg(finalPrompt));
     }
 
-    // Prepend env vars for worker identity
+    // Attach worker identity through the process environment. The startup
+    // command remains a display/resume preview only; the actual launch uses
+    // command/args/env so it works on Windows without POSIX inline assignment.
+    const workerEnv: Record<string, string> = {};
     const envPrefixParts: string[] = [];
-    if (runId) envPrefixParts.push(`ADE_RUN_ID=${shellEscapeArg(runId)}`);
-    if (stepId) envPrefixParts.push(`ADE_STEP_ID=${shellEscapeArg(stepId)}`);
-    if (attemptId) envPrefixParts.push(`ADE_ATTEMPT_ID=${shellEscapeArg(attemptId)}`);
-    if (callerCtx.missionId) envPrefixParts.push(`ADE_MISSION_ID=${shellEscapeArg(callerCtx.missionId)}`);
-    if (callerCtx.ownerId) envPrefixParts.push(`ADE_OWNER_ID=${shellEscapeArg(callerCtx.ownerId)}`);
+    const addWorkerEnv = (key: string, value: string | null | undefined) => {
+      if (!value) return;
+      workerEnv[key] = value;
+      envPrefixParts.push(`${key}=${shellEscapeArg(value)}`);
+    };
+    addWorkerEnv("ADE_RUN_ID", runId);
+    addWorkerEnv("ADE_STEP_ID", stepId);
+    addWorkerEnv("ADE_ATTEMPT_ID", attemptId);
+    addWorkerEnv("ADE_MISSION_ID", callerCtx.missionId);
+    addWorkerEnv("ADE_OWNER_ID", callerCtx.ownerId);
+    workerEnv.ADE_DEFAULT_ROLE = "agent";
     envPrefixParts.push("ADE_DEFAULT_ROLE=agent");
 
     const startupCommand = envPrefixParts.length > 0
-      ? `${envPrefixParts.join(" ")} ${commandParts.join(" ")}`
-      : commandParts.join(" ");
+      ? `${envPrefixParts.join(" ")} ${commandPreviewParts.join(" ")}`
+      : commandPreviewParts.join(" ");
 
     const created = await runtime.ptyService.create({
       laneId,
@@ -5934,6 +5951,9 @@ async function runTool(args: {
       title,
       tracked: true,
       toolType: `${provider}-orchestrated`,
+      command: provider,
+      args: commandArgs,
+      env: workerEnv,
       startupCommand
     });
 
diff --git a/apps/ade-cli/src/bootstrap.ts b/apps/ade-cli/src/bootstrap.ts
index 65b1a7341..e983d3292 100644
--- a/apps/ade-cli/src/bootstrap.ts
+++ b/apps/ade-cli/src/bootstrap.ts
@@ -15,6 +15,8 @@ import { createDiffService } from "../../desktop/src/main/services/diffs/diffSer
 import { createMissionService } from "../../desktop/src/main/services/missions/missionService";
 import { createPtyService } from "../../desktop/src/main/services/pty/ptyService";
 import { createTestService } from "../../desktop/src/main/services/tests/testService";
+import { createProcessService } from "../../desktop/src/main/services/processes/processService";
+import { augmentProcessPathWithShellAndKnownCliDirs, setPathEnvValue } from "../../desktop/src/main/services/ai/cliExecutableResolver";
 import type { createAgentChatService } from "../../desktop/src/main/services/chat/agentChatService";
 import type { createPrService } from "../../desktop/src/main/services/prs/prService";
 import { createIssueInventoryService } from "../../desktop/src/main/services/prs/issueInventoryService";
@@ -37,7 +39,6 @@ import {
   type ComputerUseArtifactBrokerService,
 } from "../../desktop/src/main/services/computerUse/computerUseArtifactBrokerService";
 import type { createFileService } from "../../desktop/src/main/services/files/fileService";
-import type { createProcessService } from "../../desktop/src/main/services/processes/processService";
 import { createHeadlessLinearServices } from "./headlessLinearServices";
 import { createEventBuffer, type BufferedEvent, type EventBuffer } from "./eventBuffer";
 
@@ -121,6 +122,17 @@ export function ensureAdePaths(projectRoot: string): AdeRuntimePaths {
   };
 }
 
+function createHeadlessAdeCliAgentEnv(baseEnv: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
+  const next: NodeJS.ProcessEnv = { ...baseEnv };
+  const nextPath = augmentProcessPathWithShellAndKnownCliDirs({
+    env: next,
+    includeInteractiveShell: true,
+    timeoutMs: 1_000,
+  });
+  if (nextPath) setPathEnvValue(next, nextPath);
+  return next;
+}
+
 export async function createAdeRuntime(args: { projectRoot: string; workspaceRoot?: string } | string): Promise<AdeRuntime> {
   const resolvedArgs = typeof args === "string"
     ? { projectRoot: args, workspaceRoot: args }
@@ -218,6 +230,7 @@ export async function createAdeRuntime(args: { projectRoot: string; workspaceRoo
     broadcastData: () => {},
     broadcastExit: () => {},
     onSessionEnded: () => {},
+    getAdeCliAgentEnv: createHeadlessAdeCliAgentEnv,
     loadPty: () => nodePty
   });
 
@@ -231,6 +244,22 @@ export async function createAdeRuntime(args: { projectRoot: string; workspaceRoo
     broadcastEvent: () => {}
   });
   const issueInventoryService = createIssueInventoryService({ db });
+  const eventBuffer = createEventBuffer();
+
+  function pushEvent(category: BufferedEvent["category"], payload: Record<string, unknown>): void {
+    eventBuffer.push({ timestamp: new Date().toISOString(), category, payload });
+  }
+
+  const processService = createProcessService({
+    db,
+    projectId,
+    logger,
+    laneService,
+    projectConfigService,
+    sessionService,
+    ptyService,
+    broadcastEvent: (event) => pushEvent("runtime", event as unknown as Record<string, unknown>),
+  });
 
   // Ensure evaluation tables exist for headless runtime checks.
   db.run(`
@@ -257,12 +286,6 @@ export async function createAdeRuntime(args: { projectRoot: string; workspaceRoo
     ON orchestrator_evaluations(run_id, evaluated_at)
   `);
 
-  const eventBuffer = createEventBuffer();
-
-  function pushEvent(category: BufferedEvent["category"], payload: Record<string, unknown>): void {
-    eventBuffer.push({ timestamp: new Date().toISOString(), category, payload });
-  }
-
   const memoryService = createMemoryService(db);
   const ctoStateService = createCtoStateService({
     db,
@@ -392,13 +415,14 @@ export async function createAdeRuntime(args: { projectRoot: string; workspaceRoo
     linearSyncService: headlessLinearServices.linearSyncService,
     linearIngressService: headlessLinearServices.linearIngressService,
     linearRoutingService: headlessLinearServices.linearRoutingService,
-    processService: headlessLinearServices.processService,
+    processService,
     computerUseArtifactBrokerService,
     orchestratorService,
     aiOrchestratorService,
     eventBuffer,
     dispose: () => {
       const swallow = (fn: () => void) => { try { fn(); } catch { /* ignore */ } };
+      swallow(() => processService.disposeAll());
       swallow(() => headlessLinearServices.dispose());
       swallow(() => aiOrchestratorService.dispose());
       swallow(() => testService.disposeAll());
diff --git a/apps/ade-cli/src/cli.test.ts b/apps/ade-cli/src/cli.test.ts
index 13f797b29..37beda030 100644
--- a/apps/ade-cli/src/cli.test.ts
+++ b/apps/ade-cli/src/cli.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { buildCliPlan, formatOutput, parseCliArgs, renderLaneGraph, summarizeExecution, unwrapToolResult } from "./cli";
+import { buildCliPlan, formatOutput, parseCliArgs, renderLaneGraph, shouldAttemptDesktopSocketConnection, summarizeExecution, unwrapToolResult } from "./cli";
 
 describe("ADE CLI", () => {
   it("parses global options without stealing command flags", () => {
@@ -235,6 +235,11 @@ describe("ADE CLI", () => {
     expect(output).toContain("Git repository detected");
   });
 
+  it("attempts Windows named-pipe desktop sockets without filesystem existence checks", () => {
+    expect(shouldAttemptDesktopSocketConnection("\\\\.\\pipe\\ade-123")).toBe(true);
+    expect(shouldAttemptDesktopSocketConnection("//./pipe/ade-123")).toBe(true);
+  });
+
   it("renders a compact lane graph", () => {
     const graph = renderLaneGraph({
       lanes: [
diff --git a/apps/ade-cli/src/cli.ts b/apps/ade-cli/src/cli.ts
index 6aab71899..f057c2f6a 100644
--- a/apps/ade-cli/src/cli.ts
+++ b/apps/ade-cli/src/cli.ts
@@ -5,6 +5,7 @@ import fs from "node:fs";
 import net from "node:net";
 import path from "node:path";
 import { type JsonRpcHandler, type JsonRpcId, type JsonRpcRequest } from "./jsonrpc";
+import { isAdeMcpNamedPipePath } from "../../desktop/src/shared/adeMcpIpc";
 
 type JsonObject = Record<string, unknown>;
 
@@ -1641,7 +1642,8 @@ function resolveRoots(options: GlobalOptions): { projectRoot: string; workspaceR
 }
 
 function commandExists(command: string): boolean {
-  const result = spawnSync("which", [command], {
+  const lookupCommand = process.platform === "win32" ? "where" : "which";
+  const result = spawnSync(lookupCommand, [command], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "ignore"],
   });
@@ -1787,9 +1789,9 @@ function checkProviderReadiness(value: unknown): ReadinessCheck {
 
 function checkComputerUseReadiness(): ReadinessCheck {
   const isDarwin = process.platform === "darwin";
-  const screenshotReady = !isDarwin || commandExists("screencapture");
-  const appLaunchReady = !isDarwin || commandExists("open");
-  const guiReady = !isDarwin || commandExists("swift") || commandExists("osascript");
+  const screenshotReady = isDarwin && commandExists("screencapture");
+  const appLaunchReady = isDarwin && commandExists("open");
+  const guiReady = isDarwin && (commandExists("swift") || commandExists("osascript"));
   const ready = isDarwin && screenshotReady && appLaunchReady && guiReady;
   return {
     ready,
@@ -1814,9 +1816,11 @@ function checkComputerUseReadiness(): ReadinessCheck {
 }
 
 function checkPathReadiness(): ReadinessCheck {
-  const which = runLocalCommand("which", ["ade"], process.cwd());
+  const lookup = process.platform === "win32"
+    ? runLocalCommand("where", ["ade"], process.cwd())
+    : runLocalCommand("which", ["ade"], process.cwd());
   const current = path.resolve(process.argv[1] ?? "");
-  const whichPath = which.ok && which.stdout ? path.resolve(which.stdout.split("\n")[0]!) : null;
+  const whichPath = lookup.ok && lookup.stdout ? path.resolve(lookup.stdout.split(/\r?\n/)[0]!) : null;
   const onPath = Boolean(whichPath);
   return {
     ready: onPath,
@@ -1831,6 +1835,7 @@ function checkPathReadiness(): ReadinessCheck {
       sameBinary: Boolean(whichPath && current && whichPath === current),
       electronRunAsNode: process.env.ELECTRON_RUN_AS_NODE === "1",
       electronVersion: process.versions.electron ?? null,
+      lookupCommand: process.platform === "win32" ? "where" : "which",
     },
   };
 }
@@ -1862,8 +1867,10 @@ function buildReadinessSnapshot(args: {
   const adeDir = path.join(connection.projectRoot, ".ade");
   const sharedConfigPath = path.join(adeDir, "ade.yaml");
   const localConfigPath = path.join(adeDir, "local.yaml");
-  const socketExists = fs.existsSync(connection.socketPath);
   const desktopSocketAvailable = connection.mode === "desktop-socket";
+  const socketExists = isAdeMcpNamedPipePath(connection.socketPath)
+    ? desktopSocketAvailable
+    : fs.existsSync(connection.socketPath);
   const checks = {
     git: checkGitReadiness(connection.projectRoot),
     github: checkGitHubReadiness(connection.projectRoot),
@@ -2082,6 +2089,10 @@ class InProcessJsonRpcClient {
   }
 }
 
+export function shouldAttemptDesktopSocketConnection(socketPath: string): boolean {
+  return isAdeMcpNamedPipePath(socketPath) || fs.existsSync(socketPath);
+}
+
 async function initializeConnection(connection: CliConnection, options: GlobalOptions): Promise<void> {
   await connection.request("ade/initialize", {
     protocolVersion: PROTOCOL_VERSION,
@@ -2103,7 +2114,7 @@ async function createConnection(options: GlobalOptions): Promise<CliConnection>
   const { resolveAdeLayout } = await import("../../desktop/src/shared/adeLayout");
   const layout = resolveAdeLayout(roots.projectRoot);
 
-  if (!options.headless && fs.existsSync(layout.socketPath)) {
+  if (!options.headless && shouldAttemptDesktopSocketConnection(layout.socketPath)) {
     try {
       const socketClient = await SocketJsonRpcClient.connect(layout.socketPath, options.timeoutMs);
       const connection: CliConnection = {
@@ -2665,7 +2676,13 @@ async function executePlan(plan: CliPlan & { kind: "execute" }, options: GlobalO
     connection = await createConnection(options);
   } catch (error) {
     const roots = resolveRoots(options);
-    const socketPath = path.join(roots.projectRoot, ".ade", "ade.sock");
+    let socketPath = path.join(roots.projectRoot, ".ade", "ade.sock");
+    try {
+      const { resolveAdeLayout } = await import("../../desktop/src/shared/adeLayout");
+      socketPath = resolveAdeLayout(roots.projectRoot).socketPath;
+    } catch {
+      // Keep the conventional Unix fallback if shared layout loading fails.
+    }
     const requestedMode = options.requireSocket ? "desktop-socket" : options.headless ? "headless" : "auto";
     const cause = error instanceof Error ? error.message : String(error);
     const sourceRuntimeInterop = isSourceRuntimeInteropError(cause);
diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index c056ec544..d83d3aad7 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -11,6 +11,7 @@
     "prebuild": "node ./scripts/normalize-runtime-binaries.cjs && npm run ade:build",
     "dev": "node ./scripts/ensure-electron.cjs && node ./scripts/dev.cjs",
     "build": "tsup && vite build",
+    "dist:win": "npm run validate:win:artifacts && npm run build && electron-builder --win --x64 --publish never",
     "dist:mac": "npm run build && electron-builder --mac --publish never",
     "dist:mac:dir": "npm run build && electron-builder --dir --mac --publish never -c.mac.identity=null -c.mac.notarize=false",
     "dist:mac:signed": "node ./scripts/require-macos-release-secrets.cjs && npm run build && electron-builder --mac --publish never",
@@ -19,6 +20,7 @@
     "dist:mac:universal:signed:zip": "node ./scripts/require-macos-release-secrets.cjs && npm run build && electron-builder --mac zip --universal --publish never",
     "notarize:mac:dmg": "node ./scripts/notarize-mac-dmg.mjs",
     "validate:mac:artifacts": "node ./scripts/validate-mac-artifacts.mjs",
+    "validate:win:artifacts": "node ./scripts/validate-win-artifacts.mjs",
     "release:mac:local": "node ./scripts/release-mac-local.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
@@ -162,9 +164,17 @@
         "from": "scripts/ade-cli-macos-wrapper.sh",
         "to": "ade-cli/bin/ade"
       },
+      {
+        "from": "scripts/ade-cli-windows-wrapper.cmd",
+        "to": "ade-cli/bin/ade.cmd"
+      },
       {
         "from": "scripts/ade-cli-install-path.sh",
         "to": "ade-cli/install-path.sh"
+      },
+      {
+        "from": "scripts/ade-cli-install-path.cmd",
+        "to": "ade-cli/install-path.cmd"
       }
     ],
     "afterPack": "./scripts/after-pack-runtime-fixes.cjs",
@@ -176,6 +186,12 @@
       "publishAutoUpdate": true
     },
     "npmRebuild": false,
+    "win": {
+      "target": [
+        "nsis"
+      ],
+      "artifactName": "${productName}-${version}-win-${arch}.${ext}"
+    },
     "mac": {
       "target": [
         "dmg",
diff --git a/apps/desktop/scripts/ade-cli-install-path.cmd b/apps/desktop/scripts/ade-cli-install-path.cmd
new file mode 100644
index 000000000..7a7ef8ed2
--- /dev/null
+++ b/apps/desktop/scripts/ade-cli-install-path.cmd
@@ -0,0 +1,36 @@
+@echo off
+setlocal
+
+set "SCRIPT_DIR=%~dp0"
+set "ADE_BIN=%ADE_BIN%"
+if "%ADE_BIN%"=="" set "ADE_BIN=%SCRIPT_DIR%bin\ade.cmd"
+
+set "TARGET_PATH=%~1"
+if "%TARGET_PATH%"=="" (
+  if defined LOCALAPPDATA (
+    set "TARGET_PATH=%LOCALAPPDATA%\ADE\bin\ade.cmd"
+  ) else (
+    set "TARGET_PATH=%USERPROFILE%\.ade\bin\ade.cmd"
+  )
+)
+
+if not exist "%ADE_BIN%" (
+  echo ade install: missing bundled CLI wrapper at %ADE_BIN% 1>&2
+  exit /b 1
+)
+
+for %%I in ("%TARGET_PATH%") do set "TARGET_DIR=%%~dpI"
+if not exist "%TARGET_DIR%" mkdir "%TARGET_DIR%" >nul 2>nul
+
+(
+  echo @echo off
+  echo "%ADE_BIN%" %%*
+) > "%TARGET_PATH%"
+
+if errorlevel 1 (
+  echo ade install: failed to write %TARGET_PATH% 1>&2
+  exit /b 1
+)
+
+echo Installed ade -^> %ADE_BIN%
+echo Ensure %TARGET_DIR% is on PATH, then run: ade doctor
diff --git a/apps/desktop/scripts/ade-cli-windows-wrapper.cmd b/apps/desktop/scripts/ade-cli-windows-wrapper.cmd
new file mode 100644
index 000000000..2d1dc0cc3
--- /dev/null
+++ b/apps/desktop/scripts/ade-cli-windows-wrapper.cmd
@@ -0,0 +1,35 @@
+@echo off
+setlocal
+
+set "SCRIPT_DIR=%~dp0"
+set "CLI_JS=%ADE_CLI_JS%"
+if "%CLI_JS%"=="" set "CLI_JS=%SCRIPT_DIR%..\cli.cjs"
+
+if defined ADE_CLI_NODE (
+  "%ADE_CLI_NODE%" "%CLI_JS%" %*
+  exit /b %ERRORLEVEL%
+)
+
+set "RESOURCES_DIR=%SCRIPT_DIR%..\.."
+set "APP_EXE=%RESOURCES_DIR%\..\ADE.exe"
+
+if exist "%APP_EXE%" (
+  set "NODE_PATH_VALUE=%RESOURCES_DIR%\app.asar.unpacked\node_modules;%RESOURCES_DIR%\app.asar\node_modules"
+  if defined NODE_PATH set "NODE_PATH_VALUE=%NODE_PATH_VALUE%;%NODE_PATH%"
+  set "ELECTRON_RUN_AS_NODE=1"
+  set "NODE_PATH=%NODE_PATH_VALUE%"
+  "%APP_EXE%" "%CLI_JS%" %*
+  exit /b %ERRORLEVEL%
+)
+
+where node >nul 2>nul
+if not errorlevel 1 (
+  node -e "process.exit(Number(process.versions.node.split('.')[0]) >= 22 ? 0 : 1)" >nul 2>nul
+  if not errorlevel 1 (
+    node "%CLI_JS%" %*
+    exit /b %ERRORLEVEL%
+  )
+)
+
+echo ade: Node.js 22+ or the packaged ADE.exe runtime is required to run this CLI. 1>&2
+exit /b 127
diff --git a/apps/desktop/scripts/after-pack-runtime-fixes.cjs b/apps/desktop/scripts/after-pack-runtime-fixes.cjs
index 93381d230..9315f57a9 100644
--- a/apps/desktop/scripts/after-pack-runtime-fixes.cjs
+++ b/apps/desktop/scripts/after-pack-runtime-fixes.cjs
@@ -5,39 +5,62 @@ const {
   resolvePackagedRuntimeRoot,
 } = require("./runtimeBinaryPermissions.cjs");
 
-module.exports = async function afterPack(context) {
+function resolveUnpackedRuntimeRoot(context) {
   const productFilename = context?.packager?.appInfo?.productFilename || "ADE";
   const appBundlePath = path.join(context?.appOutDir || "", `${productFilename}.app`);
-  if (!appBundlePath || !fs.existsSync(appBundlePath)) {
-    throw new Error(`[afterPack] Missing packaged app bundle: ${String(appBundlePath)}`);
-  }
 
-  const runtimeRoot = resolvePackagedRuntimeRoot(appBundlePath);
-  const bundledCliPath = path.join(appBundlePath, "Contents", "Resources", "ade-cli", "cli.cjs");
-  const bundledCliBinPath = path.join(appBundlePath, "Contents", "Resources", "ade-cli", "bin", "ade");
-  const bundledCliInstallerPath = path.join(appBundlePath, "Contents", "Resources", "ade-cli", "install-path.sh");
-  if (!fs.existsSync(runtimeRoot)) {
-    throw new Error(`[afterPack] Missing unpacked runtime payload: ${runtimeRoot}`);
+  if (fs.existsSync(appBundlePath)) {
+    return { runtimeRoot: resolvePackagedRuntimeRoot(appBundlePath), appBundlePath };
   }
-  if (!fs.existsSync(bundledCliPath)) {
-    throw new Error(`[afterPack] Missing bundled ADE CLI entry: ${bundledCliPath}`);
+
+  const resourcesRoot = path.join(context?.appOutDir || "", "resources", "app.asar.unpacked");
+  if (!fs.existsSync(resourcesRoot)) {
+    throw new Error(
+      `[afterPack] Missing unpacked runtime payload (tried ${appBundlePath} and ${resourcesRoot})`,
+    );
   }
-  if (!fs.existsSync(bundledCliBinPath)) {
-    throw new Error(`[afterPack] Missing bundled ADE CLI wrapper: ${bundledCliBinPath}`);
+  return { runtimeRoot: resourcesRoot, appBundlePath: null };
+}
+
+function resolveExtraResourcesRoot(context, appBundlePath) {
+  if (appBundlePath) return path.join(appBundlePath, "Contents", "Resources");
+  return path.join(context?.appOutDir || "", "resources");
+}
+
+function requireFile(filePath, label) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`[afterPack] Missing ${label}: ${filePath}`);
   }
-  if (!fs.existsSync(bundledCliInstallerPath)) {
-    throw new Error(`[afterPack] Missing bundled ADE CLI PATH installer: ${bundledCliInstallerPath}`);
+}
+
+module.exports = async function afterPack(context) {
+  const { runtimeRoot, appBundlePath } = resolveUnpackedRuntimeRoot(context);
+  if (!fs.existsSync(runtimeRoot)) {
+    throw new Error(`[afterPack] Missing unpacked runtime payload: ${runtimeRoot}`);
   }
+
+  const resourcesRoot = resolveExtraResourcesRoot(context, appBundlePath);
+  const bundledCliPath = path.join(resourcesRoot, "ade-cli", "cli.cjs");
+  requireFile(bundledCliPath, "bundled ADE CLI entry");
+
+  const bundledCliBinPath = path.join(resourcesRoot, "ade-cli", "bin", "ade");
+  const bundledCliInstallerPath = path.join(resourcesRoot, "ade-cli", "install-path.sh");
+  requireFile(bundledCliBinPath, "bundled ADE CLI wrapper");
+  requireFile(bundledCliInstallerPath, "bundled ADE CLI PATH installer");
+  requireFile(path.join(resourcesRoot, "ade-cli", "bin", "ade.cmd"), "bundled ADE CLI Windows wrapper");
+  requireFile(path.join(resourcesRoot, "ade-cli", "install-path.cmd"), "bundled ADE CLI Windows PATH installer");
   fs.chmodSync(bundledCliBinPath, 0o755);
   fs.chmodSync(bundledCliInstallerPath, 0o755);
 
   const normalized = normalizeDesktopRuntimeBinaries(runtimeRoot);
   for (const entry of normalized) {
-    console.log(`[afterPack] Restored executable mode: ${entry.label} -> ${path.relative(appBundlePath, entry.filePath)}`);
+    console.log(`[afterPack] Restored executable mode: ${entry.label} -> ${path.relative(runtimeRoot, entry.filePath)}`);
   }
 
   const requiredScripts = [
     path.join(runtimeRoot, "dist", "main", "packagedRuntimeSmoke.cjs"),
+    path.join(runtimeRoot, "vendor", "crsqlite", "darwin-arm64", "crsqlite.dylib"),
+    path.join(runtimeRoot, "vendor", "crsqlite", "win32-x64", "crsqlite.dll"),
   ];
 
   for (const scriptPath of requiredScripts) {
diff --git a/apps/desktop/scripts/dev.cjs b/apps/desktop/scripts/dev.cjs
index fc32d2e91..414a84349 100644
--- a/apps/desktop/scripts/dev.cjs
+++ b/apps/desktop/scripts/dev.cjs
@@ -7,6 +7,7 @@ const path = require("node:path");
 
 const projectRoot = path.resolve(__dirname, "..");
 const distMainFile = path.join(projectRoot, "dist", "main", "main.cjs");
+const npxCommand = process.platform === "win32" ? "npx.cmd" : "npx";
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -118,6 +119,22 @@ function spawnProcess(name, cmd, args, extraEnv = {}) {
   return child;
 }
 
+function terminateChild(child, signal) {
+  if (child.killed) return;
+  if (process.platform === "win32" && typeof child.pid === "number") {
+    const result = cp.spawnSync("taskkill.exe", ["/T", "/F", "/PID", String(child.pid)], {
+      stdio: "ignore",
+      windowsHide: true,
+    });
+    if (!result.error && result.status === 0) return;
+  }
+  try {
+    child.kill(signal);
+  } catch {
+    // ignore
+  }
+}
+
 async function main() {
   const devPort = await choosePort(5173, 32);
   const devServerUrl = `http://localhost:${devPort}`;
@@ -138,13 +155,7 @@ async function main() {
     shuttingDown = true;
     fs.unwatchFile(distMainFile);
     for (const child of children) {
-      if (!child.killed) {
-        try {
-          child.kill(signal);
-        } catch {
-          // ignore
-        }
-      }
+      terminateChild(child, signal);
     }
   };
 
@@ -152,8 +163,8 @@ async function main() {
   process.on("SIGTERM", () => teardown("SIGTERM"));
   process.on("exit", () => teardown("SIGTERM"));
 
-  const vite = spawnProcess("renderer", "npx", ["vite", "--port", String(devPort), "--strictPort", "--force"]);
-  const main = spawnProcess("main", "npx", ["tsup", "--watch"]);
+  const vite = spawnProcess("renderer", npxCommand, ["vite", "--port", String(devPort), "--strictPort", "--force"]);
+  const main = spawnProcess("main", npxCommand, ["tsup", "--watch"]);
   children.add(vite);
   children.add(main);
 
@@ -176,7 +187,7 @@ async function main() {
 
   const electronEnv = { VITE_DEV_SERVER_URL: devServerUrl };
   const launchElectron = () => {
-    const child = spawnProcess("electron", "npx", ["electron", ".", `--remote-debugging-port=${remoteDebugPort}`], electronEnv);
+    const child = spawnProcess("electron", npxCommand, ["electron", ".", `--remote-debugging-port=${remoteDebugPort}`], electronEnv);
     electron = child;
     children.add(child);
     child.on("exit", (code, signal) => {
@@ -214,11 +225,7 @@ async function main() {
     if (electronRestartPending) return;
     electronRestartPending = true;
     process.stdout.write(`[ade] restarting electron (${reason})\n`);
-    try {
-      electron.kill("SIGTERM");
-    } catch {
-      electronRestartPending = false;
-    }
+    terminateChild(electron, "SIGTERM");
   };
 
   launchElectron();
diff --git a/apps/desktop/scripts/validate-win-artifacts.mjs b/apps/desktop/scripts/validate-win-artifacts.mjs
new file mode 100644
index 000000000..a0b50a32a
--- /dev/null
+++ b/apps/desktop/scripts/validate-win-artifacts.mjs
@@ -0,0 +1,51 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const desktopRoot = path.resolve(__dirname, "..");
+const packageJsonPath = path.join(desktopRoot, "package.json");
+const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+
+function fail(message) {
+  console.error(`[validate-win-artifacts] ${message}`);
+  process.exitCode = 1;
+}
+
+function requireFile(relativePath, label) {
+  const absolutePath = path.join(desktopRoot, relativePath);
+  if (!fs.existsSync(absolutePath)) {
+    fail(`Missing ${label}: ${absolutePath}`);
+  }
+}
+
+function hasExtraResource(to) {
+  return Array.isArray(pkg.build?.extraResources)
+    && pkg.build.extraResources.some((entry) => entry && entry.to === to);
+}
+
+requireFile("scripts/ade-cli-windows-wrapper.cmd", "Windows ADE CLI wrapper");
+requireFile("scripts/ade-cli-install-path.cmd", "Windows ADE CLI PATH installer");
+requireFile("vendor/crsqlite/win32-x64/crsqlite.dll", "Windows cr-sqlite extension");
+
+if (!hasExtraResource("ade-cli/bin/ade.cmd")) {
+  fail("package.json build.extraResources must ship ade-cli/bin/ade.cmd");
+}
+if (!hasExtraResource("ade-cli/install-path.cmd")) {
+  fail("package.json build.extraResources must ship ade-cli/install-path.cmd");
+}
+if (!Array.isArray(pkg.build?.win?.target) || pkg.build.win.target.length === 0) {
+  fail("package.json build.win.target must define at least one Windows target");
+}
+if (typeof pkg.scripts?.["dist:win"] !== "string" || !/\s--x64(?:\s|$)/.test(pkg.scripts["dist:win"])) {
+  fail("package.json scripts.dist:win must pass --x64 until a Windows ARM64 cr-sqlite binary is bundled");
+}
+if (!Array.isArray(pkg.build?.asarUnpack) || !pkg.build.asarUnpack.includes("vendor/crsqlite/**")) {
+  fail("package.json build.asarUnpack must unpack vendor/crsqlite/**");
+}
+
+if (process.exitCode) {
+  process.exit(process.exitCode);
+}
+
+console.log("[validate-win-artifacts] Windows package inputs are present.");
diff --git a/apps/desktop/src/main/main.ts b/apps/desktop/src/main/main.ts
index 81dfdf5f3..fc953ac70 100644
--- a/apps/desktop/src/main/main.ts
+++ b/apps/desktop/src/main/main.ts
@@ -1,7 +1,9 @@
 import { app, BrowserWindow, dialog, nativeImage, protocol, safeStorage, shell } from "electron";
 import path from "node:path";
+import { pathToFileURL } from "node:url";
 import type * as NodePty from "node-pty";
 type NodePtyType = typeof NodePty;
+import { isAdeMcpNamedPipePath } from "../shared/adeMcpIpc";
 import { registerIpc } from "./services/ipc/registerIpc";
 import { createFileLogger } from "./services/logging/logger";
 import { openKvDb } from "./services/state/kvDb";
@@ -209,7 +211,7 @@ if (process.env.VITE_DEV_SERVER_URL) {
 function getRendererUrl(): string {
   const devUrl = process.env.VITE_DEV_SERVER_URL;
   if (devUrl) return devUrl;
-  return `file://${path.join(__dirname, "../renderer/index.html")}`;
+  return pathToFileURL(path.join(__dirname, "../renderer/index.html")).toString();
 }
 
 async function createWindow(args: {
@@ -520,10 +522,18 @@ app.whenReady().then(async () => {
   protocol.handle("ade-artifact", (request) => {
     const url = new URL(request.url);
     let filePath = decodeURIComponent(url.pathname);
+    if (url.hostname === "project") {
+      if (!activeProjectRoot) return new Response("Not found", { status: 404 });
+      filePath = path.resolve(activeProjectRoot, filePath.replace(/^[/\\]+/, ""));
+    }
     // On Windows, pathname starts with /C:/... — strip leading slash
     if (process.platform === "win32" && /^\/[a-zA-Z]:/.test(filePath)) {
       filePath = filePath.slice(1);
     }
+    if (!path.isAbsolute(filePath)) {
+      if (!activeProjectRoot) return new Response("Not found", { status: 404 });
+      filePath = path.resolve(activeProjectRoot, filePath);
+    }
     filePath = path.resolve(filePath);
     let resolvedFile: string;
     try {
@@ -3073,10 +3083,11 @@ app.whenReady().then(async () => {
       destroyActiveRpcConnections,
     );
 
-    // Clean stale socket from prior crash
-    try {
-      fs.unlinkSync(rpcSocketPath);
-    } catch {}
+    if (!isAdeMcpNamedPipePath(rpcSocketPath)) {
+      try {
+        fs.unlinkSync(rpcSocketPath);
+      } catch {}
+    }
 
     const rpcSocketServer = net.createServer((conn) => {
       activeRpcConnections.add(conn);
@@ -3347,7 +3358,9 @@ app.whenReady().then(async () => {
       // ignore
     }
     try {
-      if (ctx.rpcSocketPath) fs.unlinkSync(ctx.rpcSocketPath);
+      if (ctx.rpcSocketPath && !isAdeMcpNamedPipePath(ctx.rpcSocketPath)) {
+        fs.unlinkSync(ctx.rpcSocketPath);
+      }
     } catch {
       // ignore
     }
diff --git a/apps/desktop/src/main/packagedRuntimeSmoke.ts b/apps/desktop/src/main/packagedRuntimeSmoke.ts
index 52ecca294..f9768b616 100644
--- a/apps/desktop/src/main/packagedRuntimeSmoke.ts
+++ b/apps/desktop/src/main/packagedRuntimeSmoke.ts
@@ -12,7 +12,11 @@ async function probePty(): Promise<{ ok: true; output: string }> {
   const pty = await import("node-pty");
   return new Promise((resolve, reject) => {
     let output = "";
-    const term = pty.spawn("/bin/sh", ["-lc", 'printf "ADE_PTY_OK\\n"'], {
+    const shellSpec =
+      process.platform === "win32"
+        ? { file: "powershell.exe", args: ["-NoProfile", "-Command", 'Write-Output "ADE_PTY_OK"'] }
+        : { file: "/bin/sh", args: ["-lc", 'printf "ADE_PTY_OK\\n"'] };
+    const term = pty.spawn(shellSpec.file, shellSpec.args, {
       name: "xterm-256color",
       cols: 80,
       rows: 24,
diff --git a/apps/desktop/src/main/services/ai/cliExecutableResolver.test.ts b/apps/desktop/src/main/services/ai/cliExecutableResolver.test.ts
index bb85cebc0..efe6a04a6 100644
--- a/apps/desktop/src/main/services/ai/cliExecutableResolver.test.ts
+++ b/apps/desktop/src/main/services/ai/cliExecutableResolver.test.ts
@@ -4,10 +4,14 @@ import path from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import {
   augmentPathWithKnownCliDirs,
+  augmentProcessPathWithShellAndKnownCliDirs,
+  getPathEnvValue,
   resolveExecutableFromKnownLocations,
+  setPathEnvValue,
 } from "./cliExecutableResolver";
 
 const originalPlatform = process.platform;
+const originalPathDelimiter = path.delimiter;
 
 function makeExecutable(filePath: string): void {
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
@@ -22,12 +26,24 @@ function setPlatform(value: NodeJS.Platform): void {
   });
 }
 
+function setPathDelimiter(value: string): void {
+  Object.defineProperty(path, "delimiter", {
+    value,
+    configurable: true,
+  });
+}
+
+function currentPathDelimiter(): string {
+  return process.platform === "win32" ? ";" : path.delimiter;
+}
+
 describe("cliExecutableResolver", () => {
   let tempRoot: string | null = null;
 
   afterEach(() => {
     vi.restoreAllMocks();
     setPlatform(originalPlatform);
+    setPathDelimiter(originalPathDelimiter);
     if (tempRoot) {
       fs.rmSync(tempRoot, { recursive: true, force: true });
       tempRoot = null;
@@ -78,7 +94,7 @@ describe("cliExecutableResolver", () => {
       PATH: "/usr/bin:/bin",
     });
 
-    expect(nextPath.split(path.delimiter)).toContain(path.join(homeDir, ".npm-global", "bin"));
+    expect(nextPath.split(currentPathDelimiter())).toContain(path.join(homeDir, ".npm-global", "bin"));
   });
 
   it("keeps both Intel and Apple Silicon Homebrew bins on PATH", () => {
@@ -87,11 +103,90 @@ describe("cliExecutableResolver", () => {
       PATH: "/usr/local/bin:/usr/bin:/bin",
     });
 
-    const entries = nextPath.split(path.delimiter);
+    const entries = nextPath.split(currentPathDelimiter());
     expect(entries).toContain("/usr/local/bin");
     expect(entries).toContain("/opt/homebrew/bin");
   });
 
+  it("augments PATH with known CLI dirs on Windows", () => {
+    setPlatform("win32");
+    tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-cli-path-"));
+    const homeDir = path.join(tempRoot, "home");
+    const scoopShims = path.join(homeDir, "scoop", "shims");
+    fs.mkdirSync(scoopShims, { recursive: true });
+    const fakeCodex = path.join(scoopShims, "codex.cmd");
+    fs.writeFileSync(fakeCodex, "@echo off\r\n", "utf8");
+
+    const nextPath = augmentProcessPathWithShellAndKnownCliDirs({
+      env: {
+        USERPROFILE: homeDir,
+        HOME: homeDir,
+        PATH: "C:\\Windows\\System32",
+      },
+    });
+
+    expect(nextPath.split(currentPathDelimiter())).toContain(scoopShims);
+  });
+
+  it("reads and updates Windows Path without creating duplicate PATH keys", () => {
+    setPlatform("win32");
+    const env: NodeJS.ProcessEnv = {
+      Path: "C:\\Windows\\System32",
+    };
+
+    expect(getPathEnvValue(env)).toBe("C:\\Windows\\System32");
+    setPathEnvValue(env, "C:\\Tools;C:\\Windows\\System32");
+
+    expect(env.Path).toBe("C:\\Tools;C:\\Windows\\System32");
+    expect(env.PATH).toBeUndefined();
+  });
+
+  it("prefers USERPROFILE over a Git Bash-style HOME for Windows known dirs", () => {
+    setPlatform("win32");
+    setPathDelimiter(";");
+    tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-cli-path-"));
+    const gitBashHome = "/c/Users/Alice";
+    const userProfile = "C:\\Users\\Alice";
+    const scoopShims = path.join(userProfile, "scoop", "shims");
+    const voltaBin = path.join(userProfile, ".volta", "bin");
+    const opencodeBin = path.join(userProfile, ".opencode", "bin");
+    const realExecutable = path.join(tempRoot, "codex.CMD");
+    makeExecutable(realExecutable);
+
+    const realStatSync = fs.statSync;
+    vi.spyOn(fs, "statSync").mockImplementation(((candidatePath: fs.PathLike, opts?: any) => {
+      const normalizedCandidate = path.normalize(String(candidatePath));
+      if (normalizedCandidate.toLowerCase() === path.normalize(path.join(scoopShims, "codex.CMD")).toLowerCase()) {
+        return realStatSync(realExecutable, opts);
+      }
+      const err: NodeJS.ErrnoException = new Error("ENOENT");
+      err.code = "ENOENT";
+      throw err;
+    }) as typeof fs.statSync);
+
+    const nextPath = augmentPathWithKnownCliDirs("C:\\Windows\\System32", {
+      HOME: gitBashHome,
+      USERPROFILE: userProfile,
+      PATH: "C:\\Windows\\System32",
+    });
+
+    expect(nextPath).toContain(scoopShims);
+    expect(nextPath).toContain(voltaBin);
+    expect(nextPath).toContain(opencodeBin);
+    expect(nextPath).not.toContain(path.join(gitBashHome, "scoop", "shims"));
+    expect(nextPath).not.toContain(path.join(gitBashHome, ".volta", "bin"));
+    expect(nextPath).not.toContain(path.join(gitBashHome, ".opencode", "bin"));
+
+    expect(resolveExecutableFromKnownLocations("codex", {
+      HOME: gitBashHome,
+      USERPROFILE: userProfile,
+      PATH: "C:\\Windows\\System32",
+    })).toEqual({
+      path: path.join(scoopShims, "codex.CMD"),
+      source: "known-dir",
+    });
+  });
+
   it("resolves Windows executables using PATHEXT suffixes", () => {
     setPlatform("win32");
     tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-cli-path-"));
@@ -110,4 +205,20 @@ describe("cliExecutableResolver", () => {
       source: "path",
     });
   });
+
+  it("resolves Windows executables from Path when PATH is absent", () => {
+    setPlatform("win32");
+    tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-cli-path-"));
+    const binDir = path.join(tempRoot, "bin");
+    const executablePath = path.join(binDir, "codex.cmd");
+    fs.mkdirSync(binDir, { recursive: true });
+    fs.writeFileSync(executablePath, "@echo off\r\n", "utf8");
+
+    const resolved = resolveExecutableFromKnownLocations("codex", {
+      Path: binDir,
+      PATHEXT: ".CMD;.EXE",
+    });
+    expect(resolved?.source).toBe("path");
+    expect(resolved?.path.toLowerCase()).toBe(executablePath.toLowerCase());
+  });
 });
diff --git a/apps/desktop/src/main/services/ai/cliExecutableResolver.ts b/apps/desktop/src/main/services/ai/cliExecutableResolver.ts
index 381a0955c..f54b8c5a9 100644
--- a/apps/desktop/src/main/services/ai/cliExecutableResolver.ts
+++ b/apps/desktop/src/main/services/ai/cliExecutableResolver.ts
@@ -13,8 +13,16 @@ export type ResolvedExecutable = {
 };
 
 function getHomeDir(env: NodeJS.ProcessEnv): string {
+  const profile = env.USERPROFILE?.trim();
+  if (process.platform === "win32") {
+    if (profile && profile.length > 0) return profile;
+    const home = env.HOME?.trim();
+    if (home && home.length > 0) return home;
+    return os.homedir();
+  }
   const home = env.HOME?.trim();
-  return home && home.length > 0 ? home : os.homedir();
+  if (home && home.length > 0) return home;
+  return os.homedir();
 }
 
 function uniqueNonEmpty(values: Iterable<string>): string[] {
@@ -27,6 +35,31 @@ function uniqueNonEmpty(values: Iterable<string>): string[] {
   return [...out];
 }
 
+function pathListDelimiter(): string {
+  return process.platform === "win32" ? ";" : path.delimiter;
+}
+
+export function getPathEnvKey(env: NodeJS.ProcessEnv): string {
+  if (process.platform !== "win32") return "PATH";
+  return Object.keys(env).find((key) => key.toLowerCase() === "path") ?? "Path";
+}
+
+export function getPathEnvValue(env: NodeJS.ProcessEnv): string | undefined {
+  return env[getPathEnvKey(env)];
+}
+
+export function setPathEnvValue(env: NodeJS.ProcessEnv, value: string): void {
+  const key = getPathEnvKey(env);
+  if (process.platform === "win32") {
+    for (const existing of Object.keys(env)) {
+      if (existing.toLowerCase() === "path" && existing !== key) {
+        delete env[existing];
+      }
+    }
+  }
+  env[key] = value;
+}
+
 function expandHomePath(input: string, homeDir: string): string {
   if (input === "~") return homeDir;
   if (input.startsWith("~/")) return path.join(homeDir, input.slice(2));
@@ -61,13 +94,66 @@ function readNpmPrefixBinDirs(env: NodeJS.ProcessEnv): string[] {
     }
   }
 
-  return [...prefixes].map((prefix) => path.join(prefix, "bin"));
+  return uniqueNonEmpty(
+    [...prefixes].flatMap((prefix) =>
+      process.platform === "win32"
+        ? [prefix, path.join(prefix, "bin")]
+        : [path.join(prefix, "bin")],
+    ),
+  );
 }
 
-function getKnownBinDirs(
-  command: string,
-  env: NodeJS.ProcessEnv,
-): string[] {
+function getWindowsKnownBinDirs(env: NodeJS.ProcessEnv, command: string): string[] {
+  const homeDir = getHomeDir(env);
+  const localAppData = env.LOCALAPPDATA?.trim();
+  const appData = env.APPDATA?.trim();
+  const programFiles = env.ProgramFiles?.trim();
+  const programFilesX86 = env["ProgramFiles(x86)"]?.trim();
+  const programData = env.ProgramData?.trim();
+  const scoop = env.SCOOP?.trim();
+  const bunInstall = env.BUN_INSTALL?.trim();
+  const voltaHome = env.VOLTA_HOME?.trim();
+  const pnpmHome = env.PNPM_HOME?.trim();
+  const asdfDataDir = env.ASDF_DATA_DIR?.trim();
+
+  return uniqueNonEmpty([
+    appData ? path.join(appData, "npm") : "",
+    localAppData ? path.join(localAppData, "Programs", "cursor", "resources", "app", "bin") : "",
+    localAppData ? path.join(localAppData, "Programs", "Microsoft VS Code", "bin") : "",
+    localAppData ? path.join(localAppData, "Microsoft", "WinGet", "Links") : "",
+    programFiles ? path.join(programFiles, "cursor", "resources", "app", "bin") : "",
+    programFiles ? path.join(programFiles, "Microsoft VS Code", "bin") : "",
+    programFiles ? path.join(programFiles, "Git", "cmd") : "",
+    programFiles ? path.join(programFiles, "nodejs") : "",
+    programFilesX86 ? path.join(programFilesX86, "Microsoft VS Code", "bin") : "",
+    programData ? path.join(programData, "chocolatey", "bin") : "",
+    scoop ? path.join(scoop, "shims") : path.join(homeDir, "scoop", "shims"),
+    path.join(homeDir, ".local", "bin"),
+    path.join(homeDir, ".npm-global", "bin"),
+    path.join(homeDir, ".yarn", "bin"),
+    path.join(homeDir, ".config", "yarn", "global", "node_modules", ".bin"),
+    localAppData ? path.join(localAppData, "pnpm") : "",
+    path.join(homeDir, ".pnpm-global", "bin"),
+    path.join(homeDir, ".bun", "bin"),
+    path.join(homeDir, ".opencode", "bin"),
+    path.join(homeDir, ".volta", "bin"),
+    path.join(homeDir, ".asdf", "shims"),
+    path.join(homeDir, ".asdf", "bin"),
+    path.join(homeDir, ".nvm", "current", "bin"),
+    path.join(homeDir, ".mise", "shims"),
+    path.join(homeDir, ".mise", "bin"),
+    path.join(homeDir, "bin"),
+    bunInstall ? path.join(bunInstall, "bin") : "",
+    voltaHome ? path.join(voltaHome, "bin") : "",
+    pnpmHome || "",
+    asdfDataDir ? path.join(asdfDataDir, "shims") : "",
+    ...readNpmPrefixBinDirs(env),
+    command === "codex" && programFiles ? path.join(programFiles, "Codex") : "",
+    command === "codex" && localAppData ? path.join(localAppData, "Programs", "Codex") : "",
+  ]);
+}
+
+function getUnixLikeKnownBinDirs(env: NodeJS.ProcessEnv, command: string): string[] {
   const homeDir = getHomeDir(env);
   const bunInstall = env.BUN_INSTALL?.trim();
   const voltaHome = env.VOLTA_HOME?.trim();
@@ -81,21 +167,21 @@ function getKnownBinDirs(
     "/usr/local/sbin",
     "/usr/bin",
     "/bin",
-    `${homeDir}/.local/bin`,
-    `${homeDir}/.npm-global/bin`,
-    `${homeDir}/.yarn/bin`,
-    `${homeDir}/.config/yarn/global/node_modules/.bin`,
-    `${homeDir}/Library/pnpm`,
-    `${homeDir}/.pnpm-global/bin`,
-    `${homeDir}/.bun/bin`,
-    `${homeDir}/.opencode/bin`,
-    `${homeDir}/.volta/bin`,
-    `${homeDir}/.asdf/shims`,
-    `${homeDir}/.asdf/bin`,
-    `${homeDir}/.nvm/current/bin`,
-    `${homeDir}/.mise/shims`,
-    `${homeDir}/.mise/bin`,
-    `${homeDir}/bin`,
+    path.join(homeDir, ".local", "bin"),
+    path.join(homeDir, ".npm-global", "bin"),
+    path.join(homeDir, ".yarn", "bin"),
+    path.join(homeDir, ".config", "yarn", "global", "node_modules", ".bin"),
+    path.join(homeDir, "Library", "pnpm"),
+    path.join(homeDir, ".pnpm-global", "bin"),
+    path.join(homeDir, ".bun", "bin"),
+    path.join(homeDir, ".opencode", "bin"),
+    path.join(homeDir, ".volta", "bin"),
+    path.join(homeDir, ".asdf", "shims"),
+    path.join(homeDir, ".asdf", "bin"),
+    path.join(homeDir, ".nvm", "current", "bin"),
+    path.join(homeDir, ".mise", "shims"),
+    path.join(homeDir, ".mise", "bin"),
+    path.join(homeDir, "bin"),
     bunInstall ? path.join(bunInstall, "bin") : "",
     voltaHome ? path.join(voltaHome, "bin") : "",
     pnpmHome || "",
@@ -105,6 +191,15 @@ function getKnownBinDirs(
   ]);
 }
 
+function getKnownBinDirs(
+  command: string,
+  env: NodeJS.ProcessEnv,
+): string[] {
+  return process.platform === "win32"
+    ? getWindowsKnownBinDirs(env, command)
+    : getUnixLikeKnownBinDirs(env, command);
+}
+
 function isExecutableFile(candidatePath: string): boolean {
   try {
     const stat = fs.statSync(candidatePath);
@@ -121,6 +216,7 @@ function resolveFromDirs(
 ): string | null {
   const pathext = process.platform === "win32"
     ? uniqueNonEmpty((env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";"))
+      .flatMap((ext) => [ext, ext.toLowerCase(), ext.toUpperCase()])
     : [];
   const commandHasExtension = path.extname(command).length > 0;
 
@@ -141,11 +237,11 @@ function resolveFromDirs(
 
 export function splitPathEntries(pathValue: string | undefined): string[] {
   if (!pathValue) return [];
-  return uniqueNonEmpty(pathValue.split(path.delimiter));
+  return uniqueNonEmpty(pathValue.split(pathListDelimiter()));
 }
 
 export function mergePathEntries(...values: Array<string | undefined | null>): string {
-  return uniqueNonEmpty(values.flatMap((value) => splitPathEntries(value ?? undefined))).join(path.delimiter);
+  return uniqueNonEmpty(values.flatMap((value) => splitPathEntries(value ?? undefined))).join(pathListDelimiter());
 }
 
 export function augmentPathWithKnownCliDirs(
@@ -154,10 +250,10 @@ export function augmentPathWithKnownCliDirs(
 ): string {
   return mergePathEntries(
     pathValue,
-    getKnownBinDirs("claude", env).join(path.delimiter),
-    getKnownBinDirs("codex", env).join(path.delimiter),
-    getKnownBinDirs("agent", env).join(path.delimiter),
-    getKnownBinDirs("opencode", env).join(path.delimiter),
+    getKnownBinDirs("claude", env).join(pathListDelimiter()),
+    getKnownBinDirs("codex", env).join(pathListDelimiter()),
+    getKnownBinDirs("agent", env).join(pathListDelimiter()),
+    getKnownBinDirs("opencode", env).join(pathListDelimiter()),
   );
 }
 
@@ -192,11 +288,18 @@ export function augmentProcessPathWithShellAndKnownCliDirs(args?: {
   includeInteractiveShell?: boolean;
   timeoutMs?: number;
 }): string {
+  const env = args?.env ?? process.env;
+
+  if (process.platform === "win32") {
+    // Windows has no direct `sh -ic` equivalent here; includeInteractiveShell
+    // and timeoutMs are intentionally ignored in favor of env PATH + known CLI dirs.
+    return augmentPathWithKnownCliDirs(getPathEnvValue(env), env);
+  }
+
   if (process.platform !== "darwin" && process.platform !== "linux") {
-    return args?.env?.PATH ?? process.env.PATH ?? "";
+    return getPathEnvValue(env) ?? process.env.PATH ?? "";
   }
 
-  const env = args?.env ?? process.env;
   const shellPath = env.SHELL?.trim() || "/bin/sh";
   const timeoutMs = args?.timeoutMs ?? 1_000;
   const loginPath = readShellPath(shellPath, "-lc", timeoutMs, env);
@@ -205,7 +308,7 @@ export function augmentProcessPathWithShellAndKnownCliDirs(args?: {
     : null;
 
   return augmentPathWithKnownCliDirs(
-    mergePathEntries(env.PATH, loginPath, interactivePath),
+    mergePathEntries(getPathEnvValue(env), loginPath, interactivePath),
     env,
   );
 }
@@ -214,7 +317,7 @@ export function resolveExecutableFromKnownLocations(
   command: string,
   env: NodeJS.ProcessEnv = process.env,
 ): ResolvedExecutable | null {
-  const fromPath = resolveFromDirs(command, splitPathEntries(env.PATH), env);
+  const fromPath = resolveFromDirs(command, splitPathEntries(getPathEnvValue(env)), env);
   if (fromPath) {
     return { path: fromPath, source: "path" };
   }
diff --git a/apps/desktop/src/main/services/ai/providerCredentialSources.ts b/apps/desktop/src/main/services/ai/providerCredentialSources.ts
index dc3a412f2..f6f00da2b 100644
--- a/apps/desktop/src/main/services/ai/providerCredentialSources.ts
+++ b/apps/desktop/src/main/services/ai/providerCredentialSources.ts
@@ -4,6 +4,7 @@ import path from "node:path";
 import { spawn } from "node:child_process";
 import type { Logger } from "../logging/logger";
 import { isRecord, safeJsonParse } from "../shared/utils";
+import { killWindowsProcessTree } from "../shared/processExecution";
 
 const CLAUDE_TOKEN_ENDPOINT = "https://platform.claude.com/v1/oauth/token";
 const CLAUDE_OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
@@ -88,9 +89,13 @@ export function runShellCommand(
   timeoutMs: number,
 ): Promise<{ stdout: string; stderr: string; exitCode: number | null }> {
   return new Promise((resolve, reject) => {
-    const child = spawn("sh", ["-c", command], {
+    const useCmd = process.platform === "win32";
+    const executable = useCmd ? (process.env.ComSpec?.trim() || "cmd.exe") : "sh";
+    const args = useCmd ? ["/d", "/s", "/c", command] : ["-c", command];
+    const child = spawn(executable, args, {
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env,
+      windowsVerbatimArguments: useCmd,
     });
 
     let stdout = "";
@@ -104,7 +109,13 @@ export function runShellCommand(
 
     const timer = setTimeout(() => {
       try {
-        child.kill("SIGKILL");
+        if (process.platform === "win32") {
+          killWindowsProcessTree(child.pid ?? 0, (detail) => {
+            console.warn("provider_credentials.taskkill_failed", detail);
+          });
+        } else {
+          child.kill("SIGKILL");
+        }
       } catch {
         // ignore
       }
diff --git a/apps/desktop/src/main/services/ai/providerTaskRunner.ts b/apps/desktop/src/main/services/ai/providerTaskRunner.ts
index 591ff5216..02cc996ff 100644
--- a/apps/desktop/src/main/services/ai/providerTaskRunner.ts
+++ b/apps/desktop/src/main/services/ai/providerTaskRunner.ts
@@ -13,6 +13,7 @@ import { resolveCodexExecutable } from "./codexExecutable";
 import { resolveCursorAgentExecutable } from "./cursorAgentExecutable";
 import { parseStructuredOutput } from "./utils";
 import { runOpenCodeTextPrompt } from "../opencode/openCodeRuntime";
+import { resolveCliSpawnInvocation, terminateProcessTree } from "../shared/processExecution";
 
 export type ProviderTaskRunnerArgs = {
   cwd: string;
@@ -74,14 +75,17 @@ async function runCommand(args: {
   timeoutMs?: number;
 }): Promise<SpawnResult> {
   return await new Promise((resolve, reject) => {
-    const child = spawn(args.command, args.argv, {
+    const env = {
+      ...process.env,
+      NO_COLOR: "1",
+      TERM: "dumb",
+    };
+    const invocation = resolveCliSpawnInvocation(args.command, args.argv, env);
+    const child = spawn(invocation.command, invocation.args, {
       cwd: args.cwd,
-      env: {
-        ...process.env,
-        NO_COLOR: "1",
-        TERM: "dumb",
-      },
+      env,
       stdio: ["ignore", "pipe", "pipe"],
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments,
     });
 
     let stdout = "";
@@ -91,7 +95,7 @@ async function runCommand(args: {
     const timeoutHandle = setTimeout(() => {
       if (settled) return;
       settled = true;
-      child.kill("SIGTERM");
+      terminateProcessTree(child, "SIGTERM");
       reject(new Error(`Provider task timed out after ${timeoutMs}ms.`));
     }, timeoutMs);
 
diff --git a/apps/desktop/src/main/services/ai/tools/globSearch.test.ts b/apps/desktop/src/main/services/ai/tools/globSearch.test.ts
index 8d8e1a098..bdf82d7a4 100644
--- a/apps/desktop/src/main/services/ai/tools/globSearch.test.ts
+++ b/apps/desktop/src/main/services/ai/tools/globSearch.test.ts
@@ -65,6 +65,18 @@ describe("createGlobSearchTool", () => {
     expect(result.displayFiles).toContain("src/lib/deep/nested.ts");
   });
 
+  it("accepts Windows-style separators in glob patterns", async () => {
+    const cwd = makeTmpDir("glob-windows-pattern-");
+    writeFixtureFile(cwd, "src/lib/helper.ts", "export {}");
+    writeFixtureFile(cwd, "src/lib/helper.md", "# Hello");
+
+    const tool = createGlobSearchTool(cwd);
+    const result = await tool.execute({ pattern: "src\\**\\*.ts" });
+
+    expect(result.count).toBe(1);
+    expect(result.displayFiles).toEqual(["src/lib/helper.ts"]);
+  });
+
   it("handles brace expansion: src/**/*.{ts,tsx}", async () => {
     const cwd = makeTmpDir("glob-brace-");
     writeFixtureFile(cwd, "src/App.tsx", "export {}");
diff --git a/apps/desktop/src/main/services/ai/tools/globSearch.ts b/apps/desktop/src/main/services/ai/tools/globSearch.ts
index 40a13fd2f..68904c486 100644
--- a/apps/desktop/src/main/services/ai/tools/globSearch.ts
+++ b/apps/desktop/src/main/services/ai/tools/globSearch.ts
@@ -83,7 +83,7 @@ function walkAndMatch(root: string, globPattern: string, maxFiles = 5000): strin
     for (const entry of entries) {
       if (results.length >= maxFiles) return;
       const fullPath = path.join(dir, entry.name);
-      const relativePath = path.relative(root, fullPath);
+      const relativePath = path.relative(root, fullPath).replace(/\\/g, "/");
 
       if (entry.isDirectory()) {
         if (!SKIP_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
@@ -103,7 +103,7 @@ function walkAndMatch(root: string, globPattern: string, maxFiles = 5000): strin
 
 function globPatternToRegex(glob: string): RegExp {
   // Split into segments and process
-  const segments = glob.split("/");
+  const segments = glob.replace(/\\/g, "/").split("/");
   const regexParts: string[] = [];
 
   for (const seg of segments) {
diff --git a/apps/desktop/src/main/services/ai/tools/universalTools.test.ts b/apps/desktop/src/main/services/ai/tools/universalTools.test.ts
index 127d92301..5e4b9d852 100644
--- a/apps/desktop/src/main/services/ai/tools/universalTools.test.ts
+++ b/apps/desktop/src/main/services/ai/tools/universalTools.test.ts
@@ -4,7 +4,9 @@ import path from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import type { WorkerSandboxConfig } from "../../../../shared/types";
 import { DEFAULT_WORKER_SANDBOX_CONFIG } from "../../orchestrator/orchestratorConstants";
-import { checkWorkerSandbox, createUniversalToolSet } from "./universalTools";
+import { checkWorkerSandbox, createUniversalToolSet, resolveWorkerShellInvocation } from "./universalTools";
+
+const isWin = process.platform === "win32";
 
 const tmpDirs: string[] = [];
 function makeTmpDir(prefix: string): string {
@@ -144,12 +146,77 @@ describe("checkWorkerSandbox", () => {
     expect(result.allowed).toBe(true);
   });
 
+  it("treats POSIX double-slash paths as POSIX paths", () => {
+    const result = checkWorkerSandbox(
+      "//mnt/shared/tool --version",
+      sandboxWith({ allowedPaths: ["/"] }),
+      "/tmp/project",
+    );
+
+    expect(result.allowed).toBe(true);
+  });
+
   it("rejects mutating writes into /usr/local/bin even under the default sandbox", () => {
     const result = checkWorkerSandbox("cp ./payload /usr/local/bin/tool", DEFAULT_WORKER_SANDBOX_CONFIG, "/tmp/project");
     expect(result.allowed).toBe(false);
     expect(result.reason).toContain("Path outside sandbox");
   });
 
+  it("blocks Windows registry mutation commands", () => {
+    const result = checkWorkerSandbox(
+      "reg add HKCU\\Software\\Foo /v Bar /t REG_SZ /d 1",
+      DEFAULT_WORKER_SANDBOX_CONFIG,
+      "C:\\projects\\repo",
+    );
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("Blocked command pattern");
+  });
+
+  it("blocks reg.exe mutation commands", () => {
+    const result = checkWorkerSandbox(
+      "reg.exe add HKCU\\Software\\Foo /v Bar /t REG_SZ /d 1",
+      DEFAULT_WORKER_SANDBOX_CONFIG,
+      "C:\\projects\\repo",
+    );
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("Blocked command pattern");
+  });
+
+  it("blocks format.exe drive commands", () => {
+    const result = checkWorkerSandbox("format.exe c:", DEFAULT_WORKER_SANDBOX_CONFIG, "C:\\projects\\repo");
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("Blocked command pattern");
+  });
+
+  it("blocks Windows drive paths outside the sandbox", () => {
+    const result = checkWorkerSandbox(
+      "type C:\\Windows\\win.ini",
+      sandboxWith({ allowedPaths: ["./"] }),
+      "C:\\projects\\repo",
+    );
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("Path outside sandbox");
+  });
+
+  it("blocks Windows copy commands that target protected files", () => {
+    const result = checkWorkerSandbox(
+      "copy foo .env",
+      sandboxWith({ protectedFiles: ["\\.env"] }),
+      "C:\\projects\\repo",
+    );
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("protected file pattern");
+  });
+
+  it("allows git.exe read-only subcommands like Unix git", () => {
+    const result = checkWorkerSandbox(
+      "git.exe status",
+      DEFAULT_WORKER_SANDBOX_CONFIG,
+      "C:\\projects\\repo",
+    );
+    expect(result.allowed).toBe(true);
+  });
+
   it("blocks commands that are not in the safe list when blockByDefault is enabled", () => {
     const config = sandboxWith({
       blockByDefault: true,
@@ -1129,17 +1196,31 @@ describe("createUniversalToolSet", () => {
 
   // ── bash tool ───────────────────────────────────────────────────
 
+  it("resolveWorkerShellInvocation uses cmd on Windows and bash elsewhere", () => {
+    const inv = resolveWorkerShellInvocation("echo test");
+    if (isWin) {
+      expect(inv.file.toLowerCase().endsWith("cmd.exe")).toBe(true);
+      expect(inv.args[0]).toBe("/d");
+      expect(inv.args[1]).toBe("/s");
+      expect(inv.args[2]).toBe("/c");
+      expect(inv.args[3]).toBe("echo test");
+    } else {
+      expect(inv.file).toBe("bash");
+      expect(inv.args).toEqual(["-c", "echo test"]);
+    }
+  });
+
   it("executes a basic bash command and returns output", async () => {
     const cwd = makeTmpDir("ade-tools-bash-basic-");
     const tools = createUniversalToolSet(cwd, { permissionMode: "full-auto" });
 
     const result = await (tools.bash as any).execute({
-      command: "echo hello from bash",
+      command: isWin ? "echo hello from worker-shell" : "echo hello from bash",
       timeout: 5_000,
     });
 
     expect(result.exitCode).toBe(0);
-    expect(result.stdout).toContain("hello from bash");
+    expect(result.stdout).toContain(isWin ? "hello from worker-shell" : "hello from bash");
   });
 
   it("returns nonzero exit code for failing commands", async () => {
@@ -1147,7 +1228,7 @@ describe("createUniversalToolSet", () => {
     const tools = createUniversalToolSet(cwd, { permissionMode: "full-auto" });
 
     const result = await (tools.bash as any).execute({
-      command: "exit 42",
+      command: isWin ? "exit /b 42" : "exit 42",
       timeout: 5_000,
     });
 
diff --git a/apps/desktop/src/main/services/ai/tools/universalTools.ts b/apps/desktop/src/main/services/ai/tools/universalTools.ts
index 8829d8f3a..8bb862f02 100644
--- a/apps/desktop/src/main/services/ai/tools/universalTools.ts
+++ b/apps/desktop/src/main/services/ai/tools/universalTools.ts
@@ -15,6 +15,7 @@ import type { createMemoryService } from "../../memory/memoryService";
 import type { AgentChatApprovalDecision, AgentChatEvent, WorkerSandboxConfig, CtoCoreMemory } from "../../../../shared/types";
 import { DEFAULT_WORKER_SANDBOX_CONFIG } from "../../orchestrator/orchestratorConstants";
 import { getErrorMessage, isEnoentError, isWithinDir, resolvePathWithinRoot } from "../../shared/utils";
+import { terminateProcessTree } from "../../shared/processExecution";
 
 const execFileAsync = promisify(execFile);
 
@@ -174,6 +175,7 @@ function compileSandbox(config: WorkerSandboxConfig): CompiledSandbox {
 
 const WRITE_COMMAND_RE = /(?:>|>>|\btee\b|\bcp\s|\bmv\s|\brm\s|\bwrite\b|\bedit\b)/;
 const MUTATING_BASH_RE = /\b(?:rm|mv|cp|mkdir|touch|chmod|chown|patch|install|uninstall|add|remove|upgrade|apply|commit|rebase|merge|reset|checkout|switch|restore|sed\s+-i|perl\s+-i)\b|>>?|tee\b/i;
+const MUTATING_CMD_RE = /\b(?:copy|xcopy|robocopy|move|del|erase|rd|rmdir|md|mkdir|ren|rename)\b|>>?|tee\b/i;
 
 const MEMORY_GUARD_REASON = "Search memory before mutating files or running mutating commands for this turn.";
 
@@ -189,22 +191,49 @@ function requiresTurnMemoryGuard(state?: TurnMemoryPolicyState): boolean {
 }
 
 function bashCommandLikelyMutates(command: string): boolean {
-  return MUTATING_BASH_RE.test(command) || WRITE_COMMAND_RE.test(command);
+  return MUTATING_BASH_RE.test(command) || MUTATING_CMD_RE.test(command) || WRITE_COMMAND_RE.test(command);
 }
 
-function resolveAllowedWriteRoots(cwd: string, sandboxConfig?: WorkerSandboxConfig): string[] {
-  const roots = new Set<string>([path.resolve(cwd)]);
+function resolveAllowedWriteRoots(cwd: string, sandboxConfig?: WorkerSandboxConfig, pathApi: SandboxPathApi = getSandboxPathApi(cwd)): string[] {
+  const roots = new Set<string>([pathApi.resolve(cwd)]);
   if (sandboxConfig?.allowedPaths) {
     for (const allowedPath of sandboxConfig.allowedPaths) {
       if (typeof allowedPath !== "string" || allowedPath.trim().length === 0) continue;
-      roots.add(path.resolve(cwd, allowedPath));
+      roots.add(pathApi.resolve(cwd, allowedPath));
     }
   }
   return [...roots];
 }
 
-function canonicalizePathForContainment(absPath: string): string {
-  const resolved = path.resolve(absPath);
+type SandboxPathApi = typeof path | typeof path.win32;
+
+function isWindowsPathLike(value: string): boolean {
+  const trimmed = value.trim();
+  return (
+    /^[a-zA-Z]:$/.test(trimmed) ||
+    /(?:^|[\s"'`(=])[a-zA-Z]:[\\/]/.test(value) ||
+    trimmed.startsWith("\\\\")
+  );
+}
+
+function getSandboxPathApi(cwd: string, commandOrPath = ""): SandboxPathApi {
+  return process.platform === "win32" || isWindowsPathLike(cwd) || isWindowsPathLike(commandOrPath)
+    ? path.win32
+    : path;
+}
+
+function isWithinDirForPathApi(pathApi: SandboxPathApi, root: string, candidate: string): boolean {
+  const normalizedRoot = pathApi === path.win32 ? root.toLowerCase() : root;
+  const normalizedCandidate = pathApi === path.win32 ? candidate.toLowerCase() : candidate;
+  const rel = pathApi.relative(normalizedRoot, normalizedCandidate);
+  return rel === "" || (!rel.startsWith("..") && !pathApi.isAbsolute(rel));
+}
+
+function canonicalizePathForContainment(absPath: string, pathApi: SandboxPathApi = getSandboxPathApi(absPath)): string {
+  const resolved = pathApi.resolve(absPath);
+  if (pathApi === path.win32 && process.platform !== "win32") {
+    return resolved;
+  }
   try {
     return fs.realpathSync(resolved);
   } catch (error) {
@@ -213,11 +242,11 @@ function canonicalizePathForContainment(absPath: string): string {
     }
   }
 
-  const parent = path.dirname(resolved);
+  const parent = pathApi.dirname(resolved);
   if (parent === resolved) {
     return resolved;
   }
-  return path.join(canonicalizePathForContainment(parent), path.basename(resolved));
+  return pathApi.join(canonicalizePathForContainment(parent, pathApi), pathApi.basename(resolved));
 }
 
 function toPortablePath(value: string): string {
@@ -229,17 +258,18 @@ function matchesProtectedPathPattern(
   cwd: string,
   filePath: string,
   targetPath: string,
+  pathApi: SandboxPathApi = getSandboxPathApi(cwd, filePath),
 ): boolean {
-  const resolvedCwd = path.resolve(cwd);
+  const resolvedCwd = pathApi.resolve(cwd);
   const normalizedRaw = normalizePathToken(filePath);
   const normalizedTarget = toPortablePath(targetPath);
-  const relativeTarget = toPortablePath(path.relative(resolvedCwd, targetPath));
+  const relativeTarget = toPortablePath(pathApi.relative(resolvedCwd, targetPath));
   const candidates = new Set<string>([
     normalizedRaw,
     normalizedTarget,
-    path.basename(normalizedTarget),
+    pathApi.basename(targetPath),
   ]);
-  if (relativeTarget.length && !relativeTarget.startsWith("..") && !path.isAbsolute(relativeTarget)) {
+  if (relativeTarget.length && !relativeTarget.startsWith("..") && !pathApi.isAbsolute(relativeTarget)) {
     candidates.add(relativeTarget);
   }
   return [...candidates].some((candidate) => candidate.length > 0 && pattern.re.test(candidate));
@@ -250,13 +280,14 @@ function resolveWritableTargetPath(
   filePath: string,
   sandboxConfig?: WorkerSandboxConfig,
 ): { targetPath: string | null; error?: string } {
-  const targetPath = path.resolve(cwd, filePath);
-  const realCwd = canonicalizePathForContainment(cwd);
-  const realTargetPath = canonicalizePathForContainment(targetPath);
-  const allowedRoots = resolveAllowedWriteRoots(cwd, sandboxConfig).map((allowedRoot) =>
-    canonicalizePathForContainment(allowedRoot),
+  const pathApi = getSandboxPathApi(cwd, filePath);
+  const targetPath = pathApi.resolve(cwd, filePath);
+  const realCwd = canonicalizePathForContainment(cwd, pathApi);
+  const realTargetPath = canonicalizePathForContainment(targetPath, pathApi);
+  const allowedRoots = resolveAllowedWriteRoots(cwd, sandboxConfig, pathApi).map((allowedRoot) =>
+    canonicalizePathForContainment(allowedRoot, pathApi),
   );
-  const withinAllowedRoots = allowedRoots.some((allowedRoot) => isWithinDir(allowedRoot, realTargetPath));
+  const withinAllowedRoots = allowedRoots.some((allowedRoot) => isWithinDirForPathApi(pathApi, allowedRoot, realTargetPath));
   if (!withinAllowedRoots) {
     return {
       targetPath: null,
@@ -266,7 +297,7 @@ function resolveWritableTargetPath(
   if (sandboxConfig) {
     const protectedPatterns = compileSandbox(sandboxConfig).protected;
     const matchedPattern = protectedPatterns.find((pattern) =>
-      matchesProtectedPathPattern(pattern, realCwd, filePath, realTargetPath),
+      matchesProtectedPathPattern(pattern, realCwd, filePath, realTargetPath, pathApi),
     );
     if (matchedPattern) {
       return {
@@ -282,19 +313,20 @@ function normalizePathToken(token: string): string {
   return token.trim().replace(/^[("'`]+/, "").replace(/[)"'`,;]+$/, "");
 }
 
-function tokenizeCommand(command: string): string[] {
+function tokenizeCommand(command: string, windowsMode = process.platform === "win32"): string[] {
   const tokens: string[] = [];
   let current = "";
   let quote: "'" | '"' | "`" | null = null;
   let escaped = false;
 
-  for (const ch of command) {
+  for (let i = 0; i < command.length; i += 1) {
+    const ch = command[i]!;
     if (escaped) {
       current += ch;
       escaped = false;
       continue;
     }
-    if (ch === "\\") {
+    if (!windowsMode && ch === "\\") {
       escaped = true;
       continue;
     }
@@ -310,6 +342,20 @@ function tokenizeCommand(command: string): string[] {
       quote = ch;
       continue;
     }
+    if (ch === "&" || ch === "|" || (!windowsMode && ch === ";")) {
+      if (current.length > 0) {
+        tokens.push(current);
+        current = "";
+      }
+      const next = command[i + 1];
+      if ((ch === "&" || ch === "|") && next === ch) {
+        tokens.push(`${ch}${ch}`);
+        i += 1;
+        continue;
+      }
+      tokens.push(ch);
+      continue;
+    }
     if (/\s/.test(ch)) {
       if (current.length > 0) {
         tokens.push(current);
@@ -326,11 +372,18 @@ function tokenizeCommand(command: string): string[] {
   return tokens;
 }
 
-function looksLikePathToken(value: string): boolean {
+function looksLikePathToken(value: string, windowsMode = process.platform === "win32"): boolean {
   return (
     value.startsWith(".") ||
     value.startsWith("~") ||
-    value.includes("/")
+    value.includes("/") ||
+    (windowsMode && (
+      /^[a-zA-Z]:(?:[\\/]|$)/.test(value) ||
+      value.startsWith("\\\\") ||
+      value.startsWith(".\\") ||
+      value.startsWith("..\\") ||
+      value.includes("\\")
+    ))
   );
 }
 
@@ -351,8 +404,9 @@ function splitCommandSegments(tokens: string[]): string[][] {
   return segments;
 }
 
-function collectPathReferences(command: string, cwd: string): PathReference[] {
+function collectPathReferences(command: string, cwd: string, pathApi: SandboxPathApi = getSandboxPathApi(cwd, command)): PathReference[] {
   const refs = new Map<string, PathReference>();
+  const windowsMode = pathApi === path.win32;
   const accessPriority: Record<PathAccessMode, number> = {
     unknown: 0,
     read: 1,
@@ -368,9 +422,11 @@ function collectPathReferences(command: string, cwd: string): PathReference[] {
       normalizedRaw === "~"
         ? os.homedir()
         : normalizedRaw.startsWith("~/")
-          ? path.join(os.homedir(), normalizedRaw.slice(2))
+          ? pathApi.join(os.homedir(), normalizedRaw.slice(2))
+        : windowsMode && normalizedRaw.startsWith("~\\")
+          ? pathApi.join(os.homedir(), normalizedRaw.slice(2))
           : normalizedRaw;
-    const resolved = path.resolve(cwd, expandedPath);
+    const resolved = pathApi.resolve(cwd, expandedPath);
     const key = `${normalizedRaw}::${resolved}`;
     const existing = refs.get(key);
     if (!existing || accessPriority[access] > accessPriority[existing.access]) {
@@ -378,15 +434,22 @@ function collectPathReferences(command: string, cwd: string): PathReference[] {
     }
   };
 
-  for (const token of tokenizeCommand(command)) {
+  for (const token of tokenizeCommand(command, windowsMode)) {
     const value = normalizePathToken(token);
     if (!value.length) continue;
     if (value.startsWith("-")) continue;
     if (value === "|" || value === "||" || value === "&&" || value === ";" || value === "&") continue;
-    if (value.includes("=") && !value.startsWith("./") && !value.startsWith("../") && !value.startsWith("/") && !value.startsWith(".")) {
+    if (
+      value.includes("=")
+      && !value.startsWith("./")
+      && !value.startsWith("../")
+      && !value.startsWith("/")
+      && !value.startsWith(".")
+      && !(windowsMode && (value.startsWith(".\\") || value.startsWith("..\\")))
+    ) {
       continue;
     }
-    if (looksLikePathToken(value)) {
+    if (looksLikePathToken(value, windowsMode)) {
       addPath(value, "unknown");
     }
   }
@@ -396,25 +459,38 @@ function collectPathReferences(command: string, cwd: string): PathReference[] {
   }
 
   const markOperands = (commandName: string, args: string[]) => {
-    const normalizedCommand = path.basename(commandName).toLowerCase();
-    const pathOperands = args
+    const normalizedCommand = pathApi.basename(commandName).toLowerCase().replace(/\.(?:exe|cmd|bat)$/i, "");
+    const normalizedArgs = args
       .map((value) => normalizePathToken(value))
-      .filter((value) => value.length > 0 && !value.startsWith("-") && looksLikePathToken(value));
+      .filter((value) => value.length > 0 && !value.startsWith("-") && !(windowsMode && /^\/[a-z?]/i.test(value)));
+    const pathOperands = normalizedArgs.filter((value) => looksLikePathToken(value, windowsMode));
     if (!pathOperands.length) return;
 
     switch (normalizedCommand) {
       case "cp":
+      case "copy":
+      case "xcopy":
+      case "robocopy":
       case "install":
       case "ln": {
-        if (pathOperands.length >= 2) {
+        const destination = [...normalizedArgs].reverse().find((value) => looksLikePathToken(value, windowsMode));
+        if (destination) {
           pathOperands.slice(0, -1).forEach((value) => addPath(value, "read"));
-          addPath(pathOperands[pathOperands.length - 1]!, "write");
+          addPath(destination, "write");
         }
         return;
       }
       case "mv":
+      case "move":
+      case "ren":
+      case "rename":
       case "rm":
+      case "del":
+      case "erase":
       case "mkdir":
+      case "md":
+      case "rmdir":
+      case "rd":
       case "touch":
       case "chmod":
       case "chown":
@@ -438,12 +514,12 @@ function collectPathReferences(command: string, cwd: string): PathReference[] {
     }
   };
 
-  for (const segment of splitCommandSegments(tokenizeCommand(command))) {
+  for (const segment of splitCommandSegments(tokenizeCommand(command, windowsMode))) {
     let commandIndex = 0;
     while (
       commandIndex < segment.length
       && normalizePathToken(segment[commandIndex] ?? "").includes("=")
-      && !looksLikePathToken(normalizePathToken(segment[commandIndex] ?? ""))
+      && !looksLikePathToken(normalizePathToken(segment[commandIndex] ?? ""), windowsMode)
     ) {
       commandIndex += 1;
     }
@@ -457,6 +533,26 @@ function collectPathReferences(command: string, cwd: string): PathReference[] {
   return [...refs.values()];
 }
 
+function isNullDevicePath(resolved: string): boolean {
+  if (resolved === "/dev/null") return true;
+  if (process.platform === "win32") {
+    const norm = resolved.replace(/\\/g, "/").toLowerCase();
+    return norm === "nul" || norm.endsWith("/nul");
+  }
+  return false;
+}
+
+function isSystemExecutableSandboxPath(resolved: string): boolean {
+  const norm = resolved.replace(/\\/g, "/");
+  if (process.platform !== "win32") {
+    return norm.startsWith("/usr/bin/") || norm.startsWith("/usr/local/bin/");
+  }
+  const lower = norm.toLowerCase();
+  const systemRoot = (process.env.SystemRoot || process.env.windir || "C:\\Windows").replace(/\\/g, "/");
+  const sr = systemRoot.toLowerCase();
+  return lower.startsWith(`${sr}/system32/`) || lower.startsWith(`${sr}/syswow64/`);
+}
+
 /**
  * Check a bash command against the worker sandbox config.
  * Returns { allowed: true } or { allowed: false, reason: string }.
@@ -467,6 +563,7 @@ export function checkWorkerSandbox(
   projectRoot: string,
 ): { allowed: boolean; reason?: string } {
   const compiled = compileSandbox(config);
+  const pathApi = getSandboxPathApi(projectRoot, command);
 
   // 1. Check blocked patterns first (always reject)
   for (const { re, src } of compiled.blocked) {
@@ -479,20 +576,20 @@ export function checkWorkerSandbox(
   const commandMutates = bashCommandLikelyMutates(command);
 
   // 2. Validate file paths against allowedPaths (absolute + relative)
-  const rootResolved = canonicalizePathForContainment(projectRoot);
-  const pathRefs = collectPathReferences(command, projectRoot);
+  const rootResolved = canonicalizePathForContainment(projectRoot, pathApi);
+  const pathRefs = collectPathReferences(command, projectRoot, pathApi);
   for (const entry of pathRefs) {
     const p = entry.raw;
-    const resolved = canonicalizePathForContainment(entry.resolved);
-    const isSystemExecutablePath = resolved.startsWith("/usr/bin/") || resolved.startsWith("/usr/local/bin/");
-    if (resolved === "/dev/null") continue;
+    const resolved = canonicalizePathForContainment(entry.resolved, pathApi);
+    const isSystemExecutablePath = isSystemExecutableSandboxPath(resolved);
+    if (isNullDevicePath(resolved)) continue;
     if (isSystemExecutablePath && (entry.access === "read" || (!commandMutates && entry.access !== "write"))) continue;
 
     const withinAllowed = config.allowedPaths.some((allowed) => {
-      const allowedAbs = canonicalizePathForContainment(path.resolve(projectRoot, allowed));
-      return isWithinDir(allowedAbs, resolved);
+      const allowedAbs = canonicalizePathForContainment(pathApi.resolve(projectRoot, allowed), pathApi);
+      return isWithinDirForPathApi(pathApi, allowedAbs, resolved);
     });
-    if (!withinAllowed && !isWithinDir(rootResolved, resolved)) {
+    if (!withinAllowed && !isWithinDirForPathApi(pathApi, rootResolved, resolved)) {
       return { allowed: false, reason: `Path outside sandbox: ${p}` };
     }
   }
@@ -504,7 +601,7 @@ export function checkWorkerSandbox(
       if (re.test(command)) {
         return { allowed: false, reason: `Command targets protected file pattern: ${src}` };
       }
-      const targetsProtectedPath = protectedRefs.some((entry) => matchesProtectedPathPattern({ re, src }, projectRoot, entry.raw, entry.resolved));
+      const targetsProtectedPath = protectedRefs.some((entry) => matchesProtectedPathPattern({ re, src }, projectRoot, entry.raw, entry.resolved, pathApi));
       if (targetsProtectedPath) {
         return { allowed: false, reason: `Command targets protected file pattern: ${src}` };
       }
@@ -526,6 +623,15 @@ export function checkWorkerSandbox(
 
 // ── New tool implementations ────────────────────────────────────────
 
+/** Spawn argv for worker shell execution (bash on Unix, cmd via ComSpec on Windows). */
+export function resolveWorkerShellInvocation(command: string): { file: string; args: string[] } {
+  if (process.platform === "win32") {
+    const comSpec = process.env.ComSpec?.trim() || "cmd.exe";
+    return { file: comSpec, args: ["/d", "/s", "/c", command] };
+  }
+  return { file: "bash", args: ["-c", command] };
+}
+
 function createBashTool(
   cwd: string,
   mode: PermissionMode,
@@ -536,7 +642,9 @@ function createBashTool(
   return tool({
     description:
       "Execute a shell command and return stdout/stderr. " +
-      "Commands run in a non-interactive shell with a 120-second timeout.",
+      (process.platform === "win32"
+        ? "On Windows, commands run via cmd.exe (ComSpec) with a 120-second timeout; on macOS/Linux they run in bash. "
+        : "Commands run in a non-interactive bash shell with a 120-second timeout. "),
     inputSchema: z.object({
       command: z.string().describe("The shell command to execute"),
       timeout: z
@@ -582,15 +690,25 @@ function createBashTool(
         }
       }
       const clampedTimeout = Math.min(timeout, 600_000);
+      const killProc = (proc: ReturnType<typeof spawn>): void => {
+        terminateProcessTree(proc, "SIGTERM");
+      };
       try {
         const result = await new Promise<{ stdout: string; stderr: string; exitCode: number }>(
           (resolve, reject) => {
-            const proc = spawn("bash", ["-c", command], {
+            const { file, args } = resolveWorkerShellInvocation(command);
+            const proc = spawn(file, args, {
               cwd,
-              timeout: clampedTimeout,
               stdio: ["ignore", "pipe", "pipe"],
-              env: { ...process.env, TERM: "dumb" },
+              windowsVerbatimArguments: process.platform === "win32",
+              env:
+                process.platform === "win32"
+                  ? { ...process.env }
+                  : { ...process.env, TERM: "dumb" },
             });
+            const timeoutId = setTimeout(() => {
+              killProc(proc);
+            }, clampedTimeout);
 
             let stdout = "";
             let stderr = "";
@@ -599,24 +717,28 @@ function createBashTool(
               stdout += d.toString();
               // Cap output at 1MB
               if (stdout.length > 1_000_000) {
-                proc.kill("SIGTERM");
+                killProc(proc);
               }
             });
             proc.stderr.on("data", (d: Buffer) => {
               stderr += d.toString();
               if (stderr.length > 1_000_000) {
-                proc.kill("SIGTERM");
+                killProc(proc);
               }
             });
 
             proc.on("close", (code) => {
+              clearTimeout(timeoutId);
               resolve({
                 stdout: stdout.slice(0, 200_000),
                 stderr: stderr.slice(0, 50_000),
                 exitCode: code ?? 1,
               });
             });
-            proc.on("error", reject);
+            proc.on("error", (error) => {
+              clearTimeout(timeoutId);
+              reject(error);
+            });
           }
         );
         return result;
diff --git a/apps/desktop/src/main/services/ai/tools/workflowTools.ts b/apps/desktop/src/main/services/ai/tools/workflowTools.ts
index b6046261b..f4fb2cd20 100644
--- a/apps/desktop/src/main/services/ai/tools/workflowTools.ts
+++ b/apps/desktop/src/main/services/ai/tools/workflowTools.ts
@@ -12,6 +12,7 @@ import fs from "node:fs";
 import type { createLaneService } from "../../lanes/laneService";
 import type { createPrService } from "../../prs/prService";
 import type { ComputerUseArtifactBrokerService } from "../../computerUse/computerUseArtifactBrokerService";
+import { getLocalComputerUseCapabilities } from "../../computerUse/localComputerUse";
 import { nowIso } from "../../shared/utils";
 import { getPrIssueResolutionAvailability } from "../../../../shared/prIssueResolution";
 import type { AgentChatCompletionReport } from "../../../../shared/types";
@@ -157,11 +158,20 @@ export function createWorkflowTools(
       execute: async ({ title, description }) => {
         let tmpDir: string | null = null;
         try {
+          const capabilities = getLocalComputerUseCapabilities();
+          if (!capabilities.screenshot.available) {
+            return {
+              success: false,
+              error: capabilities.screenshot.detail,
+              blocked: capabilities.screenshot.state,
+              platform: capabilities.platform,
+            };
+          }
+
           tmpDir = fs.mkdtempSync(path.join(require("node:os").tmpdir(), "ade-screenshot-"));
           const tmpPath = path.join(tmpDir, `screenshot-${Date.now()}.png`);
 
-          // Use macOS screencapture to grab the screen
-          await execFileAsync("screencapture", ["-x", tmpPath], {
+          await execFileAsync(capabilities.screenshot.command ?? "screencapture", ["-x", tmpPath], {
             timeout: 15_000,
           });
 
diff --git a/apps/desktop/src/main/services/automations/automationPlannerService.ts b/apps/desktop/src/main/services/automations/automationPlannerService.ts
index eb5c32ab6..1178b72d3 100644
--- a/apps/desktop/src/main/services/automations/automationPlannerService.ts
+++ b/apps/desktop/src/main/services/automations/automationPlannerService.ts
@@ -31,6 +31,7 @@ import { resolveClaudeCodeExecutable } from "../ai/claudeCodeExecutable";
 import { resolveCodexExecutable } from "../ai/codexExecutable";
 import type { createProjectConfigService } from "../config/projectConfigService";
 import type { createLaneService } from "../lanes/laneService";
+import { resolveCliSpawnInvocation } from "../shared/processExecution";
 import { getErrorMessage, quoteIfNeeded, resolvePathWithinRoot } from "../shared/utils";
 
 function resolveAutomationCwdBase(
@@ -388,15 +389,18 @@ async function runCodexExec(args: {
   }
   const commandPreview = [quoteIfNeeded(codexExecutable), ...cliArgs.map(quoteIfNeeded)].join(" ");
 
-  const child = spawn(codexExecutable, cliArgs, {
+  const env = {
+    ...process.env,
+    // Keep output parseable.
+    NO_COLOR: "1",
+    TERM: "dumb"
+  };
+  const invocation = resolveCliSpawnInvocation(codexExecutable, cliArgs, env);
+  const child = spawn(invocation.command, invocation.args, {
     cwd: args.cwd,
-    env: {
-      ...process.env,
-      // Keep output parseable.
-      NO_COLOR: "1",
-      TERM: "dumb"
-    },
-    stdio: ["ignore", "pipe", "pipe"]
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsVerbatimArguments: invocation.windowsVerbatimArguments,
   });
 
   let stderr = "";
@@ -469,14 +473,17 @@ async function runClaudeHeadless(args: {
   const claudeExecutable = resolveClaudeCodeExecutable().path;
   const commandPreview = [quoteIfNeeded(claudeExecutable), ...cliArgs.map(quoteIfNeeded)].join(" ");
 
-  const child = spawn(claudeExecutable, cliArgs, {
+  const env = {
+    ...process.env,
+    NO_COLOR: "1",
+    TERM: "dumb"
+  };
+  const invocation = resolveCliSpawnInvocation(claudeExecutable, cliArgs, env);
+  const child = spawn(invocation.command, invocation.args, {
     cwd: args.cwd,
-    env: {
-      ...process.env,
-      NO_COLOR: "1",
-      TERM: "dumb"
-    },
-    stdio: ["ignore", "pipe", "pipe"]
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsVerbatimArguments: invocation.windowsVerbatimArguments,
   });
 
   let stdout = "";
diff --git a/apps/desktop/src/main/services/automations/automationService.ts b/apps/desktop/src/main/services/automations/automationService.ts
index 136289d92..d9d71cc27 100644
--- a/apps/desktop/src/main/services/automations/automationService.ts
+++ b/apps/desktop/src/main/services/automations/automationService.ts
@@ -1324,7 +1324,9 @@ export function createAutomationService({
 
   const runCommand = async (args: { command: string; cwd: string; timeoutMs: number }): Promise<{ output: string; exitCode: number | null }> => {
     const startedAt = Date.now();
-    const child = spawn(process.platform === "win32" ? "cmd.exe" : "sh", process.platform === "win32" ? ["/c", args.command] : ["-lc", args.command], {
+    const shellFile = process.platform === "win32" ? (process.env.ComSpec?.trim() || "cmd.exe") : "sh";
+    const shellArgs = process.platform === "win32" ? ["/d", "/s", "/c", args.command] : ["-lc", args.command];
+    const child = spawn(shellFile, shellArgs, {
       cwd: args.cwd,
       env: process.env,
       stdio: ["ignore", "pipe", "pipe"]
diff --git a/apps/desktop/src/main/services/chat/agentChatService.ts b/apps/desktop/src/main/services/chat/agentChatService.ts
index 8b3a9caef..e8317b3e6 100644
--- a/apps/desktop/src/main/services/chat/agentChatService.ts
+++ b/apps/desktop/src/main/services/chat/agentChatService.ts
@@ -61,6 +61,10 @@ import {
   readFileWithinRootSecure,
   resolvePathWithinRoot,
 } from "../shared/utils";
+import {
+  resolveCliSpawnInvocation,
+  terminateProcessTree,
+} from "../shared/processExecution";
 import type { EpisodicSummaryService } from "../memory/episodicSummaryService";
 import { DEFAULT_FLUSH_PROMPT } from "../memory/compactionFlushPrompt";
 import type {
@@ -635,8 +639,12 @@ function signalChildProcessTree(
   child: ChildProcessWithoutNullStreams,
   signal: NodeJS.Signals,
 ): boolean {
+  if (process.platform === "win32") {
+    return terminateProcessTree(child, signal);
+  }
+
   const pid = child.pid ?? null;
-  if (process.platform !== "win32" && pid != null && Number.isInteger(pid) && pid > 0) {
+  if (pid != null && Number.isInteger(pid) && pid > 0) {
     try {
       process.kill(-pid, signal);
       return true;
@@ -683,12 +691,12 @@ function terminateChildProcessTree(
   }
 
   const timer = setTimeout(() => {
-    if (process.platform !== "win32") {
-      if (!isProcessGroupAlive(pid)) return;
+    if (process.platform === "win32") {
+      if (!isProcessAlive(pid)) return;
       signalChildProcessTree(child, "SIGKILL");
       return;
     }
-    if (!isProcessAlive(pid)) return;
+    if (!isProcessGroupAlive(pid)) return;
     signalChildProcessTree(child, "SIGKILL");
   }, killAfterMs);
   timer.unref?.();
@@ -9433,11 +9441,13 @@ export function createAgentChatService(args: {
       });
       throw error;
     }
-    const proc = spawn(codexExecutable, ["app-server"], {
+    const invocation = resolveCliSpawnInvocation(codexExecutable, ["app-server"]);
+    const proc = spawn(invocation.command, invocation.args, {
       cwd: managed.laneWorktreePath,
       env: spawnEnv,
       stdio: ["pipe", "pipe", "pipe"],
       detached: process.platform !== "win32",
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments,
     });
 
     const reader = readline.createInterface({ input: proc.stdout });
diff --git a/apps/desktop/src/main/services/chat/cursorAcpPool.ts b/apps/desktop/src/main/services/chat/cursorAcpPool.ts
index fd8e9307e..0d6d66b63 100644
--- a/apps/desktop/src/main/services/chat/cursorAcpPool.ts
+++ b/apps/desktop/src/main/services/chat/cursorAcpPool.ts
@@ -23,6 +23,7 @@ import {
   type WriteTextFileResponse,
 } from "@agentclientprotocol/sdk";
 import { hasNullByte, readFileWithinRootSecure, secureWriteTextAtomicWithinRoot } from "../shared/utils";
+import { resolveCliSpawnInvocation, terminateProcessTree } from "../shared/processExecution";
 
 export type CursorAcpBridge = {
   onPermission: ((req: RequestPermissionRequest) => Promise<RequestPermissionResponse>) | null;
@@ -136,11 +137,13 @@ function createCursorAcpClient(bridge: CursorAcpBridge, terminals: Map<string, T
       const limit = typeof params.outputByteLimit === "number" && params.outputByteLimit > 0
         ? params.outputByteLimit
         : 512 * 1024;
-      const proc = spawn(params.command, params.args ?? [], {
+      const env = mergeEnvVars(process.env, params.env ?? undefined);
+      const invocation = resolveCliSpawnInvocation(params.command, params.args ?? [], env);
+      const proc = spawn(invocation.command, invocation.args, {
         cwd,
-        env: mergeEnvVars(process.env, params.env ?? undefined),
-        shell: process.platform === "win32",
+        env,
         stdio: ["pipe", "pipe", "pipe"],
+        windowsVerbatimArguments: invocation.windowsVerbatimArguments,
       });
       proc.on("error", (err) => {
         console.error(`[CursorAcpPool] terminal process error for termId=${termId}:`, err);
@@ -210,22 +213,14 @@ function createCursorAcpClient(bridge: CursorAcpBridge, terminals: Map<string, T
     async killTerminal(params: KillTerminalRequest): Promise<void> {
       const t = terminals.get(params.terminalId);
       if (t && !t.exited) {
-        try {
-          t.proc.kill("SIGTERM");
-        } catch {
-          // ignore
-        }
+        terminateProcessTree(t.proc, "SIGTERM");
       }
     },
 
     async releaseTerminal(params: ReleaseTerminalRequest): Promise<void> {
       const t = terminals.get(params.terminalId);
       if (t) {
-        try {
-          if (!t.exited) t.proc.kill("SIGKILL");
-        } catch {
-          // ignore
-        }
+        if (!t.exited) terminateProcessTree(t.proc, "SIGKILL");
         const id = params.terminalId;
         terminals.delete(id);
         bridge.onTerminalDisposed?.(id);
@@ -300,11 +295,14 @@ export async function acquireCursorAcpConnection(args: {
     spawnArgs.push("--api-key", apiKey);
   }
 
-  const proc = spawn(args.agentPath, spawnArgs, {
+  const env = { ...process.env };
+  const invocation = resolveCliSpawnInvocation(args.agentPath, spawnArgs, env);
+  const proc = spawn(invocation.command, invocation.args, {
     stdio: ["pipe", "pipe", "pipe"],
-    env: { ...process.env },
+    env,
     cwd: args.workspacePath,
     detached: process.platform !== "win32",
+    windowsVerbatimArguments: invocation.windowsVerbatimArguments,
   });
 
   proc.on("error", (err) => {
@@ -364,18 +362,10 @@ export async function acquireCursorAcpConnection(args: {
         bridge.onTerminalDisposed?.(termId);
       }
       for (const t of terminals.values()) {
-        try {
-          if (!t.exited) t.proc.kill("SIGKILL");
-        } catch {
-          // ignore
-        }
+        if (!t.exited) terminateProcessTree(t.proc, "SIGKILL");
       }
       terminals.clear();
-      try {
-        proc.kill("SIGTERM");
-      } catch {
-        // ignore
-      }
+      terminateProcessTree(proc, "SIGTERM");
     },
   };
 
diff --git a/apps/desktop/src/main/services/cli/adeCliService.test.ts b/apps/desktop/src/main/services/cli/adeCliService.test.ts
index 8ab31991b..de26ff570 100644
--- a/apps/desktop/src/main/services/cli/adeCliService.test.ts
+++ b/apps/desktop/src/main/services/cli/adeCliService.test.ts
@@ -5,6 +5,15 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 import { createAdeCliService } from "./adeCliService";
 
 const tmpRoots: string[] = [];
+const originalPlatform = process.platform;
+const originalLocalAppData = process.env.LOCALAPPDATA;
+
+function setPlatform(value: NodeJS.Platform): void {
+  Object.defineProperty(process, "platform", {
+    value,
+    configurable: true,
+  });
+}
 
 function makeTempRoot(): string {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "ade-cli-service-"));
@@ -29,6 +38,9 @@ function logger() {
 
 afterEach(() => {
   vi.restoreAllMocks();
+  setPlatform(originalPlatform);
+  if (originalLocalAppData === undefined) delete process.env.LOCALAPPDATA;
+  else process.env.LOCALAPPDATA = originalLocalAppData;
   for (const root of tmpRoots.splice(0)) {
     fs.rmSync(root, { recursive: true, force: true });
   }
@@ -62,6 +74,45 @@ describe("createAdeCliService", () => {
     expect(service.agentEnv({ PATH: "/usr/bin:/bin" }).PATH?.split(path.delimiter)[0]).toBe(packagedBinDir);
   });
 
+  it("uses packaged Windows cmd wrappers and Path casing", async () => {
+    setPlatform("win32");
+    const root = makeTempRoot();
+    process.env.LOCALAPPDATA = path.join(root, "LocalAppData");
+    const resourcesPath = path.join(root, "resources");
+    const packagedBinDir = path.join(resourcesPath, "ade-cli", "bin");
+    const packagedCommandPath = path.join(packagedBinDir, "ade.cmd");
+    writeExecutable(packagedCommandPath, "@echo off\r\nexit /b 0\r\n");
+    writeExecutable(path.join(resourcesPath, "ade-cli", "install-path.cmd"), "@echo off\r\nexit /b 0\r\n");
+    fs.writeFileSync(path.join(resourcesPath, "ade-cli", "cli.cjs"), "console.log('ade')\n");
+
+    const service = createAdeCliService({
+      isPackaged: true,
+      resourcesPath,
+      userDataPath: path.join(root, "user-data"),
+      appExecutablePath: path.join(root, "ADE.exe"),
+      env: {
+        Path: `${packagedBinDir};C:\\Windows\\System32`,
+        PATHEXT: ".EXE;.CMD",
+      },
+      logger: logger() as any,
+    });
+
+    expect(service.resolved).toEqual({
+      source: "packaged",
+      binDir: packagedBinDir,
+      commandPath: packagedCommandPath,
+      installerPath: path.join(resourcesPath, "ade-cli", "install-path.cmd"),
+      cliJsPath: path.join(resourcesPath, "ade-cli", "cli.cjs"),
+    });
+    expect(service.agentEnv({ Path: "C:\\Windows\\System32" }).Path?.split(";")[0]).toBe(packagedBinDir);
+    expect(service.agentEnv({ Path: "C:\\Windows\\System32" }).PATH).toBeUndefined();
+
+    const status = await service.getStatus();
+    expect(status.terminalInstalled).toBe(true);
+    expect(status.terminalCommandPath?.toLowerCase()).toBe(packagedCommandPath.toLowerCase());
+    expect(status.installTargetPath.endsWith(path.join("ADE", "bin", "ade.cmd"))).toBe(true);
+  });
+
   it("reports Terminal install status from the original host PATH after agent PATH is applied", async () => {
     const root = makeTempRoot();
     const resourcesPath = path.join(root, "Resources");
@@ -156,6 +207,39 @@ describe("createAdeCliService", () => {
     expect(service.agentEnv({ PATH: "/usr/bin:/bin" }).PATH?.split(path.delimiter)[0]).toBe(path.dirname(shimPath));
   });
 
+  it("creates a Windows dev cmd shim under userData", () => {
+    setPlatform("win32");
+    const root = makeTempRoot();
+    const repoRoot = path.join(root, "repo");
+    const userDataPath = path.join(root, "user-data");
+    const cliJsPath = path.join(repoRoot, "apps", "ade-cli", "dist", "cli.cjs");
+    fs.mkdirSync(path.dirname(cliJsPath), { recursive: true });
+    fs.writeFileSync(cliJsPath, "console.log('ade')\n");
+    fs.mkdirSync(path.join(repoRoot, "apps", "desktop"), { recursive: true });
+    fs.writeFileSync(path.join(repoRoot, "apps", "ade-cli", "package.json"), "{}\n");
+    fs.writeFileSync(path.join(repoRoot, "apps", "desktop", "package.json"), "{}\n");
+    vi.spyOn(process, "cwd").mockReturnValue(repoRoot);
+
+    const service = createAdeCliService({
+      isPackaged: false,
+      resourcesPath: path.join(root, "missing-resources"),
+      userDataPath,
+      appExecutablePath: path.join(root, "ADE.exe"),
+      logger: logger() as any,
+    });
+
+    const shimPath = path.join(userDataPath, "ade-cli", "bin", "ade.cmd");
+    const script = fs.readFileSync(shimPath, "utf8");
+
+    expect(service.resolved.source).toBe("dev");
+    expect(service.resolved.commandPath).toBe(shimPath);
+    expect(script).toContain("@echo off");
+    expect(script).toContain("set \"APP_EXE=");
+    expect(script).toContain("\"%APP_EXE%\" \"%CLI_JS%\" %*");
+    expect(script).toContain(path.join("node_modules", ".bin", "tsx.cmd"));
+    expect(service.agentEnv({ Path: "C:\\Windows\\System32" }).Path?.split(";")[0]).toBe(path.dirname(shimPath));
+  });
+
   it("falls back to source CLI when dist/cli.cjs is missing in a dev repo", () => {
     const root = makeTempRoot();
     const repoRoot = path.join(root, "repo");
diff --git a/apps/desktop/src/main/services/cli/adeCliService.ts b/apps/desktop/src/main/services/cli/adeCliService.ts
index b0b752668..7543d6625 100644
--- a/apps/desktop/src/main/services/cli/adeCliService.ts
+++ b/apps/desktop/src/main/services/cli/adeCliService.ts
@@ -35,9 +35,46 @@ function shellQuote(value: string): string {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
 
+function pathDelimiter(): string {
+  return process.platform === "win32" ? ";" : PATH_DELIMITER;
+}
+
+function commandFileName(): "ade" | "ade.cmd" {
+  return process.platform === "win32" ? "ade.cmd" : "ade";
+}
+
+function installerFileName(): "install-path.sh" | "install-path.cmd" {
+  return process.platform === "win32" ? "install-path.cmd" : "install-path.sh";
+}
+
+function findPathEnvKey(env: NodeJS.ProcessEnv): string {
+  if (process.platform !== "win32") return "PATH";
+  const existing = Object.keys(env).find((key) => key.toLowerCase() === "path");
+  return existing ?? "Path";
+}
+
+function getPathEnvValue(env: NodeJS.ProcessEnv): string | undefined {
+  return env[findPathEnvKey(env)];
+}
+
+function setPathEnvValue(env: NodeJS.ProcessEnv, value: string): void {
+  const key = findPathEnvKey(env);
+  if (process.platform === "win32") {
+    for (const existing of Object.keys(env)) {
+      if (existing.toLowerCase() === "path" && existing !== key) {
+        delete env[existing];
+      }
+    }
+  }
+  env[key] = value;
+}
+
 function isExecutable(filePath: string | null | undefined): boolean {
   if (!filePath) return false;
   try {
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile()) return false;
+    if (process.platform === "win32") return true;
     fs.accessSync(filePath, fs.constants.X_OK);
     return true;
   } catch {
@@ -46,15 +83,16 @@ function isExecutable(filePath: string | null | undefined): boolean {
 }
 
 function splitPathEntries(value: string | null | undefined): string[] {
-  return (value ?? "").split(PATH_DELIMITER).map((entry) => entry.trim()).filter(Boolean);
+  return (value ?? "").split(pathDelimiter()).map((entry) => entry.trim()).filter(Boolean);
 }
 
 function pathContainsDir(pathValue: string | null | undefined, dir: string | null): boolean {
   if (!dir) return false;
-  const resolved = path.resolve(dir);
+  const resolved = process.platform === "win32" ? path.resolve(dir).toLowerCase() : path.resolve(dir);
   return splitPathEntries(pathValue).some((entry) => {
     try {
-      return path.resolve(entry) === resolved;
+      const candidate = process.platform === "win32" ? path.resolve(entry).toLowerCase() : path.resolve(entry);
+      return candidate === resolved;
     } catch {
       return false;
     }
@@ -65,15 +103,19 @@ function prependPathDir(pathValue: string | null | undefined, dir: string | null
   if (!dir) return pathValue ?? undefined;
   if (pathContainsDir(pathValue, dir)) return pathValue ?? undefined;
   const current = pathValue?.trim();
-  return current ? `${dir}${PATH_DELIMITER}${current}` : dir;
+  return current ? `${dir}${pathDelimiter()}${current}` : dir;
 }
 
-function resolveCommandOnPath(command: string, pathValue: string | null | undefined): string | null {
-  const extensions = process.platform === "win32"
-    ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean)
+function resolveCommandOnPath(command: string, pathValue: string | null | undefined, env: NodeJS.ProcessEnv = process.env): string | null {
+  const rawExtensions = process.platform === "win32"
+    ? (env.PATHEXT ?? env.Pathext ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean)
     : [""];
+  const extensions = process.platform === "win32"
+    ? Array.from(new Set(rawExtensions.flatMap((ext) => [ext, ext.toLowerCase(), ext.toUpperCase()])))
+    : rawExtensions;
+  const suffixes = process.platform === "win32" && path.extname(command) ? [""] : extensions;
   for (const entry of splitPathEntries(pathValue)) {
-    for (const ext of extensions) {
+    for (const ext of suffixes) {
       const candidate = path.join(entry, `${command}${ext}`);
       if (isExecutable(candidate)) return candidate;
     }
@@ -81,6 +123,77 @@ function resolveCommandOnPath(command: string, pathValue: string | null | undefi
   return null;
 }
 
+function escapeCmdSetValue(value: string): string {
+  return value.replace(/%/g, "%%").replace(/"/g, "\"\"");
+}
+
+function createWindowsShimScript(args: {
+  cliJsPath: string;
+  entryKind: "built" | "source";
+  tsxBinPath: string | null;
+  tsxImportPath: string | null;
+  appExecutablePath: string;
+}): string {
+  return [
+    "@echo off",
+    "setlocal",
+    `set "CLI_JS=${escapeCmdSetValue(args.cliJsPath)}"`,
+    `set "CLI_ENTRY_KIND=${escapeCmdSetValue(args.entryKind)}"`,
+    `set "TSX_BIN=${escapeCmdSetValue(args.tsxBinPath ?? "")}"`,
+    `set "TSX_IMPORT=${escapeCmdSetValue(args.tsxImportPath ?? "")}"`,
+    `set "APP_EXE=${escapeCmdSetValue(args.appExecutablePath)}"`,
+    "if /I \"%CLI_ENTRY_KIND%\"==\"source\" (",
+    "  if exist \"%TSX_BIN%\" (",
+    "    \"%TSX_BIN%\" \"%CLI_JS%\" %*",
+    "    exit /b %ERRORLEVEL%",
+    "  )",
+    "  if not exist \"%TSX_IMPORT%\" (",
+    "    echo ade: Local source CLI fallback requires repo-local tsx. Run npm --prefix apps/ade-cli install or npm --prefix apps/ade-cli run build. 1>&2",
+    "    exit /b 127",
+    "  )",
+    "  if defined ADE_CLI_NODE (",
+    "    \"%ADE_CLI_NODE%\" --import \"%TSX_IMPORT%\" \"%CLI_JS%\" %*",
+    "    exit /b %ERRORLEVEL%",
+    "  )",
+    "  if exist \"%APP_EXE%\" (",
+    "    set \"ELECTRON_RUN_AS_NODE=1\"",
+    "    \"%APP_EXE%\" --import \"%TSX_IMPORT%\" \"%CLI_JS%\" %*",
+    "    exit /b %ERRORLEVEL%",
+    "  )",
+    "  where node >nul 2>nul",
+    "  if not errorlevel 1 (",
+    "    node -e \"process.exit(Number(process.versions.node.split('.')[0]) >= 22 ? 0 : 1)\" >nul 2>nul",
+    "    if not errorlevel 1 (",
+    "      node --import \"%TSX_IMPORT%\" \"%CLI_JS%\" %*",
+    "      exit /b %ERRORLEVEL%",
+    "    )",
+    "  )",
+    "  echo ade: Node.js 22+ or the ADE Electron runtime is required to run this source CLI. 1>&2",
+    "  exit /b 127",
+    ")",
+    "if defined ADE_CLI_NODE (",
+    "  \"%ADE_CLI_NODE%\" \"%CLI_JS%\" %*",
+    "  exit /b %ERRORLEVEL%",
+    ")",
+    "if exist \"%APP_EXE%\" (",
+    "  set \"ELECTRON_RUN_AS_NODE=1\"",
+    "  \"%APP_EXE%\" \"%CLI_JS%\" %*",
+    "  exit /b %ERRORLEVEL%",
+    ")",
+    "where node >nul 2>nul",
+    "if not errorlevel 1 (",
+    "  node -e \"process.exit(Number(process.versions.node.split('.')[0]) >= 22 ? 0 : 1)\" >nul 2>nul",
+    "  if not errorlevel 1 (",
+    "    node \"%CLI_JS%\" %*",
+    "    exit /b %ERRORLEVEL%",
+    "  )",
+    ")",
+    "echo ade: Node.js 22+ or the ADE Electron runtime is required to run this CLI. 1>&2",
+    "exit /b 127",
+    "",
+  ].join("\r\n");
+}
+
 function findRepoRoot(startDir: string): string | null {
   let cursor = path.resolve(startDir);
   while (true) {
@@ -182,8 +295,8 @@ function writeDevShim(args: {
   logger: Logger;
 }): { commandPath: string; binDir: string } | null {
   const binDir = path.join(args.userDataPath, "ade-cli", "bin");
-  const commandPath = path.join(binDir, "ade");
-  const script = [
+  const commandPath = path.join(binDir, commandFileName());
+  const script = process.platform === "win32" ? createWindowsShimScript(args) : [
     "#!/bin/sh",
     "set -eu",
     `CLI_JS=${shellQuote(args.cliJsPath)}`,
@@ -239,8 +352,10 @@ function writeDevShim(args: {
 
   try {
     fs.mkdirSync(binDir, { recursive: true });
-    fs.writeFileSync(commandPath, script, { encoding: "utf8", mode: 0o755 });
-    fs.chmodSync(commandPath, 0o755);
+    fs.writeFileSync(commandPath, script, process.platform === "win32"
+      ? { encoding: "utf8" }
+      : { encoding: "utf8", mode: 0o755 });
+    if (process.platform !== "win32") fs.chmodSync(commandPath, 0o755);
     return { commandPath, binDir };
   } catch (error) {
     args.logger.warn("ade_cli.dev_shim_failed", {
@@ -254,9 +369,9 @@ function writeDevShim(args: {
 function resolveCliPaths(args: CreateAdeCliServiceArgs): ResolvedCliPaths {
   const resourcesPath = args.resourcesPath ? path.resolve(args.resourcesPath) : null;
   const packagedBinDir = resourcesPath ? path.join(resourcesPath, "ade-cli", "bin") : null;
-  const packagedCommandPath = packagedBinDir ? path.join(packagedBinDir, "ade") : null;
+  const packagedCommandPath = packagedBinDir ? path.join(packagedBinDir, commandFileName()) : null;
   const packagedCliJsPath = resourcesPath ? path.join(resourcesPath, "ade-cli", "cli.cjs") : null;
-  const packagedInstallerPath = resourcesPath ? path.join(resourcesPath, "ade-cli", "install-path.sh") : null;
+  const packagedInstallerPath = resourcesPath ? path.join(resourcesPath, "ade-cli", installerFileName()) : null;
 
   if (args.isPackaged && isExecutable(packagedCommandPath)) {
     return {
@@ -273,7 +388,7 @@ function resolveCliPaths(args: CreateAdeCliServiceArgs): ResolvedCliPaths {
     const shim = writeDevShim({
       cliJsPath: devCli.cliPath,
       entryKind: devCli.entryKind,
-      tsxBinPath: path.join(devCli.repoRoot, "apps", "ade-cli", "node_modules", ".bin", "tsx"),
+      tsxBinPath: path.join(devCli.repoRoot, "apps", "ade-cli", "node_modules", ".bin", process.platform === "win32" ? "tsx.cmd" : "tsx"),
       tsxImportPath: path.join(devCli.repoRoot, "apps", "ade-cli", "node_modules", "tsx", "dist", "loader.mjs"),
       userDataPath: args.userDataPath,
       appExecutablePath: args.appExecutablePath,
@@ -300,6 +415,10 @@ function resolveCliPaths(args: CreateAdeCliServiceArgs): ResolvedCliPaths {
 }
 
 function installTargetPath(): string {
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA?.trim() || path.join(os.homedir(), "AppData", "Local");
+    return path.join(localAppData, "ADE", "bin", "ade.cmd");
+  }
   return path.join(os.homedir(), ".local", "bin", "ade");
 }
 
@@ -342,12 +461,13 @@ function statusMessage(args: {
 
 export function createAdeCliService(args: CreateAdeCliServiceArgs) {
   const resolved = resolveCliPaths(args);
-  const hostPathSnapshot = args.env?.PATH ?? process.env.PATH;
+  const envSnapshot = args.env ?? process.env;
+  const hostPathSnapshot = getPathEnvValue(envSnapshot);
 
   const agentEnv = (baseEnv: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv => {
     const next: NodeJS.ProcessEnv = { ...baseEnv };
-    const nextPath = prependPathDir(next.PATH, resolved.binDir);
-    if (nextPath) next.PATH = nextPath;
+    const nextPath = prependPathDir(getPathEnvValue(next), resolved.binDir);
+    if (nextPath) setPathEnvValue(next, nextPath);
     if (resolved.commandPath) next.ADE_CLI_PATH = resolved.commandPath;
     if (resolved.binDir) next.ADE_CLI_BIN_DIR = resolved.binDir;
     return next;
@@ -355,18 +475,21 @@ export function createAdeCliService(args: CreateAdeCliServiceArgs) {
 
   const applyToProcessEnv = (): void => {
     const next = agentEnv(process.env);
-    process.env.PATH = next.PATH;
+    const nextPath = getPathEnvValue(next);
+    if (nextPath) setPathEnvValue(process.env, nextPath);
     if (next.ADE_CLI_PATH) process.env.ADE_CLI_PATH = next.ADE_CLI_PATH;
     if (next.ADE_CLI_BIN_DIR) process.env.ADE_CLI_BIN_DIR = next.ADE_CLI_BIN_DIR;
   };
 
   const getStatus = async (): Promise<AdeCliStatus> => {
-    const terminalCommandPath = resolveCommandOnPath("ade", hostPathSnapshot);
+    const terminalCommandPath = resolveCommandOnPath("ade", hostPathSnapshot, envSnapshot);
     const targetPath = installTargetPath();
     const targetDir = path.dirname(targetPath);
     const terminalInstalled = Boolean(terminalCommandPath);
     const bundledAvailable = Boolean(resolved.commandPath && isExecutable(resolved.commandPath));
-    const agentPathReady = bundledAvailable && pathContainsDir(agentEnv({ PATH: hostPathSnapshot }).PATH, resolved.binDir);
+    const hostPathEnv: NodeJS.ProcessEnv = {};
+    if (hostPathSnapshot) setPathEnvValue(hostPathEnv, hostPathSnapshot);
+    const agentPathReady = bundledAvailable && pathContainsDir(getPathEnvValue(agentEnv(hostPathEnv)), resolved.binDir);
     const installAvailable = resolved.source === "packaged" && isExecutable(resolved.installerPath);
     const message = statusMessage({
       terminalInstalled,
diff --git a/apps/desktop/src/main/services/computerUse/localComputerUse.ts b/apps/desktop/src/main/services/computerUse/localComputerUse.ts
index 9972660a0..75b28f0c4 100644
--- a/apps/desktop/src/main/services/computerUse/localComputerUse.ts
+++ b/apps/desktop/src/main/services/computerUse/localComputerUse.ts
@@ -144,7 +144,7 @@ export function createComputerUseArtifactPath(projectRoot: string, stem: string,
 export function toProjectArtifactUri(projectRoot: string, absolutePath: string): string {
   const relative = path.relative(projectRoot, absolutePath);
   if (!relative.startsWith("..") && !path.isAbsolute(relative)) {
-    return relative;
+    return relative.replace(/\\/g, "/");
   }
   return absolutePath;
 }
diff --git a/apps/desktop/src/main/services/conflicts/conflictService.ts b/apps/desktop/src/main/services/conflicts/conflictService.ts
index c768f38e8..101186fac 100644
--- a/apps/desktop/src/main/services/conflicts/conflictService.ts
+++ b/apps/desktop/src/main/services/conflicts/conflictService.ts
@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
+import { resolveCliSpawnInvocation } from "../shared/processExecution";
 import type {
   ApplyConflictProposalArgs,
   BatchOverlapEntry,
@@ -3498,10 +3499,13 @@ export function createConflictService({
     });
 
     const proc = await new Promise<{ stdout: string; stderr: string; status: number | null; signal: NodeJS.Signals | null }>((resolve) => {
-      const child = spawn(bin, renderedCommand.slice(1), {
+      const invocation = resolveCliSpawnInvocation(bin, renderedCommand.slice(1), process.env);
+      const child = spawn(invocation.command, invocation.args, {
         cwd: cwdLane.worktreePath,
+        env: process.env,
         stdio: ["ignore", "pipe", "pipe"],
         timeout: 8 * 60_000,
+        windowsVerbatimArguments: invocation.windowsVerbatimArguments,
       });
       let stdout = "";
       let stderr = "";
diff --git a/apps/desktop/src/main/services/ipc/registerIpc.ts b/apps/desktop/src/main/services/ipc/registerIpc.ts
index 0f936f4a5..62629b7d3 100644
--- a/apps/desktop/src/main/services/ipc/registerIpc.ts
+++ b/apps/desktop/src/main/services/ipc/registerIpc.ts
@@ -5,6 +5,7 @@ import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import type { Server as NetServer } from "node:net";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { IPC } from "../../../shared/ipc";
 import { getModelById } from "../../../shared/modelRegistry";
 import { buildPrAiResolutionContextKey } from "../../../shared/types";
@@ -583,6 +584,7 @@ import type { AdeProjectService } from "../projects/adeProjectService";
 import type { ConfigReloadService } from "../projects/configReloadService";
 import type { createAdeCliService } from "../cli/adeCliService";
 import { getErrorMessage, isRecord, nowIso, resolvePathWithinRoot, toMemoryEntryDto } from "../shared/utils";
+import { quoteWindowsCmdArg } from "../shared/processExecution";
 import { resolveAdeLayout } from "../../../shared/adeLayout";
 
 export type AppContext = {
@@ -1859,10 +1861,27 @@ export function registerIpc({
     await shell.openExternal(parsed.toString());
   });
 
+  const resolveRendererSuppliedPath = (rawPath: string, projectRoot: string): string => {
+    let inputPath = rawPath;
+    if (/^ade-artifact:\/\/project(?:\/|$)/i.test(inputPath)) {
+      const parsed = new URL(inputPath);
+      inputPath = decodeURIComponent(parsed.pathname.replace(/^\/+/, ""));
+    }
+    if (/^file:\/\//i.test(inputPath)) {
+      try {
+        inputPath = fileURLToPath(inputPath);
+      } catch {
+        inputPath = decodeURIComponent(inputPath.replace(/^file:\/\//i, ""));
+      }
+    }
+    return path.resolve(path.isAbsolute(inputPath) ? inputPath : path.join(projectRoot, inputPath));
+  };
+
   ipcMain.handle(IPC.appRevealPath, async (_event, arg: { path: string }): Promise<void> => {
     const raw = typeof arg?.path === "string" ? arg.path.trim() : "";
     if (!raw) return;
-    const normalized = path.resolve(raw);
+    const ctx = getCtx();
+    const normalized = resolveRendererSuppliedPath(raw, ctx.project.rootPath);
     // Validate the path is within known safe directories only.
     // Reject requests to reveal arbitrary paths (e.g. ~/.ssh, /etc, /System).
     const allowedDirs = getAllowedDirs(getCtx);
@@ -1883,7 +1902,8 @@ export function registerIpc({
   ipcMain.handle(IPC.appOpenPath, async (_event, arg: { path: string }): Promise<void> => {
     const raw = typeof arg?.path === "string" ? arg.path.trim() : "";
     if (!raw) return;
-    const normalized = path.resolve(raw);
+    const ctx = getCtx();
+    const normalized = resolveRendererSuppliedPath(raw, ctx.project.rootPath);
     const allowedDirs = getAllowedDirs(getCtx);
     const allowed = allowedDirs.some((dir) => {
       try {
@@ -1954,33 +1974,59 @@ export function registerIpc({
         return;
       }
 
-      const launchDetached = async (command: string, args: string[]): Promise<void> => {
+      const launchDetached = async (
+        command: string,
+        args: string[],
+        options?: { windowsVerbatimArguments?: boolean; resolveOn?: "spawn" | "exit" },
+      ): Promise<void> => {
         await new Promise<void>((resolve, reject) => {
           let settled = false;
+          const resolveOn = options?.resolveOn ?? "spawn";
           try {
-            const child = spawn(command, args, { detached: true, stdio: "ignore" });
+            const child = spawn(command, args, {
+              detached: true,
+              stdio: "ignore",
+              windowsVerbatimArguments: options?.windowsVerbatimArguments,
+            });
             child.once("error", (error) => {
               if (settled) return;
               settled = true;
               reject(error);
             });
             child.once("spawn", () => {
+              if (resolveOn !== "spawn") return;
               if (settled) return;
               settled = true;
               child.unref();
               resolve();
             });
+            child.once("exit", (code) => {
+              if (resolveOn !== "exit") return;
+              if (settled) return;
+              settled = true;
+              child.unref();
+              if (code === 0) {
+                resolve();
+              } else {
+                reject(new Error(`exit code ${code}`));
+              }
+            });
           } catch (error) {
             reject(error);
           }
         });
       };
 
-      const launchAttempts = async (attempts: Array<{ command: string; args: string[] }>): Promise<void> => {
+      const launchAttempts = async (
+        attempts: Array<{ command: string; args: string[]; windowsVerbatimArguments?: boolean; resolveOn?: "spawn" | "exit" }>,
+      ): Promise<void> => {
         let lastError: unknown = null;
         for (const attempt of attempts) {
           try {
-            await launchDetached(attempt.command, attempt.args);
+            await launchDetached(attempt.command, attempt.args, {
+              windowsVerbatimArguments: attempt.windowsVerbatimArguments,
+              resolveOn: attempt.resolveOn,
+            });
             return;
           } catch (error) {
             lastError = error;
@@ -1989,13 +2035,23 @@ export function registerIpc({
         throw lastError instanceof Error ? lastError : new Error("Failed to launch external editor.");
       };
 
-      const attempts: Array<{ command: string; args: string[] }> = [];
+      const attempts: Array<{ command: string; args: string[]; windowsVerbatimArguments?: boolean; resolveOn?: "spawn" | "exit" }> = [];
       const cliCommand = target === "vscode" ? "code" : target === "cursor" ? "cursor" : "zed";
 
       if (process.platform === "darwin") {
         const appName = target === "vscode" ? "Visual Studio Code" : target === "cursor" ? "Cursor" : "Zed";
         attempts.push({ command: "open", args: ["-a", appName, targetPath] });
       }
+      if (process.platform === "win32") {
+        // `start "" <command> <args>` — empty title is required when the next token is quoted.
+        const windowsShell = process.env.ComSpec?.trim() || "cmd.exe";
+        attempts.push({
+          command: windowsShell,
+          args: ["/d", "/s", "/c", `start "" ${quoteWindowsCmdArg(cliCommand)} ${quoteWindowsCmdArg(targetPath)}`],
+          windowsVerbatimArguments: true,
+          resolveOn: "exit",
+        });
+      }
       attempts.push({ command: cliCommand, args: [targetPath] });
 
       try {
@@ -4574,14 +4630,7 @@ export function registerIpc({
     // handler in main.ts which validates exclusively against currentArtifactsDir.
     const allowedRoots = [layout.artifactsDir];
 
-    let filePath = arg.uri;
-    if (filePath.startsWith("file://")) {
-      const { fileURLToPath } = await import("node:url");
-      try { filePath = fileURLToPath(filePath); } catch { filePath = decodeURIComponent(filePath.replace(/^file:\/\//i, "")); }
-    }
-    if (!path.isAbsolute(filePath)) {
-      filePath = path.resolve(projectRoot, filePath);
-    }
+    const filePath = resolveRendererSuppliedPath(arg.uri, projectRoot);
     // Canonicalize and verify the resolved path is inside an allowed artifact root.
     const canonical = path.normalize(path.resolve(filePath));
     const inside = allowedRoots.some((root) => {
diff --git a/apps/desktop/src/main/services/lanes/laneEnvironmentService.ts b/apps/desktop/src/main/services/lanes/laneEnvironmentService.ts
index 3803cb8c6..bf91f4654 100644
--- a/apps/desktop/src/main/services/lanes/laneEnvironmentService.ts
+++ b/apps/desktop/src/main/services/lanes/laneEnvironmentService.ts
@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { execFile } from "node:child_process";
+import { spawn } from "node:child_process";
 import type {
   LaneEnvInitConfig,
   LaneEnvInitProgress,
@@ -22,6 +22,7 @@ import {
   secureCopyPathIntoRoot,
   secureWriteFileWithinRoot,
 } from "../shared/utils";
+import { resolveCliSpawnInvocation, terminateProcessTree } from "../shared/processExecution";
 
 /** Resolve a relative path against `root` and throw if it escapes.  Logs a warning on escape. */
 function resolveCheckedPath(
@@ -227,15 +228,42 @@ export function createLaneEnvironmentService({
   ): Promise<{ exitCode: number; stdout: string; stderr: string }> {
     return new Promise((resolve) => {
       const [cmd, ...args] = command;
-      execFile(cmd, args, { cwd, timeout: timeoutMs, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
-        const exitCode = error && typeof (error as { code?: unknown }).code === "number"
-          ? (error as { code: number }).code
-          : 1;
-        resolve({
-          exitCode: error ? exitCode : 0,
-          stdout: stdout ?? "",
-          stderr: stderr ?? ""
-        });
+      if (!cmd) {
+        resolve({ exitCode: 1, stdout: "", stderr: "Missing command" });
+        return;
+      }
+      const invocation = resolveCliSpawnInvocation(cmd, args, process.env);
+      const child = spawn(invocation.command, invocation.args, {
+        cwd,
+        env: process.env,
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+      });
+      let stdout = "";
+      let stderr = "";
+      let settled = false;
+      const maxBuffer = 10 * 1024 * 1024;
+      const timer = setTimeout(() => {
+        if (settled) return;
+        terminateProcessTree(child);
+      }, timeoutMs);
+      const append = (current: string, chunk: Buffer): string =>
+        current.length >= maxBuffer
+          ? current
+          : current + chunk.toString("utf8").slice(0, maxBuffer - current.length);
+      child.stdout?.on("data", (chunk: Buffer) => { stdout = append(stdout, chunk); });
+      child.stderr?.on("data", (chunk: Buffer) => { stderr = append(stderr, chunk); });
+      child.on("error", (error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve({ exitCode: 1, stdout, stderr: error instanceof Error ? error.message : String(error) });
+      });
+      child.on("close", (code) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve({ exitCode: code ?? 1, stdout, stderr });
       });
     });
   }
diff --git a/apps/desktop/src/main/services/opencode/openCodeBinaryManager.ts b/apps/desktop/src/main/services/opencode/openCodeBinaryManager.ts
index b63c60575..501f604b3 100644
--- a/apps/desktop/src/main/services/opencode/openCodeBinaryManager.ts
+++ b/apps/desktop/src/main/services/opencode/openCodeBinaryManager.ts
@@ -12,19 +12,30 @@ export type OpenCodeBinaryInfo = {
 
 let cachedInfo: OpenCodeBinaryInfo | null = null;
 
-function bundledBinaryPath(): string {
-  const ext = process.platform === "win32" ? ".exe" : "";
+function bundledBinaryCandidatePaths(): string[] {
+  const fileNames = process.platform === "win32"
+    ? ["opencode.exe", "opencode.cmd", "opencode.bat", "opencode"]
+    : ["opencode"];
   // In packaged app, process.resourcesPath points to Resources/
   // In dev, fall back to node_modules/.bin
   const resourcesPath = (process as any).resourcesPath;
   if (resourcesPath) {
-    return join(resourcesPath, `opencode${ext}`);
+    return fileNames.map((fileName) => join(resourcesPath, fileName));
   }
   // Dev fallback: check node_modules
   if (typeof __dirname !== "string") {
-    return join(process.cwd(), "apps", "desktop", "node_modules", ".bin", `opencode${ext}`);
+    return fileNames.map((fileName) => join(process.cwd(), "apps", "desktop", "node_modules", ".bin", fileName));
+  }
+  return fileNames.map((fileName) => join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", fileName));
+}
+
+function canRunBundledBinary(filePath: string): boolean {
+  try {
+    accessSync(filePath, process.platform === "win32" ? constants.F_OK : constants.X_OK);
+    return true;
+  } catch {
+    return false;
   }
-  return join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", `opencode${ext}`);
 }
 
 export function resolveOpenCodeBinary(): OpenCodeBinaryInfo {
@@ -41,13 +52,10 @@ export function resolveOpenCodeBinary(): OpenCodeBinaryInfo {
   }
 
   // 2. Fall back to bundled binary
-  const bundled = bundledBinaryPath();
-  try {
-    accessSync(bundled, constants.X_OK);
+  const bundled = bundledBinaryCandidatePaths().find((candidate) => canRunBundledBinary(candidate));
+  if (bundled) {
     cachedInfo = { path: bundled, source: "bundled" };
     return cachedInfo;
-  } catch {
-    // Bundled binary not found or not executable
   }
 
   cachedInfo = { path: null, source: "missing" };
diff --git a/apps/desktop/src/main/services/opencode/openCodeRuntime.ts b/apps/desktop/src/main/services/opencode/openCodeRuntime.ts
index 481d5e2fb..ceb972205 100644
--- a/apps/desktop/src/main/services/opencode/openCodeRuntime.ts
+++ b/apps/desktop/src/main/services/opencode/openCodeRuntime.ts
@@ -22,6 +22,7 @@ import type {
   OpenCodeRuntimeSnapshot,
   ProjectConfigFile,
 } from "../../../shared/types";
+import { isAdeMcpNamedPipePath } from "../../../shared/adeMcpIpc";
 import { stableStringify } from "../shared/utils";
 import { resolveOpenCodeBinaryPath } from "./openCodeBinaryManager";
 import type { PermissionMode } from "../ai/tools/universalTools";
diff --git a/apps/desktop/src/main/services/opencode/openCodeServerManager.test.ts b/apps/desktop/src/main/services/opencode/openCodeServerManager.test.ts
index 9b170a261..408057c9b 100644
--- a/apps/desktop/src/main/services/opencode/openCodeServerManager.test.ts
+++ b/apps/desktop/src/main/services/opencode/openCodeServerManager.test.ts
@@ -11,15 +11,62 @@ vi.mock("./openCodeBinaryManager", () => ({
 
 import {
   __buildOpenCodeServeLaunchSpecForTests,
+  __isManagedOpenCodeServeCommandForTests,
   __resetOpenCodeServerManagerForTests,
   __setOpenCodeProcessControllerForTests,
   __setOpenCodeServerLauncherForTests,
   acquireDedicatedOpenCodeServer,
   acquireSharedOpenCodeServer,
   getOpenCodeRuntimeDiagnostics,
+  parseWindowsWmicProcessCsv,
   recoverManagedOpenCodeOrphans,
 } from "./openCodeServerManager";
 
+const originalProcessPlatform = process.platform;
+
+function setProcessPlatform(platform: NodeJS.Platform): void {
+  Object.defineProperty(process, "platform", {
+    value: platform,
+    configurable: true,
+  });
+}
+
+describe("parseWindowsWmicProcessCsv", () => {
+  it("parses WMIC CSV rows into pid, ppid, and command", () => {
+    const csv = [
+      "Node,CommandLine,ParentProcessId,ProcessId",
+      ",C:\\\\Windows\\\\System32\\\\notepad.exe,100,200",
+    ].join("\r\n");
+    const rows = parseWindowsWmicProcessCsv(csv);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toEqual({
+      pid: 200,
+      ppid: 100,
+      command: "C:\\\\Windows\\\\System32\\\\notepad.exe",
+    });
+  });
+
+  it("parses PowerShell ConvertTo-Csv rows", () => {
+    const csv = [
+      '"ProcessId","ParentProcessId","CommandLine"',
+      '"300","200","C:\\\\Windows\\\\System32\\\\cmd.exe /d /s /c opencode.cmd serve"',
+    ].join("\r\n");
+    const rows = parseWindowsWmicProcessCsv(csv);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.pid).toBe(300);
+    expect(rows[0]?.ppid).toBe(200);
+    expect(rows[0]?.command).toContain("opencode.cmd");
+  });
+});
+
+describe("Windows managed OpenCode command detection", () => {
+  it("detects cmd-wrapped serve with inline managed markers", () => {
+    const cmdLine =
+      'C:\\\\Windows\\\\System32\\\\cmd.exe /d /s /c set "ADE_OPENCODE_MANAGED=1"&&set "OPENCODE_DISABLE_PROJECT_CONFIG=1"&&set "ADE_OPENCODE_OWNER_PID=999"&&C:\\\\opencode\\\\opencode.cmd serve --hostname=127.0.0.1 --port=4310';
+    expect(__isManagedOpenCodeServeCommandForTests(cmdLine)).toBe(true);
+  });
+});
+
 describe("openCodeServerManager", () => {
   const originalEnv = {
     PATH: process.env.PATH,
@@ -48,6 +95,7 @@ describe("openCodeServerManager", () => {
       listProcesses: () => [],
       isProcessAlive: () => false,
       killProcess: () => {},
+      killProcessTree: () => false,
       waitForMs: async () => {},
     });
     __setOpenCodeServerLauncherForTests(async ({ port }) => {
@@ -63,6 +111,7 @@ describe("openCodeServerManager", () => {
 
   afterEach(() => {
     __resetOpenCodeServerManagerForTests();
+    setProcessPlatform(originalProcessPlatform as NodeJS.Platform);
     vi.useRealTimers();
     restoreEnv("PATH");
     restoreEnv("HOME");
@@ -407,35 +456,45 @@ describe("openCodeServerManager", () => {
     expect(spec.env.OPENCODE_BIN_PATH).toBeUndefined();
   });
 
-  it("reaps orphaned ADE-managed OpenCode processes and skips ones with a live owner", async () => {
+  it("quotes the OpenCode executable in Windows cmd launch specs", () => {
+    setProcessPlatform("win32");
+    process.env.ADE_OPENCODE_XDG_ROOT = "/tmp/ade-opencode-test-home";
+
+    const spec = __buildOpenCodeServeLaunchSpecForTests({
+      config: { share: "disabled" } as const,
+      port: 4310,
+    });
+
+    expect(spec.executable).toBe("cmd.exe");
+    expect(spec.args[0]).toBe("/d");
+    expect(spec.args[1]).toBe("/s");
+    expect(spec.args[2]).toBe("/c");
+    expect(spec.args[3]).toContain('&&"/Users/admin/.opencode/bin/opencode" serve --hostname=127.0.0.1 --port=4310');
+  });
+
+  it("reaps orphaned ADE-managed OpenCode processes on Windows with a tree kill and skips ones with a live owner", async () => {
+    setProcessPlatform("win32");
     let orphanAlive = true;
-    const killProcess = vi.fn((pid: number, signal: NodeJS.Signals) => {
-      if (pid === 4101 && signal === "SIGKILL") {
+    const killProcess = vi.fn();
+    const killProcessTree = vi.fn((pid: number) => {
+      if (pid === 4101) {
         orphanAlive = false;
       }
+      return true;
     });
-    const homeDir = os.homedir();
     __setOpenCodeProcessControllerForTests({
       listProcesses: () => ([
         {
           pid: 4101,
           ppid: 1,
-          command: [
-            "/Users/admin/.opencode/bin/opencode serve --hostname=127.0.0.1 --port=62298",
-            "OPENCODE_DISABLE_PROJECT_CONFIG=1",
-            `XDG_CONFIG_HOME=${homeDir}/.ade/opencode-runtime/xdg-v1/config`,
-          ].join(" "),
+          command:
+            'C:\\Windows\\System32\\cmd.exe /d /s /c set "ADE_OPENCODE_MANAGED=1"&&set "OPENCODE_DISABLE_PROJECT_CONFIG=1"&&set "ADE_OPENCODE_OWNER_PID=999999"&&C:\\opencode\\opencode.cmd serve --hostname=127.0.0.1 --port=62298',
         },
         {
           pid: 4102,
           ppid: 1,
-          command: [
-            "/Users/admin/.opencode/bin/opencode serve --hostname=127.0.0.1 --port=62299",
-            "OPENCODE_DISABLE_PROJECT_CONFIG=1",
-            "ADE_OPENCODE_MANAGED=1",
-            "ADE_OPENCODE_OWNER_PID=7788",
-            `XDG_CONFIG_HOME=${homeDir}/.ade/opencode-runtime/xdg-v1/config`,
-          ].join(" "),
+          command:
+            'C:\\Windows\\System32\\cmd.exe /d /s /c set "ADE_OPENCODE_MANAGED=1"&&set "OPENCODE_DISABLE_PROJECT_CONFIG=1"&&set "ADE_OPENCODE_OWNER_PID=7788"&&C:\\opencode\\opencode.cmd serve --hostname=127.0.0.1 --port=62299',
         },
       ]),
       isProcessAlive: (pid) => {
@@ -443,14 +502,15 @@ describe("openCodeServerManager", () => {
         return pid === 4102 || pid === 7788;
       },
       killProcess,
+      killProcessTree,
     });
     const result = await recoverManagedOpenCodeOrphans();
 
     expect(result.recoveredPids).toEqual([4101]);
     expect(result.skippedPids).toEqual([4102]);
-    expect(killProcess).toHaveBeenCalledWith(4101, "SIGTERM");
-    expect(killProcess).toHaveBeenCalledWith(4101, "SIGKILL");
-    expect(killProcess).not.toHaveBeenCalledWith(4102, "SIGTERM");
+    expect(killProcessTree).toHaveBeenCalledWith(4101);
+    expect(killProcessTree).not.toHaveBeenCalledWith(4102);
+    expect(killProcess).not.toHaveBeenCalled();
   });
 
   it("does not mark stubborn orphaned processes as recovered", async () => {
diff --git a/apps/desktop/src/main/services/opencode/openCodeServerManager.ts b/apps/desktop/src/main/services/opencode/openCodeServerManager.ts
index c9e400988..7fc787e26 100644
--- a/apps/desktop/src/main/services/opencode/openCodeServerManager.ts
+++ b/apps/desktop/src/main/services/opencode/openCodeServerManager.ts
@@ -7,6 +7,7 @@ import path from "node:path";
 import type { Config as OpenCodeConfig } from "@opencode-ai/sdk";
 import type { Logger } from "../logging/logger";
 import { stableStringify } from "../shared/utils";
+import { processOutputToString } from "../shared/processExecution";
 import { resolveOpenCodeBinaryPath } from "./openCodeBinaryManager";
 
 export type OpenCodeServerLeaseKind = "shared" | "dedicated";
@@ -62,6 +63,7 @@ type OpenCodeProcessController = {
   listProcesses(): OpenCodeProcessSnapshot[];
   isProcessAlive(pid: number): boolean;
   killProcess(pid: number, signal: NodeJS.Signals): void;
+  killProcessTree(pid: number): boolean;
   waitForMs(ms: number): Promise<void>;
 };
 
@@ -144,9 +146,125 @@ function readLinuxProcessEnvironment(pid: number): string[] {
   }
 }
 
+function parseOneCsvLine(line: string): string[] {
+  const out: string[] = [];
+  let cur = "";
+  let i = 0;
+  let inQuotes = false;
+  while (i < line.length) {
+    const c = line[i]!;
+    if (inQuotes) {
+      if (c === "\"") {
+        if (line[i + 1] === "\"") {
+          cur += "\"";
+          i += 2;
+          continue;
+        }
+        inQuotes = false;
+        i += 1;
+        continue;
+      }
+      cur += c;
+      i += 1;
+      continue;
+    }
+    if (c === "\"") {
+      inQuotes = true;
+      i += 1;
+      continue;
+    }
+    if (c === ",") {
+      out.push(cur);
+      cur = "";
+      i += 1;
+      continue;
+    }
+    cur += c;
+    i += 1;
+  }
+  out.push(cur);
+  return out;
+}
+
+/** Parses WMIC `process get ... /FORMAT:CSV` stdout into snapshots (exported for unit tests). */
+export function parseWindowsWmicProcessCsv(stdout: string): OpenCodeProcessSnapshot[] {
+  const rows: OpenCodeProcessSnapshot[] = [];
+  const lines = stdout
+    .split(/\r?\n/)
+    .map((l) => l.trim())
+    .filter((l) => l.length > 0);
+  if (lines.length < 2) return rows;
+
+  const header = parseOneCsvLine(lines[0]!);
+  const processIdIdx = header.indexOf("ProcessId");
+  const parentProcessIdIdx = header.indexOf("ParentProcessId");
+  const commandLineIdx = header.indexOf("CommandLine");
+  if (processIdIdx < 0 || parentProcessIdIdx < 0 || commandLineIdx < 0) {
+    return rows;
+  }
+
+  const maxIdx = Math.max(processIdIdx, parentProcessIdIdx, commandLineIdx);
+  for (let li = 1; li < lines.length; li += 1) {
+    const cells = parseOneCsvLine(lines[li]!);
+    if (cells.length <= maxIdx) continue;
+    const pid = Number(cells[processIdIdx]?.trim());
+    const ppid = Number(cells[parentProcessIdIdx]?.trim());
+    if (!Number.isInteger(pid) || pid <= 0 || !Number.isInteger(ppid) || ppid < 0) {
+      continue;
+    }
+    const command = (cells[commandLineIdx] ?? "").trim();
+    rows.push({ pid, ppid, command });
+  }
+  return rows;
+}
+
+function listWindowsProcessesFromWmic(): OpenCodeProcessSnapshot[] {
+  const result = spawnSync(
+    "wmic",
+    ["process", "get", "ProcessId,ParentProcessId,CommandLine", "/FORMAT:CSV"],
+    {
+      encoding: "utf8",
+      windowsHide: true,
+      maxBuffer: 50 * 1024 * 1024,
+    },
+  );
+  if (result.error || result.status !== 0 || typeof result.stdout !== "string") {
+    return [];
+  }
+  return parseWindowsWmicProcessCsv(result.stdout);
+}
+
+function listWindowsProcessesFromPowerShell(): OpenCodeProcessSnapshot[] {
+  const script =
+    "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CommandLine | ConvertTo-Csv -NoTypeInformation";
+  const result = spawnSync(
+    "powershell.exe",
+    ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script],
+    {
+      encoding: "utf8",
+      windowsHide: true,
+      maxBuffer: 50 * 1024 * 1024,
+    },
+  );
+  if (result.error || result.status !== 0 || typeof result.stdout !== "string") {
+    return [];
+  }
+  return parseWindowsWmicProcessCsv(result.stdout);
+}
+
+function listWindowsProcesses(): OpenCodeProcessSnapshot[] {
+  const fromWmic = listWindowsProcessesFromWmic();
+  if (fromWmic.length > 0) {
+    return fromWmic;
+  }
+  return listWindowsProcessesFromPowerShell();
+}
+
 const defaultOpenCodeProcessController: OpenCodeProcessController = {
   listProcesses(): OpenCodeProcessSnapshot[] {
-    if (process.platform === "win32") return [];
+    if (process.platform === "win32") {
+      return listWindowsProcesses();
+    }
     const psArgs = process.platform === "linux"
       ? ["-ww", "-axo", "pid=,ppid=,command="]
       : ["-wwE", "-axo", "pid=,ppid=,command="];
@@ -188,6 +306,33 @@ const defaultOpenCodeProcessController: OpenCodeProcessController = {
       // ignore
     }
   },
+  killProcessTree(pid: number): boolean {
+    if (!Number.isInteger(pid) || pid <= 0) return false;
+    if (process.platform === "win32") {
+      try {
+        const out = spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], { windowsHide: true });
+        if (!out.error && out.status === 0) {
+          return true;
+        }
+        console.error("opencode.kill_process_tree_taskkill_failed", {
+          pid,
+          status: out.status,
+          stdout: processOutputToString(out.stdout),
+          stderr: processOutputToString(out.stderr),
+          error: out.error,
+        });
+      } catch (error) {
+        console.error("opencode.kill_process_tree_taskkill_failed", { pid, error });
+      }
+      return false;
+    }
+    try {
+      process.kill(pid);
+      return true;
+    } catch {
+      return false;
+    }
+  },
   waitForMs(ms: number): Promise<void> {
     return new Promise((resolve) => {
       setTimeout(resolve, ms);
@@ -270,9 +415,8 @@ function isPortConflict(error: unknown): boolean {
 
 function stopChildProcess(proc: ChildProcess): void {
   if (proc.exitCode !== null || proc.signalCode !== null) return;
-  if (process.platform === "win32" && proc.pid) {
-    const out = spawnSync("taskkill", ["/pid", String(proc.pid), "/T", "/F"], { windowsHide: true });
-    if (!out.error && out.status === 0) return;
+  if (process.platform === "win32" && proc.pid && openCodeProcessController.killProcessTree(proc.pid)) {
+    return;
   }
   proc.kill();
 }
@@ -374,6 +518,15 @@ function buildManagedConfigMarkers(): string[] {
 }
 
 function isManagedOpenCodeServeCommand(command: string, configMarkers: string[]): boolean {
+  // Windows: managed markers are injected into the cmd.exe command line (WMIC/CIM omit child env).
+  if (
+    /\bcmd(?:\.exe)?\b/i.test(command)
+    && command.includes(`${ADE_OPENCODE_MANAGED_ENV}=1`)
+    && /\bopencode(?:\.cmd|\.exe)?\b/i.test(command)
+    && /\bserve\b/i.test(command)
+  ) {
+    return command.includes("OPENCODE_DISABLE_PROJECT_CONFIG=1");
+  }
   if (!/\bopencode(?:\.cmd|\.exe)?\b\s+serve\b/i.test(command)) return false;
   if (!command.includes("OPENCODE_DISABLE_PROJECT_CONFIG=1")) return false;
   if (command.includes(`${ADE_OPENCODE_MANAGED_ENV}=1`)) return true;
@@ -381,7 +534,7 @@ function isManagedOpenCodeServeCommand(command: string, configMarkers: string[])
 }
 
 function parseManagedOwnerPid(command: string): number | null {
-  const match = command.match(new RegExp(`\\b${ADE_OPENCODE_OWNER_PID_ENV}=(\\d+)\\b`));
+  const match = command.match(new RegExp(`${ADE_OPENCODE_OWNER_PID_ENV}=(\\d+)`, "i"));
   if (!match) return null;
   const pid = Number(match[1]);
   return Number.isInteger(pid) && pid > 0 ? pid : null;
@@ -449,19 +602,37 @@ export async function recoverManagedOpenCodeOrphans(args: {
         continue;
       }
 
-      openCodeProcessController.killProcess(proc.pid, "SIGTERM");
-      const exitedGracefully = await waitForProcessExit(proc.pid, ORPHAN_RECOVERY_TERM_GRACE_MS);
-      if (!exitedGracefully && openCodeProcessController.isProcessAlive(proc.pid)) {
-        openCodeProcessController.killProcess(proc.pid, "SIGKILL");
-        const exitedAfterKill = await waitForProcessExit(proc.pid, ORPHAN_RECOVERY_TERM_GRACE_MS);
-        if (!exitedAfterKill && openCodeProcessController.isProcessAlive(proc.pid)) {
-          skippedPids.push(proc.pid);
-          args.logger?.warn("opencode.server_orphan_recovery_failed", {
-            pid: proc.pid,
-            ownerPid,
-            ppid: proc.ppid,
-          });
-          continue;
+      if (process.platform === "win32") {
+        openCodeProcessController.killProcessTree(proc.pid);
+        const exitedGracefully = await waitForProcessExit(proc.pid, ORPHAN_RECOVERY_TERM_GRACE_MS);
+        if (!exitedGracefully && openCodeProcessController.isProcessAlive(proc.pid)) {
+          openCodeProcessController.killProcessTree(proc.pid);
+          const exitedAfterKill = await waitForProcessExit(proc.pid, ORPHAN_RECOVERY_TERM_GRACE_MS);
+          if (!exitedAfterKill && openCodeProcessController.isProcessAlive(proc.pid)) {
+            skippedPids.push(proc.pid);
+            args.logger?.warn("opencode.server_orphan_recovery_failed", {
+              pid: proc.pid,
+              ownerPid,
+              ppid: proc.ppid,
+            });
+            continue;
+          }
+        }
+      } else {
+        openCodeProcessController.killProcess(proc.pid, "SIGTERM");
+        const exitedGracefully = await waitForProcessExit(proc.pid, ORPHAN_RECOVERY_TERM_GRACE_MS);
+        if (!exitedGracefully && openCodeProcessController.isProcessAlive(proc.pid)) {
+          openCodeProcessController.killProcess(proc.pid, "SIGKILL");
+          const exitedAfterKill = await waitForProcessExit(proc.pid, ORPHAN_RECOVERY_TERM_GRACE_MS);
+          if (!exitedAfterKill && openCodeProcessController.isProcessAlive(proc.pid)) {
+            skippedPids.push(proc.pid);
+            args.logger?.warn("opencode.server_orphan_recovery_failed", {
+              pid: proc.pid,
+              ownerPid,
+              ppid: proc.ppid,
+            });
+            continue;
+          }
         }
       }
       recoveredPids.push(proc.pid);
@@ -490,6 +661,21 @@ function buildOpenCodeServeLaunchSpec(args: OpenCodeServerLaunchArgs): OpenCodeS
   }
   const xdgPaths = resolveOpenCodeIsolationPaths();
   ensureOpenCodeIsolationDirs(xdgPaths);
+  const env = buildIsolatedOpenCodeEnv(args.config, xdgPaths);
+  if (process.platform === "win32") {
+    const comSpec = process.env.ComSpec?.trim() || "cmd.exe";
+    const exeForCmd = `"${executable.replace(/"/g, "\"\"")}"`;
+    const cmdLine =
+      `set "${ADE_OPENCODE_MANAGED_ENV}=1"&&set "OPENCODE_DISABLE_PROJECT_CONFIG=1"&&set "${ADE_OPENCODE_OWNER_PID_ENV}=${process.pid}"&&${exeForCmd} serve --hostname=127.0.0.1 --port=${args.port}`;
+    return {
+      executable: comSpec,
+      args: ["/d", "/s", "/c", cmdLine],
+      env,
+      useShell: false,
+      xdgPaths,
+    };
+  }
+
   return {
     executable,
     args: [
@@ -497,8 +683,8 @@ function buildOpenCodeServeLaunchSpec(args: OpenCodeServerLaunchArgs): OpenCodeS
       "--hostname=127.0.0.1",
       `--port=${args.port}`,
     ],
-    env: buildIsolatedOpenCodeEnv(args.config, xdgPaths),
-    useShell: process.platform === "win32" && /\.(cmd|bat)$/i.test(executable),
+    env,
+    useShell: false,
     xdgPaths,
   };
 }
@@ -511,6 +697,7 @@ async function defaultOpenCodeServerLauncher(
     env: launchSpec.env,
     stdio: ["ignore", "pipe", "pipe"],
     windowsHide: true,
+    windowsVerbatimArguments: process.platform === "win32",
     shell: launchSpec.useShell,
   });
 
@@ -957,6 +1144,7 @@ export function __setOpenCodeProcessControllerForTests(
         listProcesses: controller.listProcesses ?? (() => []),
         isProcessAlive: controller.isProcessAlive ?? (() => false),
         killProcess: controller.killProcess ?? (() => {}),
+        killProcessTree: controller.killProcessTree ?? (() => false),
         waitForMs: controller.waitForMs ?? (async () => {}),
       }
     : defaultOpenCodeProcessController;
@@ -974,3 +1162,8 @@ export function __buildOpenCodeServeLaunchSpecForTests(args: {
     config: args.config,
   });
 }
+
+/** Test hook: whether a WMIC/CIM command line would be treated as an ADE-managed OpenCode serve. */
+export function __isManagedOpenCodeServeCommandForTests(command: string): boolean {
+  return isManagedOpenCodeServeCommand(command, buildManagedConfigMarkers());
+}
diff --git a/apps/desktop/src/main/services/orchestrator/baseOrchestratorAdapter.ts b/apps/desktop/src/main/services/orchestrator/baseOrchestratorAdapter.ts
index 105487cb3..12c714205 100644
--- a/apps/desktop/src/main/services/orchestrator/baseOrchestratorAdapter.ts
+++ b/apps/desktop/src/main/services/orchestrator/baseOrchestratorAdapter.ts
@@ -25,6 +25,34 @@ export function compactText(value: string, maxChars = 220): string {
   return `${normalized.slice(0, Math.max(0, maxChars - 3)).trimEnd()}...`;
 }
 
+export type AdapterLaunchCommand = {
+  /** Human-readable preview stored with the session and metadata. */
+  startupCommand: string;
+  /** Optional direct executable to launch instead of typing startupCommand into a shell. */
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+};
+
+function normalizeAdapterLaunch(value: string | AdapterLaunchCommand): AdapterLaunchCommand {
+  if (typeof value === "string") return { startupCommand: value };
+  return value;
+}
+
+function ptyLaunchFields(launch: AdapterLaunchCommand): {
+  startupCommand: string;
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+} {
+  return {
+    startupCommand: launch.startupCommand,
+    ...(launch.command ? { command: launch.command } : {}),
+    ...(launch.args ? { args: launch.args } : {}),
+    ...(launch.env ? { env: launch.env } : {}),
+  };
+}
+
 export function buildCompactPlanView(currentStep: OrchestratorStep, allSteps: OrchestratorStep[]): string {
   if (!allSteps.length) return "";
   const stepIdToKey = new Map(allSteps.map((s) => [s.id, s.stepKey]));
@@ -81,7 +109,7 @@ export interface BaseAdapterConfig {
   /** Session type for tracked sessions, e.g. "claude-orchestrated". */
   sessionType: TerminalToolType;
   /** Build the startup command for a startup-command-override case. */
-  buildOverrideCommand: (args: { prompt: string }) => string;
+  buildOverrideCommand: (args: { prompt: string }) => string | AdapterLaunchCommand;
   /** Build the full startup command from the assembled prompt + resolved config. */
   buildStartupCommand: (args: {
     prompt: string;
@@ -91,7 +119,7 @@ export interface BaseAdapterConfig {
     attempt: import("../../../shared/types").OrchestratorAttempt;
     permissionConfig: OrchestratorExecutorStartArgs["permissionConfig"];
     teamRuntime?: TeamRuntimeConfig;
-  }) => string;
+  }) => string | AdapterLaunchCommand;
   /** Build adapter-specific metadata to include in the accepted result. */
   buildAcceptedMetadata: (args: {
     model: string;
@@ -748,12 +776,13 @@ export function createBaseOrchestratorAdapter(config: BaseAdapterConfig): Orches
             : null;
 
         if (startupCommandOverride) {
+          const launch = normalizeAdapterLaunch(buildOverrideCommand({ prompt: startupCommandOverride }));
           // Use the startup command directly as the prompt
           const session = await args.createTrackedSession({
             laneId: step.laneId,
             toolType: sessionType,
             title: `[Orchestrator] ${step.title}`,
-            startupCommand: buildOverrideCommand({ prompt: startupCommandOverride }),
+            ...ptyLaunchFields(launch),
             cols: 120,
             rows: 40
           });
@@ -765,7 +794,7 @@ export function createBaseOrchestratorAdapter(config: BaseAdapterConfig): Orches
               adapterKind: executorKind,
               startupCommandOverride: true,
               promptLength: startupCommandOverride.length,
-              startupCommandPreview: startupCommandOverride.slice(0, 320)
+              startupCommandPreview: launch.startupCommand.slice(0, 320)
             }
           };
         }
@@ -791,7 +820,7 @@ export function createBaseOrchestratorAdapter(config: BaseAdapterConfig): Orches
         const teamRuntime = run.metadata && typeof run.metadata === "object" && !Array.isArray(run.metadata)
           ? (run.metadata as Record<string, unknown>).teamRuntime as TeamRuntimeConfig | undefined
           : undefined;
-        const startupCommand = buildStartupCommand({
+        const launch = normalizeAdapterLaunch(buildStartupCommand({
           prompt,
           model,
           step,
@@ -799,14 +828,14 @@ export function createBaseOrchestratorAdapter(config: BaseAdapterConfig): Orches
           attempt,
           permissionConfig: args.permissionConfig,
           teamRuntime
-        });
+        }));
 
         // 5. Create tracked session
         const session = await args.createTrackedSession({
           laneId: step.laneId,
           toolType: sessionType,
           title: `[Orchestrator] ${step.title}`,
-          startupCommand,
+          ...ptyLaunchFields(launch),
           cols: 120,
           rows: 40
         });
@@ -829,7 +858,7 @@ export function createBaseOrchestratorAdapter(config: BaseAdapterConfig): Orches
             steeringDirectiveCount,
             promptLength: prompt.length,
             reasoningEffort,
-            startupCommandPreview: startupCommand.slice(0, 320)
+            startupCommandPreview: launch.startupCommand.slice(0, 320)
           })
         };
       } catch (error) {
diff --git a/apps/desktop/src/main/services/orchestrator/orchestratorConstants.ts b/apps/desktop/src/main/services/orchestrator/orchestratorConstants.ts
index 5cd9e7258..3420f7968 100644
--- a/apps/desktop/src/main/services/orchestrator/orchestratorConstants.ts
+++ b/apps/desktop/src/main/services/orchestrator/orchestratorConstants.ts
@@ -113,30 +113,37 @@ export const DEFAULT_WORKER_SANDBOX_CONFIG: WorkerSandboxConfig = {
     "\\bshutdown\\b",
     "\\breboot\\b",
     ":\\(\\)\\{",
+    "\\breg(?:\\.exe)?\\s+(add|delete|import|load|unload|copy|save|restore)\\b",
+    "\\bdiskpart(?:\\.exe)?\\b",
+    "\\bformat(?:\\.exe)?\\s+[a-z]:",
+    "\\bbcdedit(?:\\.exe)?\\b",
+    "\\btakeown(?:\\.exe)?\\b",
+    ">\\s*[^\\n\\r]*[/\\\\]windows[/\\\\]system32\\b",
+    ">\\s*[^\\n\\r]*[/\\\\]windows[/\\\\]syswow64\\b",
   ],
   safeCommands: [
-    "^pnpm\\s",
-    "^npm\\s",
-    "^yarn\\s",
-    "^npx\\s",
-    "^git\\s+status\\b",
-    "^git\\s+diff\\b",
-    "^git\\s+log\\b",
-    "^git\\s+show\\b",
-    "^git\\s+branch\\s*$",
-    "^git\\s+ls-files\\b",
+    "^pnpm(\\.cmd)?\\s",
+    "^npm(\\.cmd)?\\s",
+    "^yarn(\\.cmd)?\\s",
+    "^npx(\\.cmd)?\\s",
+    "^git(\\.exe)?\\s+status\\b",
+    "^git(\\.exe)?\\s+diff\\b",
+    "^git(\\.exe)?\\s+log\\b",
+    "^git(\\.exe)?\\s+show\\b",
+    "^git(\\.exe)?\\s+branch\\s*$",
+    "^git(\\.exe)?\\s+ls-files\\b",
     "^ls\\s",
     "^ls$",
     "^pwd\\b",
     "^echo\\s",
     "^date\\b",
-    "^node\\s",
-    "^tsx\\s",
-    "^vitest\\s",
-    "^jest\\s",
-    "^eslint\\s",
-    "^prettier\\s",
-    "^tsc\\b",
+    "^node(\\.exe)?\\s",
+    "^tsx(\\.cmd)?\\s",
+    "^vitest(\\.cmd)?\\s",
+    "^jest(\\.cmd)?\\s",
+    "^eslint(\\.cmd)?\\s",
+    "^prettier(\\.cmd)?\\s",
+    "^tsc(\\.cmd)?\\b",
     "^lsof\\s",
     "^ps\\s",
   ],
diff --git a/apps/desktop/src/main/services/orchestrator/orchestratorContext.ts b/apps/desktop/src/main/services/orchestrator/orchestratorContext.ts
index 3c3786f2d..4271117c2 100644
--- a/apps/desktop/src/main/services/orchestrator/orchestratorContext.ts
+++ b/apps/desktop/src/main/services/orchestrator/orchestratorContext.ts
@@ -8,6 +8,7 @@
 
 import { createHash } from "node:crypto";
 import { spawn } from "node:child_process";
+import { terminateProcessTree } from "../shared/processExecution";
 import { nowIso } from "../shared/utils";
 import type { GetModelCapabilitiesResult } from "../../../shared/types";
 import type {
@@ -1059,18 +1060,10 @@ export const runOrchestratorHookCommand: OrchestratorHookCommandRunner = async (
     if (args.timeoutMs > 0) {
       killTimer = setTimeout(() => {
         timedOut = true;
-        try {
-          child.kill("SIGTERM");
-        } catch {
-          // Best-effort only.
-        }
+        terminateProcessTree(child, "SIGTERM");
         setTimeout(() => {
           if (child.exitCode == null && !child.killed) {
-            try {
-              child.kill("SIGKILL");
-            } catch {
-              // Best-effort only.
-            }
+            terminateProcessTree(child, "SIGKILL");
           }
         }, 1_000).unref();
       }, args.timeoutMs);
diff --git a/apps/desktop/src/main/services/orchestrator/orchestratorService.ts b/apps/desktop/src/main/services/orchestrator/orchestratorService.ts
index 09ec034dd..e5069417b 100644
--- a/apps/desktop/src/main/services/orchestrator/orchestratorService.ts
+++ b/apps/desktop/src/main/services/orchestrator/orchestratorService.ts
@@ -3954,7 +3954,8 @@ export function createOrchestratorService({
             };
           }
           const cliCommand = descriptor?.cliCommand === "codex" ? "codex" : "claude";
-          const commandParts: string[] = [cliCommand];
+          const commandArgs: string[] = [];
+          const commandPreviewParts: string[] = [cliCommand];
           const model = modelRef;
           if (model) {
             const effectiveModel = cliCommand === "claude"
@@ -3962,7 +3963,8 @@ export function createOrchestratorService({
               : cliCommand === "codex"
                 ? resolveCodexCliModel(model)
                 : model;
-            commandParts.push("--model", shellEscapeArg(effectiveModel));
+            commandArgs.push("--model", effectiveModel);
+            commandPreviewParts.push("--model", shellEscapeArg(effectiveModel));
           }
           const cliMode = args.permissionConfig?.cli?.mode ?? "full-auto";
           if (cliCommand === "codex") {
@@ -3971,24 +3973,36 @@ export function createOrchestratorService({
             if (!readOnlyExecution && codexProviderMode === "config-toml") {
               // Let Codex read its own repository/user config without forcing flags.
             } else {
-              commandParts.push(
+              const sandboxMode = readOnlyExecution || cliMode === "read-only"
+                ? "read-only"
+                : mappedCodex?.sandbox ?? args.permissionConfig?.cli?.sandboxPermissions ?? "workspace-write";
+              const approvalPolicy = readOnlyExecution || cliMode === "read-only" ? "on-request" : mappedCodex?.approvalPolicy ?? "untrusted";
+              commandArgs.push(
                 "--sandbox",
-                readOnlyExecution || cliMode === "read-only"
-                  ? "read-only"
-                  : mappedCodex?.sandbox ?? args.permissionConfig?.cli?.sandboxPermissions ?? "workspace-write",
+                sandboxMode,
                 "--ask-for-approval",
-                readOnlyExecution || cliMode === "read-only" ? "on-request" : mappedCodex?.approvalPolicy ?? "untrusted",
+                approvalPolicy,
+              );
+              commandPreviewParts.push(
+                "--sandbox",
+                shellEscapeArg(sandboxMode),
+                "--ask-for-approval",
+                shellEscapeArg(approvalPolicy),
               );
             }
           } else {
             if (!readOnlyExecution && cliMode === "full-auto") {
-              commandParts.push("--dangerously-skip-permissions");
+              commandArgs.push("--dangerously-skip-permissions");
+              commandPreviewParts.push("--dangerously-skip-permissions");
             } else {
-              commandParts.push("--permission-mode", readOnlyExecution || cliMode === "read-only" ? "plan" : "acceptEdits");
+              const claudePermissionMode = readOnlyExecution || cliMode === "read-only" ? "plan" : "acceptEdits";
+              commandArgs.push("--permission-mode", claudePermissionMode);
+              commandPreviewParts.push("--permission-mode", shellEscapeArg(claudePermissionMode));
             }
           }
-          commandParts.push(shellInlineDecodedArg(prompt));
-          const startupCommand = commandParts.join(" ");
+          commandArgs.push(prompt);
+          commandPreviewParts.push(shellInlineDecodedArg(prompt));
+          const startupCommand = commandPreviewParts.join(" ");
 
           const session = await args.createTrackedSession({
             laneId: args.step.laneId,
@@ -3996,6 +4010,8 @@ export function createOrchestratorService({
             rows: 36,
             title,
             toolType: `${kind}-orchestrated` as TerminalToolType,
+            command: cliCommand,
+            args: commandArgs,
             startupCommand
           });
           return {
diff --git a/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.test.ts b/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.test.ts
index 295a1d379..5c2a4646c 100644
--- a/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.test.ts
+++ b/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.test.ts
@@ -76,4 +76,71 @@ describe("providerOrchestratorAdapter", () => {
       codexConfigSource: "config-toml",
     }));
   });
+
+  it("launches CLI-wrapped fallback workers without shell-only command syntax", async () => {
+    projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-provider-adapter-"));
+    const createTrackedSession = vi.fn(async () => ({ ptyId: "pty-1", sessionId: "session-1" }));
+    const adapter = createProviderOrchestratorAdapter({
+      projectRoot,
+      workspaceRoot: projectRoot,
+      agentChatService: null,
+    });
+
+    const result = await adapter.start({
+      run: {
+        id: "run-1",
+        missionId: "mission-1",
+        metadata: {},
+      },
+      step: {
+        id: "step-1",
+        runId: "run-1",
+        stepKey: "codex-worker",
+        title: "Codex worker",
+        stepIndex: 0,
+        dependencyStepIds: [],
+        dependencyStepKeys: [],
+        laneId: "lane-1",
+        status: "ready",
+        metadata: {
+          modelId: "openai/gpt-5.3-codex",
+        },
+      },
+      attempt: {
+        id: "attempt-1",
+        runId: "run-1",
+        stepId: "step-1",
+      },
+      allSteps: [],
+      contextProfile: {} as any,
+      laneExport: null,
+      projectExport: { content: "Project context", truncated: false },
+      docsRefs: [],
+      fullDocs: [],
+      createTrackedSession,
+      permissionConfig: {
+        _providers: {
+          codex: "default",
+          codexSandbox: "workspace-write",
+        },
+      },
+    } as any);
+
+    expect(result.status).toBe("accepted");
+    expect(createTrackedSession).toHaveBeenCalledWith(expect.objectContaining({
+      command: process.execPath,
+      args: expect.arrayContaining(["-e"]),
+      env: expect.objectContaining({
+        ELECTRON_RUN_AS_NODE: "1",
+        ADE_MISSION_ID: "mission-1",
+        ADE_RUN_ID: "run-1",
+        ADE_STEP_ID: "step-1",
+        ADE_ATTEMPT_ID: "attempt-1",
+        ADE_DEFAULT_ROLE: "agent",
+      }),
+      startupCommand: expect.stringContaining("exec codex"),
+    }));
+    const firstCreateArgs = (createTrackedSession.mock.calls as any[])[0]?.[0];
+    expect(firstCreateArgs?.startupCommand).toContain("< ");
+  });
 });
diff --git a/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts b/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts
index b50dbf16d..53a6000e7 100644
--- a/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts
+++ b/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts
@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import type { OrchestratorExecutorAdapter } from "./orchestratorService";
-import { buildFullPrompt, createBaseOrchestratorAdapter, shellEscapeArg, shellInlineDecodedArg } from "./baseOrchestratorAdapter";
+import { buildFullPrompt, createBaseOrchestratorAdapter, shellEscapeArg, shellInlineDecodedArg, type AdapterLaunchCommand } from "./baseOrchestratorAdapter";
 import {
   classifyWorkerExecutionPath,
   getModelById,
@@ -27,9 +27,21 @@ import {
   providerPermissionsToLegacyConfig,
 } from "./permissionMapping";
 
+const WORKER_ENV_KEYS = [
+  "ADE_MISSION_ID",
+  "ADE_RUN_ID",
+  "ADE_STEP_ID",
+  "ADE_ATTEMPT_ID",
+  "ADE_DEFAULT_ROLE",
+  "ADE_OWNER_ID",
+] as const;
+
+type WorkerEnvKey = typeof WORKER_ENV_KEYS[number];
+type WorkerEnvVars = Partial<Record<WorkerEnvKey, string>> & Record<string, string>;
+
 /**
- * Build environment variable assignments for worker identity.
- * These env vars allow ADE-aware CLIs and child processes to resolve caller context.
+ * Build worker identity env vars. ADE-aware CLIs and child processes use these
+ * to resolve caller context without POSIX-only inline assignment syntax.
  */
 function buildWorkerEnvVars(args: {
   missionId: string;
@@ -37,15 +49,25 @@ function buildWorkerEnvVars(args: {
   stepId: string;
   attemptId: string;
   ownerId?: string | null;
-}): string[] {
-  return [
-    `ADE_MISSION_ID=${shellEscapeArg(args.missionId)}`,
-    `ADE_RUN_ID=${shellEscapeArg(args.runId)}`,
-    `ADE_STEP_ID=${shellEscapeArg(args.stepId)}`,
-    `ADE_ATTEMPT_ID=${shellEscapeArg(args.attemptId)}`,
-    `ADE_DEFAULT_ROLE=agent`,
-    ...(args.ownerId ? [`ADE_OWNER_ID=${shellEscapeArg(args.ownerId)}`] : []),
-  ];
+}): WorkerEnvVars {
+  return {
+    ADE_MISSION_ID: args.missionId,
+    ADE_RUN_ID: args.runId,
+    ADE_STEP_ID: args.stepId,
+    ADE_ATTEMPT_ID: args.attemptId,
+    ADE_DEFAULT_ROLE: "agent",
+    ...(args.ownerId ? { ADE_OWNER_ID: args.ownerId } : {}),
+  };
+}
+
+function previewWorkerEnvVars(env: WorkerEnvVars): string[] {
+  const parts: string[] = [];
+  for (const key of WORKER_ENV_KEYS) {
+    const value = env[key];
+    if (!value) continue;
+    parts.push(key === "ADE_DEFAULT_ROLE" ? `${key}=agent` : `${key}=${shellEscapeArg(value)}`);
+  }
+  return parts;
 }
 
 function resolveWorkerOwnerId(metadata: Record<string, unknown> | null | undefined): string | null {
@@ -69,6 +91,53 @@ function workerPromptFilePath(projectRoot: string, attemptId: string): string {
   return path.join(resolveAdeLayout(projectRoot).workerPromptsDir, `worker-${attemptId}.txt`);
 }
 
+function workerLaunchFilePath(projectRoot: string, attemptId: string): string {
+  return path.join(resolveAdeLayout(projectRoot).workerPromptsDir, `worker-${attemptId}.launch.json`);
+}
+
+const WORKER_CLI_LAUNCHER_SCRIPT = `
+const fs = require("fs");
+const { spawn } = require("child_process");
+const specPath = process.argv[1];
+let done = false;
+function finish(code) {
+  if (done) return;
+  done = true;
+  process.exit(typeof code === "number" ? code : 1);
+}
+const spec = JSON.parse(fs.readFileSync(specPath, "utf8"));
+const childEnv = { ...process.env, ...(spec.env || {}) };
+delete childEnv.ELECTRON_RUN_AS_NODE;
+const child = spawn(spec.command, Array.isArray(spec.args) ? spec.args : [], {
+  cwd: spec.cwd || process.cwd(),
+  env: childEnv,
+  shell: false,
+  stdio: [spec.stdinFilePath ? "pipe" : "inherit", "inherit", "inherit"],
+  windowsHide: false
+});
+child.on("error", (err) => {
+  console.error("[ADE] Failed to launch worker CLI: " + (err && err.message ? err.message : String(err)));
+  finish(127);
+});
+child.on("exit", (code, signal) => {
+  if (signal) {
+    console.error("[ADE] Worker CLI exited from signal " + signal + ".");
+    finish(1);
+    return;
+  }
+  finish(code == null ? 0 : code);
+});
+if (spec.stdinFilePath && child.stdin) {
+  const stream = fs.createReadStream(spec.stdinFilePath);
+  stream.on("error", (err) => {
+    console.error("[ADE] Failed to read worker prompt: " + (err && err.message ? err.message : String(err)));
+    try { child.kill(); } catch {}
+    finish(1);
+  });
+  stream.pipe(child.stdin);
+}
+`;
+
 const CLAUDE_READ_ONLY_NATIVE_TOOLS = [
   "Read",
   "Glob",
@@ -105,6 +174,45 @@ function writeWorkerPromptFile(args: {
   return promptPath;
 }
 
+function writeWorkerLaunchFile(args: {
+  projectRoot: string;
+  attemptId: string;
+  command: string;
+  commandArgs: string[];
+  promptFilePath: string;
+  env?: Record<string, string>;
+}): string {
+  const launchPath = workerLaunchFilePath(args.projectRoot, args.attemptId);
+  fs.mkdirSync(path.dirname(launchPath), { recursive: true });
+  fs.writeFileSync(
+    launchPath,
+    JSON.stringify({
+      command: args.command,
+      args: args.commandArgs,
+      stdinFilePath: args.promptFilePath,
+      env: args.env ?? {},
+    }),
+    "utf8",
+  );
+  return launchPath;
+}
+
+function nodeWorkerLaunch(args: {
+  startupCommand: string;
+  launchFilePath: string;
+  env?: Record<string, string>;
+}): AdapterLaunchCommand {
+  return {
+    startupCommand: args.startupCommand,
+    command: process.execPath,
+    args: ["-e", WORKER_CLI_LAUNCHER_SCRIPT, args.launchFilePath],
+    env: {
+      ELECTRON_RUN_AS_NODE: "1",
+      ...(args.env ?? {}),
+    },
+  };
+}
+
 export function resolveOpenCodeRuntimeRoot(): string {
   const startPoints = [
     process.cwd(),
@@ -135,6 +243,11 @@ export function cleanupWorkerRuntimeFiles(projectRoot: string, attemptId: string
   } catch {
     // Ignore — prompt file may already be removed or never created.
   }
+  try {
+    fs.unlinkSync(workerLaunchFilePath(projectRoot, attemptId));
+  } catch {
+    // Ignore — launch file may already be removed or never created.
+  }
 }
 
 /**
@@ -159,6 +272,10 @@ function cleanupStaleWorkerRuntimeFiles(projectRoot: string): void {
     layout.workerPromptsDir,
     "worker-", ".txt",
   );
+  cleanupStaleFilesInDir(
+    layout.workerPromptsDir,
+    "worker-", ".launch.json",
+  );
 }
 
 const VALID_PERMISSION_MODES = new Set<string>(["default", "plan", "edit", "full-auto", "config-toml"]);
@@ -300,7 +417,11 @@ export function createProviderOrchestratorAdapter(options?: {
     buildOverrideCommand: ({ prompt }) => {
       // For override commands, try to detect the best CLI
       // Default to claude since it's the most common
-      return `exec claude -p ${shellInlineDecodedArg(prompt)}`;
+      return {
+        startupCommand: `exec claude -p ${shellInlineDecodedArg(prompt)}`,
+        command: "claude",
+        args: ["-p", prompt],
+      };
     },
 
     buildStartupCommand: ({ prompt, model, step, run, attempt, permissionConfig, teamRuntime }) => {
@@ -332,16 +453,20 @@ export function createProviderOrchestratorAdapter(options?: {
           ? buildClaudeReadOnlyWorkerAllowedTools()
           : dedupeAllowedTools(configuredAllowedTools);
 
-        const parts: string[] = ["claude", "--model", shellEscapeArg(cliModel)];
+        const commandArgs: string[] = ["--model", cliModel];
+        const previewParts: string[] = ["claude", "--model", shellEscapeArg(cliModel)];
 
         if (dangerouslySkip) {
-          parts.push("--dangerously-skip-permissions");
+          commandArgs.push("--dangerously-skip-permissions");
+          previewParts.push("--dangerously-skip-permissions");
         } else {
-          parts.push("--permission-mode", shellEscapeArg(permissionMode));
+          commandArgs.push("--permission-mode", permissionMode);
+          previewParts.push("--permission-mode", shellEscapeArg(permissionMode));
         }
 
         if (allowedTools.length > 0) {
-          parts.push("--allowedTools", shellEscapeArg(allowedTools.join(",")));
+          commandArgs.push("--allowedTools", allowedTools.join(","));
+          previewParts.push("--allowedTools", shellEscapeArg(allowedTools.join(",")));
         }
 
         const promptFilePath = writeWorkerPromptFile({
@@ -349,20 +474,36 @@ export function createProviderOrchestratorAdapter(options?: {
           attemptId: attempt.id,
           prompt,
         });
-        parts.push("-p", `"$(cat ${shellEscapeArg(promptFilePath)})"`);
+        commandArgs.push("-p");
+        previewParts.push("-p", `"$(cat ${shellEscapeArg(promptFilePath)})"`);
 
-        const envParts: string[] = [...workerEnv];
+        const launchEnv: Record<string, string> = { ...workerEnv };
+        const envParts = previewWorkerEnvVars(workerEnv);
         if (
           teamRuntime?.enabled
           && teamRuntime.allowClaudeAgentTeams !== false
           && (teamRuntime.targetProvider === "claude" || teamRuntime.targetProvider === "auto")
         ) {
+          launchEnv.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS = "1";
           envParts.push("CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1");
         }
 
-        const cmd = parts.join(" ");
+        const cmd = previewParts.join(" ");
         const startup = `exec ${cmd}`;
-        return envParts.length > 0 ? `${envParts.join(" ")} ${startup}` : startup;
+        const startupCommand = envParts.length > 0 ? `${envParts.join(" ")} ${startup}` : startup;
+        const launchFilePath = writeWorkerLaunchFile({
+          projectRoot: canonicalProjectRoot,
+          attemptId: attempt.id,
+          command: "claude",
+          commandArgs,
+          promptFilePath,
+          env: launchEnv,
+        });
+        return nodeWorkerLaunch({
+          startupCommand,
+          launchFilePath,
+          env: launchEnv,
+        });
       }
 
       if (descriptor?.isCliWrapped && descriptor.family === "openai") {
@@ -378,37 +519,61 @@ export function createProviderOrchestratorAdapter(options?: {
             : mappedCodex?.sandbox ?? effectivePermissionConfig?._providers?.codexSandbox ?? effectivePermissionConfig?.cli?.sandboxPermissions ?? "workspace-write";
         const writablePaths = effectivePermissionConfig?._providers?.writablePaths ?? effectivePermissionConfig?.cli?.writablePaths ?? [];
 
-        const parts: string[] = [
+        const commandArgs: string[] = ["--model", resolveCodexCliModel(descriptor.providerModelId)];
+        const previewParts: string[] = [
           "codex", "--model", shellEscapeArg(resolveCodexCliModel(descriptor.providerModelId)),
         ];
         if (!useCodexConfig) {
-          parts.push("-a", shellEscapeArg(approvalPolicy), "-s", shellEscapeArg(sandboxMode));
+          commandArgs.push("-a", approvalPolicy, "-s", sandboxMode);
+          previewParts.push("-a", shellEscapeArg(approvalPolicy), "-s", shellEscapeArg(sandboxMode));
         }
 
-        parts.push("exec");
+        commandArgs.push("exec");
+        previewParts.push("exec");
 
         for (const wp of writablePaths) {
-          if (wp.trim().length) parts.push("--add-dir", shellEscapeArg(wp.trim()));
+          if (!wp.trim().length) continue;
+          commandArgs.push("--add-dir", wp.trim());
+          previewParts.push("--add-dir", shellEscapeArg(wp.trim()));
         }
 
-        parts.push("-");
+        commandArgs.push("-");
+        previewParts.push("-");
 
-        const envParts = [...workerEnv];
-        const cmd = parts.join(" ");
+        const launchEnv: Record<string, string> = { ...workerEnv };
+        const envParts = previewWorkerEnvVars(workerEnv);
+        const cmd = previewParts.join(" ");
         const promptFilePath = writeWorkerPromptFile({
           projectRoot: canonicalProjectRoot,
           attemptId: attempt.id,
           prompt,
         });
-        const startup = `${envParts.length > 0 ? `${envParts.join(" ")} ` : ""}exec ${cmd} < ${shellEscapeArg(promptFilePath)}`;
-        return startup;
+        const startupCommand = `${envParts.length > 0 ? `${envParts.join(" ")} ` : ""}exec ${cmd} < ${shellEscapeArg(promptFilePath)}`;
+        const launchFilePath = writeWorkerLaunchFile({
+          projectRoot: canonicalProjectRoot,
+          attemptId: attempt.id,
+          command: "codex",
+          commandArgs,
+          promptFilePath,
+          env: launchEnv,
+        });
+        return nodeWorkerLaunch({
+          startupCommand,
+          launchFilePath,
+          env: launchEnv,
+        });
       }
 
       // Non-CLI or unknown models can still run via the managed chat path.
       // This shell fallback only exists for CLI-wrapped workers.
       const unsupportedReason = getProviderAdapterUnsupportedModelReason(model) ?? `Model '${model}' is not supported by the provider adapter.`;
       const failureMessage = `[ADE] Shell-startup fallback for the provider adapter only supports CLI-wrapped Anthropic/OpenAI models. ${unsupportedReason}`;
-      return `printf '%s\\n' ${shellEscapeArg(failureMessage)} >&2; exit 64`;
+      return {
+        startupCommand: `printf '%s\\n' ${shellEscapeArg(failureMessage)} >&2; exit 64`,
+        command: process.execPath,
+        args: ["-e", "console.error(process.argv[1]); process.exit(64);", failureMessage],
+        env: { ELECTRON_RUN_AS_NODE: "1" },
+      };
     },
 
     buildAcceptedMetadata: ({ model, filePatterns, steeringDirectiveCount, promptLength, reasoningEffort, startupCommandPreview }) => {
diff --git a/apps/desktop/src/main/services/pty/ptyService.test.ts b/apps/desktop/src/main/services/pty/ptyService.test.ts
index 895968ab3..40eee8b74 100644
--- a/apps/desktop/src/main/services/pty/ptyService.test.ts
+++ b/apps/desktop/src/main/services/pty/ptyService.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
 import { EventEmitter } from "node:events";
 import os from "node:os";
 import path from "node:path";
@@ -171,6 +171,15 @@ vi.mock("../../utils/terminalSessionSignals", async () => {
 
 import { createPtyService, PTY_AI_TITLE_DEBOUNCE_MS } from "./ptyService";
 
+const originalPlatform = process.platform;
+
+function setPlatform(value: NodeJS.Platform): void {
+  Object.defineProperty(process, "platform", {
+    value,
+    configurable: true,
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -320,6 +329,10 @@ function createHarness(overrides: {
 // ---------------------------------------------------------------------------
 
 describe("ptyService", () => {
+  afterEach(() => {
+    setPlatform(originalPlatform);
+  });
+
   beforeEach(() => {
     vi.clearAllMocks();
     mocks.existsSyncResults.clear();
@@ -418,6 +431,56 @@ describe("ptyService", () => {
       );
     });
 
+    it("does not type startupCommand preview into direct command sessions", async () => {
+      const { service, mockPty } = createHarness();
+
+      await service.create({
+        laneId: "lane-1",
+        title: "Direct worker",
+        cols: 80,
+        rows: 24,
+        command: "codex",
+        args: ["exec", "-"],
+        startupCommand: "ADE_RUN_ID=run-1 exec codex exec - < prompt.txt",
+      });
+
+      expect(mockPty.write).not.toHaveBeenCalled();
+    });
+
+    it("wraps direct Windows command shims through cmd.exe", async () => {
+      setPlatform("win32");
+      const harness = createHarness();
+      const ptyService = createPtyService({
+        projectRoot: "/tmp/test-project",
+        transcriptsDir: "/tmp/transcripts",
+        laneService: harness.laneService as any,
+        sessionService: harness.sessionService as any,
+        logger: harness.logger as any,
+        broadcastData: vi.fn(),
+        broadcastExit: vi.fn(),
+        onSessionEnded: vi.fn(),
+        onSessionRuntimeSignal: vi.fn(),
+        loadPty: harness.loadPty as any,
+      });
+
+      await ptyService.create({
+        laneId: "lane-1",
+        title: "Direct command",
+        cols: 80,
+        rows: 24,
+        command: "npm.cmd",
+        args: ["run", "dev"],
+        env: { ComSpec: "C:\\Windows\\System32\\cmd.exe" },
+      });
+
+      const ptyLib = harness.loadPty.mock.results.at(-1)?.value as { spawn: ReturnType<typeof vi.fn> };
+      expect(ptyLib.spawn).toHaveBeenCalledWith(
+        "C:\\Windows\\System32\\cmd.exe",
+        ["/d", "/s", "/c", '"npm.cmd" "run" "dev"'],
+        expect.any(Object),
+      );
+    });
+
     it("registers the session via sessionService.create", async () => {
       const { service, sessionService } = createHarness();
       await service.create({
diff --git a/apps/desktop/src/main/services/pty/ptyService.ts b/apps/desktop/src/main/services/pty/ptyService.ts
index 88ff0310e..f277724e9 100644
--- a/apps/desktop/src/main/services/pty/ptyService.ts
+++ b/apps/desktop/src/main/services/pty/ptyService.ts
@@ -11,6 +11,7 @@ import type { createSessionService } from "../sessions/sessionService";
 import type { createAiIntegrationService } from "../ai/aiIntegrationService";
 import type { createProjectConfigService } from "../config/projectConfigService";
 import { runGit } from "../git/git";
+import { resolveCliSpawnInvocation } from "../shared/processExecution";
 import type {
   PtyDataEvent,
   PtyExitEvent,
@@ -1119,7 +1120,8 @@ export function createPtyService({
         let created: IPty | null = null;
         if (directCommand) {
           try {
-            created = ptyLib.spawn(directCommand, directArgs, opts);
+            const invocation = resolveCliSpawnInvocation(directCommand, directArgs, launchEnv);
+            created = ptyLib.spawn(invocation.command, invocation.args, opts);
           } catch (err) {
             lastErr = err;
           }
@@ -1318,7 +1320,7 @@ export function createPtyService({
         closeEntry(ptyId, exitCode ?? null);
       });
 
-      if (startupCommand) {
+      if (startupCommand && !directCommand) {
         try {
           pty.write(`${startupCommand}\r`);
           setRuntimeState(sessionId, "running");
diff --git a/apps/desktop/src/main/services/shared/processExecution.test.ts b/apps/desktop/src/main/services/shared/processExecution.test.ts
new file mode 100644
index 000000000..76727e57f
--- /dev/null
+++ b/apps/desktop/src/main/services/shared/processExecution.test.ts
@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import {
+  quoteWindowsCmdArg,
+  resolveCliSpawnInvocation,
+  resolveWindowsCmdInvocation,
+  shouldUseWindowsCmdWrapper,
+} from "./processExecution";
+
+describe("processExecution", () => {
+  it("detects Windows command shims and extensionless commands", () => {
+    expect(shouldUseWindowsCmdWrapper("codex", "win32")).toBe(true);
+    expect(shouldUseWindowsCmdWrapper("C:\\tools\\codex.cmd", "win32")).toBe(true);
+    expect(shouldUseWindowsCmdWrapper("C:\\tools\\codex.bat", "win32")).toBe(true);
+    expect(shouldUseWindowsCmdWrapper("C:\\tools\\codex.exe", "win32")).toBe(false);
+    expect(shouldUseWindowsCmdWrapper("codex", "linux")).toBe(false);
+  });
+
+  it("quotes cmd arguments consistently", () => {
+    expect(quoteWindowsCmdArg("C:\\Program Files\\tool.cmd")).toBe('"C:\\Program Files\\tool.cmd"');
+    expect(quoteWindowsCmdArg("100% done")).toBe('"100%% done"');
+    expect(quoteWindowsCmdArg('say "hi"')).toBe('"say ""hi"""');
+  });
+
+  it("wraps Windows shim invocations with ComSpec", () => {
+    const invocation = resolveCliSpawnInvocation(
+      "C:\\Users\\me\\AppData\\Roaming\\npm\\codex.cmd",
+      ["exec", "--cd", "C:\\repo path"],
+      { ComSpec: "C:\\Windows\\System32\\cmd.exe" } as NodeJS.ProcessEnv,
+      "win32",
+    );
+
+    expect(invocation).toEqual({
+      command: "C:\\Windows\\System32\\cmd.exe",
+      args: [
+        "/d",
+        "/s",
+        "/c",
+        '"C:\\Users\\me\\AppData\\Roaming\\npm\\codex.cmd" "exec" "--cd" "C:\\repo path"',
+      ],
+      windowsVerbatimArguments: true,
+    });
+  });
+
+  it("builds explicit Windows shell invocations", () => {
+    expect(resolveWindowsCmdInvocation("npm", ["run", "test"], {} as NodeJS.ProcessEnv)).toEqual({
+      command: "cmd.exe",
+      args: ["/d", "/s", "/c", '"npm" "run" "test"'],
+      windowsVerbatimArguments: true,
+    });
+  });
+});
diff --git a/apps/desktop/src/main/services/shared/processExecution.ts b/apps/desktop/src/main/services/shared/processExecution.ts
new file mode 100644
index 000000000..be0aaef0a
--- /dev/null
+++ b/apps/desktop/src/main/services/shared/processExecution.ts
@@ -0,0 +1,105 @@
+import { spawnSync, type ChildProcess } from "node:child_process";
+import path from "node:path";
+
+export type SpawnInvocation = {
+  command: string;
+  args: string[];
+  windowsVerbatimArguments?: boolean;
+};
+
+export type ProcessTreeFailureDetail = {
+  pid: number;
+  status: number | null;
+  stdout: string;
+  stderr: string;
+  error: unknown;
+};
+
+export function processOutputToString(value: Buffer | string | null | undefined): string {
+  return Buffer.isBuffer(value) ? value.toString("utf8") : String(value ?? "");
+}
+
+export function quoteWindowsCmdArg(value: string): string {
+  return `"${value.replace(/"/g, "\"\"").replace(/%/g, "%%")}"`;
+}
+
+export function shouldUseWindowsCmdWrapper(command: string, platform: NodeJS.Platform = process.platform): boolean {
+  if (platform !== "win32") return false;
+  const ext = path.win32.extname(command).toLowerCase();
+  return ext === "" || ext === ".cmd" || ext === ".bat";
+}
+
+export function resolveWindowsCmdInvocation(
+  command: string,
+  args: string[],
+  env: NodeJS.ProcessEnv = process.env,
+): SpawnInvocation {
+  const comSpec = env.ComSpec?.trim() || "cmd.exe";
+  const cmdLine = [command, ...args].map(quoteWindowsCmdArg).join(" ");
+  return {
+    command: comSpec,
+    args: ["/d", "/s", "/c", cmdLine],
+    windowsVerbatimArguments: true,
+  };
+}
+
+export function resolveCliSpawnInvocation(
+  command: string,
+  args: string[],
+  env: NodeJS.ProcessEnv = process.env,
+  platform: NodeJS.Platform = process.platform,
+): SpawnInvocation {
+  if (shouldUseWindowsCmdWrapper(command, platform)) {
+    return resolveWindowsCmdInvocation(command, args, env);
+  }
+  return {
+    command,
+    args,
+    windowsVerbatimArguments: false,
+  };
+}
+
+export function killWindowsProcessTree(
+  pid: number,
+  onFailure?: (detail: ProcessTreeFailureDetail) => void,
+): boolean {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    const out = spawnSync("taskkill.exe", ["/T", "/F", "/PID", String(pid)], { windowsHide: true });
+    if (!out.error && out.status === 0) return true;
+    onFailure?.({
+      pid,
+      status: out.status,
+      stdout: processOutputToString(out.stdout),
+      stderr: processOutputToString(out.stderr),
+      error: out.error ?? null,
+    });
+  } catch (error) {
+    onFailure?.({
+      pid,
+      status: null,
+      stdout: "",
+      stderr: "",
+      error,
+    });
+  }
+  return false;
+}
+
+export function terminateProcessTree(
+  child: Pick<ChildProcess, "kill" | "pid" | "exitCode" | "signalCode">,
+  signal: NodeJS.Signals = "SIGTERM",
+  onWindowsTaskkillFailure?: (detail: ProcessTreeFailureDetail) => void,
+): boolean {
+  if (process.platform === "win32") {
+    if (child.exitCode !== null || child.signalCode !== null) return false;
+    if (typeof child.pid === "number" && killWindowsProcessTree(child.pid, onWindowsTaskkillFailure)) {
+      return true;
+    }
+  }
+  try {
+    return child.kill(signal);
+  } catch {
+    return false;
+  }
+}
diff --git a/apps/desktop/src/main/services/shared/utils.ts b/apps/desktop/src/main/services/shared/utils.ts
index 84408a44b..5636a0091 100644
--- a/apps/desktop/src/main/services/shared/utils.ts
+++ b/apps/desktop/src/main/services/shared/utils.ts
@@ -9,6 +9,7 @@ import { spawn } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { resolveCliSpawnInvocation, terminateProcessTree } from "./processExecution";
 
 // ── Type guards ─────────────────────────────────────────────────────
 
@@ -83,10 +84,14 @@ export function spawnAsync(
 ): Promise<{ status: number | null; stdout: string; stderr: string }> {
   return new Promise((resolve) => {
     try {
-      const child = spawn(command, args, {
+      const invocation = resolveCliSpawnInvocation(command, args);
+      const child = spawn(invocation.command, invocation.args, {
         stdio: ["ignore", "pipe", "pipe"],
-        timeout: opts?.timeout ?? 5_000,
+        windowsVerbatimArguments: invocation.windowsVerbatimArguments,
       });
+      const timeout = setTimeout(() => {
+        terminateProcessTree(child);
+      }, opts?.timeout ?? 5_000);
       let stdout = "";
       let stderr = "";
       const limit = opts?.maxOutputBytes ?? 10_000;
@@ -96,8 +101,14 @@ export function spawnAsync(
       child.stderr?.on("data", (chunk: Buffer) => {
         stderr += chunk.toString("utf8").slice(0, Math.max(0, limit - stderr.length));
       });
-      child.on("error", () => resolve({ status: null, stdout, stderr }));
-      child.on("close", (code) => resolve({ status: code, stdout, stderr }));
+      child.on("error", () => {
+        clearTimeout(timeout);
+        resolve({ status: null, stdout, stderr });
+      });
+      child.on("close", (code) => {
+        clearTimeout(timeout);
+        resolve({ status: code, stdout, stderr });
+      });
     } catch {
       resolve({ status: null, stdout: "", stderr: "" });
     }
diff --git a/apps/desktop/src/main/services/state/kvDb.ts b/apps/desktop/src/main/services/state/kvDb.ts
index 05a6daf2a..e806bb60f 100644
--- a/apps/desktop/src/main/services/state/kvDb.ts
+++ b/apps/desktop/src/main/services/state/kvDb.ts
@@ -18,6 +18,7 @@ const { DatabaseSync } = require("node:sqlite") as { DatabaseSync: DatabaseSyncC
 export type SqlValue = string | number | null | Uint8Array;
 
 export type AdeDbSyncApi = {
+  isAvailable?: () => boolean;
   getSiteId: () => string;
   getDbVersion: () => number;
   exportChangesSince: (version: number) => CrsqlChangeRow[];
@@ -3314,6 +3315,7 @@ export async function openKvDb(dbPath: string, logger: Logger): Promise<AdeDb> {
   };
 
   const sync: AdeDbSyncApi = {
+    isAvailable: () => hasCrsqlite,
     getSiteId: () => desiredSiteId,
     getDbVersion: () => {
       if (!hasCrsqlite) return 0;
diff --git a/apps/desktop/src/main/services/sync/syncService.ts b/apps/desktop/src/main/services/sync/syncService.ts
index b1f0fa1b5..76d42ba94 100644
--- a/apps/desktop/src/main/services/sync/syncService.ts
+++ b/apps/desktop/src/main/services/sync/syncService.ts
@@ -300,6 +300,7 @@ export function createSyncService(args: SyncServiceArgs) {
   let disposed = false;
   const hostStartupEnabled = args.hostStartupEnabled !== false;
   let hostDiscoveryEnabled = args.hostDiscoveryEnabled !== false;
+  const isCrdtSyncAvailable = (): boolean => args.db.sync.isAvailable?.() !== false;
   let activeLocalLanePresenceIds: string[] = [];
   const localLanePresenceHeartbeatTimer = setInterval(() => {
     if (disposed || !hostService || activeLocalLanePresenceIds.length === 0) return;
@@ -386,7 +387,7 @@ export function createSyncService(args: SyncServiceArgs) {
   };
 
   const startHostIfNeeded = async (): Promise<void> => {
-    if (!hostStartupEnabled) {
+    if (!hostStartupEnabled || !isCrdtSyncAvailable()) {
       if (hostService) {
         await stopHostIfRunning();
       }
@@ -682,7 +683,8 @@ export function createSyncService(args: SyncServiceArgs) {
         ? cluster.brainDeviceId === localDevice.deviceId
         : !savedDraft && !syncPeerService.isConnected();
       const role = isLocalBrain ? "brain" : "viewer";
-      const canHostPhonePairing = role === "brain" && hostStartupEnabled;
+      const crdtSyncAvailable = isCrdtSyncAvailable();
+      const canHostPhonePairing = role === "brain" && hostStartupEnabled && crdtSyncAvailable;
       const client = syncPeerService.getStatus();
       const mode =
         role === "viewer"
@@ -717,9 +719,13 @@ export function createSyncService(args: SyncServiceArgs) {
         client,
         transferReadiness: await getTransferReadiness(),
         survivableStateText:
-          "Paused and idle state will remain available on the new host.",
+          crdtSyncAvailable
+            ? "Paused and idle state will remain available on the new host."
+            : "Desktop sync is disabled because the CRDT database extension is unavailable on this platform.",
         blockingStateText:
-          "Live missions, chats, terminals, or run processes must stop first.",
+          crdtSyncAvailable
+            ? "Live missions, chats, terminals, or run processes must stop first."
+            : "Install a Windows cr-sqlite runtime before pairing or syncing devices.",
       };
     },
 
diff --git a/apps/desktop/src/main/services/tests/testService.ts b/apps/desktop/src/main/services/tests/testService.ts
index 3ef56dd0e..016fc8e30 100644
--- a/apps/desktop/src/main/services/tests/testService.ts
+++ b/apps/desktop/src/main/services/tests/testService.ts
@@ -22,6 +22,7 @@ import type { createProjectConfigService } from "../config/projectConfigService"
 import type { createLaneService } from "../lanes/laneService";
 import { matchLaneOverlayPolicies } from "../config/laneOverlayMatcher";
 import { nowIso, resolvePathWithinRoot } from "../shared/utils";
+import { resolveCliSpawnInvocation, terminateProcessTree } from "../shared/processExecution";
 
 type ActiveRunEntry = {
   laneId: string;
@@ -295,11 +296,17 @@ export function createTestService({
       }
     })();
 
-    const child: ChildProcessByStdio<null, Readable, Readable> = spawn(suite.command[0]!, suite.command.slice(1), {
+    const invocation = resolveCliSpawnInvocation(suite.command[0]!, suite.command.slice(1), {
+      ...process.env,
+      ...suite.env,
+      ...(overlay.env ?? {})
+    });
+    const child: ChildProcessByStdio<null, Readable, Readable> = spawn(invocation.command, invocation.args, {
       cwd,
       env: { ...process.env, ...suite.env, ...(overlay.env ?? {}) },
       shell: false,
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments,
     });
 
     const entry: ActiveRunEntry = {
@@ -354,18 +361,10 @@ export function createTestService({
     if (suite.timeoutMs && suite.timeoutMs > 0) {
       entry.timeoutTimer = setTimeout(() => {
         entry.stopIntent = "timed_out";
-        try {
-          child.kill("SIGTERM");
-        } catch {
-          // ignore
-        }
+        terminateProcessTree(child, "SIGTERM");
         entry.killTimer = setTimeout(() => {
           if (activeRuns.has(runId)) {
-            try {
-              child.kill("SIGKILL");
-            } catch {
-              // ignore
-            }
+            terminateProcessTree(child, "SIGKILL");
           }
         }, 3000);
       }, suite.timeoutMs);
@@ -411,18 +410,10 @@ export function createTestService({
         entry.killTimer = null;
       }
       entry.stopIntent = "canceled";
-      try {
-        entry.child.kill("SIGTERM");
-      } catch {
-        // ignore
-      }
+      terminateProcessTree(entry.child, "SIGTERM");
       entry.killTimer = setTimeout(() => {
         if (!activeRuns.has(arg.runId)) return;
-        try {
-          entry.child.kill("SIGKILL");
-        } catch {
-          // ignore
-        }
+        terminateProcessTree(entry.child, "SIGKILL");
       }, 3000);
     },
 
diff --git a/apps/desktop/src/main/services/usage/usageTrackingService.test.ts b/apps/desktop/src/main/services/usage/usageTrackingService.test.ts
index 644e7528c..09769ad08 100644
--- a/apps/desktop/src/main/services/usage/usageTrackingService.test.ts
+++ b/apps/desktop/src/main/services/usage/usageTrackingService.test.ts
@@ -1,7 +1,24 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import { EventEmitter } from "node:events";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+
+const mockState = vi.hoisted(() => ({
+  spawn: vi.fn(),
+  spawnSync: vi.fn(),
+  resolveCodexExecutable: vi.fn(),
+}));
+
+vi.mock("node:child_process", () => ({
+  spawn: (...args: unknown[]) => mockState.spawn(...args),
+  spawnSync: (...args: unknown[]) => mockState.spawnSync(...args),
+}));
+
+vi.mock("../ai/codexExecutable", () => ({
+  resolveCodexExecutable: (...args: unknown[]) => mockState.resolveCodexExecutable(...args),
+}));
+
 import { createUsageTrackingService, _testing } from "./usageTrackingService";
 
 const {
@@ -11,6 +28,7 @@ const {
   isTokenExpiredOrExpiring,
   parseClaudeWindows,
   parseCodexRateLimitWindows,
+  pollCodexViaCliRpc,
   resolveTokenPrice,
 } = _testing;
 
@@ -29,6 +47,61 @@ function makeTmpDir(): string {
   return fs.mkdtempSync(path.join(os.tmpdir(), "ade-usage-test-"));
 }
 
+function setPlatform(value: NodeJS.Platform): void {
+  Object.defineProperty(process, "platform", {
+    value,
+    configurable: true,
+  });
+}
+
+function createFakeCodexChild({
+  closeCode = 0,
+  stdout = "",
+  stderr = "",
+  stdinError = null,
+}: {
+  closeCode?: number | null;
+  stdout?: string;
+  stderr?: string;
+  stdinError?: Error | null;
+}) {
+  const child = new EventEmitter() as any;
+  const stdoutEmitter = new EventEmitter();
+  const stderrEmitter = new EventEmitter();
+  const stdinEmitter = new EventEmitter() as any;
+  const written: string[] = [];
+
+  stdinEmitter.write = vi.fn((chunk: string) => {
+    written.push(chunk);
+    return true;
+  });
+  stdinEmitter.end = vi.fn(() => {
+    queueMicrotask(() => {
+      if (stdinError) {
+        stdinEmitter.emit("error", stdinError);
+        return;
+      }
+      if (stdout) stdoutEmitter.emit("data", Buffer.from(stdout));
+      if (stderr) stderrEmitter.emit("data", Buffer.from(stderr));
+      child.emit("close", closeCode);
+    });
+  });
+
+  child.stdout = stdoutEmitter;
+  child.stderr = stderrEmitter;
+  child.stdin = stdinEmitter;
+  child.kill = vi.fn();
+
+  return { child, written, stdinEmitter, stdoutEmitter, stderrEmitter };
+}
+
+beforeEach(() => {
+  mockState.spawn.mockReset();
+  mockState.spawnSync.mockReset();
+  mockState.spawnSync.mockReturnValue({ status: 0, stdout: Buffer.alloc(0), stderr: Buffer.alloc(0) });
+  mockState.resolveCodexExecutable.mockReset();
+});
+
 // ── calculatePacing ──────────────────────────────────────────────
 
 describe("calculatePacing", () => {
@@ -374,6 +447,142 @@ describe("parseCodexRateLimitWindows", () => {
   });
 });
 
+describe("pollCodexViaCliRpc", () => {
+  const originalPlatform = process.platform;
+  const originalComSpec = process.env.ComSpec;
+
+  beforeEach(() => {
+    setPlatform("win32");
+    process.env.ComSpec = "cmd.exe";
+  });
+
+  afterEach(() => {
+    setPlatform(originalPlatform);
+    if (originalComSpec === undefined) {
+      delete process.env.ComSpec;
+    } else {
+      process.env.ComSpec = originalComSpec;
+    }
+  });
+
+  it("wraps extensionless Windows codex paths with cmd.exe and writes the combined JSONL payload once", async () => {
+    const fake = createFakeCodexChild({
+      stdout: `${JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        result: {
+          rateLimits: {
+            primary: { usedPercent: 17, resetsAt: 1773446952 },
+            secondary: { usedPercent: 64, resetsAt: 1773853354 },
+          },
+        },
+      })}\n`,
+    });
+
+    mockState.resolveCodexExecutable.mockReturnValue({
+      path: "C:\\Users\\me\\AppData\\Local\\Programs\\codex",
+      source: "path",
+    });
+    mockState.spawn.mockReturnValue(fake.child);
+
+    const logger = createLogger();
+    const result = await pollCodexViaCliRpc(logger as any);
+
+    expect(mockState.spawn).toHaveBeenCalledTimes(1);
+    expect(mockState.spawn).toHaveBeenCalledWith(
+      "cmd.exe",
+      ["/d", "/s", "/c", '"C:\\Users\\me\\AppData\\Local\\Programs\\codex" "-s" "read-only" "-a" "untrusted" "app-server"'],
+      expect.objectContaining({ windowsVerbatimArguments: true }),
+    );
+    expect(fake.stdinEmitter.write).toHaveBeenCalledTimes(1);
+    expect(fake.written[0]).toMatch(/\n$/);
+    expect(fake.written[0]).not.toMatch(/\n\n$/);
+    expect(result.errors).toEqual([]);
+    expect(result.windows).toHaveLength(2);
+    expect(result.windows.find((window) => window.windowType === "five_hour")?.percentUsed).toBe(17);
+  });
+
+  it("spawns codex directly on POSIX without Windows shell options", async () => {
+    setPlatform("linux");
+    const fake = createFakeCodexChild({
+      stdout: `${JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        result: {
+          rateLimits: {
+            primary: { usedPercent: 17, resetsAt: 1773446952 },
+            secondary: { usedPercent: 64, resetsAt: 1773853354 },
+          },
+        },
+      })}\n`,
+    });
+
+    mockState.resolveCodexExecutable.mockReturnValue({
+      path: "codex",
+      source: "path",
+    });
+    mockState.spawn.mockReturnValue(fake.child);
+
+    const logger = createLogger();
+    const result = await pollCodexViaCliRpc(logger as any);
+
+    expect(mockState.spawn).toHaveBeenCalledTimes(1);
+    const [spawnFile, spawnArgs, spawnOptions] = mockState.spawn.mock.calls[0]!;
+    expect(spawnFile).toBe("codex");
+    expect(spawnArgs).toEqual(["-s", "read-only", "-a", "untrusted", "app-server"]);
+    expect(spawnOptions).toEqual(expect.objectContaining({ windowsVerbatimArguments: false }));
+    expect(fake.stdinEmitter.write).toHaveBeenCalledTimes(1);
+    expect(fake.written[0]).toMatch(/\n$/);
+    expect(fake.written[0]).not.toMatch(/\n\n$/);
+    expect(result.errors).toEqual([]);
+    expect(result.windows).toHaveLength(2);
+    expect(result.windows.find((window) => window.windowType === "five_hour")?.percentUsed).toBe(17);
+  });
+
+  it("routes stdin EPIPE errors through cleanup and reports a CLI RPC failure", async () => {
+    const stdinError = new Error("EPIPE");
+    const fake = createFakeCodexChild({ stdinError });
+
+    mockState.resolveCodexExecutable.mockReturnValue({
+      path: "codex.exe",
+      source: "path",
+    });
+    mockState.spawn.mockReturnValue(fake.child);
+
+    const logger = createLogger();
+    const result = await pollCodexViaCliRpc(logger as any);
+
+    expect(result.windows).toEqual([]);
+    expect(result.errors[0]).toContain("codex: CLI RPC error:");
+    expect(logger.warn).toHaveBeenCalledWith(
+      "usage.poll.codex_cli_rpc_stdin_failed",
+      expect.objectContaining({ error: "EPIPE" }),
+    );
+  });
+
+  it("logs non-zero exits after parsing close output", async () => {
+    const fake = createFakeCodexChild({
+      closeCode: 1,
+      stderr: "codex said no\n",
+    });
+
+    mockState.resolveCodexExecutable.mockReturnValue({
+      path: "codex.exe",
+      source: "path",
+    });
+    mockState.spawn.mockReturnValue(fake.child);
+
+    const logger = createLogger();
+    const result = await pollCodexViaCliRpc(logger as any);
+
+    expect(result.errors).toContain("codex: CLI RPC exited with non-zero code");
+    expect(logger.warn).toHaveBeenCalledWith(
+      "usage.poll.codex_cli_rpc_non_zero_exit",
+      expect.objectContaining({ exitCode: 1, stderr: "codex said no\n" }),
+    );
+  });
+});
+
 // ── Service Integration ──────────────────────────────────────────
 
 describe("createUsageTrackingService", () => {
diff --git a/apps/desktop/src/main/services/usage/usageTrackingService.ts b/apps/desktop/src/main/services/usage/usageTrackingService.ts
index 30ff6c85f..ca00eac69 100644
--- a/apps/desktop/src/main/services/usage/usageTrackingService.ts
+++ b/apps/desktop/src/main/services/usage/usageTrackingService.ts
@@ -9,6 +9,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
+import { spawn } from "node:child_process";
 import type { Logger } from "../logging/logger";
 import type {
   UsageProvider,
@@ -27,8 +28,9 @@ import {
   readClaudeCredentialsWithRefresh,
   readCodexCredentials,
   refreshClaudeCredentials,
-  runShellCommand,
 } from "../ai/providerCredentialSources";
+import { resolveCodexExecutable } from "../ai/codexExecutable";
+import { resolveCliSpawnInvocation, terminateProcessTree } from "../shared/processExecution";
 
 // ── Constants ────────────────────────────────────────────────────
 
@@ -37,6 +39,7 @@ const MIN_POLL_INTERVAL_MS = 60_000;          // 1 min
 const MAX_POLL_INTERVAL_MS = 15 * 60_000;     // 15 min
 const COST_CACHE_TTL_MS = 60_000;             // 60s
 const CODEX_TOKEN_REFRESH_DAYS = 8;
+const CODEX_CLI_RPC_TIMEOUT_MS = 10_000;
 
 const CLAUDE_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
 const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
@@ -347,7 +350,6 @@ async function pollCodexViaCliRpc(logger: Logger): Promise<{ windows: UsageWindo
   const errors: string[] = [];
 
   try {
-    // Initialize the Codex CLI JSON-RPC connection.
     const initPayload = JSON.stringify({
       jsonrpc: "2.0",
       id: 0,
@@ -378,12 +380,94 @@ async function pollCodexViaCliRpc(logger: Logger): Promise<{ windows: UsageWindo
 
     const combined = `${initPayload}\n${initializedPayload}\n${rateLimitsPayload}\n`;
 
-    const result = await runShellCommand(
-      `echo '${combined.replace(/'/g, "'\\''")}' | codex -s read-only -a untrusted app-server 2>/dev/null`,
-      10_000
+    const codexPath = resolveCodexExecutable().path;
+    const env = { ...process.env };
+    const invocation = resolveCliSpawnInvocation(
+      codexPath,
+      ["-s", "read-only", "-a", "untrusted", "app-server"],
+      env,
+    );
+
+    const result = await new Promise<{ stdout: string; stderr: string; exitCode: number | null }>(
+      (resolve, reject) => {
+        let settled = false;
+        let timer: ReturnType<typeof setTimeout> | null = null;
+        const finish = (callback: () => void) => {
+          if (settled) return;
+          settled = true;
+          if (timer) {
+            clearTimeout(timer);
+            timer = null;
+          }
+          callback();
+        };
+        const child = spawn(invocation.command, invocation.args, {
+          stdio: ["pipe", "pipe", "pipe"],
+          env,
+          windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+        });
+
+        let stdout = "";
+        let stderr = "";
+        const maxStdout = 50_000;
+        const maxStderr = 10_000;
+        child.stdout?.on("data", (chunk: Buffer) => {
+          if (stdout.length >= maxStdout) return;
+          const s = chunk.toString("utf8");
+          stdout += s.slice(0, maxStdout - stdout.length);
+        });
+        child.stderr?.on("data", (chunk: Buffer) => {
+          if (stderr.length >= maxStderr) return;
+          const s = chunk.toString("utf8");
+          stderr += s.slice(0, maxStderr - stderr.length);
+        });
+
+        timer = setTimeout(() => {
+          terminateProcessTree(child, "SIGKILL", (detail) => {
+            logger.warn("usage.poll.codex_cli_rpc_taskkill_failed", {
+              ...detail,
+              error: detail.error ? getErrorMessage(detail.error) : null,
+            });
+          });
+          logger.warn("usage.poll.codex_cli_rpc_timeout", {
+            timeoutMs: CODEX_CLI_RPC_TIMEOUT_MS,
+          });
+          finish(() => reject(new Error(`codex CLI RPC timed out after ${CODEX_CLI_RPC_TIMEOUT_MS}ms`)));
+        }, CODEX_CLI_RPC_TIMEOUT_MS);
+
+        child.on("error", (error) => {
+          logger.warn("usage.poll.codex_cli_rpc_spawn_failed", {
+            error: getErrorMessage(error),
+          });
+          finish(() => reject(error));
+        });
+        child.on("close", (code) => {
+          finish(() => resolve({ stdout, stderr, exitCode: code }));
+        });
+        child.stdin?.on("error", (error) => {
+          logger.warn("usage.poll.codex_cli_rpc_stdin_failed", {
+            error: getErrorMessage(error),
+          });
+          finish(() => reject(error));
+        });
+
+        try {
+          child.stdin?.write(combined);
+          child.stdin?.end();
+        } catch (err) {
+          logger.warn("usage.poll.codex_cli_rpc_stdin_failed", {
+            error: getErrorMessage(err),
+          });
+          finish(() => reject(err));
+        }
+      },
     );
 
     if (result.exitCode !== 0) {
+      logger.warn("usage.poll.codex_cli_rpc_non_zero_exit", {
+        exitCode: result.exitCode,
+        stderr: result.stderr,
+      });
       errors.push("codex: CLI RPC exited with non-zero code");
       return { windows, errors };
     }
@@ -915,4 +999,5 @@ export const _testing = {
   fetchJson,
   findJsonlFiles,
   resolveTokenPrice,
+  pollCodexViaCliRpc,
 };
diff --git a/apps/desktop/src/renderer/components/app/CommandPalette.tsx b/apps/desktop/src/renderer/components/app/CommandPalette.tsx
index 2f3afef3c..3cd7f0ad8 100644
--- a/apps/desktop/src/renderer/components/app/CommandPalette.tsx
+++ b/apps/desktop/src/renderer/components/app/CommandPalette.tsx
@@ -45,6 +45,8 @@ type BrowseRow = {
 
 function stripTrailingSeparator(input: string): string {
   if (input.length <= 1) return input;
+  if (/^[a-z]:[\\/]$/i.test(input)) return input;
+  if (/^[/\\]{2}[^/\\]+[/\\][^/\\]+[/\\]?$/i.test(input)) return input;
   return input.endsWith("/") || input.endsWith("\\") ? input.slice(0, -1) : input;
 }
 
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatComposer.test.tsx b/apps/desktop/src/renderer/components/chat/AgentChatComposer.test.tsx
index 624c5c0ec..5a7768907 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatComposer.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatComposer.test.tsx
@@ -4,6 +4,61 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 import { cleanup, fireEvent, render, screen, type RenderResult } from "@testing-library/react";
 import type { ComponentProps } from "react";
 import { AgentChatComposer } from "./AgentChatComposer";
+import { modifierKeyLabel } from "../../lib/platform";
+
+function installMatchMediaMock(): void {
+  if (typeof window.matchMedia === "function") return;
+  Object.defineProperty(window, "matchMedia", {
+    writable: true,
+    value: vi.fn().mockImplementation((query: string) => ({
+      matches: false,
+      media: query,
+      onchange: null,
+      addListener: vi.fn(),
+      removeListener: vi.fn(),
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+    })),
+  });
+}
+
+vi.mock("@emoji-mart/data", () => ({
+  default: { categories: [], emojis: {}, aliases: {}, sheet: { cols: 0, rows: 0 } },
+}));
+
+vi.mock("@emoji-mart/data/sets/15/native.json", () => ({
+  default: { categories: [], emojis: {}, aliases: {}, sheet: { cols: 0, rows: 0 } },
+}));
+
+vi.mock("@lobehub/icons", () => {
+  const brand = () => {
+    const Component = () => null;
+    Object.assign(Component, {
+      Avatar: () => null,
+      Color: () => null,
+      Combine: () => null,
+      Text: () => null,
+      colorPrimary: "#888",
+      title: "stub",
+    });
+    return Component;
+  };
+  return {
+    Anthropic: brand(),
+    Claude: brand(),
+    Codex: brand(),
+    Cursor: brand(),
+    Gemini: brand(),
+    Google: brand(),
+    Grok: brand(),
+    Groq: brand(),
+    OpenAI: brand(),
+    OpenCode: brand(),
+    OpenRouter: brand(),
+    XAI: brand(),
+  };
+});
 
 afterEach(cleanup);
 
@@ -52,6 +107,7 @@ function buildComposerProps(overrides: Partial<ComponentProps<typeof AgentChatCo
 }
 
 function renderComposer(overrides: Partial<ComponentProps<typeof AgentChatComposer>> = {}) {
+  installMatchMediaMock();
   const props = buildComposerProps(overrides);
 
   const view = render(<AgentChatComposer {...props} />);
@@ -88,7 +144,7 @@ describe("AgentChatComposer", () => {
   it("stop only interrupts the active turn", () => {
     const props = renderComposer();
 
-    const stopButtons = screen.getAllByTitle("Stop the active turn only (Cmd+.)");
+    const stopButtons = screen.getAllByTitle(`Stop the active turn only (${modifierKeyLabel}+.)`);
     fireEvent.click(stopButtons[stopButtons.length - 1]!);
 
     expect(props.onInterrupt).toHaveBeenCalledTimes(1);
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx b/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx
index b7c05fd04..bb6e7c235 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx
@@ -32,6 +32,7 @@ import { CURSOR_MODE_LABELS } from "../../../shared/cursorModes";
 import { ChatStatusGlyph } from "./chatStatusVisuals";
 import { ChatProposedPlanCard } from "./ChatProposedPlanCard";
 import { ChatCommandMenu, type ChatCommandMenuItem, type ChatCommandMenuHandle } from "./ChatCommandMenu";
+import { modifierKeyLabel } from "../../lib/platform";
 
 const MAX_TEMP_ATTACHMENT_BYTES = 10 * 1024 * 1024;
 
@@ -1880,7 +1881,7 @@ export function AgentChatComposer({
                 <button
                   type="button"
                   className="inline-flex h-7 w-7 items-center justify-center rounded-lg border border-red-500/25 bg-red-500/[0.08] text-red-400/80 transition-all hover:border-red-500/40 hover:bg-red-500/[0.14] hover:text-red-400"
-                  title="Stop the active turn only (Cmd+.)"
+                  title={`Stop the active turn only (${modifierKeyLabel}+.)`}
                   aria-label="Stop active turn"
                   onClick={onInterrupt}
                 >
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
index 2a873e58f..28c7ad0aa 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
@@ -5,6 +5,45 @@ import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/re
 import { MemoryRouter, useLocation } from "react-router-dom";
 import type { AgentChatApprovalDecision, AgentChatEventEnvelope } from "../../../shared/types";
 import * as modelRegistry from "../../../shared/modelRegistry";
+
+vi.mock("lottie-react", () => ({
+  useLottie: () => ({
+    View: null,
+    play: () => {},
+    stop: () => {},
+    pause: () => {},
+    setSpeed: () => {},
+    goToAndStop: () => {},
+    goToAndPlay: () => {},
+    setDirection: () => {},
+    getDuration: () => 0,
+    destroy: () => {},
+    animationItem: null,
+  }),
+  default: () => null,
+}));
+
+vi.mock("@lobehub/icons", () => {
+  const brand = () => {
+    const Component = () => null;
+    Object.assign(Component, {
+      Avatar: () => null,
+      Color: () => null,
+      Combine: () => null,
+      Text: () => null,
+      colorPrimary: "#888",
+      title: "stub",
+    });
+    return Component;
+  };
+  return {
+    Claude: brand(),
+    Codex: brand(),
+    Cursor: brand(),
+    OpenCode: brand(),
+  };
+});
+
 import {
   AgentChatMessageList,
   calculateVirtualWindow,
@@ -325,6 +364,170 @@ describe("AgentChatMessageList transcript rendering", () => {
     );
   });
 
+  it("maps Windows drive-letter file references into Files navigation targets", async () => {
+    vi.mocked(globalThis.window.ade.files.listWorkspaces).mockResolvedValueOnce([
+      {
+        id: "workspace-windows",
+        kind: "worktree",
+        laneId: "lane-win",
+        name: "Windows lane",
+        rootPath: "C:\\Users\\me\\repo",
+        isReadOnlyByDefault: false,
+      },
+    ]);
+
+    renderMessageList(
+      [
+        {
+          sessionId: "session-1",
+          timestamp: "2026-03-17T10:00:00.000Z",
+          event: {
+            type: "text",
+            text: "Inspect `C:\\Users\\me\\repo\\src\\main.ts`.",
+            itemId: "text-windows-absolute",
+            turnId: "turn-1",
+          },
+        },
+      ],
+      {
+        initialState: { laneId: "lane-win" },
+      },
+    );
+
+    await waitFor(() => {
+      expect(globalThis.window.ade.files.listWorkspaces).toHaveBeenCalledTimes(1);
+    });
+
+    fireEvent.click(screen.getByRole("button", { name: "C:\\Users\\me\\repo\\src\\main.ts" }));
+
+    expect(screen.getByTestId("location").textContent).toBe(
+      "/files::{\"openFilePath\":\"src/main.ts\",\"laneId\":\"lane-win\"}",
+    );
+  });
+
+  it("matches Windows drive-letter file references case-insensitively", async () => {
+    vi.mocked(globalThis.window.ade.files.listWorkspaces).mockResolvedValueOnce([
+      {
+        id: "workspace-windows",
+        kind: "worktree",
+        laneId: "lane-win",
+        name: "Windows lane",
+        rootPath: "C:\\Users\\Me\\Repo",
+        isReadOnlyByDefault: false,
+      },
+    ]);
+
+    renderMessageList(
+      [
+        {
+          sessionId: "session-1",
+          timestamp: "2026-03-17T10:00:00.000Z",
+          event: {
+            type: "text",
+            text: "Inspect `c:\\users\\me\\repo\\src\\main.ts`.",
+            itemId: "text-windows-case",
+            turnId: "turn-1",
+          },
+        },
+      ],
+      {
+        initialState: { laneId: "lane-win" },
+      },
+    );
+
+    await waitFor(() => {
+      expect(globalThis.window.ade.files.listWorkspaces).toHaveBeenCalledTimes(1);
+    });
+
+    fireEvent.click(screen.getByRole("button", { name: "c:\\users\\me\\repo\\src\\main.ts" }));
+
+    expect(screen.getByTestId("location").textContent).toBe(
+      "/files::{\"openFilePath\":\"src/main.ts\",\"laneId\":\"lane-win\"}",
+    );
+  });
+
+  it("maps Windows markdown links into Files navigation targets", async () => {
+    vi.mocked(globalThis.window.ade.files.listWorkspaces).mockResolvedValueOnce([
+      {
+        id: "workspace-windows",
+        kind: "worktree",
+        laneId: "lane-win",
+        name: "Windows lane",
+        rootPath: "C:\\Users\\me\\repo",
+        isReadOnlyByDefault: false,
+      },
+    ]);
+
+    renderMessageList(
+      [
+        {
+          sessionId: "session-1",
+          timestamp: "2026-03-17T10:00:00.000Z",
+          event: {
+            type: "text",
+            text: "Open [main.ts](C:/Users/me/repo/src/main.ts).",
+            itemId: "text-windows-link",
+            turnId: "turn-1",
+          },
+        },
+      ],
+      {
+        initialState: { laneId: "lane-win" },
+      },
+    );
+
+    await waitFor(() => {
+      expect(globalThis.window.ade.files.listWorkspaces).toHaveBeenCalledTimes(1);
+    });
+
+    fireEvent.click(screen.getByRole("button", { name: "main.ts" }));
+
+    expect(screen.getByTestId("location").textContent).toBe(
+      "/files::{\"openFilePath\":\"src/main.ts\",\"laneId\":\"lane-win\"}",
+    );
+  });
+
+  it("maps backslash UNC file references into Files navigation targets", async () => {
+    vi.mocked(globalThis.window.ade.files.listWorkspaces).mockResolvedValueOnce([
+      {
+        id: "workspace-unc",
+        kind: "worktree",
+        laneId: "lane-unc",
+        name: "UNC lane",
+        rootPath: "\\\\server\\share\\repo",
+        isReadOnlyByDefault: false,
+      },
+    ]);
+
+    renderMessageList(
+      [
+        {
+          sessionId: "session-1",
+          timestamp: "2026-03-17T10:00:00.000Z",
+          event: {
+            type: "text",
+            text: "Inspect `\\\\server\\share\\repo\\src\\main.ts`.",
+            itemId: "text-unc-absolute",
+            turnId: "turn-1",
+          },
+        },
+      ],
+      {
+        initialState: { laneId: "lane-unc" },
+      },
+    );
+
+    await waitFor(() => {
+      expect(globalThis.window.ade.files.listWorkspaces).toHaveBeenCalledTimes(1);
+    });
+
+    fireEvent.click(screen.getByRole("button", { name: "\\\\server\\share\\repo\\src\\main.ts" }));
+
+    expect(screen.getByTestId("location").textContent).toBe(
+      "/files::{\"openFilePath\":\"src/main.ts\",\"laneId\":\"lane-unc\"}",
+    );
+  });
+
   it("does not coalesce text fragments across command boundaries", () => {
     const view = renderMessageList([
       {
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
index 3951be7cb..f9d523c45 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
@@ -1,5 +1,5 @@
 import React, { useCallback, useEffect, useId, useLayoutEffect, useMemo, useRef, useState } from "react";
-import ReactMarkdown from "react-markdown";
+import ReactMarkdown, { defaultUrlTransform } from "react-markdown";
 import remarkGfm from "remark-gfm";
 import { motion } from "motion/react";
 import { useLocation, useNavigate } from "react-router-dom";
@@ -43,6 +43,7 @@ import type {
 import { getModelById, resolveModelDescriptor } from "../../../shared/modelRegistry";
 import { cn } from "../ui/cn";
 import { formatTime } from "../../lib/format";
+import { isPathEqualOrDescendant, isWindowsAbsolutePath, normalizePath } from "../../lib/pathUtils";
 import { describeToolIdentifier, replaceInternalToolNames } from "./toolPresentation";
 import { chatChipToneClass } from "./chatSurfaceTheme";
 import { ChatAttachmentTray } from "./ChatAttachmentTray";
@@ -109,17 +110,21 @@ function getEventTurnId(event: AgentChatEvent): string | null {
 }
 
 function basenamePathLabel(value: string): string {
-  const normalized = value.replace(/\\/g, "/");
+  const normalized = normalizePath(value);
   const basename = normalized.split("/").pop()?.trim();
-  return basename?.length ? basename : normalized;
+  if (!basename?.length) return normalized;
+  if (/^[A-Za-z]:$/.test(basename)) return `${basename}/`;
+  return basename;
 }
 
 function dirnamePathLabel(value: string): string | null {
-  const normalized = value.replace(/\\/g, "/");
+  const normalized = normalizePath(value);
   const basename = basenamePathLabel(normalized);
   if (basename === normalized) return null;
   const suffix = `/${basename}`;
-  return normalized.endsWith(suffix) ? normalized.slice(0, -suffix.length) : null;
+  if (!normalized.endsWith(suffix)) return null;
+  const dirname = normalized.slice(0, -suffix.length);
+  return dirname.length ? normalizePath(dirname) : null;
 }
 
 function formatFileAction(kind: Extract<AgentChatEvent, { type: "file_change" }>["kind"]): string {
@@ -399,7 +404,10 @@ function statusColorClass(status: string | undefined): string {
 }
 
 function isExternalHref(href: string): boolean {
-  return /^(?:[a-z]+:)?\/\//i.test(href) || /^mailto:/i.test(href) || /^tel:/i.test(href);
+  const trimmed = href.trim();
+  if (/^file:/i.test(trimmed)) return false;
+  if (isWindowsAbsolutePath(trimmed)) return false;
+  return /^(?:[a-z]+:)?\/\//i.test(trimmed) || /^mailto:/i.test(trimmed) || /^tel:/i.test(trimmed);
 }
 
 function normalizeWorkspacePathCandidate(value: string): string | null {
@@ -408,7 +416,14 @@ function normalizeWorkspacePathCandidate(value: string): string | null {
   if (/^(?:https?|mailto|tel):/i.test(trimmed)) return null;
   if (/^#/.test(trimmed)) return null;
   const withoutScheme = trimmed.replace(/^file:\/\//i, "");
-  const withoutQuery = withoutScheme.split(/[?#]/, 1)[0]?.trim().replace(/\\/g, "/") ?? "";
+  const rawPath = withoutScheme.split(/[?#]/, 1)[0]?.trim() ?? "";
+  let decodedPath = rawPath;
+  try {
+    decodedPath = decodeURIComponent(rawPath);
+  } catch {
+    // Keep the raw path when markdown produced a partially-encoded href.
+  }
+  const withoutQuery = decodedPath.replace(/\\/g, "/");
   if (!withoutQuery.length) return null;
   // Normalize Windows drive-letter paths: /C:/... → C:/...
   if (/^\/[A-Za-z]:\//.test(withoutQuery)) return withoutQuery.slice(1);
@@ -433,12 +448,19 @@ function looksLikeWorkspacePath(value: string): boolean {
 
 function resolveWorkspacePathFromHref(href: string | undefined): string | null {
   if (!href) return null;
+  if (isExternalHref(href)) return null;
   const candidate = normalizeWorkspacePathCandidate(href);
   if (!candidate) return null;
-  if (isExternalHref(candidate)) return null;
   return looksLikeWorkspacePath(candidate) ? candidate : null;
 }
 
+function chatMarkdownUrlTransform(value: string): string {
+  if (/^file:/i.test(value) || isWindowsAbsolutePath(value)) {
+    return value;
+  }
+  return defaultUrlTransform(value);
+}
+
 function InlineDisclosureRow({
   summary,
   children,
@@ -490,15 +512,6 @@ function InlineDisclosureRow({
   );
 }
 
-function normalizeFileSystemPath(value: string): string {
-  return value.replace(/\\/g, "/");
-}
-
-function trimTrailingSlashes(value: string): string {
-  if (value === "/") return value;
-  return value.replace(/\/+$/, "");
-}
-
 function resolveFilesNavigationTarget(args: {
   path: string;
   workspaces: FilesWorkspace[];
@@ -507,16 +520,14 @@ function resolveFilesNavigationTarget(args: {
   const candidate = normalizeWorkspacePathCandidate(args.path);
   if (!candidate) return null;
 
-  const normalizedCandidate = normalizeFileSystemPath(candidate);
-  if (normalizedCandidate.startsWith("/")) {
+  const normalizedCandidate = normalizePath(candidate);
+  if (normalizedCandidate.startsWith("/") || isWindowsAbsolutePath(normalizedCandidate)) {
     const matches = args.workspaces
       .map((workspace) => ({
         workspace,
-        rootPath: trimTrailingSlashes(normalizeFileSystemPath(workspace.rootPath)),
+        rootPath: normalizePath(workspace.rootPath),
       }))
-      .filter(({ rootPath }) =>
-        normalizedCandidate === rootPath || normalizedCandidate.startsWith(`${rootPath}/`),
-      )
+      .filter(({ workspace }) => isPathEqualOrDescendant(normalizedCandidate, workspace.rootPath))
       .sort((left, right) => {
         const rightMatchesLane = right.workspace.laneId != null && right.workspace.laneId === args.fallbackLaneId ? 1 : 0;
         const leftMatchesLane = left.workspace.laneId != null && left.workspace.laneId === args.fallbackLaneId ? 1 : 0;
@@ -561,6 +572,7 @@ const MarkdownBlock = React.memo(function MarkdownBlock({
     <div className="ade-prose-themed prose prose-invert max-w-none text-[13px] leading-[1.8] text-fg/96 prose-headings:mb-3 prose-headings:mt-6 prose-headings:font-sans prose-headings:font-semibold prose-headings:tracking-tight prose-headings:text-fg prose-p:my-3 prose-p:text-fg/88 prose-ul:my-3 prose-ul:pl-5 prose-ol:my-3 prose-ol:pl-5 prose-li:my-1.5 prose-li:pl-1 prose-li:text-fg/86 prose-strong:text-fg prose-blockquote:border-l-2 prose-blockquote:border-l-white/20 prose-blockquote:pl-4 prose-blockquote:text-fg/76 prose-hr:my-5 prose-hr:border-white/[0.08]">
       <ReactMarkdown
         remarkPlugins={[remarkGfm]}
+        urlTransform={chatMarkdownUrlTransform}
         components={{
           h1: ({ children }) => <h1 className="text-[1rem]">{children}</h1>,
           h2: ({ children }) => <h2 className="text-[0.95rem]">{children}</h2>,
@@ -3063,7 +3075,8 @@ export function AgentChatMessageList({
       workspaces: resolvedWorkspaces,
       fallbackLaneId: currentLaneId,
     });
-    if (!target && normalizeWorkspacePathCandidate(path)?.startsWith("/")) {
+    const workspaceCandidate = normalizeWorkspacePathCandidate(path);
+    if (!target && workspaceCandidate && (workspaceCandidate.startsWith("/") || isWindowsAbsolutePath(workspaceCandidate))) {
       const listWorkspaces = window.ade?.files?.listWorkspaces;
       if (typeof listWorkspaces === "function") {
         try {
diff --git a/apps/desktop/src/renderer/components/chat/ChatComputerUsePanel.tsx b/apps/desktop/src/renderer/components/chat/ChatComputerUsePanel.tsx
index 92f716da7..ff674d848 100644
--- a/apps/desktop/src/renderer/components/chat/ChatComputerUsePanel.tsx
+++ b/apps/desktop/src/renderer/components/chat/ChatComputerUsePanel.tsx
@@ -17,14 +17,15 @@ function kindLabel(kind: string): string {
 /** Convert an artifact URI to an ade-artifact:// URL that Electron's custom protocol can serve. Remote http(s) URLs return null (no automatic preview / no renderer fetch). */
 function toPreviewSrc(uri: string): string | null {
   if (/^https?:\/\//i.test(uri)) return null;
-  // Strip file:// prefix if present
   let filePath = uri;
   if (filePath.startsWith("file://")) {
-    try { filePath = decodeURIComponent(new URL(filePath).pathname); } catch { filePath = filePath.replace(/^file:\/\//i, ""); }
+    filePath = fileUriToFsPath(filePath);
+  }
+  const normalized = filePath.replace(/\\/g, "/");
+  const encoded = normalized.split("/").map((part) => encodeURIComponent(part)).join("/");
+  if (!/^([a-zA-Z]:\/|\/|\/\/)/.test(normalized)) {
+    return `ade-artifact://project/${encoded.replace(/^\/+/, "")}`;
   }
-  // For relative paths, we can't resolve here — the protocol handler in main will need the project root.
-  // But artifacts stored by the broker are typically absolute or relative to project root.
-  const encoded = new URL(filePath, "file://").pathname;
   return `ade-artifact://${encoded.startsWith("/") ? "" : "/"}${encoded}`;
 }
 
@@ -32,6 +33,9 @@ function fileUriToFsPath(uri: string): string {
   if (!uri.startsWith("file://")) return uri;
   try {
     const u = new URL(uri);
+    if (u.hostname && u.hostname !== "localhost") {
+      return `//${u.hostname}${decodeURIComponent(u.pathname)}`;
+    }
     let p = decodeURIComponent(u.pathname);
     if (/^\/[a-zA-Z]:/.test(p)) {
       p = p.slice(1);
diff --git a/apps/desktop/src/renderer/components/files/FilesPage.tsx b/apps/desktop/src/renderer/components/files/FilesPage.tsx
index 08ca1688e..e4f73c02e 100644
--- a/apps/desktop/src/renderer/components/files/FilesPage.tsx
+++ b/apps/desktop/src/renderer/components/files/FilesPage.tsx
@@ -34,7 +34,8 @@ import type {
 import { MonacoDiffView, type MonacoDiffHandle } from "../lanes/MonacoDiffView";
 import { useAppStore } from "../../state/appStore";
 import { clearDirtyBuffersForWorkspace, replaceDirtyBuffersForWorkspace } from "../../lib/dirtyWorkspaceBuffers";
-import { revealLabel } from "../../lib/platform";
+import { modifierKeyLabel, revealLabel } from "../../lib/platform";
+import { normalizePath, isPathEqualOrDescendant, remapPathForRename } from "../../lib/pathUtils";
 import { logRendererDebugEvent } from "../../lib/debugLog";
 import { COLORS, MONO_FONT, SANS_FONT, LABEL_STYLE, inlineBadge, outlineButton, primaryButton, dangerButton, cardStyle } from "../lanes/laneDesignTokens";
 import { cn } from "../ui/cn";
@@ -300,33 +301,16 @@ function applyConflictChoice(text: string, hunk: ConflictHunk, choice: "ours" |
 }
 
 function parentDirOfPath(filePath: string): string {
-  const normalized = filePath.replace(/\\/g, "/");
+  const normalized = normalizePath(filePath);
+  if (!normalized) return "";
+  if (/^[A-Za-z]:\/$/.test(normalized)) return "";
+  if (/^\/\/[^/]+\/[^/]+$/.test(normalized)) return "";
+  if (/^[A-Za-z]:\/[^/]+$/.test(normalized)) return `${normalized.slice(0, 2)}/`;
   const idx = normalized.lastIndexOf("/");
   if (idx <= 0) return "";
   return normalized.slice(0, idx);
 }
 
-function normalizePath(filePath: string): string {
-  return filePath.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\/+$/, "");
-}
-
-function isPathEqualOrDescendant(filePath: string, rootPath: string): boolean {
-  const normalizedPath = normalizePath(filePath);
-  const normalizedRoot = normalizePath(rootPath);
-  if (!normalizedRoot) return normalizedPath.length === 0;
-  return normalizedPath === normalizedRoot || normalizedPath.startsWith(`${normalizedRoot}/`);
-}
-
-function remapPathForRename(filePath: string, oldPath: string, newPath: string): string {
-  const normalizedPath = normalizePath(filePath);
-  const normalizedOld = normalizePath(oldPath);
-  const normalizedNew = normalizePath(newPath);
-  if (!normalizedOld || !normalizedNew) return normalizedPath;
-  if (normalizedPath === normalizedOld) return normalizedNew;
-  if (!normalizedPath.startsWith(`${normalizedOld}/`)) return normalizedPath;
-  return `${normalizedNew}${normalizedPath.slice(normalizedOld.length)}`;
-}
-
 const FILE_ICON_COLORS = {
   code: "#38BDF8",       // sky-400
   json: "#34D399",       // emerald-400
@@ -2213,7 +2197,7 @@ export function FilesPage() {
 
         {/* Open in external editor */}
         <div className="relative shrink-0" ref={openInMenuRef} data-tour="files.openIn">
-          <SmartTooltip content={{ label: "Open In", description: "Open the current file in an external editor or Finder." }}>
+          <SmartTooltip content={{ label: "Open In", description: "Open the current file in an external editor or file browser." }}>
             <button
               type="button"
               style={{
@@ -2403,7 +2387,7 @@ export function FilesPage() {
                 autoFocus
                 value={quickOpen}
                 onChange={(e) => setQuickOpen(e.target.value)}
-                placeholder="Type to search files... (Cmd+P)"
+                placeholder={`Type to search files... (${modifierKeyLabel}+P)`}
                 style={{
                   height: 36, width: "100%", padding: "0 36px 0 32px",
                   fontSize: 12, fontFamily: MONO_FONT, fontWeight: 500,
diff --git a/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.tsx b/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.tsx
index 60cafb46a..4c23d16bb 100644
--- a/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.tsx
+++ b/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.tsx
@@ -3,6 +3,7 @@ import { ArrowDown, ArrowsClockwise, Check, Stack, Trash, Upload, Warning } from
 import { useNavigate } from "react-router-dom";
 import { useAppStore } from "../../state/appStore";
 import { getProjectConfigCached } from "../../lib/projectConfigCache";
+import { modifierKeyLabel } from "../../lib/platform";
 import { cn } from "../ui/cn";
 import { SmartTooltip, type SmartTooltipContent } from "../ui/SmartTooltip";
 import { COLORS, LABEL_STYLE, MONO_FONT, inlineBadge, outlineButton, primaryButton, dangerButton } from "./laneDesignTokens";
@@ -208,7 +209,7 @@ function getCommitHelperText(args: {
   commitMessageAi: CommitMessageAiState;
 }): string {
   if (args.commitMessage.trim().length > 0) {
-    return "Press Cmd+Enter to commit with the typed message.";
+    return `Press ${modifierKeyLabel}+Enter to commit with the typed message.`;
   }
   if (args.commitMessageAi.enabled && args.commitMessageAi.modelId) {
     return `Blank messages will be auto-generated with ${args.commitMessageAi.modelId}.`;
diff --git a/apps/desktop/src/renderer/components/prs/detail/PrDetailPane.tsx b/apps/desktop/src/renderer/components/prs/detail/PrDetailPane.tsx
index 6d66cd4b2..26771cf9e 100644
--- a/apps/desktop/src/renderer/components/prs/detail/PrDetailPane.tsx
+++ b/apps/desktop/src/renderer/components/prs/detail/PrDetailPane.tsx
@@ -34,6 +34,7 @@ import { formatTimeAgo, formatTimestampFull } from "../shared/prFormatters";
 import { describePrTargetDiff } from "../shared/laneBranchTargets";
 import { findMatchingRebaseNeed, rebaseNeedItemKey } from "../shared/rebaseNeedUtils";
 import { usePrs } from "../state/PrsContext";
+import { modifierKeyLabel } from "../../../lib/platform";
 
 // ---- Sub-tab type ----
 type DetailTab = "overview" | "convergence" | "files" | "checks" | "activity";
@@ -2746,7 +2747,7 @@ function OverviewTab(props: OverviewTabProps) {
             <textarea
               value={props.commentDraft}
               onChange={(e) => props.setCommentDraft(e.target.value)}
-              placeholder="Leave a comment... Supports Markdown. Cmd+Enter to submit."
+              placeholder={`Leave a comment... Supports Markdown. ${modifierKeyLabel}+Enter to submit.`}
               onKeyDown={(e) => { if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) void props.onAddComment(); }}
               style={{
                 width: "100%", minHeight: 80, resize: "vertical", padding: "14px 14px 36px",
@@ -3565,7 +3566,7 @@ function ActivityTab({ activity, comments, reviews, commentDraft, setCommentDraf
           <textarea
             value={commentDraft}
             onChange={(e) => setCommentDraft(e.target.value)}
-            placeholder="Write a comment... (Cmd+Enter to submit)"
+            placeholder={`Write a comment... (${modifierKeyLabel}+Enter to submit)`}
             onKeyDown={(e) => { if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) void onAddComment(); }}
             style={{
               flex: 1, minHeight: 60, resize: "vertical", padding: 12,
diff --git a/apps/desktop/src/renderer/components/settings/AdeCliSection.tsx b/apps/desktop/src/renderer/components/settings/AdeCliSection.tsx
index f5c6f614a..f4343623c 100644
--- a/apps/desktop/src/renderer/components/settings/AdeCliSection.tsx
+++ b/apps/desktop/src/renderer/components/settings/AdeCliSection.tsx
@@ -59,6 +59,9 @@ export function AdeCliSection({ compact = false }: Props) {
   const terminalReady = status?.terminalInstalled === true;
   const agentReady = status?.agentPathReady === true;
   const bundledReady = status?.bundledAvailable === true;
+  const installTargetDir = status?.installTargetPath
+    ? status.installTargetPath.replace(/[\\/](?:ade|ade\.cmd)$/i, "")
+    : "";
   let statusColor: string = COLORS.textMuted;
   let statusLabel = "Manual action";
   if (terminalReady) {
@@ -118,7 +121,7 @@ export function AdeCliSection({ compact = false }: Props) {
 
         {!status?.installTargetDirOnPath && status?.installTargetPath ? (
           <div style={{ ...infoBoxStyle(), marginTop: 14 }}>
-            {status.installTargetPath.replace(/\/ade$/, "")} is not on this shell PATH. Agents still get the bundled command; add that directory to your shell PATH for Terminal use.
+            {installTargetDir} is not on this shell PATH. Agents still get the bundled command; add that directory to your shell PATH for Terminal use.
           </div>
         ) : null}
 
diff --git a/apps/desktop/src/renderer/lib/dirtyWorkspaceBuffers.test.ts b/apps/desktop/src/renderer/lib/dirtyWorkspaceBuffers.test.ts
new file mode 100644
index 000000000..dfba3115d
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/dirtyWorkspaceBuffers.test.ts
@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vitest";
+import {
+  clearDirtyBuffersForWorkspace,
+  getDirtyFileTextForWindow,
+  replaceDirtyBuffersForWorkspace,
+} from "./dirtyWorkspaceBuffers";
+
+describe("dirtyWorkspaceBuffers", () => {
+  it("matches Windows absolute paths case-insensitively with slash normalization", () => {
+    replaceDirtyBuffersForWorkspace("C:\\Repo", [
+      {
+        path: "src\\App.tsx",
+        content: "dirty",
+        savedContent: "saved",
+      },
+    ]);
+
+    expect(getDirtyFileTextForWindow("c:/repo/src/app.tsx")).toBe("dirty");
+    expect(getDirtyFileTextForWindow("/C:/Repo/src/App.tsx")).toBe("dirty");
+    clearDirtyBuffersForWorkspace("c:/repo");
+    expect(getDirtyFileTextForWindow("C:\\Repo\\src\\App.tsx")).toBeUndefined();
+  });
+
+  it("keeps clean buffers out of the dirty map", () => {
+    replaceDirtyBuffersForWorkspace("/repo", [
+      {
+        path: "src/App.tsx",
+        content: "same",
+        savedContent: "same",
+      },
+    ]);
+
+    expect(getDirtyFileTextForWindow("/repo/src/App.tsx")).toBeUndefined();
+  });
+});
diff --git a/apps/desktop/src/renderer/lib/dirtyWorkspaceBuffers.ts b/apps/desktop/src/renderer/lib/dirtyWorkspaceBuffers.ts
index dccaf5e69..9f586e43e 100644
--- a/apps/desktop/src/renderer/lib/dirtyWorkspaceBuffers.ts
+++ b/apps/desktop/src/renderer/lib/dirtyWorkspaceBuffers.ts
@@ -1,16 +1,43 @@
-import path from "path-browserify";
-
 /**
  * In-memory map of absolute file path → unsaved editor text for workspace file UIs.
  * The main process reads this via `window.__ADE_GET_DIRTY_FILE_TEXT__` during Cursor ACP reads.
  */
 const dirtyByAbsPath = new Map<string, string>();
 
+function isWindowsAbsolutePath(value: string): boolean {
+  return /^\/?[a-z]:\//i.test(value) || value.startsWith("//");
+}
+
+function isAbsolutePath(value: string): boolean {
+  return value.startsWith("/") || isWindowsAbsolutePath(value);
+}
+
+function trimTrailingSlash(value: string): string {
+  if (/^[a-z]:\/$/i.test(value) || value === "/" || value === "//") return value;
+  return value.replace(/\/+$/g, "");
+}
+
+function normalizeDirtyPath(value: string): string {
+  const slashNormalized = value.trim().replace(/\\/g, "/");
+  const collapsed = slashNormalized.startsWith("//")
+    ? `//${slashNormalized.slice(2).replace(/\/+/g, "/")}`
+    : slashNormalized.replace(/\/+/g, "/");
+  const drivePrefixNormalized = collapsed.replace(/^\/([a-z]:)(?=\/|$)/i, "$1");
+  const trimmed = trimTrailingSlash(drivePrefixNormalized);
+  return isWindowsAbsolutePath(trimmed) ? trimmed.toLowerCase() : trimmed;
+}
+
+function joinDirtyPath(rootPath: string, relativePath: string): string {
+  const root = trimTrailingSlash(rootPath.replace(/\\/g, "/"));
+  const rel = relativePath.replace(/\\/g, "/").replace(/^\/+/g, "");
+  return normalizeDirtyPath(`${root}/${rel}`);
+}
+
 function clearWorkspaceEntries(rootPath: string): void {
-  const rootNorm = path.normalize(rootPath);
-  const prefix = rootNorm.endsWith(path.sep) ? rootNorm : `${rootNorm}${path.sep}`;
+  const rootNorm = normalizeDirtyPath(rootPath);
+  const prefix = rootNorm.endsWith("/") ? rootNorm : `${rootNorm}/`;
   for (const key of [...dirtyByAbsPath.keys()]) {
-    const kn = path.normalize(key);
+    const kn = normalizeDirtyPath(key);
     if (kn === rootNorm || kn.startsWith(prefix)) {
       dirtyByAbsPath.delete(key);
     }
@@ -24,12 +51,12 @@ export function replaceDirtyBuffersForWorkspace(
   rootPath: string,
   tabs: ReadonlyArray<{ path: string; content: string; savedContent: string }>,
 ): void {
-  const rootNorm = path.normalize(rootPath);
+  const rootNorm = normalizeDirtyPath(rootPath);
   clearWorkspaceEntries(rootNorm);
   for (const tab of tabs) {
-    const abs = path.isAbsolute(tab.path)
-      ? path.normalize(tab.path)
-      : path.normalize(path.join(rootNorm, tab.path));
+    const abs = isAbsolutePath(tab.path)
+      ? normalizeDirtyPath(tab.path)
+      : joinDirtyPath(rootNorm, tab.path);
     if (tab.content !== tab.savedContent) {
       dirtyByAbsPath.set(abs, tab.content);
     }
@@ -42,6 +69,6 @@ export function clearDirtyBuffersForWorkspace(rootPath: string): void {
 
 /** Called from main via executeJavaScript — must stay synchronous. */
 export function getDirtyFileTextForWindow(absPath: string): string | undefined {
-  const n = path.normalize(absPath.trim());
+  const n = normalizeDirtyPath(absPath);
   return dirtyByAbsPath.get(n);
 }
diff --git a/apps/desktop/src/renderer/lib/pathUtils.test.ts b/apps/desktop/src/renderer/lib/pathUtils.test.ts
new file mode 100644
index 000000000..608ce450c
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/pathUtils.test.ts
@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+import {
+  isPathEqualOrDescendant,
+  normalizePath,
+  normalizePathForComparison,
+  remapPathForRename,
+} from "./pathUtils";
+
+describe("pathUtils", () => {
+  it("preserves Windows drive roots while normalizing separators", () => {
+    expect(normalizePath("C:\\")).toBe("C:/");
+    expect(normalizePath("/C:/Users/me/repo")).toBe("C:/Users/me/repo");
+    expect(normalizePath("C:\\Users\\me\\repo\\")).toBe("C:/Users/me/repo");
+  });
+
+  it("compares Windows paths case-insensitively", () => {
+    expect(normalizePathForComparison("C:\\Users\\Me\\Repo")).toBe("c:/users/me/repo");
+    expect(isPathEqualOrDescendant("c:/users/me/repo/src/main.ts", "C:\\Users\\Me\\Repo")).toBe(true);
+  });
+
+  it("remaps renamed Windows descendants without dropping the drive root", () => {
+    expect(remapPathForRename("C:/Users/Me/Repo/src/main.ts", "c:/users/me/repo", "D:/Work/Repo")).toBe(
+      "D:/Work/Repo/src/main.ts",
+    );
+  });
+});
diff --git a/apps/desktop/src/renderer/lib/pathUtils.ts b/apps/desktop/src/renderer/lib/pathUtils.ts
new file mode 100644
index 000000000..93f4a58ff
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/pathUtils.ts
@@ -0,0 +1,75 @@
+function normalizeSeparators(value: string): string {
+  return value.replace(/\\/g, "/");
+}
+
+function isWindowsDriveRoot(value: string): boolean {
+  return /^[A-Za-z]:\/$/.test(value);
+}
+
+function isWindowsUncRoot(value: string): boolean {
+  return /^\/\/[^/]+\/[^/]+$/.test(value);
+}
+
+function isRootPath(value: string): boolean {
+  return value === "/" || isWindowsDriveRoot(value) || isWindowsUncRoot(value);
+}
+
+export function isWindowsDrivePath(value: string): boolean {
+  const trimmed = value.trim();
+  return /^\/?[A-Za-z]:[\\/]/.test(trimmed) || /^[A-Za-z]:$/.test(trimmed);
+}
+
+export function isWindowsUncPath(value: string): boolean {
+  const trimmed = value.trim();
+  return /^(?:\\\\|\/\/)[^/\\]/.test(trimmed);
+}
+
+export function isWindowsAbsolutePath(value: string): boolean {
+  return isWindowsDrivePath(value) || isWindowsUncPath(value);
+}
+
+export function normalizePath(value: string): string {
+  const trimmed = normalizeSeparators(value).trim();
+  if (!trimmed.length) return "";
+
+  const collapsed = trimmed.startsWith("//")
+    ? `//${trimmed.slice(2).replace(/\/+/g, "/")}`
+    : trimmed.replace(/\/+/g, "/");
+  const normalizedDrivePrefix = collapsed.replace(/^\/([A-Za-z]:)(?=\/|$)/, "$1");
+
+  if (/^[A-Za-z]:$/.test(normalizedDrivePrefix)) return `${normalizedDrivePrefix}/`;
+  if (isRootPath(normalizedDrivePrefix)) return normalizedDrivePrefix;
+  return normalizedDrivePrefix.replace(/\/+$/g, "");
+}
+
+export function normalizePathForComparison(value: string): string {
+  const normalized = normalizePath(value);
+  return isWindowsAbsolutePath(normalized) ? normalized.toLowerCase() : normalized;
+}
+
+export function isPathEqualOrDescendant(filePath: string, rootPath: string): boolean {
+  const normalizedPath = normalizePathForComparison(filePath);
+  const normalizedRoot = normalizePathForComparison(rootPath);
+  if (!normalizedRoot) return normalizedPath.length === 0;
+  if (normalizedPath === normalizedRoot) return true;
+  return normalizedRoot.endsWith("/")
+    ? normalizedPath.startsWith(normalizedRoot)
+    : normalizedPath.startsWith(`${normalizedRoot}/`);
+}
+
+export function remapPathForRename(filePath: string, oldPath: string, newPath: string): string {
+  const normalizedPath = normalizePath(filePath);
+  const normalizedOld = normalizePath(oldPath);
+  const normalizedNew = normalizePath(newPath);
+  if (!normalizedOld || !normalizedNew) return normalizedPath;
+
+  const normalizedPathComparable = normalizePathForComparison(normalizedPath);
+  const normalizedOldComparable = normalizePathForComparison(normalizedOld);
+  if (normalizedPathComparable === normalizedOldComparable) return normalizedNew;
+
+  const prefix = normalizedOldComparable.endsWith("/")
+    ? normalizedOldComparable
+    : `${normalizedOldComparable}/`;
+  if (!normalizedPathComparable.startsWith(prefix)) return normalizedPath;
+  return `${normalizedNew}${normalizedPath.slice(normalizedOld.length)}`;
+}
diff --git a/apps/desktop/src/renderer/lib/platform.ts b/apps/desktop/src/renderer/lib/platform.ts
index 2a6a6c795..1726ee5f0 100644
--- a/apps/desktop/src/renderer/lib/platform.ts
+++ b/apps/desktop/src/renderer/lib/platform.ts
@@ -10,3 +10,4 @@ function getPlatformValue(): string {
 
 const isMac = /mac|darwin/i.test(getPlatformValue());
 export const revealLabel = isMac ? "Reveal in Finder" : "Reveal in File Explorer";
+export const modifierKeyLabel = isMac ? "Cmd" : "Ctrl";
diff --git a/apps/desktop/src/renderer/lib/shell.test.ts b/apps/desktop/src/renderer/lib/shell.test.ts
index ed53d15ed..77202814c 100644
--- a/apps/desktop/src/renderer/lib/shell.test.ts
+++ b/apps/desktop/src/renderer/lib/shell.test.ts
@@ -16,4 +16,26 @@ describe("shell helpers", () => {
     expect(argv).toEqual(["node", "-e", 'console.log("hello world")']);
     expect(parseCommandLine(commandArrayToLine(argv))).toEqual(argv);
   });
+
+  it("preserves Windows executable paths with backslashes", () => {
+    expect(parseCommandLine("C:\\Tools\\node.exe --version", { platform: "win32" })).toEqual([
+      "C:\\Tools\\node.exe",
+      "--version",
+    ]);
+  });
+
+  it("parses quoted Windows paths with spaces", () => {
+    expect(parseCommandLine('"C:\\Program Files\\nodejs\\node.exe" "C:\\repo path\\script.js"', { platform: "win32" })).toEqual([
+      "C:\\Program Files\\nodejs\\node.exe",
+      "C:\\repo path\\script.js",
+    ]);
+  });
+
+  it("round-trips Windows cmd and PowerShell commands", () => {
+    const cmd = ["cmd.exe", "/c", "npm run test"];
+    const powershell = ["powershell.exe", "-NoProfile", "-Command", "Write-Output \"ok\""];
+
+    expect(parseCommandLine(commandArrayToLine(cmd, { platform: "win32" }), { platform: "win32" })).toEqual(cmd);
+    expect(parseCommandLine(commandArrayToLine(powershell, { platform: "win32" }), { platform: "win32" })).toEqual(powershell);
+  });
 });
diff --git a/apps/desktop/src/renderer/lib/shell.ts b/apps/desktop/src/renderer/lib/shell.ts
index 8bd4a839f..0defcadd3 100644
--- a/apps/desktop/src/renderer/lib/shell.ts
+++ b/apps/desktop/src/renderer/lib/shell.ts
@@ -1,20 +1,38 @@
 /** Shared shell-quoting and command-line parsing utilities. */
 
+type ShellPlatform = NodeJS.Platform | "browser";
+
+function currentShellPlatform(): ShellPlatform {
+  if (typeof navigator !== "undefined" && /win/i.test(navigator.platform)) return "win32";
+  if (typeof process !== "undefined" && typeof process.platform === "string") return process.platform;
+  return "browser";
+}
+
+function isWindowsPlatform(platform: ShellPlatform = currentShellPlatform()): boolean {
+  return platform === "win32";
+}
+
 /** Quote a single shell argument, adding double quotes if needed. */
-export function quoteShellArg(arg: string): string {
+export function quoteShellArg(arg: string, options: { platform?: ShellPlatform } = {}): string {
   if (!arg.length) return '""';
+  if (isWindowsPlatform(options.platform)) {
+    if (/^[a-zA-Z0-9_.:@%+=,\\/-]+$/.test(arg)) return arg;
+    return `"${arg.replace(/"/g, "\\\"")}"`;
+  }
   if (/^[a-zA-Z0-9_.:@%+=,-]+$/.test(arg)) return arg;
   return `"${arg.replace(/(["\\$`])/g, "\\$1")}"`;
 }
 
 /** Join an array of command args into a shell-safe command line. */
-export function commandArrayToLine(command: string[]): string {
+export function commandArrayToLine(command: string[], options: { platform?: ShellPlatform } = {}): string {
   if (!command.length) return "";
-  return command.map(quoteShellArg).join(" ");
+  return command.map((arg) => quoteShellArg(arg, options)).join(" ");
 }
 
 /** Parse a shell-like command line into an array of arguments. */
-export function parseCommandLine(input: string): string[] {
+export function parseCommandLine(input: string, options: { platform?: ShellPlatform } = {}): string[] {
+  if (isWindowsPlatform(options.platform)) return parseWindowsCommandLine(input);
+
   const out: string[] = [];
   let current = "";
   let quote: '"' | "'" | null = null;
@@ -75,3 +93,39 @@ export function parseCommandLine(input: string): string[] {
   if (!out.length) throw new Error("Command line must not be empty");
   return out;
 }
+
+function parseWindowsCommandLine(input: string): string[] {
+  const out: string[] = [];
+  let current = "";
+  let inQuotes = false;
+
+  for (let i = 0; i < input.length; i += 1) {
+    const ch = input[i]!;
+
+    if (ch === '"') {
+      inQuotes = !inQuotes;
+      continue;
+    }
+
+    if (ch === "\\" && input[i + 1] === '"') {
+      current += '"';
+      i += 1;
+      continue;
+    }
+
+    if (!inQuotes && /\s/.test(ch)) {
+      if (current.length) {
+        out.push(current);
+        current = "";
+      }
+      continue;
+    }
+
+    current += ch;
+  }
+
+  if (inQuotes) throw new Error("Unclosed quote in command line");
+  if (current.length) out.push(current);
+  if (!out.length) throw new Error("Command line must not be empty");
+  return out;
+}
diff --git a/apps/desktop/src/renderer/onboarding/tours/filesTour.ts b/apps/desktop/src/renderer/onboarding/tours/filesTour.ts
index 885bc6ee6..51da49632 100644
--- a/apps/desktop/src/renderer/onboarding/tours/filesTour.ts
+++ b/apps/desktop/src/renderer/onboarding/tours/filesTour.ts
@@ -65,7 +65,7 @@ export const filesTour: Tour = {
     {
       target: '[data-tour="files.openIn"]',
       title: "Open in external editor",
-      body: "Send the active file straight to VS Code, Cursor, Zed, or Finder without leaving ADE.",
+      body: "Send the active file straight to VS Code, Cursor, Zed, or the system file browser without leaving ADE.",
       docUrl: docs.filesEditor,
       placement: "bottom",
     },
diff --git a/apps/desktop/src/shared/adeLayout.ts b/apps/desktop/src/shared/adeLayout.ts
index 3d6aceaea..7f5cdf520 100644
--- a/apps/desktop/src/shared/adeLayout.ts
+++ b/apps/desktop/src/shared/adeLayout.ts
@@ -1,4 +1,5 @@
 import path from "node:path";
+import { resolveAdeMcpIpcPath } from "./adeMcpIpc";
 
 export type AdePathEntryDefinition = {
   relativePath: string;
@@ -113,7 +114,7 @@ export function resolveAdeLayout(projectRoot: string): AdeLayoutPaths {
     secretsDir,
     dbPath: path.join(adeDir, "ade.db"),
     embeddingsPath: path.join(adeDir, "embeddings.db"),
-    socketPath: path.join(adeDir, "ade.sock"),
+    socketPath: resolveAdeMcpIpcPath(projectRoot),
     apiKeysPath: path.join(secretsDir, "api-keys.v1.bin"),
     legacyApiKeysPath: path.join(secretsDir, "api-keys.json"),
     logsDir,
diff --git a/apps/desktop/src/shared/adeMcpIpc.test.ts b/apps/desktop/src/shared/adeMcpIpc.test.ts
new file mode 100644
index 000000000..40cdd1308
--- /dev/null
+++ b/apps/desktop/src/shared/adeMcpIpc.test.ts
@@ -0,0 +1,48 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { isAdeMcpNamedPipePath, resolveAdeMcpIpcPath } from "./adeMcpIpc";
+
+const originalPlatform = process.platform;
+
+function setPlatform(value: NodeJS.Platform): void {
+  Object.defineProperty(process, "platform", {
+    value,
+    configurable: true,
+  });
+}
+
+afterEach(() => {
+  setPlatform(originalPlatform);
+});
+
+describe("resolveAdeMcpIpcPath", () => {
+  it("uses a named pipe on Windows", () => {
+    setPlatform("win32");
+    const root = "C:\\Projects\\MyRepo";
+    const resolved = resolveAdeMcpIpcPath(root);
+    expect(resolved.toLowerCase()).toMatch(/^\\\\\.\\pipe\\ade-/);
+    expect(isAdeMcpNamedPipePath(resolved)).toBe(true);
+  });
+
+  it("uses a stable pipe name for the same project root", () => {
+    setPlatform("win32");
+    const root = path.resolve("/workspace/project");
+    expect(resolveAdeMcpIpcPath(root)).toBe(resolveAdeMcpIpcPath(root));
+  });
+
+  it("uses .ade/ade.sock on Unix", () => {
+    setPlatform("linux");
+    const root = "/workspace/project";
+    expect(resolveAdeMcpIpcPath(root)).toBe(path.join(root, ".ade", "ade.sock"));
+  });
+
+  it("normalizes project root casing on Windows for pipe id", () => {
+    setPlatform("win32");
+    const a = resolveAdeMcpIpcPath("C:\\Repo");
+    const b = resolveAdeMcpIpcPath("c:\\repo");
+    expect(a).toBe(b);
+    const id = createHash("sha256").update(path.resolve("C:\\Repo").toLowerCase()).digest("hex").slice(0, 24);
+    expect(a).toBe(`\\\\.\\pipe\\ade-${id}`);
+  });
+});
diff --git a/apps/desktop/src/shared/adeMcpIpc.ts b/apps/desktop/src/shared/adeMcpIpc.ts
new file mode 100644
index 000000000..324c9e79e
--- /dev/null
+++ b/apps/desktop/src/shared/adeMcpIpc.ts
@@ -0,0 +1,18 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+
+export function isAdeMcpNamedPipePath(socketPath: string): boolean {
+  const p = socketPath.trim();
+  if (!p) return false;
+  const lower = p.toLowerCase();
+  return lower.startsWith("\\\\.\\pipe\\") || lower.startsWith("//./pipe/");
+}
+
+export function resolveAdeMcpIpcPath(projectRoot: string): string {
+  const root = path.resolve(projectRoot);
+  if (process.platform === "win32") {
+    const id = createHash("sha256").update(root.toLowerCase()).digest("hex").slice(0, 24);
+    return `\\\\.\\pipe\\ade-${id}`;
+  }
+  return path.join(root, ".ade", "ade.sock");
+}
diff --git a/apps/desktop/vendor/crsqlite/win32-x64/crsqlite.dll b/apps/desktop/vendor/crsqlite/win32-x64/crsqlite.dll
new file mode 100644
index 0000000000000000000000000000000000000000..77f85cd33629dd7dc1676f9ac7eec639873cb586
GIT binary patch
literal 1443655
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%0ANTu=jhvV+?<(_GR
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
a*KR*zEc613*i4G&p7oDoSXvy#^ZyUpLJAK6

literal 0
HcmV?d00001


From 7c95a23b5bded68e00223a60b8c77dab21d4d9fa Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Thu, 23 Apr 2026 14:54:53 -0400
Subject: [PATCH 02/11] ship: checkpoint Windows port follow-up work before
 automate/finalize

---
 .github/workflows/release-core.yml            |  87 +++-
 apps/desktop/build/icon.ico                   | Bin 0 -> 23051 bytes
 apps/desktop/package.json                     |  14 +-
 apps/desktop/scripts/ade-cli-install-path.cmd |   3 +-
 .../scripts/ade-cli-windows-wrapper.cmd       |  28 +-
 .../scripts/after-pack-runtime-fixes.cjs      |  36 +-
 .../scripts/validate-win-artifacts.mjs        | 419 ++++++++++++++-
 apps/desktop/src/main/main.ts                 |   5 +-
 .../services/ai/providerTaskRunner.test.ts    | 162 ++++++
 .../main/services/ai/providerTaskRunner.ts    |  27 +-
 .../services/ai/tools/universalTools.test.ts  |  90 ++++
 .../main/services/ai/tools/universalTools.ts  | 476 +++++++++++++++++-
 .../services/cli/windowsPackaging.test.ts     |  74 +++
 .../src/main/services/ipc/registerIpc.ts      |  12 +-
 .../orchestrator/orchestratorService.ts       |  59 ++-
 .../providerOrchestratorAdapter.ts            |  32 +-
 apps/desktop/src/preload/global.d.ts          |   2 +-
 apps/desktop/src/preload/preload.ts           |   2 +-
 .../chat/AgentChatMessageList.test.tsx        |  82 +++
 .../components/chat/AgentChatMessageList.tsx  | 127 +++--
 .../components/files/FilesPage.test.tsx       | 118 ++++-
 .../renderer/components/files/FilesPage.tsx   | 213 +++++---
 .../lib/dirtyWorkspaceBuffers.test.ts         |  15 +
 .../src/renderer/lib/dirtyWorkspaceBuffers.ts |  35 +-
 .../src/renderer/lib/pathUtils.test.ts        |  19 +
 apps/desktop/src/renderer/lib/pathUtils.ts    |  89 +++-
 apps/desktop/src/renderer/lib/shell.test.ts   |  18 +-
 apps/desktop/src/renderer/lib/shell.ts        |  22 +-
 28 files changed, 2039 insertions(+), 227 deletions(-)
 create mode 100644 apps/desktop/build/icon.ico
 create mode 100644 apps/desktop/src/main/services/ai/providerTaskRunner.test.ts
 create mode 100644 apps/desktop/src/main/services/cli/windowsPackaging.test.ts

diff --git a/.github/workflows/release-core.yml b/.github/workflows/release-core.yml
index 8f5a07158..2464170c9 100644
--- a/.github/workflows/release-core.yml
+++ b/.github/workflows/release-core.yml
@@ -38,7 +38,7 @@ jobs:
     needs: verify
     runs-on: macos-15
     concurrency:
-      group: release-${{ inputs.release_tag }}
+      group: release-${{ inputs.release_tag }}-mac
       cancel-in-progress: true
     steps:
       - uses: actions/checkout@v4
@@ -110,7 +110,6 @@ jobs:
         run: cd apps/desktop && npm run validate:mac:artifacts
 
       - name: Upload validated artifacts to workflow run
-        if: ${{ !inputs.publish }}
         uses: actions/upload-artifact@v4
         with:
           name: ade-mac-release-${{ inputs.release_tag }}
@@ -121,8 +120,79 @@ jobs:
             apps/desktop/release/latest-mac.yml
           if-no-files-found: error
 
+  build-win-release:
+    needs: verify
+    runs-on: windows-latest
+    concurrency:
+      group: release-${{ inputs.release_tag }}-win
+      cancel-in-progress: true
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.target_ref }}
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: npm
+          cache-dependency-path: |
+            apps/desktop/package-lock.json
+            apps/ade-cli/package-lock.json
+
+      - name: Install desktop dependencies
+        run: cd apps/desktop && npm ci
+
+      - name: Install ADE CLI dependencies
+        run: cd apps/ade-cli && npm ci
+
+      - name: Stamp release version
+        env:
+          ADE_RELEASE_TAG: ${{ inputs.release_tag }}
+        run: cd apps/desktop && npm run version:release
+
+      - name: Reset release output
+        shell: pwsh
+        run: |
+          Remove-Item -Recurse -Force apps/desktop/release, apps/desktop/.cache -ErrorAction SilentlyContinue
+          New-Item -ItemType Directory -Path apps/desktop/.cache | Out-Null
+
+      - name: Build and validate Windows release
+        env:
+          ELECTRON_CACHE: ${{ github.workspace }}\apps\desktop\.cache\electron
+          ELECTRON_BUILDER_CACHE: ${{ github.workspace }}\apps\desktop\.cache\electron-builder
+        run: cd apps/desktop && npm run dist:win
+
+      - name: Upload validated Windows artifacts to workflow run
+        uses: actions/upload-artifact@v4
+        with:
+          name: ade-win-release-${{ inputs.release_tag }}
+          path: |
+            apps/desktop/release/*.exe
+            apps/desktop/release/*.exe.blockmap
+            apps/desktop/release/latest.yml
+          if-no-files-found: error
+
+  publish-release:
+    if: ${{ inputs.publish }}
+    needs:
+      - build-mac-release
+      - build-win-release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download macOS release artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: ade-mac-release-${{ inputs.release_tag }}
+          path: release-assets/mac
+
+      - name: Download Windows release artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: ade-win-release-${{ inputs.release_tag }}
+          path: release-assets/win
+
       - name: Create or update draft GitHub release
-        if: ${{ inputs.publish }}
         env:
           GH_TOKEN: ${{ github.token }}
           TAG_NAME: ${{ inputs.release_tag }}
@@ -130,10 +200,13 @@ jobs:
         run: |
           shopt -s nullglob
           files=(
-            apps/desktop/release/*.dmg
-            apps/desktop/release/*.zip
-            apps/desktop/release/*-mac.zip.blockmap
-            apps/desktop/release/latest-mac.yml
+            release-assets/mac/*.dmg
+            release-assets/mac/*.zip
+            release-assets/mac/*-mac.zip.blockmap
+            release-assets/mac/latest-mac.yml
+            release-assets/win/*.exe
+            release-assets/win/*.exe.blockmap
+            release-assets/win/latest.yml
           )
 
           if [ "${#files[@]}" -eq 0 ]; then
diff --git a/apps/desktop/build/icon.ico b/apps/desktop/build/icon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..67664f895ce6be3e0933db57b304b20290067540
GIT binary patch
literal 23051
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

literal 0
HcmV?d00001

diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index d83d3aad7..27ee8ba22 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -11,7 +11,7 @@
     "prebuild": "node ./scripts/normalize-runtime-binaries.cjs && npm run ade:build",
     "dev": "node ./scripts/ensure-electron.cjs && node ./scripts/dev.cjs",
     "build": "tsup && vite build",
-    "dist:win": "npm run validate:win:artifacts && npm run build && electron-builder --win --x64 --publish never",
+    "dist:win": "npm run validate:win:artifacts && npm run build && electron-builder --win --x64 --publish never && npm run validate:win:release",
     "dist:mac": "npm run build && electron-builder --mac --publish never",
     "dist:mac:dir": "npm run build && electron-builder --dir --mac --publish never -c.mac.identity=null -c.mac.notarize=false",
     "dist:mac:signed": "node ./scripts/require-macos-release-secrets.cjs && npm run build && electron-builder --mac --publish never",
@@ -20,7 +20,8 @@
     "dist:mac:universal:signed:zip": "node ./scripts/require-macos-release-secrets.cjs && npm run build && electron-builder --mac zip --universal --publish never",
     "notarize:mac:dmg": "node ./scripts/notarize-mac-dmg.mjs",
     "validate:mac:artifacts": "node ./scripts/validate-mac-artifacts.mjs",
-    "validate:win:artifacts": "node ./scripts/validate-win-artifacts.mjs",
+    "validate:win:artifacts": "node ./scripts/validate-win-artifacts.mjs --mode=preflight",
+    "validate:win:release": "node ./scripts/validate-win-artifacts.mjs --mode=release",
     "release:mac:local": "node ./scripts/release-mac-local.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
@@ -148,6 +149,7 @@
     "asarUnpack": [
       "dist/main/packagedRuntimeSmoke.cjs",
       "node_modules/node-pty/**/*",
+      "node_modules/sql.js/**/*",
       "node_modules/@huggingface/transformers/node_modules/onnxruntime-node/**",
       "vendor/crsqlite/**"
     ],
@@ -188,8 +190,14 @@
     "npmRebuild": false,
     "win": {
       "target": [
-        "nsis"
+        {
+          "target": "nsis",
+          "arch": [
+            "x64"
+          ]
+        }
       ],
+      "icon": "build/icon.ico",
       "artifactName": "${productName}-${version}-win-${arch}.${ext}"
     },
     "mac": {
diff --git a/apps/desktop/scripts/ade-cli-install-path.cmd b/apps/desktop/scripts/ade-cli-install-path.cmd
index 7a7ef8ed2..351cf879b 100644
--- a/apps/desktop/scripts/ade-cli-install-path.cmd
+++ b/apps/desktop/scripts/ade-cli-install-path.cmd
@@ -24,7 +24,8 @@ if not exist "%TARGET_DIR%" mkdir "%TARGET_DIR%" >nul 2>nul
 
 (
   echo @echo off
-  echo "%ADE_BIN%" %%*
+  echo call "%ADE_BIN%" %%*
+  echo exit /b %%ERRORLEVEL%%
 ) > "%TARGET_PATH%"
 
 if errorlevel 1 (
diff --git a/apps/desktop/scripts/ade-cli-windows-wrapper.cmd b/apps/desktop/scripts/ade-cli-windows-wrapper.cmd
index 2d1dc0cc3..ab9ea10cc 100644
--- a/apps/desktop/scripts/ade-cli-windows-wrapper.cmd
+++ b/apps/desktop/scripts/ade-cli-windows-wrapper.cmd
@@ -5,20 +5,25 @@ set "SCRIPT_DIR=%~dp0"
 set "CLI_JS=%ADE_CLI_JS%"
 if "%CLI_JS%"=="" set "CLI_JS=%SCRIPT_DIR%..\cli.cjs"
 
+set "RESOURCES_DIR=%SCRIPT_DIR%..\.."
+set "APP_EXE=%RESOURCES_DIR%\..\ADE.exe"
+set "NODE_PATH_VALUE=%RESOURCES_DIR%\app.asar.unpacked\node_modules;%RESOURCES_DIR%\app.asar\node_modules"
+if defined NODE_PATH (
+  if defined NODE_PATH_VALUE (
+    set "NODE_PATH_VALUE=%NODE_PATH_VALUE%;%NODE_PATH%"
+  ) else (
+    set "NODE_PATH_VALUE=%NODE_PATH%"
+  )
+)
+
 if defined ADE_CLI_NODE (
-  "%ADE_CLI_NODE%" "%CLI_JS%" %*
+  call :run_with_runtime_env "%ADE_CLI_NODE%" "%CLI_JS%" %*
   exit /b %ERRORLEVEL%
 )
 
-set "RESOURCES_DIR=%SCRIPT_DIR%..\.."
-set "APP_EXE=%RESOURCES_DIR%\..\ADE.exe"
-
 if exist "%APP_EXE%" (
-  set "NODE_PATH_VALUE=%RESOURCES_DIR%\app.asar.unpacked\node_modules;%RESOURCES_DIR%\app.asar\node_modules"
-  if defined NODE_PATH set "NODE_PATH_VALUE=%NODE_PATH_VALUE%;%NODE_PATH%"
   set "ELECTRON_RUN_AS_NODE=1"
-  set "NODE_PATH=%NODE_PATH_VALUE%"
-  "%APP_EXE%" "%CLI_JS%" %*
+  call :run_with_runtime_env "%APP_EXE%" "%CLI_JS%" %*
   exit /b %ERRORLEVEL%
 )
 
@@ -26,10 +31,15 @@ where node >nul 2>nul
 if not errorlevel 1 (
   node -e "process.exit(Number(process.versions.node.split('.')[0]) >= 22 ? 0 : 1)" >nul 2>nul
   if not errorlevel 1 (
-    node "%CLI_JS%" %*
+    call :run_with_runtime_env node "%CLI_JS%" %*
     exit /b %ERRORLEVEL%
   )
 )
 
 echo ade: Node.js 22+ or the packaged ADE.exe runtime is required to run this CLI. 1>&2
 exit /b 127
+
+:run_with_runtime_env
+if defined NODE_PATH_VALUE set "NODE_PATH=%NODE_PATH_VALUE%"
+%*
+exit /b %ERRORLEVEL%
diff --git a/apps/desktop/scripts/after-pack-runtime-fixes.cjs b/apps/desktop/scripts/after-pack-runtime-fixes.cjs
index 9315f57a9..c80ae03d1 100644
--- a/apps/desktop/scripts/after-pack-runtime-fixes.cjs
+++ b/apps/desktop/scripts/after-pack-runtime-fixes.cjs
@@ -34,6 +34,7 @@ function requireFile(filePath, label) {
 }
 
 module.exports = async function afterPack(context) {
+  const platform = context?.electronPlatformName;
   const { runtimeRoot, appBundlePath } = resolveUnpackedRuntimeRoot(context);
   if (!fs.existsSync(runtimeRoot)) {
     throw new Error(`[afterPack] Missing unpacked runtime payload: ${runtimeRoot}`);
@@ -43,25 +44,34 @@ module.exports = async function afterPack(context) {
   const bundledCliPath = path.join(resourcesRoot, "ade-cli", "cli.cjs");
   requireFile(bundledCliPath, "bundled ADE CLI entry");
 
-  const bundledCliBinPath = path.join(resourcesRoot, "ade-cli", "bin", "ade");
-  const bundledCliInstallerPath = path.join(resourcesRoot, "ade-cli", "install-path.sh");
-  requireFile(bundledCliBinPath, "bundled ADE CLI wrapper");
-  requireFile(bundledCliInstallerPath, "bundled ADE CLI PATH installer");
-  requireFile(path.join(resourcesRoot, "ade-cli", "bin", "ade.cmd"), "bundled ADE CLI Windows wrapper");
-  requireFile(path.join(resourcesRoot, "ade-cli", "install-path.cmd"), "bundled ADE CLI Windows PATH installer");
-  fs.chmodSync(bundledCliBinPath, 0o755);
-  fs.chmodSync(bundledCliInstallerPath, 0o755);
+  if (platform === "darwin") {
+    const bundledCliBinPath = path.join(resourcesRoot, "ade-cli", "bin", "ade");
+    const bundledCliInstallerPath = path.join(resourcesRoot, "ade-cli", "install-path.sh");
+    requireFile(bundledCliBinPath, "bundled ADE CLI wrapper");
+    requireFile(bundledCliInstallerPath, "bundled ADE CLI PATH installer");
+    fs.chmodSync(bundledCliBinPath, 0o755);
+    fs.chmodSync(bundledCliInstallerPath, 0o755);
+  } else if (platform === "win32") {
+    requireFile(path.join(resourcesRoot, "ade-cli", "bin", "ade.cmd"), "bundled ADE CLI Windows wrapper");
+    requireFile(path.join(resourcesRoot, "ade-cli", "install-path.cmd"), "bundled ADE CLI Windows PATH installer");
+  } else {
+    requireFile(path.join(resourcesRoot, "ade-cli", "bin", "ade"), "bundled ADE CLI wrapper");
+    requireFile(path.join(resourcesRoot, "ade-cli", "install-path.sh"), "bundled ADE CLI PATH installer");
+    requireFile(path.join(resourcesRoot, "ade-cli", "bin", "ade.cmd"), "bundled ADE CLI Windows wrapper");
+    requireFile(path.join(resourcesRoot, "ade-cli", "install-path.cmd"), "bundled ADE CLI Windows PATH installer");
+  }
 
   const normalized = normalizeDesktopRuntimeBinaries(runtimeRoot);
   for (const entry of normalized) {
     console.log(`[afterPack] Restored executable mode: ${entry.label} -> ${path.relative(runtimeRoot, entry.filePath)}`);
   }
 
-  const requiredScripts = [
-    path.join(runtimeRoot, "dist", "main", "packagedRuntimeSmoke.cjs"),
-    path.join(runtimeRoot, "vendor", "crsqlite", "darwin-arm64", "crsqlite.dylib"),
-    path.join(runtimeRoot, "vendor", "crsqlite", "win32-x64", "crsqlite.dll"),
-  ];
+  const requiredScripts = [path.join(runtimeRoot, "dist", "main", "packagedRuntimeSmoke.cjs")];
+  if (platform === "darwin") {
+    requiredScripts.push(path.join(runtimeRoot, "vendor", "crsqlite", "darwin-arm64", "crsqlite.dylib"));
+  } else if (platform === "win32") {
+    requiredScripts.push(path.join(runtimeRoot, "vendor", "crsqlite", "win32-x64", "crsqlite.dll"));
+  }
 
   for (const scriptPath of requiredScripts) {
     if (!fs.existsSync(scriptPath)) {
diff --git a/apps/desktop/scripts/validate-win-artifacts.mjs b/apps/desktop/scripts/validate-win-artifacts.mjs
index a0b50a32a..c70b6e854 100644
--- a/apps/desktop/scripts/validate-win-artifacts.mjs
+++ b/apps/desktop/scripts/validate-win-artifacts.mjs
@@ -1,15 +1,46 @@
 import fs from "node:fs";
+import fsp from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
+import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { parse as parseYaml } from "yaml";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const desktopRoot = path.resolve(__dirname, "..");
 const packageJsonPath = path.join(desktopRoot, "package.json");
 const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+const productName = pkg.build?.productName ?? pkg.productName ?? "ADE";
+
+function readFlag(name) {
+  const prefix = `${name}=`;
+  for (const arg of process.argv.slice(2)) {
+    if (arg.startsWith(prefix)) {
+      return arg.slice(prefix.length).trim();
+    }
+  }
+  return null;
+}
+
+function hasFlag(name) {
+  return process.argv.slice(2).includes(name);
+}
+
+function resolveAbsolute(input) {
+  if (!input) return null;
+  return path.isAbsolute(input) ? input : path.resolve(desktopRoot, input);
+}
 
 function fail(message) {
-  console.error(`[validate-win-artifacts] ${message}`);
-  process.exitCode = 1;
+  throw new Error(`[validate-win-artifacts] ${message}`);
+}
+
+async function assertPathExists(targetPath, description) {
+  try {
+    await fsp.access(targetPath);
+  } catch {
+    fail(`Missing ${description}: ${targetPath}`);
+  }
 }
 
 function requireFile(relativePath, label) {
@@ -24,28 +55,380 @@ function hasExtraResource(to) {
     && pkg.build.extraResources.some((entry) => entry && entry.to === to);
 }
 
-requireFile("scripts/ade-cli-windows-wrapper.cmd", "Windows ADE CLI wrapper");
-requireFile("scripts/ade-cli-install-path.cmd", "Windows ADE CLI PATH installer");
-requireFile("vendor/crsqlite/win32-x64/crsqlite.dll", "Windows cr-sqlite extension");
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function parseWinTargets() {
+  const targets = pkg.build?.win?.target;
+  if (!Array.isArray(targets)) return [];
+  return targets.map((entry) => {
+    if (typeof entry === "string") {
+      return { target: entry, arch: [] };
+    }
+    const arch = Array.isArray(entry?.arch)
+      ? entry.arch.filter(Boolean)
+      : entry?.arch
+        ? [entry.arch]
+        : [];
+    return {
+      target: entry?.target ?? null,
+      arch,
+    };
+  });
+}
+
+function validatePreflight() {
+  requireFile("build/icon.ico", "Windows app icon");
+  requireFile("scripts/ade-cli-windows-wrapper.cmd", "Windows ADE CLI wrapper");
+  requireFile("scripts/ade-cli-install-path.cmd", "Windows ADE CLI PATH installer");
+  requireFile("vendor/crsqlite/win32-x64/crsqlite.dll", "Windows cr-sqlite extension");
+
+  if (!hasExtraResource("ade-cli/bin/ade.cmd")) {
+    fail("package.json build.extraResources must ship ade-cli/bin/ade.cmd");
+  }
+  if (!hasExtraResource("ade-cli/install-path.cmd")) {
+    fail("package.json build.extraResources must ship ade-cli/install-path.cmd");
+  }
+  if (!Array.isArray(pkg.build?.asarUnpack) || !pkg.build.asarUnpack.includes("vendor/crsqlite/**")) {
+    fail("package.json build.asarUnpack must unpack vendor/crsqlite/**");
+  }
+  if (!Array.isArray(pkg.build?.asarUnpack) || !pkg.build.asarUnpack.includes("node_modules/sql.js/**/*")) {
+    fail("package.json build.asarUnpack must unpack node_modules/sql.js/**/* for the plain node fallback");
+  }
+  if (pkg.build?.win?.icon !== "build/icon.ico") {
+    fail("package.json build.win.icon must point to build/icon.ico");
+  }
+
+  const winTargets = parseWinTargets();
+  if (winTargets.length === 0) {
+    fail("package.json build.win.target must define at least one Windows target");
+  }
+  if (!winTargets.every((entry) => entry.target === "nsis" && entry.arch.length === 1 && entry.arch[0] === "x64")) {
+    fail("package.json build.win.target must pin NSIS to x64 until a Windows ARM64 cr-sqlite binary is bundled");
+  }
+
+  if (typeof pkg.scripts?.["dist:win"] !== "string" || !/\s--x64(?:\s|$)/.test(pkg.scripts["dist:win"])) {
+    fail("package.json scripts.dist:win must pass --x64 until a Windows ARM64 cr-sqlite binary is bundled");
+  }
+  if (typeof pkg.scripts?.["dist:win"] !== "string" || !pkg.scripts["dist:win"].includes("validate:win:release")) {
+    fail("package.json scripts.dist:win must validate the packaged Windows release output");
+  }
+
+  console.log("[validate-win-artifacts] Windows package inputs are present.");
+}
+
+async function findArtifact(releaseDir, regex, description) {
+  const entries = await fsp.readdir(releaseDir, { withFileTypes: true });
+  const matches = entries
+    .filter((entry) => entry.isFile() && regex.test(entry.name))
+    .map((entry) => path.join(releaseDir, entry.name))
+    .sort();
 
-if (!hasExtraResource("ade-cli/bin/ade.cmd")) {
-  fail("package.json build.extraResources must ship ade-cli/bin/ade.cmd");
+  if (matches.length === 0) {
+    fail(`Unable to find ${description} in ${releaseDir}`);
+  }
+  if (matches.length > 1) {
+    fail(
+      `Found multiple ${description} artifacts in ${releaseDir}: ${matches
+        .map((filePath) => path.basename(filePath))
+        .join(", ")}`,
+    );
+  }
+
+  return matches[0];
 }
-if (!hasExtraResource("ade-cli/install-path.cmd")) {
-  fail("package.json build.extraResources must ship ade-cli/install-path.cmd");
+
+function collectLatestReferencedFiles(latest) {
+  return new Set(
+    [
+      latest?.path,
+      ...(Array.isArray(latest?.files)
+        ? latest.files.map((file) => file?.url ?? file?.path ?? null)
+        : []),
+    ].filter(Boolean),
+  );
 }
-if (!Array.isArray(pkg.build?.win?.target) || pkg.build.win.target.length === 0) {
-  fail("package.json build.win.target must define at least one Windows target");
+
+async function validateLatestYaml(latestPath, installerPath) {
+  await assertPathExists(latestPath, "latest.yml");
+  const latest = parseYaml(await fsp.readFile(latestPath, "utf8"));
+  const expectedInstallerName = path.basename(installerPath);
+  const referencedFiles = collectLatestReferencedFiles(latest);
+
+  if (!referencedFiles.has(expectedInstallerName)) {
+    fail(
+      `latest.yml does not reference ${expectedInstallerName}. ` +
+        `Referenced entries: ${Array.from(referencedFiles).join(", ") || "none"}`,
+    );
+  }
+
+  const hasSha512 =
+    Boolean(latest?.sha512) ||
+    (Array.isArray(latest?.files) && latest.files.some((file) => Boolean(file?.sha512)));
+  if (!hasSha512) {
+    fail("latest.yml is missing sha512 metadata for the installer artifact");
+  }
 }
-if (typeof pkg.scripts?.["dist:win"] !== "string" || !/\s--x64(?:\s|$)/.test(pkg.scripts["dist:win"])) {
-  fail("package.json scripts.dist:win must pass --x64 until a Windows ARM64 cr-sqlite binary is bundled");
+
+function createCommandError(command, args, status, stdout, stderr) {
+  const rendered = [command, ...args].join(" ");
+  const details = [stdout.trim(), stderr.trim()].filter(Boolean).join("\n");
+  return new Error(
+    `[validate-win-artifacts] Command failed (${status ?? "null"}): ${rendered}` +
+      (details ? `\n${details}` : ""),
+  );
 }
-if (!Array.isArray(pkg.build?.asarUnpack) || !pkg.build.asarUnpack.includes("vendor/crsqlite/**")) {
-  fail("package.json build.asarUnpack must unpack vendor/crsqlite/**");
+
+function runCommand(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const useShell = process.platform === "win32" && /\.(?:cmd|bat)$/i.test(command);
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      shell: useShell,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+
+    child.on("error", reject);
+    child.on("close", (status) => {
+      if (status === 0) {
+        resolve({ stdout, stderr });
+        return;
+      }
+      reject(createCommandError(command, args, status, stdout, stderr));
+    });
+  });
 }
 
-if (process.exitCode) {
-  process.exit(process.exitCode);
+async function findFirstNodeAddon(rootPath) {
+  const entries = await fsp.readdir(rootPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const entryPath = path.join(rootPath, entry.name);
+    if (entry.isDirectory()) {
+      const nestedMatch = await findFirstNodeAddon(entryPath);
+      if (nestedMatch) return nestedMatch;
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(".node")) {
+      return entryPath;
+    }
+  }
+
+  return null;
 }
 
-console.log("[validate-win-artifacts] Windows package inputs are present.");
+async function findNodePtyAddon(moduleRootPath) {
+  const candidateRoots = [
+    path.join(moduleRootPath, "build", "Release"),
+    path.join(moduleRootPath, "build", "Debug"),
+  ];
+
+  try {
+    const prebuildRoot = path.join(moduleRootPath, "prebuilds");
+    const prebuildDirs = await fsp.readdir(prebuildRoot, { withFileTypes: true });
+    for (const entry of prebuildDirs) {
+      if (entry.isDirectory()) candidateRoots.push(path.join(prebuildRoot, entry.name));
+    }
+  } catch {
+    // Keep the explicit candidate roots only.
+  }
+
+  for (const candidateRoot of candidateRoots) {
+    try {
+      await fsp.access(candidateRoot);
+    } catch {
+      continue;
+    }
+
+    const addonPath = await findFirstNodeAddon(candidateRoot);
+    if (addonPath) {
+      return addonPath;
+    }
+  }
+
+  return null;
+}
+
+function createNodePathValue(paths, options = {}) {
+  return paths.filter((entry) => options.includeMissing || fs.existsSync(entry)).join(";");
+}
+
+function assertAdeCliHelp(stdout, label) {
+  if (!stdout.includes("Agent-focused command-line interface for ADE")) {
+    fail(`${label} did not print ADE CLI help`);
+  }
+}
+
+async function validatePackagedRuntime(appDir) {
+  const appExe = path.join(appDir, `${productName}.exe`);
+  const resourcesPath = path.join(appDir, "resources");
+  const appAsarPath = path.join(resourcesPath, "app.asar");
+  const unpackedPath = path.join(resourcesPath, "app.asar.unpacked");
+  const adeCliPath = path.join(resourcesPath, "ade-cli", "cli.cjs");
+  const adeCliBinPath = path.join(resourcesPath, "ade-cli", "bin", "ade.cmd");
+  const adeCliInstallerPath = path.join(resourcesPath, "ade-cli", "install-path.cmd");
+  const nodeModulesPath = path.join(unpackedPath, "node_modules");
+  const nodePtyModulePath = path.join(nodeModulesPath, "node-pty");
+  const sqlJsModulePath = path.join(nodeModulesPath, "sql.js");
+  const smokeScriptPath = path.join(unpackedPath, "dist", "main", "packagedRuntimeSmoke.cjs");
+  const crsqliteDllPath = path.join(unpackedPath, "vendor", "crsqlite", "win32-x64", "crsqlite.dll");
+
+  await assertPathExists(appExe, "packaged Windows app executable");
+  await assertPathExists(appAsarPath, "app.asar payload");
+  await assertPathExists(unpackedPath, "app.asar.unpacked runtime payload");
+  await assertPathExists(adeCliPath, "bundled ADE CLI entry");
+  await assertPathExists(adeCliBinPath, "bundled ADE CLI wrapper");
+  await assertPathExists(adeCliInstallerPath, "bundled ADE CLI PATH installer");
+  await assertPathExists(nodePtyModulePath, "unpacked node-pty module");
+  await assertPathExists(sqlJsModulePath, "unpacked sql.js module");
+  await assertPathExists(smokeScriptPath, "unpacked packaged runtime smoke script");
+  await assertPathExists(crsqliteDllPath, "unpacked Windows cr-sqlite extension");
+
+  const nodePtyAddon = await findNodePtyAddon(nodePtyModulePath);
+  if (!nodePtyAddon) {
+    fail(`Missing node-pty native addon under ${nodePtyModulePath}`);
+  }
+
+  if (process.platform !== "win32" || hasFlag("--skip-live-runtime")) {
+    console.log("[validate-win-artifacts] Skipping live Windows runtime validation on this host.");
+    return;
+  }
+
+  const runtimeNodePath = createNodePathValue([
+    path.join(resourcesPath, "app.asar.unpacked", "node_modules"),
+    path.join(resourcesPath, "app.asar", "node_modules"),
+  ], { includeMissing: true });
+
+  const { stdout: smokeStdout } = await runCommand(appExe, [smokeScriptPath], {
+    cwd: unpackedPath,
+    env: {
+      ...process.env,
+      ELECTRON_RUN_AS_NODE: "1",
+      NODE_PATH: runtimeNodePath,
+    },
+  });
+
+  const payload = JSON.parse(smokeStdout.trim());
+  if (payload?.nodePty !== "function") {
+    fail(`Packaged smoke expected node-pty.spawn to be a function, got ${String(payload?.nodePty)}`);
+  }
+  if (!payload?.ptyProbe?.ok) {
+    fail("Packaged smoke failed to execute a PTY probe");
+  }
+  if (payload?.claudeQuery !== "function") {
+    fail(`Packaged smoke expected Claude SDK query() to be available, got ${String(payload?.claudeQuery)}`);
+  }
+  if (typeof payload?.claudeExecutablePath !== "string" || payload.claudeExecutablePath.trim().length === 0) {
+    fail("Packaged smoke did not report a Claude executable path");
+  }
+  if (!payload?.claudeStartup || typeof payload.claudeStartup !== "object") {
+    fail("Packaged smoke did not report a Claude startup result");
+  }
+  if (payload.claudeStartup.state === "binary-missing") {
+    console.warn("[validate-win-artifacts] Claude CLI is not installed on this machine; skipping live Claude startup check.");
+  } else if (payload.claudeStartup.state === "runtime-failed") {
+    fail(`Packaged smoke could not start Claude from the packaged app: ${String(payload.claudeStartup.message || "unknown error")}`);
+  }
+  if (payload?.codexExecutable !== "function") {
+    fail(`Packaged smoke expected Codex executable resolver to be available, got ${String(payload?.codexExecutable)}`);
+  }
+
+  const defaultHelp = await runCommand(adeCliBinPath, ["--help"], {
+    cwd: resourcesPath,
+    env: { ...process.env },
+  });
+  assertAdeCliHelp(defaultHelp.stdout, "Bundled ADE CLI wrapper");
+
+  const nodeOverrideHelp = await runCommand(adeCliBinPath, ["--help"], {
+    cwd: resourcesPath,
+    env: {
+      ...process.env,
+      ADE_CLI_NODE: process.execPath,
+    },
+  });
+  assertAdeCliHelp(nodeOverrideHelp.stdout, "Bundled ADE CLI wrapper with ADE_CLI_NODE");
+
+  const disabledAppExe = `${appExe}.bak`;
+  await fsp.rename(appExe, disabledAppExe);
+  try {
+    const plainNodeHelp = await runCommand(adeCliBinPath, ["--help"], {
+      cwd: resourcesPath,
+      env: { ...process.env },
+    });
+    assertAdeCliHelp(plainNodeHelp.stdout, "Bundled ADE CLI wrapper with plain node fallback");
+  } finally {
+    await fsp.rename(disabledAppExe, appExe);
+  }
+
+  const installRoot = await fsp.mkdtemp(path.join(os.tmpdir(), "ade-win-install-"));
+  const installedCommandPath = path.join(installRoot, "bin", "ade.cmd");
+  try {
+    await runCommand(adeCliInstallerPath, [installedCommandPath], {
+      cwd: resourcesPath,
+      env: {
+        ...process.env,
+        ADE_BIN: adeCliBinPath,
+      },
+    });
+    await assertPathExists(installedCommandPath, "installed ADE CLI shim");
+
+    const installedHelp = await runCommand(installedCommandPath, ["--help"], {
+      cwd: resourcesPath,
+      env: { ...process.env },
+    });
+    assertAdeCliHelp(installedHelp.stdout, "Installed ADE CLI shim");
+  } finally {
+    await fsp.rm(installRoot, { recursive: true, force: true });
+  }
+
+  console.log(`[validate-win-artifacts] Windows packaged runtime smoke passed: ${path.relative(appDir, nodePtyAddon)}`);
+}
+
+async function validateReleaseArtifacts() {
+  const releaseDir = resolveAbsolute(readFlag("--release-dir")) ?? path.join(desktopRoot, "release");
+  const installerRegex = new RegExp(`^${escapeRegExp(productName)}-.+-win-x64\\.exe$`);
+  const installerPath =
+    resolveAbsolute(readFlag("--installer")) ?? (await findArtifact(releaseDir, installerRegex, "Windows installer"));
+  const installerBlockmapPath =
+    resolveAbsolute(readFlag("--installer-blockmap")) ?? `${installerPath}.blockmap`;
+  const latestPath = resolveAbsolute(readFlag("--latest")) ?? path.join(releaseDir, "latest.yml");
+  const appDir = resolveAbsolute(readFlag("--app")) ?? path.join(releaseDir, "win-unpacked");
+
+  await assertPathExists(releaseDir, "release output directory");
+  await assertPathExists(installerPath, "Windows installer");
+  await assertPathExists(installerBlockmapPath, "Windows installer blockmap");
+  await assertPathExists(appDir, "win-unpacked app directory");
+  await validateLatestYaml(latestPath, installerPath);
+  await validatePackagedRuntime(appDir);
+
+  console.log("[validate-win-artifacts] Windows release artifacts passed updater and packaged-runtime checks.");
+}
+
+const mode = readFlag("--mode") ?? "preflight";
+
+try {
+  if (mode === "preflight") {
+    validatePreflight();
+  } else if (mode === "release") {
+    validatePreflight();
+    await validateReleaseArtifacts();
+  } else {
+    fail(`Unknown mode: ${mode}`);
+  }
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(message);
+  process.exit(1);
+}
diff --git a/apps/desktop/src/main/main.ts b/apps/desktop/src/main/main.ts
index fc953ac70..34aa9ffab 100644
--- a/apps/desktop/src/main/main.ts
+++ b/apps/desktop/src/main/main.ts
@@ -220,10 +220,13 @@ async function createWindow(args: {
 } = {}): Promise<BrowserWindow> {
   // Load the app icon from the build directory.
   const iconDir = path.join(__dirname, "../../build");
+  const icoPath = path.join(iconDir, "icon.ico");
   const pngPath = path.join(iconDir, "icon.png");
   const icnsPath = path.join(iconDir, "icon.icns");
   let icon: Electron.NativeImage;
-  if (fs.existsSync(pngPath)) {
+  if (process.platform === "win32" && fs.existsSync(icoPath)) {
+    icon = nativeImage.createFromPath(icoPath);
+  } else if (fs.existsSync(pngPath)) {
     icon = nativeImage.createFromPath(pngPath);
   } else if (fs.existsSync(icnsPath)) {
     icon = nativeImage.createFromPath(icnsPath);
diff --git a/apps/desktop/src/main/services/ai/providerTaskRunner.test.ts b/apps/desktop/src/main/services/ai/providerTaskRunner.test.ts
new file mode 100644
index 000000000..07a3f6585
--- /dev/null
+++ b/apps/desktop/src/main/services/ai/providerTaskRunner.test.ts
@@ -0,0 +1,162 @@
+import { EventEmitter } from "node:events";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type * as childProcess from "node:child_process";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const spawnMock = vi.fn();
+const resolveClaudeCodeExecutableMock = vi.fn(() => ({
+  path: "C:\\Users\\me\\AppData\\Roaming\\npm\\claude.cmd",
+  source: "path",
+}));
+const resolveCodexExecutableMock = vi.fn(() => ({
+  path: "C:\\Users\\me\\AppData\\Roaming\\npm\\codex.cmd",
+  source: "path",
+}));
+
+vi.mock("node:child_process", async () => {
+  const actual = await vi.importActual<typeof childProcess>("node:child_process");
+  return {
+    ...actual,
+    spawn: (...args: unknown[]) => spawnMock(...args),
+  };
+});
+
+vi.mock("./claudeCodeExecutable", () => ({
+  resolveClaudeCodeExecutable: () => resolveClaudeCodeExecutableMock(),
+}));
+
+vi.mock("./codexExecutable", () => ({
+  resolveCodexExecutable: () => resolveCodexExecutableMock(),
+}));
+
+import { runProviderTask } from "./providerTaskRunner";
+
+type MockSpawnProcess = EventEmitter & {
+  stdout: EventEmitter;
+  stderr: EventEmitter;
+  stdin: EventEmitter & { end: ReturnType<typeof vi.fn> };
+  kill: ReturnType<typeof vi.fn>;
+  pid: number;
+  exitCode: number | null;
+  signalCode: NodeJS.Signals | null;
+};
+
+function createMockProcess(args: {
+  stdout?: string;
+  stderr?: string;
+  exitCode?: number;
+  onStart?: () => void;
+} = {}): MockSpawnProcess {
+  const stdout = new EventEmitter();
+  const stderr = new EventEmitter();
+  const stdin = Object.assign(new EventEmitter(), {
+    end: vi.fn(),
+  });
+  const child = Object.assign(new EventEmitter(), {
+    stdout,
+    stderr,
+    stdin,
+    kill: vi.fn(),
+    pid: 1234,
+    exitCode: null,
+    signalCode: null,
+  }) as MockSpawnProcess;
+
+  queueMicrotask(() => {
+    args.onStart?.();
+    if (args.stdout) stdout.emit("data", Buffer.from(args.stdout, "utf8"));
+    if (args.stderr) stderr.emit("data", Buffer.from(args.stderr, "utf8"));
+    child.emit("close", args.exitCode ?? 0);
+  });
+
+  return child;
+}
+
+afterEach(() => {
+  spawnMock.mockReset();
+  resolveClaudeCodeExecutableMock.mockClear();
+  resolveCodexExecutableMock.mockClear();
+});
+
+describe("runProviderTask", () => {
+  it("pipes Claude prompts over stdin instead of argv", async () => {
+    const child = createMockProcess({
+      stdout: '{"result":"READY"}',
+    });
+    spawnMock.mockReturnValueOnce(child);
+
+    const result = await runProviderTask({
+      cwd: process.cwd(),
+      descriptor: {
+        family: "anthropic",
+        isCliWrapped: true,
+        providerModelId: "claude-sonnet-4-6",
+      } as any,
+      prompt: "Summarize the worktree state.",
+      feature: "unit-test",
+      projectConfig: {} as any,
+    });
+
+    expect(result.text).toBe("READY");
+    expect(spawnMock).toHaveBeenCalledTimes(1);
+    const [command, argv, options] = spawnMock.mock.calls[0]!;
+    expect(command).toBe("C:\\Users\\me\\AppData\\Roaming\\npm\\claude.cmd");
+    expect(argv).toContain("-p");
+    expect(argv).not.toContain("Summarize the worktree state.");
+    expect(options).toMatchObject({
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    expect(child.stdin.end).toHaveBeenCalledWith("Summarize the worktree state.");
+  });
+
+  it("pipes Codex prompts over stdin instead of argv", async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ade-provider-task-runner-"));
+    spawnMock.mockImplementationOnce((_command: unknown, argv: string[]) => {
+      const outputIndex = argv.indexOf("--output-last-message");
+      const outputPath = outputIndex >= 0 ? argv[outputIndex + 1] : null;
+      return createMockProcess({
+        onStart: () => {
+          if (outputPath) {
+            fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+            fs.writeFileSync(outputPath, "DONE", "utf8");
+          }
+        },
+      });
+    });
+    const mkdtempSpy = vi.spyOn(fs, "mkdtempSync").mockReturnValueOnce(tmpDir);
+
+    try {
+      const result = await runProviderTask({
+        cwd: process.cwd(),
+        descriptor: {
+          family: "openai",
+          isCliWrapped: true,
+          providerModelId: "gpt-5.3-codex",
+        } as any,
+        prompt: "Fix the Windows launcher.",
+        system: "Be concise.",
+        feature: "unit-test",
+        permissionMode: "edit",
+        projectConfig: {} as any,
+      });
+
+      expect(result.text).toBe("DONE");
+      expect(spawnMock).toHaveBeenCalledTimes(1);
+      const [command, argv, options] = spawnMock.mock.calls[0]!;
+      expect(command).toBe("C:\\Users\\me\\AppData\\Roaming\\npm\\codex.cmd");
+      expect(argv).toContain("exec");
+      expect(argv).toContain("-");
+      expect(argv).not.toContain("Fix the Windows launcher.");
+      expect(options).toMatchObject({
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      const child = spawnMock.mock.results[0]!.value as MockSpawnProcess;
+      expect(child.stdin.end).toHaveBeenCalledWith("Be concise.\n\nFix the Windows launcher.");
+    } finally {
+      mkdtempSpy.mockRestore();
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+});
diff --git a/apps/desktop/src/main/services/ai/providerTaskRunner.ts b/apps/desktop/src/main/services/ai/providerTaskRunner.ts
index 02cc996ff..9fde1ef7f 100644
--- a/apps/desktop/src/main/services/ai/providerTaskRunner.ts
+++ b/apps/desktop/src/main/services/ai/providerTaskRunner.ts
@@ -73,6 +73,7 @@ async function runCommand(args: {
   argv: string[];
   cwd: string;
   timeoutMs?: number;
+  stdinText?: string;
 }): Promise<SpawnResult> {
   return await new Promise((resolve, reject) => {
     const env = {
@@ -84,7 +85,7 @@ async function runCommand(args: {
     const child = spawn(invocation.command, invocation.args, {
       cwd: args.cwd,
       env,
-      stdio: ["ignore", "pipe", "pipe"],
+      stdio: [args.stdinText != null ? "pipe" : "ignore", "pipe", "pipe"],
       windowsVerbatimArguments: invocation.windowsVerbatimArguments,
     });
 
@@ -105,6 +106,12 @@ async function runCommand(args: {
     child.stderr?.on("data", (chunk) => {
       stderr += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
     });
+    child.stdin?.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeoutHandle);
+      reject(error);
+    });
 
     child.on("error", (error) => {
       if (settled) return;
@@ -119,6 +126,10 @@ async function runCommand(args: {
       clearTimeout(timeoutHandle);
       resolve({ stdout, stderr, exitCode });
     });
+
+    if (args.stdinText != null && child.stdin) {
+      child.stdin.end(args.stdinText);
+    }
   });
 }
 
@@ -143,7 +154,6 @@ async function runClaudeTask(args: ProviderTaskRunnerArgs): Promise<ProviderTask
   const prompt = appendStructuredOutputInstruction(args.prompt, args.jsonSchema);
   const sessionId = args.sessionId?.trim() || (args.feature === "orchestrator" ? randomUUID() : null);
   const cliArgs = [
-    "-p",
     "--model",
     resolveClaudeCliModel(args.descriptor.providerModelId),
     "--output-format",
@@ -163,7 +173,7 @@ async function runClaudeTask(args: ProviderTaskRunnerArgs): Promise<ProviderTask
   } else {
     cliArgs.push("--no-session-persistence");
   }
-  cliArgs.push(prompt);
+  cliArgs.push("-p");
 
   const resolved = resolveClaudeCodeExecutable({ auth: args.auth });
   const result = await runCommand({
@@ -171,6 +181,7 @@ async function runClaudeTask(args: ProviderTaskRunnerArgs): Promise<ProviderTask
     argv: cliArgs,
     cwd: args.cwd,
     timeoutMs: args.timeoutMs,
+    stdinText: prompt,
   });
   if (result.exitCode !== 0) {
     throw new Error(`Claude exited with code ${result.exitCode ?? "unknown"}${result.stderr.trim() ? `\n\n${result.stderr.trim()}` : ""}`);
@@ -212,11 +223,10 @@ async function runCodexTask(args: ProviderTaskRunnerArgs): Promise<ProviderTaskR
     cliArgs.push("--output-schema", schemaPath);
   }
 
-  if (args.system?.trim()) {
-    cliArgs.push(`${args.system.trim()}\n\n${prompt}`);
-  } else {
-    cliArgs.push(prompt);
-  }
+  cliArgs.push("-");
+  const combinedPrompt = args.system?.trim()
+    ? `${args.system.trim()}\n\n${prompt}`
+    : prompt;
 
   const resolved = resolveCodexExecutable({ auth: args.auth });
   try {
@@ -225,6 +235,7 @@ async function runCodexTask(args: ProviderTaskRunnerArgs): Promise<ProviderTaskR
       argv: cliArgs,
       cwd: args.cwd,
       timeoutMs: args.timeoutMs,
+      stdinText: combinedPrompt,
     });
     const output = fs.existsSync(outPath) ? fs.readFileSync(outPath, "utf8").trim() : result.stdout.trim();
     if (result.exitCode !== 0) {
diff --git a/apps/desktop/src/main/services/ai/tools/universalTools.test.ts b/apps/desktop/src/main/services/ai/tools/universalTools.test.ts
index 5e4b9d852..884b23086 100644
--- a/apps/desktop/src/main/services/ai/tools/universalTools.test.ts
+++ b/apps/desktop/src/main/services/ai/tools/universalTools.test.ts
@@ -208,6 +208,76 @@ describe("checkWorkerSandbox", () => {
     expect(result.reason).toContain("protected file pattern");
   });
 
+  it("blocks PowerShell writes to protected files", () => {
+    const result = checkWorkerSandbox(
+      'powershell.exe -Command "Set-Content -Path .env -Value secret"',
+      sandboxWith({ protectedFiles: ["\\.env"] }),
+      "C:\\projects\\repo",
+    );
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("protected file pattern");
+  });
+
+  it("blocks PowerShell writes outside the sandbox root", () => {
+    const result = checkWorkerSandbox(
+      'pwsh -Command "Add-Content ..\\outside.txt secret"',
+      sandboxWith({ allowedPaths: ["./"] }),
+      "C:\\projects\\repo",
+    );
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("Path outside sandbox");
+  });
+
+  it("blocks PowerShell registry provider mutations", () => {
+    const result = checkWorkerSandbox(
+      'powershell.exe -Command "Set-ItemProperty -Path HKCU:\\Software\\Foo -Name Bar -Value 1"',
+      DEFAULT_WORKER_SANDBOX_CONFIG,
+      "C:\\projects\\repo",
+    );
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("non-filesystem provider path");
+  });
+
+  it("blocks PowerShell mutations that use non-literal path arguments", () => {
+    const result = checkWorkerSandbox(
+      'powershell.exe -Command "$path = \'.env\'; Set-Content -Path $path -Value secret"',
+      DEFAULT_WORKER_SANDBOX_CONFIG,
+      "C:\\projects\\repo",
+    );
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("non-literal path argument");
+  });
+
+  it("blocks opaque PowerShell encoded commands", () => {
+    const result = checkWorkerSandbox(
+      "powershell.exe -EncodedCommand not-base64!!!",
+      DEFAULT_WORKER_SANDBOX_CONFIG,
+      "C:\\projects\\repo",
+    );
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("EncodedCommand payload is not inspectable");
+  });
+
+  it("blocks PowerShell encoded writes to protected files", () => {
+    const encoded = Buffer.from("Set-Content -Path .env -Value secret", "utf16le").toString("base64");
+    const result = checkWorkerSandbox(
+      `powershell.exe -EncodedCommand ${encoded}`,
+      sandboxWith({ protectedFiles: ["\\.env"] }),
+      "C:\\projects\\repo",
+    );
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("protected file pattern");
+  });
+
+  it("allows read-only PowerShell file reads inside the sandbox", () => {
+    const result = checkWorkerSandbox(
+      'powershell.exe -Command "Get-Content .\\README.md"',
+      DEFAULT_WORKER_SANDBOX_CONFIG,
+      "C:\\projects\\repo",
+    );
+    expect(result.allowed).toBe(true);
+  });
+
   it("allows git.exe read-only subcommands like Unix git", () => {
     const result = checkWorkerSandbox(
       "git.exe status",
@@ -851,6 +921,26 @@ describe("createUniversalToolSet", () => {
     expect(result.stderr).toContain("EXECUTION DENIED");
   });
 
+  it("blocks mutating PowerShell commands on required turns", async () => {
+    const cwd = makeTmpDir("ade-tools-memory-guard-powershell-");
+    const tools = createUniversalToolSet(cwd, {
+      permissionMode: "full-auto",
+      turnMemoryPolicyState: {
+        classification: "required",
+        orientationSatisfied: false,
+        explicitSearchPerformed: false,
+      },
+    });
+
+    const result = await (tools.bash as any).execute({
+      command: 'powershell.exe -Command "Set-Content -Path .\\blocked.txt -Value hi"',
+      timeout: 5_000,
+    });
+
+    expect(result.exitCode).toBe(126);
+    expect(result.stderr).toContain("EXECUTION DENIED");
+  });
+
   it("does not block read-only bash commands on required turns", async () => {
     const cwd = makeTmpDir("ade-tools-memory-readonly-");
     const tools = createUniversalToolSet(cwd, {
diff --git a/apps/desktop/src/main/services/ai/tools/universalTools.ts b/apps/desktop/src/main/services/ai/tools/universalTools.ts
index 8bb862f02..3d68e0894 100644
--- a/apps/desktop/src/main/services/ai/tools/universalTools.ts
+++ b/apps/desktop/src/main/services/ai/tools/universalTools.ts
@@ -186,12 +186,456 @@ type PathReference = {
   access: PathAccessMode;
 };
 
+type PowerShellInspection = {
+  mutates: boolean;
+  pathRefs: PathReference[];
+  blockedReason?: string;
+};
+
+type PowerShellMutationKind =
+  | "copy"
+  | "move"
+  | "new-item"
+  | "out-file"
+  | "path-write"
+  | "provider-item"
+  | "remove"
+  | "rename";
+
+const POWERSHELL_COMMAND_FLAGS = new Set(["-command", "-c"]);
+const POWERSHELL_ENCODED_COMMAND_FLAGS = new Set(["-encodedcommand", "-enc", "-e"]);
+const POWERSHELL_SEGMENT_SEPARATORS = new Set(["|", "||", "&&", ";"]);
+const POWERSHELL_PUNCTUATION_TOKENS = new Set(["{", "}", "(", ")", ","]);
+const POWERSHELL_MUTATION_KIND_BY_COMMAND = new Map<string, PowerShellMutationKind>([
+  ["add-content", "path-write"],
+  ["ac", "path-write"],
+  ["clear-content", "path-write"],
+  ["copy", "copy"],
+  ["copy-item", "copy"],
+  ["cpi", "copy"],
+  ["cp", "copy"],
+  ["move", "move"],
+  ["move-item", "move"],
+  ["mv", "move"],
+  ["mi", "move"],
+  ["new-item", "new-item"],
+  ["ni", "new-item"],
+  ["out-file", "out-file"],
+  ["remove-item", "remove"],
+  ["del", "remove"],
+  ["erase", "remove"],
+  ["rd", "remove"],
+  ["ri", "remove"],
+  ["rm", "remove"],
+  ["rmdir", "remove"],
+  ["rename-item", "rename"],
+  ["ren", "rename"],
+  ["rni", "rename"],
+  ["set-content", "path-write"],
+  ["set-item", "provider-item"],
+  ["set-itemproperty", "provider-item"],
+  ["new-itemproperty", "provider-item"],
+  ["remove-itemproperty", "provider-item"],
+  ["rename-itemproperty", "provider-item"],
+  ["move-itemproperty", "provider-item"],
+  ["clear-itemproperty", "provider-item"],
+]);
+
 function requiresTurnMemoryGuard(state?: TurnMemoryPolicyState): boolean {
   return !!state && state.classification === "required" && !state.orientationSatisfied && !state.explicitSearchPerformed;
 }
 
-function bashCommandLikelyMutates(command: string): boolean {
-  return MUTATING_BASH_RE.test(command) || MUTATING_CMD_RE.test(command) || WRITE_COMMAND_RE.test(command);
+function tokenizePowerShellCommand(command: string): string[] {
+  const tokens: string[] = [];
+  let current = "";
+  let quote: "'" | '"' | null = null;
+  let escaped = false;
+
+  const pushCurrent = () => {
+    if (current.length > 0) {
+      tokens.push(current);
+      current = "";
+    }
+  };
+
+  for (let i = 0; i < command.length; i += 1) {
+    const ch = command[i]!;
+    if (escaped) {
+      current += ch;
+      escaped = false;
+      continue;
+    }
+    if (ch === "`") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else {
+        current += ch;
+      }
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      continue;
+    }
+    if (ch === ">") {
+      if (/^\d$/.test(current)) {
+        const fd = current;
+        current = "";
+        const next = command[i + 1];
+        if (next === ">") {
+          tokens.push(`${fd}>>`);
+          i += 1;
+        } else {
+          tokens.push(`${fd}>`);
+        }
+        continue;
+      }
+      pushCurrent();
+      const next = command[i + 1];
+      if (next === ">") {
+        tokens.push(">>");
+        i += 1;
+      } else {
+        tokens.push(">");
+      }
+      continue;
+    }
+    if (ch === "|" || ch === "&" || ch === ";") {
+      pushCurrent();
+      const next = command[i + 1];
+      if ((ch === "|" || ch === "&") && next === ch) {
+        tokens.push(`${ch}${ch}`);
+        i += 1;
+      } else {
+        tokens.push(ch);
+      }
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      pushCurrent();
+      continue;
+    }
+    if (POWERSHELL_PUNCTUATION_TOKENS.has(ch)) {
+      pushCurrent();
+      tokens.push(ch);
+      continue;
+    }
+    current += ch;
+  }
+
+  pushCurrent();
+  return tokens;
+}
+
+function splitPowerShellSegments(tokens: string[]): string[][] {
+  const segments: string[][] = [];
+  let current: string[] = [];
+  for (const token of tokens) {
+    const normalizedToken = normalizePathToken(token);
+    if (POWERSHELL_SEGMENT_SEPARATORS.has(token) || POWERSHELL_SEGMENT_SEPARATORS.has(normalizedToken)) {
+      if (current.length > 0) segments.push(current);
+      current = [];
+      continue;
+    }
+    current.push(token);
+  }
+  if (current.length > 0) segments.push(current);
+  return segments;
+}
+
+function isPowerShellHostCommand(commandName: string): boolean {
+  const baseName = path.win32.basename(normalizePathToken(commandName)).toLowerCase();
+  return baseName === "powershell" || baseName === "powershell.exe" || baseName === "pwsh" || baseName === "pwsh.exe";
+}
+
+function decodePowerShellEncodedCommand(value: string): string | null {
+  const trimmed = normalizePathToken(value);
+  if (!trimmed.length || !/^[a-z0-9+/=]+$/i.test(trimmed)) {
+    return null;
+  }
+  try {
+    const decoded = Buffer.from(trimmed, "base64").toString("utf16le");
+    return decoded.trim().length > 0 ? decoded : null;
+  } catch {
+    return null;
+  }
+}
+
+function isPowerShellParameterToken(value: string): boolean {
+  return /^-[a-z]/i.test(value);
+}
+
+function isPowerShellDynamicArgument(value: string): boolean {
+  return value.startsWith("$") || value.startsWith("@(") || value.includes("$(");
+}
+
+function normalizePowerShellPathArgument(value: string): { path?: string; nonFilesystemProvider?: string; opaque?: string } {
+  const normalized = normalizePathToken(value);
+  if (!normalized.length) return {};
+  if (isPowerShellDynamicArgument(normalized)) {
+    return { opaque: normalized };
+  }
+
+  const fileSystemQualified = normalized.match(/^(?:microsoft\.powershell\.core\\)?filesystem::(.+)$/i);
+  if (fileSystemQualified?.[1]) {
+    return { path: fileSystemQualified[1] };
+  }
+  if (/^(?:microsoft\.powershell\.core\\)?registry::/i.test(normalized)) {
+    return { nonFilesystemProvider: normalized };
+  }
+  if (/^[a-z]:/.test(normalized)) {
+    return { path: normalized };
+  }
+  if (/^(?:[a-z][a-z0-9+.-]*::|[a-z][a-z0-9+.-]*:)/i.test(normalized)) {
+    return { nonFilesystemProvider: normalized };
+  }
+  return { path: normalized };
+}
+
+function parsePowerShellArgs(args: string[]): { positional: string[]; named: Map<string, string[]> } {
+  const positional: string[] = [];
+  const named = new Map<string, string[]>();
+
+  for (let i = 0; i < args.length; i += 1) {
+    const raw = normalizePathToken(args[i] ?? "");
+    if (!raw.length || POWERSHELL_PUNCTUATION_TOKENS.has(raw)) continue;
+
+    const inlineMatch = raw.match(/^(-[a-z][a-z0-9-]*):(.*)$/i);
+    if (inlineMatch) {
+      const key = inlineMatch[1]!.toLowerCase();
+      const value = normalizePathToken(inlineMatch[2] ?? "");
+      named.set(key, value.length > 0 ? [value] : [""]);
+      continue;
+    }
+
+    if (isPowerShellParameterToken(raw)) {
+      const key = raw.toLowerCase();
+      const next = normalizePathToken(args[i + 1] ?? "");
+      if (next.length > 0 && !isPowerShellParameterToken(next) && !POWERSHELL_PUNCTUATION_TOKENS.has(next)) {
+        const values = named.get(key) ?? [];
+        values.push(next);
+        named.set(key, values);
+        i += 1;
+      } else {
+        const values = named.get(key) ?? [];
+        values.push("");
+        named.set(key, values);
+      }
+      continue;
+    }
+
+    positional.push(raw);
+  }
+
+  return { positional, named };
+}
+
+function inspectPowerShellInvocations(
+  command: string,
+  cwd: string,
+  pathApi: SandboxPathApi = getSandboxPathApi(cwd, command),
+): PowerShellInspection {
+  const refs = new Map<string, PathReference>();
+  const accessPriority: Record<PathAccessMode, number> = {
+    unknown: 0,
+    read: 1,
+    write: 2,
+  };
+
+  const addResolvedPath = (rawValue: string, access: PathAccessMode): { blockedReason?: string } => {
+    const normalized = normalizePathToken(rawValue);
+    if (!normalized.length || normalized.includes("://")) return {};
+
+    const normalizedPath = normalizePowerShellPathArgument(normalized);
+    if (normalizedPath.opaque) {
+      if (access !== "read") {
+        return { blockedReason: `PowerShell mutation uses a non-literal path argument: ${normalizedPath.opaque}` };
+      }
+      return {};
+    }
+    if (normalizedPath.nonFilesystemProvider) {
+      if (access !== "read") {
+        return { blockedReason: `PowerShell mutation targets non-filesystem provider path: ${normalizedPath.nonFilesystemProvider}` };
+      }
+      return {};
+    }
+
+    const candidate = normalizedPath.path;
+    if (!candidate || candidate === "/dev/null") return {};
+    const expandedPath =
+      candidate === "~"
+        ? os.homedir()
+        : candidate.startsWith("~/")
+          ? pathApi.join(os.homedir(), candidate.slice(2))
+          : pathApi === path.win32 && candidate.startsWith("~\\")
+            ? pathApi.join(os.homedir(), candidate.slice(2))
+            : candidate;
+    const resolved = pathApi.resolve(cwd, expandedPath);
+    const key = `${candidate}::${resolved}`;
+    const existing = refs.get(key);
+    if (!existing || accessPriority[access] > accessPriority[existing.access]) {
+      refs.set(key, { raw: candidate, resolved, access });
+    }
+    return {};
+  };
+
+  const addFirstNamedOrPositionalPath = (
+    parsed: ReturnType<typeof parsePowerShellArgs>,
+    flags: string[],
+    positionalIndex: number | null,
+    access: PathAccessMode,
+  ): { blockedReason?: string } => {
+    for (const flag of flags) {
+      const values = parsed.named.get(flag);
+      if (values?.length) {
+        return addResolvedPath(values[0]!, access);
+      }
+    }
+    if (positionalIndex !== null && parsed.positional[positionalIndex]) {
+      return addResolvedPath(parsed.positional[positionalIndex]!, access);
+    }
+    return {};
+  };
+
+  const outerSegments = splitCommandSegments(tokenizeCommand(command, pathApi === path.win32));
+  let mutates = false;
+
+  for (const segment of outerSegments) {
+    const commandName = normalizePathToken(segment[0] ?? "");
+    if (!commandName.length || !isPowerShellHostCommand(commandName)) continue;
+
+    const args = segment.slice(1);
+    let script: string | null = null;
+    for (let i = 0; i < args.length; i += 1) {
+      const flag = normalizePathToken(args[i] ?? "").toLowerCase();
+      if (POWERSHELL_COMMAND_FLAGS.has(flag)) {
+        const remainder = args.slice(i + 1).join(" ").trim();
+        if (!remainder.length || remainder === "-") {
+          return {
+            mutates: true,
+            pathRefs: [...refs.values()],
+            blockedReason: "PowerShell -Command input is not inspectable by the worker sandbox",
+          };
+        }
+        script = remainder;
+        break;
+      }
+      if (POWERSHELL_ENCODED_COMMAND_FLAGS.has(flag)) {
+        const decoded = decodePowerShellEncodedCommand(args[i + 1] ?? "");
+        if (!decoded) {
+          return {
+            mutates: true,
+            pathRefs: [...refs.values()],
+            blockedReason: "PowerShell -EncodedCommand payload is not inspectable by the worker sandbox",
+          };
+        }
+        script = decoded;
+        break;
+      }
+    }
+
+    if (!script) continue;
+
+    const tokens = tokenizePowerShellCommand(script);
+    for (let i = 0; i < tokens.length; i += 1) {
+      const token = normalizePathToken(tokens[i] ?? "");
+      if (!token.length) continue;
+      if (token === ">" || token === ">>" || /^\d>>?$/.test(token)) {
+        mutates = true;
+        const writeTarget = addResolvedPath(tokens[i + 1] ?? "", "write");
+        if (writeTarget.blockedReason) {
+          return {
+            mutates: true,
+            pathRefs: [...refs.values()],
+            blockedReason: writeTarget.blockedReason,
+          };
+        }
+      }
+    }
+
+    for (const innerSegment of splitPowerShellSegments(tokens)) {
+      let innerCommandIndex = 0;
+      while (innerCommandIndex < innerSegment.length) {
+        const token = normalizePathToken(innerSegment[innerCommandIndex] ?? "");
+        if (!token.length || token === "&" || token === "." || POWERSHELL_PUNCTUATION_TOKENS.has(token)) {
+          innerCommandIndex += 1;
+          continue;
+        }
+        break;
+      }
+      if (innerCommandIndex >= innerSegment.length) continue;
+
+      const innerCommandName = normalizePathToken(innerSegment[innerCommandIndex] ?? "").toLowerCase();
+      const mutationKind = POWERSHELL_MUTATION_KIND_BY_COMMAND.get(innerCommandName);
+      if (!mutationKind) continue;
+      mutates = true;
+
+      const parsed = parsePowerShellArgs(innerSegment.slice(innerCommandIndex + 1));
+      let result: { blockedReason?: string } = {};
+
+      switch (mutationKind) {
+        case "path-write":
+          result = addFirstNamedOrPositionalPath(parsed, ["-path", "-literalpath", "-pspath", "-lp"], 0, "write");
+          break;
+        case "out-file":
+          result = addFirstNamedOrPositionalPath(parsed, ["-filepath", "-literalpath", "-path", "-pspath", "-lp"], 0, "write");
+          break;
+        case "copy": {
+          result = addFirstNamedOrPositionalPath(parsed, ["-path", "-literalpath", "-pspath", "-lp"], 0, "read");
+          if (result.blockedReason) break;
+          result = addFirstNamedOrPositionalPath(parsed, ["-destination"], 1, "write");
+          break;
+        }
+        case "move": {
+          result = addFirstNamedOrPositionalPath(parsed, ["-path", "-literalpath", "-pspath", "-lp"], 0, "write");
+          if (result.blockedReason) break;
+          result = addFirstNamedOrPositionalPath(parsed, ["-destination"], 1, "write");
+          break;
+        }
+        case "remove":
+          result = addFirstNamedOrPositionalPath(parsed, ["-path", "-literalpath", "-pspath", "-lp"], 0, "write");
+          break;
+        case "rename":
+          result = addFirstNamedOrPositionalPath(parsed, ["-path", "-literalpath", "-pspath", "-lp"], 0, "write");
+          if (result.blockedReason) break;
+          result = addFirstNamedOrPositionalPath(parsed, ["-newname"], 1, "write");
+          break;
+        case "new-item":
+          result = addFirstNamedOrPositionalPath(parsed, ["-path", "-literalpath", "-pspath", "-lp"], 0, "write");
+          if (result.blockedReason) break;
+          if (parsed.named.get("-name")?.[0]) {
+            result = addResolvedPath(parsed.named.get("-name")![0]!, "write");
+          }
+          break;
+        case "provider-item":
+          result = addFirstNamedOrPositionalPath(parsed, ["-path", "-literalpath", "-pspath", "-lp"], 0, "write");
+          break;
+      }
+
+      if (result.blockedReason) {
+        return {
+          mutates: true,
+          pathRefs: [...refs.values()],
+          blockedReason: result.blockedReason,
+        };
+      }
+    }
+  }
+
+  return { mutates, pathRefs: [...refs.values()] };
+}
+
+function bashCommandLikelyMutates(
+  command: string,
+  cwd = process.cwd(),
+  powerShellInspection?: PowerShellInspection,
+): boolean {
+  const inspection = powerShellInspection ?? inspectPowerShellInvocations(command, cwd);
+  return inspection.mutates || !!inspection.blockedReason || MUTATING_BASH_RE.test(command) || MUTATING_CMD_RE.test(command) || WRITE_COMMAND_RE.test(command);
 }
 
 function resolveAllowedWriteRoots(cwd: string, sandboxConfig?: WorkerSandboxConfig, pathApi: SandboxPathApi = getSandboxPathApi(cwd)): string[] {
@@ -393,7 +837,8 @@ function splitCommandSegments(tokens: string[]): string[][] {
   const segments: string[][] = [];
   let current: string[] = [];
   for (const token of tokens) {
-    if (COMMAND_SEPARATORS.has(normalizePathToken(token))) {
+    const normalizedToken = normalizePathToken(token);
+    if (COMMAND_SEPARATORS.has(token) || COMMAND_SEPARATORS.has(normalizedToken)) {
       if (current.length > 0) segments.push(current);
       current = [];
       continue;
@@ -404,7 +849,12 @@ function splitCommandSegments(tokens: string[]): string[][] {
   return segments;
 }
 
-function collectPathReferences(command: string, cwd: string, pathApi: SandboxPathApi = getSandboxPathApi(cwd, command)): PathReference[] {
+function collectPathReferences(
+  command: string,
+  cwd: string,
+  pathApi: SandboxPathApi = getSandboxPathApi(cwd, command),
+  powerShellInspection?: PowerShellInspection,
+): PathReference[] {
   const refs = new Map<string, PathReference>();
   const windowsMode = pathApi === path.win32;
   const accessPriority: Record<PathAccessMode, number> = {
@@ -530,6 +980,15 @@ function collectPathReferences(command: string, cwd: string, pathApi: SandboxPat
     markOperands(commandName, args);
   }
 
+  const nestedPowerShellRefs = (powerShellInspection ?? inspectPowerShellInvocations(command, cwd, pathApi)).pathRefs;
+  for (const entry of nestedPowerShellRefs) {
+    const key = `${entry.raw}::${entry.resolved}`;
+    const existing = refs.get(key);
+    if (!existing || accessPriority[entry.access] > accessPriority[existing.access]) {
+      refs.set(key, entry);
+    }
+  }
+
   return [...refs.values()];
 }
 
@@ -564,6 +1023,7 @@ export function checkWorkerSandbox(
 ): { allowed: boolean; reason?: string } {
   const compiled = compileSandbox(config);
   const pathApi = getSandboxPathApi(projectRoot, command);
+  const powerShellInspection = inspectPowerShellInvocations(command, projectRoot, pathApi);
 
   // 1. Check blocked patterns first (always reject)
   for (const { re, src } of compiled.blocked) {
@@ -572,12 +1032,16 @@ export function checkWorkerSandbox(
     }
   }
 
+  if (powerShellInspection.blockedReason) {
+    return { allowed: false, reason: powerShellInspection.blockedReason };
+  }
+
   const safeMatch = compiled.safe.some((re) => re.test(command));
-  const commandMutates = bashCommandLikelyMutates(command);
+  const commandMutates = bashCommandLikelyMutates(command, projectRoot, powerShellInspection);
 
   // 2. Validate file paths against allowedPaths (absolute + relative)
   const rootResolved = canonicalizePathForContainment(projectRoot, pathApi);
-  const pathRefs = collectPathReferences(command, projectRoot, pathApi);
+  const pathRefs = collectPathReferences(command, projectRoot, pathApi, powerShellInspection);
   for (const entry of pathRefs) {
     const p = entry.raw;
     const resolved = canonicalizePathForContainment(entry.resolved, pathApi);
diff --git a/apps/desktop/src/main/services/cli/windowsPackaging.test.ts b/apps/desktop/src/main/services/cli/windowsPackaging.test.ts
new file mode 100644
index 000000000..3f23cf418
--- /dev/null
+++ b/apps/desktop/src/main/services/cli/windowsPackaging.test.ts
@@ -0,0 +1,74 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { parse as parseYaml } from "yaml";
+import { describe, expect, it } from "vitest";
+
+const desktopRoot = path.resolve(__dirname, "../../../../");
+const repoRoot = path.resolve(desktopRoot, "..", "..");
+
+describe("Windows packaging", () => {
+  it("keeps the packaged Windows wrapper on a shared runtime-env path", () => {
+    const wrapperPath = path.join(desktopRoot, "scripts", "ade-cli-windows-wrapper.cmd");
+    const wrapper = fs.readFileSync(wrapperPath, "utf8");
+
+    expect(wrapper).toContain('set "NODE_PATH_VALUE=%RESOURCES_DIR%\\app.asar.unpacked\\node_modules;%RESOURCES_DIR%\\app.asar\\node_modules"');
+    expect(wrapper).toContain('call :run_with_runtime_env "%ADE_CLI_NODE%" "%CLI_JS%" %*');
+    expect(wrapper).toContain('call :run_with_runtime_env "%APP_EXE%" "%CLI_JS%" %*');
+    expect(wrapper).toContain('call :run_with_runtime_env node "%CLI_JS%" %*');
+    expect(wrapper).toContain('if defined NODE_PATH_VALUE set "NODE_PATH=%NODE_PATH_VALUE%"');
+  });
+
+  it("keeps the Windows install-path shim callable and exit-code preserving", () => {
+    const installerPath = path.join(desktopRoot, "scripts", "ade-cli-install-path.cmd");
+    const installer = fs.readFileSync(installerPath, "utf8");
+
+    expect(installer).toContain('echo call "%ADE_BIN%" %%*');
+    expect(installer).toContain("echo exit /b %%ERRORLEVEL%%");
+  });
+
+  it("pins the Windows desktop build to x64 and unpacks sql.js for node fallback", () => {
+    const packageJsonPath = path.join(desktopRoot, "package.json");
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+
+    expect(pkg.scripts["dist:win"]).toContain("validate:win:release");
+    expect(pkg.build.asarUnpack).toContain("node_modules/sql.js/**/*");
+    expect(pkg.build.win.icon).toBe("build/icon.ico");
+    expect(pkg.build.win.target).toEqual([
+      {
+        target: "nsis",
+        arch: ["x64"],
+      },
+    ]);
+  });
+
+  it("passes the Windows artifact preflight", () => {
+    const validateScriptPath = path.join(desktopRoot, "scripts", "validate-win-artifacts.mjs");
+    const result = spawnSync(process.execPath, [validateScriptPath, "--mode=preflight"], {
+      cwd: desktopRoot,
+      encoding: "utf8",
+    });
+
+    expect(result.status).toBe(0);
+    expect(result.stderr).toBe("");
+    expect(result.stdout).toContain("Windows package inputs are present.");
+  });
+
+  it("builds and publishes Windows release artifacts in release-core", () => {
+    const workflowPath = path.join(repoRoot, ".github", "workflows", "release-core.yml");
+    const workflow = parseYaml(fs.readFileSync(workflowPath, "utf8"));
+    const winJob = workflow.jobs["build-win-release"];
+    const publishJob = workflow.jobs["publish-release"];
+
+    expect(winJob["runs-on"]).toBe("windows-latest");
+    expect(winJob.steps.some((step: { run?: string }) => step.run?.includes("npm run dist:win"))).toBe(true);
+
+    const winUploadStep = winJob.steps.find((step: { name?: string }) => step.name === "Upload validated Windows artifacts to workflow run");
+    expect(winUploadStep.with.path).toContain("apps/desktop/release/latest.yml");
+
+    expect(publishJob.needs).toEqual(expect.arrayContaining(["build-mac-release", "build-win-release"]));
+    const publishStep = publishJob.steps.find((step: { name?: string }) => step.name === "Create or update draft GitHub release");
+    expect(publishStep.run).toContain("release-assets/win/latest.yml");
+    expect(publishStep.run).toContain("release-assets/win/*.exe.blockmap");
+  });
+});
diff --git a/apps/desktop/src/main/services/ipc/registerIpc.ts b/apps/desktop/src/main/services/ipc/registerIpc.ts
index 62629b7d3..e18bf3a5d 100644
--- a/apps/desktop/src/main/services/ipc/registerIpc.ts
+++ b/apps/desktop/src/main/services/ipc/registerIpc.ts
@@ -1931,13 +1931,13 @@ export function registerIpc({
     IPC.appOpenPathInEditor,
     async (
       _event,
-      arg: { rootPath: string; relativePath?: string; target: "finder" | "vscode" | "cursor" | "zed" }
+      arg: { rootPath: string; relativePath?: string; target: "default" | "finder" | "vscode" | "cursor" | "zed" }
     ): Promise<void> => {
       const rootRaw = typeof arg?.rootPath === "string" ? arg.rootPath.trim() : "";
       const relRaw = typeof arg?.relativePath === "string" ? arg.relativePath.trim() : "";
       const target = arg?.target;
       if (!rootRaw) throw new Error("Missing root path.");
-      if (target !== "finder" && target !== "vscode" && target !== "cursor" && target !== "zed") {
+      if (target !== "default" && target !== "finder" && target !== "vscode" && target !== "cursor" && target !== "zed") {
         throw new Error("Unsupported editor target.");
       }
       const rootPath = path.resolve(rootRaw);
@@ -1969,6 +1969,14 @@ export function registerIpc({
         throw resolveError;
       }
 
+      if (target === "default") {
+        const errorMessage = await shell.openPath(targetPath);
+        if (errorMessage) {
+          throw new Error(`Failed to open path: ${errorMessage}`);
+        }
+        return;
+      }
+
       if (target === "finder") {
         shell.showItemInFolder(targetPath);
         return;
diff --git a/apps/desktop/src/main/services/orchestrator/orchestratorService.ts b/apps/desktop/src/main/services/orchestrator/orchestratorService.ts
index e5069417b..a347c8a0a 100644
--- a/apps/desktop/src/main/services/orchestrator/orchestratorService.ts
+++ b/apps/desktop/src/main/services/orchestrator/orchestratorService.ts
@@ -71,8 +71,13 @@ import { evaluateRunCompletion, evaluateRunCompletionFromPhases, validateRunComp
 import {
   createProviderOrchestratorAdapter,
   cleanupWorkerRuntimeFiles,
+  nodeWorkerLaunch,
+  writeWorkerLaunchFile,
+  writeWorkerPromptFile,
 } from "./providerOrchestratorAdapter";
+import { resolveClaudeCodeExecutable } from "../ai/claudeCodeExecutable";
 import { resolveClaudeCliModel, resolveCodexCliModel } from "../ai/claudeModelUtils";
+import { resolveCodexExecutable } from "../ai/codexExecutable";
 import { runGit } from "../git/git";
 import type { AdeDb, SqlValue } from "../state/kvDb";
 import type { createPtyService } from "../pty/ptyService";
@@ -90,7 +95,7 @@ import type { ProceduralLearningService } from "../memory/proceduralLearningServ
 import { asRecord, nowIso, parseJsonRecord, TERMINAL_STEP_STATUSES, filterExecutionSteps } from "./orchestratorContext";
 import { parseNumericDependencyIndices } from "./missionLifecycle";
 import { getMissionStateDocumentPath } from "./missionStateDoc";
-import { buildFullPrompt, shellEscapeArg, shellInlineDecodedArg } from "./baseOrchestratorAdapter";
+import { buildFullPrompt, shellEscapeArg } from "./baseOrchestratorAdapter";
 import type { createAiIntegrationService } from "../ai/aiIntegrationService";
 import { classifyWorkerExecutionPath, resolveModelDescriptor } from "../../../shared/modelRegistry";
 import {
@@ -4000,9 +4005,46 @@ export function createOrchestratorService({
               commandPreviewParts.push("--permission-mode", shellEscapeArg(claudePermissionMode));
             }
           }
-          commandArgs.push(prompt);
-          commandPreviewParts.push(shellInlineDecodedArg(prompt));
-          const startupCommand = commandPreviewParts.join(" ");
+          const promptFilePath = writeWorkerPromptFile({
+            projectRoot,
+            attemptId: args.attempt.id,
+            prompt,
+          });
+
+          let launchCommand;
+          if (cliCommand === "codex") {
+            const resolvedCodex = resolveCodexExecutable();
+            commandArgs.push("exec", "-");
+            commandPreviewParts.push("exec", "-");
+            const startupCommand = `exec ${commandPreviewParts.join(" ")} < ${shellEscapeArg(promptFilePath)}`;
+            const launchFilePath = writeWorkerLaunchFile({
+              projectRoot,
+              attemptId: args.attempt.id,
+              command: resolvedCodex.path,
+              commandArgs,
+              promptFilePath,
+            });
+            launchCommand = nodeWorkerLaunch({
+              startupCommand,
+              launchFilePath,
+            });
+          } else {
+            const resolvedClaude = resolveClaudeCodeExecutable();
+            commandArgs.push("-p");
+            commandPreviewParts.push("-p");
+            const startupCommand = `exec ${commandPreviewParts.join(" ")} < ${shellEscapeArg(promptFilePath)}`;
+            const launchFilePath = writeWorkerLaunchFile({
+              projectRoot,
+              attemptId: args.attempt.id,
+              command: resolvedClaude.path,
+              commandArgs,
+              promptFilePath,
+            });
+            launchCommand = nodeWorkerLaunch({
+              startupCommand,
+              launchFilePath,
+            });
+          }
 
           const session = await args.createTrackedSession({
             laneId: args.step.laneId,
@@ -4010,9 +4052,10 @@ export function createOrchestratorService({
             rows: 36,
             title,
             toolType: `${kind}-orchestrated` as TerminalToolType,
-            command: cliCommand,
-            args: commandArgs,
-            startupCommand
+            command: launchCommand.command,
+            args: launchCommand.args,
+            env: launchCommand.env,
+            startupCommand: launchCommand.startupCommand,
           });
           return {
             status: "accepted",
@@ -4023,7 +4066,7 @@ export function createOrchestratorService({
               contextFilePath,
               contextDigest: sha256(JSON.stringify(contextManifest)),
               planMode: readOnlyExecution,
-              startupCommandPreview: startupCommand.slice(0, 320),
+              startupCommandPreview: launchCommand.startupCommand.slice(0, 320),
               localFirst: true
             }
           };
diff --git a/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts b/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts
index 53a6000e7..f2bc56a7e 100644
--- a/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts
+++ b/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts
@@ -18,7 +18,9 @@ import type {
 } from "../../../shared/types";
 import type { MissionPermissionConfig, MissionProviderPermissions } from "../../../shared/types/missions";
 import { resolveAdeLayout } from "../../../shared/adeLayout";
+import { resolveClaudeCodeExecutable } from "../ai/claudeCodeExecutable";
 import { resolveClaudeCliModel, resolveCodexCliModel } from "../ai/claudeModelUtils";
+import { resolveCodexExecutable } from "../ai/codexExecutable";
 import type { createAgentChatService } from "../chat/agentChatService";
 import {
   mapPermissionToClaude,
@@ -26,6 +28,7 @@ import {
   normalizeMissionPermissions,
   providerPermissionsToLegacyConfig,
 } from "./permissionMapping";
+import { resolveCliSpawnInvocation } from "../shared/processExecution";
 
 const WORKER_ENV_KEYS = [
   "ADE_MISSION_ID",
@@ -113,7 +116,8 @@ const child = spawn(spec.command, Array.isArray(spec.args) ? spec.args : [], {
   env: childEnv,
   shell: false,
   stdio: [spec.stdinFilePath ? "pipe" : "inherit", "inherit", "inherit"],
-  windowsHide: false
+  windowsHide: false,
+  windowsVerbatimArguments: !!spec.windowsVerbatimArguments
 });
 child.on("error", (err) => {
   console.error("[ADE] Failed to launch worker CLI: " + (err && err.message ? err.message : String(err)));
@@ -163,7 +167,7 @@ export function buildClaudeReadOnlyWorkerAllowedTools(extraToolNames: readonly s
   ]);
 }
 
-function writeWorkerPromptFile(args: {
+export function writeWorkerPromptFile(args: {
   projectRoot: string;
   attemptId: string;
   prompt: string;
@@ -174,7 +178,7 @@ function writeWorkerPromptFile(args: {
   return promptPath;
 }
 
-function writeWorkerLaunchFile(args: {
+export function writeWorkerLaunchFile(args: {
   projectRoot: string;
   attemptId: string;
   command: string;
@@ -184,11 +188,17 @@ function writeWorkerLaunchFile(args: {
 }): string {
   const launchPath = workerLaunchFilePath(args.projectRoot, args.attemptId);
   fs.mkdirSync(path.dirname(launchPath), { recursive: true });
+  const invocation = resolveCliSpawnInvocation(
+    args.command,
+    args.commandArgs,
+    { ...process.env, ...(args.env ?? {}) },
+  );
   fs.writeFileSync(
     launchPath,
     JSON.stringify({
-      command: args.command,
-      args: args.commandArgs,
+      command: invocation.command,
+      args: invocation.args,
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments ?? false,
       stdinFilePath: args.promptFilePath,
       env: args.env ?? {},
     }),
@@ -197,7 +207,7 @@ function writeWorkerLaunchFile(args: {
   return launchPath;
 }
 
-function nodeWorkerLaunch(args: {
+export function nodeWorkerLaunch(args: {
   startupCommand: string;
   launchFilePath: string;
   env?: Record<string, string>;
@@ -453,6 +463,7 @@ export function createProviderOrchestratorAdapter(options?: {
           ? buildClaudeReadOnlyWorkerAllowedTools()
           : dedupeAllowedTools(configuredAllowedTools);
 
+        const resolvedClaude = resolveClaudeCodeExecutable();
         const commandArgs: string[] = ["--model", cliModel];
         const previewParts: string[] = ["claude", "--model", shellEscapeArg(cliModel)];
 
@@ -475,7 +486,7 @@ export function createProviderOrchestratorAdapter(options?: {
           prompt,
         });
         commandArgs.push("-p");
-        previewParts.push("-p", `"$(cat ${shellEscapeArg(promptFilePath)})"`);
+        previewParts.push("-p");
 
         const launchEnv: Record<string, string> = { ...workerEnv };
         const envParts = previewWorkerEnvVars(workerEnv);
@@ -489,12 +500,12 @@ export function createProviderOrchestratorAdapter(options?: {
         }
 
         const cmd = previewParts.join(" ");
-        const startup = `exec ${cmd}`;
+        const startup = `exec ${cmd} < ${shellEscapeArg(promptFilePath)}`;
         const startupCommand = envParts.length > 0 ? `${envParts.join(" ")} ${startup}` : startup;
         const launchFilePath = writeWorkerLaunchFile({
           projectRoot: canonicalProjectRoot,
           attemptId: attempt.id,
-          command: "claude",
+          command: resolvedClaude.path,
           commandArgs,
           promptFilePath,
           env: launchEnv,
@@ -519,6 +530,7 @@ export function createProviderOrchestratorAdapter(options?: {
             : mappedCodex?.sandbox ?? effectivePermissionConfig?._providers?.codexSandbox ?? effectivePermissionConfig?.cli?.sandboxPermissions ?? "workspace-write";
         const writablePaths = effectivePermissionConfig?._providers?.writablePaths ?? effectivePermissionConfig?.cli?.writablePaths ?? [];
 
+        const resolvedCodex = resolveCodexExecutable();
         const commandArgs: string[] = ["--model", resolveCodexCliModel(descriptor.providerModelId)];
         const previewParts: string[] = [
           "codex", "--model", shellEscapeArg(resolveCodexCliModel(descriptor.providerModelId)),
@@ -552,7 +564,7 @@ export function createProviderOrchestratorAdapter(options?: {
         const launchFilePath = writeWorkerLaunchFile({
           projectRoot: canonicalProjectRoot,
           attemptId: attempt.id,
-          command: "codex",
+          command: resolvedCodex.path,
           commandArgs,
           promptFilePath,
           env: launchEnv,
diff --git a/apps/desktop/src/preload/global.d.ts b/apps/desktop/src/preload/global.d.ts
index 196d4b513..2ed9141a2 100644
--- a/apps/desktop/src/preload/global.d.ts
+++ b/apps/desktop/src/preload/global.d.ts
@@ -602,7 +602,7 @@ declare global {
         openPathInEditor: (args: {
           rootPath: string;
           relativePath?: string;
-          target: "finder" | "vscode" | "cursor" | "zed";
+          target: "default" | "finder" | "vscode" | "cursor" | "zed";
         }) => Promise<void>;
         logDebugEvent: (
           event: string,
diff --git a/apps/desktop/src/preload/preload.ts b/apps/desktop/src/preload/preload.ts
index 4205489b7..a61b80feb 100644
--- a/apps/desktop/src/preload/preload.ts
+++ b/apps/desktop/src/preload/preload.ts
@@ -612,7 +612,7 @@ contextBridge.exposeInMainWorld("ade", {
     openPathInEditor: async (args: {
       rootPath: string;
       relativePath?: string;
-      target: "finder" | "vscode" | "cursor" | "zed";
+      target: "default" | "finder" | "vscode" | "cursor" | "zed";
     }): Promise<void> => ipcRenderer.invoke(IPC.appOpenPathInEditor, args),
     logDebugEvent: (event: string, payload: Record<string, unknown> = {}): void =>
       ipcRenderer.send(IPC.appLogDebugEvent, { event, payload }),
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
index 28c7ad0aa..bbfaf8a4f 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
@@ -487,6 +487,88 @@ describe("AgentChatMessageList transcript rendering", () => {
     );
   });
 
+  it("passes Windows line and column suffixes through to Files navigation", async () => {
+    vi.mocked(globalThis.window.ade.files.listWorkspaces).mockResolvedValueOnce([
+      {
+        id: "workspace-windows",
+        kind: "worktree",
+        laneId: "lane-win",
+        name: "Windows lane",
+        rootPath: "C:\\Users\\me\\repo",
+        isReadOnlyByDefault: false,
+      },
+    ]);
+
+    renderMessageList(
+      [
+        {
+          sessionId: "session-1",
+          timestamp: "2026-03-17T10:00:00.000Z",
+          event: {
+            type: "text",
+            text: "Inspect `C:\\Users\\me\\repo\\src\\main.ts:42:5`.",
+            itemId: "text-windows-line-column",
+            turnId: "turn-1",
+          },
+        },
+      ],
+      {
+        initialState: { laneId: "lane-win" },
+      },
+    );
+
+    await waitFor(() => {
+      expect(globalThis.window.ade.files.listWorkspaces).toHaveBeenCalledTimes(1);
+    });
+
+    fireEvent.click(screen.getByRole("button", { name: "C:\\Users\\me\\repo\\src\\main.ts:42:5" }));
+
+    expect(screen.getByTestId("location").textContent).toBe(
+      "/files::{\"openFilePath\":\"src/main.ts\",\"laneId\":\"lane-win\",\"startLine\":42,\"startColumn\":5}",
+    );
+  });
+
+  it("normalizes Windows dot segments before navigating to Files", async () => {
+    vi.mocked(globalThis.window.ade.files.listWorkspaces).mockResolvedValueOnce([
+      {
+        id: "workspace-windows",
+        kind: "worktree",
+        laneId: "lane-win",
+        name: "Windows lane",
+        rootPath: "C:\\Users\\me\\repo",
+        isReadOnlyByDefault: false,
+      },
+    ]);
+
+    renderMessageList(
+      [
+        {
+          sessionId: "session-1",
+          timestamp: "2026-03-17T10:00:00.000Z",
+          event: {
+            type: "text",
+            text: "Inspect `C:\\Users\\me\\repo\\src\\..\\main.ts:42`.",
+            itemId: "text-windows-dot-segments",
+            turnId: "turn-1",
+          },
+        },
+      ],
+      {
+        initialState: { laneId: "lane-win" },
+      },
+    );
+
+    await waitFor(() => {
+      expect(globalThis.window.ade.files.listWorkspaces).toHaveBeenCalledTimes(1);
+    });
+
+    fireEvent.click(screen.getByRole("button", { name: "C:\\Users\\me\\repo\\src\\..\\main.ts:42" }));
+
+    expect(screen.getByTestId("location").textContent).toBe(
+      "/files::{\"openFilePath\":\"main.ts\",\"laneId\":\"lane-win\",\"startLine\":42}",
+    );
+  });
+
   it("maps backslash UNC file references into Files navigation targets", async () => {
     vi.mocked(globalThis.window.ade.files.listWorkspaces).mockResolvedValueOnce([
       {
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
index f9d523c45..ea4647651 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
@@ -67,6 +67,11 @@ import type { PendingInputQuestion, PendingInputRequest } from "../../../shared/
 
 const NAVIGATION_SURFACES = new Set(["work", "missions", "lanes", "cto"]);
 type PendingInputResolution = Extract<AgentChatEvent, { type: "pending_input_resolved" }>["resolution"];
+type WorkspacePathLocation = {
+  path: string;
+  startLine?: number;
+  startColumn?: number;
+};
 
 function readOperatorNavigationSuggestion(value: unknown): OperatorNavigationSuggestion | null {
   const record = readRecord(value);
@@ -410,48 +415,91 @@ function isExternalHref(href: string): boolean {
   return /^(?:[a-z]+:)?\/\//i.test(trimmed) || /^mailto:/i.test(trimmed) || /^tel:/i.test(trimmed);
 }
 
-function normalizeWorkspacePathCandidate(value: string): string | null {
+function readWorkspacePathFragmentPosition(fragment: string): Pick<WorkspacePathLocation, "startLine" | "startColumn"> {
+  const trimmed = fragment.trim();
+  if (!trimmed.length) return {};
+
+  const lineMatch = trimmed.match(/^L(\d+)(?:C(\d+))?(?:-L?\d+)?$/i);
+  if (lineMatch) {
+    const [, startLineRaw, startColumnRaw] = lineMatch;
+    return {
+      startLine: Number(startLineRaw),
+      startColumn: startColumnRaw ? Number(startColumnRaw) : undefined,
+    };
+  }
+
+  const explicitMatch = trimmed.match(/^line=(\d+)(?:,(\d+))?$/i);
+  if (!explicitMatch) return {};
+  const [, startLineRaw, startColumnRaw] = explicitMatch;
+  return {
+    startLine: Number(startLineRaw),
+    startColumn: startColumnRaw ? Number(startColumnRaw) : undefined,
+  };
+}
+
+function splitWorkspacePathLineSuffix(path: string): WorkspacePathLocation {
+  const match = path.match(/^(.*?)(?::(\d+))(?::(\d+))?$/);
+  if (!match) return { path };
+
+  const [, candidatePath, startLineRaw, startColumnRaw] = match;
+  if (!candidatePath.length) return { path };
+  return {
+    path: candidatePath,
+    startLine: Number(startLineRaw),
+    startColumn: startColumnRaw ? Number(startColumnRaw) : undefined,
+  };
+}
+
+function parseWorkspacePathLocation(value: string): WorkspacePathLocation | null {
   const trimmed = value.trim();
   if (!trimmed.length) return null;
   if (/^(?:https?|mailto|tel):/i.test(trimmed)) return null;
   if (/^#/.test(trimmed)) return null;
+
   const withoutScheme = trimmed.replace(/^file:\/\//i, "");
-  const rawPath = withoutScheme.split(/[?#]/, 1)[0]?.trim() ?? "";
+  const [withoutFragment, rawFragment = ""] = withoutScheme.split("#", 2);
+  const rawPath = withoutFragment.split("?", 1)[0]?.trim() ?? "";
   let decodedPath = rawPath;
   try {
     decodedPath = decodeURIComponent(rawPath);
   } catch {
     // Keep the raw path when markdown produced a partially-encoded href.
   }
-  const withoutQuery = decodedPath.replace(/\\/g, "/");
-  if (!withoutQuery.length) return null;
-  // Normalize Windows drive-letter paths: /C:/... → C:/...
-  if (/^\/[A-Za-z]:\//.test(withoutQuery)) return withoutQuery.slice(1);
-  return withoutQuery;
+
+  const slashNormalized = decodedPath.replace(/\\/g, "/");
+  if (!slashNormalized.length) return null;
+
+  const normalizedDrivePath = /^\/[A-Za-z]:\//.test(slashNormalized) ? slashNormalized.slice(1) : slashNormalized;
+  const fromSuffix = splitWorkspacePathLineSuffix(normalizedDrivePath);
+  const fromFragment = readWorkspacePathFragmentPosition(rawFragment);
+  const normalizedPath = normalizePath(fromSuffix.path);
+  if (!normalizedPath.length) return null;
+
+  return {
+    path: normalizedPath,
+    startLine: fromFragment.startLine ?? fromSuffix.startLine,
+    startColumn: fromFragment.startColumn ?? fromSuffix.startColumn,
+  };
 }
 
 function looksLikeWorkspacePath(value: string): boolean {
-  const candidate = normalizeWorkspacePathCandidate(value);
+  const candidate = parseWorkspacePathLocation(value);
   if (!candidate) return false;
-  if (candidate.startsWith("./")) {
-    return true;
-  }
-  // Reject directory-traversal and home-relative paths
-  if (candidate.startsWith("../") || candidate.startsWith("~/")) {
+  if (candidate.path === ".." || candidate.path.startsWith("../") || candidate.path.startsWith("~/")) {
     return false;
   }
-  if (candidate.startsWith("/")) {
-    return candidate.slice(1).includes("/") || /\.[A-Za-z0-9]{1,8}$/.test(candidate);
+  if (candidate.path.startsWith("/")) {
+    return candidate.path.slice(1).includes("/") || /\.[A-Za-z0-9]{1,8}$/.test(candidate.path);
   }
-  return candidate.includes("/") || /\.[A-Za-z0-9]{1,8}$/.test(candidate);
+  return candidate.path.includes("/") || /\.[A-Za-z0-9]{1,8}$/.test(candidate.path);
 }
 
-function resolveWorkspacePathFromHref(href: string | undefined): string | null {
+function resolveWorkspacePathFromHref(href: string | undefined): WorkspacePathLocation | null {
   if (!href) return null;
   if (isExternalHref(href)) return null;
-  const candidate = normalizeWorkspacePathCandidate(href);
+  const candidate = parseWorkspacePathLocation(href);
   if (!candidate) return null;
-  return looksLikeWorkspacePath(candidate) ? candidate : null;
+  return looksLikeWorkspacePath(href) ? candidate : null;
 }
 
 function chatMarkdownUrlTransform(value: string): string {
@@ -513,21 +561,21 @@ function InlineDisclosureRow({
 }
 
 function resolveFilesNavigationTarget(args: {
-  path: string;
+  path: string | WorkspacePathLocation;
   workspaces: FilesWorkspace[];
   fallbackLaneId: string | null;
-}): { openFilePath: string; laneId: string | null } | null {
-  const candidate = normalizeWorkspacePathCandidate(args.path);
+}): { openFilePath: string; laneId: string | null; startLine?: number; startColumn?: number } | null {
+  const candidate = typeof args.path === "string" ? parseWorkspacePathLocation(args.path) : args.path;
   if (!candidate) return null;
 
-  const normalizedCandidate = normalizePath(candidate);
+  const normalizedCandidate = normalizePath(candidate.path);
   if (normalizedCandidate.startsWith("/") || isWindowsAbsolutePath(normalizedCandidate)) {
     const matches = args.workspaces
       .map((workspace) => ({
         workspace,
         rootPath: normalizePath(workspace.rootPath),
       }))
-      .filter(({ workspace }) => isPathEqualOrDescendant(normalizedCandidate, workspace.rootPath))
+      .filter(({ rootPath }) => isPathEqualOrDescendant(normalizedCandidate, rootPath))
       .sort((left, right) => {
         const rightMatchesLane = right.workspace.laneId != null && right.workspace.laneId === args.fallbackLaneId ? 1 : 0;
         const leftMatchesLane = left.workspace.laneId != null && left.workspace.laneId === args.fallbackLaneId ? 1 : 0;
@@ -542,6 +590,8 @@ function resolveFilesNavigationTarget(args: {
     return {
       openFilePath,
       laneId: match.workspace.laneId ?? args.fallbackLaneId ?? null,
+      startLine: candidate.startLine,
+      startColumn: candidate.startColumn,
     };
   }
 
@@ -550,6 +600,8 @@ function resolveFilesNavigationTarget(args: {
   return {
     openFilePath,
     laneId: args.fallbackLaneId ?? null,
+    startLine: candidate.startLine,
+    startColumn: candidate.startColumn,
   };
 }
 
@@ -561,10 +613,10 @@ const MarkdownBlock = React.memo(function MarkdownBlock({
   workspaceLaneId,
 }: {
   markdown: string;
-  onOpenWorkspacePath?: (path: string, laneId?: string | null) => void;
+  onOpenWorkspacePath?: (path: string | WorkspacePathLocation, laneId?: string | null) => void;
   workspaceLaneId?: string | null;
 }) {
-  const openWorkspacePath = useCallback((path: string) => {
+  const openWorkspacePath = useCallback((path: WorkspacePathLocation) => {
     onOpenWorkspacePath?.(path, workspaceLaneId ?? null);
   }, [onOpenWorkspacePath, workspaceLaneId]);
 
@@ -611,8 +663,8 @@ const MarkdownBlock = React.memo(function MarkdownBlock({
           code: ({ className, children }) => {
             const text = String(children ?? "");
             const isBlock = /\n/.test(text) || (typeof className === "string" && className.length > 0);
-            const workspacePath = !isBlock ? normalizeWorkspacePathCandidate(text) : null;
-            const pathIsClickable = Boolean(workspacePath && looksLikeWorkspacePath(workspacePath));
+            const workspacePath = !isBlock ? parseWorkspacePathLocation(text) : null;
+            const pathIsClickable = Boolean(workspacePath && looksLikeWorkspacePath(text));
             return isBlock ? (
               <code className="font-mono text-[11px] text-fg/82">{children}</code>
             ) : pathIsClickable ? (
@@ -1390,7 +1442,7 @@ function renderEvent(
     assistantLabel?: string;
     turnActive?: boolean;
     sessionEnded?: boolean;
-    onOpenWorkspacePath?: (path: string) => void;
+    onOpenWorkspacePath?: (path: string | WorkspacePathLocation) => void;
     respondingApprovalIds?: Set<string>;
     pendingApprovalIds?: Set<string>;
     resolvedInputStates?: Map<string, PendingInputResolution>;
@@ -2755,7 +2807,7 @@ type EventRowProps = {
   turnActive?: boolean;
   sessionEnded?: boolean;
   isLatestWorkLog?: boolean;
-  onOpenWorkspacePath?: (path: string) => void;
+  onOpenWorkspacePath?: (path: string | WorkspacePathLocation) => void;
   onNavigateSuggestion?: (suggestion: OperatorNavigationSuggestion) => void;
   respondingApprovalIds?: Set<string>;
   pendingApprovalIds?: Set<string>;
@@ -3068,15 +3120,15 @@ export function AgentChatMessageList({
     };
   }, []);
 
-  const openWorkspacePath = useCallback(async (path: string) => {
+  const openWorkspacePath = useCallback(async (path: string | WorkspacePathLocation) => {
     let resolvedWorkspaces = filesWorkspaces;
     let target = resolveFilesNavigationTarget({
       path,
       workspaces: resolvedWorkspaces,
       fallbackLaneId: currentLaneId,
     });
-    const workspaceCandidate = normalizeWorkspacePathCandidate(path);
-    if (!target && workspaceCandidate && (workspaceCandidate.startsWith("/") || isWindowsAbsolutePath(workspaceCandidate))) {
+    const workspaceCandidate = typeof path === "string" ? parseWorkspacePathLocation(path) : path;
+    if (!target && workspaceCandidate && (workspaceCandidate.path.startsWith("/") || isWindowsAbsolutePath(workspaceCandidate.path))) {
       const listWorkspaces = window.ade?.files?.listWorkspaces;
       if (typeof listWorkspaces === "function") {
         try {
@@ -3093,9 +3145,12 @@ export function AgentChatMessageList({
       }
     }
     if (!target) return;
-    const state = target.laneId
-      ? { openFilePath: target.openFilePath, laneId: target.laneId }
-      : { openFilePath: target.openFilePath };
+    const state = {
+      openFilePath: target.openFilePath,
+      ...(target.laneId ? { laneId: target.laneId } : {}),
+      ...(typeof target.startLine === "number" ? { startLine: target.startLine } : {}),
+      ...(typeof target.startColumn === "number" ? { startColumn: target.startColumn } : {}),
+    };
     navigate("/files", { state });
     onOpenWorkspacePath?.(target.openFilePath, target.laneId);
   }, [currentLaneId, filesWorkspaces, navigate, onOpenWorkspacePath]);
diff --git a/apps/desktop/src/renderer/components/files/FilesPage.test.tsx b/apps/desktop/src/renderer/components/files/FilesPage.test.tsx
index 53aa9ac11..7a1b239c6 100644
--- a/apps/desktop/src/renderer/components/files/FilesPage.test.tsx
+++ b/apps/desktop/src/renderer/components/files/FilesPage.test.tsx
@@ -12,12 +12,16 @@ type MockEditorInstance = {
   setModel: (next: any) => void;
   getValue: () => string;
   setValue: (next: string) => void;
+  revealLineInCenter: ReturnType<typeof vi.fn>;
+  setPosition: ReturnType<typeof vi.fn>;
+  focus: ReturnType<typeof vi.fn>;
   updateOptions: ReturnType<typeof vi.fn>;
   onDidChangeModelContent: (cb: () => void) => { dispose: ReturnType<typeof vi.fn> };
   dispose: ReturnType<typeof vi.fn>;
 };
 
 let latestMockEditor: MockEditorInstance | null = null;
+let createdMockEditors: MockEditorInstance[] = [];
 
 vi.mock("../lanes/MonacoDiffView", () => ({
   MonacoDiffView: () => <div data-testid="monaco-diff" />,
@@ -57,6 +61,9 @@ vi.mock("monaco-editor", () => {
             element.textContent = next;
             onChange?.();
           },
+          revealLineInCenter: vi.fn(),
+          setPosition: vi.fn(),
+          focus: vi.fn(),
           updateOptions: vi.fn(),
           onDidChangeModelContent(cb: () => void) {
             onChange = cb;
@@ -64,6 +71,7 @@ vi.mock("monaco-editor", () => {
           },
           dispose: vi.fn(),
         };
+        createdMockEditors.push(latestMockEditor);
         return latestMockEditor;
       }),
       createModel: vi.fn(createModel),
@@ -192,6 +200,7 @@ describe("FilesPage", () => {
     projectRoot = `/Users/arul/ADE-${projectCounter}`;
     resetStore();
     latestMockEditor = null;
+    createdMockEditors = [];
     changeListener = null;
     currentTree = cloneTree(ignoredTree);
     fileContents = {
@@ -227,7 +236,8 @@ describe("FilesPage", () => {
           };
         }),
         readFile: vi.fn(async ({ path }: { path: string }) => {
-          const content = fileContents[path];
+          const content = fileContents[path]
+            ?? fileContents[Object.keys(fileContents).find((candidate) => candidate.toLowerCase() === path.toLowerCase()) ?? ""];
           if (content == null) {
             throw new Error(`ENOENT: ${path}`);
           }
@@ -271,6 +281,7 @@ describe("FilesPage", () => {
   afterEach(() => {
     cleanup();
     latestMockEditor = null;
+    createdMockEditors = [];
     changeListener = null;
     window.localStorage.clear();
     globalThis.window.confirm = originalConfirm;
@@ -482,4 +493,109 @@ describe("FilesPage", () => {
       vi.useRealTimers();
     }
   });
+
+  it("treats Windows workspace paths case-insensitively for open tabs and watcher events", async () => {
+    projectRoot = "C:/Repo";
+    resetStore();
+    currentTree = [
+      {
+        name: "src",
+        path: "src",
+        type: "directory",
+        children: [
+          {
+            name: "Main.ts",
+            path: "src/Main.ts",
+            type: "file",
+          },
+        ],
+      },
+    ];
+    fileContents = {
+      "src/Main.ts": "export const value = 7;\n",
+      "src/Renamed.ts": "export const value = 8;\n",
+    };
+    vi.mocked(window.ade.files.listWorkspaces).mockResolvedValue([
+      {
+        id: "primary",
+        kind: "primary",
+        laneId: null,
+        name: "ADE",
+        rootPath: "C:\\Repo",
+        isReadOnlyByDefault: false,
+      },
+    ]);
+
+    renderFilesPage({
+      openFilePath: "src/main.ts",
+    });
+
+    await waitForEditorText("value = 7");
+    await waitForFilesWatcherStartup();
+    expect((window.ade.files.readFile as any).mock.calls.some(([arg]: [{ path: string }]) => arg.path.toLowerCase() === "src/main.ts")).toBe(true);
+
+    emitFileChange({
+      workspaceId: "primary",
+      type: "renamed",
+      oldPath: "SRC\\MAIN.ts",
+      path: "src\\Renamed.ts",
+      ts: new Date().toISOString(),
+    });
+
+    await waitForEditorText("value = 8");
+    await waitFor(() => {
+      expect(screen.getAllByText("Renamed.ts").length).toBeGreaterThan(0);
+    });
+    expect(screen.queryAllByText("Main.ts")).toHaveLength(0);
+
+    emitFileChange({
+      workspaceId: "primary",
+      type: "deleted",
+      path: "SRC\\RENAMED.ts",
+      ts: new Date().toISOString(),
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText(/OPEN A FILE TO START EDITING/i)).toBeTruthy();
+    });
+  });
+
+  it("reveals navigation line targets in the editor view", async () => {
+    renderFilesPage({
+      openFilePath: "src/index.ts",
+      preferPrimaryWorkspace: true,
+      startLine: 3,
+      startColumn: 7,
+    });
+
+    await waitForEditorText("value = 1");
+    await waitFor(() => {
+      expect(createdMockEditors.some((editor) =>
+        editor.revealLineInCenter.mock.calls.some(([line]) => line === 3)
+      )).toBe(true);
+      expect(createdMockEditors.some((editor) =>
+        editor.setPosition.mock.calls.some(([position]) =>
+          position?.lineNumber === 3 && position?.column === 7
+        )
+      )).toBe(true);
+    });
+  });
+
+  it("opens the active file in the system default app", async () => {
+    renderFilesPage({
+      openFilePath: "src/index.ts",
+      preferPrimaryWorkspace: true,
+    });
+
+    await waitForEditorText("value = 1");
+
+    fireEvent.click(screen.getByRole("button", { name: /open in/i }));
+    fireEvent.click(await screen.findByText("SYSTEM DEFAULT"));
+
+    expect(window.ade.app.openPathInEditor).toHaveBeenCalledWith({
+      rootPath: projectRoot,
+      relativePath: "src/index.ts",
+      target: "default",
+    });
+  });
 });
diff --git a/apps/desktop/src/renderer/components/files/FilesPage.tsx b/apps/desktop/src/renderer/components/files/FilesPage.tsx
index e4f73c02e..a654932c9 100644
--- a/apps/desktop/src/renderer/components/files/FilesPage.tsx
+++ b/apps/desktop/src/renderer/components/files/FilesPage.tsx
@@ -35,7 +35,7 @@ import { MonacoDiffView, type MonacoDiffHandle } from "../lanes/MonacoDiffView";
 import { useAppStore } from "../../state/appStore";
 import { clearDirtyBuffersForWorkspace, replaceDirtyBuffersForWorkspace } from "../../lib/dirtyWorkspaceBuffers";
 import { modifierKeyLabel, revealLabel } from "../../lib/platform";
-import { normalizePath, isPathEqualOrDescendant, remapPathForRename } from "../../lib/pathUtils";
+import { arePathsEqual, normalizePath, normalizePathForWorkspaceComparison, isPathEqualOrDescendant, remapPathForRename } from "../../lib/pathUtils";
 import { logRendererDebugEvent } from "../../lib/debugLog";
 import { COLORS, MONO_FONT, SANS_FONT, LABEL_STYLE, inlineBadge, outlineButton, primaryButton, dangerButton, cardStyle } from "../lanes/laneDesignTokens";
 import { cn } from "../ui/cn";
@@ -55,6 +55,7 @@ type FilesPageNavState = {
   preferPrimaryWorkspace?: boolean;
   mode?: "edit" | "diff";
   startLine?: number;
+  startColumn?: number;
 };
 
 type ConflictHunk = {
@@ -84,7 +85,7 @@ type TextPromptState = {
 
 type EditorViewMode = "edit" | "diff" | "conflict";
 type EditorThemeMode = "dark" | "light";
-type ExternalEditorTarget = "finder" | "vscode" | "cursor" | "zed";
+type ExternalEditorTarget = "default" | "finder" | "vscode" | "cursor" | "zed";
 type FilesPaneConfig = {
   title: string;
   icon?: React.ElementType;
@@ -311,6 +312,20 @@ function parentDirOfPath(filePath: string): string {
   return normalized.slice(0, idx);
 }
 
+function areWorkspacePathsEqual(left: string | null | undefined, right: string | null | undefined, workspaceRoot?: string | null): boolean {
+  if (left == null || right == null) return left === right;
+  return arePathsEqual(left, right, workspaceRoot);
+}
+
+function findItemByWorkspacePath<T extends { path: string }>(
+  items: ReadonlyArray<T>,
+  targetPath: string | null | undefined,
+  workspaceRoot?: string | null,
+): T | undefined {
+  if (!targetPath) return undefined;
+  return items.find((item) => areWorkspacePathsEqual(item.path, targetPath, workspaceRoot));
+}
+
 const FILE_ICON_COLORS = {
   code: "#38BDF8",       // sky-400
   json: "#34D399",       // emerald-400
@@ -388,7 +403,16 @@ export function FilesPage() {
   const [tree, setTree] = useState<FileTreeNode[]>([]);
   const [expanded, setExpanded] = useState<Set<string>>(new Set());
   const [selectedNodePath, setSelectedNodePath] = useState<string | null>(initialSession?.selectedNodePath ?? null);
-  const pendingOpenRef = useRef<{ filePath: string; laneId: string | null; preferPrimaryWorkspace: boolean; key: string; mode?: "edit" | "diff"; startLine?: number } | null>(null);
+  const pendingOpenRef = useRef<{
+    filePath: string;
+    laneId: string | null;
+    preferPrimaryWorkspace: boolean;
+    key: string;
+    mode?: "edit" | "diff";
+    startLine?: number;
+    startColumn?: number;
+  } | null>(null);
+  const pendingRevealRef = useRef<{ mode: EditorViewMode; startLine: number; startColumn?: number } | null>(null);
   const diffViewRef = useRef<MonacoDiffHandle | null>(null);
   const treeRefreshStateRef = useRef<{
     inFlight: boolean;
@@ -438,9 +462,42 @@ export function FilesPage() {
   const setEditorHostRef = useCallback((node: HTMLDivElement | null) => {
     setEditorHostEl(node);
   }, []);
+  const revealPendingLocation = useCallback((): boolean => {
+    const pendingReveal = pendingRevealRef.current;
+    if (!pendingReveal) return false;
+
+    if (pendingReveal.mode === "diff") {
+      const handle = diffViewRef.current;
+      if (!handle) return false;
+      try {
+        handle.revealLineInCenter(pendingReveal.startLine);
+      } catch {
+        return false;
+      }
+      pendingRevealRef.current = null;
+      return true;
+    }
+
+    const editor = editorRef.current;
+    if (!editor) return false;
+    try {
+      editor.revealLineInCenter(pendingReveal.startLine);
+      if (typeof pendingReveal.startColumn === "number" && pendingReveal.startColumn > 0) {
+        editor.setPosition({ lineNumber: pendingReveal.startLine, column: pendingReveal.startColumn });
+      }
+    } catch {
+      return false;
+    }
+    pendingRevealRef.current = null;
+    return true;
+  }, []);
 
   const activeWorkspace = useMemo(() => workspaces.find((ws) => ws.id === workspaceId) ?? null, [workspaces, workspaceId]);
-  const activeTab = useMemo(() => openTabs.find((tab) => tab.path === activeTabPath) ?? null, [openTabs, activeTabPath]);
+  const workspaceComparisonRoot = activeWorkspace?.rootPath ?? null;
+  const activeTab = useMemo(
+    () => findItemByWorkspacePath(openTabs, activeTabPath, workspaceComparisonRoot) ?? null,
+    [openTabs, activeTabPath, workspaceComparisonRoot],
+  );
   const canEdit = Boolean(activeWorkspace) && (!activeWorkspace?.isReadOnlyByDefault || allowPrimaryEdit);
   const liveWatchEnabled = openTabs.length > 0;
 
@@ -591,23 +648,27 @@ export function FilesPage() {
     return true;
   }, [workspaceId, hasUnsavedTabs]);
 
-  const nodeByPath = useMemo(() => {
+  const nodeByComparablePath = useMemo(() => {
     const out = new Map<string, FileTreeNode>();
     const walk = (nodes: FileTreeNode[]) => {
       for (const node of nodes) {
-        out.set(node.path, node);
+        out.set(normalizePathForWorkspaceComparison(node.path, workspaceComparisonRoot), node);
         if (node.children?.length) walk(node.children);
       }
     };
     walk(tree);
     return out;
-  }, [tree]);
+  }, [tree, workspaceComparisonRoot]);
   const selectedTreeNodePath = useMemo(() => {
     if (!selectedNodePath) return null;
-    return nodeByPath.has(selectedNodePath) ? selectedNodePath : null;
-  }, [nodeByPath, selectedNodePath]);
+    return nodeByComparablePath.get(normalizePathForWorkspaceComparison(selectedNodePath, workspaceComparisonRoot))?.path ?? null;
+  }, [nodeByComparablePath, selectedNodePath, workspaceComparisonRoot]);
   const activeContextPath = contextMenu?.nodePath ?? selectedTreeNodePath ?? activeTabPath;
-  const activeContextNodeType = contextMenu?.nodeType ?? (activeContextPath ? nodeByPath.get(activeContextPath)?.type : undefined);
+  const activeContextNodeType = contextMenu?.nodeType ?? (
+    activeContextPath
+      ? nodeByComparablePath.get(normalizePathForWorkspaceComparison(activeContextPath, workspaceComparisonRoot))?.type
+      : undefined
+  );
   const laneWorkspaces = useMemo(() => workspaces.filter((ws) => ws.kind !== "primary"), [workspaces]);
   const suggestedLaneWorkspace = useMemo(() => {
     if (!laneWorkspaces.length) return null;
@@ -651,17 +712,28 @@ export function FilesPage() {
   }, [workspaceId, tree.length, openTabs.length, activeTabPath, mode, editorStatus, searchQuery, showQuickOpen]);
 
   useEffect(() => {
-    activeTabPathRef.current = activeTabPath;
-  }, [activeTabPath]);
+    activeTabPathRef.current = activeTab?.path ?? activeTabPath;
+  }, [activeTab?.path, activeTabPath]);
 
   useEffect(() => {
     openTabsRef.current = openTabs;
   }, [openTabs]);
 
+  useEffect(() => {
+    void revealPendingLocation();
+  }, [revealPendingLocation, mode, editorStatus, activeTab?.path]);
+
   useEffect(() => {
     const st = (location.state as FilesPageNavState | null) ?? null;
     const openFilePath = st?.openFilePath?.trim();
     if (!openFilePath) return;
+    if (typeof st?.startLine === "number" && st.startLine > 0) {
+      pendingRevealRef.current = {
+        mode: st?.mode ?? "edit",
+        startLine: st.startLine,
+        startColumn: st?.startColumn,
+      };
+    }
     pendingOpenRef.current = {
       key: location.key,
       filePath: openFilePath,
@@ -669,6 +741,7 @@ export function FilesPage() {
       preferPrimaryWorkspace: st?.preferPrimaryWorkspace === true,
       mode: st?.mode,
       startLine: st?.startLine,
+      startColumn: st?.startColumn,
     };
   }, [location.key, location.state]);
 
@@ -760,20 +833,22 @@ export function FilesPage() {
 
   const openFile = useCallback(async (filePath: string, options: { forceReload?: boolean; preserveMode?: boolean } = {}) => {
     if (!workspaceId) return;
-    const normalizedPath = normalizePath(filePath);
+    const requestedPath = normalizePath(filePath);
+    const normalizedPath = nodeByComparablePath.get(normalizePathForWorkspaceComparison(requestedPath, workspaceComparisonRoot))?.path ?? requestedPath;
     try {
       const loaded = await window.ade.files.readFile({ workspaceId, path: normalizedPath });
       if (loaded.isBinary) {
         setError("Binary files are read-only and cannot be edited in this view.");
       }
       setOpenTabs((prev) => {
-        const existing = prev.find((tab) => tab.path === normalizedPath);
+        const existing = findItemByWorkspacePath(prev, normalizedPath, workspaceComparisonRoot);
         if (existing && !options.forceReload) return prev;
         if (existing && options.forceReload) {
           return prev.map((tab) => (
-            tab.path === normalizedPath
+            areWorkspacePathsEqual(tab.path, normalizedPath, workspaceComparisonRoot)
               ? {
                 ...tab,
+                path: normalizedPath,
                 content: loaded.content,
                 savedContent: loaded.content,
                 languageId: loaded.languageId,
@@ -801,13 +876,16 @@ export function FilesPage() {
     } catch (err) {
       setError(err instanceof Error ? err.message : String(err));
     }
-  }, [workspaceId]);
+  }, [workspaceId, nodeByComparablePath, workspaceComparisonRoot]);
 
   const syncCleanTabFromDisk = useCallback(async (filePathRaw: string) => {
     if (!workspaceId) return;
-    const filePath = normalizePath(filePathRaw);
+    const requestedPath = normalizePath(filePathRaw);
+    const filePath = nodeByComparablePath.get(normalizePathForWorkspaceComparison(requestedPath, workspaceComparisonRoot))?.path ?? requestedPath;
     if (!filePath) return;
-    const hasCleanOpenTab = openTabsRef.current.some((tab) => tab.path === filePath && tab.content === tab.savedContent);
+    const hasCleanOpenTab = openTabsRef.current.some((tab) => (
+      areWorkspacePathsEqual(tab.path, filePath, workspaceComparisonRoot) && tab.content === tab.savedContent
+    ));
     if (!hasCleanOpenTab) return;
 
     try {
@@ -815,9 +893,10 @@ export function FilesPage() {
       setOpenTabs((prev) => {
         let changed = false;
         const next = prev.map((tab) => {
-          if (tab.path !== filePath) return tab;
+          if (!areWorkspacePathsEqual(tab.path, filePath, workspaceComparisonRoot)) return tab;
           if (tab.content !== tab.savedContent) return tab;
           if (
+            areWorkspacePathsEqual(tab.path, filePath, workspaceComparisonRoot) &&
             tab.content === loaded.content &&
             tab.savedContent === loaded.content &&
             tab.languageId === loaded.languageId &&
@@ -828,6 +907,7 @@ export function FilesPage() {
           changed = true;
           return {
             ...tab,
+            path: filePath,
             content: loaded.content,
             savedContent: loaded.content,
             languageId: loaded.languageId,
@@ -839,7 +919,7 @@ export function FilesPage() {
     } catch {
       // A deleted or renamed path can race this sync; ignore quietly.
     }
-  }, [workspaceId]);
+  }, [workspaceId, workspaceComparisonRoot, nodeByComparablePath]);
 
   useEffect(() => {
     const pending = pendingOpenRef.current;
@@ -865,6 +945,7 @@ export function FilesPage() {
 
     const pendingMode = pending.mode;
     const pendingStartLine = pending.startLine;
+    const pendingStartColumn = pending.startColumn;
     let cancelled = false;
     let pendingTimer: ReturnType<typeof setTimeout> | null = null;
     openFile(pending.filePath)
@@ -872,17 +953,14 @@ export function FilesPage() {
         if (cancelled) return;
         if (pendingMode === "diff") setMode("diff");
         if (typeof pendingStartLine === "number" && pendingStartLine > 0) {
+          pendingRevealRef.current = {
+            mode: pendingMode ?? "edit",
+            startLine: pendingStartLine,
+            startColumn: pendingStartColumn,
+          };
           const attemptReveal = (attemptsLeft: number) => {
             if (cancelled) return;
-            const handle = diffViewRef.current;
-            if (handle) {
-              try {
-                handle.revealLineInCenter(pendingStartLine);
-              } catch {
-                /* ignore */
-              }
-              return;
-            }
+            if (revealPendingLocation()) return;
             if (attemptsLeft > 0) {
               pendingTimer = setTimeout(() => attemptReveal(attemptsLeft - 1), 80);
             }
@@ -897,29 +975,31 @@ export function FilesPage() {
       cancelled = true;
       if (pendingTimer !== null) clearTimeout(pendingTimer);
     };
-  }, [workspaces, workspaceId, switchWorkspace, openFile, navigate, location.pathname]);
+  }, [workspaces, workspaceId, switchWorkspace, openFile, navigate, location.pathname, revealPendingLocation]);
 
   const closeTab = useCallback((filePath: string) => {
     setOpenTabs((prev) => {
-      const tab = prev.find((t) => t.path === filePath);
+      const tab = findItemByWorkspacePath(prev, filePath, workspaceComparisonRoot);
       if (!tab) return prev;
       if (tab.content !== tab.savedContent) {
-        const ok = window.confirm(`"${filePath}" has unsaved changes. Close anyway?`);
+        const ok = window.confirm(`"${tab.path}" has unsaved changes. Close anyway?`);
         if (!ok) return prev;
       }
-      const next = prev.filter((t) => t.path !== filePath);
-      if (activeTabPath === filePath) {
+      const next = prev.filter((t) => !areWorkspacePathsEqual(t.path, filePath, workspaceComparisonRoot));
+      if (areWorkspacePathsEqual(activeTabPath, filePath, workspaceComparisonRoot)) {
         setActiveTabPath(next[next.length - 1]?.path ?? null);
       }
       return next;
     });
-  }, [activeTabPath]);
+  }, [activeTabPath, workspaceComparisonRoot]);
 
   const saveActive = useCallback(async () => {
     if (!activeTab || !workspaceId || !canEdit || activeTab.isBinary) return;
     await window.ade.files.writeText({ workspaceId, path: activeTab.path, text: activeTab.content });
-    setOpenTabs((prev) => prev.map((tab) => (tab.path === activeTab.path ? { ...tab, savedContent: tab.content } : tab)));
-  }, [activeTab, workspaceId, canEdit]);
+    setOpenTabs((prev) => prev.map((tab) => (
+      areWorkspacePathsEqual(tab.path, activeTab.path, workspaceComparisonRoot) ? { ...tab, savedContent: tab.content } : tab
+    )));
+  }, [activeTab, workspaceId, canEdit, workspaceComparisonRoot]);
 
   const laneIdForWorkspace = activeWorkspace?.laneId ?? null;
 
@@ -953,10 +1033,10 @@ export function FilesPage() {
     if (!ok) return;
     await window.ade.git.discardFile({ laneId: laneIdForWorkspace, path: filePath });
     await refreshTree();
-    if (activeTabPath === filePath) {
+    if (areWorkspacePathsEqual(activeTabPath, filePath, workspaceComparisonRoot)) {
       await openFile(filePath, { forceReload: true });
     }
-  }, [canEdit, laneIdForWorkspace, refreshTree, activeTabPath, openFile]);
+  }, [canEdit, laneIdForWorkspace, refreshTree, activeTabPath, openFile, workspaceComparisonRoot]);
 
   const renamePath = useCallback(async (targetPath: string) => {
     if (!canEdit) {
@@ -975,13 +1055,15 @@ export function FilesPage() {
         return null;
       }
     });
-    if (!next || next === targetPath) return;
+    if (!next || areWorkspacePathsEqual(next, targetPath, workspaceComparisonRoot)) return;
     await window.ade.files.rename({ workspaceId, oldPath: targetPath, newPath: next });
-    setOpenTabs((prev) => prev.map((tab) => (tab.path === targetPath ? { ...tab, path: next } : tab)));
-    if (activeTabPath === targetPath) setActiveTabPath(next);
+    setOpenTabs((prev) => prev.map((tab) => (
+      areWorkspacePathsEqual(tab.path, targetPath, workspaceComparisonRoot) ? { ...tab, path: next } : tab
+    )));
+    if (areWorkspacePathsEqual(activeTabPath, targetPath, workspaceComparisonRoot)) setActiveTabPath(next);
     setSelectedNodePath(next);
     await refreshTree();
-  }, [canEdit, workspaceId, requestTextInput, activeTabPath, refreshTree]);
+  }, [canEdit, workspaceId, requestTextInput, activeTabPath, refreshTree, workspaceComparisonRoot]);
 
   const deletePath = useCallback(async (targetPath: string) => {
     if (!canEdit) {
@@ -992,11 +1074,11 @@ export function FilesPage() {
     const ok = window.confirm(`Delete ${targetPath}?`);
     if (!ok) return;
     await window.ade.files.delete({ workspaceId, path: targetPath });
-    setOpenTabs((prev) => prev.filter((tab) => tab.path !== targetPath));
-    if (activeTabPath === targetPath) setActiveTabPath(null);
+    setOpenTabs((prev) => prev.filter((tab) => !areWorkspacePathsEqual(tab.path, targetPath, workspaceComparisonRoot)));
+    if (areWorkspacePathsEqual(activeTabPath, targetPath, workspaceComparisonRoot)) setActiveTabPath(null);
     setSelectedNodePath(null);
     await refreshTree();
-  }, [canEdit, workspaceId, activeTabPath, refreshTree]);
+  }, [canEdit, workspaceId, activeTabPath, refreshTree, workspaceComparisonRoot]);
 
   const createFileAt = useCallback(async (basePath?: string) => {
     if (!canEdit) {
@@ -1145,7 +1227,7 @@ export function FilesPage() {
         setOpenTabs((prev) => {
           let changed = false;
           const next = prev.map((tab) => {
-            const mappedPath = remapPathForRename(tab.path, oldPath, nextPath);
+            const mappedPath = remapPathForRename(tab.path, oldPath, nextPath, workspaceComparisonRoot);
             if (mappedPath === tab.path) return tab;
             changed = true;
             if (tab.content === tab.savedContent) pendingTabSyncPaths.add(mappedPath);
@@ -1153,13 +1235,13 @@ export function FilesPage() {
           });
           return changed ? next : prev;
         });
-        setActiveTabPath((current) => (current ? remapPathForRename(current, oldPath, nextPath) : current));
-        setSelectedNodePath((current) => (current ? remapPathForRename(current, oldPath, nextPath) : current));
+        setActiveTabPath((current) => (current ? remapPathForRename(current, oldPath, nextPath, workspaceComparisonRoot) : current));
+        setSelectedNodePath((current) => (current ? remapPathForRename(current, oldPath, nextPath, workspaceComparisonRoot) : current));
         setExpanded((prev) => {
           let changed = false;
           const next = new Set<string>();
           for (const path of prev) {
-            const mappedPath = remapPathForRename(path, oldPath, nextPath);
+            const mappedPath = remapPathForRename(path, oldPath, nextPath, workspaceComparisonRoot);
             next.add(mappedPath);
             if (mappedPath !== path) changed = true;
           }
@@ -1173,18 +1255,18 @@ export function FilesPage() {
 
       if (ev.type === "deleted" && nextPath) {
         setOpenTabs((prev) => {
-          const next = prev.filter((tab) => !isPathEqualOrDescendant(tab.path, nextPath));
+          const next = prev.filter((tab) => !isPathEqualOrDescendant(tab.path, nextPath, workspaceComparisonRoot));
           if (next.length !== prev.length) {
             const activePath = activeTabPathRef.current;
-            if (activePath && !next.some((tab) => tab.path === activePath)) {
+            if (activePath && !next.some((tab) => areWorkspacePathsEqual(tab.path, activePath, workspaceComparisonRoot))) {
               setActiveTabPath(next[next.length - 1]?.path ?? null);
             }
           }
           return next.length === prev.length ? prev : next;
         });
-        setSelectedNodePath((current) => (current && isPathEqualOrDescendant(current, nextPath) ? null : current));
+        setSelectedNodePath((current) => (current && isPathEqualOrDescendant(current, nextPath, workspaceComparisonRoot) ? null : current));
         setExpanded((prev) => {
-          const next = new Set(Array.from(prev).filter((path) => !isPathEqualOrDescendant(path, nextPath)));
+          const next = new Set(Array.from(prev).filter((path) => !isPathEqualOrDescendant(path, nextPath, workspaceComparisonRoot)));
           return next.size === prev.size ? prev : next;
         });
       } else if (nextPath) {
@@ -1244,7 +1326,7 @@ export function FilesPage() {
           });
         });
     };
-  }, [workspaceId, liveWatchEnabled, refreshTree, syncCleanTabFromDisk]);
+  }, [workspaceId, liveWatchEnabled, refreshTree, syncCleanTabFromDisk, workspaceComparisonRoot]);
 
   useEffect(() => {
     const onBeforeUnload = (event: BeforeUnloadEvent) => {
@@ -1369,9 +1451,12 @@ export function FilesPage() {
         const targetPath = activeTabPathRef.current;
         if (!targetPath || editorApplyingRef.current) return;
         const next = editor.getValue();
-        setOpenTabs((prev) => prev.map((tab) => (tab.path === targetPath ? { ...tab, content: next } : tab)));
+        setOpenTabs((prev) => prev.map((tab) => (
+          areWorkspacePathsEqual(tab.path, targetPath, workspaceComparisonRoot) ? { ...tab, content: next } : tab
+        )));
       });
       setEditorStatus("ready");
+      void revealPendingLocation();
       logRendererDebugEvent("renderer.files.monaco_load.done", {
         path: activeTab.path,
       });
@@ -1409,7 +1494,7 @@ export function FilesPage() {
   // canEdit intentionally excluded — the updateOptions effect below handles
   // readOnly toggling without destroying and recreating the entire editor.
   // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [activeTab?.path, mode, editorHostEl, editorTheme]);
+  }, [activeTab?.path, mode, editorHostEl, editorTheme, revealPendingLocation]);
 
   useEffect(() => {
     const monaco = monacoRef.current;
@@ -1445,6 +1530,7 @@ export function FilesPage() {
     const modelKey = `${activeTab.path}::${language}`;
     if (modelRef.current && modelKeyRef.current === modelKey) {
       editor.updateOptions({ readOnly: !canEdit || activeTab.isBinary });
+      void revealPendingLocation();
       return;
     }
 
@@ -1462,7 +1548,8 @@ export function FilesPage() {
     modelKeyRef.current = modelKey;
     editor.setModel(modelRef.current);
     editor.updateOptions({ readOnly: !canEdit || activeTab.isBinary });
-  }, [activeTab?.path, activeTab?.languageId, activeTab?.isBinary, mode, canEdit, editorStatus]);
+    void revealPendingLocation();
+  }, [activeTab?.path, activeTab?.languageId, activeTab?.isBinary, mode, canEdit, editorStatus, revealPendingLocation]);
 
   useEffect(() => {
     if (!activeTab || !editorRef.current || mode !== "edit") return;
@@ -1481,7 +1568,8 @@ export function FilesPage() {
     <div>
       {nodes.map((node) => {
         const isExpanded = expanded.has(node.path);
-        const isActive = activeTabPath === node.path || selectedTreeNodePath === node.path;
+        const isActive = areWorkspacePathsEqual(activeTabPath, node.path, workspaceComparisonRoot)
+          || areWorkspacePathsEqual(selectedTreeNodePath, node.path, workspaceComparisonRoot);
         const statusColor = changeStatusColor(node.changeStatus ?? null);
         const fileIcon = node.type === "file" ? getFileIcon(node.name) : null;
         const FileIcon = fileIcon?.icon;
@@ -1584,7 +1672,9 @@ export function FilesPage() {
   const conflictHunks = activeTab ? parseConflictHunks(activeTab.content) : [];
   const laneIdForDiff = activeWorkspace?.laneId;
   const hasConflictMarkers = conflictHunks.length > 0;
-  const activeContextNode = activeContextPath ? nodeByPath.get(activeContextPath) ?? null : null;
+  const activeContextNode = activeContextPath
+    ? nodeByComparablePath.get(normalizePathForWorkspaceComparison(activeContextPath, workspaceComparisonRoot)) ?? null
+    : null;
   const activeContextChangeStatus = activeContextNode?.changeStatus ?? null;
   const editorModeHint =
     mode === "edit"
@@ -1805,7 +1895,7 @@ export function FilesPage() {
             ) : null}
             {openTabs.map((tab, idx) => {
               const dirty = tab.content !== tab.savedContent;
-              const isActiveTab = activeTabPath === tab.path;
+              const isActiveTab = areWorkspacePathsEqual(activeTabPath, tab.path, workspaceComparisonRoot);
               const tabNumber = String(idx + 1).padStart(2, "0");
               const tabFileIcon = getFileIcon(tab.path.split("/").pop() ?? "");
               const TabFileIcon = tabFileIcon.icon;
@@ -2217,6 +2307,7 @@ export function FilesPage() {
             <div className="ade-liquid-glass-menu absolute right-0 top-full z-50 mt-1 overflow-hidden" style={{ width: 220, padding: "2px 0" }}>
               {(
                 [
+                  { key: "default", label: "SYSTEM DEFAULT" },
                   { key: "finder", label: revealLabel.toUpperCase() },
                   { key: "vscode", label: "VS CODE" },
                   { key: "cursor", label: "CURSOR" },
diff --git a/apps/desktop/src/renderer/lib/dirtyWorkspaceBuffers.test.ts b/apps/desktop/src/renderer/lib/dirtyWorkspaceBuffers.test.ts
index dfba3115d..93dd928f3 100644
--- a/apps/desktop/src/renderer/lib/dirtyWorkspaceBuffers.test.ts
+++ b/apps/desktop/src/renderer/lib/dirtyWorkspaceBuffers.test.ts
@@ -21,6 +21,21 @@ describe("dirtyWorkspaceBuffers", () => {
     expect(getDirtyFileTextForWindow("C:\\Repo\\src\\App.tsx")).toBeUndefined();
   });
 
+  it("normalizes dot segments before matching Windows dirty buffers", () => {
+    replaceDirtyBuffersForWorkspace("C:\\Repo", [
+      {
+        path: ".\\src\\nested\\..\\App.tsx",
+        content: "dirty",
+        savedContent: "saved",
+      },
+    ]);
+
+    expect(getDirtyFileTextForWindow("C:/Repo/src/App.tsx")).toBe("dirty");
+    expect(getDirtyFileTextForWindow("C:/Repo/src/./App.tsx")).toBe("dirty");
+    clearDirtyBuffersForWorkspace("C:/Repo/.");
+    expect(getDirtyFileTextForWindow("C:/Repo/src/App.tsx")).toBeUndefined();
+  });
+
   it("keeps clean buffers out of the dirty map", () => {
     replaceDirtyBuffersForWorkspace("/repo", [
       {
diff --git a/apps/desktop/src/renderer/lib/dirtyWorkspaceBuffers.ts b/apps/desktop/src/renderer/lib/dirtyWorkspaceBuffers.ts
index 9f586e43e..372f6eb07 100644
--- a/apps/desktop/src/renderer/lib/dirtyWorkspaceBuffers.ts
+++ b/apps/desktop/src/renderer/lib/dirtyWorkspaceBuffers.ts
@@ -2,43 +2,30 @@
  * In-memory map of absolute file path → unsaved editor text for workspace file UIs.
  * The main process reads this via `window.__ADE_GET_DIRTY_FILE_TEXT__` during Cursor ACP reads.
  */
-const dirtyByAbsPath = new Map<string, string>();
+import { isPathEqualOrDescendant, isWindowsAbsolutePath, normalizePath, normalizePathForComparison } from "./pathUtils";
 
-function isWindowsAbsolutePath(value: string): boolean {
-  return /^\/?[a-z]:\//i.test(value) || value.startsWith("//");
-}
+const dirtyByAbsPath = new Map<string, string>();
 
 function isAbsolutePath(value: string): boolean {
-  return value.startsWith("/") || isWindowsAbsolutePath(value);
-}
-
-function trimTrailingSlash(value: string): string {
-  if (/^[a-z]:\/$/i.test(value) || value === "/" || value === "//") return value;
-  return value.replace(/\/+$/g, "");
+  const normalized = normalizePath(value);
+  return normalized.startsWith("/") || isWindowsAbsolutePath(normalized);
 }
 
 function normalizeDirtyPath(value: string): string {
-  const slashNormalized = value.trim().replace(/\\/g, "/");
-  const collapsed = slashNormalized.startsWith("//")
-    ? `//${slashNormalized.slice(2).replace(/\/+/g, "/")}`
-    : slashNormalized.replace(/\/+/g, "/");
-  const drivePrefixNormalized = collapsed.replace(/^\/([a-z]:)(?=\/|$)/i, "$1");
-  const trimmed = trimTrailingSlash(drivePrefixNormalized);
-  return isWindowsAbsolutePath(trimmed) ? trimmed.toLowerCase() : trimmed;
+  return normalizePathForComparison(value);
 }
 
 function joinDirtyPath(rootPath: string, relativePath: string): string {
-  const root = trimTrailingSlash(rootPath.replace(/\\/g, "/"));
-  const rel = relativePath.replace(/\\/g, "/").replace(/^\/+/g, "");
-  return normalizeDirtyPath(`${root}/${rel}`);
+  const root = normalizePath(rootPath);
+  const rel = normalizePath(relativePath).replace(/^\/+/g, "");
+  return normalizeDirtyPath(root.length ? `${root}/${rel}` : rel);
 }
 
 function clearWorkspaceEntries(rootPath: string): void {
-  const rootNorm = normalizeDirtyPath(rootPath);
-  const prefix = rootNorm.endsWith("/") ? rootNorm : `${rootNorm}/`;
+  const rootNorm = normalizePath(rootPath);
+  if (!rootNorm.length) return;
   for (const key of [...dirtyByAbsPath.keys()]) {
-    const kn = normalizeDirtyPath(key);
-    if (kn === rootNorm || kn.startsWith(prefix)) {
+    if (isPathEqualOrDescendant(key, rootNorm)) {
       dirtyByAbsPath.delete(key);
     }
   }
diff --git a/apps/desktop/src/renderer/lib/pathUtils.test.ts b/apps/desktop/src/renderer/lib/pathUtils.test.ts
index 608ce450c..4ed659bce 100644
--- a/apps/desktop/src/renderer/lib/pathUtils.test.ts
+++ b/apps/desktop/src/renderer/lib/pathUtils.test.ts
@@ -1,8 +1,10 @@
 import { describe, expect, it } from "vitest";
 import {
+  arePathsEqual,
   isPathEqualOrDescendant,
   normalizePath,
   normalizePathForComparison,
+  normalizePathForWorkspaceComparison,
   remapPathForRename,
 } from "./pathUtils";
 
@@ -13,14 +15,31 @@ describe("pathUtils", () => {
     expect(normalizePath("C:\\Users\\me\\repo\\")).toBe("C:/Users/me/repo");
   });
 
+  it("collapses dot segments without walking above rooted paths", () => {
+    expect(normalizePath("C:\\Users\\me\\repo\\src\\..\\main.ts")).toBe("C:/Users/me/repo/main.ts");
+    expect(normalizePath("\\\\server\\share\\repo\\..\\main.ts")).toBe("//server/share/main.ts");
+    expect(normalizePath("/repo/src/../../main.ts")).toBe("/main.ts");
+    expect(normalizePath("../repo/./src/../main.ts")).toBe("../repo/main.ts");
+  });
+
   it("compares Windows paths case-insensitively", () => {
     expect(normalizePathForComparison("C:\\Users\\Me\\Repo")).toBe("c:/users/me/repo");
     expect(isPathEqualOrDescendant("c:/users/me/repo/src/main.ts", "C:\\Users\\Me\\Repo")).toBe(true);
   });
 
+  it("compares relative paths case-insensitively inside Windows workspaces", () => {
+    expect(normalizePathForWorkspaceComparison("src\\Main.ts", "C:\\Repo")).toBe("src/main.ts");
+    expect(arePathsEqual("src/Main.ts", "SRC\\main.ts", "C:\\Repo")).toBe(true);
+    expect(isPathEqualOrDescendant("src/main.ts", "SRC", "C:\\Repo")).toBe(true);
+  });
+
   it("remaps renamed Windows descendants without dropping the drive root", () => {
     expect(remapPathForRename("C:/Users/Me/Repo/src/main.ts", "c:/users/me/repo", "D:/Work/Repo")).toBe(
       "D:/Work/Repo/src/main.ts",
     );
   });
+
+  it("remaps relative Windows workspace paths case-insensitively", () => {
+    expect(remapPathForRename("src/Main.ts", "SRC", "Renamed", "C:\\Repo")).toBe("Renamed/Main.ts");
+  });
 });
diff --git a/apps/desktop/src/renderer/lib/pathUtils.ts b/apps/desktop/src/renderer/lib/pathUtils.ts
index 93f4a58ff..72634b35d 100644
--- a/apps/desktop/src/renderer/lib/pathUtils.ts
+++ b/apps/desktop/src/renderer/lib/pathUtils.ts
@@ -28,6 +28,62 @@ export function isWindowsAbsolutePath(value: string): boolean {
   return isWindowsDrivePath(value) || isWindowsUncPath(value);
 }
 
+function splitNormalizedPath(value: string): { root: string; segments: string[] } {
+  if (!value.length) return { root: "", segments: [] };
+
+  if (value.startsWith("//")) {
+    const match = value.match(/^\/\/([^/]+)\/([^/]+)(?:\/(.*))?$/);
+    if (!match) return { root: value, segments: [] };
+    const [, server, share, rest = ""] = match;
+    return {
+      root: `//${server}/${share}`,
+      segments: rest.split("/").filter(Boolean),
+    };
+  }
+
+  if (/^[A-Za-z]:\//.test(value)) {
+    return {
+      root: `${value.slice(0, 2)}/`,
+      segments: value.slice(3).split("/").filter(Boolean),
+    };
+  }
+
+  if (value.startsWith("/")) {
+    return {
+      root: "/",
+      segments: value.slice(1).split("/").filter(Boolean),
+    };
+  }
+
+  return {
+    root: "",
+    segments: value.split("/").filter(Boolean),
+  };
+}
+
+function collapsePathSegments(root: string, segments: string[]): string[] {
+  const collapsed: string[] = [];
+
+  for (const segment of segments) {
+    if (!segment.length || segment === ".") continue;
+
+    if (segment === "..") {
+      if (collapsed.length > 0 && collapsed[collapsed.length - 1] !== "..") {
+        collapsed.pop();
+        continue;
+      }
+      if (!root.length) {
+        collapsed.push("..");
+      }
+      continue;
+    }
+
+    collapsed.push(segment);
+  }
+
+  return collapsed;
+}
+
 export function normalizePath(value: string): string {
   const trimmed = normalizeSeparators(value).trim();
   if (!trimmed.length) return "";
@@ -39,7 +95,13 @@ export function normalizePath(value: string): string {
 
   if (/^[A-Za-z]:$/.test(normalizedDrivePrefix)) return `${normalizedDrivePrefix}/`;
   if (isRootPath(normalizedDrivePrefix)) return normalizedDrivePrefix;
-  return normalizedDrivePrefix.replace(/\/+$/g, "");
+
+  const { root, segments } = splitNormalizedPath(normalizedDrivePrefix.replace(/\/+$/g, ""));
+  const normalizedSegments = collapsePathSegments(root, segments);
+
+  if (!root.length) return normalizedSegments.join("/");
+  if (!normalizedSegments.length) return root;
+  return root === "/" ? `/${normalizedSegments.join("/")}` : `${root}${root.endsWith("/") ? "" : "/"}${normalizedSegments.join("/")}`;
 }
 
 export function normalizePathForComparison(value: string): string {
@@ -47,9 +109,22 @@ export function normalizePathForComparison(value: string): string {
   return isWindowsAbsolutePath(normalized) ? normalized.toLowerCase() : normalized;
 }
 
-export function isPathEqualOrDescendant(filePath: string, rootPath: string): boolean {
-  const normalizedPath = normalizePathForComparison(filePath);
-  const normalizedRoot = normalizePathForComparison(rootPath);
+export function normalizePathForWorkspaceComparison(value: string, workspaceRoot?: string | null): string {
+  const normalized = normalizePath(value);
+  if (!normalized.length) return "";
+  const normalizedWorkspaceRoot = normalizePath(workspaceRoot ?? "");
+  return isWindowsAbsolutePath(normalizedWorkspaceRoot) || isWindowsAbsolutePath(normalized)
+    ? normalized.toLowerCase()
+    : normalized;
+}
+
+export function arePathsEqual(left: string, right: string, workspaceRoot?: string | null): boolean {
+  return normalizePathForWorkspaceComparison(left, workspaceRoot) === normalizePathForWorkspaceComparison(right, workspaceRoot);
+}
+
+export function isPathEqualOrDescendant(filePath: string, rootPath: string, workspaceRoot?: string | null): boolean {
+  const normalizedPath = normalizePathForWorkspaceComparison(filePath, workspaceRoot ?? rootPath);
+  const normalizedRoot = normalizePathForWorkspaceComparison(rootPath, workspaceRoot ?? rootPath);
   if (!normalizedRoot) return normalizedPath.length === 0;
   if (normalizedPath === normalizedRoot) return true;
   return normalizedRoot.endsWith("/")
@@ -57,14 +132,14 @@ export function isPathEqualOrDescendant(filePath: string, rootPath: string): boo
     : normalizedPath.startsWith(`${normalizedRoot}/`);
 }
 
-export function remapPathForRename(filePath: string, oldPath: string, newPath: string): string {
+export function remapPathForRename(filePath: string, oldPath: string, newPath: string, workspaceRoot?: string | null): string {
   const normalizedPath = normalizePath(filePath);
   const normalizedOld = normalizePath(oldPath);
   const normalizedNew = normalizePath(newPath);
   if (!normalizedOld || !normalizedNew) return normalizedPath;
 
-  const normalizedPathComparable = normalizePathForComparison(normalizedPath);
-  const normalizedOldComparable = normalizePathForComparison(normalizedOld);
+  const normalizedPathComparable = normalizePathForWorkspaceComparison(normalizedPath, workspaceRoot ?? oldPath);
+  const normalizedOldComparable = normalizePathForWorkspaceComparison(normalizedOld, workspaceRoot ?? oldPath);
   if (normalizedPathComparable === normalizedOldComparable) return normalizedNew;
 
   const prefix = normalizedOldComparable.endsWith("/")
diff --git a/apps/desktop/src/renderer/lib/shell.test.ts b/apps/desktop/src/renderer/lib/shell.test.ts
index 77202814c..39f8dc51a 100644
--- a/apps/desktop/src/renderer/lib/shell.test.ts
+++ b/apps/desktop/src/renderer/lib/shell.test.ts
@@ -33,9 +33,25 @@ describe("shell helpers", () => {
 
   it("round-trips Windows cmd and PowerShell commands", () => {
     const cmd = ["cmd.exe", "/c", "npm run test"];
-    const powershell = ["powershell.exe", "-NoProfile", "-Command", "Write-Output \"ok\""];
+    const powershell = ["powershell.exe", "-NoProfile", "-Command", 'Write-Output "ok"'];
 
     expect(parseCommandLine(commandArrayToLine(cmd, { platform: "win32" }), { platform: "win32" })).toEqual(cmd);
     expect(parseCommandLine(commandArrayToLine(powershell, { platform: "win32" }), { platform: "win32" })).toEqual(powershell);
   });
+
+  it("round-trips Windows arguments that end with a backslash", () => {
+    const argv = ["node.exe", "C:\\repo path\\nested\\"];
+    const line = commandArrayToLine(argv, { platform: "win32" });
+
+    expect(line).toBe('node.exe "C:\\repo path\\nested\\"');
+    expect(parseCommandLine(line, { platform: "win32" })).toEqual(argv);
+  });
+
+  it("parses Windows doubled quotes without treating backslashes as escapes", () => {
+    expect(parseCommandLine('"ab""c" "C:\\repo path\\" d', { platform: "win32" })).toEqual([
+      'ab"c',
+      "C:\\repo path\\",
+      "d",
+    ]);
+  });
 });
diff --git a/apps/desktop/src/renderer/lib/shell.ts b/apps/desktop/src/renderer/lib/shell.ts
index 0defcadd3..558907104 100644
--- a/apps/desktop/src/renderer/lib/shell.ts
+++ b/apps/desktop/src/renderer/lib/shell.ts
@@ -12,12 +12,17 @@ function isWindowsPlatform(platform: ShellPlatform = currentShellPlatform()): bo
   return platform === "win32";
 }
 
+function quoteWindowsArg(arg: string): string {
+  if (!arg.length) return '""';
+  if (!/[\s"]/.test(arg)) return arg;
+  return `"${arg.replace(/"/g, "\"\"")}"`;
+}
+
 /** Quote a single shell argument, adding double quotes if needed. */
 export function quoteShellArg(arg: string, options: { platform?: ShellPlatform } = {}): string {
   if (!arg.length) return '""';
   if (isWindowsPlatform(options.platform)) {
-    if (/^[a-zA-Z0-9_.:@%+=,\\/-]+$/.test(arg)) return arg;
-    return `"${arg.replace(/"/g, "\\\"")}"`;
+    return quoteWindowsArg(arg);
   }
   if (/^[a-zA-Z0-9_.:@%+=,-]+$/.test(arg)) return arg;
   return `"${arg.replace(/(["\\$`])/g, "\\$1")}"`;
@@ -103,13 +108,12 @@ function parseWindowsCommandLine(input: string): string[] {
     const ch = input[i]!;
 
     if (ch === '"') {
-      inQuotes = !inQuotes;
-      continue;
-    }
-
-    if (ch === "\\" && input[i + 1] === '"') {
-      current += '"';
-      i += 1;
+      if (inQuotes && input[i + 1] === '"') {
+        current += '"';
+        i += 1;
+      } else {
+        inQuotes = !inQuotes;
+      }
       continue;
     }
 

From 9249964db1e416e5007e2fdceb0be082da267939 Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Thu, 23 Apr 2026 14:59:03 -0400
Subject: [PATCH 03/11] test: add automated tests for Windows port foundations

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../services/shared/processExecution.test.ts  | 184 +++++++++++++++++-
 .../src/renderer/lib/pathUtils.test.ts        |  36 ++++
 2 files changed, 219 insertions(+), 1 deletion(-)

diff --git a/apps/desktop/src/main/services/shared/processExecution.test.ts b/apps/desktop/src/main/services/shared/processExecution.test.ts
index 76727e57f..b9c83cf10 100644
--- a/apps/desktop/src/main/services/shared/processExecution.test.ts
+++ b/apps/desktop/src/main/services/shared/processExecution.test.ts
@@ -1,9 +1,23 @@
-import { describe, expect, it } from "vitest";
+import type * as childProcess from "node:child_process";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const spawnSyncMock = vi.fn();
+
+vi.mock("node:child_process", async () => {
+  const actual = await vi.importActual<typeof childProcess>("node:child_process");
+  return {
+    ...actual,
+    spawnSync: (...args: unknown[]) => spawnSyncMock(...args),
+  };
+});
+
 import {
+  killWindowsProcessTree,
   quoteWindowsCmdArg,
   resolveCliSpawnInvocation,
   resolveWindowsCmdInvocation,
   shouldUseWindowsCmdWrapper,
+  terminateProcessTree,
 } from "./processExecution";
 
 describe("processExecution", () => {
@@ -49,3 +63,171 @@ describe("processExecution", () => {
     });
   });
 });
+
+describe("killWindowsProcessTree", () => {
+  afterEach(() => {
+    spawnSyncMock.mockReset();
+  });
+
+  it("shells out to taskkill /T /F and returns true on exit 0", () => {
+    spawnSyncMock.mockReturnValueOnce({ status: 0, stdout: "", stderr: "", error: null });
+    const failure = vi.fn();
+
+    expect(killWindowsProcessTree(4321, failure)).toBe(true);
+    expect(failure).not.toHaveBeenCalled();
+    expect(spawnSyncMock).toHaveBeenCalledTimes(1);
+    const [command, args, options] = spawnSyncMock.mock.calls[0]!;
+    expect(command).toBe("taskkill.exe");
+    expect(args).toEqual(["/T", "/F", "/PID", "4321"]);
+    expect(options).toMatchObject({ windowsHide: true });
+  });
+
+  it("invokes the failure callback with taskkill stderr when exit is non-zero", () => {
+    spawnSyncMock.mockReturnValueOnce({
+      status: 128,
+      stdout: Buffer.from("out", "utf8"),
+      stderr: Buffer.from("Access denied.", "utf8"),
+      error: null,
+    });
+    const failure = vi.fn();
+
+    expect(killWindowsProcessTree(1234, failure)).toBe(false);
+    expect(failure).toHaveBeenCalledTimes(1);
+    expect(failure).toHaveBeenCalledWith({
+      pid: 1234,
+      status: 128,
+      stdout: "out",
+      stderr: "Access denied.",
+      error: null,
+    });
+  });
+
+  it("invokes the failure callback when spawnSync throws", () => {
+    const thrown = new Error("spawn failed");
+    spawnSyncMock.mockImplementationOnce(() => {
+      throw thrown;
+    });
+    const failure = vi.fn();
+
+    expect(killWindowsProcessTree(55, failure)).toBe(false);
+    expect(failure).toHaveBeenCalledWith({
+      pid: 55,
+      status: null,
+      stdout: "",
+      stderr: "",
+      error: thrown,
+    });
+  });
+
+  it("rejects non-positive or non-integer pids without shelling out", () => {
+    const failure = vi.fn();
+
+    expect(killWindowsProcessTree(0, failure)).toBe(false);
+    expect(killWindowsProcessTree(-7, failure)).toBe(false);
+    expect(killWindowsProcessTree(3.14, failure)).toBe(false);
+    expect(spawnSyncMock).not.toHaveBeenCalled();
+    expect(failure).not.toHaveBeenCalled();
+  });
+});
+
+type FakeChildShape = Pick<childProcess.ChildProcess, "kill" | "pid" | "exitCode" | "signalCode">;
+
+function fakeChild(overrides: Partial<FakeChildShape> = {}): FakeChildShape & { kill: ReturnType<typeof vi.fn> } {
+  return {
+    pid: 4321,
+    exitCode: null,
+    signalCode: null,
+    kill: vi.fn(() => true),
+    ...overrides,
+  } as FakeChildShape & { kill: ReturnType<typeof vi.fn> };
+}
+
+const originalPlatform = process.platform;
+
+function setPlatform(value: NodeJS.Platform): void {
+  Object.defineProperty(process, "platform", {
+    value,
+    configurable: true,
+  });
+}
+
+describe("terminateProcessTree", () => {
+  afterEach(() => {
+    spawnSyncMock.mockReset();
+    setPlatform(originalPlatform);
+  });
+
+  it("on non-Windows, forwards the signal to child.kill and returns its result", () => {
+    setPlatform("linux");
+    const child = fakeChild();
+
+    expect(terminateProcessTree(child, "SIGTERM")).toBe(true);
+    expect(child.kill).toHaveBeenCalledWith("SIGTERM");
+    expect(spawnSyncMock).not.toHaveBeenCalled();
+  });
+
+  it("on non-Windows, returns false and does not throw when child.kill throws", () => {
+    setPlatform("linux");
+    const child = fakeChild({
+      kill: vi.fn(() => {
+        throw new Error("ESRCH");
+      }),
+    });
+
+    expect(terminateProcessTree(child, "SIGKILL")).toBe(false);
+  });
+
+  it("on Windows, calls taskkill for a live child and skips child.kill on success", () => {
+    setPlatform("win32");
+    spawnSyncMock.mockReturnValueOnce({ status: 0, stdout: "", stderr: "", error: null });
+    const child = fakeChild();
+
+    expect(terminateProcessTree(child)).toBe(true);
+    expect(spawnSyncMock).toHaveBeenCalledTimes(1);
+    expect(spawnSyncMock.mock.calls[0]![1]).toEqual(["/T", "/F", "/PID", "4321"]);
+    expect(child.kill).not.toHaveBeenCalled();
+  });
+
+  it("on Windows, falls back to child.kill when taskkill fails", () => {
+    setPlatform("win32");
+    spawnSyncMock.mockReturnValueOnce({
+      status: 1,
+      stdout: "",
+      stderr: Buffer.from("err", "utf8"),
+      error: null,
+    });
+    const child = fakeChild();
+    const failure = vi.fn();
+
+    expect(terminateProcessTree(child, "SIGTERM", failure)).toBe(true);
+    expect(failure).toHaveBeenCalledTimes(1);
+    expect(child.kill).toHaveBeenCalledWith("SIGTERM");
+  });
+
+  it("on Windows, skips taskkill entirely when the child has already exited", () => {
+    setPlatform("win32");
+    const child = fakeChild({ exitCode: 0 });
+
+    expect(terminateProcessTree(child)).toBe(false);
+    expect(spawnSyncMock).not.toHaveBeenCalled();
+    expect(child.kill).not.toHaveBeenCalled();
+  });
+
+  it("on Windows, skips taskkill entirely when the child already received a signal", () => {
+    setPlatform("win32");
+    const child = fakeChild({ signalCode: "SIGTERM" });
+
+    expect(terminateProcessTree(child)).toBe(false);
+    expect(spawnSyncMock).not.toHaveBeenCalled();
+    expect(child.kill).not.toHaveBeenCalled();
+  });
+
+  it("on Windows, falls back to child.kill when pid is missing", () => {
+    setPlatform("win32");
+    const child = fakeChild({ pid: undefined });
+
+    expect(terminateProcessTree(child, "SIGKILL")).toBe(true);
+    expect(spawnSyncMock).not.toHaveBeenCalled();
+    expect(child.kill).toHaveBeenCalledWith("SIGKILL");
+  });
+});
diff --git a/apps/desktop/src/renderer/lib/pathUtils.test.ts b/apps/desktop/src/renderer/lib/pathUtils.test.ts
index 4ed659bce..f92149d3c 100644
--- a/apps/desktop/src/renderer/lib/pathUtils.test.ts
+++ b/apps/desktop/src/renderer/lib/pathUtils.test.ts
@@ -2,6 +2,9 @@ import { describe, expect, it } from "vitest";
 import {
   arePathsEqual,
   isPathEqualOrDescendant,
+  isWindowsAbsolutePath,
+  isWindowsDrivePath,
+  isWindowsUncPath,
   normalizePath,
   normalizePathForComparison,
   normalizePathForWorkspaceComparison,
@@ -43,3 +46,36 @@ describe("pathUtils", () => {
     expect(remapPathForRename("src/Main.ts", "SRC", "Renamed", "C:\\Repo")).toBe("Renamed/Main.ts");
   });
 });
+
+describe("Windows path predicates", () => {
+  it("identifies drive-letter paths, including leading-slash and bare-drive forms", () => {
+    expect(isWindowsDrivePath("C:\\Users\\me")).toBe(true);
+    expect(isWindowsDrivePath("c:/users/me")).toBe(true);
+    expect(isWindowsDrivePath("/C:/Users/me")).toBe(true);
+    expect(isWindowsDrivePath("Z:")).toBe(true);
+
+    expect(isWindowsDrivePath("relative/path")).toBe(false);
+    expect(isWindowsDrivePath("/unix/path")).toBe(false);
+    expect(isWindowsDrivePath("C:relative")).toBe(false);
+  });
+
+  it("identifies UNC paths in both backslash and forward-slash form", () => {
+    expect(isWindowsUncPath("\\\\server\\share\\file.txt")).toBe(true);
+    expect(isWindowsUncPath("//server/share/file.txt")).toBe(true);
+
+    expect(isWindowsUncPath("\\\\")).toBe(false);
+    expect(isWindowsUncPath("//")).toBe(false);
+    expect(isWindowsUncPath("/unix/path")).toBe(false);
+    expect(isWindowsUncPath("C:\\path")).toBe(false);
+  });
+
+  it("identifies any Windows absolute path as drive or UNC", () => {
+    expect(isWindowsAbsolutePath("C:\\Users")).toBe(true);
+    expect(isWindowsAbsolutePath("\\\\srv\\share")).toBe(true);
+    expect(isWindowsAbsolutePath("//srv/share")).toBe(true);
+
+    expect(isWindowsAbsolutePath("/unix/path")).toBe(false);
+    expect(isWindowsAbsolutePath("relative/path")).toBe(false);
+    expect(isWindowsAbsolutePath("")).toBe(false);
+  });
+});

From 27304e9ada83b595a9b0b38e61090663f34b1160 Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Thu, 23 Apr 2026 15:40:19 -0400
Subject: [PATCH 04/11] docs: update internal docs for Windows port

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 docs/ARCHITECTURE.md | 38 +++++++++++++++++++++++++++++++-------
 1 file changed, 31 insertions(+), 7 deletions(-)

diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index 8bc2f0b4f..888b37e97 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -84,9 +84,17 @@ A standalone Node CLI that exposes ADE actions over a private JSON-RPC
 bridge.
 
 - **Socket mode** — when ADE desktop is running, `ade` connects to the
-  project socket at `.ade/ade.sock`.
+  project IPC endpoint. On macOS/Linux that is `.ade/ade.sock`; on
+  Windows it is a named pipe under `\\.\pipe\ade-<hash>` where `<hash>`
+  is a SHA-256 prefix of the lowercased absolute project root
+  (`apps/desktop/src/shared/adeMcpIpc.ts`). Both platforms share the
+  same JSON-RPC framing.
 - **Headless mode** — with `--headless`, the CLI bootstraps the same
   project services directly from the repository.
+- **Windows packaging** — the installer lays down `ade-cli-windows-wrapper.cmd`
+  plus an `ade-cli-install-path.cmd` helper alongside the bundled Node
+  runtime so that `ade` works from a normal Windows shell without a
+  global Node install. See §14.4 for the packaging flow.
 - **Session identity** — the CLI resolves caller role from ADE context
   environment variables and command flags. Role vocabulary: `cto`,
   `orchestrator`, `agent`, `external`, `evaluator`.
@@ -867,7 +875,12 @@ ADE/
 │   ├── features/
 │   └── final-plan/
 ├── new-docs/           # This file + feature docs
-├── scripts/            # Release, validate, notarize, after-pack
+├── scripts/            # Release, validate, notarize, after-pack (per-platform)
+│                       # Platform-specific: validate-mac-artifacts.mjs,
+│                       # validate-win-artifacts.mjs, ade-cli-windows-wrapper.cmd, etc.
+├── apps/desktop/vendor/crsqlite/
+│   ├── darwin-arm64/
+│   └── win32-x64/      # Prebuilt cr-sqlite native binaries per platform
 ├── .github/workflows/
 │   ├── ci.yml
 │   ├── prepare-release.yml
@@ -919,14 +932,25 @@ Sharding is required because the desktop suite is large enough to be slow in a s
 
 ### 14.4 Packaging (Electron Builder)
 
+macOS:
+
 - `npm run dist:mac` — notarized .dmg for local distribution.
 - `npm run dist:mac:universal:signed` — universal x64+arm64 signed builds.
 - `npm run dist:mac:universal:signed:zip` — zip archive variant.
-- Post-packaging hardening (`apps/desktop/scripts/`):
-  - `runtimeBinaryPermissions.cjs` — restores exec bits on `node-pty` spawn helpers, Codex vendor binaries, Claude SDK ripgrep helpers; patches `node-pty` `unixTerminal.js` for ASAR-unpacked paths.
-  - `after-pack-runtime-fixes.cjs` — electron-builder after-pack hook.
-  - `validate-mac-artifacts.mjs` — confirms expected binaries + intact code signing.
-  - `notarize-mac-dmg.mjs` — Apple notarization.
+
+Windows:
+
+- `npm run dist:win` — x64 installer via `electron-builder --win --x64`, wrapped with `validate:win:artifacts` (preflight) and `validate:win:release` (post-build) checks in `apps/desktop/scripts/validate-win-artifacts.mjs`.
+- Windows-only wrappers for the bundled `ade` CLI ship in `apps/desktop/scripts/`: `ade-cli-windows-wrapper.cmd` (launcher) and `ade-cli-install-path.cmd` (idempotent PATH install helper). The platform-agnostic `.sh` wrapper covers macOS/Linux.
+- The Windows installer bundles the prebuilt `cr-sqlite` native binary from `apps/desktop/vendor/crsqlite/win32-x64/` plus a Windows node-pty ConPTY worker.
+- GitHub Actions `release-core.yml` drives signed/notarized Windows artifacts.
+
+Post-packaging hardening (`apps/desktop/scripts/`):
+
+- `runtimeBinaryPermissions.cjs` — restores exec bits on `node-pty` spawn helpers, Codex vendor binaries, Claude SDK ripgrep helpers; patches `node-pty` `unixTerminal.js` for ASAR-unpacked paths.
+- `after-pack-runtime-fixes.cjs` — electron-builder after-pack hook. Covers both platforms: runs the permissions pass on macOS and stages CLI wrappers + runtime shims on Windows.
+- `validate-mac-artifacts.mjs` / `validate-win-artifacts.mjs` — per-platform artifact validators; confirm expected binaries and signing state.
+- `notarize-mac-dmg.mjs` — Apple notarization.
 
 ### 14.5 Documentation
 

From c78b6f1812fb36c72191f1f5abf76294dcaff1dc Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Thu, 23 Apr 2026 16:09:19 -0400
Subject: [PATCH 05/11] ship: iteration 2 fix CI and review comments

---
 apps/ade-cli/src/adeRpcServer.test.ts         | 78 ++++++++++++++-----
 apps/ade-cli/src/adeRpcServer.ts              | 24 +++++-
 .../orchestrator/aiOrchestratorService.ts     | 15 +++-
 .../services/shared/processExecution.test.ts  |  2 +
 .../main/services/shared/processExecution.ts  | 20 ++++-
 5 files changed, 115 insertions(+), 24 deletions(-)

diff --git a/apps/ade-cli/src/adeRpcServer.test.ts b/apps/ade-cli/src/adeRpcServer.test.ts
index 9e44ea17a..49da7d242 100644
--- a/apps/ade-cli/src/adeRpcServer.test.ts
+++ b/apps/ade-cli/src/adeRpcServer.test.ts
@@ -946,6 +946,14 @@ async function withEnv<T>(vars: Record<string, string | undefined>, fn: () => Pr
   }
 }
 
+function createFakePathExecutable(dir: string, name: string): string {
+  fs.mkdirSync(dir, { recursive: true });
+  const executablePath = path.join(dir, process.platform === "win32" ? `${name}.cmd` : name);
+  fs.writeFileSync(executablePath, process.platform === "win32" ? "@echo off\r\n" : "#!/bin/sh\n");
+  if (process.platform !== "win32") fs.chmodSync(executablePath, 0o755);
+  return executablePath;
+}
+
 describe("adeRpcServer", () => {
   it("treats requested privileged roles as external without trusted env identity", async () => {
     const { runtime } = createRuntime();
@@ -1805,15 +1813,19 @@ describe("adeRpcServer", () => {
 
   it("routes spawn_agent to lane-scoped tracked pty sessions", async () => {
     const fixture = createRuntime();
+    const binDir = fs.mkdtempSync(path.join(os.tmpdir(), "ade-cli-spawn-bin-"));
+    const claudePath = createFakePathExecutable(binDir, "claude");
     const handler = createAdeRpcRequestHandler({ runtime: fixture.runtime, serverVersion: "test" });
 
-    await initialize(handler, { role: "orchestrator" });
-    const response = await callTool(handler, "spawn_agent", {
-      laneId: "lane-1",
-      provider: "claude",
-      model: "claude-sonnet-4-6",
-      prompt: "Implement API wiring",
-      title: "Orchestrator Spawn"
+    const response = await withEnv({ PATH: `${binDir}${path.delimiter}${process.env.PATH ?? ""}` }, async () => {
+      await initialize(handler, { role: "orchestrator" });
+      return await callTool(handler, "spawn_agent", {
+        laneId: "lane-1",
+        provider: "claude",
+        model: "claude-sonnet-4-6",
+        prompt: "Implement API wiring",
+        title: "Orchestrator Spawn"
+      });
     });
 
     expect(response?.isError).toBeUndefined();
@@ -1824,7 +1836,7 @@ describe("adeRpcServer", () => {
         rows: 36,
         tracked: true,
         toolType: "claude-orchestrated",
-        command: "claude",
+        command: claudePath,
         args: expect.arrayContaining(["--model", "claude-sonnet-4-6", "--permission-mode", "default", "Implement API wiring"]),
         env: expect.objectContaining({
           ADE_DEFAULT_ROLE: "agent",
@@ -1841,17 +1853,21 @@ describe("adeRpcServer", () => {
   it("starts spawn_agent without writing an attached ADE server config", async () => {
     const fixture = createRuntime();
     fixture.runtime.workspaceRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-cli-spawn-workspace-"));
+    const binDir = fs.mkdtempSync(path.join(os.tmpdir(), "ade-cli-spawn-bin-"));
+    const claudePath = createFakePathExecutable(binDir, "claude");
     const handler = createAdeRpcRequestHandler({ runtime: fixture.runtime, serverVersion: "test" });
 
-    await initialize(handler, { role: "orchestrator", runId: "run-from-identity" });
-    const response = await callTool(handler, "spawn_agent", {
-      laneId: "lane-1",
-      provider: "claude",
-      model: "claude-sonnet-4-6",
-      prompt: "Implement API wiring",
-      title: "Orchestrator Spawn",
-      runId: "run-1",
-      attemptId: "attempt-workspace-roots"
+    const response = await withEnv({ PATH: `${binDir}${path.delimiter}${process.env.PATH ?? ""}` }, async () => {
+      await initialize(handler, { role: "orchestrator", runId: "run-from-identity" });
+      return await callTool(handler, "spawn_agent", {
+        laneId: "lane-1",
+        provider: "claude",
+        model: "claude-sonnet-4-6",
+        prompt: "Implement API wiring",
+        title: "Orchestrator Spawn",
+        runId: "run-1",
+        attemptId: "attempt-workspace-roots"
+      });
     });
 
     expect(response?.isError).toBeUndefined();
@@ -1860,7 +1876,7 @@ describe("adeRpcServer", () => {
     expect(response.structuredContent.startupCommand).toContain("ADE_ATTEMPT_ID=attempt-workspace-roots");
     expect(fixture.runtime.ptyService.create).toHaveBeenCalledWith(
       expect.objectContaining({
-        command: "claude",
+        command: claudePath,
         env: expect.objectContaining({
           ADE_RUN_ID: "run-1",
           ADE_ATTEMPT_ID: "attempt-workspace-roots",
@@ -1870,6 +1886,32 @@ describe("adeRpcServer", () => {
     );
   });
 
+  it("keeps spawn_agent on shell startup when the provider executable cannot be resolved", async () => {
+    const fixture = createRuntime();
+    const handler = createAdeRpcRequestHandler({ runtime: fixture.runtime, serverVersion: "test" });
+
+    const response = await withEnv({ PATH: fs.mkdtempSync(path.join(os.tmpdir(), "ade-cli-empty-path-")) }, async () => {
+      await initialize(handler, { role: "orchestrator" });
+      return await callTool(handler, "spawn_agent", {
+        laneId: "lane-1",
+        provider: "claude",
+        prompt: "Implement API wiring",
+      });
+    });
+
+    expect(response?.isError).toBeUndefined();
+    expect(fixture.runtime.ptyService.create).toHaveBeenCalledWith(
+      expect.not.objectContaining({
+        command: expect.any(String),
+      })
+    );
+    expect(fixture.runtime.ptyService.create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        startupCommand: expect.stringContaining("claude"),
+      })
+    );
+  });
+
   it("rejects config-toml permission mode for Claude spawn_agent sessions", async () => {
     const fixture = createRuntime();
     const handler = createAdeRpcRequestHandler({ runtime: fixture.runtime, serverVersion: "test" });
diff --git a/apps/ade-cli/src/adeRpcServer.ts b/apps/ade-cli/src/adeRpcServer.ts
index d4211b4a1..5c4535682 100644
--- a/apps/ade-cli/src/adeRpcServer.ts
+++ b/apps/ade-cli/src/adeRpcServer.ts
@@ -83,6 +83,26 @@ const DEFAULT_PTY_ROWS = 36;
 
 const RESOURCE_MIME_JSON = "application/json";
 
+function resolveExecutableOnPath(command: string, env: NodeJS.ProcessEnv = process.env): string | null {
+  const trimmed = command.trim();
+  if (!trimmed) return null;
+  const lookup = process.platform === "win32"
+    ? { command: "where.exe", args: [trimmed] }
+    : { command: env.SHELL?.trim() || "/bin/sh", args: ["-lc", `command -v ${shellEscapeArg(trimmed)}`] };
+  const result = spawnSync(lookup.command, lookup.args, {
+    encoding: "utf8",
+    env,
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+  if (result.status !== 0 || typeof result.stdout !== "string") return null;
+  const first = result.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .find(Boolean);
+  if (!first) return null;
+  return path.isAbsolute(first) ? first : null;
+}
+
 const TOOL_SPECS: ToolSpec[] = [
   {
     name: "spawn_agent",
@@ -5943,6 +5963,7 @@ async function runTool(args: {
     const startupCommand = envPrefixParts.length > 0
       ? `${envPrefixParts.join(" ")} ${commandPreviewParts.join(" ")}`
       : commandPreviewParts.join(" ");
+    const providerExecutable = resolveExecutableOnPath(provider);
 
     const created = await runtime.ptyService.create({
       laneId,
@@ -5951,8 +5972,7 @@ async function runTool(args: {
       title,
       tracked: true,
       toolType: `${provider}-orchestrated`,
-      command: provider,
-      args: commandArgs,
+      ...(providerExecutable ? { command: providerExecutable, args: commandArgs } : {}),
       env: workerEnv,
       startupCommand
     });
diff --git a/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.ts b/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.ts
index d8cfaf8c5..beea24035 100644
--- a/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.ts
+++ b/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.ts
@@ -4265,6 +4265,7 @@ Check all worker statuses and continue managing the mission from here. Read work
         skippedBlockedRuns += 1;
         continue;
       }
+      let ownsHealthSweepRun = false;
       if (activeHealthSweepRuns.has(run.id)) {
         // Interval/startup sweeps are opportunistic; manual/chat/status sweeps should wait briefly
         // so explicit health checks don't get dropped due to an in-flight background sweep.
@@ -4273,9 +4274,17 @@ Check all worker statuses and continue managing the mission from here. Read work
         while (activeHealthSweepRuns.has(run.id) && Date.now() < deadline) {
           await new Promise((resolve) => setTimeout(resolve, 25));
         }
-        if (activeHealthSweepRuns.has(run.id)) continue;
+        if (activeHealthSweepRuns.has(run.id)) {
+          logger.debug("ai_orchestrator.health_sweep_explicit_overlap", {
+            runId: run.id,
+            reason
+          });
+        }
+      }
+      if (!activeHealthSweepRuns.has(run.id)) {
+        activeHealthSweepRuns.add(run.id);
+        ownsHealthSweepRun = true;
       }
-      activeHealthSweepRuns.add(run.id);
       try {
         if (disposed) break;
         sweeps += 1;
@@ -4589,7 +4598,7 @@ Check all worker statuses and continue managing the mission from here. Read work
           error: error instanceof Error ? error.message : String(error)
         });
       } finally {
-        activeHealthSweepRuns.delete(run.id);
+        if (ownsHealthSweepRun) activeHealthSweepRuns.delete(run.id);
       }
     }
 
diff --git a/apps/desktop/src/main/services/shared/processExecution.test.ts b/apps/desktop/src/main/services/shared/processExecution.test.ts
index b9c83cf10..c589af73f 100644
--- a/apps/desktop/src/main/services/shared/processExecution.test.ts
+++ b/apps/desktop/src/main/services/shared/processExecution.test.ts
@@ -31,8 +31,10 @@ describe("processExecution", () => {
 
   it("quotes cmd arguments consistently", () => {
     expect(quoteWindowsCmdArg("C:\\Program Files\\tool.cmd")).toBe('"C:\\Program Files\\tool.cmd"');
+    expect(quoteWindowsCmdArg("C:\\Program Files\\")).toBe('"C:\\Program Files\\\\"');
     expect(quoteWindowsCmdArg("100% done")).toBe('"100%% done"');
     expect(quoteWindowsCmdArg('say "hi"')).toBe('"say ""hi"""');
+    expect(quoteWindowsCmdArg('C:\\path\\"quoted"')).toBe('"C:\\path\\\\\"\"quoted\"\"\"');
   });
 
   it("wraps Windows shim invocations with ComSpec", () => {
diff --git a/apps/desktop/src/main/services/shared/processExecution.ts b/apps/desktop/src/main/services/shared/processExecution.ts
index be0aaef0a..3d7badd2b 100644
--- a/apps/desktop/src/main/services/shared/processExecution.ts
+++ b/apps/desktop/src/main/services/shared/processExecution.ts
@@ -20,7 +20,25 @@ export function processOutputToString(value: Buffer | string | null | undefined)
 }
 
 export function quoteWindowsCmdArg(value: string): string {
-  return `"${value.replace(/"/g, "\"\"").replace(/%/g, "%%")}"`;
+  let quoted = "\"";
+  let backslashes = 0;
+  for (const char of value.replace(/%/g, "%%")) {
+    if (char === "\\") {
+      backslashes += 1;
+      continue;
+    }
+    if (char === "\"") {
+      quoted += "\\".repeat(backslashes * 2);
+      quoted += "\"\"";
+    } else {
+      quoted += "\\".repeat(backslashes);
+      quoted += char;
+    }
+    backslashes = 0;
+  }
+  quoted += "\\".repeat(backslashes * 2);
+  quoted += "\"";
+  return quoted;
 }
 
 export function shouldUseWindowsCmdWrapper(command: string, platform: NodeJS.Platform = process.platform): boolean {

From 605127811d3efb882ded5ab28e1441631fd2e276 Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Thu, 23 Apr 2026 16:22:16 -0400
Subject: [PATCH 06/11] ship: iteration 3 address greptile follow-ups

---
 .../providerOrchestratorAdapter.ts            |  1 +
 apps/desktop/src/renderer/lib/shell.test.ts   | 12 ++++-
 apps/desktop/src/renderer/lib/shell.ts        | 45 ++++++++++++++++++-
 3 files changed, 55 insertions(+), 3 deletions(-)

diff --git a/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts b/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts
index f2bc56a7e..a1e54b678 100644
--- a/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts
+++ b/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts
@@ -132,6 +132,7 @@ child.on("exit", (code, signal) => {
   finish(code == null ? 0 : code);
 });
 if (spec.stdinFilePath && child.stdin) {
+  child.stdin.on("error", () => {});
   const stream = fs.createReadStream(spec.stdinFilePath);
   stream.on("error", (err) => {
     console.error("[ADE] Failed to read worker prompt: " + (err && err.message ? err.message : String(err)));
diff --git a/apps/desktop/src/renderer/lib/shell.test.ts b/apps/desktop/src/renderer/lib/shell.test.ts
index 39f8dc51a..3ec579d38 100644
--- a/apps/desktop/src/renderer/lib/shell.test.ts
+++ b/apps/desktop/src/renderer/lib/shell.test.ts
@@ -43,12 +43,20 @@ describe("shell helpers", () => {
     const argv = ["node.exe", "C:\\repo path\\nested\\"];
     const line = commandArrayToLine(argv, { platform: "win32" });
 
-    expect(line).toBe('node.exe "C:\\repo path\\nested\\"');
+    expect(line).toBe('node.exe "C:\\repo path\\nested\\\\"');
+    expect(parseCommandLine(line, { platform: "win32" })).toEqual(argv);
+  });
+
+  it("round-trips Windows arguments with backslashes before quotes", () => {
+    const argv = ["node.exe", 'C:\\repo path\\"quoted"'];
+    const line = commandArrayToLine(argv, { platform: "win32" });
+
+    expect(line).toBe('node.exe "C:\\repo path\\\\\"\"quoted\"\""');
     expect(parseCommandLine(line, { platform: "win32" })).toEqual(argv);
   });
 
   it("parses Windows doubled quotes without treating backslashes as escapes", () => {
-    expect(parseCommandLine('"ab""c" "C:\\repo path\\" d', { platform: "win32" })).toEqual([
+    expect(parseCommandLine('"ab""c" "C:\\repo path\\\\" d', { platform: "win32" })).toEqual([
       'ab"c',
       "C:\\repo path\\",
       "d",
diff --git a/apps/desktop/src/renderer/lib/shell.ts b/apps/desktop/src/renderer/lib/shell.ts
index 558907104..ac6c068fa 100644
--- a/apps/desktop/src/renderer/lib/shell.ts
+++ b/apps/desktop/src/renderer/lib/shell.ts
@@ -15,7 +15,25 @@ function isWindowsPlatform(platform: ShellPlatform = currentShellPlatform()): bo
 function quoteWindowsArg(arg: string): string {
   if (!arg.length) return '""';
   if (!/[\s"]/.test(arg)) return arg;
-  return `"${arg.replace(/"/g, "\"\"")}"`;
+  let quoted = "\"";
+  let backslashes = 0;
+  for (const char of arg) {
+    if (char === "\\") {
+      backslashes += 1;
+      continue;
+    }
+    if (char === "\"") {
+      quoted += "\\".repeat(backslashes * 2);
+      quoted += "\"\"";
+    } else {
+      quoted += "\\".repeat(backslashes);
+      quoted += char;
+    }
+    backslashes = 0;
+  }
+  quoted += "\\".repeat(backslashes * 2);
+  quoted += "\"";
+  return quoted;
 }
 
 /** Quote a single shell argument, adding double quotes if needed. */
@@ -107,6 +125,31 @@ function parseWindowsCommandLine(input: string): string[] {
   for (let i = 0; i < input.length; i += 1) {
     const ch = input[i]!;
 
+    if (ch === "\\") {
+      let end = i;
+      while (input[end] === "\\") end += 1;
+      const count = end - i;
+      if (input[end] === '"') {
+        current += "\\".repeat(Math.floor(count / 2));
+        if (count % 2 === 0) {
+          if (inQuotes && input[end + 1] === '"') {
+            current += '"';
+            i = end + 1;
+          } else {
+            inQuotes = !inQuotes;
+            i = end;
+          }
+        } else {
+          current += '"';
+          i = end;
+        }
+      } else {
+        current += "\\".repeat(count);
+        i = end - 1;
+      }
+      continue;
+    }
+
     if (ch === '"') {
       if (inQuotes && input[i + 1] === '"') {
         current += '"';

From 1153de39970edca5e3861cb5a9948aa258647862 Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Thu, 23 Apr 2026 16:32:00 -0400
Subject: [PATCH 07/11] ship: iteration 4 stabilize terminal renderer test

---
 .../src/renderer/components/terminals/TerminalView.test.tsx     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/apps/desktop/src/renderer/components/terminals/TerminalView.test.tsx b/apps/desktop/src/renderer/components/terminals/TerminalView.test.tsx
index 013a40f10..7155c04a8 100644
--- a/apps/desktop/src/renderer/components/terminals/TerminalView.test.tsx
+++ b/apps/desktop/src/renderer/components/terminals/TerminalView.test.tsx
@@ -416,7 +416,7 @@ describe("TerminalView", () => {
     // 1) timer flush kicks off the render + initRendererChain
     // 2) microtask flush lets the dynamic import resolve
     // 3) second timer flush lets the post-import code run
-    for (let i = 0; i < 20; i++) {
+    for (let i = 0; i < 200; i++) {
       await act(async () => {});
       await flushAllTimers();
       const runtime = getTerminalRuntimeSnapshot("session-dom");

From fcf7cd4fcb3c6789ff7e7a6ea3a3750ab4937623 Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Thu, 23 Apr 2026 16:50:37 -0400
Subject: [PATCH 08/11] ship: iteration 5 address final review feedback

---
 apps/ade-cli/src/adeRpcServer.test.ts         |  44 +++
 apps/ade-cli/src/adeRpcServer.ts              |   5 +-
 apps/desktop/scripts/dev.cjs                  |  50 +++-
 .../services/ai/tools/universalTools.test.ts  |  99 +++++++
 .../main/services/ai/tools/universalTools.ts  | 253 +++++++++++++++---
 .../services/conflicts/conflictService.ts     |  55 +++-
 .../opencode/openCodeServerManager.test.ts    |  13 +-
 .../opencode/openCodeServerManager.ts         |  20 +-
 .../aiOrchestratorService.test.ts             |  87 ++++++
 .../orchestrator/aiOrchestratorService.ts     |   1 +
 .../providerOrchestratorAdapter.test.ts       |  71 ++++-
 .../providerOrchestratorAdapter.ts            |   3 +-
 .../src/main/services/pty/ptyService.test.ts  |   2 +-
 .../src/main/services/pty/ptyService.ts       |   5 +-
 .../main/services/sync/syncService.test.ts    |  58 ++++
 .../src/main/services/sync/syncService.ts     |  19 +-
 apps/desktop/src/shared/adeMcpIpc.test.ts     |  23 +-
 apps/desktop/src/shared/adeMcpIpc.ts          |  10 +-
 docs/ARCHITECTURE.md                          |   2 +-
 19 files changed, 748 insertions(+), 72 deletions(-)

diff --git a/apps/ade-cli/src/adeRpcServer.test.ts b/apps/ade-cli/src/adeRpcServer.test.ts
index 49da7d242..6c404c620 100644
--- a/apps/ade-cli/src/adeRpcServer.test.ts
+++ b/apps/ade-cli/src/adeRpcServer.test.ts
@@ -5,6 +5,18 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 import { createAdeRpcRequestHandler, _resetGlobalAskUserRateLimit } from "./adeRpcServer";
 
 type RuntimeFixture = ReturnType<typeof createRuntime>;
+const originalPlatform = process.platform;
+
+function setPlatform(value: NodeJS.Platform): void {
+  Object.defineProperty(process, "platform", {
+    value,
+    configurable: true,
+  });
+}
+
+afterEach(() => {
+  setPlatform(originalPlatform);
+});
 
 function createRuntime() {
   const operationStart = vi.fn((args: any) => ({ operationId: `op-${args.kind}-${Date.now()}` }));
@@ -1912,6 +1924,38 @@ describe("adeRpcServer", () => {
     );
   });
 
+  it("does not use POSIX env assignment in unresolved Windows spawn_agent startup commands", async () => {
+    setPlatform("win32");
+    const fixture = createRuntime();
+    const handler = createAdeRpcRequestHandler({ runtime: fixture.runtime, serverVersion: "test" });
+
+    const response = await withEnv({ PATH: fs.mkdtempSync(path.join(os.tmpdir(), "ade-cli-empty-win-path-")) }, async () => {
+      await initialize(handler, { role: "orchestrator" });
+      return await callTool(handler, "spawn_agent", {
+        laneId: "lane-1",
+        provider: "claude",
+        prompt: "Implement API wiring",
+        runId: "run-1",
+        attemptId: "attempt-win-fallback",
+      });
+    });
+
+    expect(response?.isError).toBeUndefined();
+    expect(response.structuredContent.startupCommand).toContain("claude");
+    expect(response.structuredContent.startupCommand).not.toContain("ADE_RUN_ID=run-1");
+    expect(response.structuredContent.startupCommand).not.toContain("ADE_ATTEMPT_ID=attempt-win-fallback");
+    expect(fixture.runtime.ptyService.create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        env: expect.objectContaining({
+          ADE_RUN_ID: "run-1",
+          ADE_ATTEMPT_ID: "attempt-win-fallback",
+          ADE_DEFAULT_ROLE: "agent",
+        }),
+        startupCommand: response.structuredContent.startupCommand,
+      })
+    );
+  });
+
   it("rejects config-toml permission mode for Claude spawn_agent sessions", async () => {
     const fixture = createRuntime();
     const handler = createAdeRpcRequestHandler({ runtime: fixture.runtime, serverVersion: "test" });
diff --git a/apps/ade-cli/src/adeRpcServer.ts b/apps/ade-cli/src/adeRpcServer.ts
index 5c4535682..e1079e875 100644
--- a/apps/ade-cli/src/adeRpcServer.ts
+++ b/apps/ade-cli/src/adeRpcServer.ts
@@ -5960,8 +5960,9 @@ async function runTool(args: {
     workerEnv.ADE_DEFAULT_ROLE = "agent";
     envPrefixParts.push("ADE_DEFAULT_ROLE=agent");
 
-    const startupCommand = envPrefixParts.length > 0
-      ? `${envPrefixParts.join(" ")} ${commandPreviewParts.join(" ")}`
+    const startupEnvPrefixParts = process.platform === "win32" ? [] : envPrefixParts;
+    const startupCommand = startupEnvPrefixParts.length > 0
+      ? `${startupEnvPrefixParts.join(" ")} ${commandPreviewParts.join(" ")}`
       : commandPreviewParts.join(" ");
     const providerExecutable = resolveExecutableOnPath(provider);
 
diff --git a/apps/desktop/scripts/dev.cjs b/apps/desktop/scripts/dev.cjs
index 414a84349..3603b808e 100644
--- a/apps/desktop/scripts/dev.cjs
+++ b/apps/desktop/scripts/dev.cjs
@@ -7,7 +7,7 @@ const path = require("node:path");
 
 const projectRoot = path.resolve(__dirname, "..");
 const distMainFile = path.join(projectRoot, "dist", "main", "main.cjs");
-const npxCommand = process.platform === "win32" ? "npx.cmd" : "npx";
+const npxCommand = "npx";
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -109,11 +109,53 @@ async function waitForStableFile(filePath, timeoutMs, stableWindowMs = 300) {
   }
 }
 
+function quoteWindowsCmdArg(value) {
+  let quoted = "\"";
+  let backslashes = 0;
+  for (const char of String(value).replace(/%/g, "%%")) {
+    if (char === "\\") {
+      backslashes += 1;
+      continue;
+    }
+    if (char === "\"") {
+      quoted += "\\".repeat(backslashes * 2);
+      quoted += "\"\"";
+    } else {
+      quoted += "\\".repeat(backslashes);
+      quoted += char;
+    }
+    backslashes = 0;
+  }
+  quoted += "\\".repeat(backslashes * 2);
+  quoted += "\"";
+  return quoted;
+}
+
+function shouldUseWindowsCmdWrapper(cmd) {
+  if (process.platform !== "win32") return false;
+  const ext = path.win32.extname(cmd).toLowerCase();
+  return ext === "" || ext === ".cmd" || ext === ".bat";
+}
+
+function resolveSpawnInvocation(cmd, args, env) {
+  if (!shouldUseWindowsCmdWrapper(cmd)) {
+    return { command: cmd, args, windowsVerbatimArguments: false };
+  }
+  return {
+    command: env.ComSpec && env.ComSpec.trim() ? env.ComSpec.trim() : "cmd.exe",
+    args: ["/d", "/s", "/c", [cmd, ...args].map(quoteWindowsCmdArg).join(" ")],
+    windowsVerbatimArguments: true,
+  };
+}
+
 function spawnProcess(name, cmd, args, extraEnv = {}) {
-  const child = cp.spawn(cmd, args, {
+  const env = { ...process.env, ...extraEnv };
+  const invocation = resolveSpawnInvocation(cmd, args, env);
+  const child = cp.spawn(invocation.command, invocation.args, {
     cwd: projectRoot,
-    env: { ...process.env, ...extraEnv },
-    stdio: "inherit"
+    env,
+    stdio: "inherit",
+    windowsVerbatimArguments: invocation.windowsVerbatimArguments,
   });
   child.__adeName = name;
   return child;
diff --git a/apps/desktop/src/main/services/ai/tools/universalTools.test.ts b/apps/desktop/src/main/services/ai/tools/universalTools.test.ts
index 884b23086..6517d0647 100644
--- a/apps/desktop/src/main/services/ai/tools/universalTools.test.ts
+++ b/apps/desktop/src/main/services/ai/tools/universalTools.test.ts
@@ -248,6 +248,105 @@ describe("checkWorkerSandbox", () => {
     expect(result.reason).toContain("non-literal path argument");
   });
 
+  it("blocks uninspected PowerShell -File script execution", () => {
+    const result = checkWorkerSandbox(
+      "powershell.exe -File .\\scripts\\setup.ps1",
+      DEFAULT_WORKER_SANDBOX_CONFIG,
+      "C:\\projects\\repo",
+    );
+
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("PowerShell script file is not inspectable");
+  });
+
+  it("blocks uninspected bare PowerShell script execution", () => {
+    const result = checkWorkerSandbox(
+      ".\\scripts\\setup.ps1",
+      DEFAULT_WORKER_SANDBOX_CONFIG,
+      "C:\\projects\\repo",
+    );
+
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("PowerShell script file is not inspectable");
+  });
+
+  it("detects PowerShell mutations through nested cmd.exe /c wrappers", () => {
+    const result = checkWorkerSandbox(
+      'cmd.exe /d /s /c cmd.exe /c powershell.exe -Command "Set-Content -Path ..\\outside.txt -Value hi"',
+      sandboxWith({ allowedPaths: ["./"] }),
+      "C:\\projects\\repo",
+    );
+
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("Path outside sandbox");
+  });
+
+  it("blocks PowerShell mutation paths hidden behind parenthesized expressions", () => {
+    const result = checkWorkerSandbox(
+      'powershell.exe -Command "Set-Content -Path (Join-Path .. outside.txt) -Value hi"',
+      DEFAULT_WORKER_SANDBOX_CONFIG,
+      "C:\\projects\\repo",
+    );
+
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("uninspectable path argument");
+  });
+
+  it("blocks PowerShell mutation paths hidden behind subexpressions", () => {
+    const result = checkWorkerSandbox(
+      'powershell.exe -Command "Set-Content -Path $(Join-Path .. outside.txt) -Value hi"',
+      DEFAULT_WORKER_SANDBOX_CONFIG,
+      "C:\\projects\\repo",
+    );
+
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("uninspectable path argument");
+  });
+
+  it("blocks PowerShell mutation paths hidden behind array expressions", () => {
+    const result = checkWorkerSandbox(
+      'powershell.exe -Command "Set-Content -Path @(\'..\\outside.txt\') -Value hi"',
+      DEFAULT_WORKER_SANDBOX_CONFIG,
+      "C:\\projects\\repo",
+    );
+
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("uninspectable path argument");
+  });
+
+  it("blocks PowerShell mutations with empty path captures", () => {
+    const result = checkWorkerSandbox(
+      'powershell.exe -Command "Set-Content -Path -Value secret"',
+      DEFAULT_WORKER_SANDBOX_CONFIG,
+      "C:\\projects\\repo",
+    );
+
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("uninspectable path argument");
+  });
+
+  it("does not let PowerShell switch parameters consume positional mutation paths", () => {
+    const result = checkWorkerSandbox(
+      'powershell.exe -Command "Set-Content -NoNewline ..\\outside.txt -Value hi"',
+      sandboxWith({ allowedPaths: ["./"] }),
+      "C:\\projects\\repo",
+    );
+
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("Path outside sandbox");
+  });
+
+  it("keeps inspecting positional paths after PowerShell -Force and -Recurse switches", () => {
+    const result = checkWorkerSandbox(
+      'powershell.exe -Command "Remove-Item -Force -Recurse ..\\outside"',
+      sandboxWith({ allowedPaths: ["./"] }),
+      "C:\\projects\\repo",
+    );
+
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("Path outside sandbox");
+  });
+
   it("blocks opaque PowerShell encoded commands", () => {
     const result = checkWorkerSandbox(
       "powershell.exe -EncodedCommand not-base64!!!",
diff --git a/apps/desktop/src/main/services/ai/tools/universalTools.ts b/apps/desktop/src/main/services/ai/tools/universalTools.ts
index 3d68e0894..692c939c6 100644
--- a/apps/desktop/src/main/services/ai/tools/universalTools.ts
+++ b/apps/desktop/src/main/services/ai/tools/universalTools.ts
@@ -204,8 +204,21 @@ type PowerShellMutationKind =
 
 const POWERSHELL_COMMAND_FLAGS = new Set(["-command", "-c"]);
 const POWERSHELL_ENCODED_COMMAND_FLAGS = new Set(["-encodedcommand", "-enc", "-e"]);
+const POWERSHELL_FILE_FLAGS = new Set(["-file"]);
 const POWERSHELL_SEGMENT_SEPARATORS = new Set(["|", "||", "&&", ";"]);
 const POWERSHELL_PUNCTUATION_TOKENS = new Set(["{", "}", "(", ")", ","]);
+const POWERSHELL_SWITCH_PARAMETERS = new Set([
+  "-append",
+  "-confirm",
+  "-debug",
+  "-force",
+  "-noclobber",
+  "-nonewline",
+  "-passthru",
+  "-recurse",
+  "-verbose",
+  "-whatif",
+]);
 const POWERSHELL_MUTATION_KIND_BY_COMMAND = new Map<string, PowerShellMutationKind>([
   ["add-content", "path-write"],
   ["ac", "path-write"],
@@ -352,6 +365,15 @@ function isPowerShellHostCommand(commandName: string): boolean {
   return baseName === "powershell" || baseName === "powershell.exe" || baseName === "pwsh" || baseName === "pwsh.exe";
 }
 
+function isCmdHostCommand(commandName: string): boolean {
+  const baseName = path.win32.basename(normalizePathToken(commandName)).toLowerCase();
+  return baseName === "cmd" || baseName === "cmd.exe";
+}
+
+function isPowerShellScriptPath(value: string): boolean {
+  return /\.ps1$/i.test(normalizePathToken(value));
+}
+
 function decodePowerShellEncodedCommand(value: string): string | null {
   const trimmed = normalizePathToken(value);
   if (!trimmed.length || !/^[a-z0-9+/=]+$/i.test(trimmed)) {
@@ -369,10 +391,27 @@ function isPowerShellParameterToken(value: string): boolean {
   return /^-[a-z]/i.test(value);
 }
 
+function isPowerShellSwitchParameterToken(value: string): boolean {
+  return POWERSHELL_SWITCH_PARAMETERS.has(value.toLowerCase());
+}
+
 function isPowerShellDynamicArgument(value: string): boolean {
   return value.startsWith("$") || value.startsWith("@(") || value.includes("$(");
 }
 
+function isPowerShellOpaquePathSyntax(value: string): boolean {
+  const trimmed = value.trim();
+  return (
+    !trimmed.length ||
+    trimmed === "@" ||
+    trimmed === "$" ||
+    POWERSHELL_PUNCTUATION_TOKENS.has(trimmed) ||
+    trimmed.startsWith("(") ||
+    trimmed.startsWith("@(") ||
+    trimmed.includes("$(")
+  );
+}
+
 function normalizePowerShellPathArgument(value: string): { path?: string; nonFilesystemProvider?: string; opaque?: string } {
   const normalized = normalizePathToken(value);
   if (!normalized.length) return {};
@@ -414,6 +453,12 @@ function parsePowerShellArgs(args: string[]): { positional: string[]; named: Map
 
     if (isPowerShellParameterToken(raw)) {
       const key = raw.toLowerCase();
+      if (isPowerShellSwitchParameterToken(key)) {
+        const values = named.get(key) ?? [];
+        values.push("");
+        named.set(key, values);
+        continue;
+      }
       const next = normalizePathToken(args[i + 1] ?? "");
       if (next.length > 0 && !isPowerShellParameterToken(next) && !POWERSHELL_PUNCTUATION_TOKENS.has(next)) {
         const values = named.get(key) ?? [];
@@ -438,6 +483,7 @@ function inspectPowerShellInvocations(
   command: string,
   cwd: string,
   pathApi: SandboxPathApi = getSandboxPathApi(cwd, command),
+  depth = 0,
 ): PowerShellInspection {
   const refs = new Map<string, PathReference>();
   const accessPriority: Record<PathAccessMode, number> = {
@@ -447,6 +493,9 @@ function inspectPowerShellInvocations(
   };
 
   const addResolvedPath = (rawValue: string, access: PathAccessMode): { blockedReason?: string } => {
+    if (access !== "read" && isPowerShellOpaquePathSyntax(rawValue)) {
+      return { blockedReason: `PowerShell mutation uses an uninspectable path argument: ${rawValue}` };
+    }
     const normalized = normalizePathToken(rawValue);
     if (!normalized.length || normalized.includes("://")) return {};
 
@@ -488,6 +537,7 @@ function inspectPowerShellInvocations(
     flags: string[],
     positionalIndex: number | null,
     access: PathAccessMode,
+    failOnMissing = true,
   ): { blockedReason?: string } => {
     for (const flag of flags) {
       const values = parsed.named.get(flag);
@@ -498,54 +548,83 @@ function inspectPowerShellInvocations(
     if (positionalIndex !== null && parsed.positional[positionalIndex]) {
       return addResolvedPath(parsed.positional[positionalIndex]!, access);
     }
+    if (access !== "read" && failOnMissing) {
+      return { blockedReason: "PowerShell mutation path argument is not inspectable by the worker sandbox" };
+    }
     return {};
   };
 
-  const outerSegments = splitCommandSegments(tokenizeCommand(command, pathApi === path.win32));
-  let mutates = false;
+  const mergeInspection = (inspection: PowerShellInspection) => {
+    for (const entry of inspection.pathRefs) {
+      const key = `${entry.raw}::${entry.resolved}`;
+      const existing = refs.get(key);
+      if (!existing || accessPriority[entry.access] > accessPriority[existing.access]) {
+        refs.set(key, entry);
+      }
+    }
+  };
 
-  for (const segment of outerSegments) {
-    const commandName = normalizePathToken(segment[0] ?? "");
-    if (!commandName.length || !isPowerShellHostCommand(commandName)) continue;
+  const inspectScriptFile = (rawScriptPath: string): PowerShellInspection => {
+    const trimmed = rawScriptPath.trim();
+    if (isPowerShellOpaquePathSyntax(trimmed) || isPowerShellDynamicArgument(trimmed)) {
+      return {
+        mutates: true,
+        pathRefs: [...refs.values()],
+        blockedReason: `PowerShell script path is not inspectable by the worker sandbox: ${trimmed}`,
+      };
+    }
 
-    const args = segment.slice(1);
-    let script: string | null = null;
-    for (let i = 0; i < args.length; i += 1) {
-      const flag = normalizePathToken(args[i] ?? "").toLowerCase();
-      if (POWERSHELL_COMMAND_FLAGS.has(flag)) {
-        const remainder = args.slice(i + 1).join(" ").trim();
-        if (!remainder.length || remainder === "-") {
-          return {
-            mutates: true,
-            pathRefs: [...refs.values()],
-            blockedReason: "PowerShell -Command input is not inspectable by the worker sandbox",
-          };
-        }
-        script = remainder;
-        break;
+    const normalizedPath = normalizePowerShellPathArgument(trimmed);
+    if (normalizedPath.opaque || normalizedPath.nonFilesystemProvider || !normalizedPath.path) {
+      return {
+        mutates: true,
+        pathRefs: [...refs.values()],
+        blockedReason: `PowerShell script path is not inspectable by the worker sandbox: ${trimmed}`,
+      };
+    }
+
+    const addScriptRef = addResolvedPath(normalizedPath.path, "read");
+    if (addScriptRef.blockedReason) {
+      return { mutates: true, pathRefs: [...refs.values()], blockedReason: addScriptRef.blockedReason };
+    }
+
+    const scriptPath = pathApi.resolve(cwd, normalizedPath.path);
+    try {
+      const realCwd = canonicalizePathForContainment(cwd, pathApi);
+      const realScriptPath = canonicalizePathForContainment(scriptPath, pathApi);
+      if (!isWithinDirForPathApi(pathApi, realCwd, realScriptPath)) {
+        return {
+          mutates: true,
+          pathRefs: [...refs.values()],
+          blockedReason: `PowerShell script file is outside the inspectable sandbox root: ${normalizedPath.path}`,
+        };
       }
-      if (POWERSHELL_ENCODED_COMMAND_FLAGS.has(flag)) {
-        const decoded = decodePowerShellEncodedCommand(args[i + 1] ?? "");
-        if (!decoded) {
-          return {
-            mutates: true,
-            pathRefs: [...refs.values()],
-            blockedReason: "PowerShell -EncodedCommand payload is not inspectable by the worker sandbox",
-          };
-        }
-        script = decoded;
-        break;
+      if (!fs.existsSync(realScriptPath) || !fs.statSync(realScriptPath).isFile()) {
+        return {
+          mutates: true,
+          pathRefs: [...refs.values()],
+          blockedReason: `PowerShell script file is not inspectable by the worker sandbox: ${normalizedPath.path}`,
+        };
       }
+      const script = fs.readFileSync(realScriptPath, "utf-8");
+      return inspectPowerShellScript(script);
+    } catch {
+      return {
+        mutates: true,
+        pathRefs: [...refs.values()],
+        blockedReason: `PowerShell script file is not inspectable by the worker sandbox: ${normalizedPath.path}`,
+      };
     }
+  };
 
-    if (!script) continue;
-
+  const inspectPowerShellScript = (script: string): PowerShellInspection => {
+    let scriptMutates = false;
     const tokens = tokenizePowerShellCommand(script);
     for (let i = 0; i < tokens.length; i += 1) {
       const token = normalizePathToken(tokens[i] ?? "");
       if (!token.length) continue;
       if (token === ">" || token === ">>" || /^\d>>?$/.test(token)) {
-        mutates = true;
+        scriptMutates = true;
         const writeTarget = addResolvedPath(tokens[i + 1] ?? "", "write");
         if (writeTarget.blockedReason) {
           return {
@@ -569,10 +648,19 @@ function inspectPowerShellInvocations(
       }
       if (innerCommandIndex >= innerSegment.length) continue;
 
-      const innerCommandName = normalizePathToken(innerSegment[innerCommandIndex] ?? "").toLowerCase();
+      const innerCommandToken = normalizePathToken(innerSegment[innerCommandIndex] ?? "");
+      const innerCommandName = innerCommandToken.toLowerCase();
+      if (isPowerShellScriptPath(innerCommandToken)) {
+        const scriptFileInspection = inspectScriptFile(innerCommandToken);
+        mergeInspection(scriptFileInspection);
+        if (scriptFileInspection.blockedReason) return { ...scriptFileInspection, pathRefs: [...refs.values()] };
+        scriptMutates = scriptMutates || scriptFileInspection.mutates;
+        continue;
+      }
+
       const mutationKind = POWERSHELL_MUTATION_KIND_BY_COMMAND.get(innerCommandName);
       if (!mutationKind) continue;
-      mutates = true;
+      scriptMutates = true;
 
       const parsed = parsePowerShellArgs(innerSegment.slice(innerCommandIndex + 1));
       let result: { blockedReason?: string } = {};
@@ -605,7 +693,7 @@ function inspectPowerShellInvocations(
           result = addFirstNamedOrPositionalPath(parsed, ["-newname"], 1, "write");
           break;
         case "new-item":
-          result = addFirstNamedOrPositionalPath(parsed, ["-path", "-literalpath", "-pspath", "-lp"], 0, "write");
+          result = addFirstNamedOrPositionalPath(parsed, ["-path", "-literalpath", "-pspath", "-lp"], 0, "write", false);
           if (result.blockedReason) break;
           if (parsed.named.get("-name")?.[0]) {
             result = addResolvedPath(parsed.named.get("-name")![0]!, "write");
@@ -624,6 +712,97 @@ function inspectPowerShellInvocations(
         };
       }
     }
+
+    return { mutates: scriptMutates, pathRefs: [...refs.values()] };
+  };
+
+  const outerSegments = splitCommandSegments(tokenizeCommand(command, pathApi === path.win32));
+  let mutates = false;
+
+  for (const segment of outerSegments) {
+    const commandName = normalizePathToken(segment[0] ?? "");
+    if (!commandName.length) continue;
+
+    if (isCmdHostCommand(commandName)) {
+      if (depth >= 4) {
+        return {
+          mutates: true,
+          pathRefs: [...refs.values()],
+          blockedReason: "Nested cmd.exe /c command is not inspectable by the worker sandbox",
+        };
+      }
+      const commandArgIndex = segment.findIndex((arg, index) => index > 0 && /^\/c$/i.test(normalizePathToken(arg)));
+      if (commandArgIndex >= 0) {
+        const nestedCommand = segment.slice(commandArgIndex + 1).join(" ").trim();
+        if (!nestedCommand.length) {
+          return {
+            mutates: true,
+            pathRefs: [...refs.values()],
+            blockedReason: "cmd.exe /c payload is not inspectable by the worker sandbox",
+          };
+        }
+        const nestedInspection = inspectPowerShellInvocations(nestedCommand, cwd, pathApi, depth + 1);
+        mergeInspection(nestedInspection);
+        if (nestedInspection.blockedReason) return { ...nestedInspection, pathRefs: [...refs.values()] };
+        mutates = mutates || nestedInspection.mutates;
+      }
+      continue;
+    }
+
+    if (isPowerShellScriptPath(commandName)) {
+      const scriptFileInspection = inspectScriptFile(commandName);
+      mergeInspection(scriptFileInspection);
+      if (scriptFileInspection.blockedReason) return { ...scriptFileInspection, pathRefs: [...refs.values()] };
+      mutates = mutates || scriptFileInspection.mutates;
+      continue;
+    }
+
+    if (!isPowerShellHostCommand(commandName)) continue;
+
+    const args = segment.slice(1);
+    let script: string | null = null;
+    for (let i = 0; i < args.length; i += 1) {
+      const flag = normalizePathToken(args[i] ?? "").toLowerCase();
+      if (POWERSHELL_COMMAND_FLAGS.has(flag)) {
+        const remainder = args.slice(i + 1).join(" ").trim();
+        if (!remainder.length || remainder === "-") {
+          return {
+            mutates: true,
+            pathRefs: [...refs.values()],
+            blockedReason: "PowerShell -Command input is not inspectable by the worker sandbox",
+          };
+        }
+        script = remainder;
+        break;
+      }
+      if (POWERSHELL_ENCODED_COMMAND_FLAGS.has(flag)) {
+        const decoded = decodePowerShellEncodedCommand(args[i + 1] ?? "");
+        if (!decoded) {
+          return {
+            mutates: true,
+            pathRefs: [...refs.values()],
+            blockedReason: "PowerShell -EncodedCommand payload is not inspectable by the worker sandbox",
+          };
+        }
+        script = decoded;
+        break;
+      }
+      if (POWERSHELL_FILE_FLAGS.has(flag)) {
+        const scriptPath = args[i + 1] ?? "";
+        const scriptFileInspection = inspectScriptFile(scriptPath);
+        mergeInspection(scriptFileInspection);
+        if (scriptFileInspection.blockedReason) return { ...scriptFileInspection, pathRefs: [...refs.values()] };
+        mutates = mutates || scriptFileInspection.mutates;
+        script = null;
+        break;
+      }
+    }
+
+    if (!script) continue;
+    const scriptInspection = inspectPowerShellScript(script);
+    mergeInspection(scriptInspection);
+    if (scriptInspection.blockedReason) return { ...scriptInspection, pathRefs: [...refs.values()] };
+    mutates = mutates || scriptInspection.mutates;
   }
 
   return { mutates, pathRefs: [...refs.values()] };
diff --git a/apps/desktop/src/main/services/conflicts/conflictService.ts b/apps/desktop/src/main/services/conflicts/conflictService.ts
index 101186fac..c7a57eafe 100644
--- a/apps/desktop/src/main/services/conflicts/conflictService.ts
+++ b/apps/desktop/src/main/services/conflicts/conflictService.ts
@@ -2,7 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-import { resolveCliSpawnInvocation } from "../shared/processExecution";
+import { resolveCliSpawnInvocation, terminateProcessTree } from "../shared/processExecution";
 import type {
   ApplyConflictProposalArgs,
   BatchOverlapEntry,
@@ -199,6 +199,23 @@ const PREFILTER_MAX_GLOBAL_PAIRS = 800;
 const PREFILTER_MAX_TOUCHED_FILES = 800;
 const STALE_MS = 5 * 60_000;
 const EXTERNAL_DIFF_MAX_OUTPUT_BYTES = 32 * 1024 * 1024;
+const EXTERNAL_RESOLVER_TIMEOUT_MS = 8 * 60_000;
+
+function terminateExternalResolverProcessTree(
+  child: ReturnType<typeof spawn>,
+  signal: NodeJS.Signals,
+): boolean {
+  if (child.exitCode !== null || child.signalCode !== null) return false;
+  if (process.platform !== "win32" && typeof child.pid === "number") {
+    try {
+      process.kill(-child.pid, signal);
+      return true;
+    } catch {
+      // Fall through to the direct child kill path.
+    }
+  }
+  return terminateProcessTree(child, signal);
+}
 
 function safeJsonArray<T>(raw: string | null): T[] {
   const parsed = safeJsonParse(raw, null);
@@ -3498,25 +3515,44 @@ export function createConflictService({
       command: renderedCommand
     });
 
-    const proc = await new Promise<{ stdout: string; stderr: string; status: number | null; signal: NodeJS.Signals | null }>((resolve) => {
+    const proc = await new Promise<{ stdout: string; stderr: string; status: number | null; signal: NodeJS.Signals | null; timedOut: boolean }>((resolve) => {
       const invocation = resolveCliSpawnInvocation(bin, renderedCommand.slice(1), process.env);
       const child = spawn(invocation.command, invocation.args, {
         cwd: cwdLane.worktreePath,
         env: process.env,
         stdio: ["ignore", "pipe", "pipe"],
-        timeout: 8 * 60_000,
+        detached: process.platform !== "win32",
         windowsVerbatimArguments: invocation.windowsVerbatimArguments,
       });
       let stdout = "";
       let stderr = "";
+      let timedOut = false;
+      let forceKillTimer: NodeJS.Timeout | null = null;
+      const timeoutTimer = setTimeout(() => {
+        timedOut = true;
+        terminateExternalResolverProcessTree(child, "SIGTERM");
+        forceKillTimer = setTimeout(() => {
+          terminateExternalResolverProcessTree(child, "SIGKILL");
+        }, 2_000);
+      }, EXTERNAL_RESOLVER_TIMEOUT_MS);
+      const cleanupTimers = () => {
+        clearTimeout(timeoutTimer);
+        if (forceKillTimer) clearTimeout(forceKillTimer);
+      };
       child.stdout?.on("data", (chunk: Buffer) => {
         if (stdout.length < 8 * 1024 * 1024) stdout += chunk.toString("utf8");
       });
       child.stderr?.on("data", (chunk: Buffer) => {
         if (stderr.length < 8 * 1024 * 1024) stderr += chunk.toString("utf8");
       });
-      child.on("error", () => resolve({ stdout, stderr, status: 1, signal: null }));
-      child.on("close", (code, signal) => resolve({ stdout, stderr, status: code, signal }));
+      child.on("error", () => {
+        cleanupTimers();
+        resolve({ stdout, stderr, status: 1, signal: null, timedOut });
+      });
+      child.on("close", (code, signal) => {
+        cleanupTimers();
+        resolve({ stdout, stderr, status: code, signal, timedOut });
+      });
     });
 
     const stdout = proc.stdout ?? "";
@@ -3536,7 +3572,7 @@ export function createConflictService({
       finalPatchPath = patchPath;
     }
 
-    const status: ConflictExternalResolverRunStatus = proc.status === 0 ? "completed" : "failed";
+    const status: ConflictExternalResolverRunStatus = proc.status === 0 && !proc.timedOut ? "completed" : "failed";
     const runRecord: ExternalResolverRunRecord = {
       ...existingRun,
       status,
@@ -3548,12 +3584,17 @@ export function createConflictService({
       logPath: outputLogPath,
       warnings: [
         ...existingRun.warnings,
+        ...(proc.timedOut ? ["resolver_timeout_process_tree_terminated"] : []),
         ...(proc.signal ? [`process_signal:${proc.signal}`] : []),
         ...(diffResult.stdoutTruncated ? ["git_diff_stdout_truncated"] : []),
         ...(diffResult.stderrTruncated ? ["git_diff_stderr_truncated"] : []),
         ...missingRequiredContexts.map((relPath) => `missing_context:${relPath}`)
       ],
-      error: proc.status === 0 ? null : (stderr.trim() || `Exit code ${proc.status ?? -1}`)
+      error: status === "completed"
+        ? null
+        : proc.timedOut
+          ? `External resolver timed out after ${EXTERNAL_RESOLVER_TIMEOUT_MS}ms.`
+          : (stderr.trim() || `Exit code ${proc.status ?? -1}`)
     };
     writeExternalRunRecord(runRecord);
     return toRunSummary(runRecord);
diff --git a/apps/desktop/src/main/services/opencode/openCodeServerManager.test.ts b/apps/desktop/src/main/services/opencode/openCodeServerManager.test.ts
index 408057c9b..51f65dee0 100644
--- a/apps/desktop/src/main/services/opencode/openCodeServerManager.test.ts
+++ b/apps/desktop/src/main/services/opencode/openCodeServerManager.test.ts
@@ -3,10 +3,11 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 const mockState = vi.hoisted(() => ({
   created: [] as Array<{ close: ReturnType<typeof vi.fn>; url: string }>,
+  resolveOpenCodeBinaryPath: vi.fn(() => "/Users/admin/.opencode/bin/opencode"),
 }));
 
 vi.mock("./openCodeBinaryManager", () => ({
-  resolveOpenCodeBinaryPath: vi.fn(() => "/Users/admin/.opencode/bin/opencode"),
+  resolveOpenCodeBinaryPath: mockState.resolveOpenCodeBinaryPath,
 }));
 
 import {
@@ -65,6 +66,12 @@ describe("Windows managed OpenCode command detection", () => {
       'C:\\\\Windows\\\\System32\\\\cmd.exe /d /s /c set "ADE_OPENCODE_MANAGED=1"&&set "OPENCODE_DISABLE_PROJECT_CONFIG=1"&&set "ADE_OPENCODE_OWNER_PID=999"&&C:\\\\opencode\\\\opencode.cmd serve --hostname=127.0.0.1 --port=4310';
     expect(__isManagedOpenCodeServeCommandForTests(cmdLine)).toBe(true);
   });
+
+  it("detects cmd-wrapped .bat OpenCode serve shims", () => {
+    const cmdLine =
+      'C:\\\\Windows\\\\System32\\\\cmd.exe /d /s /c set "ADE_OPENCODE_MANAGED=1"&&set "OPENCODE_DISABLE_PROJECT_CONFIG=1"&&set "ADE_OPENCODE_OWNER_PID=999"&&"C:\\\\tools\\\\opencode.bat" serve --hostname=127.0.0.1 --port=4310';
+    expect(__isManagedOpenCodeServeCommandForTests(cmdLine)).toBe(true);
+  });
 });
 
 describe("openCodeServerManager", () => {
@@ -90,6 +97,7 @@ describe("openCodeServerManager", () => {
   beforeEach(() => {
     vi.useFakeTimers();
     mockState.created.length = 0;
+    mockState.resolveOpenCodeBinaryPath.mockReturnValue("/Users/admin/.opencode/bin/opencode");
     __resetOpenCodeServerManagerForTests();
     __setOpenCodeProcessControllerForTests({
       listProcesses: () => [],
@@ -459,6 +467,7 @@ describe("openCodeServerManager", () => {
   it("quotes the OpenCode executable in Windows cmd launch specs", () => {
     setProcessPlatform("win32");
     process.env.ADE_OPENCODE_XDG_ROOT = "/tmp/ade-opencode-test-home";
+    mockState.resolveOpenCodeBinaryPath.mockReturnValue("C:\\Users\\100% dev\\bin\\opencode.bat");
 
     const spec = __buildOpenCodeServeLaunchSpecForTests({
       config: { share: "disabled" } as const,
@@ -469,7 +478,7 @@ describe("openCodeServerManager", () => {
     expect(spec.args[0]).toBe("/d");
     expect(spec.args[1]).toBe("/s");
     expect(spec.args[2]).toBe("/c");
-    expect(spec.args[3]).toContain('&&"/Users/admin/.opencode/bin/opencode" serve --hostname=127.0.0.1 --port=4310');
+    expect(spec.args[3]).toContain('&&"C:\\Users\\100%% dev\\bin\\opencode.bat" "serve" "--hostname=127.0.0.1" "--port=4310"');
   });
 
   it("reaps orphaned ADE-managed OpenCode processes on Windows with a tree kill and skips ones with a live owner", async () => {
diff --git a/apps/desktop/src/main/services/opencode/openCodeServerManager.ts b/apps/desktop/src/main/services/opencode/openCodeServerManager.ts
index 7fc787e26..b08df75cf 100644
--- a/apps/desktop/src/main/services/opencode/openCodeServerManager.ts
+++ b/apps/desktop/src/main/services/opencode/openCodeServerManager.ts
@@ -7,7 +7,7 @@ import path from "node:path";
 import type { Config as OpenCodeConfig } from "@opencode-ai/sdk";
 import type { Logger } from "../logging/logger";
 import { stableStringify } from "../shared/utils";
-import { processOutputToString } from "../shared/processExecution";
+import { processOutputToString, quoteWindowsCmdArg, resolveWindowsCmdInvocation } from "../shared/processExecution";
 import { resolveOpenCodeBinaryPath } from "./openCodeBinaryManager";
 
 export type OpenCodeServerLeaseKind = "shared" | "dedicated";
@@ -522,12 +522,12 @@ function isManagedOpenCodeServeCommand(command: string, configMarkers: string[])
   if (
     /\bcmd(?:\.exe)?\b/i.test(command)
     && command.includes(`${ADE_OPENCODE_MANAGED_ENV}=1`)
-    && /\bopencode(?:\.cmd|\.exe)?\b/i.test(command)
+    && /\bopencode(?:\.cmd|\.bat|\.exe)?\b/i.test(command)
     && /\bserve\b/i.test(command)
   ) {
     return command.includes("OPENCODE_DISABLE_PROJECT_CONFIG=1");
   }
-  if (!/\bopencode(?:\.cmd|\.exe)?\b\s+serve\b/i.test(command)) return false;
+  if (!/\bopencode(?:\.cmd|\.bat|\.exe)?\b\s+serve\b/i.test(command)) return false;
   if (!command.includes("OPENCODE_DISABLE_PROJECT_CONFIG=1")) return false;
   if (command.includes(`${ADE_OPENCODE_MANAGED_ENV}=1`)) return true;
   return configMarkers.some((marker) => command.includes(marker));
@@ -663,12 +663,18 @@ function buildOpenCodeServeLaunchSpec(args: OpenCodeServerLaunchArgs): OpenCodeS
   ensureOpenCodeIsolationDirs(xdgPaths);
   const env = buildIsolatedOpenCodeEnv(args.config, xdgPaths);
   if (process.platform === "win32") {
-    const comSpec = process.env.ComSpec?.trim() || "cmd.exe";
-    const exeForCmd = `"${executable.replace(/"/g, "\"\"")}"`;
+    const invocation = resolveWindowsCmdInvocation(
+      executable,
+      ["serve", "--hostname=127.0.0.1", `--port=${args.port}`],
+      env,
+    );
     const cmdLine =
-      `set "${ADE_OPENCODE_MANAGED_ENV}=1"&&set "OPENCODE_DISABLE_PROJECT_CONFIG=1"&&set "${ADE_OPENCODE_OWNER_PID_ENV}=${process.pid}"&&${exeForCmd} serve --hostname=127.0.0.1 --port=${args.port}`;
+      `set ${quoteWindowsCmdArg(`${ADE_OPENCODE_MANAGED_ENV}=1`)}`
+      + `&&set ${quoteWindowsCmdArg("OPENCODE_DISABLE_PROJECT_CONFIG=1")}`
+      + `&&set ${quoteWindowsCmdArg(`${ADE_OPENCODE_OWNER_PID_ENV}=${process.pid}`)}`
+      + `&&${invocation.args[3] ?? ""}`;
     return {
-      executable: comSpec,
+      executable: invocation.command,
       args: ["/d", "/s", "/c", cmdLine],
       env,
       useShell: false,
diff --git a/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.test.ts b/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.test.ts
index 9ee4324ea..09039c6c9 100644
--- a/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.test.ts
+++ b/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.test.ts
@@ -3192,6 +3192,93 @@ describe("aiOrchestratorService", () => {
     }
   });
 
+  it("does not enter a run body while another health sweep owns it", async () => {
+    const fixture = await createFixture();
+    let releaseFirstSweep: () => void = () => {};
+    const firstSweepGate = new Promise<void>((resolve) => {
+      releaseFirstSweep = resolve;
+    });
+    try {
+      const mission = fixture.missionService.create({
+        prompt: "Verify overlapping health sweeps keep single ownership.",
+        laneId: fixture.laneId
+      });
+      const launch = await fixture.aiOrchestratorService.startMissionRun({
+        missionId: mission.id,
+        runMode: "manual",
+        defaultExecutorKind: "manual"
+      });
+      if (!launch.started) throw new Error("Expected mission run to start");
+      const runId = launch.started.run.id;
+
+      fixture.orchestratorService.addSteps({
+        runId,
+        steps: [{ stepKey: "implement-changes", title: "Implement requested changes", stepIndex: 0, dependencyStepKeys: [], executorKind: "manual", metadata: { instructions: "Do the work" } }]
+      });
+      fixture.orchestratorService.tick({ runId });
+      const graph = fixture.orchestratorService.getRunGraph({ runId });
+      const readyStep = graph.steps.find((s) => s.status === "ready");
+      if (!readyStep) throw new Error("Expected a ready step");
+
+      const attempt = await fixture.orchestratorService.startAttempt({
+        runId,
+        stepId: readyStep.id,
+        ownerId: "test-owner",
+        executorKind: "manual"
+      });
+      const sessionId = "session-ended-overlap";
+      fixture.db.run(
+        `
+          update orchestrator_attempts
+          set executor_kind = 'opencode',
+              executor_session_id = ?
+          where id = ?
+        `,
+        [sessionId, attempt.id]
+      );
+      fixture.db.run(
+        `
+          insert into terminal_sessions(
+            id, lane_id, pty_id, tracked, title, started_at, ended_at, exit_code,
+            transcript_path, head_sha_start, head_sha_end, status, last_output_preview,
+            summary, tool_type, resume_command, last_output_at
+          ) values (?, ?, null, 1, 'Worker', ?, ?, 0, '', null, null, 'ended', null, null, 'codex-orchestrated', null, ?)
+        `,
+        [
+          sessionId,
+          fixture.laneId,
+          "2000-01-01T00:00:00.000Z",
+          "2000-01-01T00:00:01.000Z",
+          "2000-01-01T00:00:00.000Z",
+        ]
+      );
+
+      const originalReconcile = fixture.orchestratorService.onTrackedSessionEnded.bind(fixture.orchestratorService);
+      let reconcileCalls = 0;
+      fixture.orchestratorService.onTrackedSessionEnded = (async (args: any) => {
+        reconcileCalls += 1;
+        await firstSweepGate;
+        return await originalReconcile(args);
+      }) as typeof fixture.orchestratorService.onTrackedSessionEnded;
+
+      const firstSweep = fixture.aiOrchestratorService.runHealthSweep("overlap-owner");
+      for (let tries = 0; tries < 40 && reconcileCalls === 0; tries += 1) {
+        await new Promise((resolve) => setTimeout(resolve, 25));
+      }
+      expect(reconcileCalls).toBe(1);
+      const overlappedSweep = await fixture.aiOrchestratorService.runHealthSweep("overlap-contender");
+
+      expect(overlappedSweep.sweeps).toBe(0);
+      expect(reconcileCalls).toBe(1);
+
+      releaseFirstSweep();
+      await firstSweep;
+    } finally {
+      releaseFirstSweep();
+      fixture.dispose();
+    }
+  }, 10_000);
+
   it("skips background health sweeps for runs blocked on open interventions", async () => {
     const fixture = await createFixture();
     try {
diff --git a/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.ts b/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.ts
index beea24035..d3d6aa904 100644
--- a/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.ts
+++ b/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.ts
@@ -4279,6 +4279,7 @@ Check all worker statuses and continue managing the mission from here. Read work
             runId: run.id,
             reason
           });
+          continue;
         }
       }
       if (!activeHealthSweepRuns.has(run.id)) {
diff --git a/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.test.ts b/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.test.ts
index 5c2a4646c..d83d3dcc4 100644
--- a/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.test.ts
+++ b/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.test.ts
@@ -1,12 +1,25 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockState = vi.hoisted(() => ({
+  resolveClaudeCodeExecutable: vi.fn(() => ({ path: "/mock/bin/claude", source: "path" as const })),
+}));
+
+vi.mock("../ai/claudeCodeExecutable", () => ({
+  resolveClaudeCodeExecutable: mockState.resolveClaudeCodeExecutable,
+}));
+
 import { createProviderOrchestratorAdapter } from "./providerOrchestratorAdapter";
 
 describe("providerOrchestratorAdapter", () => {
   let projectRoot: string | null = null;
 
+  beforeEach(() => {
+    mockState.resolveClaudeCodeExecutable.mockReturnValue({ path: "/mock/bin/claude", source: "path" });
+  });
+
   afterEach(() => {
     if (projectRoot) {
       fs.rmSync(projectRoot, { recursive: true, force: true });
@@ -77,6 +90,62 @@ describe("providerOrchestratorAdapter", () => {
     }));
   });
 
+  it("resolves the Claude executable for direct startup-command overrides", async () => {
+    projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-provider-adapter-"));
+    mockState.resolveClaudeCodeExecutable.mockReturnValue({
+      path: "C:\\Users\\me\\AppData\\Roaming\\npm\\claude.cmd",
+      source: "path",
+    });
+    const createTrackedSession = vi.fn(async () => ({ ptyId: "pty-override", sessionId: "session-override" }));
+    const adapter = createProviderOrchestratorAdapter({
+      projectRoot,
+      workspaceRoot: projectRoot,
+      agentChatService: null,
+    });
+
+    const result = await adapter.start({
+      run: {
+        id: "run-1",
+        missionId: "mission-1",
+        metadata: {},
+      },
+      step: {
+        id: "step-1",
+        runId: "run-1",
+        stepKey: "override-worker",
+        title: "Override worker",
+        stepIndex: 0,
+        dependencyStepIds: [],
+        dependencyStepKeys: [],
+        laneId: "lane-1",
+        status: "ready",
+        metadata: {
+          startupCommand: "diagnose the failing check",
+        },
+      },
+      attempt: {
+        id: "attempt-1",
+        runId: "run-1",
+        stepId: "step-1",
+      },
+      allSteps: [],
+      contextProfile: {} as any,
+      laneExport: null,
+      projectExport: { content: "", truncated: false },
+      docsRefs: [],
+      fullDocs: [],
+      createTrackedSession,
+    } as any);
+
+    expect(result.status).toBe("accepted");
+    expect(mockState.resolveClaudeCodeExecutable).toHaveBeenCalledTimes(1);
+    expect(createTrackedSession).toHaveBeenCalledWith(expect.objectContaining({
+      command: "C:\\Users\\me\\AppData\\Roaming\\npm\\claude.cmd",
+      args: ["-p", "diagnose the failing check"],
+      startupCommand: expect.stringContaining("exec claude -p"),
+    }));
+  });
+
   it("launches CLI-wrapped fallback workers without shell-only command syntax", async () => {
     projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-provider-adapter-"));
     const createTrackedSession = vi.fn(async () => ({ ptyId: "pty-1", sessionId: "session-1" }));
diff --git a/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts b/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts
index a1e54b678..c4b2d637e 100644
--- a/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts
+++ b/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts
@@ -428,9 +428,10 @@ export function createProviderOrchestratorAdapter(options?: {
     buildOverrideCommand: ({ prompt }) => {
       // For override commands, try to detect the best CLI
       // Default to claude since it's the most common
+      const resolvedClaude = resolveClaudeCodeExecutable();
       return {
         startupCommand: `exec claude -p ${shellInlineDecodedArg(prompt)}`,
-        command: "claude",
+        command: resolvedClaude.path,
         args: ["-p", prompt],
       };
     },
diff --git a/apps/desktop/src/main/services/pty/ptyService.test.ts b/apps/desktop/src/main/services/pty/ptyService.test.ts
index 40eee8b74..57ed6d025 100644
--- a/apps/desktop/src/main/services/pty/ptyService.test.ts
+++ b/apps/desktop/src/main/services/pty/ptyService.test.ts
@@ -476,7 +476,7 @@ describe("ptyService", () => {
       const ptyLib = harness.loadPty.mock.results.at(-1)?.value as { spawn: ReturnType<typeof vi.fn> };
       expect(ptyLib.spawn).toHaveBeenCalledWith(
         "C:\\Windows\\System32\\cmd.exe",
-        ["/d", "/s", "/c", '"npm.cmd" "run" "dev"'],
+        '/d /s /c "npm.cmd" "run" "dev"',
         expect.any(Object),
       );
     });
diff --git a/apps/desktop/src/main/services/pty/ptyService.ts b/apps/desktop/src/main/services/pty/ptyService.ts
index f277724e9..9f513b12d 100644
--- a/apps/desktop/src/main/services/pty/ptyService.ts
+++ b/apps/desktop/src/main/services/pty/ptyService.ts
@@ -1121,7 +1121,10 @@ export function createPtyService({
         if (directCommand) {
           try {
             const invocation = resolveCliSpawnInvocation(directCommand, directArgs, launchEnv);
-            created = ptyLib.spawn(invocation.command, invocation.args, opts);
+            const ptyArgs = invocation.windowsVerbatimArguments
+              ? invocation.args.join(" ")
+              : invocation.args;
+            created = ptyLib.spawn(invocation.command, ptyArgs, opts);
           } catch (err) {
             lastErr = err;
           }
diff --git a/apps/desktop/src/main/services/sync/syncService.test.ts b/apps/desktop/src/main/services/sync/syncService.test.ts
index f73c6850b..084111020 100644
--- a/apps/desktop/src/main/services/sync/syncService.test.ts
+++ b/apps/desktop/src/main/services/sync/syncService.test.ts
@@ -510,6 +510,64 @@ describe.skipIf(!isCrsqliteAvailable())("syncService", () => {
     expect(service.getPin()).toBeNull();
   }, 30_000);
 
+  it("rejects PIN changes when CRDT sync is unavailable", async () => {
+    const projectRoot = makeProjectRoot("ade-sync-service-crdt-disabled-");
+    const db = await openKvDb(
+      path.join(projectRoot, ".ade", "ade.db"),
+      createLogger() as any,
+    );
+    db.sync.isAvailable = () => false;
+
+    const service = createSyncService({
+      db,
+      logger: createLogger() as any,
+      projectRoot,
+      fileService: { dispose: () => {} } as any,
+      laneService: {
+        list: async () => [],
+        create: async () => ({}),
+        archive: async () => {},
+      } as any,
+      prService: {
+        listAll: async () => [],
+        getDetail: async () => null,
+        getStatus: async () => null,
+        getChecks: async () => [],
+        getReviews: async () => [],
+        getComments: async () => [],
+        getFiles: async () => [],
+        createFromLane: async () => ({}),
+        land: async () => ({}),
+        closePr: async () => {},
+        requestReviewers: async () => {},
+      } as any,
+      sessionService: { list: () => [] } as any,
+      ptyService: {} as any,
+      computerUseArtifactBrokerService: {} as any,
+      missionService: { list: () => [] } as any,
+      agentChatService: { listSessions: async () => [] } as any,
+      processService: { listRuntime: () => [] } as any,
+    } as any);
+
+    activeDisposers.push(async () => {
+      await service.dispose();
+      db.close();
+    });
+
+    await service.initialize();
+    const status = await service.getStatus();
+
+    expect(status.bootstrapToken).toBeNull();
+    expect(status.pairingPinConfigured).toBe(false);
+    await expect(service.setPin("123456")).rejects.toThrow(
+      "Phone pairing is unavailable because the CRDT database extension is unavailable on this platform.",
+    );
+    await expect(service.clearPin()).rejects.toThrow(
+      "Phone pairing is unavailable because the CRDT database extension is unavailable on this platform.",
+    );
+    expect(service.getPin()).toBeNull();
+  }, 30_000);
+
   it("retries the sync host on bind conflicts so another project can still initialize", async () => {
     const projectRoot = makeProjectRoot("ade-sync-service-port-retry-");
     const db = await openKvDb(
diff --git a/apps/desktop/src/main/services/sync/syncService.ts b/apps/desktop/src/main/services/sync/syncService.ts
index 76d42ba94..497988b39 100644
--- a/apps/desktop/src/main/services/sync/syncService.ts
+++ b/apps/desktop/src/main/services/sync/syncService.ts
@@ -301,6 +301,18 @@ export function createSyncService(args: SyncServiceArgs) {
   const hostStartupEnabled = args.hostStartupEnabled !== false;
   let hostDiscoveryEnabled = args.hostDiscoveryEnabled !== false;
   const isCrdtSyncAvailable = (): boolean => args.db.sync.isAvailable?.() !== false;
+  const assertPhonePairingAvailable = (): void => {
+    if (!hostStartupEnabled) {
+      throw new Error(
+        "Phone pairing is unavailable because the sync host is disabled for this ADE process.",
+      );
+    }
+    if (!isCrdtSyncAvailable()) {
+      throw new Error(
+        "Phone pairing is unavailable because the CRDT database extension is unavailable on this platform.",
+      );
+    }
+  };
   let activeLocalLanePresenceIds: string[] = [];
   const localLanePresenceHeartbeatTimer = setInterval(() => {
     if (disposed || !hostService || activeLocalLanePresenceIds.length === 0) return;
@@ -791,11 +803,7 @@ export function createSyncService(args: SyncServiceArgs) {
     },
 
     async setPin(pin: string): Promise<SyncRoleSnapshot> {
-      if (!hostStartupEnabled) {
-        throw new Error(
-          "Phone pairing is unavailable because the sync host is disabled for this ADE process.",
-        );
-      }
+      assertPhonePairingAvailable();
       const current = await service.getStatus();
       if (current.role !== "brain") {
         throw new Error("Phone pairing PINs can only be managed on the host desktop.");
@@ -807,6 +815,7 @@ export function createSyncService(args: SyncServiceArgs) {
     },
 
     async clearPin(): Promise<SyncRoleSnapshot> {
+      assertPhonePairingAvailable();
       const current = await service.getStatus();
       if (current.role !== "brain") {
         throw new Error("Phone pairing PINs can only be managed on the host desktop.");
diff --git a/apps/desktop/src/shared/adeMcpIpc.test.ts b/apps/desktop/src/shared/adeMcpIpc.test.ts
index 40cdd1308..e3ad9198f 100644
--- a/apps/desktop/src/shared/adeMcpIpc.test.ts
+++ b/apps/desktop/src/shared/adeMcpIpc.test.ts
@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
+import fs from "node:fs";
 import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { isAdeMcpNamedPipePath, resolveAdeMcpIpcPath } from "./adeMcpIpc";
 
 const originalPlatform = process.platform;
@@ -13,6 +14,7 @@ function setPlatform(value: NodeJS.Platform): void {
 }
 
 afterEach(() => {
+  vi.restoreAllMocks();
   setPlatform(originalPlatform);
 });
 
@@ -42,7 +44,24 @@ describe("resolveAdeMcpIpcPath", () => {
     const a = resolveAdeMcpIpcPath("C:\\Repo");
     const b = resolveAdeMcpIpcPath("c:\\repo");
     expect(a).toBe(b);
-    const id = createHash("sha256").update(path.resolve("C:\\Repo").toLowerCase()).digest("hex").slice(0, 24);
+    const id = createHash("sha256").update(path.win32.resolve("C:\\Repo").toLowerCase()).digest("hex").slice(0, 24);
     expect(a).toBe(`\\\\.\\pipe\\ade-${id}`);
   });
+
+  it("canonicalizes Windows path separators and dot segments before hashing", () => {
+    setPlatform("win32");
+    expect(resolveAdeMcpIpcPath("C:/Repo/child/..")).toBe(resolveAdeMcpIpcPath("c:\\repo"));
+  });
+
+  it("uses native realpath on Windows when available before hashing", () => {
+    setPlatform("win32");
+    vi.spyOn(fs.realpathSync, "native").mockImplementation((value) => {
+      const raw = String(value).toLowerCase();
+      if (raw === "c:\\alias") return "C:\\Canonical";
+      if (raw === "c:\\canonical") return "C:\\Canonical";
+      throw new Error("unexpected path");
+    });
+
+    expect(resolveAdeMcpIpcPath("C:\\Alias")).toBe(resolveAdeMcpIpcPath("C:\\Canonical"));
+  });
 });
diff --git a/apps/desktop/src/shared/adeMcpIpc.ts b/apps/desktop/src/shared/adeMcpIpc.ts
index 324c9e79e..d45ed0bce 100644
--- a/apps/desktop/src/shared/adeMcpIpc.ts
+++ b/apps/desktop/src/shared/adeMcpIpc.ts
@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import fs from "node:fs";
 import path from "node:path";
 
 export function isAdeMcpNamedPipePath(socketPath: string): boolean {
@@ -9,10 +10,17 @@ export function isAdeMcpNamedPipePath(socketPath: string): boolean {
 }
 
 export function resolveAdeMcpIpcPath(projectRoot: string): string {
-  const root = path.resolve(projectRoot);
   if (process.platform === "win32") {
+    let canonicalRoot = projectRoot;
+    try {
+      canonicalRoot = fs.realpathSync.native(projectRoot);
+    } catch {
+      canonicalRoot = projectRoot;
+    }
+    const root = path.win32.resolve(canonicalRoot).replace(/\//g, "\\");
     const id = createHash("sha256").update(root.toLowerCase()).digest("hex").slice(0, 24);
     return `\\\\.\\pipe\\ade-${id}`;
   }
+  const root = path.resolve(projectRoot);
   return path.join(root, ".ade", "ade.sock");
 }
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index 888b37e97..9498d0618 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -943,7 +943,7 @@ Windows:
 - `npm run dist:win` — x64 installer via `electron-builder --win --x64`, wrapped with `validate:win:artifacts` (preflight) and `validate:win:release` (post-build) checks in `apps/desktop/scripts/validate-win-artifacts.mjs`.
 - Windows-only wrappers for the bundled `ade` CLI ship in `apps/desktop/scripts/`: `ade-cli-windows-wrapper.cmd` (launcher) and `ade-cli-install-path.cmd` (idempotent PATH install helper). The platform-agnostic `.sh` wrapper covers macOS/Linux.
 - The Windows installer bundles the prebuilt `cr-sqlite` native binary from `apps/desktop/vendor/crsqlite/win32-x64/` plus a Windows node-pty ConPTY worker.
-- GitHub Actions `release-core.yml` drives signed/notarized Windows artifacts.
+- GitHub Actions `release-core.yml` builds and validates Windows artifacts; they are not currently code-signed or notarized.
 
 Post-packaging hardening (`apps/desktop/scripts/`):
 

From ddecf19c5f616606ae44f4c616e0962d9aacfd45 Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Thu, 23 Apr 2026 17:04:47 -0400
Subject: [PATCH 09/11] ship: iteration 6 rebase and raise lane cap

---
 .claude/commands/shipLane.md |  4 +++-
 .claude/scheduled_tasks.lock |  2 +-
 docs/playbooks/ship-lane.md  | 17 +++++++++++------
 3 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/.claude/commands/shipLane.md b/.claude/commands/shipLane.md
index 46a660d84..3b63cf380 100644
--- a/.claude/commands/shipLane.md
+++ b/.claude/commands/shipLane.md
@@ -1,6 +1,6 @@
 ---
 name: shipLane
-description: 'Autonomously drive a lane through CI + review until merged (automate → finalize → poll/fix loop, self-paced wake-ups, max 5 iterations)'
+description: 'Autonomously drive a lane through CI + review until merged (automate → finalize → poll/fix loop, self-paced wake-ups, max 10 iterations)'
 ---
 
 # Ship Lane Command
@@ -89,6 +89,8 @@ ScheduleWakeup({
 
 Pass `$ARGUMENTS` through so a PR-number argument is preserved across wake-ups.
 
+Waiting must be token-idle. After scheduling a wake-up, stop the active agent turn completely and let the scheduler re-invoke this command later. Do not keep agents alive in polling loops, do not run `--watch` commands, and do not ask sub-agents to sleep while holding context. Poll only once per scheduled invocation, then either fix, exit, or schedule the next wake.
+
 Do NOT schedule a wake if `status` is `done-clean`, `done-max`, or `blocked` — print the summary and stop.
 
 ---
diff --git a/.claude/scheduled_tasks.lock b/.claude/scheduled_tasks.lock
index bc1d26542..309d60a9e 100644
--- a/.claude/scheduled_tasks.lock
+++ b/.claude/scheduled_tasks.lock
@@ -1 +1 @@
-{"sessionId":"bab81aa2-1bdb-495e-9bf6-3d87ede93f1f","pid":85962,"procStart":"Thu Apr 23 05:29:47 2026","acquiredAt":1776922287064}
\ No newline at end of file
+{"sessionId":"5364eda2-5696-4227-b94c-5f2678de1f2e","pid":64448,"procStart":"Thu Apr 23 18:51:52 2026","acquiredAt":1776973376438}
\ No newline at end of file
diff --git a/docs/playbooks/ship-lane.md b/docs/playbooks/ship-lane.md
index d422fc5c8..884ae8bca 100644
--- a/docs/playbooks/ship-lane.md
+++ b/docs/playbooks/ship-lane.md
@@ -15,8 +15,9 @@ Run this playbook once per lane, when the code on the branch is done (or nearly
 ## Execution contract
 
 - **Autonomous.** Do not pause for user confirmation mid-loop.
-- **Bounded.** Hard cap: 5 iterations. Exit earlier if clean or blocked.
+- **Bounded.** Hard cap: 10 iterations. Exit earlier if clean or blocked.
 - **Scoped checks.** Never run the full test suite between iterations — only failing test files and touched shards.
+- **Token-idle waits.** Waiting is done by scheduler/resume, not by live polling loops. Between wake-ups, agents should be asleep, not consuming model context or tokens.
 - **Idempotent resume.** All state lives in `.ade/shipLane/<branch>.json`. A re-invocation reads that file and picks up where it left off.
 
 ## Concurrency model
@@ -29,6 +30,8 @@ Pick the richest available and **use it fully**:
 
 **Rule:** the lead reads poll-agent summaries, not raw API output. Fix agents receive minimum scope (failing test paths + error snippets, or comment bodies + file anchors) and return patches or direct edits. The lead commits and pushes; fix agents do not.
 
+**Waiting rule:** agents never stay alive just to wait. A poll-agent performs one bounded poll and exits. Fix agents perform one bounded fix task and exit. The lead schedules a wake-up or records a blocked/done state, then exits the active turn.
+
 ## State file
 
 Path: `.ade/shipLane/<sanitized-branch>.json` (sanitize by replacing `/` with `__`).
@@ -142,11 +145,13 @@ Then schedule the first wake-up (see Phase 5).
 
 Runs on every wake-up. Delegate to a **poll-agent** so the lead's context stays clean. The poll-agent runs these calls and returns a single structured summary.
 
+This is a one-shot poll. Do not use `gh pr checks --watch`, shell `while` loops, repeated sleeps, or minute-by-minute status checks. If CI/review is still pending, return `ciRunning: true` or no actionable comments, then let Phase 5 schedule the next wake.
+
 ### 1.1 PR and CI state
 
 ```bash
 gh pr view "$PR_NUMBER" --json state,mergeable,mergeStateStatus,headRefOid,baseRefOid,isDraft
-gh pr checks "$PR_NUMBER" --json name,state,conclusion,link
+gh pr checks "$PR_NUMBER" --watch=false --json name,state,conclusion,link
 ```
 
 If any check's `state` is `IN_PROGRESS` or `QUEUED`, note CI as still running.
@@ -321,7 +326,7 @@ git commit -m "ship: iteration $N — fix $CI_JOBS, address #$COMMENT_IDS"
 git push
 ```
 
-Post bot pings (Phase 4), update state (Phase 5), restart Phase 1 immediately.
+Post bot pings (Phase 4), update state (Phase 5), and schedule the next wake. Do not restart Phase 1 immediately after a push; give CI and review bots time to run while the agent is asleep.
 
 ---
 
@@ -363,7 +368,7 @@ These are separate comments (not a single body) so each bot handler parses its o
 
 ### 5.2 Decide exit vs next wake
 
-- `iteration >= 5` → set `status: done-max`, `exitReason: "iteration-cap-reached"`, post a PR comment listing remaining unaddressed items, exit.
+- `iteration >= 10` → set `status: done-max`, `exitReason: "iteration-cap-reached"`, post a PR comment listing remaining unaddressed items, exit.
 - `merged == true` (observed during this iteration) → set `status: done-clean`, exit.
 - Otherwise → schedule next wake.
 
@@ -376,7 +381,7 @@ Agent-CLI-agnostic guidance (Claude Code maps this to `ScheduleWakeup`; other CL
 - CI done, waiting on human review → **1800 seconds** (30 min; cost-efficient)
 - Unknown → **720 seconds** default
 
-The cadence is a hint, not a contract. If the agent knows CI finishes faster, wake sooner; if reviewers are slow, wake later.
+The cadence is a hint, not a live polling budget. Prefer longer sleeps over frequent checks. If the environment has a real scheduler/resume primitive, use it and end the active turn. If no scheduler exists, write the updated state file and stop with a summary that names the next intended wake time; an external runner or human can re-invoke the playbook later. Do not emulate scheduling with an active model loop.
 
 ---
 
@@ -385,7 +390,7 @@ The cadence is a hint, not a contract. If the agent knows CI finishes faster, wa
 | status | meaning | next action |
 | --- | --- | --- |
 | `done-clean` | PR merged OR green + no unaddressed comments | clear state file; print summary |
-| `done-max` | 5 iterations exhausted | leave state file; post PR comment to human |
+| `done-max` | 10 iterations exhausted | leave state file; post PR comment to human |
 | `blocked` | Unrecoverable conflict, gate failure, or API error | leave state file; post PR comment with reason |
 
 ## Summary output (always print on exit)

From 5f2318fcb50f32c47885008a334da9aa39e79d94 Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Thu, 23 Apr 2026 17:23:14 -0400
Subject: [PATCH 10/11] ship: address final CI and review feedback

---
 .claude/commands/shipLane.md                  |  2 +-
 apps/ade-cli/src/adeRpcServer.ts              | 35 ++++++++++--
 apps/ade-cli/src/bootstrap.ts                 | 22 ++++++++
 apps/desktop/scripts/ade-cli-install-path.cmd |  2 +-
 .../main/services/ai/providerTaskRunner.ts    |  8 ++-
 .../services/ai/tools/universalTools.test.ts  | 11 ++++
 .../main/services/ai/tools/universalTools.ts  |  7 +++
 .../opencode/openCodeServerManager.ts         |  2 +-
 .../aiOrchestratorService.test.ts             |  8 +++
 .../providerOrchestratorAdapter.ts            | 26 ++++++++-
 .../services/shared/processExecution.test.ts  |  1 +
 .../main/services/shared/processExecution.ts  |  2 +-
 .../src/main/services/sync/syncService.ts     |  9 ++++
 .../services/usage/usageTrackingService.ts    |  8 +++
 .../chat/AgentChatMessageList.test.tsx        | 41 ++++++++++++++
 .../components/chat/AgentChatMessageList.tsx  | 21 ++++++--
 docs/playbooks/ship-lane.md                   | 54 ++++++++++++++-----
 17 files changed, 234 insertions(+), 25 deletions(-)

diff --git a/.claude/commands/shipLane.md b/.claude/commands/shipLane.md
index 3b63cf380..01b55a3b9 100644
--- a/.claude/commands/shipLane.md
+++ b/.claude/commands/shipLane.md
@@ -1,6 +1,6 @@
 ---
 name: shipLane
-description: 'Autonomously drive a lane through CI + review until merged (automate → finalize → poll/fix loop, self-paced wake-ups, max 10 iterations)'
+description: 'Autonomously drive a lane through CI + review until ready or capped (automate → finalize → poll/fix loop, self-paced wake-ups, max 5 iterations)'
 ---
 
 # Ship Lane Command
diff --git a/apps/ade-cli/src/adeRpcServer.ts b/apps/ade-cli/src/adeRpcServer.ts
index e1079e875..31450bfa0 100644
--- a/apps/ade-cli/src/adeRpcServer.ts
+++ b/apps/ade-cli/src/adeRpcServer.ts
@@ -2627,6 +2627,35 @@ function shellEscapeArg(value: string): string {
   return `'${sanitized.replace(/'/g, `'"'"'`)}'`;
 }
 
+function windowsShellEscapeArg(value: string): string {
+  const sanitized = stripInjectionChars(value);
+  if (!sanitized.length) return "\"\"";
+  if (/^[a-zA-Z0-9_.:/\\-]+$/.test(sanitized)) return sanitized;
+  let quoted = "\"";
+  let backslashes = 0;
+  for (const char of sanitized.replace(/%/g, "%%")) {
+    if (char === "\\") {
+      backslashes += 1;
+      continue;
+    }
+    if (char === "\"") {
+      quoted += "\\".repeat(backslashes * 2);
+      quoted += "\"\"";
+    } else {
+      quoted += "\\".repeat(backslashes);
+      quoted += char;
+    }
+    backslashes = 0;
+  }
+  quoted += "\\".repeat(backslashes * 2);
+  quoted += "\"";
+  return quoted;
+}
+
+function previewShellEscapeArg(value: string): string {
+  return process.platform === "win32" ? windowsShellEscapeArg(value) : shellEscapeArg(value);
+}
+
 function clipText(value: string, maxChars: number): string {
   if (value.length <= maxChars) return value;
   return `${value.slice(0, Math.max(0, maxChars - 18))}\n...<truncated>`;
@@ -5910,7 +5939,7 @@ async function runTool(args: {
     const commandPreviewParts: string[] = [provider];
     if (model) {
       commandArgs.push("--model", model);
-      commandPreviewParts.push("--model", shellEscapeArg(model));
+      commandPreviewParts.push("--model", previewShellEscapeArg(model));
     }
     if (provider === "codex") {
       if (permissionMode === "full-auto") {
@@ -5932,14 +5961,14 @@ async function runTool(args: {
       const claudePermission =
         permissionMode === "plan" ? "plan" : permissionMode === "full-auto" ? "bypassPermissions" : permissionMode === "edit" ? "acceptEdits" : "default";
       commandArgs.push("--permission-mode", claudePermission);
-      commandPreviewParts.push("--permission-mode", shellEscapeArg(claudePermission));
+      commandPreviewParts.push("--permission-mode", previewShellEscapeArg(claudePermission));
 
       // ADE-owned actions are exposed through the `ade` CLI. Child agent
       // sessions receive identity env vars below instead of an attached server.
     }
     if (finalPrompt) {
       commandArgs.push(finalPrompt);
-      commandPreviewParts.push(shellEscapeArg(finalPrompt));
+      commandPreviewParts.push(previewShellEscapeArg(finalPrompt));
     }
 
     // Attach worker identity through the process environment. The startup
diff --git a/apps/ade-cli/src/bootstrap.ts b/apps/ade-cli/src/bootstrap.ts
index e983d3292..44453020b 100644
--- a/apps/ade-cli/src/bootstrap.ts
+++ b/apps/ade-cli/src/bootstrap.ts
@@ -250,6 +250,27 @@ export async function createAdeRuntime(args: { projectRoot: string; workspaceRoo
     eventBuffer.push({ timestamp: new Date().toISOString(), category, payload });
   }
 
+  const getHeadlessLaneRuntimeEnv = async (laneId: string): Promise<Record<string, string>> => {
+    const lanes = await laneService.list({ includeArchived: false, includeStatus: false });
+    const lane = lanes.find((entry) => entry.id === laneId);
+    const laneIndex = Math.max(0, lanes.findIndex((entry) => entry.id === laneId));
+    const portStart = 3000 + laneIndex * 100;
+    const portEnd = portStart + 99;
+    const slug = (lane?.name ?? lane?.branchRef ?? laneId)
+      .trim()
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "") || "lane";
+    const hostname = `${slug}.localhost`;
+    return {
+      PORT: String(portStart),
+      PORT_RANGE_START: String(portStart),
+      PORT_RANGE_END: String(portEnd),
+      HOSTNAME: hostname,
+      PROXY_HOSTNAME: hostname,
+    };
+  };
+
   const processService = createProcessService({
     db,
     projectId,
@@ -258,6 +279,7 @@ export async function createAdeRuntime(args: { projectRoot: string; workspaceRoo
     projectConfigService,
     sessionService,
     ptyService,
+    getLaneRuntimeEnv: getHeadlessLaneRuntimeEnv,
     broadcastEvent: (event) => pushEvent("runtime", event as unknown as Record<string, unknown>),
   });
 
diff --git a/apps/desktop/scripts/ade-cli-install-path.cmd b/apps/desktop/scripts/ade-cli-install-path.cmd
index 351cf879b..7b6503ecd 100644
--- a/apps/desktop/scripts/ade-cli-install-path.cmd
+++ b/apps/desktop/scripts/ade-cli-install-path.cmd
@@ -10,7 +10,7 @@ if "%TARGET_PATH%"=="" (
   if defined LOCALAPPDATA (
     set "TARGET_PATH=%LOCALAPPDATA%\ADE\bin\ade.cmd"
   ) else (
-    set "TARGET_PATH=%USERPROFILE%\.ade\bin\ade.cmd"
+    set "TARGET_PATH=%USERPROFILE%\AppData\Local\ADE\bin\ade.cmd"
   )
 )
 
diff --git a/apps/desktop/src/main/services/ai/providerTaskRunner.ts b/apps/desktop/src/main/services/ai/providerTaskRunner.ts
index 9fde1ef7f..5a85cc866 100644
--- a/apps/desktop/src/main/services/ai/providerTaskRunner.ts
+++ b/apps/desktop/src/main/services/ai/providerTaskRunner.ts
@@ -43,6 +43,12 @@ type SpawnResult = {
   exitCode: number | null;
 };
 
+function isBenignStdinCloseError(error: unknown): boolean {
+  if (!error || typeof error !== "object") return false;
+  const code = (error as { code?: unknown }).code;
+  return code === "EPIPE" || code === "ERR_STREAM_DESTROYED";
+}
+
 function appendStructuredOutputInstruction(prompt: string, jsonSchema?: unknown): string {
   if (!jsonSchema) return prompt;
   return `${prompt}
@@ -107,7 +113,7 @@ async function runCommand(args: {
       stderr += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
     });
     child.stdin?.on("error", (error) => {
-      if (settled) return;
+      if (settled || isBenignStdinCloseError(error)) return;
       settled = true;
       clearTimeout(timeoutHandle);
       reject(error);
diff --git a/apps/desktop/src/main/services/ai/tools/universalTools.test.ts b/apps/desktop/src/main/services/ai/tools/universalTools.test.ts
index 6517d0647..d7cd61e0b 100644
--- a/apps/desktop/src/main/services/ai/tools/universalTools.test.ts
+++ b/apps/desktop/src/main/services/ai/tools/universalTools.test.ts
@@ -281,6 +281,17 @@ describe("checkWorkerSandbox", () => {
     expect(result.reason).toContain("Path outside sandbox");
   });
 
+  it("fails closed for generic mutating cmd.exe /c payloads", () => {
+    const result = checkWorkerSandbox(
+      'cmd.exe /c "copy foo ..\\outside.txt"',
+      sandboxWith({ allowedPaths: ["./"] }),
+      "C:\\projects\\repo",
+    );
+
+    expect(result.allowed).toBe(false);
+    expect(result.reason).toContain("cmd.exe /c mutating payload");
+  });
+
   it("blocks PowerShell mutation paths hidden behind parenthesized expressions", () => {
     const result = checkWorkerSandbox(
       'powershell.exe -Command "Set-Content -Path (Join-Path .. outside.txt) -Value hi"',
diff --git a/apps/desktop/src/main/services/ai/tools/universalTools.ts b/apps/desktop/src/main/services/ai/tools/universalTools.ts
index 692c939c6..cd8bab9bb 100644
--- a/apps/desktop/src/main/services/ai/tools/universalTools.ts
+++ b/apps/desktop/src/main/services/ai/tools/universalTools.ts
@@ -744,6 +744,13 @@ function inspectPowerShellInvocations(
         const nestedInspection = inspectPowerShellInvocations(nestedCommand, cwd, pathApi, depth + 1);
         mergeInspection(nestedInspection);
         if (nestedInspection.blockedReason) return { ...nestedInspection, pathRefs: [...refs.values()] };
+        if (MUTATING_CMD_RE.test(nestedCommand)) {
+          return {
+            mutates: true,
+            pathRefs: [...refs.values()],
+            blockedReason: "cmd.exe /c mutating payload is not inspectable by the worker sandbox",
+          };
+        }
         mutates = mutates || nestedInspection.mutates;
       }
       continue;
diff --git a/apps/desktop/src/main/services/opencode/openCodeServerManager.ts b/apps/desktop/src/main/services/opencode/openCodeServerManager.ts
index b08df75cf..c553e1d5f 100644
--- a/apps/desktop/src/main/services/opencode/openCodeServerManager.ts
+++ b/apps/desktop/src/main/services/opencode/openCodeServerManager.ts
@@ -254,7 +254,7 @@ function listWindowsProcessesFromPowerShell(): OpenCodeProcessSnapshot[] {
 
 function listWindowsProcesses(): OpenCodeProcessSnapshot[] {
   const fromWmic = listWindowsProcessesFromWmic();
-  if (fromWmic.length > 0) {
+  if (fromWmic.length > 0 && fromWmic.every((process) => process.command.trim().length > 0)) {
     return fromWmic;
   }
   return listWindowsProcessesFromPowerShell();
diff --git a/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.test.ts b/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.test.ts
index 09039c6c9..27c3e6f0a 100644
--- a/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.test.ts
+++ b/apps/desktop/src/main/services/orchestrator/aiOrchestratorService.test.ts
@@ -3171,6 +3171,14 @@ describe("aiOrchestratorService", () => {
         `,
         ["2000-01-01T00:00:00.000Z", "2000-01-01T00:00:00.000Z", attempt.id]
       );
+      fixture.db.run(
+        `
+          update orchestrator_claims
+          set heartbeat_at = '2000-01-01T00:00:00.000Z'
+          where attempt_id = ?
+        `,
+        [attempt.id]
+      );
 
       // A startup/interval sweep can be in flight on slower CI runners. Retry the
       // explicit sweep until this attempt is reconciled instead of racing it.
diff --git a/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts b/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts
index c4b2d637e..2e92f65dd 100644
--- a/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts
+++ b/apps/desktop/src/main/services/orchestrator/providerOrchestratorAdapter.ts
@@ -100,18 +100,40 @@ function workerLaunchFilePath(projectRoot: string, attemptId: string): string {
 
 const WORKER_CLI_LAUNCHER_SCRIPT = `
 const fs = require("fs");
-const { spawn } = require("child_process");
+const { spawn, spawnSync } = require("child_process");
 const specPath = process.argv[1];
 let done = false;
+let child = null;
+function terminateChild() {
+  if (!child || !child.pid) return;
+  try {
+    if (process.platform === "win32") {
+      spawnSync("taskkill.exe", ["/pid", String(child.pid), "/t", "/f"], { stdio: "ignore", windowsHide: true });
+    } else {
+      child.kill("SIGTERM");
+    }
+  } catch {}
+}
 function finish(code) {
   if (done) return;
   done = true;
   process.exit(typeof code === "number" ? code : 1);
 }
+process.on("SIGTERM", () => {
+  terminateChild();
+  finish(143);
+});
+process.on("SIGINT", () => {
+  terminateChild();
+  finish(130);
+});
+process.on("exit", () => {
+  terminateChild();
+});
 const spec = JSON.parse(fs.readFileSync(specPath, "utf8"));
 const childEnv = { ...process.env, ...(spec.env || {}) };
 delete childEnv.ELECTRON_RUN_AS_NODE;
-const child = spawn(spec.command, Array.isArray(spec.args) ? spec.args : [], {
+child = spawn(spec.command, Array.isArray(spec.args) ? spec.args : [], {
   cwd: spec.cwd || process.cwd(),
   env: childEnv,
   shell: false,
diff --git a/apps/desktop/src/main/services/shared/processExecution.test.ts b/apps/desktop/src/main/services/shared/processExecution.test.ts
index c589af73f..8a3056d30 100644
--- a/apps/desktop/src/main/services/shared/processExecution.test.ts
+++ b/apps/desktop/src/main/services/shared/processExecution.test.ts
@@ -35,6 +35,7 @@ describe("processExecution", () => {
     expect(quoteWindowsCmdArg("100% done")).toBe('"100%% done"');
     expect(quoteWindowsCmdArg('say "hi"')).toBe('"say ""hi"""');
     expect(quoteWindowsCmdArg('C:\\path\\"quoted"')).toBe('"C:\\path\\\\\"\"quoted\"\"\"');
+    expect(quoteWindowsCmdArg("line one\r\nline two")).toBe('"line one  line two"');
   });
 
   it("wraps Windows shim invocations with ComSpec", () => {
diff --git a/apps/desktop/src/main/services/shared/processExecution.ts b/apps/desktop/src/main/services/shared/processExecution.ts
index 3d7badd2b..3ca0a2618 100644
--- a/apps/desktop/src/main/services/shared/processExecution.ts
+++ b/apps/desktop/src/main/services/shared/processExecution.ts
@@ -22,7 +22,7 @@ export function processOutputToString(value: Buffer | string | null | undefined)
 export function quoteWindowsCmdArg(value: string): string {
   let quoted = "\"";
   let backslashes = 0;
-  for (const char of value.replace(/%/g, "%%")) {
+  for (const char of value.replace(/%/g, "%%").replace(/[\r\n]/g, " ")) {
     if (char === "\\") {
       backslashes += 1;
       continue;
diff --git a/apps/desktop/src/main/services/sync/syncService.ts b/apps/desktop/src/main/services/sync/syncService.ts
index 497988b39..7a4a7148a 100644
--- a/apps/desktop/src/main/services/sync/syncService.ts
+++ b/apps/desktop/src/main/services/sync/syncService.ts
@@ -554,6 +554,12 @@ export function createSyncService(args: SyncServiceArgs) {
           await startHostIfNeeded();
         } else {
           await stopHostIfRunning();
+          if (!isCrdtSyncAvailable()) {
+            if (syncPeerService.isConnected()) {
+              syncPeerService.disconnect({ preserveDraft: true });
+            }
+            continue;
+          }
           const draft = savedDraft ?? resolveViewerDraftFromRegistry();
           if (draft && !syncPeerService.isConnected()) {
             syncPeerService.setSavedDraft(draft);
@@ -771,6 +777,9 @@ export function createSyncService(args: SyncServiceArgs) {
     async connectToBrain(
       draft: SyncDesktopConnectionDraft,
     ): Promise<SyncRoleSnapshot> {
+      if (!isCrdtSyncAvailable()) {
+        throw new Error("Desktop sync is unavailable because the CRDT database extension is not loaded.");
+      }
       await stopHostIfRunning();
       deviceRegistryService.clearClusterRegistryForViewerJoin();
       writeSavedDraft(draft);
diff --git a/apps/desktop/src/main/services/usage/usageTrackingService.ts b/apps/desktop/src/main/services/usage/usageTrackingService.ts
index ca00eac69..4c365155a 100644
--- a/apps/desktop/src/main/services/usage/usageTrackingService.ts
+++ b/apps/desktop/src/main/services/usage/usageTrackingService.ts
@@ -41,6 +41,12 @@ const COST_CACHE_TTL_MS = 60_000;             // 60s
 const CODEX_TOKEN_REFRESH_DAYS = 8;
 const CODEX_CLI_RPC_TIMEOUT_MS = 10_000;
 
+function isBenignStdinCloseError(error: unknown): boolean {
+  if (!error || typeof error !== "object") return false;
+  const code = (error as { code?: unknown }).code;
+  return code === "EPIPE" || code === "ERR_STREAM_DESTROYED";
+}
+
 const CLAUDE_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
 const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 
@@ -445,6 +451,7 @@ async function pollCodexViaCliRpc(logger: Logger): Promise<{ windows: UsageWindo
           finish(() => resolve({ stdout, stderr, exitCode: code }));
         });
         child.stdin?.on("error", (error) => {
+          if (isBenignStdinCloseError(error)) return;
           logger.warn("usage.poll.codex_cli_rpc_stdin_failed", {
             error: getErrorMessage(error),
           });
@@ -455,6 +462,7 @@ async function pollCodexViaCliRpc(logger: Logger): Promise<{ windows: UsageWindo
           child.stdin?.write(combined);
           child.stdin?.end();
         } catch (err) {
+          if (isBenignStdinCloseError(err)) return;
           logger.warn("usage.poll.codex_cli_rpc_stdin_failed", {
             error: getErrorMessage(err),
           });
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
index bbfaf8a4f..fbed02140 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
@@ -610,6 +610,47 @@ describe("AgentChatMessageList transcript rendering", () => {
     );
   });
 
+  it("preserves UNC authorities in file URI references", async () => {
+    vi.mocked(globalThis.window.ade.files.listWorkspaces).mockResolvedValueOnce([
+      {
+        id: "workspace-unc",
+        kind: "worktree",
+        laneId: "lane-unc",
+        name: "UNC lane",
+        rootPath: "//server/share/repo",
+        isReadOnlyByDefault: false,
+      },
+    ]);
+
+    renderMessageList(
+      [
+        {
+          sessionId: "session-1",
+          timestamp: "2026-03-17T10:00:00.000Z",
+          event: {
+            type: "text",
+            text: "Inspect `file://server/share/repo/src/main.ts#line=12`.",
+            itemId: "text-unc-file-uri",
+            turnId: "turn-1",
+          },
+        },
+      ],
+      {
+        initialState: { laneId: "lane-unc" },
+      },
+    );
+
+    await waitFor(() => {
+      expect(globalThis.window.ade.files.listWorkspaces).toHaveBeenCalledTimes(1);
+    });
+
+    fireEvent.click(screen.getByRole("button", { name: "file://server/share/repo/src/main.ts#line=12" }));
+
+    expect(screen.getByTestId("location").textContent).toBe(
+      "/files::{\"openFilePath\":\"src/main.ts\",\"laneId\":\"lane-unc\",\"startLine\":12}",
+    );
+  });
+
   it("does not coalesce text fragments across command boundaries", () => {
     const view = renderMessageList([
       {
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
index ea4647651..0a78d7163 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
@@ -456,9 +456,24 @@ function parseWorkspacePathLocation(value: string): WorkspacePathLocation | null
   if (/^(?:https?|mailto|tel):/i.test(trimmed)) return null;
   if (/^#/.test(trimmed)) return null;
 
-  const withoutScheme = trimmed.replace(/^file:\/\//i, "");
-  const [withoutFragment, rawFragment = ""] = withoutScheme.split("#", 2);
-  const rawPath = withoutFragment.split("?", 1)[0]?.trim() ?? "";
+  let rawPath: string;
+  let rawFragment = "";
+  if (/^file:/i.test(trimmed)) {
+    try {
+      const url = new URL(trimmed);
+      rawPath = `${url.host ? `//${url.host}` : ""}${url.pathname}`.trim();
+      rawFragment = url.hash.startsWith("#") ? url.hash.slice(1) : "";
+    } catch {
+      const withoutScheme = trimmed.replace(/^file:\/\//i, "");
+      const [withoutFragment, fallbackFragment = ""] = withoutScheme.split("#", 2);
+      rawPath = withoutFragment.split("?", 1)[0]?.trim() ?? "";
+      rawFragment = fallbackFragment;
+    }
+  } else {
+    const [withoutFragment, fallbackFragment = ""] = trimmed.split("#", 2);
+    rawPath = withoutFragment.split("?", 1)[0]?.trim() ?? "";
+    rawFragment = fallbackFragment;
+  }
   let decodedPath = rawPath;
   try {
     decodedPath = decodeURIComponent(rawPath);
diff --git a/docs/playbooks/ship-lane.md b/docs/playbooks/ship-lane.md
index 884ae8bca..64c18f516 100644
--- a/docs/playbooks/ship-lane.md
+++ b/docs/playbooks/ship-lane.md
@@ -10,13 +10,14 @@ Run this playbook once per lane, when the code on the branch is done (or nearly
 - Polling CI and review comments
 - Fixing valid review comments and CI failures
 - Rebasing when teammates merge into `main` ahead of you
-- Repeating until the PR is merged, clean, or a human is required
+- Repeating until the PR is clean, capped, or a human is required
 
 ## Execution contract
 
 - **Autonomous.** Do not pause for user confirmation mid-loop.
-- **Bounded.** Hard cap: 10 iterations. Exit earlier if clean or blocked.
-- **Scoped checks.** Never run the full test suite between iterations — only failing test files and touched shards.
+- **Bounded.** Hard cap: 5 iterations. Exit earlier if clean or blocked. At the cap, do not auto-merge; leave a handoff comment that explains why the loop stopped and what remains, if anything.
+- **Rebase budget rebate.** A rebase, merge-from-main, or conflict-resolution pass moves the current iteration count down by 2 before the next cap check, with a floor of 0. Example: if the lane is on iteration 4 and must rebase because `main` moved, record the rebase and continue as iteration 2.
+- **Scoped checks.** Never run the full test suite between iterations. For CI, fix and rerun only the failing test file(s) or failing check target. For review-only changes, rerun only directly affected existing tests, plus the narrow package typecheck/lint when the touched surface needs it.
 - **Token-idle waits.** Waiting is done by scheduler/resume, not by live polling loops. Between wake-ups, agents should be asleep, not consuming model context or tokens.
 - **Idempotent resume.** All state lives in `.ade/shipLane/<branch>.json`. A re-invocation reads that file and picks up where it left off.
 
@@ -52,6 +53,8 @@ Path: `.ade/shipLane/<sanitized-branch>.json` (sanitize by replacing `/` with `_
 
 `status` values: `running`, `done-clean`, `done-max`, `blocked`.
 
+The `iteration` value is the active turn budget counter, not a raw count of pushes. Normal fix iterations increment it by 1. Rebase/merge/conflict recovery decrements it by 2 first, then the current pass records its result. Never let it go below 0.
+
 ---
 
 ## Phase 0 — Setup (first invocation only)
@@ -211,7 +214,7 @@ Pure logic on the poll summary:
 | Condition | Action |
 | --- | --- |
 | `merged == true` | Exit `done-clean`; clear state file. |
-| `behindMain == true` | Go to Phase 3a (rebase), then restart Phase 1. |
+| `behindMain == true` | Go to Phase 3a (rebase), apply the rebase budget rebate, then schedule/poll according to Phase 5. |
 | `ciFailed` empty, `newComments` empty, `ciRunning == true` | No fix work. Go to Phase 5 (schedule next wake). |
 | `ciFailed` empty, `newComments` empty, `ciRunning == false` | Exit `done-clean`. |
 | Otherwise | Go to Phase 3b (fix). |
@@ -266,7 +269,15 @@ Then:
 git push --force-with-lease
 ```
 
-Post bot pings (Phase 4), update state (Phase 5), restart Phase 1 immediately — do not schedule a wake, because we just pushed and want a fresh poll soon.
+Before bookkeeping, apply the **rebase budget rebate**:
+
+```json
+{
+  "iteration": "max(0, previous iteration - 2)"
+}
+```
+
+Post bot pings (Phase 4), update state (Phase 5), and schedule the next wake. Do not immediately repoll after a rebase push; let CI and review bots run while the agent is asleep.
 
 ---
 
@@ -287,7 +298,20 @@ Extract:
 - Exact error snippets (stack trace + surrounding lines)
 - Which shard (e.g., `test-desktop (3)` → failing files only ran on shard 3)
 
-### 3b.2 Dispatch fix sub-agents in parallel
+Only investigate and rerun the failing target. If a shard fails because of one file, rerun that file, not the whole shard. If a typecheck/lint/build job fails, rerun that exact package-level command only after fixing the reported files.
+
+### 3b.2 Review-comment hygiene
+
+Before dispatching review fixes:
+
+- Group comments by normalized finding: same file, nearby line, same author, and materially same body. Treat repeats as one issue.
+- Drop stale comments whose line no longer exists or whose requested change is already present in the current diff.
+- If a review thread can be resolved with the available GitHub/ADE tooling, resolve it as soon as the fix is present or the comment is stale/duplicate.
+- Add every handled, stale, or duplicate comment id to `addressedCommentIds` so future iterations do not keep revisiting it.
+
+Do not linger on repeated bot feedback. Fix the underlying issue once, mark old copies handled/resolved when possible, and move on.
+
+### 3b.3 Dispatch fix sub-agents in parallel
 
 If both CI fixes and review-comment fixes are needed, spawn them **in parallel** (each scoped to its own minimum input):
 
@@ -296,6 +320,7 @@ If both CI fixes and review-comment fixes are needed, spawn them **in parallel**
 - Error snippets (not full logs)
 - Allowed to read any source file, but MUST NOT rewrite tests unless the test is genuinely wrong
 - Must verify each fix with `cd <app> && npx vitest run <specific file>` before reporting done
+- Must not run the full suite or an entire CI shard when the failing file is known
 
 **review-fix-agent** input:
 - List of new comments: `{id, author, body, path, line}`
@@ -304,11 +329,12 @@ If both CI fixes and review-comment fixes are needed, spawn them **in parallel**
   - Praise
   - Comments whose referenced line no longer exists in the current diff
   - IDs already in `addressedCommentIds`
-- Record every comment id it addressed (for the lead to merge into state)
+- Repeated comments for the same already-fixed issue
+- Record every comment id it addressed, resolved, or dismissed as stale/duplicate (for the lead to merge into state)
 
 Both agents edit files directly. They do not commit; only the lead commits.
 
-### 3b.3 Lead verification + commit
+### 3b.4 Lead verification + commit
 
 ```bash
 git status
@@ -317,7 +343,11 @@ git diff --stat
 
 The lead reviews the combined diff. If anything is surprising (unrelated files touched, enormous diffs), the lead can revert specific hunks with `git checkout -- <file>` before committing.
 
-Re-run scoped checks on touched files (same commands as Phase 3a validation).
+Re-run only the narrow checks that matter:
+
+- For CI fixes, rerun the failing test file(s) or exact failing check target.
+- For review-only fixes, rerun colocated/directly affected tests when they exist; otherwise run the smallest package typecheck/lint that covers the touched surface.
+- Do not run the full desktop or CLI suite inside the loop.
 
 Commit with a message that lists what was addressed:
 
@@ -358,7 +388,7 @@ These are separate comments (not a single body) so each bot handler parses its o
 
 ```json
 {
-  "iteration": <prev + 1>,
+  "iteration": <prev + 1, after any rebase/conflict rebate>,
   "lastPushSha": "<new HEAD sha>",
   "addressedCommentIds": [<prev list>, <new ids handled this iteration>],
   "lastPolledAt": "<ISO 8601 now>",
@@ -368,7 +398,7 @@ These are separate comments (not a single body) so each bot handler parses its o
 
 ### 5.2 Decide exit vs next wake
 
-- `iteration >= 10` → set `status: done-max`, `exitReason: "iteration-cap-reached"`, post a PR comment listing remaining unaddressed items, exit.
+- `iteration >= 5` → set `status: done-max`, `exitReason: "iteration-cap-reached"`, post a PR handoff comment explaining why the loop stopped and listing remaining unaddressed CI/review items, if any. Do not auto-merge at the cap; leave the PR open for a human to merge or rerun the lane.
 - `merged == true` (observed during this iteration) → set `status: done-clean`, exit.
 - Otherwise → schedule next wake.
 
@@ -390,7 +420,7 @@ The cadence is a hint, not a live polling budget. Prefer longer sleeps over freq
 | status | meaning | next action |
 | --- | --- | --- |
 | `done-clean` | PR merged OR green + no unaddressed comments | clear state file; print summary |
-| `done-max` | 10 iterations exhausted | leave state file; post PR comment to human |
+| `done-max` | 5 iterations exhausted | leave state file; post PR handoff comment to human; do not auto-merge |
 | `blocked` | Unrecoverable conflict, gate failure, or API error | leave state file; post PR comment with reason |
 
 ## Summary output (always print on exit)

From 1d7543280367c76aff6a59c393d135f6606b5e35 Mon Sep 17 00:00:00 2001
From: Arul Sharma <31745423+arul28@users.noreply.github.com>
Date: Thu, 23 Apr 2026 17:42:57 -0400
Subject: [PATCH 11/11] ship: address late review polish

---
 .../services/shared/processExecution.test.ts  |  4 ++--
 .../main/services/shared/processExecution.ts  |  2 +-
 .../chat/AgentChatComposer.test.tsx           |  7 +++++--
 .../renderer/components/files/FilesPage.tsx   | 20 +++++++++++++++----
 .../components/lanes/LaneGitActionsPane.tsx   |  2 +-
 .../src/renderer/lib/pathUtils.test.ts        |  5 +++++
 apps/desktop/src/renderer/lib/pathUtils.ts    | 10 +++++-----
 7 files changed, 35 insertions(+), 15 deletions(-)

diff --git a/apps/desktop/src/main/services/shared/processExecution.test.ts b/apps/desktop/src/main/services/shared/processExecution.test.ts
index 8a3056d30..40b4a90eb 100644
--- a/apps/desktop/src/main/services/shared/processExecution.test.ts
+++ b/apps/desktop/src/main/services/shared/processExecution.test.ts
@@ -52,7 +52,7 @@ describe("processExecution", () => {
         "/d",
         "/s",
         "/c",
-        '"C:\\Users\\me\\AppData\\Roaming\\npm\\codex.cmd" "exec" "--cd" "C:\\repo path"',
+        '""C:\\Users\\me\\AppData\\Roaming\\npm\\codex.cmd" "exec" "--cd" "C:\\repo path""',
       ],
       windowsVerbatimArguments: true,
     });
@@ -61,7 +61,7 @@ describe("processExecution", () => {
   it("builds explicit Windows shell invocations", () => {
     expect(resolveWindowsCmdInvocation("npm", ["run", "test"], {} as NodeJS.ProcessEnv)).toEqual({
       command: "cmd.exe",
-      args: ["/d", "/s", "/c", '"npm" "run" "test"'],
+      args: ["/d", "/s", "/c", '""npm" "run" "test""'],
       windowsVerbatimArguments: true,
     });
   });
diff --git a/apps/desktop/src/main/services/shared/processExecution.ts b/apps/desktop/src/main/services/shared/processExecution.ts
index 3ca0a2618..c18bc8eac 100644
--- a/apps/desktop/src/main/services/shared/processExecution.ts
+++ b/apps/desktop/src/main/services/shared/processExecution.ts
@@ -56,7 +56,7 @@ export function resolveWindowsCmdInvocation(
   const cmdLine = [command, ...args].map(quoteWindowsCmdArg).join(" ");
   return {
     command: comSpec,
-    args: ["/d", "/s", "/c", cmdLine],
+    args: ["/d", "/s", "/c", `"${cmdLine}"`],
     windowsVerbatimArguments: true,
   };
 }
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatComposer.test.tsx b/apps/desktop/src/renderer/components/chat/AgentChatComposer.test.tsx
index 5a7768907..361875e48 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatComposer.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatComposer.test.tsx
@@ -1,6 +1,6 @@
 /* @vitest-environment jsdom */
 
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { cleanup, fireEvent, render, screen, type RenderResult } from "@testing-library/react";
 import type { ComponentProps } from "react";
 import { AgentChatComposer } from "./AgentChatComposer";
@@ -60,6 +60,10 @@ vi.mock("@lobehub/icons", () => {
   };
 });
 
+beforeEach(() => {
+  installMatchMediaMock();
+});
+
 afterEach(cleanup);
 
 function buildComposerProps(overrides: Partial<ComponentProps<typeof AgentChatComposer>> = {}) {
@@ -107,7 +111,6 @@ function buildComposerProps(overrides: Partial<ComponentProps<typeof AgentChatCo
 }
 
 function renderComposer(overrides: Partial<ComponentProps<typeof AgentChatComposer>> = {}) {
-  installMatchMediaMock();
   const props = buildComposerProps(overrides);
 
   const view = render(<AgentChatComposer {...props} />);
diff --git a/apps/desktop/src/renderer/components/files/FilesPage.tsx b/apps/desktop/src/renderer/components/files/FilesPage.tsx
index a654932c9..ec75948d8 100644
--- a/apps/desktop/src/renderer/components/files/FilesPage.tsx
+++ b/apps/desktop/src/renderer/components/files/FilesPage.tsx
@@ -412,7 +412,7 @@ export function FilesPage() {
     startLine?: number;
     startColumn?: number;
   } | null>(null);
-  const pendingRevealRef = useRef<{ mode: EditorViewMode; startLine: number; startColumn?: number } | null>(null);
+  const pendingRevealRef = useRef<{ mode: EditorViewMode; startLine: number; startColumn?: number; targetPath?: string } | null>(null);
   const diffViewRef = useRef<MonacoDiffHandle | null>(null);
   const treeRefreshStateRef = useRef<{
     inFlight: boolean;
@@ -465,6 +465,14 @@ export function FilesPage() {
   const revealPendingLocation = useCallback((): boolean => {
     const pendingReveal = pendingRevealRef.current;
     if (!pendingReveal) return false;
+    const activeRevealPath = activeTabPathRef.current;
+    if (
+      pendingReveal.targetPath
+      && activeRevealPath
+      && !arePathsEqual(activeRevealPath, pendingReveal.targetPath)
+    ) {
+      return false;
+    }
 
     if (pendingReveal.mode === "diff") {
       const handle = diffViewRef.current;
@@ -732,6 +740,7 @@ export function FilesPage() {
         mode: st?.mode ?? "edit",
         startLine: st.startLine,
         startColumn: st?.startColumn,
+        targetPath: openFilePath,
       };
     }
     pendingOpenRef.current = {
@@ -832,7 +841,7 @@ export function FilesPage() {
   }, [refreshTreeNow, workspaceId]);
 
   const openFile = useCallback(async (filePath: string, options: { forceReload?: boolean; preserveMode?: boolean } = {}) => {
-    if (!workspaceId) return;
+    if (!workspaceId) return null;
     const requestedPath = normalizePath(filePath);
     const normalizedPath = nodeByComparablePath.get(normalizePathForWorkspaceComparison(requestedPath, workspaceComparisonRoot))?.path ?? requestedPath;
     try {
@@ -873,8 +882,10 @@ export function FilesPage() {
       }
       setActiveTabPath(normalizedPath);
       setSelectedNodePath(normalizedPath);
+      return normalizedPath;
     } catch (err) {
       setError(err instanceof Error ? err.message : String(err));
+      return null;
     }
   }, [workspaceId, nodeByComparablePath, workspaceComparisonRoot]);
 
@@ -949,7 +960,7 @@ export function FilesPage() {
     let cancelled = false;
     let pendingTimer: ReturnType<typeof setTimeout> | null = null;
     openFile(pending.filePath)
-      .then(() => {
+      .then((openedPath) => {
         if (cancelled) return;
         if (pendingMode === "diff") setMode("diff");
         if (typeof pendingStartLine === "number" && pendingStartLine > 0) {
@@ -957,6 +968,7 @@ export function FilesPage() {
             mode: pendingMode ?? "edit",
             startLine: pendingStartLine,
             startColumn: pendingStartColumn,
+            targetPath: openedPath ?? pending.filePath,
           };
           const attemptReveal = (attemptsLeft: number) => {
             if (cancelled) return;
@@ -2429,7 +2441,7 @@ export function FilesPage() {
             <>
               <div style={{ ...LABEL_STYLE, padding: "4px 12px", fontSize: 8 }}>FILE</div>
               {[
-                { label: "OPEN", action: async () => openFile(contextMenu.nodePath), color: COLORS.textSecondary },
+                { label: "OPEN", action: async () => { await openFile(contextMenu.nodePath); }, color: COLORS.textSecondary },
                 { label: "OPEN DIFF", action: async () => { await openFile(contextMenu.nodePath); setMode("diff"); }, color: COLORS.info },
               ].map((item) => (
                 <button
diff --git a/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.tsx b/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.tsx
index 4c23d16bb..22e65c536 100644
--- a/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.tsx
+++ b/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.tsx
@@ -1677,7 +1677,7 @@ export function LaneGitActionsPane({
               effect: hasStaged
                 ? `${amendCommit ? "Amend" : "Commit"} ${stagedCount} staged file${stagedCount === 1 ? "" : "s"}`
                 : "No staged files to commit",
-              shortcut: "\u2318+Enter",
+              shortcut: `${modifierKeyLabel}+Enter`,
             }}>
               <button
                 type="button"
diff --git a/apps/desktop/src/renderer/lib/pathUtils.test.ts b/apps/desktop/src/renderer/lib/pathUtils.test.ts
index f92149d3c..b4dc74050 100644
--- a/apps/desktop/src/renderer/lib/pathUtils.test.ts
+++ b/apps/desktop/src/renderer/lib/pathUtils.test.ts
@@ -25,6 +25,11 @@ describe("pathUtils", () => {
     expect(normalizePath("../repo/./src/../main.ts")).toBe("../repo/main.ts");
   });
 
+  it("preserves leading and trailing spaces in path segments", () => {
+    expect(normalizePath(" docs/spec.md")).toBe(" docs/spec.md");
+    expect(normalizePath("src/App.tsx ")).toBe("src/App.tsx ");
+  });
+
   it("compares Windows paths case-insensitively", () => {
     expect(normalizePathForComparison("C:\\Users\\Me\\Repo")).toBe("c:/users/me/repo");
     expect(isPathEqualOrDescendant("c:/users/me/repo/src/main.ts", "C:\\Users\\Me\\Repo")).toBe(true);
diff --git a/apps/desktop/src/renderer/lib/pathUtils.ts b/apps/desktop/src/renderer/lib/pathUtils.ts
index 72634b35d..c73370e92 100644
--- a/apps/desktop/src/renderer/lib/pathUtils.ts
+++ b/apps/desktop/src/renderer/lib/pathUtils.ts
@@ -85,12 +85,12 @@ function collapsePathSegments(root: string, segments: string[]): string[] {
 }
 
 export function normalizePath(value: string): string {
-  const trimmed = normalizeSeparators(value).trim();
-  if (!trimmed.length) return "";
+  const normalizedInput = normalizeSeparators(value);
+  if (!normalizedInput.length) return "";
 
-  const collapsed = trimmed.startsWith("//")
-    ? `//${trimmed.slice(2).replace(/\/+/g, "/")}`
-    : trimmed.replace(/\/+/g, "/");
+  const collapsed = normalizedInput.startsWith("//")
+    ? `//${normalizedInput.slice(2).replace(/\/+/g, "/")}`
+    : normalizedInput.replace(/\/+/g, "/");
   const normalizedDrivePrefix = collapsed.replace(/^\/([A-Za-z]:)(?=\/|$)/, "$1");
 
   if (/^[A-Za-z]:$/.test(normalizedDrivePrefix)) return `${normalizedDrivePrefix}/`;