feat(pr): workspace setting to auto-keep new authored PRs mergeable by default

Adds a per-workspace 'Auto-keep new PRs mergeable' toggle (Settings → Workspace).
When on, a newly-tracked open PR the viewer AUTHORED gets auto-keep-mergeable
armed automatically on first sighting, so the watcher keeps it mergeable without
a manual per-PR toggle.

Scoped to authored PRs on purpose: arming auto-keep-mergeable dispatches cloud
fix runs that PUSH COMMITS, so it must never auto-fire on someone else's
review-requested PR. The default is applied only in upsertRow's INSERT branch
(genuine first sighting, authored + open) — never on the hot update path, so it
can't retroactively arm an existing PR, and the extra settings read (projected to
the small settings jsonb, never the logo blob) is off the hot path.

- shared: WorkspaceSettings.defaultAutoKeepMergeable
- backend: prCache.upsertRow reads the setting on insert, arms autoKeepMergeable
  + autoMergeState { attempts: 0, accounted: true } (mirrors the toggle route),
  and rides it on the insert broadcast so the desktop reflects it immediately
- desktop: AutoKeepMergeableDefaultToggle in the Workspace settings section
- tests: authored-arms / reviewer-does-not-arm / default-off / update-path-never-arms

Author: Gilbert09

apps/desktop/src/renderer/components/panels/SettingsPanel.tsx

@@ -636,6 +636,8 @@ function WorkspaceSettings() {
             )}
           </Card>
 
+          <AutoKeepMergeableDefaultToggle />
+
           <Card className="p-4 border-destructive/30">
             <h4 className="font-medium mb-1">Delete workspace</h4>
             <p className="text-sm text-muted-foreground mb-3">
@@ -1038,6 +1040,63 @@ export function ProviderConnectCards() {
  * back to Auto). Always shown so the default is discoverable even with one (or
  * zero) providers connected. Persists to `workspace.settings.defaultCloudProvider`.
  */
