diff --git a/src/main/index.ts b/src/main/index.ts
index 0cd411e0582..324d7562979 100644
--- a/src/main/index.ts
+++ b/src/main/index.ts
@@ -166,9 +166,9 @@ if (preflightReady) {
         handleMacAppActivation
       })
     } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error)
       const message =
-        formatProfileStateStartupFailure(error) ??
-        `Orca could not finish starting: ${error instanceof Error ? error.message : String(error)}`
+        formatProfileStateStartupFailure(error) ?? `Orca could not finish starting: ${detail}`
       const failureClass = profileStateStartupFailureClass(error)
       if (failureClass !== undefined) {
         recordDurableCrashBreadcrumb('profile_state_startup_failed', {
@@ -225,7 +225,13 @@ if (preflightReady) {
             return
           }
           await presentProfileStateStartupRecoveryDialog({
-            message,
+            message:
+              formatProfileStateStartupFailure(error, translateMain) ??
+              translateMain(
+                'startupFailure.finishFailed',
+                'Orca could not finish starting: {{detail}}',
+                { detail }
+              ),
             ...(failureClass === 'recovery-required' || failureClass === 'ambiguous-authority'
               ? { recoveryCommand: 'orca profile state exports' }
               : {}),
diff --git a/src/main/persistence/profile-state/profile-state-database-publication.ts b/src/main/persistence/profile-state/profile-state-database-publication.ts
index 09399691b88..d58ea038cd9 100644
--- a/src/main/persistence/profile-state/profile-state-database-publication.ts
+++ b/src/main/persistence/profile-state/profile-state-database-publication.ts
@@ -1,20 +1,15 @@
 import { dirname } from 'node:path'
 import { publishFileDurableSync } from '../../durable-file-write'
+import { profileStatePublicationFailureText } from './profile-state-startup-failure'
 
 class ProfileStateDatabasePublicationError extends Error {
   readonly code = 'profile-state-publication-unavailable' as const
+  readonly directory: string
 
   constructor(databaseFile: string, cause: unknown) {
-    super(
-      [
-        `Orca could not safely publish profile state in ${dirname(databaseFile)}.`,
-        'This location must support hard links, and Orca needs permission to create them.',
-        'Close Orca and orcad before checking folder permissions or moving the complete Orca data directory to a writable local filesystem that supports hard links, such as APFS, NTFS, or ext4.',
-        'Keep the original directory and all recovery files.'
-      ].join('\n'),
-      { cause }
-    )
+    super(profileStatePublicationFailureText(dirname(databaseFile)), { cause })
     this.name = 'ProfileStateDatabasePublicationError'
+    this.directory = dirname(databaseFile)
   }
 }
 
diff --git a/src/main/persistence/profile-state/profile-state-startup-failure.ts b/src/main/persistence/profile-state/profile-state-startup-failure.ts
index 0621ce4ee0d..d44f79d900d 100644
--- a/src/main/persistence/profile-state/profile-state-startup-failure.ts
+++ b/src/main/persistence/profile-state/profile-state-startup-failure.ts
@@ -1,4 +1,11 @@
 import { profileStateSectionLabels } from './profile-state-section-labels'
+import type { ProfileStateDialogTranslate } from './profile-state-startup-recovery-dialog'
+
+// Logs keep English; dialogs pass translateMain.
+const english: ProfileStateDialogTranslate = (_key, fallback, options) =>
+  fallback.replace(/\{\{(\w+)\}\}/g, (slot, name: string) =>
+    options && Object.hasOwn(options, name) ? options[name] : slot
+  )
 
 type ProfileStateRecoveryFailure = {
   code: 'profile-state-recovery-required'
@@ -54,70 +61,174 @@ export function isDivergedProfileStateFailure(error: unknown): boolean {
   return isProfileStateAuthorityFailure(error) && error.divergence === 'diverged-json'
 }
 
-export function formatProfileStateStartupFailure(error: unknown): string | undefined {
+export function formatProfileStateStartupFailure(
+  error: unknown,
+  translate: ProfileStateDialogTranslate = english
+): string | undefined {
   if (isProfileStateRecoveryFailure(error)) {
+    const noneFound = `  ${translate('profileState.startupFailure.noneFound', '(none found)')}`
     const retainedBackups = !error.backupPaths?.length
-      ? '  (none found)'
+      ? noneFound
       : error.backupPaths.map((path) => `  ${path}`).join('\n')
     const retainedExports =
       error.exportPaths.length === 0
-        ? '  (none found)'
+        ? noneFound
         : error.exportPaths.map((path) => `  ${path}`).join('\n')
+    const sqlitePath = translate(
+      'profileState.startupFailure.sqlitePath',
+      'SQLite path: {{path}}',
+      { path: error.databaseFile }
+    )
     const damagedSections = repairableSectionDomains(error)
     if (damagedSections !== undefined && typeof error.profileId === 'string') {
       return [
-        `Part of this profile's saved state is damaged: ${profileStateSectionLabels(damagedSections).join(', ')}. Everything else is intact.`,
-        `Stop Orca, then run \`orca profile state rollback --repair --profile-id ${error.profileId}\` to replace only the damaged parts from backups and keep everything else. Orca keeps a copy of the damaged file.`,
-        `SQLite path: ${error.databaseFile}`,
-        'To restore a whole backup instead, run `orca profile state exports`, then `orca profile state rollback --backup <id>`.'
+        translate(
+          'profileState.startupFailure.sectionsDamaged',
+          "Part of this profile's saved state is damaged: {{sections}}. Everything else is intact.",
+          {
+            sections: profileStateSectionLabels(damagedSections, translate).join(', ')
+          }
+        ),
+        translate(
+          'profileState.startupFailure.repairCommand',
+          'Stop Orca, then run `{{command}}` to replace only the damaged parts from backups and keep everything else. Orca keeps a copy of the damaged file.',
+          {
+            command: `orca profile state rollback --repair --profile-id ${error.profileId}`
+          }
+        ),
+        sqlitePath,
+        translate(
+          'profileState.startupFailure.restoreWholeBackup',
+          'To restore a whole backup instead, run `{{exportsCommand}}`, then `{{rollbackCommand}}`.',
+          {
+            exportsCommand: 'orca profile state exports',
+            rollbackCommand: 'orca profile state rollback --backup <id>'
+          }
+        )
       ].join('\n')
     }
     return [
-      'Orca cannot safely open the active profile because its SQLite state is unreadable.',
-      `Legacy JSON path: ${error.dataFile}`,
-      `SQLite path: ${error.databaseFile}`,
-      'Retained SQLite backups:',
+      translate(
+        'profileState.startupFailure.sqliteUnreadable',
+        'Orca cannot safely open the active profile because its SQLite state is unreadable.'
+      ),
+      translate('profileState.startupFailure.legacyJsonPath', 'Legacy JSON path: {{path}}', {
+        path: error.dataFile
+      }),
+      sqlitePath,
+      translate('profileState.startupFailure.retainedBackups', 'Retained SQLite backups:'),
       retainedBackups,
-      'Retained JSON exports:',
+      translate('profileState.startupFailure.retainedExports', 'Retained JSON exports:'),
       retainedExports,
-      'Stop Orca, then run `orca profile state exports` and choose a known-good recovery artifact.',
-      'Restore SQLite with `orca profile state rollback --backup <id>`, or restore a JSON export with',
-      '`orca profile state rollback --revision <revision>`.'
+      translate(
+        'profileState.startupFailure.chooseRecoveryArtifact',
+        'Stop Orca, then run `{{command}}` and choose a known-good recovery artifact.',
+        { command: 'orca profile state exports' }
+      ),
+      translate(
+        'profileState.startupFailure.restoreCommands',
+        'Restore SQLite with `{{backupCommand}}`, or restore a JSON export with `{{revisionCommand}}`.',
+        {
+          backupCommand: 'orca profile state rollback --backup <id>',
+          revisionCommand: 'orca profile state rollback --revision <revision>'
+        }
+      )
     ].join('\n')
   }
 
   if (isProfileStateAuthorityFailure(error)) {
     return [
-      `Orca cannot safely choose a profile-state authority: ${error.message}`,
-      'An older build may have changed the JSON file. Both copies are preserved; neither is selected automatically.',
-      'Stop Orca and copy the profile directory before choosing which state to keep.',
-      'To keep the current JSON, including edits from an older build, run `orca profile state rollback --current-json`. This archives both copies and does not merge their contents.',
-      'Run `orca profile state exports` to inspect retained recovery points.',
-      'Use `orca profile state rollback --backup <id>` or `orca profile state rollback --revision <revision>` only after selecting the state you want to restore.'
+      translate(
+        'profileState.startupFailure.authorityAmbiguous',
+        'Orca cannot safely choose a profile-state authority: {{detail}}',
+        { detail: error.message }
+      ),
+      translate(
+        'profileState.startupFailure.authorityBothPreserved',
+        'An older build may have changed the JSON file. Both copies are preserved; neither is selected automatically.'
+      ),
+      translate(
+        'profileState.startupFailure.authorityCopyFirst',
+        'Stop Orca and copy the profile directory before choosing which state to keep.'
+      ),
+      translate(
+        'profileState.startupFailure.authorityKeepJson',
+        'To keep the current JSON, including edits from an older build, run `{{command}}`. This archives both copies and does not merge their contents.',
+        { command: 'orca profile state rollback --current-json' }
+      ),
+      translate(
+        'profileState.startupFailure.authorityInspect',
+        'Run `{{command}}` to inspect retained recovery points.',
+        { command: 'orca profile state exports' }
+      ),
+      translate(
+        'profileState.startupFailure.authorityRestore',
+        'Use `{{backupCommand}}` or `{{revisionCommand}}` only after selecting the state you want to restore.',
+        {
+          backupCommand: 'orca profile state rollback --backup <id>',
+          revisionCommand: 'orca profile state rollback --revision <revision>'
+        }
+      )
     ].join('\n')
   }
 
   const failureClass = profileStateStartupFailureClass(error)
-  if (
-    failureClass === 'publication-unavailable' &&
-    isRecord(error) &&
-    typeof error.message === 'string'
-  ) {
-    return error.message
+  if (failureClass === 'publication-unavailable' && isRecord(error)) {
+    if (typeof error.directory === 'string') {
+      return profileStatePublicationFailureText(error.directory, translate)
+    }
+    if (typeof error.message === 'string') {
+      return error.message
+    }
   }
   if (failureClass === 'newer-schema') {
-    return 'This profile was saved by a newer version of Orca. Open it with that version or a newer release. Your profile has not been changed.'
+    return translate(
+      'profileState.startupFailure.newerSchema',
+      'This profile was saved by a newer version of Orca. Open it with that version or a newer release. Your profile has not been changed.'
+    )
   }
   if (failureClass === 'revision-conflict') {
-    return 'The active profile changed while Orca was starting. Close other Orca processes using this profile, then restart Orca.'
+    return translate(
+      'profileState.startupFailure.revisionConflict',
+      'The active profile changed while Orca was starting. Close other Orca processes using this profile, then restart Orca.'
+    )
   }
   if (failureClass === 'writer-unavailable') {
-    return 'Orca could not start profile persistence. Restart Orca; if the problem continues, repair or reinstall this build.'
+    return translate(
+      'profileState.startupFailure.writerUnavailable',
+      'Orca could not start profile persistence. Restart Orca; if the problem continues, repair or reinstall this build.'
+    )
   }
 
   return undefined
 }
 
+/** Shared by the error's English message and the localized startup dialog. */
+export function profileStatePublicationFailureText(
+  directory: string,
+  translate: ProfileStateDialogTranslate = english
+): string {
+  return [
+    translate(
+      'profileState.startupFailure.publicationUnavailable',
+      'Orca could not safely publish profile state in {{directory}}.',
+      { directory }
+    ),
+    translate(
+      'profileState.startupFailure.publicationNeedsHardLinks',
+      'This location must support hard links, and Orca needs permission to create them.'
+    ),
+    translate(
+      'profileState.startupFailure.publicationMoveData',
+      'Close Orca and orcad before checking folder permissions or moving the complete Orca data directory to a writable local filesystem that supports hard links, such as APFS, NTFS, or ext4.'
+    ),
+    translate(
+      'profileState.startupFailure.publicationKeepFiles',
+      'Keep the original directory and all recovery files.'
+    )
+  ].join('\n')
+}
+
 function isProfileStateRecoveryFailure(error: unknown): error is ProfileStateRecoveryFailure {
   return (
     isRecord(error) &&
diff --git a/src/main/startup/main-process-preflight-failure.ts b/src/main/startup/main-process-preflight-failure.ts
index 108345c440a..78e6abbeba8 100644
--- a/src/main/startup/main-process-preflight-failure.ts
+++ b/src/main/startup/main-process-preflight-failure.ts
@@ -21,9 +21,6 @@ export function acquireDesktopProfileLockOrExplain(userDataPath: string): boolea
 
 /** Ends a failed preflight without showing a Linux dialog before Electron is ready. */
 export function handleMainProcessPreflightFailure(error: unknown, exitCode = 1): void {
-  const message =
-    formatProfileStateStartupFailure(error) ??
-    (error instanceof Error ? error.message : String(error))
   const shouldShowDialog = !state.isServeMode && !isBackgroundLaunch()
   state.desktopActivationGate = null
   const admission = state.profileStateAdmission
@@ -36,6 +33,10 @@ export function handleMainProcessPreflightFailure(error: unknown, exitCode = 1):
 
   const showDialogAndExit = (): void => {
     try {
+      // Built here so Linux reads the system-language catalog loaded after ready.
+      const message =
+        formatProfileStateStartupFailure(error, translateMain) ??
+        (error instanceof Error ? error.message : String(error))
       dialog.showErrorBox(translateMain('startupFailure.title', 'Orca could not start'), message)
     } catch (dialogError) {
       console.warn('[startup] Could not show startup failure:', dialogError)
diff --git a/src/main/startup/profile-state-startup-failure-localization.test.ts b/src/main/startup/profile-state-startup-failure-localization.test.ts
new file mode 100644
index 00000000000..de4934cadc2
--- /dev/null
+++ b/src/main/startup/profile-state-startup-failure-localization.test.ts
@@ -0,0 +1,37 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import es from '../../renderer/src/i18n/locales/es.json'
+import { UI_LANGUAGE_ENGLISH, UI_LANGUAGE_SPANISH } from '../../shared/ui-language'
+import { setMainUiLanguage, translateMain } from '../i18n/main-i18n'
+import { formatProfileStateStartupFailure } from '../persistence/profile-state/profile-state-startup-failure'
+
+vi.mock('electron', () => ({ app: { getLocale: () => 'en-US' } }))
+
+afterEach(async () => {
+  await setMainUiLanguage(UI_LANGUAGE_ENGLISH)
+})
+
+describe('profile-state startup failure localization', () => {
+  it('reads dialog copy from the active catalog and keeps commands verbatim', async () => {
+    await setMainUiLanguage(UI_LANGUAGE_SPANISH)
+    expect(formatProfileStateStartupFailure({ code: 'newer-schema' }, translateMain)).toBe(
+      es.profileState.startupFailure.newerSchema
+    )
+    const repair = formatProfileStateStartupFailure(
+      {
+        code: 'profile-state-recovery-required',
+        dataFile: '/profile/orca-data.json',
+        databaseFile: '/profile/profile-state.db',
+        exportPaths: [],
+        profileId: 'profile-a',
+        repairableSections: [{ domain: 'settings' }]
+      },
+      translateMain
+    )
+    expect(repair).toContain(es.profileState.section.settings)
+    expect(repair).toContain('`orca profile state rollback --repair --profile-id profile-a`')
+    // Logs and the CLI keep English when no translator is passed.
+    expect(formatProfileStateStartupFailure({ code: 'newer-schema' })).toContain(
+      'newer version of Orca'
+    )
+  })
+})
diff --git a/src/main/startup/windows-install-dir-acl-recovery.ts b/src/main/startup/windows-install-dir-acl-recovery.ts
index 5d85b4ed835..5c25087ac77 100644
--- a/src/main/startup/windows-install-dir-acl-recovery.ts
+++ b/src/main/startup/windows-install-dir-acl-recovery.ts
@@ -1,5 +1,6 @@
 import { dirname } from 'node:path'
 import type { CrashReportBreadcrumbData } from '../../shared/crash-reporting'
+import { translateMain } from '../i18n/main-i18n'
 import { logStartupMilestone } from './startup-diagnostics'
 import {
   clearGpuFallbackMarker,
@@ -255,24 +256,35 @@ export async function repairKnownPoisonedInstallDirBeforeWindow(
   }
 }
 
-const CAUSE =
-  "Windows permissions on Orca's install folder are blocking its own sandboxed processes from reading the files it shipped with."
-
 // The blank-window recovery dialog is the only place to deliver exact admin commands.
 export function describeInstallDirAclPoison(): InstallDirAclPoisonDiagnosis | null {
   if (!poison) {
     return null
   }
   const commands = buildInstallDirAclRepairCommands(poison.installDir)
+  const cause = translateMain(
+    'installDirAcl.cause',
+    "Windows permissions on Orca's install folder are blocking its own sandboxed processes from reading the files it shipped with."
+  )
   if (poison.stage === 'repaired') {
-    return { detail: `${CAUSE}\n\nOrca repaired the permissions. Reload to use them.`, commands }
+    return {
+      detail: `${cause}\n\n${translateMain('installDirAcl.repaired', 'Orca repaired the permissions. Reload to use them.')}`,
+      commands
+    }
   }
   const status =
     poison.stage === 'pending'
-      ? 'Orca is repairing the permissions now.'
-      : 'Orca could not repair them, which usually means the folder needs an administrator.'
+      ? translateMain('installDirAcl.repairing', 'Orca is repairing the permissions now.')
+      : translateMain(
+          'installDirAcl.repairFailed',
+          'Orca could not repair them, which usually means the folder needs an administrator.'
+        )
+  const runCommands = translateMain(
+    'installDirAcl.runCommands',
+    'Run these in an Administrator Command Prompt, then relaunch Orca:'
+  )
   return {
-    detail: `${CAUSE} ${status}\n\nRun these in an Administrator Command Prompt, then relaunch Orca:\n\n${commands.join('\n')}`,
+    detail: `${cause} ${status}\n\n${runCommands}\n\n${commands.join('\n')}`,
     commands
   }
 }
diff --git a/src/renderer/src/i18n/locales/de.json b/src/renderer/src/i18n/locales/de.json
index a020b2b3763..85e9cf4f810 100644
--- a/src/renderer/src/i18n/locales/de.json
+++ b/src/renderer/src/i18n/locales/de.json
@@ -21723,10 +21723,37 @@
       "automationHistory": "Automatisierungsverlauf",
       "onboarding": "Einrichtungsfortschritt",
       "other": "Sonstiger gespeicherter App-Zustand"
+    },
+    "startupFailure": {
+      "noneFound": "(keine gefunden)",
+      "sqlitePath": "SQLite-Pfad: {{path}}",
+      "sectionsDamaged": "Ein Teil des gespeicherten Zustands dieses Profils ist beschädigt: {{sections}}. Alles andere ist intakt.",
+      "repairCommand": "Orca beenden und dann `{{command}}` ausführen, um nur die beschädigten Teile aus Sicherungskopien zu ersetzen und alles andere beizubehalten. Orca bewahrt eine Kopie der beschädigten Datei auf.",
+      "restoreWholeBackup": "Um stattdessen eine vollständige Sicherungskopie wiederherzustellen, zuerst `{{exportsCommand}}` und dann `{{rollbackCommand}}` ausführen.",
+      "sqliteUnreadable": "Orca kann das aktive Profil nicht sicher öffnen, da sein SQLite-Zustand nicht lesbar ist.",
+      "legacyJsonPath": "Pfad der alten JSON-Datei: {{path}}",
+      "retainedBackups": "Aufbewahrte SQLite-Sicherungskopien:",
+      "retainedExports": "Aufbewahrte JSON-Exporte:",
+      "chooseRecoveryArtifact": "Orca beenden, dann `{{command}}` ausführen und einen nachweislich intakten Wiederherstellungsstand auswählen.",
+      "restoreCommands": "SQLite mit `{{backupCommand}}` oder einen JSON-Export mit `{{revisionCommand}}` wiederherstellen.",
+      "authorityAmbiguous": "Orca kann nicht sicher bestimmen, welcher Profilzustand maßgeblich ist: {{detail}}",
+      "authorityBothPreserved": "Ein älterer Build könnte die JSON-Datei geändert haben. Beide Kopien bleiben erhalten; keine wird automatisch ausgewählt.",
+      "authorityCopyFirst": "Orca beenden und das Profilverzeichnis kopieren, bevor ausgewählt wird, welcher Zustand beibehalten werden soll.",
+      "authorityKeepJson": "Um die aktuelle JSON-Datei einschließlich der Änderungen aus einem älteren Build beizubehalten, `{{command}}` ausführen. Dabei werden beide Kopien archiviert, ohne ihre Inhalte zusammenzuführen.",
+      "authorityInspect": "`{{command}}` ausführen, um die aufbewahrten Wiederherstellungspunkte zu prüfen.",
+      "authorityRestore": "`{{backupCommand}}` oder `{{revisionCommand}}` erst verwenden, nachdem der wiederherzustellende Zustand ausgewählt wurde.",
+      "newerSchema": "Dieses Profil wurde mit einer neueren Version von Orca gespeichert. Mit dieser oder einer noch neueren Version öffnen. Das Profil wurde nicht verändert.",
+      "revisionConflict": "Das aktive Profil wurde während des Starts von Orca geändert. Andere Orca-Prozesse schließen, die dieses Profil verwenden, und Orca dann neu starten.",
+      "writerUnavailable": "Orca konnte die Profilspeicherung nicht starten. Orca neu starten; falls das Problem weiterhin besteht, diesen Build reparieren oder neu installieren.",
+      "publicationUnavailable": "Orca konnte den Profilzustand nicht sicher in {{directory}} speichern.",
+      "publicationNeedsHardLinks": "Dieser Speicherort muss Hardlinks unterstützen, und Orca benötigt die Berechtigung, sie zu erstellen.",
+      "publicationMoveData": "Orca und orcad schließen, bevor die Ordnerberechtigungen geprüft werden oder das gesamte Orca-Datenverzeichnis auf ein beschreibbares lokales Dateisystem mit Hardlink-Unterstützung wie APFS, NTFS oder ext4 verschoben wird.",
+      "publicationKeepFiles": "Das ursprüngliche Verzeichnis und alle Wiederherstellungsdateien aufbewahren."
     }
   },
   "startupFailure": {
-    "title": "Orca konnte nicht gestartet werden"
+    "title": "Orca konnte nicht gestartet werden",
+    "finishFailed": "Orca konnte den Start nicht abschließen: {{detail}}"
   },
   "native": {
     "about": {
@@ -22192,5 +22219,12 @@
       "recipeExitedWithoutCode": "Rezept wurde mit unbekanntem Code beendet.",
       "destroyExitedWithoutCode": "Löschen wurde mit unbekanntem Code beendet."
     }
+  },
+  "installDirAcl": {
+    "cause": "Die Windows-Berechtigungen für den Installationsordner von Orca hindern dessen eigene Sandbox-Prozesse daran, die mitgelieferten Dateien zu lesen.",
+    "repaired": "Orca hat die Berechtigungen repariert. Neu laden, um sie anzuwenden.",
+    "repairing": "Orca repariert gerade die Berechtigungen.",
+    "repairFailed": "Orca konnte sie nicht reparieren. Meist sind für den Ordner Administratorrechte erforderlich.",
+    "runCommands": "Diese Befehle in einer Eingabeaufforderung mit Administratorrechten ausführen und Orca anschließend erneut starten:"
   }
 }
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index a82016a76bf..1cf0c172d66 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -22140,10 +22140,37 @@
       "automationHistory": "Automation history",
       "onboarding": "Onboarding progress",
       "other": "Other saved app state"
+    },
+    "startupFailure": {
+      "noneFound": "(none found)",
+      "sqlitePath": "SQLite path: {{path}}",
+      "sectionsDamaged": "Part of this profile's saved state is damaged: {{sections}}. Everything else is intact.",
+      "repairCommand": "Stop Orca, then run `{{command}}` to replace only the damaged parts from backups and keep everything else. Orca keeps a copy of the damaged file.",
+      "restoreWholeBackup": "To restore a whole backup instead, run `{{exportsCommand}}`, then `{{rollbackCommand}}`.",
+      "sqliteUnreadable": "Orca cannot safely open the active profile because its SQLite state is unreadable.",
+      "legacyJsonPath": "Legacy JSON path: {{path}}",
+      "retainedBackups": "Retained SQLite backups:",
+      "retainedExports": "Retained JSON exports:",
+      "chooseRecoveryArtifact": "Stop Orca, then run `{{command}}` and choose a known-good recovery artifact.",
+      "restoreCommands": "Restore SQLite with `{{backupCommand}}`, or restore a JSON export with `{{revisionCommand}}`.",
+      "authorityAmbiguous": "Orca cannot safely choose a profile-state authority: {{detail}}",
+      "authorityBothPreserved": "An older build may have changed the JSON file. Both copies are preserved; neither is selected automatically.",
+      "authorityCopyFirst": "Stop Orca and copy the profile directory before choosing which state to keep.",
+      "authorityKeepJson": "To keep the current JSON, including edits from an older build, run `{{command}}`. This archives both copies and does not merge their contents.",
+      "authorityInspect": "Run `{{command}}` to inspect retained recovery points.",
+      "authorityRestore": "Use `{{backupCommand}}` or `{{revisionCommand}}` only after selecting the state you want to restore.",
+      "newerSchema": "This profile was saved by a newer version of Orca. Open it with that version or a newer release. Your profile has not been changed.",
+      "revisionConflict": "The active profile changed while Orca was starting. Close other Orca processes using this profile, then restart Orca.",
+      "writerUnavailable": "Orca could not start profile persistence. Restart Orca; if the problem continues, repair or reinstall this build.",
+      "publicationUnavailable": "Orca could not safely publish profile state in {{directory}}.",
+      "publicationNeedsHardLinks": "This location must support hard links, and Orca needs permission to create them.",
+      "publicationMoveData": "Close Orca and orcad before checking folder permissions or moving the complete Orca data directory to a writable local filesystem that supports hard links, such as APFS, NTFS, or ext4.",
+      "publicationKeepFiles": "Keep the original directory and all recovery files."
     }
   },
   "startupFailure": {
-    "title": "Orca could not start"
+    "title": "Orca could not start",
+    "finishFailed": "Orca could not finish starting: {{detail}}"
   },
   "wslDriveProject": {
     "label": "Git",
@@ -22652,5 +22679,12 @@
       "recipeExitedWithoutCode": "Recipe exited with code unknown.",
       "destroyExitedWithoutCode": "Destroy exited with code unknown."
     }
+  },
+  "installDirAcl": {
+    "cause": "Windows permissions on Orca's install folder are blocking its own sandboxed processes from reading the files it shipped with.",
+    "repaired": "Orca repaired the permissions. Reload to use them.",
+    "repairing": "Orca is repairing the permissions now.",
+    "repairFailed": "Orca could not repair them, which usually means the folder needs an administrator.",
+    "runCommands": "Run these in an Administrator Command Prompt, then relaunch Orca:"
   }
 }
diff --git a/src/renderer/src/i18n/locales/es.json b/src/renderer/src/i18n/locales/es.json
index 525fbbd1ead..ace00274096 100644
--- a/src/renderer/src/i18n/locales/es.json
+++ b/src/renderer/src/i18n/locales/es.json
@@ -22105,10 +22105,37 @@
       "automationHistory": "Historial de automatizaciones",
       "onboarding": "Progreso del onboarding",
       "other": "Otro estado guardado de la app"
+    },
+    "startupFailure": {
+      "noneFound": "(no se encontró ninguna)",
+      "sqlitePath": "Ruta de SQLite: {{path}}",
+      "sectionsDamaged": "Parte del estado guardado de este perfil está dañada: {{sections}}. Todo lo demás está intacto.",
+      "repairCommand": "Cierra Orca y ejecuta `{{command}}` para reemplazar solo las partes dañadas desde copias de seguridad y conservar todo lo demás. Orca guarda una copia del archivo dañado.",
+      "restoreWholeBackup": "Para restaurar una copia de seguridad completa en su lugar, ejecuta `{{exportsCommand}}` y luego `{{rollbackCommand}}`.",
+      "sqliteUnreadable": "Orca no puede abrir el perfil activo de forma segura porque su estado SQLite no se puede leer.",
+      "legacyJsonPath": "Ruta del JSON heredado: {{path}}",
+      "retainedBackups": "Copias de seguridad de SQLite conservadas:",
+      "retainedExports": "Exportaciones JSON conservadas:",
+      "chooseRecoveryArtifact": "Cierra Orca, ejecuta `{{command}}` y elige un elemento de recuperación que sepas que está en buen estado.",
+      "restoreCommands": "Restaura SQLite con `{{backupCommand}}` o una exportación JSON con `{{revisionCommand}}`.",
+      "authorityAmbiguous": "Orca no puede determinar de forma segura qué estado del perfil es el válido: {{detail}}",
+      "authorityBothPreserved": "Una versión anterior puede haber modificado el archivo JSON. Ambas copias se conservan; ninguna se selecciona automáticamente.",
+      "authorityCopyFirst": "Cierra Orca y copia el directorio del perfil antes de elegir qué estado conservar.",
+      "authorityKeepJson": "Para conservar el JSON actual, incluidos los cambios de una versión anterior, ejecuta `{{command}}`. Esto archiva ambas copias sin fusionar su contenido.",
+      "authorityInspect": "Ejecuta `{{command}}` para inspeccionar los puntos de recuperación conservados.",
+      "authorityRestore": "Usa `{{backupCommand}}` o `{{revisionCommand}}` solo después de seleccionar el estado que quieres restaurar.",
+      "newerSchema": "Este perfil se guardó con una versión más reciente de Orca. Ábrelo con esa versión o una posterior. Tu perfil no se ha modificado.",
+      "revisionConflict": "El perfil activo cambió mientras Orca se iniciaba. Cierra los demás procesos de Orca que usan este perfil y reinicia Orca.",
+      "writerUnavailable": "Orca no pudo iniciar el guardado del perfil. Reinicia Orca; si el problema continúa, repara o reinstala esta versión.",
+      "publicationUnavailable": "Orca no pudo guardar el estado del perfil de forma segura en {{directory}}.",
+      "publicationNeedsHardLinks": "Esta ubicación debe admitir enlaces duros y Orca necesita permiso para crearlos.",
+      "publicationMoveData": "Cierra Orca y orcad antes de comprobar los permisos de la carpeta o mover todo el directorio de datos de Orca a un sistema de archivos local que permita la escritura y admita enlaces duros, como APFS, NTFS o ext4.",
+      "publicationKeepFiles": "Conserva el directorio original y todos los archivos de recuperación."
     }
   },
   "startupFailure": {
-    "title": "Orca no pudo iniciarse"
+    "title": "Orca no pudo iniciarse",
+    "finishFailed": "Orca no pudo terminar de iniciarse: {{detail}}"
   },
   "localBuild": {
     "chooseTitle": "Elegir una compilación local de Orca",
@@ -22809,5 +22836,12 @@
       "recipeExitedWithoutCode": "La receta finalizó con un código desconocido.",
       "destroyExitedWithoutCode": "La destrucción finalizó con un código desconocido."
     }
+  },
+  "installDirAcl": {
+    "cause": "Los permisos de Windows en la carpeta de instalación de Orca impiden que sus propios procesos en sandbox lean los archivos incluidos con la aplicación.",
+    "repaired": "Orca reparó los permisos. Recarga para aplicarlos.",
+    "repairing": "Orca está reparando los permisos.",
+    "repairFailed": "Orca no pudo repararlos, lo que normalmente significa que la carpeta requiere permisos de administrador.",
+    "runCommands": "Ejecuta estos comandos en un Símbolo del sistema abierto como administrador y luego vuelve a iniciar Orca:"
   }
 }
diff --git a/src/renderer/src/i18n/locales/fr.json b/src/renderer/src/i18n/locales/fr.json
index 40473c87a79..c3dbd60c61d 100644
--- a/src/renderer/src/i18n/locales/fr.json
+++ b/src/renderer/src/i18n/locales/fr.json
@@ -22105,10 +22105,37 @@
       "automationHistory": "Historique des automatisations",
       "onboarding": "Progression de la prise en main",
       "other": "Autre état enregistré de l'application"
+    },
+    "startupFailure": {
+      "noneFound": "(aucun élément trouvé)",
+      "sqlitePath": "Chemin SQLite : {{path}}",
+      "sectionsDamaged": "Une partie de l'état enregistré de ce profil est endommagée : {{sections}}. Tout le reste est intact.",
+      "repairCommand": "Quittez Orca, puis exécutez `{{command}}` pour remplacer uniquement les parties endommagées à partir des sauvegardes et conserver tout le reste. Orca conserve une copie du fichier endommagé.",
+      "restoreWholeBackup": "Pour restaurer plutôt une sauvegarde complète, exécutez `{{exportsCommand}}`, puis `{{rollbackCommand}}`.",
+      "sqliteUnreadable": "Orca ne peut pas ouvrir le profil actif en toute sécurité, car son état SQLite est illisible.",
+      "legacyJsonPath": "Chemin de l'ancien fichier JSON : {{path}}",
+      "retainedBackups": "Sauvegardes SQLite conservées :",
+      "retainedExports": "Exports JSON conservés :",
+      "chooseRecoveryArtifact": "Quittez Orca, puis exécutez `{{command}}` et choisissez un élément de récupération dont l'intégrité est confirmée.",
+      "restoreCommands": "Restaurez SQLite avec `{{backupCommand}}`, ou un export JSON avec `{{revisionCommand}}`.",
+      "authorityAmbiguous": "Orca ne peut pas déterminer en toute sécurité quel état du profil fait foi : {{detail}}",
+      "authorityBothPreserved": "Une ancienne version a peut-être modifié le fichier JSON. Les deux copies sont conservées ; aucune n'est sélectionnée automatiquement.",
+      "authorityCopyFirst": "Quittez Orca et copiez le répertoire du profil avant de choisir quel état conserver.",
+      "authorityKeepJson": "Pour conserver le JSON actuel, y compris les modifications d'une ancienne version, exécutez `{{command}}`. Les deux copies sont archivées sans fusionner leur contenu.",
+      "authorityInspect": "Exécutez `{{command}}` pour examiner les points de récupération conservés.",
+      "authorityRestore": "Utilisez `{{backupCommand}}` ou `{{revisionCommand}}` uniquement après avoir sélectionné l'état à restaurer.",
+      "newerSchema": "Ce profil a été enregistré par une version plus récente d'Orca. Ouvrez-le avec cette version ou une version ultérieure. Votre profil n'a pas été modifié.",
+      "revisionConflict": "Le profil actif a changé pendant le démarrage d'Orca. Fermez les autres processus Orca qui utilisent ce profil, puis redémarrez Orca.",
+      "writerUnavailable": "Orca n'a pas pu démarrer l'enregistrement du profil. Redémarrez Orca ; si le problème persiste, réparez ou réinstallez cette version.",
+      "publicationUnavailable": "Orca n'a pas pu enregistrer l'état du profil en toute sécurité dans {{directory}}.",
+      "publicationNeedsHardLinks": "Cet emplacement doit prendre en charge les liens physiques, et Orca doit avoir l'autorisation de les créer.",
+      "publicationMoveData": "Fermez Orca et orcad avant de vérifier les autorisations du dossier ou de déplacer tout le répertoire de données d'Orca vers un système de fichiers local accessible en écriture et prenant en charge les liens physiques, comme APFS, NTFS ou ext4.",
+      "publicationKeepFiles": "Conservez le répertoire d'origine et tous les fichiers de récupération."
     }
   },
   "startupFailure": {
-    "title": "Orca n'a pas pu démarrer"
+    "title": "Orca n'a pas pu démarrer",
+    "finishFailed": "Orca n'a pas pu terminer son démarrage : {{detail}}"
   },
   "localBuild": {
     "chooseTitle": "Choisir une build locale d'Orca",
@@ -22809,5 +22836,12 @@
       "recipeExitedWithoutCode": "La recette s’est terminée avec un code inconnu.",
       "destroyExitedWithoutCode": "La destruction s’est terminée avec un code inconnu."
     }
