diff --git a/apps/desktop/src/main/ipc/cloud-sync-handlers.ts b/apps/desktop/src/main/ipc/cloud-sync-handlers.ts
index 2864595..7bb494b 100644
--- a/apps/desktop/src/main/ipc/cloud-sync-handlers.ts
+++ b/apps/desktop/src/main/ipc/cloud-sync-handlers.ts
@@ -6,6 +6,9 @@ import { IPC_CHANNELS } from '@d3ro/core/ipc-channels'
 import { ipcSuccess, ipcError, ErrorCode, D3ROError } from '@d3ro/core/errors'
 import { getCloudSyncService } from '../services/CloudSyncService'
 import { getLogger } from '../services/LoggerService'
+import { onConfigChanged } from '../services/ConfigService'
+import { isApplyingRemoteSettings } from '../services/sync/settings-sync'
+import { reapplyThemeToAllPopups } from '../windows/WindowManager'
 
 const logger = getLogger('cloud-sync-handlers')
 
@@ -115,6 +118,13 @@ export function registerCloudSyncHandlers(): void {
     broadcast(IPC_CHANNELS.CLOUD_SYNC.SYNC_ERROR, payload)
   })
   // 다른 기기의 변경이 반영되면 앱 공통 새로고침 신호로 알린다 (이력·사전·회의·명령 화면이 구독).
+  // 동기화가 메인에서 바꾼 설정(언어·테마 등)을 화면에도 알린다 — IPC로 바꿀 때만 방송되던 경로.
+  onConfigChanged((event) => {
+    if (!isApplyingRemoteSettings()) return
+    broadcast(IPC_CHANNELS.CONFIG.CHANGED, event)
+    if (event.key === 'theme') reapplyThemeToAllPopups()
+  })
+
   sync.on('data-changed', (payload) => {
     broadcast(IPC_CHANNELS.APP.DATA_CHANGED, { type: 'cloud-sync', entities: payload.entities })
   })
diff --git a/apps/desktop/src/main/ipc/history-handlers.ts b/apps/desktop/src/main/ipc/history-handlers.ts
index 0142169..4298b01 100644
--- a/apps/desktop/src/main/ipc/history-handlers.ts
+++ b/apps/desktop/src/main/ipc/history-handlers.ts
@@ -3,15 +3,22 @@
 import { ipcMain } from 'electron'
 import { IPC_CHANNELS } from '@d3ro/core/ipc-channels'
 import { ipcSuccess, ipcError, ErrorCode } from '@d3ro/core/errors'
+import fs from 'fs'
 import { getHistoryService } from '../services/HistoryService'
+import { getCloudSyncService } from '../services/CloudSyncService'
+import { audioMimeType } from '../services/sync/audio-sync'
 import type {
   HistoryQueryParams,
   HistoryGetByIdParams,
   HistoryDeleteParams,
   HistorySearchParams,
-  HistorySetFavoriteParams
+  HistorySetFavoriteParams,
+  HistoryAudioSource
 } from '@d3ro/core/types'
 
