Fix synced queue wipe replication and preserve dirty file session buffers

The stacked-PR queue overhaul migration deleted queue_landing_state while
CRR triggers were active, replicating DELETE tombstones to peers that had
not upgraded yet. Strip CRR metadata before the one-shot local wipe and run
it after migrations but before ensureCrrTables re-registers replication.

Files tab session caching dropped unsaved buffers over 8 MiB when switching
project/lane scope. Always retain dirty tabs in the session snapshot so
large in-flight edits are not lost silently on tab reentry.

Co-authored-by: Arul Sharma <arul28@users.noreply.github.com>

Author: cursoragent

apps/desktop/src/main/services/state/kvDb.sync.test.ts

@@ -178,6 +178,59 @@ describe.skipIf(!isCrsqliteAvailable())("kvDb sync foundation", () => {
     repaired.close();
   });
 
+  it("does not replicate queue_landing_state overhaul wipe deletes to synced peers", async () => {
+    const dbPathA = makeDbPath("ade-kvdb-sync-queue-wipe-a-");
+    const dbA = await openKvDb(dbPathA, createLogger() as any);
+    const projectId = "project-queue-wipe";
+    const groupId = "group-queue-wipe";
+    const queueId = "queue-wipe-1";
+
+    dbA.run(
+      `insert into projects(id, root_path, display_name, default_base_ref, created_at, last_opened_at)
+       values (?, ?, ?, ?, ?, ?)`,
+      [projectId, "/repo/queue-wipe", "Queue Wipe", "main", "2026-03-15T00:00:00.000Z", "2026-03-15T00:00:00.000Z"],
+    );
+    dbA.run(
+      `insert into pr_groups(id, project_id, group_type, name, auto_rebase, ci_gating, target_branch, created_at)
+       values (?, ?, ?, ?, 0, 0, ?, ?)`,
+      [groupId, projectId, "stack", "Stack", "main", "2026-03-15T00:00:00.000Z"],
+    );
+    dbA.run(
+      `insert into queue_landing_state(
+        id, group_id, project_id, state, entries_json, config_json, current_position, started_at
+      ) values (?, ?, ?, ?, ?, ?, 0, ?)`,
+      [queueId, groupId, projectId, "active", "[]", "{}", "2026-03-15T00:00:00.000Z"],
+    );
+
+    const dbB = await openKvDb(makeDbPath("ade-kvdb-sync-queue-wipe-b-"), createLogger() as any);
+    const baselineChanges = dbA.sync.exportChangesSince(0);
+    expect(baselineChanges.some((change) => change.table === "queue_landing_state")).toBe(true);
+    dbB.sync.applyChanges(baselineChanges);
+    expect(
+      dbB.get<{ id: string }>("select id from queue_landing_state where id = ?", [queueId])?.id,
+    ).toBe(queueId);
+
+    const versionBeforeWipe = dbA.sync.getDbVersion();
+    dbA.run("delete from kv where key = ?", ["queue_landing_state.wiped_for_stacked_overhaul.v1"]);
+    dbA.close();
+
+    const dbAReopened = await openKvDb(dbPathA, createLogger() as any);
+    expect(
+      dbAReopened.get<{ id: string }>("select id from queue_landing_state where id = ?", [queueId]),
+    ).toBeNull();
+
+    const wipeChanges = dbAReopened.sync.exportChangesSince(versionBeforeWipe);
+    expect(wipeChanges.some((change) => change.table === "queue_landing_state")).toBe(false);
+
+    dbB.sync.applyChanges(wipeChanges);
+    expect(
+      dbB.get<{ id: string }>("select id from queue_landing_state where id = ?", [queueId])?.id,
+    ).toBe(queueId);
+
+    dbAReopened.close();
+    dbB.close();
+  });
+
   it("ignores CRDT changes for legacy unified_memories tables removed in #329", async () => {
     const db2 = await openKvDb(makeDbPath("ade-kvdb-sync-mem-skip-"), createLogger() as any);
     const legacyChange = {

apps/desktop/src/main/services/state/kvDb.ts

@@ -521,6 +521,65 @@ function dropCrrTriggers(db: DatabaseSyncType, tableName: string, logger?: Logge
   return triggers.length;
 }
 
+/** Strip CRR triggers/metadata so row deletes stay local (no replicated tombstones). */
+function deleteAllRowsWithoutCrrReplication(
+  db: DatabaseSyncType,
+  tableName: string,
+  logger?: Logger,
+): void {
+  if (!rawHasTable(db, tableName)) return;
+
+  const clockTableName = `${tableName}__crsql_clock`;
+  const pksTableName = `${tableName}__crsql_pks`;
+  if (rawHasTable(db, clockTableName) || rawHasTable(db, pksTableName) || listCrrTriggers(db, tableName).length > 0) {
+    if (rawHasTable(db, "crsql_master") && rawHasColumn(db, "crsql_master", "tbl_name")) {
+      runStatement(db, "delete from crsql_master where tbl_name = ?", [tableName]);
+    }
+    if (rawHasTable(db, "crsql_changes") && rawHasColumn(db, "crsql_changes", "table")) {
+      runStatement(db, "delete from crsql_changes where [table] = ?", [tableName]);
+    }
+    try {
+      getRow(db, "select crsql_as_table(?) as ok", [tableName]);
+    } catch {
+      // Table may not be registered enough for crsql_as_table; shadow cleanup below still applies.
+    }
+    dropCrrTriggers(db, tableName, logger);
+    runStatement(db, `drop table if exists ${quoteIdentifier(clockTableName)}`);
+    runStatement(db, `drop table if exists ${quoteIdentifier(pksTableName)}`);
+  }
+
+  runStatement(db, `delete from ${quoteIdentifier(tableName)}`);
+}
+
+const QUEUE_OVERHAUL_WIPE_MARKER = "queue_landing_state.wiped_for_stacked_overhaul.v1";
+
+/**
+ * One-shot local wipe of legacy queue_landing_state on upgrade to the stacked-PR
+ * queue overhaul. Must run after migrations and before ensureCrrTables so deletes
+ * do not replicate to peers that have not upgraded yet.
+ */
+function wipeQueueLandingStateForStackedOverhaulIfNeeded(db: DatabaseSyncType, logger?: Logger): void {
+  try {
+    const row = getRow<{ value: string }>(
+      db,
+      "select value from kv where key = ?",
+      [QUEUE_OVERHAUL_WIPE_MARKER],
+    );
+    if (row) return;
+
+    deleteAllRowsWithoutCrrReplication(db, "queue_landing_state", logger);
+    runStatement(
+      db,
+      "insert into kv (key, value) values (?, ?) on conflict(key) do update set value = excluded.value",
+      [QUEUE_OVERHAUL_WIPE_MARKER, new Date().toISOString()],
+    );
+  } catch {
+    // Table may not exist on a brand-new DB; initialization will create both
+    // tables and the next startup will record the marker. Skipping the wipe
+    // on a fresh DB is correct (nothing to wipe).
+  }
+}
+
 function removeExcludedCrrMetadata(db: DatabaseSyncType, logger?: Logger): void {
   for (const tableName of LOCAL_ONLY_CRR_EXCLUDED_TABLES) {
     const clockTableName = `${tableName}__crsql_clock`;
@@ -1821,32 +1880,6 @@ function migrate(db: MigrationDb) {
   try { db.run("alter table queue_landing_state add column wait_reason text"); } catch {}
   try { db.run("alter table queue_landing_state add column updated_at text"); } catch {}
 
-  // One-shot wipe of legacy queue_landing_state on upgrade to the stacked-PR
-  // queue overhaul. The new queue creates PRs with chain bases (PR_N's base =
-  // previous lane's branch) instead of all-into-main, so any in-flight queue
-  // from the old code path would be misinterpreted by the new landing loop.
-  // Wiping rather than migrating is a deliberate choice — the user accepts
-  // losing in-flight queues in exchange for not maintaining a translation
-  // layer for every legacy field shape.
-  const QUEUE_OVERHAUL_WIPE_MARKER = "queue_landing_state.wiped_for_stacked_overhaul.v1";
-  try {
-    const row = db.get<{ value: string }>(
-      "select value from kv where key = ?",
-      [QUEUE_OVERHAUL_WIPE_MARKER],
-    );
-    if (!row) {
-      db.run("delete from queue_landing_state");
-      db.run(
-        "insert into kv (key, value) values (?, ?) on conflict(key) do update set value = excluded.value",
-        [QUEUE_OVERHAUL_WIPE_MARKER, new Date().toISOString()],
-      );
-    }
-  } catch {
-    // Table may not exist on a brand-new DB; initialization will create both
-    // tables and the next startup will record the marker. Skipping the wipe
-    // on a fresh DB is correct (nothing to wipe).
-  }
-
   // Rebase dismiss/defer persistence
   db.run(`
     create table if not exists rebase_dismissed (
@@ -2849,6 +2882,8 @@ export async function openKvDb(dbPath: string, logger: Logger): Promise<AdeDb> {
       removeExcludedCrrMetadata(db, logger);
     }
 
+    wipeQueueLandingStateForStackedOverhaulIfNeeded(db, logger);
+
     if (crsqliteLoaded) {
       loadCrsqliteIfAvailable();
       ensureCrrTables(db, logger);

apps/desktop/src/renderer/components/files/FilesPage.tsx

@@ -159,7 +159,6 @@ const filesRootTreeCacheByWorkspace = new Map<string, FileTreeNode[]>();
 const MAX_FILES_PAGE_CACHED_SCOPES = 8;
 const MAX_FILES_TREE_CACHED_WORKSPACES = 32;
 const MAX_CACHED_CLEAN_TAB_CHARS = 256 * 1024;
-const MAX_CACHED_DIRTY_TAB_CHARS = 8 * 1024 * 1024;
 const MAX_QUEUED_TREE_PARENT_REFRESHES = 24;
 const FILES_WATCH_START_DELAY_MS = import.meta.env.MODE === "test" || (window as any).__adeBrowserMock ? 0 : 2_000;
 
@@ -249,8 +248,10 @@ function filesPageSessionHasUnsavedTabs(session: FilesPageSessionState | undefin
 function cacheableSessionTabs(openTabs: OpenTab[]): OpenTab[] {
   return openTabs
     .filter((tab) => {
+      // Always retain unsaved buffers across session scope changes; size limits
+      // apply only to clean tabs so large in-flight edits are not dropped silently.
       if (tab.content !== tab.savedContent) {
-        return tab.content.length <= MAX_CACHED_DIRTY_TAB_CHARS;
+        return true;
       }
       return isTextTab(tab) && tab.content.length <= MAX_CACHED_CLEAN_TAB_CHARS;
     })