+  },
+  "installDirAcl": {
+    "cause": "Les autorisations Windows du dossier d'installation d'Orca empêchent ses propres processus isolés de lire les fichiers fournis avec l'application.",
+    "repaired": "Orca a corrigé les autorisations. Rechargez pour les appliquer.",
+    "repairing": "Orca corrige les autorisations.",
+    "repairFailed": "Orca n'a pas pu les corriger, ce qui signifie généralement que le dossier nécessite des droits d'administrateur.",
+    "runCommands": "Exécutez ces commandes dans une invite de commandes ouverte en tant qu'administrateur, puis relancez Orca :"
   }
 }
diff --git a/src/renderer/src/i18n/locales/ja.json b/src/renderer/src/i18n/locales/ja.json
index f64be37a120..1e039bbdc2b 100644
--- a/src/renderer/src/i18n/locales/ja.json
+++ b/src/renderer/src/i18n/locales/ja.json
@@ -21501,10 +21501,37 @@
       "automationHistory": "自動化の履歴",
       "onboarding": "オンボーディングの進行状況",
       "other": "その他の保存済みアプリ状態"
+    },
+    "startupFailure": {
+      "noneFound": "（見つかりません）",
+      "sqlitePath": "SQLite パス: {{path}}",
+      "sectionsDamaged": "このプロファイルの保存状態の一部が破損しています: {{sections}}。それ以外はすべて正常です。",
+      "repairCommand": "Orca を終了し、`{{command}}` を実行すると、破損した部分だけをバックアップから置き換え、それ以外をすべて維持できます。Orca は破損したファイルのコピーを保持します。",
+      "restoreWholeBackup": "代わりにバックアップ全体を復元するには、`{{exportsCommand}}`、次に `{{rollbackCommand}}` を実行してください。",
+      "sqliteUnreadable": "SQLite の状態を読み取れないため、Orca はアクティブなプロファイルを安全に開けません。",
+      "legacyJsonPath": "従来の JSON パス: {{path}}",
+      "retainedBackups": "保持されている SQLite バックアップ:",
+      "retainedExports": "保持されている JSON エクスポート:",
+      "chooseRecoveryArtifact": "Orca を終了し、`{{command}}` を実行して、正常であることが確認済みの復旧用データを選択してください。",
+      "restoreCommands": "`{{backupCommand}}` で SQLite を復元するか、`{{revisionCommand}}` で JSON エクスポートを復元してください。",
+      "authorityAmbiguous": "Orca はどのプロファイル状態を正とするか安全に判断できません: {{detail}}",
+      "authorityBothPreserved": "古いビルドが JSON ファイルを変更した可能性があります。両方のコピーは保持され、どちらも自動では選択されません。",
+      "authorityCopyFirst": "どの状態を保持するか選択する前に、Orca を終了してプロファイルディレクトリをコピーしてください。",
+      "authorityKeepJson": "古いビルドでの編集を含む現在の JSON を保持するには、`{{command}}` を実行してください。両方のコピーがアーカイブされ、内容は統合されません。",
+      "authorityInspect": "`{{command}}` を実行して、保持されている復旧ポイントを確認してください。",
+      "authorityRestore": "復元する状態を選択してから、`{{backupCommand}}` または `{{revisionCommand}}` を使用してください。",
+      "newerSchema": "このプロファイルは新しいバージョンの Orca で保存されています。そのバージョン以降の Orca で開いてください。プロファイルは変更されていません。",
+      "revisionConflict": "Orca の起動中にアクティブなプロファイルが変更されました。このプロファイルを使用している他の Orca プロセスを終了し、Orca を再起動してください。",
+      "writerUnavailable": "Orca はプロファイルの保存処理を開始できませんでした。Orca を再起動してください。問題が続く場合は、このビルドを修復するか再インストールしてください。",
+      "publicationUnavailable": "Orca はプロファイル状態を {{directory}} に安全に保存できませんでした。",
+      "publicationNeedsHardLinks": "この場所はハードリンクをサポートしている必要があり、Orca にはその作成権限が必要です。",
+      "publicationMoveData": "フォルダーの権限を確認したり、Orca のデータディレクトリ全体を、APFS、NTFS、ext4 などのハードリンクをサポートする書き込み可能なローカルファイルシステムに移動したりする前に、Orca と orcad を終了してください。",
+      "publicationKeepFiles": "元のディレクトリとすべての復旧用ファイルを保持してください。"
     }
   },
   "startupFailure": {
-    "title": "Orca を起動できませんでした"
+    "title": "Orca を起動できませんでした",
+    "finishFailed": "Orca は起動を完了できませんでした: {{detail}}"
   },
   "localBuild": {
     "chooseTitle": "ローカルの Orca ビルドを選択",
@@ -22193,5 +22220,12 @@
       "recipeExitedWithoutCode": "レシピは不明なコードで終了しました。",
       "destroyExitedWithoutCode": "破棄処理は不明なコードで終了しました。"
     }