+/**
+ * Workspace default: auto-arm "auto-keep mergeable" on every new PR the viewer
+ * authored. Persists to `workspace.settings.defaultAutoKeepMergeable`; the
+ * backend applies it only to authored PRs on first sighting (never a PR you're
+ * only reviewing). Individual PRs stay hand-toggleable in the PR detail sheet.
+ */
+function AutoKeepMergeableDefaultToggle() {
+  const currentWorkspaceId = useWorkspaceStore((s) => s.currentWorkspaceId);
+  const workspaces = useWorkspaceStore((s) => s.workspaces);
+  const setWorkspaces = useWorkspaceStore((s) => s.setWorkspaces);
+  const [saving, setSaving] = useState(false);
+
+  const workspace = workspaces.find((w) => w.id === currentWorkspaceId);
+  const enabled = workspace?.settings?.defaultAutoKeepMergeable === true;
+
+  const onToggle = async (next: boolean) => {
+    if (!currentWorkspaceId) return;
+    setSaving(true);
+    try {
+      const settings = { defaultAutoKeepMergeable: next } as Workspace['settings'];
+      await api.workspaces.update(currentWorkspaceId, { settings });
+      setWorkspaces(
+        workspaces.map((w) =>
+          w.id === currentWorkspaceId
+            ? { ...w, settings: { ...w.settings, ...settings } as Workspace['settings'] }
+            : w,
+        ),
+      );
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  return (
+    <Card className="p-4">
+      <label className="flex items-start gap-3 cursor-pointer">
+        <input
+          type="checkbox"
+          checked={enabled}
+          disabled={saving || !currentWorkspaceId}
+          onChange={(e) => void onToggle(e.target.checked)}
+          className="mt-1"
+        />
+        <div className="flex-1">
+          <div className="font-medium text-sm">Auto-keep new PRs mergeable</div>
+          <p className="text-xs text-muted-foreground mt-1">
+            When a PR you authored first shows up in this workspace, automatically turn on
+            “Auto-keep mergeable” — a cloud agent fixes conflicts, CI, and review comments to keep
+            it mergeable until it merges. Applies only to PRs you opened, never ones you’re just
+            reviewing. You can still toggle any individual PR from its detail panel.
+          </p>
+        </div>
+      </label>
+    </Card>
+  );
+}
+
 function CloudProviderDefaultSelector() {
   const currentWorkspaceId = useWorkspaceStore((s) => s.currentWorkspaceId);
   const workspaces = useWorkspaceStore((s) => s.workspaces);

packages/backend/src/__tests__/prCache.test.ts

@@ -413,6 +413,84 @@ describe('prCache — DB integration', () => {
     ).toBe('Renamed');
   });
 
+  describe('auto-keep mergeable default', () => {
+    async function setDefault(on: boolean): Promise<void> {
+      await db
+        .update(workspacesTable)
+        .set({ settings: { defaultAutoKeepMergeable: on } })
+        .where(eq(workspacesTable.id, 'ws1'));
+    }
+    async function flags(number: number) {
+      const rows = await db
+        .select({
+          autoKeepMergeable: pullRequestsTable.autoKeepMergeable,
+          autoMergeState: pullRequestsTable.autoMergeState,
+        })
+        .from(pullRequestsTable)
+        .where(eq(pullRequestsTable.number, number));
+      return rows[0];
+    }
+
+    it('arms a new AUTHORED open PR when the workspace default is on', async () => {
+      await setDefault(true);
+      await upsertFromBatchResult({
+        workspaceId: 'ws1',
+        repositoryId: 'repo1',
+        summary: makeSummary({ number: 10 }),
+        authored: true,
+      });
+      const f = await flags(10);
+      expect(f.autoKeepMergeable).toBe(true);
+      expect(f.autoMergeState).toEqual({ attempts: 0, accounted: true });
+    });
+
+    it('does NOT arm a PR the viewer only reviews (not authored), even with the default on', async () => {
+      await setDefault(true);
+      await upsertFromBatchResult({
+        workspaceId: 'ws1',
+        repositoryId: 'repo1',
+        summary: makeSummary({ number: 11 }),
+        authored: false,
+        reviewRequested: true,
+      });
+      const f = await flags(11);
+      expect(f.autoKeepMergeable).toBe(false);
+      expect(f.autoMergeState).toBeNull();
+    });
+
+    it('leaves a new authored PR off when the workspace default is off', async () => {
+      await setDefault(false);
+      await upsertFromBatchResult({
+        workspaceId: 'ws1',
+        repositoryId: 'repo1',
+        summary: makeSummary({ number: 12 }),
+        authored: true,
+      });
+      const f = await flags(12);
+      expect(f.autoKeepMergeable).toBe(false);
+      expect(f.autoMergeState).toBeNull();
+    });
+
+    it('never arms retroactively on the update path — only on first insert', async () => {
+      await setDefault(false);
+      await upsertFromBatchResult({
+        workspaceId: 'ws1',
+        repositoryId: 'repo1',
+        summary: makeSummary({ number: 13 }),
+        authored: true,
+      });
+      // Flip the default on, then re-upsert the SAME PR (update path).
+      await setDefault(true);
+      await upsertFromBatchResult({
+        workspaceId: 'ws1',
+        repositoryId: 'repo1',
+        summary: makeSummary({ number: 13, title: 'Updated' }),
+        authored: true,
+      });
+      expect((await flags(13)).autoKeepMergeable).toBe(false);
+    });
+  });
+
   describe('linkTaskToPullRequest', () => {
     async function seedTask(): Promise<string> {
       const id = `task-${Math.random().toString(36).slice(2, 8)}`;

packages/backend/src/services/prCache.ts

@@ -4,6 +4,7 @@ import { getDbClient, type Database } from '../db/client.js';
 import {
   pullRequests as pullRequestsTable,
   repositories as repositoriesTable,
+  workspaces as workspacesTable,
 } from '../db/schema.js';
 import { emitPullRequestUpdated } from './websocket.js';
 import {
@@ -547,6 +548,25 @@ function isFresh(lastPolledAt: Date, ttlMs: number): boolean {
   return Date.now() - lastPolledAt.getTime() < ttlMs;
 }
 
+/**
+ * The workspace's "auto-keep mergeable by default" setting. Read only when a
+ * brand-new authored PR is being inserted (a rare event — never the hot update
+ * path), and projected to the small `settings` jsonb so the large `logo` column
+ * never ships.
+ */
+async function workspaceDefaultAutoKeepMergeable(
+  db: Database,
+  workspaceId: string
+): Promise<boolean> {
+  const rows = await db
+    .select({ settings: workspacesTable.settings })
+    .from(workspacesTable)
+    .where(eq(workspacesTable.id, workspaceId))
+    .limit(1);
+  const settings = (rows[0]?.settings as { defaultAutoKeepMergeable?: boolean } | null) ?? {};
+  return settings.defaultAutoKeepMergeable === true;
+}
+
 async function upsertRow(
   db: Database,
   opts: {
@@ -592,6 +612,19 @@ async function upsertRow(
   }
   const lastSummary = summaryToJsonb(summary);
   const cursors = nextCursors(summary);
+  // A newly-tracked open PR the viewer AUTHORED inherits the workspace's
+  // "auto-keep mergeable by default" setting. Scoped to authored PRs on purpose:
+  // arming it dispatches cloud fix runs that PUSH COMMITS, so it must never
+  // auto-fire on someone else's review-requested PR. Only computed on a genuine
+  // insert of an authored open PR — never on updates or non-authored rows.
+  let autoKeepMergeable = false;
+  let autoMergeState: { attempts: number; accounted: boolean } | null = null;
+  if (!opts.existingId && opts.authored === true && summary.state === 'open') {
+    if (await workspaceDefaultAutoKeepMergeable(db, opts.workspaceId)) {
+      autoKeepMergeable = true;
+      autoMergeState = { attempts: 0, accounted: true };
+    }
+  }
   if (opts.existingId) {
     // Update path — leave taskId alone (set on first insert only).
     await db
@@ -635,6 +668,8 @@ async function upsertRow(
       lastReviewCommentId: cursors.lastReviewCommentId,
       lastCommentId: cursors.lastCommentId,
       lastCheckDigest: cursors.lastCheckDigest,
+      autoKeepMergeable,
+      autoMergeState,
       createdAt: now,
       updatedAt: now,
     });
@@ -652,6 +687,11 @@ async function upsertRow(
     lastSummary,
     ...(opts.reviewRequested === undefined ? {} : { reviewRequested: opts.reviewRequested }),
     ...(opts.authored === undefined ? {} : { authored: opts.authored }),
+    // Surface the auto-armed state on first insert so the toggle reflects it
+    // without waiting for a full fetch (matches the toggle route's emit shape).
+    ...(autoKeepMergeable
+      ? { autoKeepMergeable: true, autoMergeState: { attempts: 0, paused: false } }
+      : {}),
   });
   return id;
 }

packages/shared/src/index.ts

@@ -118,6 +118,14 @@ export interface WorkspaceSettings {
   claudeModel?: ClaudeModelId;
   /** Which model PostHog Code runs use. Unset = {@link DEFAULT_POSTHOG_CODE_MODEL_ID}. */
   posthogCodeModel?: PostHogCodeModelId;
+  /**
+   * When on, a newly-tracked open PR the viewer AUTHORED gets "auto-keep
+   * mergeable" armed automatically (the watcher fires cloud fix runs to keep it
+   * mergeable until it merges). Scoped to authored PRs on purpose — arming it
+   * pushes commits, so it must never auto-fire on someone else's
+   * review-requested PR. Individual PRs can still be toggled by hand. Unset = off.
+   */
+  defaultAutoKeepMergeable?: boolean;
 }
 
 export interface ContinuousBuildSettings {