fix: avoid history reclamation during structure-only upgrades

Ordinary database schema upgrades previously ran VACUUM on free pages and
showed misleading history-cleanup progress. Separate structure upgrades from
required legacy conversions, retaining reclamation intent only for retries
within the same startup. Preserve released data without new schema versions
or persistent migration markers; Agent and normal writes remain unchanged.

Add real SQLite and Worker regressions, bilingual operation-specific startup
copy, and migration documentation. Synchronize native Electron drag input
with actual resize state without weakening layout assertions.

Validation: 47 focused migration tests passed; typecheck, lint and diff checks
passed. Final full suite: 5137 passed, 74 skipped, 2 unrelated Electron failures.
Both failing Electron tests passed an isolated rerun; full CI remains unverified.

Release note: 修复普通数据库结构升级再次整理历史和回收空间的问题；仅在需要转换旧数据时执行相关处理，启动页准确显示当前升级操作。

src/main/assistant/activity-history-io.test.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path'
 import { DatabaseSync } from 'node:sqlite'
 import { expect, it, vi } from 'vitest'
 import { AssistantDatabase } from './assistant-database'
-import { upgradeAssistantStorage } from './assistant-storage-upgrade'
+import { getPendingAssistantStorageUpgrade, upgradeAssistantStorage } from './assistant-storage-upgrade'
 
 it('migrates activity history and writes only changed records during streaming', () => {
   const directory = mkdtempSync(join(tmpdir(), 'goodbuddy-save-io-'))
@@ -41,6 +41,7 @@ it('migrates activity history and writes only changed records during streaming',
     }
     const beforeBytes = statSync(`${path}-wal`).size
     database.close()
+    expect(getPendingAssistantStorageUpgrade(path)).toEqual({ migrateNotes: false, reclaimSpace: true })
     upgradeAssistantStorage(path, () => undefined)
     database.initialize(directory)
     expect(database.getActivityHistory()).toEqual({ records, legacyHistoryMayBeIncomplete: true })

src/main/assistant/assistant-database.ts

@@ -1846,21 +1846,24 @@ export class AssistantDatabase {
   }
 
   // Called by the existing startup worker before the business connection opens.
-  upgradeMagicNoteStorage(
+  upgradeStorage(
     onProgress: (progress: AssistantStorageProgress) => void,
-    isCancelled: () => boolean
+    isCancelled: () => boolean,
+    upgrade: { migrateNotes: boolean; reclaimSpace: boolean }
   ): void {
     const database = new DatabaseSync(this.databasePath, { timeout: 5_000 })
     try {
       database.exec('PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON;')
       this.migrate(database, onProgress, isCancelled)
       this.database = database
-      this.repairMagicNoteStorage(onProgress, isCancelled)
+      if (upgrade.migrateNotes) this.repairMagicNoteStorage(onProgress, isCancelled)
       if (isCancelled()) throw new DOMException('Upgrade cancelled', 'AbortError')
-      const free = database.prepare('PRAGMA freelist_count').get() as { freelist_count: number }
-      if (free.freelist_count > 0) {
-        onProgress({ stage: 'compacting', processed: 0, total: 0, bytesBefore: statSync(this.databasePath).size })
-        database.exec('PRAGMA wal_checkpoint(TRUNCATE); VACUUM;')
+      if (upgrade.reclaimSpace) {
+        const free = database.prepare('PRAGMA freelist_count').get() as { freelist_count: number }
+        if (free.freelist_count > 0) {
+          onProgress({ stage: 'compacting', processed: 0, total: 0, bytesBefore: statSync(this.databasePath).size })
+          database.exec('PRAGMA wal_checkpoint(TRUNCATE); VACUUM;')
+        }
       }
       database.exec('PRAGMA wal_checkpoint(TRUNCATE)')
     } finally {

src/main/assistant/assistant-storage-upgrade.test.ts

@@ -9,6 +9,7 @@ import type { ConversationMessageBlock } from '../../shared/assistant-contracts'
 import type { SubagentEvent } from '../../shared/contracts'
 import { AssistantDatabase, ASSISTANT_DATABASE_SCHEMA_VERSION } from './assistant-database'
 import {
+  getPendingAssistantStorageUpgrade,
   hasPendingAssistantStorageUpgrade,
   upgradeAssistantStorage
 } from './assistant-storage-upgrade'
@@ -54,6 +55,58 @@ function subagent(requestId: string): SubagentEvent {
 }
 
 describe('subagent progress storage', () => {
+  it.each([45, 46])('upgrades schema %i without reconverting history or vacuuming ordinary free pages', async (sourceVersion) => {
+    const { path, database, taskId } = await fixture()
+    const event = subagent(randomUUID())
+    event.progress = [{ id: randomUUID(), type: 'text', content: 'Keep current-format progress' }]
+    database.appendTaskEvent(taskId, 'subagent', event)
+    const note = database.createMagicNote({ title: 'Already migrated', content: { version: 1, ops: [{ insert: 'Keep note\n' }] } })
+    const header = { id: randomUUID(), title: 'Keep chat', updatedAt: 1000 }
+    const message = { id: randomUUID(), role: 'assistant' as const, state: 'complete' as const,
+      content: 'Normal chat update'.repeat(100_000), createdAt: 1000 }
+    database.saveLocalConversations([{ header, messages: [message] }])
+    database.saveLocalConversations([{ header, messages: [{ ...message, content: 'Final response' }] }])
+    const expected = database.getConversation(header.id)
+    database.close()
+    const sql = new DatabaseSync(path)
+    try {
+      sql.exec(`DROP VIEW supervision_review_current;
+        DROP TABLE supervision_review_navigation; DROP TABLE supervision_review_batches;
+        DROP TABLE supervision_review_sources; DROP TABLE supervision_review_runs;`)
+      if (sourceVersion === 45) sql.exec(`
+        DROP TRIGGER messages_review_insert; DROP TRIGGER messages_review_update;
+        DROP TRIGGER messages_review_delete; DROP TRIGGER tasks_review_delete;
+        DROP TABLE review_checkpoints; ALTER TABLE messages DROP COLUMN review_revision;`)
+      sql.exec(`PRAGMA user_version = ${sourceVersion}; PRAGMA wal_checkpoint(TRUNCATE)`)
+      expect(sql.prepare('PRAGMA freelist_count').get()!.freelist_count).toBeGreaterThan(0)
+      const events = sql.prepare('SELECT * FROM task_events WHERE task_id = ? ORDER BY id').all(taskId)
+      expect(events.length).toBeGreaterThan(0)
+      expect(hasPendingAssistantStorageUpgrade(path)).toBe(true)
+      const confirmedUpgrade = getPendingAssistantStorageUpgrade(path)!
+      expect(confirmedUpgrade).toEqual({ migrateNotes: false, reclaimSpace: false })
+      const exec = vi.spyOn(DatabaseSync.prototype, 'exec')
+      const progress = vi.fn()
+      upgradeAssistantStorage(path, progress)
+      expect(exec.mock.calls.some(([statement]) => /VACUUM/i.test(statement))).toBe(false)
+      expect(progress.mock.calls.map(([value]) => value.stage)).not.toContain('compacting')
+      expect(progress.mock.calls.map(([value]) => value.stage)).not.toContain('converting')
+      expect(sql.prepare('PRAGMA user_version').get()!.user_version).toBe(ASSISTANT_DATABASE_SCHEMA_VERSION)
+      expect(sql.prepare('SELECT * FROM task_events WHERE task_id = ? ORDER BY id').all(taskId)).toEqual(events)
+      // A retry in the same startup must not gain reclamation just because free pages remain.
+      upgradeAssistantStorage(path, progress, () => false, { confirmedUpgrade })
+      expect(exec.mock.calls.some(([statement]) => /VACUUM/i.test(statement))).toBe(false)
+      database.initialize(dirname(path))
+      expect(database.getConversation(header.id)).toEqual(expected)
+      expect(database.getMagicNote(note.id)).toEqual(note)
+      database.close()
+      progress.mockClear()
+      upgradeAssistantStorage(path, progress)
+      expect(progress).not.toHaveBeenCalled()
+      expect(hasPendingAssistantStorageUpgrade(path)).toBe(false)
+      expect(sql.prepare('PRAGMA integrity_check').get()).toEqual({ integrity_check: 'ok' })
+    } finally { sql.close() }
+  })
+
   it('does not migrate or vacuum ordinary chat free pages on repeated startup', async () => {
     const { path, database } = await fixture()
     const header = { id: randomUUID(), title: 'Chat restart', updatedAt: 1000 }

src/main/assistant/assistant-storage-upgrade.ts

@@ -12,9 +12,14 @@ import {
   SUBAGENT_PROGRESS_STORAGE_SCHEMA_VERSION
 } from './subagent-progress-storage'
 
-export function hasPendingAssistantStorageUpgrade(
+export type AssistantStorageUpgrade = {
+  migrateNotes: boolean
+  reclaimSpace: boolean
+}
+
+export function getPendingAssistantStorageUpgrade(
   databasePath: string
-): boolean {
+): AssistantStorageUpgrade | undefined {
   const database = new DatabaseSync(databasePath, {
     readOnly: true,
     timeout: 5_000
@@ -23,37 +28,50 @@ export function hasPendingAssistantStorageUpgrade(
     const row = database.prepare('PRAGMA user_version').get() as {
       user_version: number
     }
-    if (row.user_version < ASSISTANT_DATABASE_SCHEMA_VERSION) {
-      return true
-    }
     const noteTable = database.prepare(
       `SELECT 1
        FROM sqlite_master
        WHERE type = 'table' AND name = 'magic_note_entries'
        LIMIT 1`
     ).get()
-    if (!noteTable) return false
-    return Boolean(database.prepare(
+    const migrateNotes = Boolean(noteTable && database.prepare(
       `SELECT 1
        FROM magic_note_entries
        WHERE json_extract(content_json, '$.storage') IS NULL
           OR json_extract(content_json, '$.storage') <> 'file'
        LIMIT 1`
     ).get())
+    if (row.user_version >= ASSISTANT_DATABASE_SCHEMA_VERSION && !migrateNotes) return undefined
+    // Reclamation belongs to specific released data conversions, not every schema bump.
+    const legacySubagents = row.user_version > 0 &&
+      row.user_version < SUBAGENT_PROGRESS_STORAGE_SCHEMA_VERSION &&
+      Boolean(database.prepare("SELECT 1 FROM task_events WHERE kind = 'subagent' LIMIT 1").get())
+    const legacyActivity = row.user_version > 0 && row.user_version < 44 &&
+      Boolean(database.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'activity_history'").get()) &&
+      Boolean(database.prepare("SELECT 1 FROM activity_history WHERE records_json <> '[]' LIMIT 1").get())
+    return { migrateNotes, reclaimSpace: migrateNotes || legacySubagents || legacyActivity }
   } finally {
     database.close()
   }
 }
 
+export function hasPendingAssistantStorageUpgrade(databasePath: string): boolean {
+  return getPendingAssistantStorageUpgrade(databasePath) !== undefined
+}
+
 export function upgradeAssistantStorage(
   databasePath: string,
   onProgress: (progress: AssistantStorageProgress) => void,
   isCancelled: () => boolean = () => false,
-  options: { pendingUpgradeConfirmed?: boolean } = {}
+  options: { confirmedUpgrade?: AssistantStorageUpgrade } = {}
 ): void {
-  if (!options.pendingUpgradeConfirmed && !hasPendingAssistantStorageUpgrade(databasePath)) return
+  const upgrade = options.confirmedUpgrade ?? getPendingAssistantStorageUpgrade(databasePath)
+  if (!upgrade) return
+  if (isCancelled()) throw new DOMException('Upgrade cancelled', 'AbortError')
   upgradeSubagentStorage(databasePath, onProgress, isCancelled)
-  new AssistantDatabase(databasePath).upgradeMagicNoteStorage(onProgress, isCancelled)
+  onProgress({ stage: 'upgrading', processed: 0, total: 0, bytesBefore: statSync(databasePath).size })
+  if (isCancelled()) throw new DOMException('Upgrade cancelled', 'AbortError')
+  new AssistantDatabase(databasePath).upgradeStorage(onProgress, isCancelled, upgrade)
 }
 
 function upgradeSubagentStorage(
@@ -137,7 +155,7 @@ function upgradeSubagentStorage(
     const free = database.prepare('PRAGMA freelist_count').get() as {
       freelist_count: number
     }
-    if (free.freelist_count > 0) {
+    if (tasks.length > 0 && free.freelist_count > 0) {
       progress.stage = 'compacting'
       onProgress({ ...progress })
       // Rebuild the now-small live database, not a second copy of the bloated input.