+  },
+  "installDirAcl": {
+    "cause": "Orca のインストールフォルダーに設定された Windows の権限により、Orca 自身のサンドボックス内のプロセスが同梱ファイルを読み取れません。",
+    "repaired": "Orca が権限を修復しました。適用するにはリロードしてください。",
+    "repairing": "Orca が権限を修復しています。",
+    "repairFailed": "Orca は権限を修復できませんでした。通常、フォルダーへの操作に管理者権限が必要な場合に発生します。",
+    "runCommands": "管理者権限のコマンドプロンプトで次のコマンドを実行し、Orca を再起動してください:"
   }
 }
diff --git a/src/renderer/src/i18n/locales/ko.json b/src/renderer/src/i18n/locales/ko.json
index 1a4e8229c10..f52eece28a4 100644
--- a/src/renderer/src/i18n/locales/ko.json
+++ b/src/renderer/src/i18n/locales/ko.json
@@ -21501,10 +21501,37 @@
       "automationHistory": "자동화 기록",
       "onboarding": "온보딩 진행 상황",
       "other": "기타 저장된 앱 상태"
+    },
+    "startupFailure": {
+      "noneFound": "(찾을 수 없음)",
+      "sqlitePath": "SQLite 경로: {{path}}",
+      "sectionsDamaged": "이 프로필의 저장된 상태 중 일부가 손상되었습니다: {{sections}}. 나머지는 모두 정상입니다.",
+      "repairCommand": "Orca를 종료한 다음 `{{command}}`를 실행하면 손상된 부분만 백업에서 교체하고 나머지는 모두 유지할 수 있습니다. Orca는 손상된 파일의 사본을 보관합니다.",
+      "restoreWholeBackup": "대신 백업 전체를 복원하려면 `{{exportsCommand}}`를 실행한 다음 `{{rollbackCommand}}`를 실행하세요.",
+      "sqliteUnreadable": "SQLite 상태를 읽을 수 없어 Orca가 활성 프로필을 안전하게 열 수 없습니다.",
+      "legacyJsonPath": "기존 JSON 경로: {{path}}",
+      "retainedBackups": "보관된 SQLite 백업:",
+      "retainedExports": "보관된 JSON 내보내기 파일:",
+      "chooseRecoveryArtifact": "Orca를 종료한 다음 `{{command}}`를 실행하고 정상임이 확인된 복구 자료를 선택하세요.",
+      "restoreCommands": "`{{backupCommand}}`로 SQLite를 복원하거나 `{{revisionCommand}}`로 JSON 내보내기 파일을 복원하세요.",
+      "authorityAmbiguous": "Orca가 어떤 프로필 상태를 기준으로 삼을지 안전하게 판단할 수 없습니다: {{detail}}",
+      "authorityBothPreserved": "이전 빌드가 JSON 파일을 변경했을 수 있습니다. 두 사본 모두 보관되며 어느 쪽도 자동으로 선택되지 않습니다.",
+      "authorityCopyFirst": "유지할 상태를 선택하기 전에 Orca를 종료하고 프로필 디렉터리를 복사하세요.",
+      "authorityKeepJson": "이전 빌드에서 편집한 내용을 포함한 현재 JSON을 유지하려면 `{{command}}`를 실행하세요. 두 사본 모두 보관되며 내용은 병합되지 않습니다.",
+      "authorityInspect": "`{{command}}`를 실행하여 보관된 복구 지점을 확인하세요.",
+      "authorityRestore": "복원할 상태를 선택한 후에만 `{{backupCommand}}` 또는 `{{revisionCommand}}`를 사용하세요.",
+      "newerSchema": "이 프로필은 더 최신 버전의 Orca에서 저장되었습니다. 해당 버전이나 그 이후 버전으로 여세요. 프로필은 변경되지 않았습니다.",
+      "revisionConflict": "Orca가 시작되는 동안 활성 프로필이 변경되었습니다. 이 프로필을 사용하는 다른 Orca 프로세스를 종료한 다음 Orca를 다시 시작하세요.",
+      "writerUnavailable": "Orca가 프로필 저장을 시작하지 못했습니다. Orca를 다시 시작하세요. 문제가 계속되면 이 빌드를 복구하거나 다시 설치하세요.",
+      "publicationUnavailable": "Orca가 {{directory}}에 프로필 상태를 안전하게 저장하지 못했습니다.",
+      "publicationNeedsHardLinks": "이 위치는 하드 링크를 지원해야 하며 Orca에 하드 링크를 만들 권한이 있어야 합니다.",
+      "publicationMoveData": "폴더 권한을 확인하거나 Orca 데이터 디렉터리 전체를 APFS, NTFS, ext4 등 하드 링크를 지원하고 쓰기 가능한 로컬 파일 시스템으로 이동하기 전에 Orca와 orcad를 종료하세요.",
+      "publicationKeepFiles": "원본 디렉터리와 모든 복구 파일을 보관하세요."
     }
   },
   "startupFailure": {
-    "title": "Orca를 시작할 수 없음"
+    "title": "Orca를 시작할 수 없음",
+    "finishFailed": "Orca가 시작을 완료하지 못했습니다: {{detail}}"
   },
   "localBuild": {
     "chooseTitle": "로컬 Orca 빌드 선택",
@@ -22193,5 +22220,12 @@
       "recipeExitedWithoutCode": "레시피가 알 수 없는 코드로 종료되었습니다.",
       "destroyExitedWithoutCode": "삭제 작업이 알 수 없는 코드로 종료되었습니다."
     }
