ship: iteration 2 fix CI and review comments

Author: arul28

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" });

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
     });

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);
       }
     }
 

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", () => {

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 {