+/** 렌더러로 넘기는 로컬 녹음 상한. 넘으면 재생하지 않는다(IPC 복사 비용). */
+const MAX_LOCAL_AUDIO_BYTES = 100 * 1024 * 1024
+
 export function registerHistoryHandlers(): void {
   ipcMain.handle(IPC_CHANNELS.HISTORY.GET_ALL, async (_event, params: HistoryQueryParams) => {
     try {
@@ -67,6 +74,27 @@ export function registerHistoryHandlers(): void {
     }
   })
 
+  ipcMain.handle(IPC_CHANNELS.HISTORY.GET_AUDIO, async (_event, params: HistoryGetByIdParams) => {
+    try {
+      const entry = getHistoryService().getById(params.id)
+      if (!entry) return ipcError(ErrorCode.HistoryNotFound, `History entry not found: ${params.id}`)
+      const localPath = entry.audioLocalPath
+      if (localPath && fs.existsSync(localPath) && fs.statSync(localPath).size <= MAX_LOCAL_AUDIO_BYTES) {
+        const source: HistoryAudioSource = {
+          kind: 'local',
+          bytes: new Uint8Array(fs.readFileSync(localPath)),
+          mimeType: audioMimeType(localPath) ?? 'audio/wav',
+        }
+        return ipcSuccess(source)
+      }
+      const url = await getCloudSyncService().createHistoryAudioUrl(params.id)
+      return ipcSuccess(url ? ({ kind: 'remote', url } satisfies HistoryAudioSource) : null)
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      return ipcError(ErrorCode.DBQueryFailed, `Failed to load audio: ${message}`)
+    }
+  })
+
   ipcMain.handle(IPC_CHANNELS.HISTORY.SEARCH, async (_event, params: HistorySearchParams) => {
     try {
       return ipcSuccess(getHistoryService().search(params))
diff --git a/apps/desktop/src/main/services/CloudSyncService.ts b/apps/desktop/src/main/services/CloudSyncService.ts
index 100579e..021b505 100644
--- a/apps/desktop/src/main/services/CloudSyncService.ts
+++ b/apps/desktop/src/main/services/CloudSyncService.ts
@@ -13,7 +13,7 @@ import {
   type RealtimeChannel
 } from '@supabase/supabase-js'
 import { getLogger } from './LoggerService'
-import { configGet, configSet } from './ConfigService'
+import { configGet, configSet, onConfigChanged } from './ConfigService'
 import { SUPABASE_URL, SUPABASE_ANON_KEY } from '@d3ro/core/supabase-config'
 import { openForUser, openLocal, closeCurrent, getCurrentUserId, importLocalModeData } from '../db'
 import { D3ROError, ErrorCode } from '@d3ro/core/errors'
@@ -24,6 +24,8 @@ import { enqueueChange, getSyncState, setSyncState } from './sync/sync-outbox'
 import { checkInDesktopDevice, currentDeviceInfo, unregisterDesktopDevice } from './sync/device-registration'
 import type { SyncEntity, SyncRunResult } from './sync/sync-types'
 import { nodeRealtimeTransport } from './sync/realtime-transport'
+import { SETTINGS_ROW_ID, SYNCED_CONFIG_KEYS, isApplyingRemoteSettings } from './sync/settings-sync'
+import { AUDIO_BUCKET, listLocalAudioOwners } from './sync/audio-sync'
 
 const logger = getLogger('CloudSyncService')
 
@@ -46,6 +48,8 @@ const REALTIME_TABLES = [
   'memo_tags',
   'custom_instructions',
   'user_templates',
+  'knowledge_documents',
+  'user_settings',
   'sync_tombstones',
 ] as const
 
@@ -125,6 +129,23 @@ class CloudSyncService extends EventEmitter {
 
     this._lastSyncAt = (configGet('cloudSyncLastAt') as number | undefined) ?? null
 
+    // 언어·테마·자동 다듬기·활성 명령이 바뀌면 모바일 user_settings 로 올린다(원격 반영 중엔 제외).
+    onConfigChanged((event) => {
+      if (isApplyingRemoteSettings()) return
+      if ((SYNCED_CONFIG_KEYS as readonly string[]).includes(event.key)) {
+        this.pushOne('user_settings', SETTINGS_ROW_ID)
+      }
+      // 녹음 동기화를 켜면 그동안 올리지 않은 녹음을 올린다.
+      if (event.key === 'cloudSyncAudio' && event.value === true && this._engine) {
+        try {
+          for (const id of listLocalAudioOwners('history')) this.pushOne('history_audio', id)
+          for (const id of listLocalAudioOwners('meeting')) this.pushOne('meeting_audio', id)
+        } catch (err) {
+          logger.warn(`Audio re-queue failed: ${err instanceof Error ? err.message : String(err)}`)
+        }
+      }
+    })
+
     // 저장된 refresh token 복원
     const stored = this._loadStoredRefreshToken()
     if (stored) {
@@ -913,6 +934,29 @@ class CloudSyncService extends EventEmitter {
     }
   }
 
+  /**
+   * 다른 기기(모바일·웹)에서 녹음한 기록의 재생 URL(5분 서명). 로컬 파일이 없을 때만 쓴다.
+   * 로그인 전이거나 서버에 녹음이 없으면 null.
+   */
+  async createHistoryAudioUrl(historyId: string): Promise<string | null> {
+    const client = this._client
+    const session = this._session
+    if (!client || !session) return null
+    const { data, error } = await client
+      .from('audio_files')
+      .select('storage_key,upload_status')
+      .eq('user_id', session.user.id)
+      .eq('history_id', historyId)
+      .eq('upload_status', 'uploaded')
+      .order('created_at', { ascending: false })
+      .limit(1)
+      .maybeSingle()
+    if (error || !data || typeof data.storage_key !== 'string') return null
+    if (!data.storage_key.startsWith(`${session.user.id}/`)) return null
+    const signed = await client.storage.from(AUDIO_BUCKET).createSignedUrl(data.storage_key, 300)
+    return signed.error ? null : signed.data.signedUrl
+  }
+
   getSyncStatus(): SyncStatus | null {
     if (!this._engine) return null
     try {
diff --git a/apps/desktop/src/main/services/ConfigService.ts b/apps/desktop/src/main/services/ConfigService.ts
index ab944a4..eac6561 100644
--- a/apps/desktop/src/main/services/ConfigService.ts
+++ b/apps/desktop/src/main/services/ConfigService.ts
@@ -158,6 +158,7 @@ const CONFIG_DEFAULTS: AppConfig = {
   supabaseAnonKey: '',
   cloudSyncLastAt: null,
   deviceInstallationId: null,
+  cloudSyncAudio: true,
   onboardingCompleted: false,
   // Phase 6/10+: AppConfig 키 기본값 (WS2 SSOT 강화 대응).
   // as never 제거 후 configGet이 이 키들을 반환 — 기존 사용자 config(0.1.x)에
diff --git a/apps/desktop/src/main/services/HistoryService.ts b/apps/desktop/src/main/services/HistoryService.ts
index ad0f23f..ec84590 100644
--- a/apps/desktop/src/main/services/HistoryService.ts
+++ b/apps/desktop/src/main/services/HistoryService.ts
@@ -41,6 +41,7 @@ class HistoryService {
 
     // Phase 3.3: 로그인 상태면 자동 push (fire-and-forget, 로컬 write는 차단하지 않음)
     void getCloudSyncService().pushOne('history', id)
+    if (input.audioLocalPath) getCloudSyncService().pushOne('history_audio', id)
 
     // 비동기로 LLM 타이틀 자동 생성 (fire-and-forget)
     this.generateTitle(id).catch(() => { /* ignore */ })
diff --git a/apps/desktop/src/main/services/MeetingModeService.ts b/apps/desktop/src/main/services/MeetingModeService.ts
index 86eaf1b..581cc99 100644
--- a/apps/desktop/src/main/services/MeetingModeService.ts
+++ b/apps/desktop/src/main/services/MeetingModeService.ts
@@ -369,6 +369,7 @@ class MeetingModeService extends EventEmitter {
           if (!fs.existsSync(audioDir)) fs.mkdirSync(audioDir, { recursive: true })
           const wavPath = path.join(audioDir, `${sessionId}.wav`)
           this._saveWav(wavPath, Buffer.concat(this._audioBuffersForFile))
+          getCloudSyncService().pushOne('meeting_audio', sessionId)
           logger.info(`회의 오디오 저장: ${wavPath}`)
         } catch (err) {
           logger.warn(`오디오 저장 실패: ${err instanceof Error ? err.message : String(err)}`)
diff --git a/apps/desktop/src/main/services/RAGService.ts b/apps/desktop/src/main/services/RAGService.ts
index 65f2463..1b7a6d8 100644
--- a/apps/desktop/src/main/services/RAGService.ts
+++ b/apps/desktop/src/main/services/RAGService.ts
@@ -4,13 +4,15 @@
 
 import { EventEmitter } from 'events'
 import path from 'path'
-import { eq } from 'drizzle-orm'
+import fs from 'fs'
+import { asc, eq } from 'drizzle-orm'
 import { getLogger } from './LoggerService'
 import { getPremiumLLMService } from './PremiumLLMService'
 import { getOllamaServerUrl } from './LocalLLMService'
 import { getDatabase } from '../db'
 import { ragDocuments, ragChunks } from '../db/schema'
 import { getMainWindow } from '../windows/WindowManager'
+import { getCloudSyncService } from './CloudSyncService'
 import { IPC_CHANNELS } from '@d3ro/core/ipc-channels'
 import { D3ROError, ErrorCode } from '@d3ro/core/errors'
 import type {
@@ -133,8 +135,12 @@ class RAGService extends EventEmitter {
       addedAt: Date.now(),
     }).run()
 
+    // 청크 원문을 먼저 저장한다 — 임베딩이 실패해도 원문은 남아 재색인·기기 간 동기화가 가능하다.
+    this._storeChunks(docId, chunks)
+    getCloudSyncService().pushOne('knowledge_documents', docId)
+
     // 비동기 인덱싱 (임베딩 생성)
-    this._indexDocument(docId, fileName, chunks).catch((err) => {
+    this._embedStoredChunks(docId, fileName).catch((err) => {
       logger.error(`Indexing failed for ${fileName}:`, err)
     })
 
@@ -154,10 +160,59 @@ class RAGService extends EventEmitter {
    * 문서 제거 (청크 포함)
    */
   removeDocument(documentId: string): void {
+    this.removeRemote(documentId)
+    getCloudSyncService().pushDelete('knowledge_documents', documentId)
+    logger.info(`RAG document removed: ${documentId}`)
+  }
+
+  /** 동기화: 다른 기기에서 지운 문서를 지운다(outbox에 넣지 않는다). */
+  removeRemote(documentId: string): boolean {
     const db = getDatabase()
     db.delete(ragChunks).where(eq(ragChunks.documentId, documentId)).run()
-    db.delete(ragDocuments).where(eq(ragDocuments.id, documentId)).run()
-    logger.info(`RAG document removed: ${documentId}`)
+    return db.delete(ragDocuments).where(eq(ragDocuments.id, documentId)).run().changes > 0
+  }
+
+  /**
+   * 동기화: 다른 기기(모바일·웹)의 지식 문서를 원문 청크로 받아 저장하고, 이 기기의 임베딩 모델로 색인한다.
+   * 임베딩 공간이 기기마다 달라 벡터는 옮기지 않는다. 원본 파일은 없으므로 filePath는 비워 둔다.
+   */
+  applyRemoteDocument(doc: {
+    id: string
+    fileName: string
+    fileType: RAGDocument['fileType']
+    chunks: string[]
+    addedAt: number
+  }): boolean {
+    const db = getDatabase()
+    if (db.select({ id: ragDocuments.id }).from(ragDocuments).where(eq(ragDocuments.id, doc.id)).get()) return false
+    const chunks = doc.chunks.filter((c) => c.trim().length > 0)
+    if (chunks.length === 0) return false
+    db.insert(ragDocuments).values({
+      id: doc.id,
+      fileName: doc.fileName,
+      filePath: '',
+      fileType: doc.fileType,
+      chunkCount: chunks.length,
+      indexed: false,
+      indexedAt: null,
+      addedAt: doc.addedAt,
+    }).run()
+    this._storeChunks(doc.id, chunks)
+    this._embedStoredChunks(doc.id, doc.fileName).catch((err) => {
+      logger.warn(`Synced document ${doc.fileName} is stored but not embedded yet:`, err)
+    })
+    return true
+  }
+
+  /** 저장된 청크 원문(chunkIndex 순) — 동기화 업로드용 */
+  getStoredChunks(documentId: string): string[] {
+    return getDatabase()
+      .select({ content: ragChunks.content })
+      .from(ragChunks)
+      .where(eq(ragChunks.documentId, documentId))
+      .orderBy(asc(ragChunks.chunkIndex))
+      .all()
+      .map((r) => r.content)
   }
 
   /**
@@ -171,8 +226,11 @@ class RAGService extends EventEmitter {
     }
     const doc = rows[0]
 
-    // 기존 청크 삭제
-    db.delete(ragChunks).where(eq(ragChunks.documentId, documentId)).run()
+    // 원본 파일이 없으면(다른 기기에서 동기화된 문서 등) 저장된 원문 청크로 다시 임베딩한다.
+    if (!doc.filePath || !fs.existsSync(doc.filePath)) {
+      await this._embedStoredChunks(documentId, doc.fileName, { force: true })
+      return
+    }
 
     // 텍스트 재추출 + 재인덱싱
     const content = await this._extractText(doc.filePath, doc.fileType as RAGDocument['fileType'])
@@ -183,7 +241,9 @@ class RAGService extends EventEmitter {
       .where(eq(ragDocuments.id, documentId))
       .run()
 
-    await this._indexDocument(documentId, doc.fileName, chunks)
+    this._storeChunks(documentId, chunks)
+    getCloudSyncService().pushOne('knowledge_documents', documentId)
+    await this._embedStoredChunks(documentId, doc.fileName)
   }
 
   /**
@@ -194,7 +254,8 @@ class RAGService extends EventEmitter {
 
     try {
       const db = getDatabase()
-      const allChunks = db.select().from(ragChunks).all()
+      // 원문만 있고 아직 임베딩되지 않은 청크는 검색 대상이 아니다.
+      const allChunks = db.select().from(ragChunks).all().filter((c) => c.embedding.length > 0)
       if (allChunks.length === 0) {
         throw new D3ROError(ErrorCode.RAGQueryFailed, 'No indexed chunks to query')
       }
@@ -245,9 +306,37 @@ ${context}`
 
   // ── 내부 메서드 ──
 
-  private async _indexDocument(docId: string, fileName: string, chunks: string[]): Promise<void> {
+  /** 청크 원문을 (다시) 저장한다. 임베딩은 비워 두고 _embedStoredChunks 가 채운다. */
+  private _storeChunks(docId: string, chunks: string[]): void {
+    const db = getDatabase()
+    db.transaction((tx) => {
+      tx.delete(ragChunks).where(eq(ragChunks.documentId, docId)).run()
+      chunks.forEach((content, index) => {
+        tx.insert(ragChunks).values({
+          id: crypto.randomUUID(),
+          documentId: docId,
+          content,
+          embedding: '',
+          chunkIndex: index,
+        }).run()
+      })
+    })
+  }
+
+  /** 저장된 청크 중 임베딩이 없는 것(force면 전부)을 이 기기의 임베딩 모델로 채운다. */
+  private async _embedStoredChunks(
+    docId: string,
+    fileName: string,
+    options: { force?: boolean } = {}
+  ): Promise<void> {
     this._state = 'indexing'
     const db = getDatabase()
+    const chunks = db
+      .select()
+      .from(ragChunks)
+      .where(eq(ragChunks.documentId, docId))
+      .orderBy(asc(ragChunks.chunkIndex))
+      .all()
 
     logger.info(`RAG indexing started: ${fileName} (${chunks.length} chunks)`)
 
@@ -262,21 +351,21 @@ ${context}`
 
     let successCount = 0
     for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i]
+      if (chunk.embedding.length > 0 && !options.force) {
+        successCount++
+        continue
+      }
       try {
-        const embedding = await this._embed(chunks[i])
-
-        db.insert(ragChunks).values({
-          id: crypto.randomUUID(),
-          documentId: docId,
-          content: chunks[i],
-          embedding: JSON.stringify(embedding),
-          chunkIndex: i,
-        }).run()
-
+        const embedding = await this._embed(chunk.content)
+        db.update(ragChunks)
+          .set({ embedding: JSON.stringify(embedding) })
+          .where(eq(ragChunks.id, chunk.id))
+          .run()
         successCount++
       } catch (err) {
         logger.warn(`RAG embedding failed for chunk ${i}/${chunks.length} of ${fileName}:`, err)
-        // 개별 청크 실패는 건너뛰고 계속 진행
+        // 개별 청크 실패는 건너뛰고 계속 진행 — 원문은 남아 있어 재색인할 수 있다
       }
 
       const progress: RAGIndexProgress = {
@@ -307,9 +396,9 @@ ${context}`
       )
     }
 
-    // 인덱싱 완료 표시
+    // 인덱싱 완료 표시 (chunkCount는 원문 청크 수 — 서버·모바일과 같은 기준)
     db.update(ragDocuments)
-      .set({ indexed: true, indexedAt: Date.now(), chunkCount: successCount })
+      .set({ indexed: true, indexedAt: Date.now(), chunkCount: chunks.length })
       .where(eq(ragDocuments.id, docId))
       .run()
 
diff --git a/apps/desktop/src/main/services/sync/SyncEngine.ts b/apps/desktop/src/main/services/sync/SyncEngine.ts
index dac6cc9..8dd3cb1 100644
--- a/apps/desktop/src/main/services/sync/SyncEngine.ts
+++ b/apps/desktop/src/main/services/sync/SyncEngine.ts
@@ -18,6 +18,8 @@ import {
   pushMemoTagRemovals,
   reconcileMemoTags,
 } from './memo-tag-sync'
+import { fetchRemoteAudioOwners, isAudioSyncEnabled, listLocalAudioOwners, pushAudio } from './audio-sync'
+import { SETTINGS_ROW_ID, applyRemoteSettings, fetchRemoteSettings, pushSettings } from './settings-sync'
 import {
   completeEntry,
   dropEntry,
@@ -215,6 +217,25 @@ export class SyncEngine extends EventEmitter {
         }
       }
     }
+    const ctx: PushContext = { remote: this.remote, userId: this.userId }
+    // 설정: 서버에 행이 없을 때만 로컬 값을 올린다. 있으면 다른 기기의 선택이 우선(pull이 반영).
+    if (!(await fetchRemoteSettings(ctx))) {
+      enqueueChange('user_settings', SETTINGS_ROW_ID, 'upsert', now)
+      queued++
+    }
+    if (isAudioSyncEnabled()) {
+      for (const owner of ['history', 'meeting'] as const) {
+        const local = listLocalAudioOwners(owner)
+        if (local.length === 0) continue
+        const remote = await fetchRemoteAudioOwners(this.remote, this.userId, owner)
+        for (const id of local) {
+          if (!remote.has(id)) {
+            enqueueChange(owner === 'history' ? 'history_audio' : 'meeting_audio', id, 'upsert', now)
+            queued++
+          }
+        }
+      }
+    }
     setSyncState(BACKFILL_FLAG, 'done', now)
     logger.info(`Backfill queued ${queued} local change(s) for ${this.userId}`)
   }
@@ -269,31 +290,51 @@ export class SyncEngine extends EventEmitter {
       'meeting_memos',
       'meeting_documents',
       'custom_instructions',
+      'user_settings',
       'user_templates',
+      'knowledge_documents',
       'memo_tags',
+      'history_audio',
+      'meeting_audio',
     ]
     let networkDown = false
     for (const entity of upsertOrder) {
       const bucket = byEntity.get(entity)
       if (!bucket || bucket.upserts.length === 0 || networkDown) continue
-      const outcomes =
-        entity === 'memo_tags'
-          ? await pushMemoTagAdds(ctx, bucket.upserts.map((e) => e.rowId))
-          : await this.requireAdapter(entity).push(ctx, bucket.upserts.map((e) => e.rowId))
+      const ids = bucket.upserts.map((e) => e.rowId)
+      const outcomes = await this.pushUpserts(ctx, entity, ids)
       networkDown = this.settle(bucket.upserts, outcomes, result, entity)
     }
     // 자식 먼저 delete (서버 cascade가 있어도 순서를 지켜 FK 오류를 피한다)
     for (const entity of [...order].reverse()) {
       const bucket = byEntity.get(entity)
       if (!bucket || bucket.deletes.length === 0 || networkDown) continue
+      const ids = bucket.deletes.map((e) => e.rowId)
       const outcomes =
         entity === 'memo_tags'
-          ? await pushMemoTagRemovals(ctx, bucket.deletes.map((e) => e.rowId))
-          : await this.requireAdapter(entity).pushDeletes(ctx, bucket.deletes.map((e) => e.rowId))
+          ? await pushMemoTagRemovals(ctx, ids)
+          : adapterFor(entity)
+            ? await this.requireAdapter(entity).pushDeletes(ctx, ids)
+            : ids.map((id) => ({ id, error: null }))
       networkDown = this.settle(bucket.deletes, outcomes, result, entity)
     }
   }
 
+  private async pushUpserts(ctx: PushContext, entity: SyncEntity, ids: string[]): Promise<PushOutcome[]> {
+    switch (entity) {
+      case 'memo_tags':
+        return pushMemoTagAdds(ctx, ids)
+      case 'user_settings':
+        return [{ id: SETTINGS_ROW_ID, error: await pushSettings(ctx) }]
+      case 'history_audio':
+        return pushAudio(ctx, 'history', ids)
+      case 'meeting_audio':
+        return pushAudio(ctx, 'meeting', ids)
+      default:
+        return this.requireAdapter(entity).push(ctx, ids)
+    }
+  }
+
   /** outbox를 결과대로 정리. 네트워크 계열 실패가 있었으면 true(이번 flush 중단). */
   private settle(entries: OutboxEntry[], outcomes: PushOutcome[], result: SyncRunResult, entity: SyncEntity): boolean {
     const byId = new Map(outcomes.map((o) => [o.id, o.error]))
@@ -361,6 +402,20 @@ export class SyncEngine extends EventEmitter {
       logger.warn(`Reconcile memo_tags failed: ${message}`)
     }
 
+    try {
+      if (!pendingOps('user_settings').has(SETTINGS_ROW_ID)) {
+        const row = await fetchRemoteSettings({ remote: this.remote, userId: this.userId })
+        if (row && applyRemoteSettings(row)) {
+          changed.add('user_settings')
+          result.pulled++
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err)
+      result.errors.push(`user_settings: ${message}`)
+      logger.warn(`Pull user_settings failed: ${message}`)
+    }
+
     result.changed = [...changed]
     if (result.errors.length === 0) setSyncState('lastPullAt', String(this.now()))
   }
@@ -389,7 +444,7 @@ export class SyncEngine extends EventEmitter {
         const id = typeof row.id === 'string' ? row.id : null
         if (id && !pending.has(id)) {
           try {
-            if (adapter.applyRemote(row)) applied++
+            if (await adapter.applyRemote(row, { remote: this.remote, userId: this.userId })) applied++
           } catch (err) {
             logger.warn(
               `Apply ${adapter.entity}/${id} failed: ${err instanceof Error ? err.message : String(err)}`
diff --git a/apps/desktop/src/main/services/sync/audio-sync.ts b/apps/desktop/src/main/services/sync/audio-sync.ts
new file mode 100644
index 0000000..4214276
--- /dev/null
+++ b/apps/desktop/src/main/services/sync/audio-sync.ts
@@ -0,0 +1,219 @@
+// src/main/services/sync/audio-sync.ts
+// 데스크톱 녹음 파일을 모바일과 같은 저장소 계약(`audio` 버킷, `{userId}/...` 경로, audio_files 행)으로 올린다.
+// 모바일은 audio_files 로 재생 URL을 만들고, 데스크톱은 반대로 모바일 녹음을 재생할 때 서명 URL을 받는다.
+
+import fs from 'fs'
+import path from 'path'
+import { createHash } from 'crypto'
+import { app } from 'electron'
+import { eq, isNotNull } from 'drizzle-orm'
+import { getDatabase } from '../../db'
+import { history, meetingSessions } from '../../db/schema'
+import { configGet } from '../ConfigService'
+import { getLogger } from '../LoggerService'
+import { isUuid, type PushContext } from './sync-adapters'
+import { toSyncRemoteError, type PushOutcome, type RemoteCursor, type SyncRemote } from './sync-types'
+
+const logger = getLogger('AudioSync')
+
+export const AUDIO_BUCKET = 'audio'
+/** Supabase Storage 파일 한도(config.toml storage 50MiB). 넘는 파일은 올리지 않는다. */
+export const MAX_AUDIO_BYTES = 50 * 1024 * 1024
+
+export type AudioOwner = 'history' | 'meeting'
+
+const OWNER_COLUMN: Record<AudioOwner, 'history_id' | 'meeting_id'> = {
+  history: 'history_id',
+  meeting: 'meeting_id',
+}
+
+/** audio 버킷이 허용하는 형식만(서버 allowed_mime_types). 그 밖의 파일은 올리지 않는다. */
+const AUDIO_MIME: Record<string, string> = {
+  '.wav': 'audio/wav',
+  '.webm': 'audio/webm',
+  '.mp3': 'audio/mpeg',
+  '.m4a': 'audio/x-m4a',
+  '.aac': 'audio/aac',
+  '.ogg': 'audio/ogg',
+  '.flac': 'audio/flac',
+  '.mp4': 'video/mp4',
+  '.mov': 'video/quicktime',
+}
+
+export function audioMimeType(filePath: string): string | null {
+  return AUDIO_MIME[path.extname(filePath).toLowerCase()] ?? null
+}
+
+export function audioStorageKey(userId: string, owner: AudioOwner, id: string, extension = '.wav'): string {
+  return `${userId}/desktop/${owner}/${id}${extension.toLowerCase()}`
+}
+
+export function isAudioSyncEnabled(): boolean {
+  return configGet('cloudSyncAudio') !== false
+}
+
+function meetingAudioPath(id: string): string {
+  return path.join(app.getPath('userData'), 'meeting-audio', `${id}.wav`)
+}
+
+/** 로컬 녹음 파일 경로. 파일이 없으면 null */
+export function localAudioPath(owner: AudioOwner, id: string): string | null {
+  let candidate: string | null
+  if (owner === 'history') {
+    const row = getDatabase()
+      .select({ audioLocalPath: history.audioLocalPath })
+      .from(history)
+      .where(eq(history.id, id))
+      .get()
+    candidate = row?.audioLocalPath ?? null
+  } else {
+    candidate = meetingAudioPath(id)
+  }
+  return candidate && fs.existsSync(candidate) ? candidate : null
+}
+
+/** 녹음이 있는 로컬 항목 id (최초 대조용) */
+export function listLocalAudioOwners(owner: AudioOwner): string[] {
+  if (owner === 'history') {
+    return getDatabase()
+      .select({ id: history.id, audioLocalPath: history.audioLocalPath })
+      .from(history)
+      .where(isNotNull(history.audioLocalPath))
+      .all()
+      .filter((r) => isUuid(r.id) && r.audioLocalPath !== null && fs.existsSync(r.audioLocalPath))
+      .map((r) => r.id)
+  }
+  return getDatabase()
+    .select({ id: meetingSessions.id })
+    .from(meetingSessions)
+    .all()
+    .filter((r) => isUuid(r.id) && fs.existsSync(meetingAudioPath(r.id)))
+    .map((r) => r.id)
+}
+
+function durationMs(owner: AudioOwner, id: string): number | null {
+  if (owner === 'history') {
+    const row = getDatabase().select({ duration: history.duration }).from(history).where(eq(history.id, id)).get()
+    return row ? Math.round(row.duration * 1000) : null
+  }
+  const row = getDatabase()
+    .select({ durationMs: meetingSessions.durationMs })
+    .from(meetingSessions)
+    .where(eq(meetingSessions.id, id))
+    .get()
+  return row?.durationMs ?? null
+}
+
+export async function pushAudio(ctx: PushContext, owner: AudioOwner, ids: string[]): Promise<PushOutcome[]> {
+  const outcomes: PushOutcome[] = []
+  const column = OWNER_COLUMN[owner]
+  for (const id of ids) {
+    const filePath = isAudioSyncEnabled() && isUuid(id) ? localAudioPath(owner, id) : null
+    const mimeType = filePath ? audioMimeType(filePath) : null
+    if (!filePath || !mimeType) {
+      outcomes.push({ id, error: null })
+      continue
+    }
+    try {
+      const size = fs.statSync(filePath).size
+      if (size > MAX_AUDIO_BYTES) {
+        logger.info(`Audio ${owner}/${id} is ${size} bytes — over the storage limit, kept local only`)
+        outcomes.push({ id, error: null })
+        continue
+      }
+      const bytes = fs.readFileSync(filePath)
+      const sha256 = createHash('sha256').update(bytes).digest('hex')
+      const existing = await ctx.remote.selectWhere(
+        'audio_files',
+        ctx.userId,
+        [
+          { column, op: 'eq', value: id },
+          { column: 'sha256', op: 'eq', value: sha256 },
+          { column: 'upload_status', op: 'eq', value: 'uploaded' },
+        ],
+        'id'
+      )
+      if (existing.length > 0) {
+        outcomes.push({ id, error: null })
+        continue
+      }
+      const key = audioStorageKey(ctx.userId, owner, id, path.extname(filePath))
+      await ctx.remote.uploadObject(AUDIO_BUCKET, key, new Uint8Array(bytes), mimeType)
+      await ctx.remote.upsert(
+        'audio_files',
+        [
+          {
+            user_id: ctx.userId,
+            [column]: id,
+            source: 'recording',
+            original_name: path.basename(filePath),
+            storage_key: key,
+            mime_type: mimeType,
+            size_bytes: size,
+            duration_ms: durationMs(owner, id),
+            sha256,
+            upload_status: 'uploaded',
+          },
+        ],
+        'user_id,sha256,storage_key'
+      )
+      outcomes.push({ id, error: null })
+    } catch (err) {
+      outcomes.push({ id, error: toSyncRemoteError(err) })
+    }
+  }
+  return outcomes
+}
+
+/** 서버에 이미 올라간 녹음의 주인 id (최초 대조용) */
+export async function fetchRemoteAudioOwners(remote: SyncRemote, userId: string, owner: AudioOwner): Promise<Set<string>> {
+  const column = OWNER_COLUMN[owner]
+  const owners = new Set<string>()
+  let after: RemoteCursor | null = null
+  for (;;) {
+    const page = await remote.fetchPage({
+      table: 'audio_files',
+      userId,
+      cursorColumn: 'updated_at',
+      after,
+      limit: 1000,
+      columns: `id,${column},updated_at`,
+      filters: [{ column: 'upload_status', op: 'eq', value: 'uploaded' }],
+    })
+    for (const row of page) {
+      const value = row[column]
+      if (isUuid(value)) owners.add(value)
+    }
+    if (page.length < 1000) break
+    const last = page[page.length - 1]
+    if (typeof last.updated_at !== 'string' || typeof last.id !== 'string') break
+    after = { ts: last.updated_at, id: last.id }
+  }
+  return owners
+}
+
+/**
+ * 지운 기록·회의의 녹음을 저장소와 audio_files 에서 지운다.
+ * 부모 행이 지워지면 audio_files 는 SET NULL 로 고아가 되므로 부모보다 먼저 지운다. 실패해도 부모 삭제는 진행한다.
+ */
+export async function purgeRemoteAudio(ctx: PushContext, column: 'history_id' | 'meeting_id', ids: string[]): Promise<void> {
+  for (const id of ids.filter(isUuid)) {
+    try {
+      const rows = await ctx.remote.selectWhere(
+        'audio_files',
+        ctx.userId,
+        [{ column, op: 'eq', value: id }],
+        'id,storage_key'
+      )
+      const keys = rows.map((r) => r.storage_key).filter((k): k is string => typeof k === 'string')
+      await ctx.remote.removeObjects(AUDIO_BUCKET, keys)
+      await ctx.remote.deleteByIds(
+        'audio_files',
+        ctx.userId,
+        rows.map((r) => r.id).filter(isUuid)
+      )
+    } catch (err) {
+      logger.warn(`Audio cleanup for ${column}=${id} failed: ${err instanceof Error ? err.message : String(err)}`)
+    }
+  }
+}
diff --git a/apps/desktop/src/main/services/sync/settings-sync.ts b/apps/desktop/src/main/services/sync/settings-sync.ts
new file mode 100644
index 0000000..38eb411
--- /dev/null
+++ b/apps/desktop/src/main/services/sync/settings-sync.ts
@@ -0,0 +1,169 @@
+// src/main/services/sync/settings-sync.ts
+// 모바일 user_settings(한 행, revision 낙관적 동시성)와 데스크톱 설정 중 뜻이 같은 것만 맞춘다.
+//   locale ↔ language (모바일이 받는 ko/en만)
+//   theme_mode ↔ theme (system/light/dark 만 — 데스크톱 전용 테마는 로컬에 둔다)
+//   auto_polish_enabled ↔ defaultLLMAction ('none' 이면 꺼짐)
+//   active_instruction_id ↔ activeInstructionId (양쪽에 있는 사용자 명령일 때만)
+
+import type { LLMActionSelection, ThemeMode } from '@d3ro/core/types'
+import { configGet, configSet } from '../ConfigService'
+import { getCustomInstructionService } from '../CustomInstructionService'
+import { isUuid, type PushContext } from './sync-adapters'
+import { toSyncRemoteError, type RemoteRow, type SyncRemoteError } from './sync-types'
+
+export const SETTINGS_ROW_ID = 'self'
+
+/** 이 키들이 바뀌면 설정 동기화 대상이다 */
+export const SYNCED_CONFIG_KEYS = ['language', 'theme', 'defaultLLMAction', 'activeInstructionId'] as const
+
+const SETTINGS_COLUMNS = 'user_id,locale,theme_mode,auto_polish_enabled,active_instruction_id,revision'
+
+let applyingRemote = false
+
+/** 원격 설정을 반영하는 중인지 — 이 동안의 설정 변경은 다시 올리지 않는다(에코 방지) */
+export function isApplyingRemoteSettings(): boolean {
+  return applyingRemote
+}
+
+export interface LocalSettings {
+  language: string
+  theme: ThemeMode
+  defaultLLMAction: LLMActionSelection
+  activeInstructionId: string
+}
+
+export interface RemoteSettingsPatch {
+  locale?: 'ko' | 'en'
+  theme_mode?: 'system' | 'light' | 'dark'
+  auto_polish_enabled: boolean
+}
+
+export function readLocalSettings(): LocalSettings {
+  return {
+    language: String(configGet('language') ?? 'ko'),
+    theme: (configGet('theme') ?? 'auto') as ThemeMode,
+    defaultLLMAction: (configGet('defaultLLMAction') ?? 'refine') as LLMActionSelection,
+    activeInstructionId: String(configGet('activeInstructionId') ?? ''),
+  }
+}
+
+export function toRemoteSettings(local: LocalSettings): RemoteSettingsPatch {
+  const patch: RemoteSettingsPatch = { auto_polish_enabled: local.defaultLLMAction !== 'none' }
+  if (local.language === 'ko' || local.language === 'en') patch.locale = local.language
+  if (local.theme === 'auto') patch.theme_mode = 'system'
+  else if (local.theme === 'light' || local.theme === 'dark') patch.theme_mode = local.theme
+  return patch
+}
+
+/** 원격 행이 요구하는 로컬 변경만 돌려준다(같으면 빈 객체). */
+export function remoteToLocalPatch(
+  row: RemoteRow,
+  local: LocalSettings,
+  userInstructionIds: ReadonlySet<string>
+): Partial<LocalSettings> {
+  const patch: Partial<LocalSettings> = {}
+  if ((row.locale === 'ko' || row.locale === 'en') && row.locale !== local.language) patch.language = row.locale
+
+  const sharedTheme = local.theme === 'auto' || local.theme === 'light' || local.theme === 'dark'
+  if (sharedTheme) {
+    const theme: ThemeMode | null =
+      row.theme_mode === 'system' ? 'auto' : row.theme_mode === 'light' || row.theme_mode === 'dark' ? row.theme_mode : null
+    if (theme && theme !== local.theme) patch.theme = theme
+  }
+
+  if (row.auto_polish_enabled === false && local.defaultLLMAction !== 'none') patch.defaultLLMAction = 'none'
+  if (row.auto_polish_enabled === true && local.defaultLLMAction === 'none') patch.defaultLLMAction = 'refine'
+
+  const remoteActive = row.active_instruction_id
+  if (isUuid(remoteActive)) {
+    if (userInstructionIds.has(remoteActive) && remoteActive !== local.activeInstructionId) {
+      patch.activeInstructionId = remoteActive
+    }
+  } else if (remoteActive === null && userInstructionIds.has(local.activeInstructionId)) {
+    // 사용자 명령이 해제됐다. 데스크톱 프리셋(builtin-*)이 켜져 있으면 모바일이 알 수 없으므로 둔다.
+    patch.activeInstructionId = ''
+  }
+  return patch
+}
+
+function userInstructionIds(): Set<string> {
+  return new Set(
+    getCustomInstructionService()
+      .getAll()
+      .filter((i) => !i.isBuiltin && isUuid(i.id))
+      .map((i) => i.id)
+  )
+}
+
+export async function fetchRemoteSettings(ctx: PushContext): Promise<RemoteRow | null> {
+  const rows = await ctx.remote.selectWhere('user_settings', ctx.userId, [], SETTINGS_COLUMNS)
+  return rows[0] ?? null
+}
+
+/** 로컬 설정을 올린다. 모바일과 같은 revision 규칙(재조회 → revision 조건부 수정, 최대 3회). */
+export async function pushSettings(ctx: PushContext): Promise<SyncRemoteError | null> {
+  const local = readLocalSettings()
+  const desired = toRemoteSettings(local)
+  try {
+    let remote: RemoteRow | null = null
+    let saved = false
+    for (let attempt = 0; attempt < 3 && !saved; attempt++) {
+      remote = await fetchRemoteSettings(ctx)
+      if (!remote) {
+        try {
+          await ctx.remote.insert('user_settings', [{ user_id: ctx.userId, ...desired }])
+          saved = true
+        } catch (err) {
+          const error = toSyncRemoteError(err)
+          if (error.code !== '23505') throw error
+        }
+        continue
+      }
+      const revision = Number(remote.revision ?? 1)
+      // 이미 같으면 쓰지 않는다 — revision만 올리면 다른 기기에 가짜 변경이 전파된다.
+      const current = remote
+      if ((Object.keys(desired) as Array<keyof RemoteSettingsPatch>).every((k) => current[k] === desired[k])) {
+        saved = true
+        break
+      }
+      const changed = await ctx.remote.updateMatching(
+        'user_settings',
+        ctx.userId,
+        { revision },
+        { ...desired, revision: revision + 1 }
+      )
+      saved = changed > 0
+    }
+    if (!saved) return toSyncRemoteError({ code: '40001', message: 'user_settings changed repeatedly on another device' })
+
+    // 활성 명령: 양쪽에 있는 사용자 명령이거나 '없음'일 때만 올린다(프리셋은 모바일에 없다).
+    const ids = userInstructionIds()
+    const active = local.activeInstructionId
+    const remoteActive = remote?.active_instruction_id ?? null
+    if (active === '' && remoteActive !== null) {
+      await ctx.remote.rpc('set_active_custom_instruction', { instruction_id: null })
+    } else if (ids.has(active) && remoteActive !== active) {
+      await ctx.remote.rpc('set_active_custom_instruction', { instruction_id: active })
+    }
+    return null
+  } catch (err) {
+    return toSyncRemoteError(err)
+  }
+}
+
+/** 원격 설정을 로컬에 반영한다. 바꾼 것이 있으면 true */
+export function applyRemoteSettings(row: RemoteRow): boolean {
+  const patch = remoteToLocalPatch(row, readLocalSettings(), userInstructionIds())
+  const keys = Object.keys(patch) as Array<keyof LocalSettings>
+  if (keys.length === 0) return false
+  applyingRemote = true
+  try {
+    if (patch.language !== undefined) configSet('language', patch.language)
+    if (patch.theme !== undefined) configSet('theme', patch.theme)
+    if (patch.defaultLLMAction !== undefined) configSet('defaultLLMAction', patch.defaultLLMAction)
+    if (patch.activeInstructionId !== undefined) configSet('activeInstructionId', patch.activeInstructionId)
+  } finally {
+    applyingRemote = false
+  }
+  return true
+}
diff --git a/apps/desktop/src/main/services/sync/supabase-sync-remote.ts b/apps/desktop/src/main/services/sync/supabase-sync-remote.ts
index 57c94be..fce6e72 100644
--- a/apps/desktop/src/main/services/sync/supabase-sync-remote.ts
+++ b/apps/desktop/src/main/services/sync/supabase-sync-remote.ts
@@ -76,9 +76,66 @@ export class SupabaseSyncRemote implements SyncRemote {
     return rowsOf(data)
   }
 
-  async upsert(table: string, rows: RemoteRow[]): Promise<void> {
+  async selectChildren(
+    table: string,
+    parentColumn: string,
+    parentId: string,
+    columns: string,
+    orderBy: string
+  ): Promise<RemoteRow[]> {
+    const { data, error } = await this.client
+      .from(table)
+      .select(columns)
+      .eq(parentColumn, parentId)
+      .order(orderBy, { ascending: true })
+    if (error) throw toSyncRemoteError(error)
+    return rowsOf(data)
+  }
+
+  async upsert(table: string, rows: RemoteRow[], onConflict = 'id'): Promise<void> {
     if (rows.length === 0) return
-    const { error } = await this.client.from(table).upsert(rows, { onConflict: 'id' })
+    const { error } = await this.client.from(table).upsert(rows, { onConflict })
+    if (error) throw toSyncRemoteError(error)
+  }
+
+  async insert(table: string, rows: RemoteRow[]): Promise<void> {
+    if (rows.length === 0) return
+    const { error } = await this.client.from(table).insert(rows)
+    if (error) throw toSyncRemoteError(error)
+  }
+
+  async updateMatching(
+    table: string,
+    userId: string,
+    match: Record<string, string | number>,
+    patch: RemoteRow
+  ): Promise<number> {
+    let query = this.client.from(table).update(patch).eq('user_id', userId)
+    for (const [column, value] of Object.entries(match)) query = query.eq(column, value)
+    const { data, error } = await query.select('user_id')
+    if (error) throw toSyncRemoteError(error)
+    return rowsOf(data).length
+  }
+
+  async deleteChildren(table: string, parentColumn: string, parentId: string): Promise<void> {
+    const { error } = await this.client.from(table).delete().eq(parentColumn, parentId)
+    if (error) throw toSyncRemoteError(error)
+  }
+
+  async invokeFunction(name: string, body: Record<string, unknown>): Promise<unknown> {
+    const { data, error } = await this.client.functions.invoke(name, { body })
+    if (error) throw toSyncRemoteError(error)
+    return data
+  }
+
+  async uploadObject(bucket: string, key: string, bytes: Uint8Array, contentType: string): Promise<void> {
+    const { error } = await this.client.storage.from(bucket).upload(key, bytes, { contentType, upsert: true })
+    if (error) throw toSyncRemoteError(error)
+  }
+
+  async removeObjects(bucket: string, keys: string[]): Promise<void> {
+    if (keys.length === 0) return
+    const { error } = await this.client.storage.from(bucket).remove(keys)
     if (error) throw toSyncRemoteError(error)
   }
 
diff --git a/apps/desktop/src/main/services/sync/sync-adapters.ts b/apps/desktop/src/main/services/sync/sync-adapters.ts
index 448c305..57099c2 100644
--- a/apps/desktop/src/main/services/sync/sync-adapters.ts
+++ b/apps/desktop/src/main/services/sync/sync-adapters.ts
@@ -10,11 +10,14 @@ import {
   meetingMemos,
   meetingSessions,
   memoTags,
+  ragDocuments,
 } from '../../db/schema'
 import type { CustomInstruction, DictationTemplate, MeetingDocTemplate, TemplateField } from '@d3ro/core/types'
 import { getCustomInstructionService } from '../CustomInstructionService'
 import { getDictationTemplateService } from '../DictationTemplateService'
 import { getMeetingDocTemplateService } from '../MeetingDocTemplateService'
+import { getRAGService } from '../RAGService'
+import { purgeRemoteAudio } from './audio-sync'
 import { dropEntry } from './sync-outbox'
 import {
   SyncRemoteError,
@@ -43,8 +46,8 @@ export interface SyncAdapter {
   listLocalVersions(): LocalVersion[]
   push(ctx: PushContext, ids: string[]): Promise<PushOutcome[]>
   pushDeletes(ctx: PushContext, ids: string[]): Promise<PushOutcome[]>
-  /** 원격 행을 로컬에 반영. 반영했으면 true */
-  applyRemote(row: RemoteRow): boolean
+  /** 원격 행을 로컬에 반영. 반영했으면 true. 자식 행을 더 읽어야 하는 엔티티는 비동기다 */
+  applyRemote(row: RemoteRow, ctx: PushContext): boolean | Promise<boolean>
   /** 원격 삭제를 로컬에 반영. 지운 행이 있으면 true */
   deleteLocal(id: string): boolean
 }
@@ -209,7 +212,9 @@ const historyAdapter: SyncAdapter = {
     )
     return [...outcomes, ...missingAsDone(ids, found)]
   },
-  pushDeletes(ctx, ids) {
+  async pushDeletes(ctx, ids) {
+    // 지운 기록의 녹음 파일도 저장소에서 지운다(행은 SET NULL로 남아 고아가 된다).
+    await purgeRemoteAudio(ctx, 'history_id', ids)
     return deleteRemote(ctx, 'history', ids)
   },
   applyRemote(row) {
@@ -296,11 +301,9 @@ async function adoptRemoteDictionaryRow(
   const match = matches.find((m) => isUuid(m.id) && m.id !== localId)
   if (!match || !isUuid(match.id)) return error
   const remoteId = match.id
-  db.transaction((tx) => {
-    tx.delete(dictionary).where(eq(dictionary.id, localId)).run()
-  })
+  db.delete(dictionary).where(eq(dictionary.id, localId)).run()
   dropEntry('dictionary', localId)
-  dictionaryAdapter.applyRemote(match)
+  void dictionaryAdapter.applyRemote(match, ctx)
   const merged = db.select().from(dictionary).where(eq(dictionary.id, remoteId)).get()
   if (merged && local.usageCount > merged.usageCount) {
     db.update(dictionary)
@@ -440,7 +443,8 @@ const meetingsAdapter: SyncAdapter = {
     )
     return [...outcomes, ...missingAsDone(ids, found)]
   },
-  pushDeletes(ctx, ids) {
+  async pushDeletes(ctx, ids) {
+    await purgeRemoteAudio(ctx, 'meeting_id', ids)
     return deleteRemote(ctx, 'meetings', ids)
   },
   applyRemote(row) {
@@ -841,6 +845,95 @@ const userTemplatesAdapter: SyncAdapter = {
   },
 }
 
+// ── knowledge_documents ─────────────────────────────────
+// 원문 청크만 옮긴다. 임베딩은 기기마다 모델·차원이 달라(데스크톱 nomic 768 vs 서버 1536) 각자 만든다.
+
+const KNOWLEDGE_TYPES = ['txt', 'md', 'pdf', 'docx'] as const
+const CHUNK_BATCH = 200
+
+async function pushKnowledgeDocument(ctx: PushContext, id: string): Promise<SyncRemoteError | null> {
+  const db = getDatabase()
+  const doc = db.select().from(ragDocuments).where(eq(ragDocuments.id, id)).get()
+  if (!doc) return null
+  const chunks = getRAGService().getStoredChunks(id)
+  if (chunks.length === 0) return null
+  try {
+    await ctx.remote.upsert('knowledge_documents', [
+      {
+        id: doc.id,
+        user_id: ctx.userId,
+        title: doc.fileName.slice(0, 300),
+        file_name: doc.fileName,
+        file_type: doc.fileType,
+        chunk_count: chunks.length,
+        indexed: false,
+        indexed_at: null,
+        created_at: iso(doc.addedAt),
+      },
+    ])
+    await ctx.remote.deleteChildren('knowledge_chunks', 'document_id', doc.id)
+    for (let i = 0; i < chunks.length; i += CHUNK_BATCH) {
+      await ctx.remote.insert(
+        'knowledge_chunks',
+        chunks.slice(i, i + CHUNK_BATCH).map((content, offset) => ({
+          document_id: doc.id,
+          chunk_index: i + offset,
+          content,
+        }))
+      )
+    }
+  } catch (err) {
+    return toSyncRemoteError(err)
+  }
+  // 모바일·웹 검색용 서버 임베딩. 공급자 키가 없거나 한도에 걸려도 원문은 이미 올라갔다 —
+  // 모바일에서 "색인" 을 다시 누를 수 있으므로 여기서 실패로 되돌리지 않는다.
+  try {
+    await ctx.remote.invokeFunction('embed-chunks', { document_id: doc.id })
+  } catch {
+    // 의도적 무시(위 주석)
+  }
+  return null
+}
+
+const knowledgeAdapter: SyncAdapter = {
+  entity: 'knowledge_documents',
+  pull: { columns: 'id,title,file_name,file_type,chunk_count,created_at,updated_at' },
+  listLocalVersions() {
+    return getDatabase()
+      .select({ id: ragDocuments.id, addedAt: ragDocuments.addedAt })
+      .from(ragDocuments)
+      .all()
+      .filter((r) => isUuid(r.id))
+      .map((r) => ({ id: r.id, updatedAt: r.addedAt }))
+  },
+  async push(ctx, ids) {
+    const outcomes: PushOutcome[] = []
+    for (const id of ids) outcomes.push({ id, error: await pushKnowledgeDocument(ctx, id) })
+    return outcomes
+  },
+  pushDeletes(ctx, ids) {
+    return deleteRemote(ctx, 'knowledge_documents', ids)
+  },
+  async applyRemote(row, ctx) {
+    const id = row.id
+    if (!isUuid(id)) return false
+    const exists = getDatabase().select({ id: ragDocuments.id }).from(ragDocuments).where(eq(ragDocuments.id, id)).get()
+    if (exists) return false
+    const chunkRows = await ctx.remote.selectChildren('knowledge_chunks', 'document_id', id, 'chunk_index,content', 'chunk_index')
+    const chunks = chunkRows.map((c) => str(c.content)).filter((c): c is string => c !== null)
+    return getRAGService().applyRemoteDocument({
+      id,
+      fileName: str(row.file_name) ?? str(row.title) ?? 'document',
+      fileType: oneOf(row.file_type, KNOWLEDGE_TYPES) ?? 'txt',
+      chunks,
+      addedAt: ms(row.created_at, Date.now()),
+    })
+  },
+  deleteLocal(id) {
+    return getRAGService().removeRemote(id)
+  },
+}
+
 /** push 순서: 부모(이력·회의)가 자식(태그·메모·문서)보다 먼저. 삭제는 역순. */
 export const TABLE_ADAPTERS: readonly SyncAdapter[] = [
   historyAdapter,
@@ -850,6 +943,7 @@ export const TABLE_ADAPTERS: readonly SyncAdapter[] = [
   meetingDocumentsAdapter,
   customInstructionsAdapter,
   userTemplatesAdapter,
+  knowledgeAdapter,
 ]
 
 export function adapterFor(entity: SyncEntity): SyncAdapter | null {
diff --git a/apps/desktop/src/main/services/sync/sync-types.ts b/apps/desktop/src/main/services/sync/sync-types.ts
index 1b32c17..5b24fa6 100644
--- a/apps/desktop/src/main/services/sync/sync-types.ts
+++ b/apps/desktop/src/main/services/sync/sync-types.ts
@@ -11,6 +11,12 @@ export const SYNC_ENTITIES = [
   'memo_tags',
   'custom_instructions',
   'user_templates',
+  'knowledge_documents',
+  /** 단일 행(row_id 'self'): 언어·테마·자동 다듬기·활성 명령 */
+  'user_settings',
+  /** 녹음 파일 업로드(row_id = history id / meeting id) */
+  'history_audio',
+  'meeting_audio',
 ] as const
 
 export type SyncEntity = (typeof SYNC_ENTITIES)[number]
@@ -54,9 +60,18 @@ export interface RemotePageRequest {
 export interface SyncRemote {
   fetchPage(request: RemotePageRequest): Promise<RemoteRow[]>
   selectWhere(table: string, userId: string, filters: RemoteFilter[], columns?: string): Promise<RemoteRow[]>
-  upsert(table: string, rows: RemoteRow[]): Promise<void>
+  /** user_id 소유 검사가 없는 자식 테이블(knowledge_chunks) 조회 — RLS가 부모 소유로 거른다 */
+  selectChildren(table: string, parentColumn: string, parentId: string, columns: string, orderBy: string): Promise<RemoteRow[]>
+  upsert(table: string, rows: RemoteRow[], onConflict?: string): Promise<void>
+  insert(table: string, rows: RemoteRow[]): Promise<void>
+  /** user_id + match 조건에 맞는 행을 patch로 수정하고 수정된 행 수를 돌려준다(낙관적 동시성용) */
+  updateMatching(table: string, userId: string, match: Record<string, string | number>, patch: RemoteRow): Promise<number>
   deleteByIds(table: string, userId: string, ids: string[]): Promise<void>
+  deleteChildren(table: string, parentColumn: string, parentId: string): Promise<void>
   rpc(name: string, params: Record<string, unknown>): Promise<unknown>
+  invokeFunction(name: string, body: Record<string, unknown>): Promise<unknown>
+  uploadObject(bucket: string, key: string, bytes: Uint8Array, contentType: string): Promise<void>
+  removeObjects(bucket: string, keys: string[]): Promise<void>
 }
 
 export class SyncRemoteError extends Error {
diff --git a/apps/desktop/src/preload/index.ts b/apps/desktop/src/preload/index.ts
index d5dc00f..946133d 100644
--- a/apps/desktop/src/preload/index.ts
+++ b/apps/desktop/src/preload/index.ts
@@ -67,6 +67,7 @@ import type {
   HistoryDeleteParams,
   HistorySearchParams,
   HistorySetFavoriteParams,
+  HistoryAudioSource,
   DictionaryQueryParams,
   DictionaryPage,
   DictionaryEntry,
@@ -411,6 +412,8 @@ const electronAPI = {
     deleteAll: () => invoke<void>(IPC_CHANNELS.HISTORY.DELETE_ALL),
     setFavorite: (params: HistorySetFavoriteParams) =>
       invoke<HistoryEntry>(IPC_CHANNELS.HISTORY.SET_FAVORITE, params),
+    getAudio: (params: HistoryGetByIdParams) =>
+      invoke<HistoryAudioSource | null>(IPC_CHANNELS.HISTORY.GET_AUDIO, params),
     search: (params: HistorySearchParams) =>
       invoke<HistoryPage>(IPC_CHANNELS.HISTORY.SEARCH, params),
     onAdded: (cb: (e: HistoryEntry) => void): Unsubscribe =>
diff --git a/apps/desktop/src/renderer/App.tsx b/apps/desktop/src/renderer/App.tsx
index 897a4ce..8714681 100644
--- a/apps/desktop/src/renderer/App.tsx
+++ b/apps/desktop/src/renderer/App.tsx
@@ -9,7 +9,7 @@
 import { useState, useEffect, useMemo, useRef } from 'react'
 import { ThemeProvider, CssBaseline, useMediaQuery } from '@mui/material'
 import { getTheme } from '@d3ro/ui/theme'
-import { I18nProvider, type I18nStorage, type Locale } from '@d3ro/i18n'
+import { I18nProvider, useI18n, type I18nStorage, type Locale } from '@d3ro/i18n'
 import { AppLayout } from './components/AppLayout'
 import { UpgradePromptModal } from './components/UpgradePromptModal'
 import { startSystemAudioCapture, stopSystemAudioCapture } from './utils/systemAudioCapture'
@@ -26,6 +26,21 @@ const electronI18nStorage: I18nStorage = {
   }
 }
 
+/** 다른 기기(모바일)에서 바꾼 언어가 동기화로 들어오면 화면 언어도 바꾼다. */
+function SyncedLocale(): null {
+  const { locale, setLocale } = useI18n()
+  useEffect(
+    () =>
+      window.electronAPI.config.onChanged((e: ConfigChangedEvent) => {
+        if (e.key === 'language' && typeof e.value === 'string' && e.value !== locale) {
+          setLocale(e.value as Locale)
+        }
+      }),
+    [locale, setLocale],
+  )
+  return null
+}
+
 export function App(): React.ReactElement {
   const [themeMode, setThemeMode] = useState<ThemeMode>('auto')
   const prefersDark = useMediaQuery('(prefers-color-scheme: dark)')
@@ -76,6 +91,7 @@ export function App(): React.ReactElement {
 
   return (
     <I18nProvider storage={electronI18nStorage}>
+      <SyncedLocale />
       <ThemeProvider theme={theme}>
         <CssBaseline />
         <AppLayout />
diff --git a/apps/desktop/src/renderer/components/CloudSyncSection.tsx b/apps/desktop/src/renderer/components/CloudSyncSection.tsx
index caf957f..1da7197 100644
--- a/apps/desktop/src/renderer/components/CloudSyncSection.tsx
+++ b/apps/desktop/src/renderer/components/CloudSyncSection.tsx
@@ -3,7 +3,7 @@
 // 로그인 상태 / 지금 동기화 / 마지막 동기화 / 올릴 변경·거부된 변경 건수
 
 import { useCallback, useEffect, useState } from 'react'
-import { Box, Button, Stack, Alert, CircularProgress } from '@mui/material'
+import { Box, Button, Stack, Alert, CircularProgress, FormControlLabel, Switch } from '@mui/material'
 import { Cloud, CloudCheck, Globe, GitBranch, RefreshCw } from 'lucide-react'
 import { d3roPalette, typoSx } from '@d3ro/ui/theme'
 import { useI18n } from '@d3ro/i18n'
@@ -32,6 +32,7 @@ export function CloudSyncSection(): React.ReactElement {
   const [error, setError] = useState<string | null>(null)
   const [info, setInfo] = useState<string | null>(null)
   const [busy, setBusy] = useState(false)
+  const [audioSync, setAudioSync] = useState(true)
 
   const refreshState = useCallback(async () => {
     const r = await window.electronAPI.cloudSync.getState()
@@ -41,6 +42,9 @@ export function CloudSyncSection(): React.ReactElement {
   // 초기 상태 로드 + 이벤트 구독
   useEffect(() => {
     void refreshState()
+    void window.electronAPI.config.get({ key: 'cloudSyncAudio' }).then((r) => {
+      if (r.success) setAudioSync(r.data !== false)
+    })
 
     const unsubAuth = window.electronAPI.cloudSync.onAuthChanged(() => {
       void refreshState()
@@ -60,6 +64,11 @@ export function CloudSyncSection(): React.ReactElement {
     }
   }, [refreshState])
 
+  function handleAudioSyncChange(enabled: boolean): void {
+    setAudioSync(enabled)
+    void window.electronAPI.config.set({ key: 'cloudSyncAudio', value: enabled })
+  }
+
   async function handleSignIn(provider: 'google' | 'github'): Promise<void> {
     setError(null)
     setBusy(true)
@@ -174,6 +183,16 @@ export function CloudSyncSection(): React.ReactElement {
             )}
           </Stack>
 
+          <Box>
+            <FormControlLabel
+              control={<Switch checked={audioSync} onChange={(e) => handleAudioSyncChange(e.target.checked)} />}
+              label={t('cloudSync.audio')}
+            />
+            <Box sx={{ color: d3roPalette.text.muted, fontSize: 12, lineHeight: 1.6, pl: 0.5 }}>
+              {t('cloudSync.audioDesc')}
+            </Box>
+          </Box>
+
           <Stack direction="row" spacing={1}>
             <Button
               variant="contained"
diff --git a/apps/desktop/src/renderer/components/shared/HistoryEntryCard.tsx b/apps/desktop/src/renderer/components/shared/HistoryEntryCard.tsx
index 45b3f22..346e609 100644
--- a/apps/desktop/src/renderer/components/shared/HistoryEntryCard.tsx
+++ b/apps/desktop/src/renderer/components/shared/HistoryEntryCard.tsx
@@ -1,9 +1,9 @@
 // src/renderer/components/shared/HistoryEntryCard.tsx
 // High-End Agency Dictation History Card with Audio Telemetry & Instant Actions
 
-import React, { useState, useEffect, useCallback } from 'react'
+import React, { useState, useEffect, useCallback, useRef } from 'react'
 import { Box, IconButton, Tooltip, Chip, Collapse } from '@mui/material'
-import { Copy, Check, Trash2, Tag, X, ScrollText, ChevronDown, Sparkles, Volume2, Star } from 'lucide-react'
+import { Copy, Check, Trash2, Tag, X, ScrollText, ChevronDown, Sparkles, Volume2, Star, Play, Square } from 'lucide-react'
 import { MetalCard, Led, TactileBadge } from '@d3ro/ui/components/ds'
 import { d3roPalette, d3roFontSans, d3roFontMono, d3roTypo, d3roRadius, d3roShadow } from '@d3ro/ui/theme'
 import { useI18n } from '@d3ro/i18n'
@@ -40,6 +40,56 @@ export function HistoryEntryCard({
   const [summaryLoading, setSummaryLoading] = useState(false)
   const [copied, setCopied] = useState(false)
   const hasSummary = !!entry.summaryText
+  const [audioState, setAudioState] = useState<'idle' | 'loading' | 'playing' | 'unavailable'>('idle')
+  const audioRef = useRef<HTMLAudioElement | null>(null)
+  const objectUrlRef = useRef<string | null>(null)
+
+  const stopAudio = useCallback((next: 'idle' | 'unavailable' = 'idle') => {
+    audioRef.current?.pause()
+    audioRef.current = null
+    if (objectUrlRef.current) {
+      URL.revokeObjectURL(objectUrlRef.current)
+      objectUrlRef.current = null
+    }
+    setAudioState(next)
+  }, [])
+
+  useEffect(() => () => stopAudio(), [stopAudio])
+
+  // 이 기기 녹음은 파일 바이트로, 모바일·웹 녹음은 서명 URL로 재생한다.
+  const handleToggleAudio = useCallback(
+    async (e: React.MouseEvent) => {
+      e.stopPropagation()
+      if (audioState === 'playing') {
+        stopAudio()
+        return
+      }
+      setAudioState('loading')
+      try {
+        const result = await window.electronAPI.history.getAudio({ id: entry.id })
+        if (!result.success || !result.data) {
+          stopAudio('unavailable')
+          return
+        }
+        let src: string
+        if (result.data.kind === 'local') {
+          src = URL.createObjectURL(new Blob([result.data.bytes.slice()], { type: result.data.mimeType }))
+          objectUrlRef.current = src
+        } else {
+          src = result.data.url
+        }
+        const audio = new Audio(src)
+        audioRef.current = audio
+        audio.onended = () => stopAudio()
+        audio.onerror = () => stopAudio('unavailable')
+        await audio.play()
+        setAudioState('playing')
+      } catch {
+        stopAudio('unavailable')
+      }
+    },
+    [audioState, entry.id, stopAudio],
+  )
 
   const loadTags = useCallback(async () => {
     if (!showTags) return
@@ -163,6 +213,39 @@ export function HistoryEntryCard({
 
             {/* Quick Action Buttons */}
             <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5, flexShrink: 0 }}>
+              {entry.duration > 0 && (
+                <Tooltip
+                  title={
+                    audioState === 'playing'
+                      ? t('history.stopAudio')
+                      : audioState === 'unavailable'
+                        ? t('history.audioUnavailable')
+                        : t('history.playAudio')
+                  }
+                >
+                  <span>
+                    <IconButton
+                      size="small"
+                      aria-label={audioState === 'playing' ? t('history.stopAudio') : t('history.playAudio')}
+                      disabled={audioState === 'loading'}
+                      onClick={(e) => void handleToggleAudio(e)}
+                      sx={{
+                        p: 0.6,
+                        color:
+                          audioState === 'playing'
+                            ? d3roPalette.accent.main
+                            : audioState === 'unavailable'
+                              ? d3roPalette.tag.red
+                              : d3roPalette.text.inactive,
+                        bgcolor: audioState === 'playing' ? d3roPalette.accent.dim : 'transparent',
+                        '&:hover': { color: d3roPalette.text.primary, bgcolor: d3roPalette.glass.raised },
+                      }}
+                    >
+                      {audioState === 'playing' ? <Square size={13} /> : <Play size={14} />}
+                    </IconButton>
+                  </span>
+                </Tooltip>
+              )}
               {onToggleFavorite && (
                 <Tooltip title={entry.isFavorite ? t('history.unfavorite') : t('history.favorite')}>
                   <IconButton
diff --git a/apps/desktop/tests/helpers/fakeSyncRemote.ts b/apps/desktop/tests/helpers/fakeSyncRemote.ts
index 8806739..774f64e 100644
--- a/apps/desktop/tests/helpers/fakeSyncRemote.ts
+++ b/apps/desktop/tests/helpers/fakeSyncRemote.ts
@@ -17,6 +17,9 @@ export class FakeSyncRemote implements SyncRemote {
   private clock = Date.parse('2026-09-27T00:00:00.000Z')
   private tombstoneSeq = 0
   networkDown = false
+  /** 업로드된 저장소 객체: `${bucket}/${key}` → 바이트 */
+  readonly objects = new Map<string, Uint8Array>()
+  readonly invoked: string[] = []
   /** 특정 행 upsert를 거부시키는 훅 (재시도 불가 오류 시뮬레이션) */
   rejectRow: ((table: string, row: RemoteRow) => SyncRemoteError | null) | null = null
   readonly calls: string[] = []
@@ -106,7 +109,71 @@ export class FakeSyncRemote implements SyncRemote {
       .map((r) => ({ ...r }))
   }
 
-  async upsert(table: string, rows: RemoteRow[]): Promise<void> {
+  async selectChildren(
+    table: string,
+    parentColumn: string,
+    parentId: string,
+    _columns: string,
+    orderBy: string
+  ): Promise<RemoteRow[]> {
+    this.guard()
+    return this.rows(table)
+      .filter((r) => r[parentColumn] === parentId)
+      .sort((a, b) => Number(a[orderBy]) - Number(b[orderBy]))
+      .map((r) => ({ ...r }))
+  }
+
+  async insert(table: string, rows: RemoteRow[]): Promise<void> {
+    this.guard()
+    this.calls.push(`insert:${table}:${rows.length}`)
+    for (const row of rows) {
+      if (table === 'user_settings' && this.rows(table).some((r) => r.user_id === row.user_id)) {
+        throw new SyncRemoteError('duplicate key value', '23505', false)
+      }
+      const at = this.now()
+      this.rows(table).push({ id: crypto.randomUUID(), revision: 1, created_at: at, updated_at: at, ...row })
+    }
+  }
+
+  async updateMatching(
+    table: string,
+    userId: string,
+    match: Record<string, string | number>,
+    patch: RemoteRow
+  ): Promise<number> {
+    this.guard()
+    this.calls.push(`update:${table}`)
+    const rows = this.rows(table).filter(
+      (r) => r.user_id === userId && Object.entries(match).every(([k, v]) => r[k] === v)
+    )
+    for (const row of rows) Object.assign(row, patch, { updated_at: this.now() })
+    return rows.length
+  }
+
+  async deleteChildren(table: string, parentColumn: string, parentId: string): Promise<void> {
+    this.guard()
+    const rows = this.rows(table)
+    for (let i = rows.length - 1; i >= 0; i--) if (rows[i][parentColumn] === parentId) rows.splice(i, 1)
+  }
+
+  async invokeFunction(name: string, body: Record<string, unknown>): Promise<unknown> {
+    this.guard()
+    this.invoked.push(`${name}:${String(body.document_id ?? '')}`)
+    return { indexed: true }
+  }
+
+  async uploadObject(bucket: string, key: string, bytes: Uint8Array): Promise<void> {
+    this.guard()
+    if (!key.startsWith(`${this.userId}/`)) throw new SyncRemoteError('row-level security', '42501', false)
+    this.objects.set(`${bucket}/${key}`, bytes)
+  }
+
+  async removeObjects(bucket: string, keys: string[]): Promise<void> {
+    this.guard()
+    for (const key of keys) this.objects.delete(`${bucket}/${key}`)
+  }
+
+  async upsert(table: string, rows: RemoteRow[], onConflict = 'id'): Promise<void> {
     this.guard()
     this.calls.push(`upsert:${table}:${rows.length}`)
     // 배치는 원자적이다: 하나라도 거부되면 전체 실패
@@ -126,15 +193,19 @@ export class FakeSyncRemote implements SyncRemote {
         throw new SyncRemoteError('violates foreign key', '23503', true)
       }
     }
+    const conflictColumns = onConflict.split(',')
     for (const row of rows) {
-      const existing = this.find(table, String(row.id))
+      const existing =
+        onConflict === 'id'
+          ? this.find(table, String(row.id))
+          : this.rows(table).find((r) => conflictColumns.every((c) => r[c] === row[c]))
       if (existing) {
         const changed = Object.keys(row).some((k) => k !== 'updated_at' && existing[k] !== row[k])
         Object.assign(existing, row, { updated_at: this.now() })
         if (table === 'history' && changed) existing.revision = Number(existing.revision ?? 1) + 1
       } else {
         const at = this.now()
-        this.rows(table).push({ revision: 1, created_at: at, ...row, updated_at: row.updated_at ?? at })
+        this.rows(table).push({ id: crypto.randomUUID(), revision: 1, created_at: at, ...row, updated_at: row.updated_at ?? at })
       }
     }
   }
@@ -168,6 +239,10 @@ export class FakeSyncRemote implements SyncRemote {
     if (table === 'history') {
       for (const t of this.rows('memo_tags').filter((r) => r.history_id === id)) this.removeRow('memo_tags', String(t.id))
     }
+    if (table === 'knowledge_documents') {
+      const chunks = this.rows('knowledge_chunks')
+      for (let i = chunks.length - 1; i >= 0; i--) if (chunks[i].document_id === id) chunks.splice(i, 1)
+    }
   }
 
   async rpc(name: string, params: Record<string, unknown>): Promise<unknown> {
@@ -213,6 +288,16 @@ export class FakeSyncRemote implements SyncRemote {
       }
       return this.mobileInsert('user_templates', { id, revision: 1, ...fields })
     }
+    if (name === 'set_active_custom_instruction') {
+      const instructionId = params.instruction_id
+      if (instructionId !== null && !this.find('custom_instructions', String(instructionId))) {
+        throw new SyncRemoteError('instruction_not_found', 'P0002', true)
+      }
+      const row = this.rows('user_settings').find((r) => r.user_id === this.userId)
+      if (row) Object.assign(row, { active_instruction_id: instructionId, revision: Number(row.revision) + 1, updated_at: this.now() })
+      else this.mobileInsert('user_settings', { active_instruction_id: instructionId, revision: 1 })
+      return row
+    }
     if (name === 'sync_delete_user_template_v1') {
       const id = String(params.p_id)
       if (!this.find('user_templates', id)) return false
diff --git a/apps/desktop/tests/integration/cross-device-sync.supabase.test.ts b/apps/desktop/tests/integration/cross-device-sync.supabase.test.ts
index ada74bf..4d519a9 100644
--- a/apps/desktop/tests/integration/cross-device-sync.supabase.test.ts
+++ b/apps/desktop/tests/integration/cross-device-sync.supabase.test.ts
@@ -8,14 +8,18 @@
 //   vitest run tests/integration/cross-device-sync.supabase.test.ts
 // 환경변수가 없으면 건너뛴다(CI 기본).
 
-import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
 import { eq } from 'drizzle-orm'
 import { createClient, type SupabaseClient } from '@supabase/supabase-js'
 import { nodeRealtimeTransport } from '../../src/main/services/sync/realtime-transport'
 import { createTestDb } from '../helpers/createTestDb'
 import { bindTestDatabase, unbindTestDatabase } from '../../src/main/db'
-import { dictionary, history, meetingMemos, meetingSessions, memoTags } from '../../src/main/db/schema'
-import { initInMemoryConfig, resetInMemoryConfig } from '../../src/main/services/ConfigService'
+import { dictionary, history, meetingMemos, meetingSessions, memoTags, ragChunks, ragDocuments } from '../../src/main/db/schema'
+import { configGet, configSet, initInMemoryConfig, resetInMemoryConfig } from '../../src/main/services/ConfigService'
+import { resetRAGServiceForTests } from '../../src/main/services/RAGService'
 import {
   getCustomInstructionService,
   resetCustomInstructionServiceForTests,
@@ -252,6 +256,82 @@ describe.skipIf(!enabled)('cross-device sync against local Supabase', () => {
     expect(seen).toContain('tombstone')
   }, 45_000)
 
+  it('지식 문서(원문 청크)·설정·녹음이 실제 RLS/저장소 정책을 통과해 오간다', async () => {
+    const db = testDb.db
+    resetRAGServiceForTests()
+    // 로컬 임베딩 서버(Ollama)는 없다고 보고 원문 저장 경로만 확인한다(Supabase 호출은 통과시킨다).
+    const realFetch = globalThis.fetch
+    vi.spyOn(globalThis, 'fetch').mockImplementation((input, init) =>
+      String(input instanceof Request ? input.url : input).includes('11434')
+        ? Promise.reject(new TypeError('fetch failed'))
+        : realFetch(input, init)
+    )
+
+    // 데스크톱 지식 문서
+    const docId = crypto.randomUUID()
+    db.insert(ragDocuments).values({ id: docId, fileName: 'desk.md', filePath: '', fileType: 'md', chunkCount: 2, indexed: false, addedAt: Date.now() }).run()
+    ;['alpha chunk', 'beta chunk'].forEach((content, chunkIndex) =>
+      db.insert(ragChunks).values({ id: crypto.randomUUID(), documentId: docId, content, embedding: '', chunkIndex }).run()
+    )
+    enqueueChange('knowledge_documents', docId, 'upsert')
+
+    // 모바일 지식 문서
+    const phoneDoc = crypto.randomUUID()
+    must(await mobile.from('knowledge_documents').insert({ id: phoneDoc, user_id: userId, title: 'Phone doc', file_name: 'phone.txt', file_type: 'txt', chunk_count: 1 }))
+    must(await mobile.from('knowledge_chunks').insert({ document_id: phoneDoc, chunk_index: 0, content: 'from the phone' }))
+
+    // 녹음이 있는 데스크톱 기록
+    const audioDir = fs.mkdtempSync(path.join(os.tmpdir(), 'd3ro-it-audio-'))
+    const audioFile = path.join(audioDir, 'clip.wav')
+    fs.writeFileSync(audioFile, Buffer.from('RIFF----WAVEfmt integration audio bytes'))
+    const clipId = crypto.randomUUID()
+    db.insert(history).values({ id: clipId, originalText: 'with audio', duration: 1, audioLocalPath: audioFile, createdAt: Date.now(), updatedAt: Date.now() }).run()
+    enqueueChange('history', clipId, 'upsert')
+    enqueueChange('history_audio', clipId, 'upsert')
+
+    // 설정: 데스크톱 변경 → 서버, 이후 모바일 변경 → 데스크톱
+    configSet('theme', 'dark')
+    enqueueChange('user_settings', 'self', 'upsert')
+
+    const pushed = await engine.flush()
+    expect(pushed.errors).toEqual([])
+    const remoteChunks = must(await mobile.from('knowledge_chunks').select('content').eq('document_id', docId).order('chunk_index'))
+    expect(remoteChunks.map((c) => c.content)).toEqual(['alpha chunk', 'beta chunk'])
+    const audio = must(await mobile.from('audio_files').select('storage_key,upload_status,mime_type').eq('history_id', clipId))
+    expect(audio).toHaveLength(1)
+    expect(audio[0].upload_status).toBe('uploaded')
+    const signed = await mobile.storage.from('audio').createSignedUrl(String(audio[0].storage_key), 60)
+    expect(signed.error).toBeNull()
+    const settings = must(await mobile.from('user_settings').select('theme_mode,revision').eq('user_id', userId).single())
+    expect(settings.theme_mode).toBe('dark')
+
+    must(
+      await mobile
+        .from('user_settings')
+        .update({ locale: 'en', revision: Number(settings.revision) + 1 })
+        .eq('user_id', userId)
+        .eq('revision', settings.revision)
+    )
+    await engine.pull()
+    expect(configGet('language')).toBe('en')
+    const pulledChunks = db.select().from(ragChunks).where(eq(ragChunks.documentId, phoneDoc)).all()
+    expect(pulledChunks.map((c) => c.content)).toEqual(['from the phone'])
+
+    // 모바일이 지식 문서를 지우면 데스크톱에서도 사라진다(삭제 기록)
+    must(await mobile.from('knowledge_documents').delete().eq('id', phoneDoc))
+    await engine.pull()
+    expect(db.select().from(ragDocuments).where(eq(ragDocuments.id, phoneDoc)).all()).toEqual([])
+
+    // 데스크톱 기록 삭제 → 저장소 녹음도 정리
+    db.delete(history).where(eq(history.id, clipId)).run()
+    enqueueChange('history', clipId, 'delete')
+    const deleted = await engine.flush()
+    expect(deleted.errors).toEqual([])
+    expect(must(await mobile.from('audio_files').select('id').eq('user_id', userId).eq('storage_key', String(audio[0].storage_key)))).toEqual([])
+    fs.rmSync(audioDir, { recursive: true, force: true })
+    vi.restoreAllMocks()
+  }, 60_000)
+
   it('데스크톱이 기기 목록에 나타나고, 모바일에서 해제하면 revoked가 된다', async () => {
     const info = { deviceName: 'IT-DESKTOP', appVersion: '9.9.9', osVersion: 'test' }
     const first = await checkInDesktopDevice(desktop, userId, 'signin', info, null)
diff --git a/apps/desktop/tests/main/sync/SyncExtensions.test.ts b/apps/desktop/tests/main/sync/SyncExtensions.test.ts
new file mode 100644
index 0000000..bd96d6f
--- /dev/null
+++ b/apps/desktop/tests/main/sync/SyncExtensions.test.ts
@@ -0,0 +1,203 @@
+// 동기화 확장 — 지식베이스(원문 청크), 모바일 user_settings, 녹음 파일 업로드.
+
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { eq } from 'drizzle-orm'
+import { createTestDb } from '../../helpers/createTestDb'
+import { FakeSyncRemote } from '../../helpers/fakeSyncRemote'
+import { bindTestDatabase, unbindTestDatabase } from '../../../src/main/db'
+import { history, ragChunks, ragDocuments } from '../../../src/main/db/schema'
+import { configGet, configSet, initInMemoryConfig, resetInMemoryConfig } from '../../../src/main/services/ConfigService'
+import {
+  getCustomInstructionService,
+  resetCustomInstructionServiceForTests,
+} from '../../../src/main/services/CustomInstructionService'
+import { resetDictationTemplateServiceForTests } from '../../../src/main/services/DictationTemplateService'
+import { resetMeetingDocTemplateServiceForTests } from '../../../src/main/services/MeetingDocTemplateService'
+import { resetRAGServiceForTests } from '../../../src/main/services/RAGService'
+import { SyncEngine } from '../../../src/main/services/sync/SyncEngine'
+import { enqueueChange, outboxCounts, pendingOps } from '../../../src/main/services/sync/sync-outbox'
+import { remoteToLocalPatch, toRemoteSettings } from '../../../src/main/services/sync/settings-sync'
+
+const USER = '11111111-1111-4111-8111-111111111111'
+
+let testDb: ReturnType<typeof createTestDb>
+let remote: FakeSyncRemote
+let engine: SyncEngine
+let tmpDir: string
+
+beforeEach(() => {
+  testDb = createTestDb()
+  bindTestDatabase(testDb.db, USER)
+  initInMemoryConfig()
+  resetCustomInstructionServiceForTests()
+  resetDictationTemplateServiceForTests()
+  resetMeetingDocTemplateServiceForTests()
+  resetRAGServiceForTests()
+  getCustomInstructionService().initialize()
+  // 로컬 임베딩 서버(Ollama)는 테스트에 없다 — 즉시 실패시켜 원문만 저장되는 경로를 탄다.
+  vi.spyOn(globalThis, 'fetch').mockRejectedValue(new TypeError('fetch failed'))
+  remote = new FakeSyncRemote(USER)
+  engine = new SyncEngine({ remote, userId: USER })
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'd3ro-sync-audio-'))
+})
+
+afterEach(() => {
+  vi.restoreAllMocks()
+  engine.dispose()
+  unbindTestDatabase()
+  resetInMemoryConfig()
+  testDb.close()
+  fs.rmSync(tmpDir, { recursive: true, force: true })
+})
+
+function insertLocalDocument(chunks: string[]): string {
+  const id = crypto.randomUUID()
+  testDb.db
+    .insert(ragDocuments)
+    .values({ id, fileName: 'notes.md', filePath: '', fileType: 'md', chunkCount: chunks.length, indexed: false, addedAt: Date.now() })
+    .run()
+  chunks.forEach((content, chunkIndex) => {
+    testDb.db.insert(ragChunks).values({ id: crypto.randomUUID(), documentId: id, content, embedding: '', chunkIndex }).run()
+  })
+  return id
+}
+
+describe('지식베이스', () => {
+  it('데스크톱 문서를 원문 청크로 올리고 서버 임베딩을 요청한다', async () => {
+    const id = insertLocalDocument(['first chunk text', 'second chunk text'])
+    const result = await engine.runFullSync()
+    expect(result.errors).toEqual([])
+    expect(remote.find('knowledge_documents', id)?.chunk_count).toBe(2)
+    expect(remote.rows('knowledge_chunks').filter((c) => c.document_id === id).map((c) => c.content)).toEqual([
+      'first chunk text',
+      'second chunk text',
+    ])
+    expect(remote.invoked).toContain(`embed-chunks:${id}`)
+  })
+
+  it('모바일 문서를 받아 원문을 저장하고, 모바일 삭제를 반영한다', async () => {
+    const id = crypto.randomUUID()
+    remote.mobileInsert('knowledge_documents', { id, title: 'Phone doc', file_name: 'phone.txt', file_type: 'txt', chunk_count: 2 })
+    remote.rows('knowledge_chunks').push(
+      { id: crypto.randomUUID(), document_id: id, chunk_index: 1, content: 'second' },
+      { id: crypto.randomUUID(), document_id: id, chunk_index: 0, content: 'first' }
+    )
+    await engine.runFullSync()
+    const doc = testDb.db.select().from(ragDocuments).where(eq(ragDocuments.id, id)).get()
+    expect(doc?.fileName).toBe('phone.txt')
+    expect(doc?.filePath).toBe('')
+    const chunks = testDb.db.select().from(ragChunks).where(eq(ragChunks.documentId, id)).all()
+    expect(chunks.sort((a, b) => a.chunkIndex - b.chunkIndex).map((c) => c.content)).toEqual(['first', 'second'])
+
+    remote.mobileDelete('knowledge_documents', id)
+    await engine.pull()
+    expect(testDb.db.select().from(ragDocuments).all()).toEqual([])
+    expect(testDb.db.select().from(ragChunks).all()).toEqual([])
+  })
+})
+
+describe('설정 (user_settings)', () => {
+  it('서버에 행이 없으면 데스크톱 값을 올린다', async () => {
+    configSet('language', 'en')
+    configSet('theme', 'dark')
+    configSet('defaultLLMAction', 'none')
+    await engine.runFullSync()
+    const row = remote.rows('user_settings')[0]
+    expect(row).toMatchObject({ locale: 'en', theme_mode: 'dark', auto_polish_enabled: false })
+  })
+
+  it('서버에 행이 있으면 모바일 값이 이기고, 반영이 다시 올라가지 않는다', async () => {
+    configSet('language', 'en')
+    configSet('theme', 'auto')
+    configSet('defaultLLMAction', 'none')
+    remote.mobileInsert('user_settings', { locale: 'ko', theme_mode: 'light', auto_polish_enabled: true, revision: 4, active_instruction_id: null })
+    const result = await engine.runFullSync()
+    expect(result.changed).toContain('user_settings')
+    expect(configGet('language')).toBe('ko')
+    expect(configGet('theme')).toBe('light')
+    expect(configGet('defaultLLMAction')).toBe('refine')
+    expect(pendingOps('user_settings').size).toBe(0)
+    expect(remote.rows('user_settings')[0].revision).toBe(4)
+  })
+
+  it('데스크톱 변경은 revision 조건부로 올리고, 같은 값이면 쓰지 않는다', async () => {
+    remote.mobileInsert('user_settings', { locale: 'ko', theme_mode: 'system', auto_polish_enabled: true, revision: 2, active_instruction_id: null })
+    await engine.runFullSync()
+    configSet('theme', 'dark')
+    enqueueChange('user_settings', 'self', 'upsert')
+    await engine.flush()
+    expect(remote.rows('user_settings')[0]).toMatchObject({ theme_mode: 'dark', revision: 3 })
+
+    enqueueChange('user_settings', 'self', 'upsert')
+    await engine.flush()
+    expect(remote.rows('user_settings')[0].revision).toBe(3)
+    expect(outboxCounts().pending).toBe(0)
+  })
+
+  it('양쪽에 있는 사용자 명령만 활성 명령으로 맞춘다', async () => {
+    const command = getCustomInstructionService().create({ name: 'Calm', description: '', prompt: 'Make it calm' })
+    await engine.runFullSync()
+    const row = remote.rows('user_settings')[0]
+    Object.assign(row, { active_instruction_id: command.id, revision: Number(row.revision) + 1 })
+    await engine.pull()
+    expect(configGet('activeInstructionId')).toBe(command.id)
+
+    // 데스크톱 프리셋이 켜져 있으면 모바일의 '없음'이 덮지 않는다
+    const local = { language: 'ko', theme: 'auto' as const, defaultLLMAction: 'refine' as const, activeInstructionId: 'builtin-translate' }
+    expect(remoteToLocalPatch({ active_instruction_id: null }, local, new Set([command.id]))).toEqual({})
+  })
+
+  it('데스크톱 전용 테마·언어는 서버로 보내지 않는다', () => {
+    expect(toRemoteSettings({ language: 'ja', theme: 'nord', defaultLLMAction: 'translate', activeInstructionId: '' })).toEqual({
+      auto_polish_enabled: true,
+    })
+  })
+})
+
+describe('녹음 파일', () => {
+  function insertHistoryWithAudio(): { id: string; file: string } {
+    const id = crypto.randomUUID()
+    const file = path.join(tmpDir, `${id}.wav`)
+    fs.writeFileSync(file, Buffer.from('RIFF....WAVEfmt fake audio'))
+    const now = Date.now()
+    testDb.db.insert(history).values({ id, originalText: 'spoken', duration: 2, audioLocalPath: file, createdAt: now, updatedAt: now }).run()
+    return { id, file }
+  }
+
+  it('기록 녹음을 모바일과 같은 경로·행으로 올리고, 기록을 지우면 파일도 지운다', async () => {
+    const { id } = insertHistoryWithAudio()
+    const result = await engine.runFullSync()
+    expect(result.errors).toEqual([])
+    const key = `${USER}/desktop/history/${id}.wav`
+    expect(remote.objects.has(`audio/${key}`)).toBe(true)
+    expect(remote.rows('audio_files')[0]).toMatchObject({
+      history_id: id,
+      storage_key: key,
+      mime_type: 'audio/wav',
+      upload_status: 'uploaded',
+      duration_ms: 2000,
+    })
+
+    // 같은 파일은 다시 올리지 않는다
+    enqueueChange('history_audio', id, 'upsert')
+    await engine.flush()
+    expect(remote.rows('audio_files')).toHaveLength(1)
+
+    testDb.db.delete(history).where(eq(history.id, id)).run()
+    enqueueChange('history', id, 'delete')
+    await engine.flush()
+    expect(remote.objects.size).toBe(0)
+    expect(remote.rows('audio_files')).toHaveLength(0)
+  })
+
+  it('녹음 동기화를 끄면 올리지 않는다', async () => {
+    configSet('cloudSyncAudio', false)
+    insertHistoryWithAudio()
+    await engine.runFullSync()
+    expect(remote.objects.size).toBe(0)
+    expect(outboxCounts().pending).toBe(0)
+  })
+})
diff --git a/packages/core/src/ipc-channels.ts b/packages/core/src/ipc-channels.ts
index 2eeca49..e8e6af9 100644
--- a/packages/core/src/ipc-channels.ts
+++ b/packages/core/src/ipc-channels.ts
@@ -146,6 +146,8 @@ export const IPC_CHANNELS = {
     DELETE: 'history:delete',
     DELETE_ALL: 'history:deleteAll',
     SET_FAVORITE: 'history:setFavorite',
+    /** 녹음 재생 소스: 로컬 파일 바이트 또는 다른 기기 녹음의 서명 URL */
+    GET_AUDIO: 'history:getAudio',
     SEARCH: 'history:search',
     EXPORT: 'history:export',
     // Main → Renderer events
diff --git a/packages/core/src/types.ts b/packages/core/src/types.ts
index 2f5baa7..413e5cb 100644
--- a/packages/core/src/types.ts
+++ b/packages/core/src/types.ts
@@ -485,6 +485,8 @@ export interface AppConfig {
    * 원격 해제된 id는 재사용할 수 없어(서버 규칙) 재로그인 때 새로 발급한다.
    */
   deviceInstallationId: string | null
+  /** 로그인 시 녹음 파일도 클라우드에 올려 모바일·웹에서 재생 (파일당 50MiB 이하) */
+  cloudSyncAudio: boolean
   /** 빅뱅 Phase 2: 첫 실행 온보딩 완료 여부 (로컬 모드 entry point) */
   onboardingCompleted: boolean
   /** Phase 6: Custom instructions (CustomInstructionService) */
@@ -660,6 +662,11 @@ export interface HistorySetFavoriteParams {
   isFavorite: boolean
 }
 
+/** 녹음 재생 소스. 이 기기에서 녹음했으면 파일 바이트, 모바일·웹 녹음이면 5분짜리 서명 URL */
+export type HistoryAudioSource =
+  | { kind: 'local'; bytes: Uint8Array; mimeType: string }
+  | { kind: 'remote'; url: string }
+
 export interface HistorySearchParams {
   query: string
   page: number
diff --git a/packages/i18n/src/locales/de.json b/packages/i18n/src/locales/de.json
index faf9f58..4c0dcfa 100644
--- a/packages/i18n/src/locales/de.json
+++ b/packages/i18n/src/locales/de.json
@@ -541,5 +541,10 @@
   "cloudSync.browserPending": "Schließe die Anmeldung im Browser ab.",
   "cloudSync.signedOut": "Abgemeldet. Die Einträge auf diesem Computer bleiben erhalten.",
   "cloudSync.done": "Synchronisierung abgeschlossen ({{count}} übernommen)",
-  "cloudSync.doneWithErrors": "Synchronisierung abgeschlossen ({{count}} übernommen, {{errors}} fehlgeschlagen – nächster Lauf versucht es erneut)"
+  "cloudSync.doneWithErrors": "Synchronisierung abgeschlossen ({{count}} übernommen, {{errors}} fehlgeschlagen – nächster Lauf versucht es erneut)",
+  "history.playAudio": "Aufnahme abspielen",
+  "history.stopAudio": "Wiedergabe stoppen",
+  "history.audioUnavailable": "Keine Aufnahme zum Abspielen (Aufnahmen anderer Geräte erst nach deren Synchronisierung)",
+  "cloudSync.audio": "Aufnahmen ebenfalls synchronisieren",
+  "cloudSync.audioDesc": "Lädt Aufnahmen hoch, damit Handy und Web sie abspielen können. Dateien über 50 MB bleiben auf diesem Computer."
 }
diff --git a/packages/i18n/src/locales/en.json b/packages/i18n/src/locales/en.json
index 05742f0..6d6f240 100644
--- a/packages/i18n/src/locales/en.json
+++ b/packages/i18n/src/locales/en.json
@@ -1927,5 +1927,10 @@
   "mobile.devices.platform.ios": "iPhone / iPad",
   "mobile.devices.platform.web": "Web browser",
   "mobile.devices.platform.windows": "Windows desktop app",
-  "mobile.devices.platform.macos": "macOS desktop app"
+  "mobile.devices.platform.macos": "macOS desktop app",
+  "history.playAudio": "Play recording",
+  "history.stopAudio": "Stop playback",
+  "history.audioUnavailable": "No recording to play (recordings from another device play once that device has synced)",
+  "cloudSync.audio": "Sync recordings too",
+  "cloudSync.audioDesc": "Uploads recordings so the phone and web can play them. Files over 50 MB stay on this computer."
 }
diff --git a/packages/i18n/src/locales/es.json b/packages/i18n/src/locales/es.json
index c6c1b9c..a5adeca 100644
--- a/packages/i18n/src/locales/es.json
+++ b/packages/i18n/src/locales/es.json
@@ -541,5 +541,10 @@
   "cloudSync.browserPending": "Termina de iniciar sesión en el navegador.",
   "cloudSync.signedOut": "Sesión cerrada. Los registros de este equipo se conservan.",
   "cloudSync.done": "Sincronización completa ({{count}} aplicados)",
-  "cloudSync.doneWithErrors": "Sincronización completa ({{count}} aplicados, {{errors}} fallidos: se reintentan en la próxima)"
+  "cloudSync.doneWithErrors": "Sincronización completa ({{count}} aplicados, {{errors}} fallidos: se reintentan en la próxima)",
+  "history.playAudio": "Reproducir grabación",
+  "history.stopAudio": "Detener",
+  "history.audioUnavailable": "No hay grabación para reproducir (las de otro dispositivo se reproducen cuando ese dispositivo sincroniza)",
+  "cloudSync.audio": "Sincronizar también las grabaciones",
+  "cloudSync.audioDesc": "Sube las grabaciones para reproducirlas en el móvil y la web. Los archivos de más de 50 MB se quedan en este equipo."
 }
diff --git a/packages/i18n/src/locales/fr.json b/packages/i18n/src/locales/fr.json
index 3f9a511..cacca13 100644
--- a/packages/i18n/src/locales/fr.json
+++ b/packages/i18n/src/locales/fr.json
@@ -541,5 +541,10 @@
   "cloudSync.browserPending": "Terminez la connexion dans votre navigateur.",
   "cloudSync.signedOut": "Déconnecté. Les enregistrements de cet ordinateur sont conservés.",
   "cloudSync.done": "Synchronisation terminée ({{count}} appliqués)",
-  "cloudSync.doneWithErrors": "Synchronisation terminée ({{count}} appliqués, {{errors}} en échec — réessayés à la prochaine)"
+  "cloudSync.doneWithErrors": "Synchronisation terminée ({{count}} appliqués, {{errors}} en échec — réessayés à la prochaine)",
+  "history.playAudio": "Écouter l'enregistrement",
+  "history.stopAudio": "Arrêter la lecture",
+  "history.audioUnavailable": "Aucun enregistrement à lire (ceux d'un autre appareil sont disponibles après sa synchronisation)",
+  "cloudSync.audio": "Synchroniser aussi les enregistrements",
+  "cloudSync.audioDesc": "Envoie les enregistrements pour les écouter sur mobile et sur le web. Les fichiers de plus de 50 Mo restent sur cet ordinateur."
 }
diff --git a/packages/i18n/src/locales/ja.json b/packages/i18n/src/locales/ja.json
index 9b17f5a..2488f31 100644
--- a/packages/i18n/src/locales/ja.json
+++ b/packages/i18n/src/locales/ja.json
@@ -541,5 +541,10 @@
   "cloudSync.browserPending": "ブラウザでログインを完了してください。",
   "cloudSync.signedOut": "ログアウトしました。このコンピューターの記録はそのまま残ります。",
   "cloudSync.done": "同期完了（{{count}} 件反映）",
-  "cloudSync.doneWithErrors": "同期完了（{{count}} 件反映、{{errors}} 件失敗 — 次回の同期で再試行）"
+  "cloudSync.doneWithErrors": "同期完了（{{count}} 件反映、{{errors}} 件失敗 — 次回の同期で再試行）",
+  "history.playAudio": "録音を再生",
+  "history.stopAudio": "再生を停止",
+  "history.audioUnavailable": "再生できる録音がありません（他の端末の録音は、その端末の同期後に再生できます）",
+  "cloudSync.audio": "録音ファイルも同期",
+  "cloudSync.audioDesc": "録音をクラウドにアップロードし、モバイルやウェブで再生できるようにします。50MBを超えるファイルはこのコンピューターにのみ保存されます。"
 }
diff --git a/packages/i18n/src/locales/ko.json b/packages/i18n/src/locales/ko.json
index b444058..e2294a6 100644
--- a/packages/i18n/src/locales/ko.json
+++ b/packages/i18n/src/locales/ko.json
@@ -1934,5 +1934,10 @@
   "mobile.devices.platform.ios": "iPhone·iPad",
   "mobile.devices.platform.web": "웹 브라우저",
   "mobile.devices.platform.windows": "Windows 데스크톱 앱",
-  "mobile.devices.platform.macos": "macOS 데스크톱 앱"
+  "mobile.devices.platform.macos": "macOS 데스크톱 앱",
+  "history.playAudio": "녹음 듣기",
+  "history.stopAudio": "재생 멈춤",
+  "history.audioUnavailable": "들을 수 있는 녹음이 없습니다 (다른 기기 녹음은 그 기기의 동기화가 끝나면 들을 수 있어요)",
+  "cloudSync.audio": "녹음 파일도 동기화",
+  "cloudSync.audioDesc": "녹음을 클라우드에 올려 모바일·웹에서 들을 수 있게 합니다. 50MB를 넘는 파일은 이 컴퓨터에만 둡니다."
 }
diff --git a/packages/i18n/src/locales/pt.json b/packages/i18n/src/locales/pt.json
index 8d1839e..826936f 100644
--- a/packages/i18n/src/locales/pt.json
+++ b/packages/i18n/src/locales/pt.json
@@ -541,5 +541,10 @@
   "cloudSync.browserPending": "Conclua o login no navegador.",
   "cloudSync.signedOut": "Você saiu. Os registros deste computador continuam aqui.",
   "cloudSync.done": "Sincronização concluída ({{count}} aplicados)",
-  "cloudSync.doneWithErrors": "Sincronização concluída ({{count}} aplicados, {{errors}} com falha — tentados de novo na próxima)"
+  "cloudSync.doneWithErrors": "Sincronização concluída ({{count}} aplicados, {{errors}} com falha — tentados de novo na próxima)",
+  "history.playAudio": "Ouvir gravação",
+  "history.stopAudio": "Parar",
+  "history.audioUnavailable": "Nenhuma gravação para ouvir (as de outro dispositivo tocam depois que ele sincroniza)",
+  "cloudSync.audio": "Sincronizar também as gravações",
+  "cloudSync.audioDesc": "Envia as gravações para ouvir no celular e na web. Arquivos acima de 50 MB ficam neste computador."
 }
diff --git a/packages/i18n/src/locales/ru.json b/packages/i18n/src/locales/ru.json
index 95d8d51..88e97d0 100644
--- a/packages/i18n/src/locales/ru.json
+++ b/packages/i18n/src/locales/ru.json
@@ -541,5 +541,10 @@
   "cloudSync.browserPending": "Завершите вход в браузере.",
   "cloudSync.signedOut": "Вы вышли. Записи на этом компьютере сохранены.",
   "cloudSync.done": "Синхронизация завершена (применено: {{count}})",
-  "cloudSync.doneWithErrors": "Синхронизация завершена (применено: {{count}}, ошибок: {{errors}} — повтор при следующей синхронизации)"
+  "cloudSync.doneWithErrors": "Синхронизация завершена (применено: {{count}}, ошибок: {{errors}} — повтор при следующей синхронизации)",
+  "history.playAudio": "Прослушать запись",
+  "history.stopAudio": "Остановить",
+  "history.audioUnavailable": "Нет записи для воспроизведения (записи с другого устройства доступны после его синхронизации)",
+  "cloudSync.audio": "Синхронизировать и записи",
+  "cloudSync.audioDesc": "Загружает записи, чтобы их можно было слушать на телефоне и в вебе. Файлы больше 50 МБ остаются на этом компьютере."
 }
diff --git a/packages/i18n/src/locales/th.json b/packages/i18n/src/locales/th.json
index 3e52924..9048f5e 100644
--- a/packages/i18n/src/locales/th.json
+++ b/packages/i18n/src/locales/th.json
@@ -541,5 +541,10 @@
   "cloudSync.browserPending": "โปรดเข้าสู่ระบบให้เสร็จในเบราว์เซอร์",
   "cloudSync.signedOut": "ออกจากระบบแล้ว ข้อมูลบนคอมพิวเตอร์นี้ยังอยู่ครบ",
   "cloudSync.done": "ซิงก์เสร็จแล้ว ({{count}} รายการ)",
-  "cloudSync.doneWithErrors": "ซิงก์เสร็จแล้ว ({{count}} รายการ, ล้มเหลว {{errors}} — จะลองใหม่รอบหน้า)"
+  "cloudSync.doneWithErrors": "ซิงก์เสร็จแล้ว ({{count}} รายการ, ล้มเหลว {{errors}} — จะลองใหม่รอบหน้า)",
+  "history.playAudio": "เล่นเสียงที่บันทึก",
+  "history.stopAudio": "หยุดเล่น",
+  "history.audioUnavailable": "ไม่มีเสียงให้เล่น (เสียงจากอุปกรณ์อื่นจะเล่นได้หลังอุปกรณ์นั้นซิงก์)",
+  "cloudSync.audio": "ซิงก์ไฟล์เสียงด้วย",
+  "cloudSync.audioDesc": "อัปโหลดไฟล์เสียงเพื่อเล่นบนมือถือและเว็บ ไฟล์ที่ใหญ่กว่า 50MB จะเก็บไว้ในเครื่องนี้เท่านั้น"
 }
diff --git a/packages/i18n/src/locales/vi.json b/packages/i18n/src/locales/vi.json
index bb33f40..d0eab7f 100644
--- a/packages/i18n/src/locales/vi.json
+++ b/packages/i18n/src/locales/vi.json
@@ -541,5 +541,10 @@
   "cloudSync.browserPending": "Hãy hoàn tất đăng nhập trên trình duyệt.",
   "cloudSync.signedOut": "Đã đăng xuất. Dữ liệu trên máy này vẫn được giữ nguyên.",
   "cloudSync.done": "Đồng bộ xong (áp dụng {{count}})",
-  "cloudSync.doneWithErrors": "Đồng bộ xong ({{count}} áp dụng, {{errors}} lỗi — sẽ thử lại lần sau)"
+  "cloudSync.doneWithErrors": "Đồng bộ xong ({{count}} áp dụng, {{errors}} lỗi — sẽ thử lại lần sau)",
+  "history.playAudio": "Phát bản ghi",
+  "history.stopAudio": "Dừng phát",
+  "history.audioUnavailable": "Không có bản ghi để phát (bản ghi từ thiết bị khác phát được sau khi thiết bị đó đồng bộ)",
+  "cloudSync.audio": "Đồng bộ cả bản ghi âm",
+  "cloudSync.audioDesc": "Tải bản ghi lên để nghe trên điện thoại và web. Tệp lớn hơn 50MB chỉ lưu trên máy này."
 }
diff --git a/packages/i18n/src/locales/zh-TW.json b/packages/i18n/src/locales/zh-TW.json
index be1cf36..a72e5a9 100644
--- a/packages/i18n/src/locales/zh-TW.json
+++ b/packages/i18n/src/locales/zh-TW.json
@@ -541,5 +541,10 @@
   "cloudSync.browserPending": "請在瀏覽器中完成登入。",
   "cloudSync.signedOut": "已登出。這台電腦上的紀錄會保留。",
   "cloudSync.done": "同步完成（已套用 {{count}} 項）",
-  "cloudSync.doneWithErrors": "同步完成（已套用 {{count}} 項，{{errors}} 項失敗 — 下次同步時重試）"
+  "cloudSync.doneWithErrors": "同步完成（已套用 {{count}} 項，{{errors}} 項失敗 — 下次同步時重試）",
+  "history.playAudio": "播放錄音",
+  "history.stopAudio": "停止播放",
+  "history.audioUnavailable": "沒有可播放的錄音（其他裝置的錄音需在該裝置同步後才能播放）",
+  "cloudSync.audio": "同時同步錄音",
+  "cloudSync.audioDesc": "將錄音上傳到雲端，讓手機和網頁也能播放。超過 50MB 的檔案只保留在本機。"
 }
diff --git a/packages/i18n/src/locales/zh.json b/packages/i18n/src/locales/zh.json
index 2e1508f..2752c20 100644
--- a/packages/i18n/src/locales/zh.json
+++ b/packages/i18n/src/locales/zh.json
@@ -541,5 +541,10 @@
   "cloudSync.browserPending": "请在浏览器中完成登录。",
   "cloudSync.signedOut": "已退出登录。本机上的记录会保留。",
   "cloudSync.done": "同步完成（已应用 {{count}} 项）",
-  "cloudSync.doneWithErrors": "同步完成（已应用 {{count}} 项，{{errors}} 项失败 — 下次同步时重试）"
+  "cloudSync.doneWithErrors": "同步完成（已应用 {{count}} 项，{{errors}} 项失败 — 下次同步时重试）",
+  "history.playAudio": "播放录音",
+  "history.stopAudio": "停止播放",
+  "history.audioUnavailable": "没有可播放的录音（其他设备的录音需在该设备同步后才能播放）",
+  "cloudSync.audio": "同时同步录音",
+  "cloudSync.audioDesc": "将录音上传到云端，以便在手机和网页上播放。超过 50MB 的文件只保留在本机。"
 }