Improve path safety and orchestrator; misc fixes

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: arul28

apps/desktop/src/main/services/chat/agentChatService.test.ts

@@ -1844,6 +1844,7 @@ describe("createAgentChatService", () => {
         model: "gpt-5.4",
       });
 
+      const threadsBefore = mockState.codexThreadCounter;
       const turnsBefore = mockState.codexTurnCounter;
       const outsidePath = path.join(process.cwd(), `.ade-agent-chat-outside-${Date.now()}.txt`);
       fs.writeFileSync(outsidePath, "secret", "utf8");
@@ -1856,6 +1857,7 @@ describe("createAgentChatService", () => {
       } finally {
         fs.rmSync(outsidePath, { force: true });
       }
+      expect(mockState.codexThreadCounter).toBe(threadsBefore);
       expect(mockState.codexTurnCounter).toBe(turnsBefore);
     });
 
@@ -1892,7 +1894,12 @@ describe("createAgentChatService", () => {
     });
 
     it("logs attachment read failures and keeps the fallback text generic", async () => {
-      const { service, logger } = createService();
+      const events: AgentChatEventEnvelope[] = [];
+      const { service, logger } = createService({
+        onEvent: (event: AgentChatEventEnvelope) => {
+          events.push(event);
+        },
+      });
       const attachmentDir = path.join(tmpRoot, "attachment-dir");
       fs.mkdirSync(attachmentDir, { recursive: true });
       vi.mocked(generateText).mockResolvedValue({ text: "Attachment fallback test" } as any);
@@ -1924,10 +1931,21 @@ describe("createAgentChatService", () => {
         : [];
       const messages = rawMessages;
       const currentUserMessageText = JSON.stringify(messages.at(-1)?.content);
+      const userMessageEvent = await waitForEvent(
+        events,
+        (event): event is AgentChatEventEnvelope & {
+          event: Extract<AgentChatEventEnvelope["event"], { type: "user_message" }>;
+        } => event.event.type === "user_message",
+      );
+      const rendererPayload = JSON.stringify(userMessageEvent.event);
 
       expect(currentUserMessageText).toContain("Attachment unavailable: attachment-dir");
       expect(currentUserMessageText).not.toContain("Path is not a regular file");
       expect(currentUserMessageText).not.toContain("EISDIR");
+      expect(rendererPayload).not.toContain("Path is not a regular file");
+      expect(rendererPayload).not.toContain("EISDIR");
+      expect(rendererPayload).not.toContain(attachmentDir);
+      expect(rendererPayload).not.toContain(tmpRoot);
       expect(logger.warn).toHaveBeenCalledWith(
         "agent_chat.streaming_attachment_unavailable",
         expect.objectContaining({

apps/desktop/src/main/services/files/fileService.test.ts

@@ -0,0 +1,48 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createFileService } from "./fileService";
+
+describe("fileService", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("preserves non-escape filesystem errors while resolving workspace paths", () => {
+    const rootPath = fs.mkdtempSync(path.join(os.tmpdir(), "ade-file-service-"));
+    const rootReal = fs.realpathSync(rootPath);
+    const blockedPath = path.join(rootReal, "blocked");
+    const permissionError = Object.assign(new Error("permission denied"), { code: "EACCES" as const });
+    const originalLstatSync = fs.lstatSync.bind(fs);
+
+    const laneService = {
+      resolveWorkspaceById: vi.fn(() => ({
+        id: "workspace-1",
+        laneId: "lane-1",
+        rootPath,
+      })),
+      getFilesWorkspaces: vi.fn(() => []),
+    } as any;
+
+    const service = createFileService({ laneService });
+    const spy = vi.spyOn(fs, "lstatSync").mockImplementation(((filePath: fs.PathLike) => {
+      if (String(filePath) === blockedPath) {
+        throw permissionError;
+      }
+      return originalLstatSync(filePath);
+    }) as typeof fs.lstatSync);
+
+    try {
+      expect(() =>
+        service.readFile({
+          workspaceId: "workspace-1",
+          path: "blocked/child.txt",
+        })
+      ).toThrow(permissionError);
+    } finally {
+      spy.mockRestore();
+      fs.rmSync(rootPath, { recursive: true, force: true });
+    }
+  });
+});

apps/desktop/src/main/services/files/fileService.ts

@@ -139,8 +139,11 @@ function ensureSafePath(
   let absPath: string;
   try {
     absPath = resolvePathWithinRoot(rootPath, joinedPath, { allowMissing: opts.allowMissing });
-  } catch {
-    throw new Error("Refusing to access path outside workspace");
+  } catch (error) {
+    if (error instanceof Error && error.message === "Path escapes root") {
+      throw new Error("Refusing to access path outside workspace");
+    }
+    throw error;
   }
   if (containsDotGit(absPath)) {
     throw new Error("Refusing to access .git internals");

apps/desktop/src/main/services/orchestrator/aiOrchestratorService.test.ts

@@ -3383,6 +3383,90 @@ describe("aiOrchestratorService", () => {
     }
   });
 
+  it("keeps coordinator availability interventions open when no live coordinator exists", async () => {
+    const fixture = await createFixture();
+    try {
+      const mission = fixture.missionService.create({
+        prompt: "Do not clear coordinator blockers without a live coordinator.",
+        laneId: fixture.laneId,
+      });
+      const started = fixture.orchestratorService.startRun({
+        missionId: mission.id,
+        steps: [],
+      });
+      const runId = started.run.id;
+      fixture.missionService.update({
+        missionId: mission.id,
+        status: "in_progress",
+      });
+      fixture.orchestratorService.addSteps({
+        runId,
+        steps: [
+          {
+            stepKey: "manual-check",
+            title: "Manual check",
+            stepIndex: 0,
+            dependencyStepKeys: [],
+            executorKind: "manual",
+          },
+        ],
+      });
+      fixture.orchestratorService.tick({ runId });
+      const graph = fixture.orchestratorService.getRunGraph({ runId });
+      const readyStep = graph.steps.find((step) => step.stepKey === "manual-check" && step.status === "ready");
+      if (!readyStep) throw new Error("Expected manual-check step to be ready");
+      const attempt = await fixture.orchestratorService.startAttempt({
+        runId,
+        stepId: readyStep.id,
+        ownerId: "test-owner",
+        executorKind: "manual",
+      });
+      await fixture.orchestratorService.completeAttempt({
+        attemptId: attempt.id,
+        status: "succeeded",
+      });
+      const intervention = fixture.missionService.addIntervention({
+        missionId: mission.id,
+        interventionType: "failed_step",
+        title: "Coordinator unavailable",
+        body: "Coordinator agent is not available for this run.",
+        requestedAction: "Resume after coordinator runtime is healthy.",
+        metadata: {
+          runId,
+          stepId: readyStep.id,
+          attemptId: attempt.id,
+          reasonCode: "coordinator_unavailable",
+        },
+      });
+
+      fixture.aiOrchestratorService.onOrchestratorRuntimeEvent({
+        type: "orchestrator-step-updated",
+        runId,
+        stepId: readyStep.id,
+        attemptId: attempt.id,
+        at: new Date().toISOString(),
+        reason: "attempt_completed",
+      } as any);
+
+      const refreshedMission = fixture.missionService.get(mission.id);
+      const refreshedIntervention = refreshedMission?.interventions.find((entry) => entry.id === intervention.id);
+      expect(refreshedIntervention?.status).toBe("open");
+
+      const resolvedEvents = fixture.orchestratorService.listRuntimeEvents({
+        runId,
+        eventTypes: ["intervention_resolved"],
+        limit: 10,
+      });
+      expect(
+        resolvedEvents.some((entry) =>
+          String((entry.payload as Record<string, unknown> | null)?.interventionId ?? "") === intervention.id
+        )
+      ).toBe(false);
+    } finally {
+      fixture.dispose();
+    }
+  });
+
   it("prefers mission launch failures over later coordinator-unavailable interventions in run view", async () => {
     const fixture = await createFixture();
     try {

apps/desktop/src/main/services/orchestrator/aiOrchestratorService.ts

@@ -10178,14 +10178,14 @@ Check all worker statuses and continue managing the mission from here. Read work
           reason: event.reason,
           recovered: false
         });
+      } else {
+        resolveCoordinatorHealthInterventions({
+          runId,
+          note: "Coordinator runtime is healthy again; closed stale coordinator availability intervention.",
+          resolutionReason: "coordinator_recovered",
+        });
       }
 
-      resolveCoordinatorHealthInterventions({
-        runId,
-        note: "Coordinator runtime is healthy again; closed stale coordinator availability intervention.",
-        resolutionReason: "coordinator_recovered",
-      });
-
       // Run finalized — coordinator's job is done, shut it down
       if (event.reason === "finalized") {
         const terminalRunStatus = getEventGraph().run.status;

apps/desktop/src/main/services/orchestrator/coordinatorTools.test.ts

@@ -15,6 +15,8 @@ function createTestDeps(args: {
     text: string;
     priority?: "normal" | "urgent";
   }) => Promise<CoordinatorWorkerDeliveryStatus>;
+  projectRoot?: string;
+  workspaceRoot?: string;
   memoryService?: {
     search: (opts: Record<string, unknown>) => Promise<any[]>;
     searchAcrossScopeOwners?: (opts: Record<string, unknown>) => Promise<any[]>;
@@ -55,15 +57,40 @@ function createTestDeps(args: {
     missionId: "mission-1",
     logger,
     db: {} as any,
-    projectRoot: "/tmp",
-    workspaceRoot: "/tmp/worktree",
+    projectRoot: args.projectRoot ?? "/tmp",
+    workspaceRoot: args.workspaceRoot ?? "/tmp/worktree",
     onDagMutation: vi.fn(),
     sendWorkerMessageToSession: args.sendWorkerMessageToSession,
   });
 
   return { tools, orchestratorService };
 }
 
+describe("coordinator project context", () => {
+  it("redacts the workspace root from get_project_context", async () => {
+    const workspaceRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-coordinator-tools-"));
+    try {
+      fs.writeFileSync(path.join(workspaceRoot, "README.md"), "# Test workspace\n", "utf8");
+      const { tools } = createTestDeps({
+        graph: { run: { id: "run-1", metadata: {} }, steps: [], attempts: [] },
+        workspaceRoot,
+      });
+
+      const result = await (tools.get_project_context as any).execute({});
+
+      expect(result).toMatchObject({
+        ok: true,
+        projectRoot: "./",
+        projectRootRedacted: true,
+        rootLabel: "./",
+      });
+      expect(JSON.stringify(result)).not.toContain(workspaceRoot);
+    } finally {
+      fs.rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+  });
+});
+
 describe("coordinator memory tools", () => {
   it("memory_search queries project memory with mission scope defaults", async () => {
     const memoryService = {

apps/desktop/src/main/services/orchestrator/coordinatorTools.ts

@@ -6299,9 +6299,12 @@ Format: Lead with the concrete rule or fact, then brief context for WHY. One act
         } catch {
           // Ignore
         }
+        const workspaceRootLabel = "./";
         return {
           ok: true,
-          projectRoot: workspaceRoot,
+          projectRoot: workspaceRootLabel,
+          projectRootRedacted: true,
+          rootLabel: workspaceRootLabel,
           topLevelEntries: topLevel,
           docs,
         };

apps/desktop/src/main/services/shared/utils.test.ts

@@ -237,9 +237,7 @@ describe("resolvePathWithinRoot", () => {
       fs.rmSync(outsideDir, { recursive: true, force: true });
     }
   });
-});
 
-describe("resolvePathWithinRoot", () => {
   it("allows a normal child path when intermediate segments do not exist yet", () => {
     const root = fs.mkdtempSync(path.join(os.tmpdir(), "ade-utils-root-"));
     try {

apps/desktop/src/main/services/shared/utils.ts

@@ -276,8 +276,8 @@ function ensureDirectoryChainWithinRoot(
 
     const nextPath = path.join(cursor, segment);
     try {
-      const stat = fs.lstatSync(nextPath);
-      const resolvedPath = stat.isSymbolicLink() ? realpathExisting(nextPath) : realpathExisting(nextPath);
+      fs.lstatSync(nextPath);
+      const resolvedPath = realpathExisting(nextPath);
       if (!isPathAlignedWithRoot(rootReal, resolvedPath)) {
         throw new Error("Path escapes root");
       }

apps/desktop/src/renderer/components/cto/pipeline/WorkflowListSidebar.tsx

@@ -154,16 +154,24 @@ export function WorkflowListSidebar({
                   key={workflow.id}
                   type="button"
                   onClick={() => onSelectWorkflow(workflow.id)}
+                  aria-current={isSelected ? "true" : undefined}
+                  aria-pressed={workflow.enabled}
                   className={cn(
                     "w-full rounded-lg px-3 py-2.5 text-left transition-all duration-200",
                     isSelected ? "bg-[rgba(167,139,250,0.08)]" : "hover:bg-white/[0.03]",
                   )}
                   style={isSelected ? { border: "1px solid rgba(167,139,250,0.15)" } : { border: "1px solid transparent" }}
                 >
                   <div className="flex items-center justify-between gap-2">
-                    <div className="truncate text-xs font-medium text-fg">{workflow.name}</div>
+                    <div className="truncate text-xs font-medium text-fg">
+                      {workflow.name}
+                      <span className="sr-only">
+                        {` ${isSelected ? "selected" : "not selected"} ${workflow.enabled ? "enabled" : "disabled"}`}
+                      </span>
+                    </div>
                     <div
                       className="h-2 w-2 rounded-full shrink-0"
+                      aria-hidden="true"
                       style={{ background: workflow.enabled ? "#34D399" : "#6B7280" }}
                     />
                   </div>