+  },
+  "installDirAcl": {
+    "cause": "Orca 설치 폴더의 Windows 권한 때문에 Orca 자체 샌드박스 프로세스가 함께 배포된 파일을 읽지 못하고 있습니다.",
+    "repaired": "Orca가 권한을 복구했습니다. 적용하려면 새로고침하세요.",
+    "repairing": "Orca가 권한을 복구하고 있습니다.",
+    "repairFailed": "Orca가 권한을 복구하지 못했습니다. 일반적으로 해당 폴더에 관리자 권한이 필요하다는 뜻입니다.",
+    "runCommands": "관리자 권한으로 연 명령 프롬프트에서 다음 명령을 실행한 후 Orca를 다시 실행하세요:"
   }
 }
diff --git a/src/renderer/src/i18n/locales/pt.json b/src/renderer/src/i18n/locales/pt.json
index c50255c4642..7b86f96ba5a 100644
--- a/src/renderer/src/i18n/locales/pt.json
+++ b/src/renderer/src/i18n/locales/pt.json
@@ -21933,10 +21933,37 @@
       "automationHistory": "Histórico de automações",
       "onboarding": "Progresso da integração",
       "other": "Outro estado salvo do app"
+    },
+    "startupFailure": {
+      "noneFound": "(nada encontrado)",
+      "sqlitePath": "Caminho do SQLite: {{path}}",
+      "sectionsDamaged": "Parte do estado salvo deste perfil está danificada: {{sections}}. Todo o restante está intacto.",
+      "repairCommand": "Feche o Orca e execute `{{command}}` para substituir apenas as partes danificadas a partir dos backups e manter todo o restante. O Orca guarda uma cópia do arquivo danificado.",
+      "restoreWholeBackup": "Para restaurar um backup completo em vez disso, execute `{{exportsCommand}}` e depois `{{rollbackCommand}}`.",
+      "sqliteUnreadable": "O Orca não consegue abrir o perfil ativo com segurança porque seu estado SQLite está ilegível.",
+      "legacyJsonPath": "Caminho do JSON legado: {{path}}",
+      "retainedBackups": "Backups do SQLite mantidos:",
+      "retainedExports": "Exportações JSON mantidas:",
+      "chooseRecoveryArtifact": "Feche o Orca, execute `{{command}}` e escolha um artefato de recuperação comprovadamente íntegro.",
+      "restoreCommands": "Restaure o SQLite com `{{backupCommand}}` ou uma exportação JSON com `{{revisionCommand}}`.",
+      "authorityAmbiguous": "O Orca não consegue determinar com segurança qual estado do perfil é o válido: {{detail}}",
+      "authorityBothPreserved": "Uma compilação mais antiga pode ter alterado o arquivo JSON. As duas cópias são preservadas; nenhuma é selecionada automaticamente.",
+      "authorityCopyFirst": "Feche o Orca e copie o diretório do perfil antes de escolher qual estado manter.",
+      "authorityKeepJson": "Para manter o JSON atual, incluindo edições de uma compilação mais antiga, execute `{{command}}`. Isso arquiva as duas cópias sem mesclar o conteúdo delas.",
+      "authorityInspect": "Execute `{{command}}` para inspecionar os pontos de recuperação mantidos.",
+      "authorityRestore": "Use `{{backupCommand}}` ou `{{revisionCommand}}` somente depois de selecionar o estado que deseja restaurar.",
+      "newerSchema": "Este perfil foi salvo por uma versão mais recente do Orca. Abra-o com essa versão ou uma posterior. Seu perfil não foi alterado.",
+      "revisionConflict": "O perfil ativo foi alterado enquanto o Orca iniciava. Feche os outros processos do Orca que usam este perfil e reinicie o Orca.",
+      "writerUnavailable": "O Orca não conseguiu iniciar o salvamento do perfil. Reinicie o Orca; se o problema continuar, repare ou reinstale esta compilação.",
+      "publicationUnavailable": "O Orca não conseguiu salvar o estado do perfil com segurança em {{directory}}.",
+      "publicationNeedsHardLinks": "Este local precisa oferecer suporte a links físicos, e o Orca precisa de permissão para criá-los.",
+      "publicationMoveData": "Feche o Orca e o orcad antes de verificar as permissões da pasta ou mover todo o diretório de dados do Orca para um sistema de arquivos local gravável que ofereça suporte a links físicos, como APFS, NTFS ou ext4.",
+      "publicationKeepFiles": "Mantenha o diretório original e todos os arquivos de recuperação."
     }
   },
   "startupFailure": {
-    "title": "Não foi possível iniciar o Orca"
+    "title": "Não foi possível iniciar o Orca",
+    "finishFailed": "O Orca não conseguiu concluir a inicialização: {{detail}}"
   },
   "browserExtensions": {
     "permission": {
@@ -22622,5 +22649,12 @@
       "recipeExitedWithoutCode": "A receita terminou com um código desconhecido.",
       "destroyExitedWithoutCode": "A destruição terminou com um código desconhecido."
     }
+  },
+  "installDirAcl": {
+    "cause": "As permissões do Windows na pasta de instalação do Orca impedem que os próprios processos em sandbox leiam os arquivos distribuídos com o aplicativo.",
+    "repaired": "O Orca corrigiu as permissões. Recarregue para aplicá-las.",
+    "repairing": "O Orca está corrigindo as permissões.",
+    "repairFailed": "O Orca não conseguiu corrigi-las, o que geralmente significa que a pasta exige permissões de administrador.",
+    "runCommands": "Execute estes comandos em um Prompt de Comando como administrador e abra o Orca novamente:"
   }
 }
