desktop + iOS: PR convergence rails, onboarding tour revamp, terminals overhaul

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

@@ -151,7 +151,10 @@ import type {
   LandResult,
   LandStackEnhancedArgs,
   LandQueueNextArgs,
+  CleanupPrBranchArgs,
+  CleanupPrBranchResult,
   PrCheck,
+  PrCommit,
   PrComment,
   PrReviewThread,
   PrHealth,
@@ -5878,6 +5881,7 @@ export function registerIpc({
 
   ipcMain.handle(IPC.prsGetDetail, (_e, args: { prId: string }) => getCtx().prService.getDetail(args.prId));
   ipcMain.handle(IPC.prsGetFiles, (_e, args: { prId: string }) => getCtx().prService.getFiles(args.prId));
+  ipcMain.handle(IPC.prsGetCommits, (_e, args: { prId: string }): Promise<PrCommit[]> => getCtx().prService.getCommits(args.prId));
   ipcMain.handle(IPC.prsGetActionRuns, (_e, args: { prId: string }) => getCtx().prService.getActionRuns(args.prId));
   ipcMain.handle(IPC.prsGetActivity, (_e, args: { prId: string }) => getCtx().prService.getActivity(args.prId));
   ipcMain.handle(IPC.prsAddComment, (_e, args) => getCtx().prService.addComment(args));
@@ -5930,6 +5934,8 @@ export function registerIpc({
       );
     },
   );
+  ipcMain.handle(IPC.prsCleanupBranch, (_e, args: CleanupPrBranchArgs): Promise<CleanupPrBranchResult> =>
+    getCtx().prService.cleanupBranch(args));
 
   // Issue Inventory (PR convergence loop)
   ipcMain.handle(IPC.prsIssueInventorySync, async (_e, args: { prId: string }): Promise<IssueInventorySnapshot> => {

apps/desktop/src/main/services/prs/issueInventoryService.test.ts

@@ -288,6 +288,108 @@ describe("issueInventoryService", () => {
       expect(insertCalls.length).toBe(0);
     });
 
+    it("treats unresolved threads with a latest resolution acknowledgement as fixed", () => {
+      const db = makeMockDb();
+      db.get.mockReturnValue(makeFakeRow({
+        external_id: "thread:thread-ack",
+        state: "new",
+        thread_comment_count: 1,
+        thread_latest_comment_id: "comment-1",
+      }));
+      db.all.mockReturnValue([makeFakeRow({
+        external_id: "thread:thread-ack",
+        state: "new",
+        thread_comment_count: 1,
+        thread_latest_comment_id: "comment-1",
+      })]);
+
+      const service = createIssueInventoryService({ db });
+      service.syncFromPrData(
+        PR_ID,
+        [],
+        [makeReviewThread({
+          id: "thread-ack",
+          comments: [
+            {
+              id: "comment-1",
+              author: "reviewer",
+              authorAvatarUrl: null,
+              body: "This needs a null check.",
+              url: null,
+              createdAt: "2026-03-23T12:00:00.000Z",
+              updatedAt: "2026-03-23T12:00:00.000Z",
+            },
+            {
+              id: "comment-2",
+              author: "arul28",
+              authorAvatarUrl: null,
+              body: "Fixed in the latest commit.",
+              url: null,
+              createdAt: "2026-03-23T12:10:00.000Z",
+              updatedAt: "2026-03-23T12:10:00.000Z",
+            },
+          ],
+        })],
+        [],
+      );
+
+      const updateCalls = db.run.mock.calls.filter(
+        (call: unknown[]) => typeof call[0] === "string" && (call[0] as string).includes("update pr_issue_inventory"),
+      );
+      expect(updateCalls.some((call: unknown[]) => (call[1] as unknown[])[8] === "fixed")).toBe(true);
+    });
+
+    it("does not treat negative resolution wording as fixed", () => {
+      const db = makeMockDb();
+      db.get.mockReturnValue(makeFakeRow({
+        external_id: "thread:thread-not-fixed",
+        state: "new",
+        thread_comment_count: 1,
+        thread_latest_comment_id: "comment-1",
+      }));
+      db.all.mockReturnValue([makeFakeRow({
+        external_id: "thread:thread-not-fixed",
+        state: "new",
+        thread_comment_count: 1,
+        thread_latest_comment_id: "comment-1",
+      })]);
+
+      const service = createIssueInventoryService({ db });
+      service.syncFromPrData(
+        PR_ID,
+        [],
+        [makeReviewThread({
+          id: "thread-not-fixed",
+          comments: [
+            {
+              id: "comment-1",
+              author: "reviewer",
+              authorAvatarUrl: null,
+              body: "Please tighten this logic.",
+              url: null,
+              createdAt: "2026-03-23T12:00:00.000Z",
+              updatedAt: "2026-03-23T12:00:00.000Z",
+            },
+            {
+              id: "comment-2",
+              author: "reviewer",
+              authorAvatarUrl: null,
+              body: "This is not fixed yet.",
+              url: null,
+              createdAt: "2026-03-23T12:10:00.000Z",
+              updatedAt: "2026-03-23T12:10:00.000Z",
+            },
+          ],
+        })],
+        [],
+      );
+
+      const updateCalls = db.run.mock.calls.filter(
+        (call: unknown[]) => typeof call[0] === "string" && (call[0] as string).includes("update pr_issue_inventory"),
+      );
+      expect(updateCalls.some((call: unknown[]) => (call[1] as unknown[])[8] === "fixed")).toBe(false);
+    });
+
     it("skips outdated review threads", () => {
       const db = makeMockDb();
       db.get.mockReturnValue(null);

apps/desktop/src/main/services/prs/issueInventoryService.ts

@@ -14,7 +14,7 @@ import type {
   PrReviewThread,
 } from "../../../shared/types";
 import { DEFAULT_CONVERGENCE_RUNTIME_STATE, DEFAULT_PIPELINE_SETTINGS } from "../../../shared/types";
-import { isNoisyIssueComment } from "./resolverUtils";
+import { isNoisyIssueComment, looksLikeResolutionAck } from "./resolverUtils";
 import { nowIso } from "../shared/utils";
 
 // ---------------------------------------------------------------------------
@@ -740,7 +740,16 @@ export function createIssueInventoryService(deps: { db: AdeDb }) {
           threadLatestCommentSource: source,
         };
 
-        if (thread.isResolved || thread.isOutdated) {
+        // Only treat as a resolution ACK when the latest reply is from a real
+        // human (or an unclassified author). Review bots — CodeRabbit (normalized
+        // from `coderabbitai`), Copilot, Codex, Greptile, Seer, ADE, etc. — often
+        // mention "fixed/resolved/done" inside long markdown bodies without
+        // actually acknowledging a fix, so passing their comments through the
+        // heuristic silently flips real, open threads to `"fixed"`.
+        const latestReplyLooksResolved = (source === "human" || source === "unknown")
+          && looksLikeResolutionAck(body);
+
+        if (thread.isResolved || thread.isOutdated || latestReplyLooksResolved) {
           if (!existing) continue;
           upsertItem(prId, externalId, threadData, {
             state: "fixed",

apps/desktop/src/main/services/prs/prIssueResolver.test.ts

@@ -169,6 +169,8 @@ describe("buildPrIssueResolutionPrompt", () => {
     expect(prompt).toContain("Watch carefully for regressions caused by your fixes.");
     expect(prompt).toContain("update the test");
     expect(prompt).toContain("rerun the complete failing test files or suites locally");
+    expect(prompt).toContain("one bounded Path to Merge resolution round");
+    expect(prompt).toContain("ADE will poll GitHub");
     expect(prompt).toContain("Commit the changes and push the PR branch before you stop.");
     expect(prompt).toContain("If you cannot safely commit or push the necessary changes");
     expect(prompt).toContain("prRefreshIssueInventory");

apps/desktop/src/main/services/prs/prIssueResolver.ts

@@ -514,7 +514,9 @@ export function buildPrIssueResolutionPrompt(args: IssueResolutionPromptArgs): s
     "",
     "Requirements",
     "- Fix all valid issues in the selected scope, not just the first one.",
+    "- Treat this chat as one bounded Path to Merge resolution round. Make one coherent set of fixes for the current inventory, then hand control back to ADE.",
     "- If you make local code or git changes that should affect the PR, do not finish with local-only state. Commit the changes and push the PR branch before you stop.",
+    "- After you push, do not wait indefinitely for CI or advisory review bots. ADE will poll GitHub, observe custom post-push comments, and launch the next round if new actionable work appears.",
     "- If you only resolve stale review threads or other PR metadata with ADE tools and no local git changes are needed, say that clearly in your final note.",
     "- If you cannot safely commit or push the necessary changes, stop with a concrete blocker instead of exiting as if the round succeeded.",
   );
@@ -559,7 +561,7 @@ export function buildPrIssueResolutionPrompt(args: IssueResolutionPromptArgs): s
     "- Before you push, rerun the complete failing test files or suites locally, not just the specific failing test names. Test runners and sharded CI can hide additional failures behind the first error in a file.",
     "- Treat newly added or heavily modified test files as likely regression hotspots, even if CI only surfaced a different failure first.",
     "- Watch carefully for regressions caused by your fixes. If a change breaks an existing test because the expected behavior legitimately changed, update the test. Do not change tests just to mask a bug.",
-    "- Continue iterating until the selected issue set is cleared and CI is green, or stop only with a concrete blocker and explain it clearly.",
+    "- Stop with a concise final note that lists what changed, what you validated, whether you pushed, and any concrete blocker ADE should surface to the operator.",
   );
   if (isIncremental) {
     promptSections.push(

apps/desktop/src/main/services/prs/prService.ts

@@ -13,6 +13,8 @@ import type {
   CommitIntegrationArgs,
   CleanupIntegrationWorkflowArgs,
   CleanupIntegrationWorkflowResult,
+  CleanupPrBranchArgs,
+  CleanupPrBranchResult,
   DeleteIntegrationProposalArgs,
   DeleteIntegrationProposalResult,
   DismissIntegrationCleanupArgs,
@@ -2615,6 +2617,10 @@ export function createPrService({
     const createdAt = nowIso();
     const headBranch = asString(pr?.head?.ref) || branchNameFromRef(lane.branchRef);
     const baseBranch = asString(pr?.base?.ref) || branchNameFromRef(lane.baseRef);
+    const laneBranch = branchNameFromRef(lane.branchRef);
+    if (normalizeBranchName(laneBranch) !== normalizeBranchName(headBranch)) {
+      throw new Error(`Cannot link PR #${locator.number} to lane "${lane.name}" because the PR head branch is "${headBranch}" but the lane branch is "${laneBranch}".`);
+    }
 
     // Backfill creation_strategy for imported PRs that don't have one stored yet.
     // The wizard defaults to "pr_target" when users create via the UI; mirror
@@ -2653,6 +2659,78 @@ export function createPrService({
     return await refreshOne(prId);
   };
 
+  const cleanupBranch = async (args: CleanupPrBranchArgs): Promise<CleanupPrBranchResult> => {
+    const row = getRow(args.prId);
+    if (!row) throw new Error(`PR not found: ${args.prId}`);
+    if (row.state !== "merged" && row.state !== "closed") {
+      throw new Error("Branch cleanup is only available after a PR is merged or closed.");
+    }
+
+    const branchName = branchNameFromRef(row.head_branch);
+    if (!branchName || branchName === "HEAD") {
+      throw new Error("PR head branch is missing.");
+    }
+
+    const lanes = await laneService.list({ includeArchived: true, includeStatus: false });
+    const primaryBranches = new Set(
+      lanes
+        .filter((lane) => lane.laneType === "primary")
+        .map((lane) => normalizeBranchName(branchNameFromRef(lane.branchRef)))
+        .filter(Boolean),
+    );
+    if (primaryBranches.has(normalizeBranchName(branchName))) {
+      throw new Error(`Refusing to clean up protected branch "${branchName}".`);
+    }
+
+    const result: CleanupPrBranchResult = {
+      prId: args.prId,
+      branchName,
+      localDeleted: false,
+      remoteDeleted: false,
+      localError: null,
+      remoteError: null,
+    };
+
+    if (args.deleteLocalBranch !== false) {
+      const refCheck = await runGit(["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], {
+        cwd: projectRoot,
+        timeoutMs: 8_000,
+      });
+      if (refCheck.exitCode === 0) {
+        // Only force-delete when the PR is merged. For closed (non-merged) PRs
+        // the branch may still hold unintegrated work, so use the safe `-d`
+        // variant which refuses to drop unmerged commits.
+        const deleteFlag = row.state === "merged" ? "-D" : "-d";
+        const deleted = await runGit(["branch", deleteFlag, branchName], { cwd: projectRoot, timeoutMs: 30_000 });
+        if (deleted.exitCode === 0) result.localDeleted = true;
+        else result.localError = deleted.stderr || deleted.stdout || `Failed to delete local branch ${branchName}`;
+      }
+    }
+
+    if (args.deleteRemoteBranch) {
+      const remote = args.remoteName?.trim() || "origin";
+      const remoteCheck = await runGit(["remote", "get-url", remote], { cwd: projectRoot, timeoutMs: 8_000 });
+      if (remoteCheck.exitCode !== 0) {
+        result.remoteError = `Remote '${remote}' is not configured for this repository`;
+      } else {
+        const remoteRefCheck = await runGit(["ls-remote", "--heads", remote, branchName], {
+          cwd: projectRoot,
+          timeoutMs: 12_000,
+        });
+        if (remoteRefCheck.exitCode === 0 && remoteRefCheck.stdout.trim().length > 0) {
+          const deleted = await runGit(["push", remote, "--delete", branchName], { cwd: projectRoot, timeoutMs: 45_000 });
+          if (deleted.exitCode === 0) result.remoteDeleted = true;
+          else result.remoteError = deleted.stderr || deleted.stdout || `Failed to delete remote branch ${branchName}`;
+        }
+      }
+    }
+
+    if (result.localError || result.remoteError) {
+      logger.warn("prs.branch_cleanup_partial_failure", result);
+    }
+    return result;
+  };
+
   const land = async (args: LandPrArgs): Promise<LandResult> => {
     const row = getRow(args.prId);
     if (!row) throw new Error(`PR not found: ${args.prId}`);
@@ -5034,6 +5112,10 @@ export function createPrService({
       return await linkToLane(args);
     },
 
+    async cleanupBranch(args: CleanupPrBranchArgs): Promise<CleanupPrBranchResult> {
+      return await cleanupBranch(args);
+    },
+
     getForLane(laneId: string): PrSummary | null {
       const row = getRowForLane(laneId);
       return row ? rowToSummary(row) : null;
@@ -5306,6 +5388,12 @@ export function createPrService({
       return files;
     },
 
+    async getCommits(prId: string): Promise<PrCommit[]> {
+      const commits = await getCommitsSnapshot(prId);
+      upsertSnapshotRow({ prId, commits });
+      return commits;
+    },
+
     async getActionRuns(prId: string): Promise<PrActionRun[]> {
       const row = requireRow(prId);
       const repo = repoFromRow(row);

apps/desktop/src/main/services/prs/resolverUtils.ts

@@ -16,6 +16,10 @@ const NOISY_BODY_PATTERNS = [
   /<!-- internal state/i,
   /walkthrough/i,
   /@codex review/i,
+  /^@(copilot|coderabbitai|greptile|codex)\s+review\b/i,
+  /\bship-lane handoff\b/i,
+  /\bclear-to-merge\b/i,
+  /\bci green\b/i,
 ];
 
 export function isNoisyIssueComment(comment: PrComment): boolean {
@@ -26,6 +30,41 @@ export function isNoisyIssueComment(comment: PrComment): boolean {
   return NOISY_BODY_PATTERNS.some((pattern) => pattern.test(body));
 }
 
+const RESOLUTION_NEGATION_PATTERNS = [
+  /\bnot\s+(fixed|addressed|resolved|done|handled)\b/i,
+  /\b(still|isn'?t|is not|not yet)\s+(an issue|fixed|addressed|resolved|done|handled|working)\b/i,
+  /\b(no|doesn'?t|does not|won'?t|can'?t|cannot|hasn'?t|haven'?t)\s+(fix|address|resolve|handle|be\s+(fixed|addressed|resolved|done|handled))\b/i,
+  /\b(will|to\s+be)\s+(fixed|addressed|resolved|done|handled)\s+(in|by)\b/i,
+  /\bstill\s+(broken|failing|an\s+issue)\b/i,
+];
+
+// ACK patterns are intentionally narrow: they must look like an actual
+// acknowledgement rather than any mention of the verbs "fixed/resolved/done".
+// `looksLikeResolutionAck` auto-flips issue inventory items to `"fixed"`, so
+// false positives silently drop live review threads from the convergence loop.
+const RESOLUTION_ACK_PATTERNS = [
+  // Terse standalone acks: "fixed.", "done!", "resolved"
+  /^\s*(fixed|addressed|resolved|done|handled)[.! ]*$/i,
+  // First-person / subject acks: "I fixed", "we addressed", "this is fixed"
+  /\b(i|we|i've|we've|this\s+(is|was)|that\s+(is|was)|it\s+(is|was))\s+(now\s+)?(fixed|addressed|resolved|done|handled)\b/i,
+  // Commit/PR-reference acks: "Fixed in commit abc", "addressed in #123",
+  // "resolved in the latest push". Scoped to concrete references to avoid
+  // matching deferrals like "addressed in a follow-up PR".
+  /^\s*(fixed|addressed|resolved|handled)\s+(in|by)\s+(the\s+latest|commit\b|#\d+|[0-9a-f]{7,40}\b|pr\s*#?\d+|my\s+(latest|most\s+recent))/i,
+  /\bshould be (good|fixed|resolved)\b/i,
+  /\bno longer (an issue|applies|reproduces)\b/i,
+  /\bthanks[,! ]+(fixed|addressed|resolved)\b/i,
+  /\bclear-to-merge\b/i,
+  /\bci green\b/i,
+];
+
+export function looksLikeResolutionAck(body: string | null | undefined): boolean {
+  const text = (body ?? "").trim();
+  if (!text) return false;
+  if (RESOLUTION_NEGATION_PATTERNS.some((pattern) => pattern.test(text))) return false;
+  return RESOLUTION_ACK_PATTERNS.some((pattern) => pattern.test(text));
+}
+
 /**
  * Map ADE's permission mode to the agent chat permission mode.
  * Shared by both the issue resolver and rebase resolver.

apps/desktop/src/preload/global.d.ts

@@ -306,7 +306,10 @@ import type {
   PrActionRun,
   PrActivityEvent,
   PrCheck,
+  PrCommit,
   PrComment,
+  CleanupPrBranchArgs,
+  CleanupPrBranchResult,
   PrConflictAnalysis,
   PrDetail,
   PrEventPayload,
@@ -1473,6 +1476,7 @@ declare global {
         onEvent: (cb: (ev: PrEventPayload) => void) => () => void;
         getDetail: (prId: string) => Promise<PrDetail>;
         getFiles: (prId: string) => Promise<PrFile[]>;
+        getCommits: (prId: string) => Promise<PrCommit[]>;
         getActionRuns: (prId: string) => Promise<PrActionRun[]>;
         getActivity: (prId: string) => Promise<PrActivityEvent[]>;
         addComment: (args: AddPrCommentArgs) => Promise<PrComment>;
@@ -1542,6 +1546,9 @@ declare global {
         launchIssueResolutionFromThread: (
           args: LaunchPrIssueResolutionFromThreadArgs,
         ) => Promise<LaunchPrIssueResolutionFromThreadResult>;
+        cleanupBranch: (
+          args: CleanupPrBranchArgs,
+        ) => Promise<CleanupPrBranchResult>;
       };
       rebase: {
         scanNeeds: () => Promise<RebaseNeed[]>;