Review engine: multi-pass pipeline, publishing, tool-backed evidence

apps/desktop/src/main/main.ts

@@ -78,6 +78,7 @@ import { createAutomationService } from "./services/automations/automationServic
 import { createAutomationPlannerService } from "./services/automations/automationPlannerService";
 import { createAutomationSecretService } from "./services/automations/automationSecretService";
 import { createAutomationIngressService } from "./services/automations/automationIngressService";
+import { createReviewService } from "./services/review/reviewService";
 import { createGithubPollingService } from "./services/automations/githubPollingService";
 import type { AutomationAdeActionRegistry } from "./services/automations/automationService";
 import {
@@ -2334,6 +2335,23 @@ app.whenReady().then(async () => {
       onEvent: (event) =>
         emitProjectEvent(projectRoot, IPC.automationsEvent, event),
     });
+    const reviewService = createReviewService({
+      db,
+      logger,
+      projectId,
+      projectRoot,
+      projectDefaultBranch: baseRef,
+      laneService,
+      gitService,
+      agentChatService,
+      sessionService,
+      sessionDeltaService,
+      testService,
+      issueInventoryService,
+      prService,
+      embeddingService,
+      onEvent: (event) => emitProjectEvent(projectRoot, IPC.reviewEvent, event),
+    });
     const automationIngressService = createAutomationIngressService({
       logger,
       automationService,
@@ -3464,6 +3482,7 @@ app.whenReady().then(async () => {
       queueLandingService,
       issueInventoryService,
       prSummaryService,
+      reviewService,
       jobEngine,
       automationService,
       automationPlannerService,
@@ -3572,6 +3591,7 @@ app.whenReady().then(async () => {
       queueLandingService: null,
       issueInventoryService: null,
       prSummaryService: null,
+      reviewService: null,
       jobEngine: null,
       automationService: null,
       automationPlannerService: null,
@@ -3684,6 +3704,11 @@ app.whenReady().then(async () => {
     } catch {
       // ignore
     }
+    try {
+      ctx.reviewService?.dispose?.();
+    } catch {
+      // ignore
+    }
     try {
       ctx.usageTrackingService?.dispose();
     } catch {

apps/desktop/src/main/services/ipc/registerIpc.ts

@@ -41,6 +41,11 @@ import type {
   AutomationSaveDraftResult,
   AutomationSimulateRequest,
   AutomationSimulateResult,
+  ReviewLaunchContext,
+  ReviewListRunsArgs,
+  ReviewRun,
+  ReviewRunDetail,
+  ReviewStartRunArgs,
   AdeActionRegistryEntry,
   AddMissionArtifactArgs,
   AddMissionInterventionArgs,
@@ -534,6 +539,7 @@ import type { createPrPollingService } from "../prs/prPollingService";
 import type { createQueueLandingService } from "../prs/queueLandingService";
 import type { createIssueInventoryService } from "../prs/issueInventoryService";
 import type { createPrSummaryService } from "../prs/prSummaryService";
+import type { createReviewService } from "../review/reviewService";
 import type { createAgentChatService } from "../chat/agentChatService";
 import type { createComputerUseArtifactBrokerService } from "../computerUse/computerUseArtifactBrokerService";
 import { buildComputerUseOwnerSnapshot } from "../computerUse/controlPlane";
@@ -631,6 +637,7 @@ export type AppContext = {
   queueLandingService: ReturnType<typeof createQueueLandingService>;
   issueInventoryService: ReturnType<typeof createIssueInventoryService>;
   prSummaryService: ReturnType<typeof createPrSummaryService>;
+  reviewService: ReturnType<typeof createReviewService>;
   jobEngine: ReturnType<typeof createJobEngine>;
   automationService: ReturnType<typeof createAutomationService>;
   automationPlannerService: ReturnType<typeof createAutomationPlannerService>;
@@ -2785,6 +2792,56 @@ export function registerIpc({
     return ctx.automationPlannerService.simulate(arg);
   });
 
+  ipcMain.handle(IPC.reviewListLaunchContext, async (): Promise<ReviewLaunchContext> => {
+    const ctx = getCtx();
+    return ctx.reviewService.listLaunchContext();
+  });
+
+  ipcMain.handle(IPC.reviewListRuns, async (_event, arg: ReviewListRunsArgs = {}): Promise<ReviewRun[]> => {
+    const ctx = getCtx();
+    return ctx.reviewService.listRuns(arg);
+  });
+
+  ipcMain.handle(IPC.reviewGetRunDetail, async (_event, arg: { runId: string }): Promise<ReviewRunDetail | null> => {
+    const ctx = getCtx();
+    return ctx.reviewService.getRunDetail({ runId: arg?.runId ?? "" });
+  });
+
+  ipcMain.handle(IPC.reviewStartRun, async (_event, arg: ReviewStartRunArgs): Promise<ReviewRun> => {
+    const ctx = getCtx();
+    return ctx.reviewService.startRun(arg);
+  });
+
+  ipcMain.handle(IPC.reviewRerun, async (_event, arg: { runId: string }): Promise<ReviewRun> => {
+    const ctx = getCtx();
+    return ctx.reviewService.rerun(arg?.runId ?? "");
+  });
+
+  ipcMain.handle(IPC.reviewCancelRun, async (_event, arg: { runId: string }) => {
+    const ctx = getCtx();
+    return ctx.reviewService.cancelRun({ runId: arg?.runId ?? "" });
+  });
+
+  ipcMain.handle(IPC.reviewRecordFeedback, async (_event, arg: import("../../../shared/types").ReviewRecordFeedbackArgs) => {
+    const ctx = getCtx();
+    return ctx.reviewService.recordFeedback(arg);
+  });
+
+  ipcMain.handle(IPC.reviewListSuppressions, async (_event, arg: import("../../../shared/types").ReviewListSuppressionsArgs | undefined) => {
+    const ctx = getCtx();
+    return ctx.reviewService.listSuppressions(arg ?? {});
+  });
+
+  ipcMain.handle(IPC.reviewDeleteSuppression, async (_event, arg: { suppressionId: string }) => {
+    const ctx = getCtx();
+    return ctx.reviewService.deleteSuppression({ suppressionId: arg?.suppressionId ?? "" });
+  });
+
+  ipcMain.handle(IPC.reviewQualityReport, async () => {
+    const ctx = getCtx();
+    return ctx.reviewService.qualityReport();
+  });
+
   ipcMain.handle(IPC.adeActionsListRegistry, async (): Promise<AdeActionRegistryEntry[]> => {
     const ctx = getCtx();
     const services = getAdeActionDomainServices(ctx as unknown as AdeRuntime);

apps/desktop/src/main/services/lanes/laneLaunchContext.test.ts

@@ -156,6 +156,29 @@ describe("resolveLaneLaunchContext", () => {
     });
   });
 
+  describe("happy path: explicit absolute cwd outside worktree", () => {
+    it("allows an external absolute cwd when the caller opts in", () => {
+      mocks.statSync.mockReturnValue({ isDirectory: () => true });
+      mocks.realpathSync
+        .mockReturnValueOnce("/real/lane/root")
+        .mockReturnValueOnce("/real/project/root");
+
+      const result = resolveLaneLaunchContext({
+        laneService: makeLaneService("/projects/my-lane"),
+        laneId: "lane-1",
+        requestedCwd: "/real/project/root",
+        allowExternalCwd: true,
+        purpose: "start agent",
+      });
+
+      expect(result).toEqual({
+        laneWorktreePath: "/real/lane/root",
+        cwd: "/real/project/root",
+      });
+      expect(mocks.resolvePathWithinRoot).not.toHaveBeenCalled();
+    });
+  });
+
   describe("error: lane has no worktree configured", () => {
     it("throws when worktreePath is empty string", () => {
       expect(() =>

apps/desktop/src/main/services/lanes/laneLaunchContext.ts

@@ -29,6 +29,7 @@ export function resolveLaneLaunchContext(args: {
   laneService: ReturnType<typeof createLaneService>;
   laneId: string;
   requestedCwd?: string | null;
+  allowExternalCwd?: boolean;
   purpose: string;
 }): LaneLaunchContext {
   const laneId = String(args.laneId ?? "").trim();
@@ -51,6 +52,16 @@ export function resolveLaneLaunchContext(args: {
     };
   }
 
+  if (args.allowExternalCwd === true && path.isAbsolute(requestedCwd)) {
+    return {
+      laneWorktreePath: laneRoot,
+      cwd: ensureDirectoryExists(
+        path.resolve(requestedCwd),
+        `Requested cwd '${requestedCwd}' is not an existing directory.`,
+      ),
+    };
+  }
+
   const requestedTarget = path.isAbsolute(requestedCwd)
     ? requestedCwd
     : path.resolve(laneRoot, requestedCwd);

apps/desktop/src/main/services/lanes/laneService.ts

@@ -2532,6 +2532,11 @@ export function createLaneService({
       db.run("delete from pr_pipeline_settings where pr_id in (select id from pull_requests where lane_id = ? and project_id = ?)", [laneId, projectId]);
       db.run("delete from pr_issue_inventory where pr_id in (select id from pull_requests where lane_id = ? and project_id = ?)", [laneId, projectId]);
       db.run("delete from pull_requests where lane_id = ? and project_id = ?", [laneId, projectId]);
+      db.run("delete from review_run_publications where run_id in (select id from review_runs where lane_id = ? and project_id = ?)", [laneId, projectId]);
+      db.run("delete from review_finding_feedback where run_id in (select id from review_runs where lane_id = ? and project_id = ?)", [laneId, projectId]);
+      db.run("delete from review_findings where run_id in (select id from review_runs where lane_id = ? and project_id = ?)", [laneId, projectId]);
+      db.run("delete from review_run_artifacts where run_id in (select id from review_runs where lane_id = ? and project_id = ?)", [laneId, projectId]);
+      db.run("delete from review_runs where lane_id = ? and project_id = ?", [laneId, projectId]);
       db.run("delete from session_deltas where lane_id = ?", [laneId]);
       db.run("delete from terminal_sessions where lane_id = ?", [laneId]);
       db.run("delete from operations where lane_id = ?", [laneId]);

apps/desktop/src/main/services/processes/processService.test.ts

@@ -212,6 +212,7 @@ describe("processService PTY-backed run commands", () => {
     try {
       await service.start({ laneId: "lane-env", processId: "print-env" });
       expect(ptyService.create).toHaveBeenCalledWith(expect.objectContaining({
+        allowNewSessionId: true,
         env: expect.objectContaining({
           PORT: "3001",
           PORT_RANGE_START: "3001",
@@ -227,6 +228,65 @@ describe("processService PTY-backed run commands", () => {
     }
   });
 
+  it("allows a managed process to use an explicit absolute cwd outside the lane worktree", async () => {
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-process-absolute-cwd-"));
+    const laneRoot = path.join(projectRoot, ".ade", "worktrees", "lane-absolute");
+    fs.mkdirSync(laneRoot, { recursive: true });
+    const dbPath = path.join(projectRoot, "kv.sqlite");
+    const projectId = "proj-absolute-cwd";
+    const logger = createLogger();
+    const db = await openKvDb(dbPath, createLogger());
+    const now = "2026-03-24T12:00:00.000Z";
+    const { ptyService, sessionService } = createPtyHarness(projectRoot);
+
+    db.run(
+      "insert into projects(id, root_path, display_name, default_base_ref, created_at, last_opened_at) values (?, ?, ?, ?, ?, ?)",
+      [projectId, projectRoot, "test", "main", now, now],
+    );
+    db.run(
+      `insert into lanes(
+        id, project_id, name, description, lane_type, base_ref, branch_ref, worktree_path,
+        attached_root_path, is_edit_protected, parent_lane_id, color, icon, tags_json, status, created_at, archived_at
+      ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      ["lane-absolute", projectId, "Lane Absolute", null, "worktree", "main", "feature/absolute", laneRoot, null, 0, null, null, null, null, "active", now, null],
+    );
+
+    const config = makeMinimalConfig([
+      { id: "absolute-proc", command: ["scripts/dogfood.sh", "code-review"], cwd: projectRoot },
+    ]);
+
+    const service = createProcessService({
+      db,
+      projectId,
+      logger,
+      laneService: {
+        getLaneWorktreePath: () => laneRoot,
+        list: async () => [makeLaneSummary(laneRoot, "lane-absolute")],
+      } as any,
+      projectConfigService: {
+        get: () => config,
+        getEffective: () => config.effective,
+        getExecutableConfig: () => config.effective,
+      } as any,
+      sessionService,
+      ptyService,
+      broadcastEvent: () => {},
+    });
+
+    try {
+      const resolvedProjectRoot = fs.realpathSync(projectRoot);
+      await service.start({ laneId: "lane-absolute", processId: "absolute-proc" });
+      expect(ptyService.create).toHaveBeenCalledWith(expect.objectContaining({
+        allowExternalCwd: true,
+        cwd: resolvedProjectRoot,
+      }));
+    } finally {
+      service.disposeAll();
+      db.close();
+      fs.rmSync(projectRoot, { recursive: true, force: true });
+    }
+  });
+
   it("includes envPath and envShell in the process.start log entry", async () => {
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ade-process-startlog-"));
     const dbPath = path.join(tmpDir, "kv.sqlite");

apps/desktop/src/main/services/processes/processService.ts

@@ -582,17 +582,32 @@ export function createProcessService({
     }
 
     const laneRoot = laneService.getLaneWorktreePath(laneId);
-    const configuredCwd = opts.overlay?.cwd?.trim() ? opts.overlay.cwd : definition.cwd;
-    const cwdCandidate = path.isAbsolute(configuredCwd) ? configuredCwd : path.join(laneRoot, configuredCwd);
+    const configuredCwd = opts.overlay?.cwd?.trim() ? opts.overlay.cwd.trim() : definition.cwd.trim();
+    // Absolute cwd is intentionally allowed: ProcessDefinition.cwd and LaneOverlayOverrides.cwd
+    // originate from the trusted project config (same file that already declares the command
+    // to execute), not from UI/IPC input. Relative paths remain sandboxed to the lane worktree.
+    const allowExternalCwd = path.isAbsolute(configuredCwd);
     let cwd: string;
-    try {
-      cwd = resolvePathWithinRoot(laneRoot, cwdCandidate);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (message.includes("Path does not exist")) {
+    if (allowExternalCwd) {
+      try {
+        const resolved = path.resolve(configuredCwd);
+        const stat = fs.statSync(resolved);
+        if (!stat.isDirectory()) throw new Error("Path is not a directory");
+        cwd = fs.realpathSync(resolved);
+      } catch {
         throw new Error(`Process '${definition.id}' cwd does not exist: ${configuredCwd}`);
       }
-      throw new Error(`Process '${definition.id}' cwd must stay within the lane workspace`);
+    } else {
+      const cwdCandidate = path.join(laneRoot, configuredCwd);
+      try {
+        cwd = resolvePathWithinRoot(laneRoot, cwdCandidate);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("Path does not exist")) {
+          throw new Error(`Process '${definition.id}' cwd does not exist: ${configuredCwd}`);
+        }
+        throw new Error(`Process '${definition.id}' cwd must stay within the lane workspace`);
+      }
     }
 
     const laneRuntimeEnv = (await getLaneRuntimeEnv?.(laneId)) ?? {};
@@ -614,6 +629,8 @@ export function createProcessService({
     try {
       const result = await ptyService.create({
         sessionId,
+        allowNewSessionId: true,
+        allowExternalCwd,
         laneId,
         cwd,
         cols: 120,