diff --git a/src/renderer/src/i18n/locales/ru.json b/src/renderer/src/i18n/locales/ru.json
index 858d068f66f..05d169e8337 100644
--- a/src/renderer/src/i18n/locales/ru.json
+++ b/src/renderer/src/i18n/locales/ru.json
@@ -22192,6 +22192,32 @@
       "okButton": "ОК",
       "safeDetail": "Изменения, сохранённые до этого момента, в безопасности. Новые изменения не будут сохраняться, пока вы не перезапустите Orca.",
       "title": "Сохранение остановлено"
+    },
+    "startupFailure": {
+      "noneFound": "(не найдено)",
+      "sqlitePath": "Путь к SQLite: {{path}}",
+      "sectionsDamaged": "Часть сохранённого состояния этого профиля повреждена: {{sections}}. Всё остальное не повреждено.",
+      "repairCommand": "Закройте Orca, затем выполните `{{command}}`, чтобы заменить только повреждённые части из резервных копий и сохранить всё остальное. Orca сохраняет копию повреждённого файла.",
+      "restoreWholeBackup": "Чтобы вместо этого восстановить резервную копию целиком, выполните `{{exportsCommand}}`, затем `{{rollbackCommand}}`.",
+      "sqliteUnreadable": "Orca не может безопасно открыть активный профиль, так как его состояние SQLite недоступно для чтения.",
+      "legacyJsonPath": "Путь к устаревшему JSON: {{path}}",
+      "retainedBackups": "Сохранённые резервные копии SQLite:",
+      "retainedExports": "Сохранённые экспорты JSON:",
+      "chooseRecoveryArtifact": "Закройте Orca, затем выполните `{{command}}` и выберите заведомо исправные данные для восстановления.",
+      "restoreCommands": "Восстановите SQLite с помощью `{{backupCommand}}` или экспорт JSON с помощью `{{revisionCommand}}`.",
+      "authorityAmbiguous": "Orca не может безопасно выбрать основной источник состояния профиля: {{detail}}",
+      "authorityBothPreserved": "Более старая сборка могла изменить файл JSON. Обе копии сохранены; ни одна не выбирается автоматически.",
+      "authorityCopyFirst": "Закройте Orca и скопируйте каталог профиля, прежде чем выбирать, какое состояние сохранить.",
+      "authorityKeepJson": "Чтобы сохранить текущий JSON, включая изменения из более старой сборки, выполните `{{command}}`. Обе копии будут архивированы без объединения их содержимого.",
+      "authorityInspect": "Выполните `{{command}}`, чтобы просмотреть сохранённые точки восстановления.",
+      "authorityRestore": "Используйте `{{backupCommand}}` или `{{revisionCommand}}` только после выбора состояния, которое хотите восстановить.",
+      "newerSchema": "Этот профиль сохранён в более новой версии Orca. Откройте его в той же или более новой версии. Ваш профиль не был изменён.",
+      "revisionConflict": "Активный профиль изменился во время запуска Orca. Закройте другие процессы Orca, использующие этот профиль, затем перезапустите Orca.",
+      "writerUnavailable": "Orca не удалось начать сохранение профиля. Перезапустите Orca; если проблема повторится, восстановите или переустановите эту сборку.",
+      "publicationUnavailable": "Orca не удалось безопасно сохранить состояние профиля в {{directory}}.",
+      "publicationNeedsHardLinks": "Это расположение должно поддерживать жёсткие ссылки, а Orca нужны права на их создание.",
+      "publicationMoveData": "Закройте Orca и orcad, прежде чем проверять права доступа к папке или переносить весь каталог данных Orca на доступную для записи локальную файловую систему с поддержкой жёстких ссылок, например APFS, NTFS или ext4.",
+      "publicationKeepFiles": "Сохраните исходный каталог и все файлы восстановления."
     }
   },
   "gpuFallback": {
@@ -22227,7 +22253,8 @@
     "useButton": "Использовать локальную сборку"
   },
   "startupFailure": {
-    "title": "Не удалось запустить Orca"
+    "title": "Не удалось запустить Orca",
+    "finishFailed": "Orca не удалось завершить запуск: {{detail}}"
   },
   "native": {
     "about": {
@@ -22867,5 +22894,12 @@
       "recipeExitedWithoutCode": "Рецепт завершился с неизвестным кодом.",
       "destroyExitedWithoutCode": "Уничтожение завершилось с неизвестным кодом."
     }
+  },
+  "installDirAcl": {
+    "cause": "Права доступа Windows к папке установки Orca не позволяют собственным процессам Orca в изолированной среде читать файлы, поставляемые с приложением.",
+    "repaired": "Orca исправила права доступа. Перезагрузите окно, чтобы применить их.",
+    "repairing": "Orca исправляет права доступа.",
+    "repairFailed": "Orca не удалось их исправить. Обычно это означает, что для изменения прав доступа к папке нужны права администратора.",
+    "runCommands": "Выполните эти команды в командной строке от имени администратора, затем снова запустите Orca:"
   }
 }
diff --git a/src/renderer/src/i18n/locales/tr.json b/src/renderer/src/i18n/locales/tr.json
index d5853a5dd19..06f8b24a843 100644
--- a/src/renderer/src/i18n/locales/tr.json
+++ b/src/renderer/src/i18n/locales/tr.json
@@ -21548,10 +21548,37 @@
       "automationHistory": "Otomasyon geçmişi",
       "onboarding": "Başlangıç adımlarındaki ilerleme",
       "other": "Uygulamanın diğer kayıtlı durumu"
+    },
+    "startupFailure": {
+      "noneFound": "(bulunamadı)",
+      "sqlitePath": "SQLite yolu: {{path}}",
+      "sectionsDamaged": "Bu profilin kayıtlı durumunun bir bölümü hasarlı: {{sections}}. Diğer her şey sağlam.",
+      "repairCommand": "Orca'yı kapatın, ardından yalnızca hasarlı bölümleri yedeklerden değiştirip diğer her şeyi korumak için `{{command}}` komutunu çalıştırın. Orca hasarlı dosyanın bir kopyasını saklar.",
+      "restoreWholeBackup": "Bunun yerine bir yedeği bütünüyle geri yüklemek için önce `{{exportsCommand}}`, ardından `{{rollbackCommand}}` komutunu çalıştırın.",
+      "sqliteUnreadable": "SQLite durumu okunamadığı için etkin profil Orca'da güvenli bir şekilde açılamadı.",
+      "legacyJsonPath": "Eski JSON yolu: {{path}}",
+      "retainedBackups": "Saklanan SQLite yedekleri:",
+      "retainedExports": "Saklanan JSON dışa aktarımları:",
+      "chooseRecoveryArtifact": "Orca'yı kapatın, ardından `{{command}}` komutunu çalıştırın ve sağlam olduğu bilinen bir kurtarma öğesi seçin.",
+      "restoreCommands": "SQLite'ı `{{backupCommand}}` ile veya bir JSON dışa aktarımını `{{revisionCommand}}` ile geri yükleyin.",
+      "authorityAmbiguous": "Profil durumunun esas alınacak kaynağı Orca'da güvenli bir şekilde seçilemedi: {{detail}}",
+      "authorityBothPreserved": "Eski bir derleme JSON dosyasını değiştirmiş olabilir. Her iki kopya da korunur; hiçbiri otomatik olarak seçilmez.",
+      "authorityCopyFirst": "Hangi durumun korunacağını seçmeden önce Orca'yı kapatın ve profil dizinini kopyalayın.",
+      "authorityKeepJson": "Eski bir derlemede yapılan düzenlemeler dahil mevcut JSON'u korumak için `{{command}}` komutunu çalıştırın. Bu işlem her iki kopyayı arşivler ve içeriklerini birleştirmez.",
+      "authorityInspect": "Saklanan kurtarma noktalarını incelemek için `{{command}}` komutunu çalıştırın.",
+      "authorityRestore": "`{{backupCommand}}` veya `{{revisionCommand}}` komutunu yalnızca geri yüklemek istediğiniz durumu seçtikten sonra kullanın.",
+      "newerSchema": "Bu profil Orca'nın daha yeni bir sürümünde kaydedilmiş. O sürümle veya daha yeni bir sürümle açın. Profiliniz değiştirilmedi.",
+      "revisionConflict": "Orca başlatılırken etkin profil değişti. Bu profili kullanan diğer Orca işlemlerini kapatın, ardından Orca'yı yeniden başlatın.",
+      "writerUnavailable": "Orca'da profil kaydı başlatılamadı. Orca'yı yeniden başlatın; sorun devam ederse bu derlemeyi onarın veya yeniden yükleyin.",
+      "publicationUnavailable": "Profil durumu Orca tarafından {{directory}} konumuna güvenli bir şekilde kaydedilemedi.",
+      "publicationNeedsHardLinks": "Bu konum sabit bağlantıları desteklemeli ve Orca'nın bunları oluşturma izni olmalıdır.",
+      "publicationMoveData": "Klasör izinlerini kontrol etmeden veya Orca veri dizininin tamamını APFS, NTFS ya da ext4 gibi sabit bağlantıları destekleyen yazılabilir bir yerel dosya sistemine taşımadan önce Orca ve orcad uygulamalarını kapatın.",
+      "publicationKeepFiles": "Özgün dizini ve tüm kurtarma dosyalarını saklayın."
     }
   },
   "startupFailure": {
-    "title": "Orca başlatılamadı"
+    "title": "Orca başlatılamadı",
+    "finishFailed": "Orca'nın başlatılması tamamlanamadı: {{detail}}"
   },
   "native": {
     "about": {
@@ -22173,5 +22200,12 @@
       "recipeExitedWithoutCode": "Tarif bilinmeyen bir kodla sonlandı.",
       "destroyExitedWithoutCode": "Yok etme işlemi bilinmeyen bir kodla sonlandı."
     }
+  },
+  "installDirAcl": {
+    "cause": "Orca'nın kurulum klasöründeki Windows izinleri, kendi korumalı alan süreçlerinin uygulamayla birlikte gelen dosyaları okumasını engelliyor.",
+    "repaired": "Orca izinleri onardı. Uygulamak için yenileyin.",
+    "repairing": "Orca şu anda izinleri onarıyor.",
+    "repairFailed": "İzinler Orca tarafından onarılamadı. Bu genellikle klasör için yönetici yetkisi gerektiği anlamına gelir.",
+    "runCommands": "Yönetici olarak açılan Komut İstemi penceresinde bu komutları çalıştırın, ardından Orca'yı yeniden başlatın:"
   }
 }
diff --git a/src/renderer/src/i18n/locales/zh-Hant.json b/src/renderer/src/i18n/locales/zh-Hant.json
index 15f911eaf8d..8f2e8f925aa 100644
--- a/src/renderer/src/i18n/locales/zh-Hant.json
+++ b/src/renderer/src/i18n/locales/zh-Hant.json
@@ -21270,10 +21270,37 @@
       "automationHistory": "自動化歷程",
       "onboarding": "入門導覽進度",
       "other": "其他已儲存的應用程式狀態"
+    },
+    "startupFailure": {
+      "noneFound": "（找不到）",
+      "sqlitePath": "SQLite 路徑：{{path}}",
+      "sectionsDamaged": "此設定檔儲存的部分狀態已損毀：{{sections}}。其餘內容皆完好無損。",
+      "repairCommand": "關閉 Orca，然後執行 `{{command}}`，僅從備份取代損毀的部分，並保留其餘所有內容。Orca 會保留損毀檔案的副本。",
+      "restoreWholeBackup": "若要改為還原整份備份，請先執行 `{{exportsCommand}}`，再執行 `{{rollbackCommand}}`。",
+      "sqliteUnreadable": "Orca 無法安全地開啟目前使用的設定檔，因為其 SQLite 狀態無法讀取。",
+      "legacyJsonPath": "舊版 JSON 路徑：{{path}}",
+      "retainedBackups": "保留的 SQLite 備份：",
+      "retainedExports": "保留的 JSON 匯出：",
+      "chooseRecoveryArtifact": "關閉 Orca，然後執行 `{{command}}`，選擇一份已確認完好的復原資料。",
+      "restoreCommands": "使用 `{{backupCommand}}` 還原 SQLite，或使用 `{{revisionCommand}}` 還原 JSON 匯出。",
+      "authorityAmbiguous": "Orca 無法安全地確定要以哪份設定檔狀態為準：{{detail}}",
+      "authorityBothPreserved": "舊版可能變更過 JSON 檔案。兩份副本皆已保留，不會自動選取任何一份。",
+      "authorityCopyFirst": "請先關閉 Orca 並複製設定檔目錄，再選擇要保留的狀態。",
+      "authorityKeepJson": "若要保留目前的 JSON（包含舊版中的編輯內容），請執行 `{{command}}`。這會封存兩份副本，不會合併其內容。",
+      "authorityInspect": "執行 `{{command}}` 以檢視保留的復原點。",
+      "authorityRestore": "請先選擇要還原的狀態，再使用 `{{backupCommand}}` 或 `{{revisionCommand}}`。",
+      "newerSchema": "此設定檔是由較新版的 Orca 儲存。請使用該版本或更新版本開啟。設定檔未經變更。",
+      "revisionConflict": "Orca 啟動期間，目前使用的設定檔發生變更。請關閉使用此設定檔的其他 Orca 行程，然後重新啟動 Orca。",
+      "writerUnavailable": "Orca 無法啟動設定檔儲存功能。請重新啟動 Orca；若問題持續發生，請修復或重新安裝此版本。",
+      "publicationUnavailable": "Orca 無法將設定檔狀態安全地儲存至 {{directory}}。",
+      "publicationNeedsHardLinks": "此位置必須支援硬連結，且 Orca 需要建立硬連結的權限。",
+      "publicationMoveData": "在檢查資料夾權限，或將整個 Orca 資料目錄移至支援硬連結的可寫入本機檔案系統（例如 APFS、NTFS 或 ext4）之前，請關閉 Orca 和 orcad。",
+      "publicationKeepFiles": "請保留原始目錄和所有復原檔案。"
     }
   },
   "startupFailure": {
-    "title": "Orca 無法啟動"
+    "title": "Orca 無法啟動",
+    "finishFailed": "Orca 無法完成啟動：{{detail}}"
   },
   "native": {
     "about": {
@@ -21895,5 +21922,12 @@
       "recipeExitedWithoutCode": "環境範本已結束，結束代碼未知。",
       "destroyExitedWithoutCode": "銷燬作業已結束，結束代碼未知。"
     }
+  },
+  "installDirAcl": {
+    "cause": "Orca 安裝資料夾的 Windows 權限阻止 Orca 自身的沙箱行程讀取隨附的檔案。",
+    "repaired": "Orca 已修復權限。請重新載入以套用。",
+    "repairing": "Orca 正在修復權限。",
+    "repairFailed": "Orca 無法修復權限，這通常表示該資料夾需要系統管理員權限。",
+    "runCommands": "在以系統管理員身分開啟的命令提示字元中執行以下指令，然後重新啟動 Orca："
   }
 }
diff --git a/src/renderer/src/i18n/locales/zh.json b/src/renderer/src/i18n/locales/zh.json
index b919755f726..94892281c50 100644
--- a/src/renderer/src/i18n/locales/zh.json
+++ b/src/renderer/src/i18n/locales/zh.json
@@ -21555,10 +21555,37 @@
       "automationHistory": "自动化历史",
       "onboarding": "入门引导进度",
       "other": "其他已保存的应用状态"
+    },
+    "startupFailure": {
+      "noneFound": "（未找到）",
+      "sqlitePath": "SQLite 路径：{{path}}",
+      "sectionsDamaged": "此配置文件已保存状态的一部分已损坏：{{sections}}。其余内容均完好无损。",
+      "repairCommand": "关闭 Orca，然后运行 `{{command}}`，仅从备份中替换损坏的部分，并保留其余所有内容。Orca 会保留损坏文件的副本。",
+      "restoreWholeBackup": "如需改为恢复整份备份，请先运行 `{{exportsCommand}}`，再运行 `{{rollbackCommand}}`。",
+      "sqliteUnreadable": "Orca 无法安全地打开当前配置文件，因为其 SQLite 状态无法读取。",
+      "legacyJsonPath": "旧版 JSON 路径：{{path}}",
+      "retainedBackups": "保留的 SQLite 备份：",
+      "retainedExports": "保留的 JSON 导出：",
+      "chooseRecoveryArtifact": "关闭 Orca，然后运行 `{{command}}`，选择一份确认完好的恢复数据。",
+      "restoreCommands": "使用 `{{backupCommand}}` 恢复 SQLite，或使用 `{{revisionCommand}}` 恢复 JSON 导出。",
+      "authorityAmbiguous": "Orca 无法安全地确定以哪份配置文件状态为准：{{detail}}",
+      "authorityBothPreserved": "旧版本可能修改过 JSON 文件。两个副本均已保留，不会自动选择任何一个。",
+      "authorityCopyFirst": "关闭 Orca 并复制配置文件目录，然后再选择要保留的状态。",
+      "authorityKeepJson": "如需保留当前 JSON（包括旧版本中的修改），请运行 `{{command}}`。此操作会归档两个副本，不会合并其内容。",
+      "authorityInspect": "运行 `{{command}}` 以查看保留的恢复点。",
+      "authorityRestore": "请先选择要恢复的状态，再使用 `{{backupCommand}}` 或 `{{revisionCommand}}`。",
+      "newerSchema": "此配置文件由较新版本的 Orca 保存。请使用该版本或更新版本打开。你的配置文件未被更改。",
+      "revisionConflict": "Orca 启动期间，当前配置文件发生了更改。请关闭使用此配置文件的其他 Orca 进程，然后重新启动 Orca。",
+      "writerUnavailable": "Orca 无法启动配置文件保存功能。请重新启动 Orca；如果问题仍然存在，请修复或重新安装此版本。",
+      "publicationUnavailable": "Orca 无法将配置文件状态安全地保存到 {{directory}}。",
+      "publicationNeedsHardLinks": "此位置必须支持硬链接，且 Orca 需要创建硬链接的权限。",
+      "publicationMoveData": "在检查文件夹权限，或将整个 Orca 数据目录移动到支持硬链接的可写本地文件系统（如 APFS、NTFS 或 ext4）之前，请关闭 Orca 和 orcad。",
+      "publicationKeepFiles": "请保留原始目录和所有恢复文件。"
     }
   },
   "startupFailure": {
-    "title": "Orca 无法启动"
+    "title": "Orca 无法启动",
+    "finishFailed": "Orca 无法完成启动：{{detail}}"
   },
   "localBuild": {
     "chooseTitle": "选择本地 Orca 构建",
@@ -22194,5 +22221,12 @@
       "recipeExitedWithoutCode": "环境模板已退出，退出码未知。",
       "destroyExitedWithoutCode": "销毁操作已退出，退出码未知。"
     }
+  },
+  "installDirAcl": {
+    "cause": "Orca 安装文件夹的 Windows 权限阻止了 Orca 自身的沙箱进程读取随应用附带的文件。",
+    "repaired": "Orca 已修复权限。请重新加载以应用。",
+    "repairing": "Orca 正在修复权限。",
+    "repairFailed": "Orca 无法修复权限，这通常意味着该文件夹需要管理员权限。",
+    "runCommands": "在以管理员身份运行的命令提示符中执行以下命令，然后重新启动 Orca："
   }
 }