diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.json
index f5680947d89..4e731e7c62c 100644
--- a/.github/workspace-dep-closures.json
+++ b/.github/workspace-dep-closures.json
@@ -4877,6 +4877,7 @@
       "crates/macro_env_var",
       "crates/macro_event_broker",
       "crates/macro_event_topics",
+      "crates/macro_queues",
       "crates/macro_service_urls",
       "crates/macro_sync_service_jwt",
       "crates/macro_tower_layers",
diff --git a/.sqlx/query-1f21761b4bc48d82468fa7e8cebbd5e309aab299895ab0e4a91c01a870d9109c.json b/.sqlx/query-1f21761b4bc48d82468fa7e8cebbd5e309aab299895ab0e4a91c01a870d9109c.json
new file mode 100644
index 00000000000..1b5d58ed199
--- /dev/null
+++ b/.sqlx/query-1f21761b4bc48d82468fa7e8cebbd5e309aab299895ab0e4a91c01a870d9109c.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n            UPDATE \"Document\"\n            SET \"fileType\" = $3,\n                \"updatedAt\" = NOW()\n            WHERE id = $1 AND LOWER(\"fileType\") = $2\n            ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "1f21761b4bc48d82468fa7e8cebbd5e309aab299895ab0e4a91c01a870d9109c"
+}
diff --git a/.sqlx/query-3f6fad37bbed718a3124a1946c642b63e816133ecea6ce72c8c9507277617f30.json b/.sqlx/query-3f6fad37bbed718a3124a1946c642b63e816133ecea6ce72c8c9507277617f30.json
new file mode 100644
index 00000000000..585499ecb11
--- /dev/null
+++ b/.sqlx/query-3f6fad37bbed718a3124a1946c642b63e816133ecea6ce72c8c9507277617f30.json
@@ -0,0 +1,22 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n            INSERT INTO \"DocumentBom\" (\"documentId\", \"createdAt\", \"updatedAt\")\n            VALUES ($1, NOW(), NOW())\n            RETURNING id\n            ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "id",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text"
+      ]
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "3f6fad37bbed718a3124a1946c642b63e816133ecea6ce72c8c9507277617f30"
+}
diff --git a/.sqlx/query-92d93a6bc6a48cce58a03908a840395eb184c9eb259894f689390b13e5647a6c.json b/.sqlx/query-92d93a6bc6a48cce58a03908a840395eb184c9eb259894f689390b13e5647a6c.json
new file mode 100644
index 00000000000..c8b812d4563
--- /dev/null
+++ b/.sqlx/query-92d93a6bc6a48cce58a03908a840395eb184c9eb259894f689390b13e5647a6c.json
@@ -0,0 +1,14 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM \"DocumentInstance\" WHERE id = $1",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Int8"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "92d93a6bc6a48cce58a03908a840395eb184c9eb259894f689390b13e5647a6c"
+}
diff --git a/.sqlx/query-dadea3eca110a122079f319ea9d944cdab75327b002a16e85cf9da6fe8f18c8c.json b/.sqlx/query-dadea3eca110a122079f319ea9d944cdab75327b002a16e85cf9da6fe8f18c8c.json
new file mode 100644
index 00000000000..ee430a934f7
--- /dev/null
+++ b/.sqlx/query-dadea3eca110a122079f319ea9d944cdab75327b002a16e85cf9da6fe8f18c8c.json
@@ -0,0 +1,14 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "DELETE FROM \"DocumentBom\" WHERE id = $1",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Int8"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "dadea3eca110a122079f319ea9d944cdab75327b002a16e85cf9da6fe8f18c8c"
+}
diff --git a/.sqlx/query-e53dd219e78de6f92272433200e09f2d94ad20d9f6e193e1e92655d335a128d3.json b/.sqlx/query-e53dd219e78de6f92272433200e09f2d94ad20d9f6e193e1e92655d335a128d3.json
new file mode 100644
index 00000000000..208428c2618
--- /dev/null
+++ b/.sqlx/query-e53dd219e78de6f92272433200e09f2d94ad20d9f6e193e1e92655d335a128d3.json
@@ -0,0 +1,23 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n            INSERT INTO \"DocumentInstance\" (\"documentId\", \"sha\", \"createdAt\", \"updatedAt\")\n            VALUES ($1, $2, NOW(), NOW())\n            RETURNING id\n            ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "id",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text",
+        "Text"
+      ]
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "e53dd219e78de6f92272433200e09f2d94ad20d9f6e193e1e92655d335a128d3"
+}
diff --git a/Cargo.lock b/Cargo.lock
index c2f4f11447e..4e7a4336e5b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4802,6 +4802,7 @@ dependencies = [
  "aws-sdk-sqs",
  "axum",
  "database_env_vars",
+ "docx_engine",
  "doppler-config",
  "futures",
  "http-body-util",
@@ -4820,6 +4821,7 @@ dependencies = [
  "macro_uuid",
  "model",
  "nix 0.29.0",
+ "pptx_engine",
  "remote_env_var",
  "rs-libreoffice-bindings",
  "s3_client",
@@ -4830,6 +4832,7 @@ dependencies = [
  "sqlx",
  "sqs_client",
  "sqs_worker",
+ "tempfile",
  "tokio",
  "tower 0.5.3",
  "tower-http",
@@ -6396,12 +6399,17 @@ dependencies = [
  "macro_aws_config",
  "macro_entrypoint",
  "macro_env_var",
+ "macro_queues",
  "macro_service_urls",
+ "macro_uuid",
  "model",
+ "model_owner",
  "s3_key",
  "serde",
  "serde_json",
+ "sha2 0.10.9",
  "sqlx",
+ "sqs_client",
  "sync_service_client",
  "tokio",
  "tracing",
diff --git a/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/README.md b/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/README.md
index d494582b0dd..edd7863d15b 100644
--- a/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/README.md
+++ b/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/README.md
@@ -49,3 +49,5 @@ Notices:
 - U.S. federal works (SEC, Census, BLS, BEA, IRS, SBA, GSA) are in the public domain; the FRED export carries BLS series data.
 
 Templates whose terms forbid redistribution (Microsoft Create, Vertex42, Breaking Into Wall Street, Damodaran, SBDC) were used only for local testing and are not committed. Add a file by copying it here unmodified and adding its `file`, `title`, `source` and `license` to the manifest; set `skipCalculation` with a reason only when the engine cannot finish it.
+
+`upgraded-from-xls.xlsx` is a legacy Excel 97 workbook (`services/convert_service/fixtures/legacy/budget.xls`) converted to `.xlsx` by LibreOffice with the `Calc MS Excel 2007 XML` filter, exactly as the convert service upgrades uploaded `.xls` files. `../xlsx-upgraded-legacy.test.ts` checks that it imports into a native spreadsheet with its sheets, formulas, merges and number formats.
diff --git a/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/upgraded-from-xls.xlsx b/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/upgraded-from-xls.xlsx
new file mode 100644
index 00000000000..775d52de0ae
Binary files /dev/null and b/apps/web/src/features/block-spreadsheet/core/xlsx-fixtures/upgraded-from-xls.xlsx differ
diff --git a/apps/web/src/features/block-spreadsheet/core/xlsx-upgraded-legacy.test.ts b/apps/web/src/features/block-spreadsheet/core/xlsx-upgraded-legacy.test.ts
new file mode 100644
index 00000000000..13f4282bac4
--- /dev/null
+++ b/apps/web/src/features/block-spreadsheet/core/xlsx-upgraded-legacy.test.ts
@@ -0,0 +1,122 @@
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { initSync } from '@ironcalc/wasm';
+import { createInitializedSpreadsheetCalculator } from '@macro-inc/spreadsheet/calculation';
+import {
+  importSpreadsheetSheets,
+  readSpreadsheetWorkbook,
+} from '@macro-inc/spreadsheet/workbook-document';
+import ExcelJS from 'exceljs';
+import { LoroDoc } from 'loro-crdt';
+import { beforeAll, describe, expect, it } from 'vitest';
+import { decodeXlsx, encodeXlsx } from './xlsx-codec';
+
+/**
+ * An uploaded legacy `.xls` is upgraded to `.xlsx` by LibreOffice on the
+ * server; this is that output for a two-sheet budget. It must import into a
+ * native spreadsheet like any Excel-written workbook.
+ */
+const upgraded = () =>
+  new Uint8Array(
+    readFileSync(
+      createRequire(import.meta.url).resolve(
+        './xlsx-fixtures/upgraded-from-xls.xlsx'
+      )
+    )
+  );
+
+beforeAll(() =>
+  initSync({
+    module: readFileSync(
+      createRequire(import.meta.url).resolve('@ironcalc/wasm/wasm_bg.wasm')
+    ),
+  })
+);
+
+describe('workbook upgraded from a legacy .xls', () => {
+  it('imports both sheets with their cells and formulas', async () => {
+    const imported = await decodeXlsx(upgraded());
+
+    expect(imported.sheets.map((sheet) => sheet.name)).toEqual([
+      'Budget',
+      'Notes',
+    ]);
+    const [budget, notes] = imported.sheets;
+    expect(budget.cells.A1.value).toBe('Month');
+    // Stored as text in the .xls, so it stays text rather than becoming a date.
+    expect(budget.cells.A2.value).toBe("'2026-01");
+    expect(budget.cells.B2.value).toBe('1050');
+    expect(budget.cells.D2.value).toBe('=B2-C2');
+    expect(budget.cells.D13.value).toBe('=B13-C13');
+    expect(budget.cells.A15.value).toBe('Total');
+    expect(budget.cells.B15.value).toBe('=SUM(B2:B13)');
+    expect(budget.cells.D15.value).toBe('=SUM(D2:D13)');
+    expect(budget.cells.F1.value).toBe('Merged header');
+    expect(notes.cells.B1.value).toBe('Finance');
+    expect(notes.cells.B2.value).toBe('=Budget!D15/Budget!B15');
+  });
+
+  it('keeps header styles, number formats and the merged header', async () => {
+    const imported = await decodeXlsx(upgraded());
+    const budget = imported.sheets[0];
+
+    expect(budget.cells.A1).toMatchObject({
+      bold: true,
+      fillColor: '#DDEBF7',
+    });
+    // `#,##0.00` imports as Macro's thousands-separated number format.
+    expect(budget.cells.B15).toMatchObject({ format: 'number', decimals: 2 });
+    expect(budget.metadata?.merges).toEqual(['F1:H1']);
+    expect(imported.warnings).toEqual([
+      'Merged ranges are shown as individual cells in Macro and restored on Excel export when their covered cells remain empty.',
+    ]);
+  });
+
+  it('calculates the same results after native save and reopen', async () => {
+    const imported = await decodeXlsx(upgraded());
+    const doc = new LoroDoc();
+    const reopened = new LoroDoc();
+    const engine = createInitializedSpreadsheetCalculator();
+    try {
+      importSpreadsheetSheets(doc, imported.sheets, true);
+      reopened.import(doc.export({ mode: 'snapshot' }));
+      const sheets = readSpreadsheetWorkbook(reopened);
+      const results = engine.calculateWorkbook(
+        sheets.map((sheet) => ({ ...sheet, rowCount: sheet.layout.rowCount })),
+        { includeTypes: true }
+      );
+
+      const budget = results[sheets[0].id];
+      // Revenue 1000 + 50i and cost 600 + 20i for months 1..12.
+      expect(budget.B15.number).toBe(15_900);
+      expect(budget.C15.number).toBe(8_760);
+      expect(budget.D15.number).toBe(7_140);
+      expect(budget.D2.number).toBe(430);
+      expect(budget.B15.display).toBe('15,900.00');
+      expect(results[sheets[1].id].B2.number).toBeCloseTo(7_140 / 15_900, 12);
+      for (const values of Object.values(results)) {
+        expect(
+          Object.entries(values).filter(([, value]) => value.error)
+        ).toEqual([]);
+      }
+    } finally {
+      engine.dispose();
+    }
+  });
+
+  it('exports back to an .xlsx Excel reads with the same formulas', async () => {
+    const imported = await decodeXlsx(upgraded());
+
+    const exported = await encodeXlsx({ sheets: imported.sheets });
+
+    const external = new ExcelJS.Workbook();
+    await external.xlsx.load(exported.bytes.slice().buffer);
+    const budget = external.getWorksheet('Budget')!;
+    expect(budget.getCell('B15').formula).toBe('SUM(B2:B13)');
+    expect(budget.getCell('D2').formula).toBe('B2-C2');
+    expect(budget.getCell('F1').isMerged).toBe(true);
+    expect(external.getWorksheet('Notes')!.getCell('B2').formula).toBe(
+      'Budget!D15/Budget!B15'
+    );
+  });
+});
diff --git a/apps/web/src/features/block-spreadsheet/views/SpreadsheetEditor.tsx b/apps/web/src/features/block-spreadsheet/views/SpreadsheetEditor.tsx
index 42cdf952b13..99c0998a08c 100644
--- a/apps/web/src/features/block-spreadsheet/views/SpreadsheetEditor.tsx
+++ b/apps/web/src/features/block-spreadsheet/views/SpreadsheetEditor.tsx
@@ -529,9 +529,16 @@ export function SpreadsheetEditor(props: {
 
   async function importFile(file: File | undefined) {
     if (!file || !editable()) return;
+    if (/\.xls$/i.test(file.name)) {
+      // Converting .xls to .xlsx needs the server; uploads are upgraded.
+      actions.setNotice(
+        'Legacy .xls workbooks are converted when uploaded. Upload the file, then choose Edit in Macro.'
+      );
+      return;
+    }
     if (!/\.(csv|xlsx)$/i.test(file.name)) {
       actions.setNotice(
-        'Choose a .csv or .xlsx file. Legacy .xls and macro-enabled workbooks are not supported.'
+        'Choose a .csv or .xlsx file. Macro-enabled workbooks are not supported.'
       );
       return;
     }
diff --git a/apps/web/src/features/block-unknown/component/Block.tsx b/apps/web/src/features/block-unknown/component/Block.tsx
index dc7355e4e43..897d74ae1fe 100644
--- a/apps/web/src/features/block-unknown/component/Block.tsx
+++ b/apps/web/src/features/block-unknown/component/Block.tsx
@@ -1,8 +1,10 @@
 import { FileSidePanelSections, SidePanel } from '@components/app/side-panel';
+import { useSplitLayout } from '@components/app/split-layout/layout';
 import { useBlockId } from '@core/block';
 import { DocumentBlockContainer } from '@core/component/DocumentBlockContainer';
 import { toast } from '@core/component/Toast/Toast';
 import { useShareModal } from '@core/component/TopBar/shareModal';
+import { fileTypeToBlockName } from '@core/constant/allBlocks';
 import { blockMetadataSignal } from '@core/signal/load';
 import { useGetPermissions } from '@core/signal/permissions';
 import {
@@ -10,11 +12,26 @@ import {
   useBlockDocumentName,
 } from '@core/util/currentBlockDocumentName';
 import { downloadFile } from '@filesystem/download';
+import { waitForDocumentContentReady } from '@queries/storage/document-location';
+import { fetchDocumentMetadata } from '@queries/storage/document-metadata';
 import { createCallback } from '@solid-primitives/rootless';
-import { lazy, Show, Suspense } from 'solid-js';
+import {
+  createSignal,
+  lazy,
+  onCleanup,
+  onMount,
+  Show,
+  Suspense,
+} from 'solid-js';
 import { SpreadsheetSkeleton } from '../../block-spreadsheet/components/SpreadsheetSkeleton';
 import { isUploadedWorkbook } from '../../block-spreadsheet/core/uploaded-workbook';
 import { useSpreadsheetAccess } from '../../block-spreadsheet/primitives/use-spreadsheet-access';
+import {
+  legacyOfficeUpgradeTarget,
+  pollForLegacyUpgrade,
+  shouldAwaitLegacyUpgrade,
+  upgradedOfficeLabel,
+} from '../legacy-office';
 import { useGetFileBlob } from '../signal/blockData';
 import { TopBar } from './TopBar';
 import { UnknownContent } from './UnknownContent';
@@ -50,6 +67,7 @@ function BlockUnknownContent() {
     owner: blockMetadataSignal()?.owner,
   }));
   const getBlob = useGetFileBlob();
+  const convertingTo = useLegacyOfficeUpgrade(blockId);
 
   const downloadDocument = createCallback(async () => {
     try {
@@ -74,6 +92,7 @@ function BlockUnknownContent() {
             fallback={
               <UnknownContent
                 fileName={fileName()}
+                convertingTo={convertingTo()}
                 onShare={openShare}
                 onDownload={() => void downloadDocument()}
               />
@@ -88,3 +107,56 @@ function BlockUnknownContent() {
     </SidePanel.Layout>
   );
 }
+
+/**
+ * Waits for a just-uploaded .doc/.ppt/.xls to be upgraded to OpenXML, then
+ * reopens it in the block for its new type. Returns the label of the format
+ * being converted to while waiting.
+ */
+function useLegacyOfficeUpgrade(documentId: string) {
+  const { replaceSplit } = useSplitLayout();
+  const initial = blockMetadataSignal.get();
+  const target = legacyOfficeUpgradeTarget(initial?.fileType);
+  const [waiting, setWaiting] = createSignal(
+    !!initial && !!target && shouldAwaitLegacyUpgrade(initial, Date.now())
+  );
+
+  onMount(() => {
+    if (!target || !waiting()) return;
+    const controller = new AbortController();
+    onCleanup(() => controller.abort());
+
+    void (async () => {
+      const upgraded = await pollForLegacyUpgrade({
+        target,
+        fetchMetadata: () => fetchDocumentMetadata(documentId),
+        fileTypeOf: (metadata) => metadata.fileType,
+        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+        signal: controller.signal,
+      });
+      if (controller.signal.aborted) return;
+      if (!upgraded) {
+        setWaiting(false);
+        return;
+      }
+      // Word content becomes readable once the DOCX pipeline processes it.
+      if (target === 'docx') {
+        await waitForDocumentContentReady({
+          documentId,
+          timeoutMs: 60_000,
+        }).catch(() => undefined);
+        if (controller.signal.aborted) return;
+      }
+      const blockName = fileTypeToBlockName(upgraded.fileType);
+      if (blockName === 'unknown') {
+        // Excel workbooks stay in this block, which previews them.
+        blockMetadataSignal.set(upgraded);
+        setWaiting(false);
+        return;
+      }
+      replaceSplit({ content: { type: blockName, id: documentId } });
+    })();
+  });
+
+  return () => (waiting() && target ? upgradedOfficeLabel(target) : undefined);
+}
diff --git a/apps/web/src/features/block-unknown/component/UnknownContent.test.tsx b/apps/web/src/features/block-unknown/component/UnknownContent.test.tsx
new file mode 100644
index 00000000000..25d6483c16c
--- /dev/null
+++ b/apps/web/src/features/block-unknown/component/UnknownContent.test.tsx
@@ -0,0 +1,38 @@
+import { cleanup, render, screen } from '@solidjs/testing-library';
+import { afterEach, expect, it, vi } from 'vitest';
+import { UnknownContent } from './UnknownContent';
+
+afterEach(cleanup);
+
+it('offers the file when there is no preview', () => {
+  render(() => (
+    <UnknownContent
+      fileName="notes.bin"
+      onShare={vi.fn()}
+      onDownload={vi.fn()}
+    />
+  ));
+
+  expect(screen.getByText(/No preview available for/)).toBeTruthy();
+  expect(screen.queryByTestId('legacy-office-converting')).toBeNull();
+  expect(screen.getByText('Download')).toBeTruthy();
+});
+
+it('says a legacy Office file is being converted and still offers the original', () => {
+  const onDownload = vi.fn();
+  render(() => (
+    <UnknownContent
+      fileName="Board Update.ppt"
+      convertingTo="PowerPoint presentation"
+      onShare={vi.fn()}
+      onDownload={onDownload}
+    />
+  ));
+
+  const status = screen.getByTestId('legacy-office-converting');
+  expect(status.textContent).toContain('Board Update.ppt');
+  expect(status.textContent).toContain('to a PowerPoint presentation');
+  expect(screen.queryByText(/No preview available/)).toBeNull();
+  screen.getByText('Download').click();
+  expect(onDownload).toHaveBeenCalledOnce();
+});
diff --git a/apps/web/src/features/block-unknown/component/UnknownContent.tsx b/apps/web/src/features/block-unknown/component/UnknownContent.tsx
index 98c9ee2c75e..64f44dfae2c 100644
--- a/apps/web/src/features/block-unknown/component/UnknownContent.tsx
+++ b/apps/web/src/features/block-unknown/component/UnknownContent.tsx
@@ -1,19 +1,41 @@
+import { LoadingSpinner } from '@core/component/LoadingSpinner';
 import ShareFat from '@icon/share.svg';
 import DownloadSimple from '@phosphor/download-simple.svg';
 import { Button } from '@ui';
+import { Show } from 'solid-js';
 
 export function UnknownContent(props: {
   fileName: string;
+  /** Set while a legacy Office file is being upgraded, e.g. "PowerPoint presentation". */
+  convertingTo?: string;
   onShare: () => void;
   onDownload: () => void;
 }) {
   return (
     <div class="flex h-full flex-col items-center justify-center">
       <div class="mx-4 flex w-fit flex-col items-center justify-center gap-4 p-4">
-        <div class="text-center text-lg">
-          No preview available for{' '}
-          <span class="text-ink-muted">{props.fileName}</span>
-        </div>
+        <Show
+          when={props.convertingTo}
+          fallback={
+            <div class="text-center text-lg">
+              No preview available for{' '}
+              <span class="text-ink-muted">{props.fileName}</span>
+            </div>
+          }
+        >
+          {(convertingTo) => (
+            <div
+              class="flex flex-col items-center gap-2 text-center text-lg"
+              data-testid="legacy-office-converting"
+            >
+              <LoadingSpinner class="size-5" />
+              <div>
+                Converting <span class="text-ink-muted">{props.fileName}</span>{' '}
+                to a {convertingTo()}…
+              </div>
+            </div>
+          )}
+        </Show>
 
         <div class="flex flex-row items-center gap-2">
           <Button variant="accent" onClick={props.onShare}>
diff --git a/apps/web/src/features/block-unknown/legacy-office.test.ts b/apps/web/src/features/block-unknown/legacy-office.test.ts
new file mode 100644
index 00000000000..c1e1ae7cb2b
--- /dev/null
+++ b/apps/web/src/features/block-unknown/legacy-office.test.ts
@@ -0,0 +1,178 @@
+import { describe, expect, it, vi } from 'vitest';
+import {
+  LEGACY_UPGRADE_WINDOW_MS,
+  legacyOfficeUpgradeTarget,
+  pollForLegacyUpgrade,
+  shouldAwaitLegacyUpgrade,
+  upgradedOfficeLabel,
+} from './legacy-office';
+
+describe('legacyOfficeUpgradeTarget', () => {
+  it('maps legacy Office types to OpenXML', () => {
+    expect(legacyOfficeUpgradeTarget('doc')).toBe('docx');
+    expect(legacyOfficeUpgradeTarget('ppt')).toBe('pptx');
+    expect(legacyOfficeUpgradeTarget('xls')).toBe('xlsx');
+    expect(legacyOfficeUpgradeTarget('PPT')).toBe('pptx');
+  });
+
+  it('ignores types that are not upgraded', () => {
+    for (const fileType of ['docx', 'pptx', 'xlsx', 'xlsm', 'pdf', '', null]) {
+      expect(legacyOfficeUpgradeTarget(fileType)).toBeUndefined();
+    }
+  });
+
+  it('labels each target', () => {
+    expect(upgradedOfficeLabel('docx')).toBe('Word document');
+    expect(upgradedOfficeLabel('pptx')).toBe('PowerPoint presentation');
+    expect(upgradedOfficeLabel('xlsx')).toBe('Excel workbook');
+  });
+});
+
+describe('shouldAwaitLegacyUpgrade', () => {
+  const now = Date.parse('2026-10-06T12:00:00Z');
+
+  it('waits for a recent legacy upload', () => {
+    expect(
+      shouldAwaitLegacyUpgrade(
+        { fileType: 'ppt', createdAt: '2026-10-06T11:59:00Z' },
+        now
+      )
+    ).toBe(true);
+  });
+
+  it('does not wait for old legacy documents', () => {
+    expect(
+      shouldAwaitLegacyUpgrade(
+        {
+          fileType: 'ppt',
+          createdAt: new Date(now - LEGACY_UPGRADE_WINDOW_MS).toISOString(),
+        },
+        now
+      )
+    ).toBe(false);
+  });
+
+  it('does not wait without a usable creation time or legacy type', () => {
+    expect(shouldAwaitLegacyUpgrade({ fileType: 'doc' }, now)).toBe(false);
+    expect(
+      shouldAwaitLegacyUpgrade(
+        { fileType: 'doc', createdAt: 'not a date' },
+        now
+      )
+    ).toBe(false);
+    expect(
+      shouldAwaitLegacyUpgrade(
+        { fileType: 'pdf', createdAt: '2026-10-06T11:59:00Z' },
+        now
+      )
+    ).toBe(false);
+  });
+});
+
+describe('pollForLegacyUpgrade', () => {
+  function clock() {
+    let time = 0;
+    return {
+      now: () => time,
+      sleep: vi.fn(async (ms: number) => {
+        time += ms;
+      }),
+    };
+  }
+
+  it('resolves once the file type changes', async () => {
+    const { now, sleep } = clock();
+    const fetchMetadata = vi
+      .fn<() => Promise<{ fileType: string }>>()
+      .mockResolvedValueOnce({ fileType: 'ppt' })
+      .mockResolvedValueOnce({ fileType: 'ppt' })
+      .mockResolvedValueOnce({ fileType: 'pptx' });
+
+    const result = await pollForLegacyUpgrade({
+      target: 'pptx',
+      fetchMetadata,
+      fileTypeOf: (m) => m.fileType,
+      sleep,
+      now,
+      intervalMs: 1_000,
+    });
+
+    expect(result).toEqual({ fileType: 'pptx' });
+    expect(fetchMetadata).toHaveBeenCalledTimes(3);
+    expect(sleep).toHaveBeenCalledTimes(2);
+  });
+
+  it('retries failed requests', async () => {
+    const { now, sleep } = clock();
+    const fetchMetadata = vi
+      .fn<() => Promise<{ fileType: string }>>()
+      .mockRejectedValueOnce(new Error('offline'))
+      .mockResolvedValueOnce({ fileType: 'docx' });
+
+    const result = await pollForLegacyUpgrade({
+      target: 'docx',
+      fetchMetadata,
+      fileTypeOf: (m) => m.fileType,
+      sleep,
+      now,
+    });
+
+    expect(result).toEqual({ fileType: 'docx' });
+  });
+
+  it('gives up at the timeout', async () => {
+    const { now, sleep } = clock();
+    const fetchMetadata = vi.fn(async () => ({ fileType: 'xls' }));
+
+    const result = await pollForLegacyUpgrade({
+      target: 'xlsx',
+      fetchMetadata,
+      fileTypeOf: (m) => m.fileType,
+      sleep,
+      now,
+      intervalMs: 1_000,
+      timeoutMs: 5_000,
+    });
+
+    expect(result).toBeUndefined();
+    expect(fetchMetadata).toHaveBeenCalledTimes(5);
+  });
+
+  it('stops when aborted', async () => {
+    const { now, sleep } = clock();
+    const controller = new AbortController();
+    const fetchMetadata = vi.fn(async () => {
+      controller.abort();
+      return { fileType: 'doc' };
+    });
+
+    const result = await pollForLegacyUpgrade({
+      target: 'docx',
+      fetchMetadata,
+      fileTypeOf: (m) => m.fileType,
+      sleep,
+      now,
+      signal: controller.signal,
+    });
+
+    expect(result).toBeUndefined();
+    expect(fetchMetadata).toHaveBeenCalledTimes(1);
+    expect(sleep).not.toHaveBeenCalled();
+  });
+
+  it('does not accept a different target', async () => {
+    const { now, sleep } = clock();
+
+    const result = await pollForLegacyUpgrade({
+      target: 'pptx',
+      fetchMetadata: async () => ({ fileType: 'docx' }),
+      fileTypeOf: (m) => m.fileType,
+      sleep,
+      now,
+      intervalMs: 1_000,
+      timeoutMs: 2_000,
+    });
+
+    expect(result).toBeUndefined();
+  });
+});
diff --git a/apps/web/src/features/block-unknown/legacy-office.ts b/apps/web/src/features/block-unknown/legacy-office.ts
new file mode 100644
index 00000000000..868f5774fdc
--- /dev/null
+++ b/apps/web/src/features/block-unknown/legacy-office.ts
@@ -0,0 +1,89 @@
+/**
+ * Legacy binary Office uploads (.doc, .ppt, .xls) are upgraded to OpenXML on
+ * the server shortly after upload. While that runs the document still has its
+ * legacy file type and opens here; these helpers decide whether to wait for
+ * the upgrade and detect when it lands.
+ */
+
+export type UpgradedOfficeType = 'docx' | 'pptx' | 'xlsx';
+
+const UPGRADE_TARGETS: Record<string, UpgradedOfficeType> = {
+  doc: 'docx',
+  ppt: 'pptx',
+  xls: 'xlsx',
+};
+
+const UPGRADE_LABELS: Record<UpgradedOfficeType, string> = {
+  docx: 'Word document',
+  pptx: 'PowerPoint presentation',
+  xlsx: 'Excel workbook',
+};
+
+/** Documents older than this were uploaded before upgrades or failed them. */
+export const LEGACY_UPGRADE_WINDOW_MS = 10 * 60 * 1000;
+
+export function legacyOfficeUpgradeTarget(
+  fileType: string | null | undefined
+): UpgradedOfficeType | undefined {
+  return fileType ? UPGRADE_TARGETS[fileType.toLowerCase()] : undefined;
+}
+
+export function upgradedOfficeLabel(target: UpgradedOfficeType): string {
+  return UPGRADE_LABELS[target];
+}
+
+/** Whether an upgrade for this document may still be on its way. */
+export function shouldAwaitLegacyUpgrade(
+  document: { fileType?: string | null; createdAt?: string | null },
+  now: number
+): boolean {
+  if (!legacyOfficeUpgradeTarget(document.fileType)) return false;
+  if (!document.createdAt) return false;
+  const created = Date.parse(document.createdAt);
+  if (Number.isNaN(created)) return false;
+  return now - created < LEGACY_UPGRADE_WINDOW_MS;
+}
+
+export type PollForUpgradeOptions<M> = {
+  target: UpgradedOfficeType;
+  fetchMetadata: () => Promise<M>;
+  fileTypeOf: (metadata: M) => string | null | undefined;
+  sleep: (ms: number) => Promise<void>;
+  intervalMs?: number;
+  timeoutMs?: number;
+  now?: () => number;
+  signal?: AbortSignal;
+};
+
+/**
+ * Polls document metadata until its file type becomes `target`. Resolves with
+ * that metadata, or `undefined` on timeout or abort. Failed requests are
+ * retried until the timeout.
+ */
+export async function pollForLegacyUpgrade<M>(
+  options: PollForUpgradeOptions<M>
+): Promise<M | undefined> {
+  const {
+    target,
+    fetchMetadata,
+    fileTypeOf,
+    sleep,
+    intervalMs = 3_000,
+    timeoutMs = 3 * 60 * 1000,
+    now = Date.now,
+    signal,
+  } = options;
+  const deadline = now() + timeoutMs;
+
+  while (!signal?.aborted && now() < deadline) {
+    try {
+      const metadata = await fetchMetadata();
+      if (fileTypeOf(metadata)?.toLowerCase() === target) return metadata;
+    } catch {
+      // Keep waiting: a transient failure should not end the wait.
+    }
+    if (signal?.aborted) break;
+    await sleep(intervalMs);
+  }
+  return undefined;
+}
diff --git a/crates/documents/src/domain.rs b/crates/documents/src/domain.rs
index 7a699c4f6b8..e1518e3099b 100644
--- a/crates/documents/src/domain.rs
+++ b/crates/documents/src/domain.rs
@@ -25,6 +25,10 @@ pub mod starter;
 #[cfg(feature = "ports")]
 pub mod upload_finalize;
 
+/// Legacy Office (.doc/.ppt/.xls) upgrades to OpenXML.
+#[cfg(feature = "ports")]
+pub mod legacy_office_upgrade;
+
 pub mod models;
 #[cfg(feature = "axum")]
 pub mod permission_token;
diff --git a/crates/documents/src/domain/legacy_office_upgrade.rs b/crates/documents/src/domain/legacy_office_upgrade.rs
new file mode 100644
index 00000000000..e779327cd57
--- /dev/null
+++ b/crates/documents/src/domain/legacy_office_upgrade.rs
@@ -0,0 +1,336 @@
+//! Upgrading legacy binary Office uploads (`.doc`, `.ppt`, `.xls`) to their
+//! OpenXML equivalents so they open in the native Word, PowerPoint, and
+//! spreadsheet surfaces.
+//!
+//! The upgrade runs in two steps, both driven by object-created events:
+//!
+//! 1. When the legacy original lands, [`LegacyOfficeUpgrader::request_upgrade`]
+//!    asks the conversion service to write `upgraded.{docx,pptx,xlsx}` next to
+//!    it. The original stays ready, so the document is downloadable even if
+//!    conversion fails.
+//! 2. When the upgraded object lands, [`LegacyOfficeUpgrader::apply_upgrade`]
+//!    makes it the document's current version and switches the file type.
+//!    PowerPoint and Excel become a new document instance; Word becomes a new
+//!    DOCX BOM staged for the regular DOCX pipeline.
+
+use std::future::Future;
+
+use model::document::{DocumentBasic, FileType};
+use model_owner::Owner;
+
+use super::content::{DocumentContent, DocumentContentLocation};
+use super::models::DocumentError;
+
+/// The OpenXML format a legacy binary Office type is upgraded to.
+pub fn upgrade_target(file_type: FileType) -> Option<FileType> {
+    match file_type {
+        FileType::Doc => Some(FileType::Docx),
+        FileType::Ppt => Some(FileType::Pptx),
+        FileType::Xls => Some(FileType::Xlsx),
+        _ => None,
+    }
+}
+
+/// The legacy binary Office type an OpenXML format is upgraded from.
+pub fn upgrade_source(target: FileType) -> Option<FileType> {
+    match target {
+        FileType::Docx => Some(FileType::Doc),
+        FileType::Pptx => Some(FileType::Ppt),
+        FileType::Xlsx => Some(FileType::Xls),
+        _ => None,
+    }
+}
+
+/// A request to convert a legacy original into its OpenXML equivalent.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct LegacyOfficeUpgradeRequest {
+    /// The document owner, which prefixes every object key.
+    pub owner: Owner,
+    /// The document being upgraded.
+    pub document_id: String,
+    /// The version holding the legacy original.
+    pub source_version_id: i64,
+    /// The legacy type.
+    pub from: FileType,
+    /// The OpenXML type.
+    pub to: FileType,
+}
+
+/// Where the upgraded object is copied to become the document's content.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum UpgradedObjectDestination {
+    /// A document instance in the document storage bucket.
+    DocumentVersion {
+        /// The new document instance id.
+        version_id: i64,
+    },
+    /// A DOCX BOM in the DOCX staging bucket, picked up by the DOCX pipeline.
+    DocxStaging {
+        /// The new DOCX BOM id.
+        bom_id: i64,
+    },
+}
+
+/// Object storage and conversion capabilities for legacy upgrades.
+pub trait LegacyOfficeUpgradeStoragePort: Send + Sync {
+    /// Ask the conversion service to write the upgraded object.
+    fn request_upgrade(
+        &self,
+        request: &LegacyOfficeUpgradeRequest,
+    ) -> impl Future<Output = Result<(), DocumentError>> + Send;
+
+    /// SHA-256 of the upgraded object, recorded on the new document instance.
+    fn upgraded_object_sha(
+        &self,
+        owner: &Owner,
+        document_id: &str,
+        target: FileType,
+    ) -> impl Future<Output = Result<String, DocumentError>> + Send;
+
+    /// Copy the upgraded object to the destination that serves it.
+    fn promote_upgraded_object(
+        &self,
+        owner: &Owner,
+        document_id: &str,
+        target: FileType,
+        destination: UpgradedObjectDestination,
+    ) -> impl Future<Output = Result<(), DocumentError>> + Send;
+}
+
+/// Document persistence needed to swap in an upgraded version.
+pub trait LegacyOfficeUpgradeRepoPort: Send + Sync {
+    /// Insert a document instance (version) and return its id.
+    fn create_document_instance(
+        &self,
+        document_id: &str,
+        sha: &str,
+    ) -> impl Future<Output = Result<i64, DocumentError>> + Send;
+
+    /// Delete a document instance created for an upgrade that did not finish.
+    fn delete_document_instance(
+        &self,
+        version_id: i64,
+    ) -> impl Future<Output = Result<(), DocumentError>> + Send;
+
+    /// Insert a DOCX BOM (version) and return its id.
+    fn create_document_bom(
+        &self,
+        document_id: &str,
+    ) -> impl Future<Output = Result<i64, DocumentError>> + Send;
+
+    /// Delete a DOCX BOM created for an upgrade that did not finish.
+    fn delete_document_bom(
+        &self,
+        bom_id: i64,
+    ) -> impl Future<Output = Result<(), DocumentError>> + Send;
+
+    /// Change the document's file type from `from` to `to` if it is still
+    /// `from`. Returns whether this call made the change.
+    fn swap_document_file_type(
+        &self,
+        document_id: &str,
+        from: FileType,
+        to: FileType,
+    ) -> impl Future<Output = Result<bool, DocumentError>> + Send;
+
+    /// Persist content lifecycle metadata.
+    fn set_document_content(
+        &self,
+        document_id: &str,
+        content: DocumentContent,
+    ) -> impl Future<Output = Result<(), DocumentError>> + Send;
+}
+
+/// What [`LegacyOfficeUpgrader::apply_upgrade`] did.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum UpgradeOutcome {
+    /// The upgraded object is now the document's content.
+    Applied,
+    /// The document is not (or no longer) the legacy source of this upgrade,
+    /// e.g. a redelivered event after the upgrade already applied.
+    Skipped,
+}
+
+/// Runs both steps of a legacy Office upgrade.
+pub struct LegacyOfficeUpgrader<'a, R, S> {
+    repo: &'a R,
+    storage: &'a S,
+}
+
+impl<'a, R, S> LegacyOfficeUpgrader<'a, R, S>
+where
+    R: LegacyOfficeUpgradeRepoPort,
+    S: LegacyOfficeUpgradeStoragePort,
+{
+    /// Construct an upgrader.
+    pub fn new(repo: &'a R, storage: &'a S) -> Self {
+        Self { repo, storage }
+    }
+
+    /// Request an upgrade when `version_id` holds a legacy Office original.
+    /// Returns whether one was requested.
+    #[tracing::instrument(skip(self, document_context), fields(document_id = %document_context.document_id), err)]
+    pub async fn request_upgrade(
+        &self,
+        document_context: &DocumentBasic,
+        version_id: i64,
+    ) -> Result<bool, DocumentError> {
+        let Some(from) = document_context.try_file_type() else {
+            return Ok(false);
+        };
+        let Some(to) = upgrade_target(from) else {
+            return Ok(false);
+        };
+
+        self.storage
+            .request_upgrade(&LegacyOfficeUpgradeRequest {
+                owner: document_context.owner.clone(),
+                document_id: document_context.document_id.clone(),
+                source_version_id: version_id,
+                from,
+                to,
+            })
+            .await?;
+        Ok(true)
+    }
+
+    /// Make the upgraded `target` object the document's content.
+    ///
+    /// Safe to repeat: once applied, the file type no longer matches the
+    /// legacy source and later calls skip. The file type is swapped before
+    /// the object is copied so the copy's own object-created event sees the
+    /// new type and does not request another upgrade.
+    #[tracing::instrument(skip(self, document_context), fields(document_id = %document_context.document_id), err)]
+    pub async fn apply_upgrade(
+        &self,
+        document_context: &DocumentBasic,
+        target: FileType,
+    ) -> Result<UpgradeOutcome, DocumentError> {
+        let Some(source) = upgrade_source(target) else {
+            return Err(DocumentError::BadRequest(format!(
+                "{target} is not an upgrade target"
+            )));
+        };
+        if document_context.try_file_type() != Some(source) {
+            return Ok(UpgradeOutcome::Skipped);
+        }
+
+        match target {
+            FileType::Docx => self.apply_docx_upgrade(document_context, source).await,
+            _ => {
+                self.apply_versioned_upgrade(document_context, source, target)
+                    .await
+            }
+        }
+    }
+
+    async fn apply_versioned_upgrade(
+        &self,
+        document_context: &DocumentBasic,
+        source: FileType,
+        target: FileType,
+    ) -> Result<UpgradeOutcome, DocumentError> {
+        let document_id = &document_context.document_id;
+        let owner = &document_context.owner;
+
+        let sha = self
+            .storage
+            .upgraded_object_sha(owner, document_id, target)
+            .await?;
+        let version_id = self
+            .repo
+            .create_document_instance(document_id, &sha)
+            .await?;
+
+        if !self
+            .repo
+            .swap_document_file_type(document_id, source, target)
+            .await?
+        {
+            self.repo.delete_document_instance(version_id).await?;
+            return Ok(UpgradeOutcome::Skipped);
+        }
+
+        if let Err(error) = self
+            .storage
+            .promote_upgraded_object(
+                owner,
+                document_id,
+                target,
+                UpgradedObjectDestination::DocumentVersion { version_id },
+            )
+            .await
+        {
+            self.repo
+                .swap_document_file_type(document_id, target, source)
+                .await?;
+            self.repo.delete_document_instance(version_id).await?;
+            return Err(error);
+        }
+
+        self.repo
+            .set_document_content(
+                document_id,
+                DocumentContent::ready(DocumentContentLocation::ObjectStorage),
+            )
+            .await?;
+        Ok(UpgradeOutcome::Applied)
+    }
+
+    async fn apply_docx_upgrade(
+        &self,
+        document_context: &DocumentBasic,
+        source: FileType,
+    ) -> Result<UpgradeOutcome, DocumentError> {
+        let document_id = &document_context.document_id;
+        let owner = &document_context.owner;
+
+        let bom_id = self.repo.create_document_bom(document_id).await?;
+
+        if !self
+            .repo
+            .swap_document_file_type(document_id, source, FileType::Docx)
+            .await?
+        {
+            self.repo.delete_document_bom(bom_id).await?;
+            return Ok(UpgradeOutcome::Skipped);
+        }
+
+        // The DOCX pipeline marks the content ready once it has processed the
+        // staged file, exactly as for a DOCX upload.
+        self.repo
+            .set_document_content(
+                document_id,
+                DocumentContent::pending_at(DocumentContentLocation::ConvertedPdf),
+            )
+            .await?;
+
+        if let Err(error) = self
+            .storage
+            .promote_upgraded_object(
+                owner,
+                document_id,
+                FileType::Docx,
+                UpgradedObjectDestination::DocxStaging { bom_id },
+            )
+            .await
+        {
+            self.repo
+                .swap_document_file_type(document_id, FileType::Docx, source)
+                .await?;
+            self.repo.delete_document_bom(bom_id).await?;
+            self.repo
+                .set_document_content(
+                    document_id,
+                    DocumentContent::ready(DocumentContentLocation::ObjectStorage),
+                )
+                .await?;
+            return Err(error);
+        }
+
+        Ok(UpgradeOutcome::Applied)
+    }
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/documents/src/domain/legacy_office_upgrade/tests.rs b/crates/documents/src/domain/legacy_office_upgrade/tests.rs
new file mode 100644
index 00000000000..21c15b5519c
--- /dev/null
+++ b/crates/documents/src/domain/legacy_office_upgrade/tests.rs
@@ -0,0 +1,556 @@
+use std::str::FromStr;
+use std::sync::Mutex;
+
+use super::*;
+use crate::domain::content::DocumentContentState;
+
+const DOCUMENT_ID: &str = "doc-1";
+
+#[derive(Clone, Debug, PartialEq)]
+enum Call {
+    RequestUpgrade(LegacyOfficeUpgradeRequest),
+    Sha(FileType),
+    Promote(FileType, UpgradedObjectDestination),
+    CreateInstance(String),
+    DeleteInstance(i64),
+    CreateBom,
+    DeleteBom(i64),
+    Swap(FileType, FileType),
+    SetContent(DocumentContentState, Option<DocumentContentLocation>),
+}
+
+#[derive(Default)]
+struct Fake {
+    calls: Mutex<Vec<Call>>,
+    /// The document's stored file type, which swaps compare against.
+    file_type: Mutex<Option<FileType>>,
+    fail_promote: bool,
+    fail_sha: bool,
+    fail_request: bool,
+}
+
+impl Fake {
+    fn with_type(file_type: FileType) -> Self {
+        Self {
+            file_type: Mutex::new(Some(file_type)),
+            ..Self::default()
+        }
+    }
+
+    fn record(&self, call: Call) {
+        self.calls.lock().unwrap().push(call);
+    }
+
+    fn calls(&self) -> Vec<Call> {
+        self.calls.lock().unwrap().clone()
+    }
+
+    fn stored_type(&self) -> Option<FileType> {
+        *self.file_type.lock().unwrap()
+    }
+}
+
+fn storage_error() -> DocumentError {
+    DocumentError::Internal(anyhow::anyhow!("storage unavailable"))
+}
+
+impl LegacyOfficeUpgradeStoragePort for Fake {
+    async fn request_upgrade(
+        &self,
+        request: &LegacyOfficeUpgradeRequest,
+    ) -> Result<(), DocumentError> {
+        self.record(Call::RequestUpgrade(request.clone()));
+        if self.fail_request {
+            return Err(storage_error());
+        }
+        Ok(())
+    }
+
+    async fn upgraded_object_sha(
+        &self,
+        _owner: &Owner,
+        _document_id: &str,
+        target: FileType,
+    ) -> Result<String, DocumentError> {
+        self.record(Call::Sha(target));
+        if self.fail_sha {
+            return Err(storage_error());
+        }
+        Ok("upgraded-sha".to_string())
+    }
+
+    async fn promote_upgraded_object(
+        &self,
+        _owner: &Owner,
+        _document_id: &str,
+        target: FileType,
+        destination: UpgradedObjectDestination,
+    ) -> Result<(), DocumentError> {
+        self.record(Call::Promote(target, destination));
+        if self.fail_promote {
+            return Err(storage_error());
+        }
+        Ok(())
+    }
+}
+
+impl LegacyOfficeUpgradeRepoPort for Fake {
+    async fn create_document_instance(
+        &self,
+        _document_id: &str,
+        sha: &str,
+    ) -> Result<i64, DocumentError> {
+        self.record(Call::CreateInstance(sha.to_string()));
+        Ok(42)
+    }
+
+    async fn delete_document_instance(&self, version_id: i64) -> Result<(), DocumentError> {
+        self.record(Call::DeleteInstance(version_id));
+        Ok(())
+    }
+
+    async fn create_document_bom(&self, _document_id: &str) -> Result<i64, DocumentError> {
+        self.record(Call::CreateBom);
+        Ok(7)
+    }
+
+    async fn delete_document_bom(&self, bom_id: i64) -> Result<(), DocumentError> {
+        self.record(Call::DeleteBom(bom_id));
+        Ok(())
+    }
+
+    async fn swap_document_file_type(
+        &self,
+        _document_id: &str,
+        from: FileType,
+        to: FileType,
+    ) -> Result<bool, DocumentError> {
+        self.record(Call::Swap(from, to));
+        let mut stored = self.file_type.lock().unwrap();
+        if *stored != Some(from) {
+            return Ok(false);
+        }
+        *stored = Some(to);
+        Ok(true)
+    }
+
+    async fn set_document_content(
+        &self,
+        _document_id: &str,
+        content: DocumentContent,
+    ) -> Result<(), DocumentError> {
+        self.record(Call::SetContent(content.state, content.location));
+        Ok(())
+    }
+}
+
+fn owner() -> Owner {
+    Owner::from_principal_str("macro|owner@macro.com").unwrap()
+}
+
+fn document(file_type: Option<&str>) -> DocumentBasic {
+    DocumentBasic {
+        document_id: DOCUMENT_ID.to_string(),
+        document_name: "Quarterly".to_string(),
+        owner: owner(),
+        file_type: file_type.map(str::to_string),
+        sub_type: None,
+        branched_from_id: None,
+        branched_from_version_id: None,
+        document_family_id: None,
+        project_id: None,
+        deleted_at: None,
+    }
+}
+
+#[test]
+fn legacy_types_map_to_openxml_and_back() {
+    for (legacy, openxml) in [
+        (FileType::Doc, FileType::Docx),
+        (FileType::Ppt, FileType::Pptx),
+        (FileType::Xls, FileType::Xlsx),
+    ] {
+        assert_eq!(upgrade_target(legacy), Some(openxml));
+        assert_eq!(upgrade_source(openxml), Some(legacy));
+    }
+}
+
+#[test]
+fn other_types_have_no_upgrade() {
+    for file_type in [
+        FileType::Docx,
+        FileType::Pptx,
+        FileType::Xlsx,
+        FileType::Xlsm,
+        FileType::Pdf,
+        FileType::Md,
+        FileType::Spreadsheet,
+    ] {
+        assert_eq!(upgrade_target(file_type), None, "{file_type}");
+    }
+    for file_type in [
+        FileType::Doc,
+        FileType::Ppt,
+        FileType::Xls,
+        FileType::Pdf,
+        FileType::Xlsm,
+    ] {
+        assert_eq!(upgrade_source(file_type), None, "{file_type}");
+    }
+}
+
+#[tokio::test]
+async fn requests_upgrade_for_each_legacy_type() {
+    for (legacy, openxml) in [
+        ("doc", FileType::Docx),
+        ("ppt", FileType::Pptx),
+        ("xls", FileType::Xlsx),
+    ] {
+        let fake = Fake::default();
+        let upgrader = LegacyOfficeUpgrader::new(&fake, &fake);
+
+        let requested = upgrader
+            .request_upgrade(&document(Some(legacy)), 11)
+            .await
+            .unwrap();
+
+        assert!(requested, "{legacy}");
+        assert_eq!(
+            fake.calls(),
+            vec![Call::RequestUpgrade(LegacyOfficeUpgradeRequest {
+                owner: owner(),
+                document_id: DOCUMENT_ID.to_string(),
+                source_version_id: 11,
+                from: FileType::from_str(legacy).unwrap(),
+                to: openxml,
+            })]
+        );
+    }
+}
+
+#[tokio::test]
+async fn requests_upgrade_for_uppercase_stored_type() {
+    let fake = Fake::default();
+    let upgrader = LegacyOfficeUpgrader::new(&fake, &fake);
+
+    assert!(
+        upgrader
+            .request_upgrade(&document(Some("PPT")), 3)
+            .await
+            .unwrap()
+    );
+}
+
+#[tokio::test]
+async fn does_not_request_upgrade_for_modern_or_unknown_types() {
+    for file_type in [
+        Some("docx"),
+        Some("pptx"),
+        Some("xlsx"),
+        Some("xlsm"),
+        Some("pdf"),
+        Some("not-a-type"),
+        None,
+    ] {
+        let fake = Fake::default();
+        let upgrader = LegacyOfficeUpgrader::new(&fake, &fake);
+
+        let requested = upgrader
+            .request_upgrade(&document(file_type), 1)
+            .await
+            .unwrap();
+
+        assert!(!requested, "{file_type:?}");
+        assert!(fake.calls().is_empty(), "{file_type:?}");
+    }
+}
+
+#[tokio::test]
+async fn request_failure_is_returned() {
+    let fake = Fake {
+        fail_request: true,
+        ..Fake::default()
+    };
+    let upgrader = LegacyOfficeUpgrader::new(&fake, &fake);
+
+    assert!(
+        upgrader
+            .request_upgrade(&document(Some("doc")), 1)
+            .await
+            .is_err()
+    );
+}
+
+#[tokio::test]
+async fn applies_presentation_upgrade_as_new_version() {
+    let fake = Fake::with_type(FileType::Ppt);
+    let upgrader = LegacyOfficeUpgrader::new(&fake, &fake);
+
+    let outcome = upgrader
+        .apply_upgrade(&document(Some("ppt")), FileType::Pptx)
+        .await
+        .unwrap();
+
+    assert_eq!(outcome, UpgradeOutcome::Applied);
+    assert_eq!(fake.stored_type(), Some(FileType::Pptx));
+    assert_eq!(
+        fake.calls(),
+        vec![
+            Call::Sha(FileType::Pptx),
+            Call::CreateInstance("upgraded-sha".to_string()),
+            // The type changes before the copy, so the copy's object-created
+            // event sees pptx and requests nothing.
+            Call::Swap(FileType::Ppt, FileType::Pptx),
+            Call::Promote(
+                FileType::Pptx,
+                UpgradedObjectDestination::DocumentVersion { version_id: 42 }
+            ),
+            Call::SetContent(
+                DocumentContentState::Ready,
+                Some(DocumentContentLocation::ObjectStorage)
+            ),
+        ]
+    );
+}
+
+#[tokio::test]
+async fn applies_workbook_upgrade_as_new_version() {
+    let fake = Fake::with_type(FileType::Xls);
+    let upgrader = LegacyOfficeUpgrader::new(&fake, &fake);
+
+    let outcome = upgrader
+        .apply_upgrade(&document(Some("xls")), FileType::Xlsx)
+        .await
+        .unwrap();
+
+    assert_eq!(outcome, UpgradeOutcome::Applied);
+    assert_eq!(fake.stored_type(), Some(FileType::Xlsx));
+    assert!(fake.calls().contains(&Call::Promote(
+        FileType::Xlsx,
+        UpgradedObjectDestination::DocumentVersion { version_id: 42 }
+    )));
+}
+
+#[tokio::test]
+async fn applies_word_upgrade_through_the_docx_pipeline() {
+    let fake = Fake::with_type(FileType::Doc);
+    let upgrader = LegacyOfficeUpgrader::new(&fake, &fake);
+
+    let outcome = upgrader
+        .apply_upgrade(&document(Some("doc")), FileType::Docx)
+        .await
+        .unwrap();
+
+    assert_eq!(outcome, UpgradeOutcome::Applied);
+    assert_eq!(fake.stored_type(), Some(FileType::Docx));
+    assert_eq!(
+        fake.calls(),
+        vec![
+            Call::CreateBom,
+            Call::Swap(FileType::Doc, FileType::Docx),
+            Call::SetContent(
+                DocumentContentState::Pending,
+                Some(DocumentContentLocation::ConvertedPdf)
+            ),
+            Call::Promote(
+                FileType::Docx,
+                UpgradedObjectDestination::DocxStaging { bom_id: 7 }
+            ),
+        ]
+    );
+}
+
+#[tokio::test]
+async fn skips_when_already_upgraded() {
+    for (stored, target) in [
+        ("pptx", FileType::Pptx),
+        ("docx", FileType::Docx),
+        ("xlsx", FileType::Xlsx),
+    ] {
+        let fake = Fake::default();
+        let upgrader = LegacyOfficeUpgrader::new(&fake, &fake);
+
+        let outcome = upgrader
+            .apply_upgrade(&document(Some(stored)), target)
+            .await
+            .unwrap();
+
+        assert_eq!(outcome, UpgradeOutcome::Skipped, "{stored}");
+        assert!(fake.calls().is_empty(), "{stored}");
+    }
+}
+
+#[tokio::test]
+async fn skips_when_the_upgrade_is_for_a_different_legacy_type() {
+    let fake = Fake::with_type(FileType::Doc);
+    let upgrader = LegacyOfficeUpgrader::new(&fake, &fake);
+
+    let outcome = upgrader
+        .apply_upgrade(&document(Some("doc")), FileType::Pptx)
+        .await
+        .unwrap();
+
+    assert_eq!(outcome, UpgradeOutcome::Skipped);
+    assert!(fake.calls().is_empty());
+}
+
+#[tokio::test]
+async fn rejects_non_upgrade_targets() {
+    let fake = Fake::with_type(FileType::Pdf);
+    let upgrader = LegacyOfficeUpgrader::new(&fake, &fake);
+
+    let error = upgrader
+        .apply_upgrade(&document(Some("pdf")), FileType::Pdf)
+        .await
+        .unwrap_err();
+
+    assert!(matches!(error, DocumentError::BadRequest(_)));
+    assert!(fake.calls().is_empty());
+}
+
+#[tokio::test]
+async fn concurrent_apply_that_loses_the_swap_cleans_up() {
+    // Another delivery already swapped the type after this one read it.
+    let fake = Fake::with_type(FileType::Pptx);
+    let upgrader = LegacyOfficeUpgrader::new(&fake, &fake);
+
+    let outcome = upgrader
+        .apply_upgrade(&document(Some("ppt")), FileType::Pptx)
+        .await
+        .unwrap();
+
+    assert_eq!(outcome, UpgradeOutcome::Skipped);
+    assert_eq!(
+        fake.calls(),
+        vec![
+            Call::Sha(FileType::Pptx),
+            Call::CreateInstance("upgraded-sha".to_string()),
+            Call::Swap(FileType::Ppt, FileType::Pptx),
+            Call::DeleteInstance(42),
+        ]
+    );
+}
+
+#[tokio::test]
+async fn concurrent_docx_apply_that_loses_the_swap_cleans_up() {
+    let fake = Fake::with_type(FileType::Docx);
+    let upgrader = LegacyOfficeUpgrader::new(&fake, &fake);
+
+    let outcome = upgrader
+        .apply_upgrade(&document(Some("doc")), FileType::Docx)
+        .await
+        .unwrap();
+
+    assert_eq!(outcome, UpgradeOutcome::Skipped);
+    assert_eq!(
+        fake.calls(),
+        vec![
+            Call::CreateBom,
+            Call::Swap(FileType::Doc, FileType::Docx),
+            Call::DeleteBom(7)
+        ]
+    );
+}
+
+#[tokio::test]
+async fn failed_copy_restores_the_legacy_document() {
+    let fake = Fake {
+        fail_promote: true,
+        ..Fake::with_type(FileType::Xls)
+    };
+    let upgrader = LegacyOfficeUpgrader::new(&fake, &fake);
+
+    let result = upgrader
+        .apply_upgrade(&document(Some("xls")), FileType::Xlsx)
+        .await;
+
+    assert!(result.is_err());
+    assert_eq!(fake.stored_type(), Some(FileType::Xls));
+    assert_eq!(
+        fake.calls()[3..],
+        [
+            Call::Promote(
+                FileType::Xlsx,
+                UpgradedObjectDestination::DocumentVersion { version_id: 42 }
+            ),
+            Call::Swap(FileType::Xlsx, FileType::Xls),
+            Call::DeleteInstance(42),
+        ]
+    );
+}
+
+#[tokio::test]
+async fn failed_docx_staging_restores_the_legacy_document() {
+    let fake = Fake {
+        fail_promote: true,
+        ..Fake::with_type(FileType::Doc)
+    };
+    let upgrader = LegacyOfficeUpgrader::new(&fake, &fake);
+
+    let result = upgrader
+        .apply_upgrade(&document(Some("doc")), FileType::Docx)
+        .await;
+
+    assert!(result.is_err());
+    assert_eq!(fake.stored_type(), Some(FileType::Doc));
+    assert_eq!(
+        fake.calls()[3..],
+        [
+            Call::Promote(
+                FileType::Docx,
+                UpgradedObjectDestination::DocxStaging { bom_id: 7 }
+            ),
+            Call::Swap(FileType::Docx, FileType::Doc),
+            Call::DeleteBom(7),
+            Call::SetContent(
+                DocumentContentState::Ready,
+                Some(DocumentContentLocation::ObjectStorage)
+            ),
+        ]
+    );
+}
+
+#[tokio::test]
+async fn unreadable_upgrade_writes_nothing() {
+    let fake = Fake {
+        fail_sha: true,
+        ..Fake::with_type(FileType::Ppt)
+    };
+    let upgrader = LegacyOfficeUpgrader::new(&fake, &fake);
+
+    let result = upgrader
+        .apply_upgrade(&document(Some("ppt")), FileType::Pptx)
+        .await;
+
+    assert!(result.is_err());
+    assert_eq!(fake.calls(), vec![Call::Sha(FileType::Pptx)]);
+    assert_eq!(fake.stored_type(), Some(FileType::Ppt));
+}
+
+#[tokio::test]
+async fn applying_twice_applies_once() {
+    let fake = Fake::with_type(FileType::Ppt);
+    let upgrader = LegacyOfficeUpgrader::new(&fake, &fake);
+
+    let first = upgrader
+        .apply_upgrade(&document(Some("ppt")), FileType::Pptx)
+        .await
+        .unwrap();
+    // A redelivered event reloads the document, which is now a pptx.
+    let second = upgrader
+        .apply_upgrade(&document(Some("pptx")), FileType::Pptx)
+        .await
+        .unwrap();
+
+    assert_eq!(
+        (first, second),
+        (UpgradeOutcome::Applied, UpgradeOutcome::Skipped)
+    );
+    assert_eq!(
+        fake.calls()
+            .iter()
+            .filter(|call| matches!(call, Call::CreateInstance(_)))
+            .count(),
+        1
+    );
+}
diff --git a/crates/documents/src/outbound/pg_document_repo.rs b/crates/documents/src/outbound/pg_document_repo.rs
index e9e1ef23128..d1adefcbb0a 100644
--- a/crates/documents/src/outbound/pg_document_repo.rs
+++ b/crates/documents/src/outbound/pg_document_repo.rs
@@ -8,6 +8,7 @@ mod tests;
 mod copy;
 mod create;
 mod edit;
+mod legacy_upgrade;
 mod markdown_backfill;
 mod share;
 
diff --git a/crates/documents/src/outbound/pg_document_repo/legacy_upgrade.rs b/crates/documents/src/outbound/pg_document_repo/legacy_upgrade.rs
new file mode 100644
index 00000000000..9e715f37f83
--- /dev/null
+++ b/crates/documents/src/outbound/pg_document_repo/legacy_upgrade.rs
@@ -0,0 +1,113 @@
+//! Persistence for swapping a legacy Office document to its OpenXML upgrade.
+
+use entity_registry::BotFacts;
+use model::document::FileType;
+
+use crate::domain::content::DocumentContent;
+use crate::domain::legacy_office_upgrade::LegacyOfficeUpgradeRepoPort;
+use crate::domain::models::DocumentError;
+use crate::domain::ports::DocumentRepo;
+
+use super::PgDocumentRepo;
+
+fn internal(error: sqlx::Error) -> DocumentError {
+    DocumentError::Internal(error.into())
+}
+
+impl<B: BotFacts + 'static> LegacyOfficeUpgradeRepoPort for PgDocumentRepo<B> {
+    #[tracing::instrument(err, skip(self))]
+    async fn create_document_instance(
+        &self,
+        document_id: &str,
+        sha: &str,
+    ) -> Result<i64, DocumentError> {
+        sqlx::query_scalar!(
+            r#"
+            INSERT INTO "DocumentInstance" ("documentId", "sha", "createdAt", "updatedAt")
+            VALUES ($1, $2, NOW(), NOW())
+            RETURNING id
+            "#,
+            document_id,
+            sha,
+        )
+        .fetch_one(&self.pool)
+        .await
+        .map_err(internal)
+    }
+
+    #[tracing::instrument(err, skip(self))]
+    async fn delete_document_instance(&self, version_id: i64) -> Result<(), DocumentError> {
+        sqlx::query!(
+            r#"DELETE FROM "DocumentInstance" WHERE id = $1"#,
+            version_id,
+        )
+        .execute(&self.pool)
+        .await
+        .map_err(internal)?;
+        Ok(())
+    }
+
+    #[tracing::instrument(err, skip(self))]
+    async fn create_document_bom(&self, document_id: &str) -> Result<i64, DocumentError> {
+        sqlx::query_scalar!(
+            r#"
+            INSERT INTO "DocumentBom" ("documentId", "createdAt", "updatedAt")
+            VALUES ($1, NOW(), NOW())
+            RETURNING id
+            "#,
+            document_id,
+        )
+        .fetch_one(&self.pool)
+        .await
+        .map_err(internal)
+    }
+
+    #[tracing::instrument(err, skip(self))]
+    async fn delete_document_bom(&self, bom_id: i64) -> Result<(), DocumentError> {
+        sqlx::query!(r#"DELETE FROM "DocumentBom" WHERE id = $1"#, bom_id)
+            .execute(&self.pool)
+            .await
+            .map_err(internal)?;
+        Ok(())
+    }
+
+    #[tracing::instrument(err, skip(self))]
+    async fn swap_document_file_type(
+        &self,
+        document_id: &str,
+        from: FileType,
+        to: FileType,
+    ) -> Result<bool, DocumentError> {
+        // Stored file types can carry the upload's casing, so compare
+        // case-insensitively and always write the canonical lowercase type.
+        let result = sqlx::query!(
+            r#"
+            UPDATE "Document"
+            SET "fileType" = $3,
+                "updatedAt" = NOW()
+            WHERE id = $1 AND LOWER("fileType") = $2
+            "#,
+            document_id,
+            from.as_str(),
+            to.as_str(),
+        )
+        .execute(&self.pool)
+        .await
+        .map_err(internal)?;
+        Ok(result.rows_affected() == 1)
+    }
+
+    #[tracing::instrument(err, skip(self, content))]
+    async fn set_document_content(
+        &self,
+        document_id: &str,
+        content: DocumentContent,
+    ) -> Result<(), DocumentError> {
+        DocumentRepo::set_document_content(self, document_id, content)
+            .await
+            .map_err(internal)
+    }
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/documents/src/outbound/pg_document_repo/legacy_upgrade/tests.rs b/crates/documents/src/outbound/pg_document_repo/legacy_upgrade/tests.rs
new file mode 100644
index 00000000000..4160756fc95
--- /dev/null
+++ b/crates/documents/src/outbound/pg_document_repo/legacy_upgrade/tests.rs
@@ -0,0 +1,205 @@
+use entity_registry::{EntityRegistryResult, OwnerGrantPolicy};
+use entity_registry_db_utils::OwnedEntityRegistrar;
+use macro_db_migrator::MACRO_DB_MIGRATIONS;
+use model_owner::Owner;
+use sqlx::{Pool, Postgres};
+
+use super::*;
+use crate::domain::content::{DocumentContentLocation, DocumentContentState};
+
+/// `txt` document with one instance in the fixture.
+const DOCUMENT_ID: &str = "d0000000-0000-0000-0000-000000000001";
+
+#[derive(Clone)]
+struct NoBots;
+
+impl BotFacts for NoBots {
+    async fn sponsor(&self, _bot: bot_id::BotId) -> EntityRegistryResult<Option<Owner>> {
+        Ok(None)
+    }
+}
+
+fn repo(pool: Pool<Postgres>) -> PgDocumentRepo<NoBots> {
+    PgDocumentRepo::new(
+        pool,
+        OwnedEntityRegistrar::new(OwnerGrantPolicy::new(NoBots)),
+    )
+}
+
+async fn set_file_type(pool: &Pool<Postgres>, file_type: &str) {
+    sqlx::query!(
+        r#"UPDATE "Document" SET "fileType" = $2 WHERE id = $1"#,
+        DOCUMENT_ID,
+        file_type,
+    )
+    .execute(pool)
+    .await
+    .unwrap();
+}
+
+async fn file_type(pool: &Pool<Postgres>) -> Option<String> {
+    sqlx::query_scalar!(
+        r#"SELECT "fileType" FROM "Document" WHERE id = $1"#,
+        DOCUMENT_ID
+    )
+    .fetch_one(pool)
+    .await
+    .unwrap()
+}
+
+#[sqlx::test(
+    migrator = "MACRO_DB_MIGRATIONS",
+    fixtures(path = "../../../../fixtures", scripts("documents_test_data"))
+)]
+async fn new_instance_becomes_the_latest_version(pool: Pool<Postgres>) {
+    let repo = repo(pool.clone());
+    let (before, _) = repo
+        .get_latest_document_version_id(DOCUMENT_ID)
+        .await
+        .unwrap();
+
+    let version_id = repo
+        .create_document_instance(DOCUMENT_ID, "upgraded-sha")
+        .await
+        .unwrap();
+
+    assert_ne!(version_id, before);
+    let (latest, _) = repo
+        .get_latest_document_version_id(DOCUMENT_ID)
+        .await
+        .unwrap();
+    assert_eq!(latest, version_id);
+    let sha = sqlx::query_scalar!(
+        r#"SELECT sha FROM "DocumentInstance" WHERE id = $1"#,
+        version_id
+    )
+    .fetch_one(&pool)
+    .await
+    .unwrap();
+    assert_eq!(sha, "upgraded-sha");
+
+    repo.delete_document_instance(version_id).await.unwrap();
+    let (restored, _) = repo
+        .get_latest_document_version_id(DOCUMENT_ID)
+        .await
+        .unwrap();
+    assert_eq!(restored, before);
+}
+
+#[sqlx::test(
+    migrator = "MACRO_DB_MIGRATIONS",
+    fixtures(path = "../../../../fixtures", scripts("documents_test_data"))
+)]
+async fn bom_can_be_created_and_removed(pool: Pool<Postgres>) {
+    let repo = repo(pool.clone());
+
+    let bom_id = repo.create_document_bom(DOCUMENT_ID).await.unwrap();
+    let count = || async {
+        sqlx::query_scalar!(
+            r#"SELECT COUNT(*) AS "count!" FROM "DocumentBom" WHERE id = $1 AND "documentId" = $2"#,
+            bom_id,
+            DOCUMENT_ID,
+        )
+        .fetch_one(&pool)
+        .await
+        .unwrap()
+    };
+    assert_eq!(count().await, 1);
+
+    repo.delete_document_bom(bom_id).await.unwrap();
+    assert_eq!(count().await, 0);
+}
+
+#[sqlx::test(
+    migrator = "MACRO_DB_MIGRATIONS",
+    fixtures(path = "../../../../fixtures", scripts("documents_test_data"))
+)]
+async fn swap_only_changes_the_expected_type(pool: Pool<Postgres>) {
+    let repo = repo(pool.clone());
+    set_file_type(&pool, "ppt").await;
+
+    assert!(
+        !repo
+            .swap_document_file_type(DOCUMENT_ID, FileType::Doc, FileType::Docx)
+            .await
+            .unwrap()
+    );
+    assert_eq!(file_type(&pool).await.as_deref(), Some("ppt"));
+
+    assert!(
+        repo.swap_document_file_type(DOCUMENT_ID, FileType::Ppt, FileType::Pptx)
+            .await
+            .unwrap()
+    );
+    assert_eq!(file_type(&pool).await.as_deref(), Some("pptx"));
+
+    // A second swap from the old type loses.
+    assert!(
+        !repo
+            .swap_document_file_type(DOCUMENT_ID, FileType::Ppt, FileType::Pptx)
+            .await
+            .unwrap()
+    );
+}
+
+#[sqlx::test(
+    migrator = "MACRO_DB_MIGRATIONS",
+    fixtures(path = "../../../../fixtures", scripts("documents_test_data"))
+)]
+async fn swap_matches_uppercase_stored_types(pool: Pool<Postgres>) {
+    let repo = repo(pool.clone());
+    set_file_type(&pool, "XLS").await;
+
+    assert!(
+        repo.swap_document_file_type(DOCUMENT_ID, FileType::Xls, FileType::Xlsx)
+            .await
+            .unwrap()
+    );
+    assert_eq!(file_type(&pool).await.as_deref(), Some("xlsx"));
+}
+
+#[sqlx::test(
+    migrator = "MACRO_DB_MIGRATIONS",
+    fixtures(path = "../../../../fixtures", scripts("documents_test_data"))
+)]
+async fn swap_on_a_missing_document_reports_no_change(pool: Pool<Postgres>) {
+    let repo = repo(pool);
+
+    assert!(
+        !repo
+            .swap_document_file_type(
+                "d0000000-0000-0000-0000-00000000ffff",
+                FileType::Doc,
+                FileType::Docx
+            )
+            .await
+            .unwrap()
+    );
+}
+
+#[sqlx::test(
+    migrator = "MACRO_DB_MIGRATIONS",
+    fixtures(path = "../../../../fixtures", scripts("documents_test_data"))
+)]
+async fn content_is_persisted(pool: Pool<Postgres>) {
+    let repo = repo(pool);
+
+    LegacyOfficeUpgradeRepoPort::set_document_content(
+        &repo,
+        DOCUMENT_ID,
+        DocumentContent::pending_at(DocumentContentLocation::ConvertedPdf),
+    )
+    .await
+    .unwrap();
+
+    let content = repo
+        .get_persisted_document_content(DOCUMENT_ID)
+        .await
+        .unwrap()
+        .unwrap();
+    assert_eq!(content.state, DocumentContentState::Pending);
+    assert_eq!(
+        content.location,
+        Some(DocumentContentLocation::ConvertedPdf)
+    );
+}
diff --git a/crates/docx_engine/tests/fixtures/upgraded-from-doc.docx b/crates/docx_engine/tests/fixtures/upgraded-from-doc.docx
new file mode 100644
index 00000000000..ec0a5870112
Binary files /dev/null and b/crates/docx_engine/tests/fixtures/upgraded-from-doc.docx differ
diff --git a/crates/docx_engine/tests/upgraded_legacy.rs b/crates/docx_engine/tests/upgraded_legacy.rs
new file mode 100644
index 00000000000..3f7485058f9
--- /dev/null
+++ b/crates/docx_engine/tests/upgraded_legacy.rs
@@ -0,0 +1,132 @@
+//! A legacy `.doc` upgraded to `.docx` by LibreOffice, as the convert service
+//! does on upload (`fixtures/upgraded-from-doc.docx`, from
+//! `services/convert_service/fixtures/legacy/memo.doc`), opens, lays out,
+//! renders, edits and saves in the engine.
+
+use docx_engine::Document;
+use docx_engine::edit::{EditOp, Pos, Session};
+use docx_engine::model::block::{BlockId, BlockKind};
+use docx_engine::render::{ImageCache, Renderer};
+use pptx_engine::font::FontDb;
+
+fn fonts() -> FontDb {
+    let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../pptx_engine/fonts");
+    let mut files: Vec<_> = std::fs::read_dir(&dir)
+        .expect("the PPTX engine's fonts")
+        .filter_map(|e| e.ok().map(|e| e.path()))
+        .filter(|p| p.extension().is_some_and(|e| e == "ttf"))
+        .collect();
+    files.sort();
+    let mut db = FontDb::new();
+    for file in files {
+        db.register(std::fs::read(file).expect("a font file"));
+    }
+    db
+}
+
+fn upgraded_bytes() -> Vec<u8> {
+    std::fs::read(
+        std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("tests/fixtures/upgraded-from-doc.docx"),
+    )
+    .expect("the upgraded fixture")
+}
+
+/// Top-level paragraph texts of the body, in order.
+fn paragraphs(document: &Document) -> Vec<(BlockId, String)> {
+    let body = document.body();
+    body.children(None)
+        .iter()
+        .filter_map(|id| body.get(id))
+        .filter(|block| block.kind == BlockKind::Paragraph)
+        .map(|block| (block.id.clone(), block.content.text()))
+        .collect()
+}
+
+#[test]
+fn upgraded_document_lays_out_and_renders() {
+    let document = Document::open(upgraded_bytes()).expect("the upgraded document opens");
+    let fonts = fonts();
+
+    let layout = document.layout(&fonts);
+
+    // The memo has a page break before its appendix.
+    assert!(layout.pages.len() >= 2, "{} pages", layout.pages.len());
+    let mut images = ImageCache::new();
+    let mut renderer = Renderer {
+        doc: &document,
+        fonts: &fonts,
+        images: &mut images,
+    };
+    for page in &layout.pages {
+        let raster = renderer.render_page(page, 0.5);
+        assert!(raster.width > 0);
+    }
+}
+
+#[test]
+fn paragraph_text_survives_the_upgrade() {
+    let document = Document::open(upgraded_bytes()).unwrap();
+    let texts: Vec<String> = paragraphs(&document).into_iter().map(|(_, t)| t).collect();
+    let all = texts.join("\n");
+
+    for expected in [
+        "Quarterly Memo",
+        "Revenue grew twelve percent quarter over quarter, with margins holding steady.",
+        "Launched the new editor",
+        "Closed three enterprise deals",
+        "Appendix",
+        "Café façade naïve – unicode survives the round trip.",
+    ] {
+        assert!(all.contains(expected), "missing {expected:?} in {texts:?}");
+    }
+    let xml = document.document_xml();
+    assert!(xml.contains("<w:tbl>"), "table lost");
+}
+
+#[test]
+fn upgraded_document_is_editable_and_saves() {
+    let fonts = fonts();
+    let document = Document::open(upgraded_bytes()).unwrap();
+    let (title, _) = paragraphs(&document)
+        .into_iter()
+        .find(|(_, text)| text == "Quarterly Memo")
+        .expect("the title paragraph");
+    let mut editor = Session::new(document);
+
+    let caret = Pos::new(title, 0);
+    editor
+        .apply(
+            &[
+                EditOp::Select {
+                    anchor: caret.clone(),
+                    focus: caret,
+                },
+                EditOp::InsertText {
+                    text: "Upgraded ".to_string(),
+                },
+            ],
+            None,
+            &fonts,
+        )
+        .expect("the title is editable");
+    let saved = editor.save().expect("the edited document saves");
+
+    let reopened = Document::open(saved).expect("the saved document reopens");
+    assert!(
+        paragraphs(&reopened)
+            .iter()
+            .any(|(_, text)| text == "Upgraded Quarterly Memo")
+    );
+}
+
+#[test]
+fn unedited_save_keeps_every_paragraph() {
+    let document = Document::open(upgraded_bytes()).unwrap();
+    let before: Vec<String> = paragraphs(&document).into_iter().map(|(_, t)| t).collect();
+
+    let reopened = Document::open(document.save().unwrap()).unwrap();
+
+    let after: Vec<String> = paragraphs(&reopened).into_iter().map(|(_, t)| t).collect();
+    assert_eq!(before, after);
+}
diff --git a/crates/model/src/convert.rs b/crates/model/src/convert.rs
index d9cbc46f8e3..167082bfc70 100644
--- a/crates/model/src/convert.rs
+++ b/crates/model/src/convert.rs
@@ -1,6 +1,8 @@
 use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
 
+use crate::document::FileType;
+
 #[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
 pub struct ConvertRequest {
     /// The bucket of the current item
@@ -26,4 +28,11 @@ pub struct ConvertQueueMessage {
     pub from_key: String,
     /// The destination key of the current item we are converting
     pub to_key: String,
+    /// The source file type, for keys without an extension such as
+    /// versioned document keys. Falls back to the `from_key` extension.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub from_file_type: Option<FileType>,
+    /// The target file type. Falls back to the `to_key` extension.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub to_file_type: Option<FileType>,
 }
diff --git a/crates/pptx_engine/tests/fixtures/upgraded-from-ppt.pptx b/crates/pptx_engine/tests/fixtures/upgraded-from-ppt.pptx
new file mode 100644
index 00000000000..3c7b711edb0
Binary files /dev/null and b/crates/pptx_engine/tests/fixtures/upgraded-from-ppt.pptx differ
diff --git a/crates/pptx_engine/tests/upgraded_legacy.rs b/crates/pptx_engine/tests/upgraded_legacy.rs
new file mode 100644
index 00000000000..321397c6514
--- /dev/null
+++ b/crates/pptx_engine/tests/upgraded_legacy.rs
@@ -0,0 +1,115 @@
+//! A legacy `.ppt` deck upgraded to `.pptx` by LibreOffice, as the convert
+//! service does on upload (`fixtures/upgraded-from-ppt.pptx`, from
+//! `services/convert_service/fixtures/legacy/deck.ppt`), opens, renders, edits
+//! and saves in the engine.
+
+use pptx_engine::font::FontDb;
+use pptx_engine::{EditOp, Presentation};
+
+fn fonts() -> FontDb {
+    let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("fonts");
+    let mut files: Vec<_> = std::fs::read_dir(&dir)
+        .expect("the fonts directory")
+        .filter_map(|e| e.ok().map(|e| e.path()))
+        .filter(|p| {
+            p.extension()
+                .is_some_and(|e| e.eq_ignore_ascii_case("ttf") || e.eq_ignore_ascii_case("otf"))
+        })
+        .collect();
+    files.sort();
+    let mut db = FontDb::new();
+    for file in files {
+        db.register(std::fs::read(file).expect("a font file"));
+    }
+    db
+}
+
+fn upgraded_deck() -> Presentation {
+    let bytes = std::fs::read(
+        std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("tests/fixtures/upgraded-from-ppt.pptx"),
+    )
+    .expect("the upgraded fixture");
+    Presentation::open(bytes).expect("the upgraded deck opens")
+}
+
+fn slide_xml(presentation: &Presentation, index: usize) -> String {
+    let part = presentation.slides()[index].part.clone();
+    String::from_utf8(presentation.read_bytes(&part).unwrap()).unwrap()
+}
+
+/// The `p:cNvPr` id of the shape whose text contains `needle`.
+fn shape_id_with_text(xml: &str, needle: &str) -> u32 {
+    let at = xml.find(needle).expect("text on the slide");
+    let tag = xml[..at]
+        .rfind("<p:cNvPr id=\"")
+        .expect("a shape before the text");
+    let rest = &xml[tag + "<p:cNvPr id=\"".len()..];
+    rest[..rest.find('"').unwrap()].parse().unwrap()
+}
+
+#[test]
+fn every_slide_renders() {
+    let mut presentation = upgraded_deck();
+    let fonts = fonts();
+
+    assert_eq!(presentation.slides().len(), 4);
+    for index in 0..presentation.slides().len() {
+        let raster = presentation
+            .render_slide(index, 320, &fonts)
+            .unwrap_or_else(|e| panic!("slide {} failed to render: {e}", index + 1));
+        assert_eq!(raster.width, 320);
+    }
+}
+
+#[test]
+fn slide_content_survives_the_upgrade() {
+    let presentation = upgraded_deck();
+
+    assert!(slide_xml(&presentation, 0).contains("Board Update"));
+    let highlights = slide_xml(&presentation, 1);
+    assert!(highlights.contains("Revenue up 12%"));
+    assert!(highlights.contains("Three new customers"));
+    assert!(slide_xml(&presentation, 2).contains("<a:tbl>"));
+    let shapes = slide_xml(&presentation, 3);
+    assert!(shapes.contains("Shape text"));
+    assert!(shapes.contains("<p:pic>"), "picture lost");
+}
+
+#[test]
+fn upgraded_deck_is_editable_and_saves() {
+    let mut presentation = upgraded_deck();
+    let fonts = fonts();
+    let slide = presentation.slides()[0].id;
+    let shape = shape_id_with_text(&slide_xml(&presentation, 0), "Board Update");
+
+    presentation
+        .apply(
+            &[EditOp::SetText {
+                slide,
+                shape,
+                cell: None,
+                text: "Board Update (edited)".to_string(),
+            }],
+            &fonts,
+        )
+        .expect("the title is editable");
+    let saved = presentation.save().expect("the edited deck saves");
+
+    let mut reopened = Presentation::open(saved).expect("the saved deck reopens");
+    assert!(slide_xml(&reopened, 0).contains("Board Update (edited)"));
+    reopened
+        .render_slide(0, 320, &fonts)
+        .expect("the edited slide renders");
+}
+
+#[test]
+fn unedited_save_keeps_the_upgrade() {
+    let mut presentation = upgraded_deck();
+    let before: Vec<String> = (0..4).map(|i| slide_xml(&presentation, i)).collect();
+
+    let reopened = Presentation::open(presentation.save().unwrap()).unwrap();
+
+    let after: Vec<String> = (0..4).map(|i| slide_xml(&reopened, i)).collect();
+    assert_eq!(before, after);
+}
diff --git a/crates/s3_key/src/document_key.rs b/crates/s3_key/src/document_key.rs
index a9737464530..9079c8c82da 100644
--- a/crates/s3_key/src/document_key.rs
+++ b/crates/s3_key/src/document_key.rs
@@ -17,11 +17,49 @@ pub const PDF_EXTENSION: &str = "pdf";
 /// The file extension for DOCX files.
 pub const DOCX_EXTENSION: &str = "docx";
 
+/// The file name used for legacy Office files upgraded to their OpenXML
+/// equivalents (`.doc` → `upgraded.docx`, `.ppt` → `upgraded.pptx`,
+/// `.xls` → `upgraded.xlsx`).
+pub const UPGRADED_DOCUMENT_FILE_NAME: &str = "upgraded";
+
+/// The OpenXML format a legacy Office document is upgraded to.
+#[derive(Eq, PartialEq, Debug, Clone, Copy)]
+pub enum UpgradedOfficeFormat {
+    /// Word, upgraded from `.doc`.
+    Docx,
+    /// PowerPoint, upgraded from `.ppt`.
+    Pptx,
+    /// Excel, upgraded from `.xls`.
+    Xlsx,
+}
+
+impl UpgradedOfficeFormat {
+    /// The file extension of the upgraded format.
+    pub fn extension(self) -> &'static str {
+        match self {
+            Self::Docx => DOCX_EXTENSION,
+            Self::Pptx => "pptx",
+            Self::Xlsx => "xlsx",
+        }
+    }
+
+    fn from_extension(extension: &str) -> Option<Self> {
+        match extension {
+            DOCX_EXTENSION => Some(Self::Docx),
+            "pptx" => Some(Self::Pptx),
+            "xlsx" => Some(Self::Xlsx),
+            _ => None,
+        }
+    }
+}
+
 /// Represents an S3 key in the document storage bucket.
 ///
 /// Covers all known key shapes:
 /// - `Versioned`: `{owner}/{document_id}/{version_id}` — a specific document version
 /// - `ConvertedPdf`: `{owner}/{document_id}/converted.pdf` — a DOCX converted to PDF
+/// - `UpgradedOffice`: `{owner}/{document_id}/upgraded.{docx|pptx|xlsx}` — a legacy
+///   Office file converted to OpenXML
 /// - `TempDocx`: `temp_files/{document_id}.docx` — a temporary DOCX export
 /// - `SyncServiceSnapshot`: `sync_service_snapshot/{document_id}` — a cached CRDT snapshot
 /// - `BomPart`: `{sha}` — a content-addressable BOM part from DOCX uploads
@@ -46,6 +84,16 @@ pub enum DocumentKey {
         /// The document ID.
         document_id: String,
     },
+    /// A legacy Office file upgraded to OpenXML:
+    /// `{owner}/{document_id}/upgraded.{docx|pptx|xlsx}`
+    UpgradedOffice {
+        /// The owner segment, an owner principal string.
+        owner_segment: String,
+        /// The document ID.
+        document_id: String,
+        /// The upgraded format.
+        format: UpgradedOfficeFormat,
+    },
     /// A temporary DOCX export: `temp_files/{document_id}.docx`
     TempDocx {
         /// The document ID.
@@ -126,11 +174,21 @@ impl DocumentKey {
 
                 let converted_pdf_suffix =
                     format!("{CONVERTED_DOCUMENT_FILE_NAME}.{PDF_EXTENSION}");
+                let upgraded_format = tail
+                    .strip_prefix(UPGRADED_DOCUMENT_FILE_NAME)
+                    .and_then(|rest| rest.strip_prefix('.'))
+                    .and_then(UpgradedOfficeFormat::from_extension);
                 if tail == converted_pdf_suffix {
                     Ok(Self::ConvertedPdf {
                         owner_segment,
                         document_id,
                     })
+                } else if let Some(format) = upgraded_format {
+                    Ok(Self::UpgradedOffice {
+                        owner_segment,
+                        document_id,
+                        format,
+                    })
                 } else {
                     let version_id: i64 = tail.parse().context(format!(
                         "invalid version id: expected integer, got '{tail}'"
@@ -156,6 +214,7 @@ impl DocumentKey {
         match self {
             Self::Versioned { document_id, .. }
             | Self::ConvertedPdf { document_id, .. }
+            | Self::UpgradedOffice { document_id, .. }
             | Self::TempDocx { document_id }
             | Self::SyncServiceSnapshot { document_id } => Some(document_id),
             Self::BomPart { .. } => None,
@@ -165,9 +224,9 @@ impl DocumentKey {
     /// Returns the owner segment for the key shapes that carry one.
     pub fn owner_segment(&self) -> Option<&str> {
         match self {
-            Self::Versioned { owner_segment, .. } | Self::ConvertedPdf { owner_segment, .. } => {
-                Some(owner_segment)
-            }
+            Self::Versioned { owner_segment, .. }
+            | Self::ConvertedPdf { owner_segment, .. }
+            | Self::UpgradedOffice { owner_segment, .. } => Some(owner_segment),
             Self::TempDocx { .. } | Self::SyncServiceSnapshot { .. } | Self::BomPart { .. } => None,
         }
     }
@@ -197,6 +256,11 @@ impl DocumentKey {
         matches!(self, Self::ConvertedPdf { .. })
     }
 
+    /// Returns `true` if this is an upgraded legacy Office key.
+    pub fn is_upgraded_office(&self) -> bool {
+        matches!(self, Self::UpgradedOffice { .. })
+    }
+
     /// Returns the version ID as a string suitable for `SearchExtractorMessage`.
     ///
     /// - `Versioned` → the integer version ID as a string
@@ -206,7 +270,10 @@ impl DocumentKey {
         match self {
             Self::Versioned { version_id, .. } => Some(version_id.to_string()),
             Self::ConvertedPdf { .. } => Some(CONVERTED_DOCUMENT_FILE_NAME.to_string()),
-            Self::TempDocx { .. } | Self::SyncServiceSnapshot { .. } | Self::BomPart { .. } => None,
+            Self::UpgradedOffice { .. }
+            | Self::TempDocx { .. }
+            | Self::SyncServiceSnapshot { .. }
+            | Self::BomPart { .. } => None,
         }
     }
 
@@ -227,6 +294,16 @@ impl DocumentKey {
                 CONVERTED_DOCUMENT_FILE_NAME,
                 Some(PDF_EXTENSION),
             ),
+            Self::UpgradedOffice {
+                owner_segment,
+                document_id,
+                format,
+            } => build_document_key_from_segment(
+                owner_segment,
+                document_id,
+                UPGRADED_DOCUMENT_FILE_NAME,
+                Some(format.extension()),
+            ),
             Self::TempDocx { document_id } => build_temp_docx_key(document_id),
             Self::SyncServiceSnapshot { document_id } => {
                 format!("{SYNC_SERVICE_SNAPSHOT_PREFIX}/{document_id}")
@@ -293,6 +370,21 @@ pub fn build_docx_to_pdf_converted_document_key(owner: &Owner, document_id: &str
     )
 }
 
+/// Builds the S3 key a legacy Office document's OpenXML upgrade is written to.
+/// Format: `{owner}/{document_id}/upgraded.{docx|pptx|xlsx}`
+pub fn build_upgraded_office_document_key(
+    owner: &Owner,
+    document_id: &str,
+    format: UpgradedOfficeFormat,
+) -> String {
+    build_document_key_from_segment(
+        &owner_segment(owner),
+        document_id,
+        UPGRADED_DOCUMENT_FILE_NAME,
+        Some(format.extension()),
+    )
+}
+
 /// Builds the S3 key for a DOCX document's staging bucket.
 /// Format: `{owner}/{document_id}/{document_version_id}.docx`
 pub fn build_docx_staging_bucket_document_key(
diff --git a/crates/s3_key/src/document_key/test.rs b/crates/s3_key/src/document_key/test.rs
index 4bc075214e0..2bfbea35735 100644
--- a/crates/s3_key/src/document_key/test.rs
+++ b/crates/s3_key/src/document_key/test.rs
@@ -340,3 +340,50 @@ fn test_build_temp_docx_key() {
     let key = build_temp_docx_key("document-id");
     assert_eq!(key, "temp_files/document-id.docx");
 }
+
+#[test]
+fn upgraded_office_keys_build_and_parse() {
+    for (format, extension) in [
+        (UpgradedOfficeFormat::Docx, "docx"),
+        (UpgradedOfficeFormat::Pptx, "pptx"),
+        (UpgradedOfficeFormat::Xlsx, "xlsx"),
+    ] {
+        for (principal, owner) in owners() {
+            let key = build_upgraded_office_document_key(&owner, DOCUMENT_ID, format);
+            assert_eq!(
+                key,
+                format!("{principal}/{DOCUMENT_ID}/upgraded.{extension}")
+            );
+
+            let parsed = DocumentKey::from_s3_key(&key).unwrap();
+            assert_eq!(
+                parsed,
+                DocumentKey::UpgradedOffice {
+                    owner_segment: principal.to_string(),
+                    document_id: DOCUMENT_ID.to_string(),
+                    format,
+                }
+            );
+            assert!(parsed.is_upgraded_office());
+            assert!(!parsed.is_versioned());
+            assert_eq!(parsed.document_id(), Some(DOCUMENT_ID));
+            assert_eq!(parsed.owner_segment(), Some(principal));
+            assert_eq!(parsed.version_id_string(), None);
+            assert_eq!(parsed.to_key(), key);
+        }
+    }
+}
+
+#[test]
+fn upgraded_office_keys_reject_other_extensions() {
+    for tail in [
+        "upgraded.doc",
+        "upgraded.pdf",
+        "upgraded",
+        "upgraded.DOCX",
+        "upgradedx.docx",
+    ] {
+        let key = format!("{USER_PRINCIPAL}/{DOCUMENT_ID}/{tail}");
+        assert!(DocumentKey::from_s3_key(&key).is_err(), "{key}");
+    }
+}
diff --git a/crates/s3_key/src/lib.rs b/crates/s3_key/src/lib.rs
index d33db193f31..a0f6f7a8cec 100644
--- a/crates/s3_key/src/lib.rs
+++ b/crates/s3_key/src/lib.rs
@@ -5,9 +5,11 @@
 mod document_key;
 pub use document_key::{
     CONVERTED_DOCUMENT_FILE_NAME, DOCX_EXTENSION, DocumentKey, PDF_EXTENSION,
-    SYNC_SERVICE_SNAPSHOT_PREFIX, TEMP_FILE_PREFIX, build_cloud_storage_bucket_document_key,
+    SYNC_SERVICE_SNAPSHOT_PREFIX, TEMP_FILE_PREFIX, UPGRADED_DOCUMENT_FILE_NAME,
+    UpgradedOfficeFormat, build_cloud_storage_bucket_document_key,
     build_cloud_storage_bucket_document_prefix, build_docx_staging_bucket_document_key,
-    build_docx_to_pdf_converted_document_key, build_temp_docx_key, document_key_url_path,
+    build_docx_to_pdf_converted_document_key, build_temp_docx_key,
+    build_upgraded_office_document_key, document_key_url_path,
 };
 mod bulk_upload_key;
 pub use bulk_upload_key::BulkUploadStagingKey;
diff --git a/docs/AGENT_GUIDE/documents.md b/docs/AGENT_GUIDE/documents.md
index 79096d4672c..924ed8ed9a2 100644
--- a/docs/AGENT_GUIDE/documents.md
+++ b/docs/AGENT_GUIDE/documents.md
@@ -276,7 +276,9 @@ protection). Choose
 **Insert new sheets** to keep existing work, or **Replace workbook** to replace it
 in one undoable operation. Names must be unique when inserting sheets. Canceling
 leaves the workbook untouched; a replacement is blocked if the workbook changed
-while the preview was open. Legacy `.xls`, macros, and encrypted files are rejected.
+while the preview was open. Macros and encrypted files are rejected. A legacy `.xls`
+is rejected here with a hint to upload it instead; uploads convert it (see
+[Legacy Office uploads](#legacy-office-uploads)).
 
 **Import and export → Download as Excel (.xlsx)** exports every sheet with formulas,
 current formula result caches, precise numeric values, custom Excel number formats, fonts, borders, and column widths. Named ranges, named constants, and names defined by formulas are retained and calculate. Imported legacy formulas keep Excel's implicit intersection, shown with `@` as current Excel shows it; 3-D references such as `SUM('Jan:Dec'!B2)` are listed sheet by sheet. Imported merged ranges, hidden sheets/rows/columns, row heights, filters, and frozen panes are retained for export. Macro hides imported rows and columns, shows hidden sheets and individual cells of merged ranges; editing a covered merged cell omits that merge during export with a warning so the edit is preserved. Imported charts, images, shapes, text boxes, pivot tables, conditional formatting, validation and notes are written back. Structured table formulas and rich text are not fully supported; review import notes before conversion.
@@ -432,6 +434,27 @@ fail, the rest of the tree still appears and a toast says some files could not b
 uploaded. The unzip runs in the upload extractor Lambda, which the local stack
 does not run; verify folder imports against a deployed backend.
 
+## Legacy Office uploads
+
+Uploaded legacy binary Office files are converted to their OpenXML equivalents
+on the server: `.doc` → `.docx`, `.ppt` → `.pptx`, `.xls` → `.xlsx`. This also
+applies to files inside an uploaded folder. The document keeps its id and name;
+its file type changes and the converted file becomes its latest version.
+Converted Word files then go through the regular DOCX pipeline, and converted
+workbooks open in the uploaded-workbook preview, where **Edit in Macro** imports
+them into a native spreadsheet.
+
+While a legacy file uploaded in the last 10 minutes is converting, its view shows
+**Converting … to a PowerPoint presentation…** (or Word document / Excel
+workbook) with **Download** still available for the original. When the
+conversion lands, the split reopens in the right block (workbooks switch in
+place). If conversion fails or takes over 3 minutes, the view falls back to
+**No preview available**, and the original stays downloadable. Legacy files
+uploaded before conversion existed are not converted.
+
+Conversion runs in the convert service through the upload finalizer Lambda,
+neither of which the local stack runs, so verify it against a deployed backend.
+
 ## Presentations (PowerPoint)
 
 Uploaded `.pptx` files open in the `pptx` block (`/app/pptx/<documentId>`).
diff --git a/infra/stacks/cloud-storage-service/document-upload-finalizer-lambda.ts b/infra/stacks/cloud-storage-service/document-upload-finalizer-lambda.ts
index 8415a4011ae..7995dd692c5 100644
--- a/infra/stacks/cloud-storage-service/document-upload-finalizer-lambda.ts
+++ b/infra/stacks/cloud-storage-service/document-upload-finalizer-lambda.ts
@@ -16,11 +16,18 @@ export type DocumentUploadFinalizerLambdaEnvVars = {
   LEXICAL_SERVICE_URL: pulumi.Output<string> | string;
   SYNC_SERVICE_URL: pulumi.Output<string> | string;
   RUST_LOG: pulumi.Output<string> | string;
+  ENVIRONMENT: pulumi.Output<string> | string;
+  DOCUMENT_STORAGE_BUCKET: pulumi.Output<string> | string;
+  DOCX_DOCUMENT_UPLOAD_BUCKET: pulumi.Output<string> | string;
 };
 
 type DocumentUploadFinalizerLambdaArgs = {
   envVars: DocumentUploadFinalizerLambdaEnvVars;
   documentStorageBucketArn: pulumi.Output<string> | string;
+  /** Upgraded legacy `.doc` files are staged here for the DOCX pipeline. */
+  docxUploadBucketArn: pulumi.Output<string> | string;
+  /** Legacy `.doc`/`.ppt`/`.xls` uploads are upgraded through this queue. */
+  convertQueueArn: pulumi.Output<string> | string;
   vpc: {
     vpcId: pulumi.Output<string> | string;
     publicSubnetIds: pulumi.Output<string[]> | string[];
@@ -40,7 +47,14 @@ export class DocumentUploadFinalizerLambda extends pulumi.ComponentResource {
     opts?: pulumi.ComponentResourceOptions
   ) {
     super('my:components:DocumentUploadFinalizerLambda', name, {}, opts);
-    const { documentStorageBucketArn, vpc, envVars, tags } = args;
+    const {
+      documentStorageBucketArn,
+      docxUploadBucketArn,
+      convertQueueArn,
+      vpc,
+      envVars,
+      tags,
+    } = args;
 
     this.tags = tags;
 
@@ -53,9 +67,35 @@ export class DocumentUploadFinalizerLambda extends pulumi.ComponentResource {
           Statement: [
             {
               Effect: 'Allow',
-              Action: ['s3:GetObject'],
+              // PutObject copies an upgraded legacy Office file into a new
+              // document version.
+              Action: ['s3:GetObject', 's3:PutObject'],
               Resource: [pulumi.interpolate`${documentStorageBucketArn}/*`],
             },
+            {
+              Effect: 'Allow',
+              Action: ['s3:PutObject'],
+              Resource: [pulumi.interpolate`${docxUploadBucketArn}/*`],
+            },
+          ],
+        }),
+        tags: this.tags,
+      },
+      { parent: this }
+    );
+
+    const sqsPolicy = new aws.iam.Policy(
+      `${BASE_NAME}-sqs-policy`,
+      {
+        name: `${BASE_NAME}-sqs-policy-${stack}`,
+        policy: pulumi.output({
+          Version: '2012-10-17',
+          Statement: [
+            {
+              Effect: 'Allow',
+              Action: ['sqs:SendMessage'],
+              Resource: [convertQueueArn],
+            },
           ],
         }),
         tags: this.tags,
@@ -84,6 +124,7 @@ export class DocumentUploadFinalizerLambda extends pulumi.ComponentResource {
           aws.iam.ManagedPolicy.AWSLambdaVPCAccessExecutionRole,
           aws.iam.ManagedPolicy.CloudWatchLogsFullAccess,
           s3Policy.arn,
+          sqsPolicy.arn,
         ],
         tags: this.tags,
       },
diff --git a/infra/stacks/cloud-storage-service/docx-unzip-bucket.ts b/infra/stacks/cloud-storage-service/docx-unzip-bucket.ts
index a527fb8bf80..53118f7ee97 100644
--- a/infra/stacks/cloud-storage-service/docx-unzip-bucket.ts
+++ b/infra/stacks/cloud-storage-service/docx-unzip-bucket.ts
@@ -7,12 +7,14 @@ export function attachPolicyToDocxUnzipBucket({
   bulkUploadLambdaRoleArn,
   convertServiceRoleArn,
   cloudStorageServiceRoleArn,
+  documentUploadFinalizerRoleArn,
   bucket,
 }: {
   docxUnzipLambdaRoleArn: pulumi.Output<string> | string;
   bulkUploadLambdaRoleArn: pulumi.Output<string> | string | undefined;
   convertServiceRoleArn: pulumi.Output<string> | string;
   cloudStorageServiceRoleArn: pulumi.Output<string> | string;
+  documentUploadFinalizerRoleArn: pulumi.Output<string> | string;
   bucket: aws.s3.Bucket;
 }) {
   const groupName = `document-store-admin-${stack}`;
@@ -34,6 +36,7 @@ export function attachPolicyToDocxUnzipBucket({
         docxUnzipLambdaRoleArn,
         cloudStorageServiceRoleArn,
         convertServiceRoleArn,
+        documentUploadFinalizerRoleArn,
       ];
       if (bulkUploadLambdaRoleArn) {
         arnsWithRoles.push(bulkUploadLambdaRoleArn);
@@ -61,6 +64,17 @@ export function attachPolicyToDocxUnzipBucket({
     Resource: [bucket.arn, pulumi.interpolate`${bucket.arn}/*`],
   };
 
+  // Stages upgraded legacy `.doc` files for the DOCX pipeline.
+  const allowDocumentUploadFinalizerPolicyStatement: aws.iam.PolicyStatement = {
+    Sid: 'AllowDocumentUploadFinalizer',
+    Effect: 'Allow',
+    Principal: {
+      AWS: documentUploadFinalizerRoleArn,
+    },
+    Action: ['s3:PutObject'],
+    Resource: [pulumi.interpolate`${bucket.arn}/*`],
+  };
+
   const allowDocxUnzipLambdaPolicyStatement: aws.iam.PolicyStatement = {
     Sid: 'AllowAccessForDocxUnzipLambda',
     Effect: 'Allow',
@@ -98,6 +112,7 @@ export function attachPolicyToDocxUnzipBucket({
     allowDocumentStorageServicePolicyStatement,
     allowConvertServicePolicyStatement,
     allowDocxUnzipLambdaPolicyStatement,
+    allowDocumentUploadFinalizerPolicyStatement,
     {
       Sid: 'DenyNonBucketPolicyAccessForNonAdmins',
       Effect: 'Deny',
@@ -133,6 +148,7 @@ export function attachPolicyToDocxUnzipBucket({
     allowDocumentStorageServicePolicyStatement,
     allowConvertServicePolicyStatement,
     allowDocxUnzipLambdaPolicyStatement,
+    allowDocumentUploadFinalizerPolicyStatement,
     {
       Sid: 'DenyNonAdminAccess',
       Effect: 'Deny',
diff --git a/infra/stacks/cloud-storage-service/index.ts b/infra/stacks/cloud-storage-service/index.ts
index 76097042883..493fcbbbcc3 100644
--- a/infra/stacks/cloud-storage-service/index.ts
+++ b/infra/stacks/cloud-storage-service/index.ts
@@ -458,12 +458,18 @@ const documentUploadFinalizerEnvVars: DocumentUploadFinalizerLambdaEnvVars = {
   SYNC_SERVICE_URL: getServiceUrl(ServiceUrl.SYNC_SERVICE_URL),
   RUST_LOG:
     'document_upload_finalizer_handler=info,documents=info,macro_http_request=info',
+  // Selects the stack's convert queue.
+  ENVIRONMENT: stack,
+  DOCUMENT_STORAGE_BUCKET: pulumi.interpolate`${documentStorageBucketId}`,
+  DOCX_DOCUMENT_UPLOAD_BUCKET: pulumi.interpolate`${docxUploadBucketName}`,
 };
 
 const documentUploadFinalizer = new DocumentUploadFinalizerLambda(
   `document-upload-finalizer-${stack}`,
   {
     documentStorageBucketArn,
+    docxUploadBucketArn,
+    convertQueueArn,
     envVars: documentUploadFinalizerEnvVars,
     vpc: coparse_api_vpc,
     tags,
@@ -492,4 +498,5 @@ attachPolicyToDocxUnzipBucket({
   docxUnzipLambdaRoleArn: docxUnzipHandler.role.arn,
   bulkUploadLambdaRoleArn,
   convertServiceRoleArn,
+  documentUploadFinalizerRoleArn: documentUploadFinalizer.role.arn,
 });
diff --git a/services/convert_service/Cargo.toml b/services/convert_service/Cargo.toml
index 3b0326ce00f..0b2bfe6c3cd 100644
--- a/services/convert_service/Cargo.toml
+++ b/services/convert_service/Cargo.toml
@@ -60,3 +60,8 @@ utoipa = { workspace = true }
 utoipa-swagger-ui = { workspace = true }
 zip = { workspace = true, features = ["bzip2"] }
 workspace-hack = { version = "0.1", path = "../../crates/workspace-hack" }
+
+[dev-dependencies]
+docx_engine = { path = "../../crates/docx_engine" }
+pptx_engine = { path = "../../crates/pptx_engine" }
+tempfile = { workspace = true }
diff --git a/services/convert_service/fixtures/legacy/budget.xls b/services/convert_service/fixtures/legacy/budget.xls
new file mode 100644
index 00000000000..bcffd9adcea
Binary files /dev/null and b/services/convert_service/fixtures/legacy/budget.xls differ
diff --git a/services/convert_service/fixtures/legacy/deck.ppt b/services/convert_service/fixtures/legacy/deck.ppt
new file mode 100644
index 00000000000..52f92abfac8
Binary files /dev/null and b/services/convert_service/fixtures/legacy/deck.ppt differ
diff --git a/services/convert_service/fixtures/legacy/memo.doc b/services/convert_service/fixtures/legacy/memo.doc
new file mode 100644
index 00000000000..1fed2d03f2c
Binary files /dev/null and b/services/convert_service/fixtures/legacy/memo.doc differ
diff --git a/services/convert_service/src/api/backfill/backfill_docx.rs b/services/convert_service/src/api/backfill/backfill_docx.rs
index 16d33108b4d..facdd0c8049 100644
--- a/services/convert_service/src/api/backfill/backfill_docx.rs
+++ b/services/convert_service/src/api/backfill/backfill_docx.rs
@@ -182,6 +182,8 @@ async fn process_docx(
                 to_bucket: document_storage_bucket.to_string(),
                 from_key: from_key.clone(),
                 to_key: to_key.clone(),
+                from_file_type: None,
+                to_file_type: None,
             }));
         }
 
diff --git a/services/convert_service/src/process/convert.rs b/services/convert_service/src/process/convert.rs
index 74eb7b7a186..67e4a75f32c 100644
--- a/services/convert_service/src/process/convert.rs
+++ b/services/convert_service/src/process/convert.rs
@@ -1,21 +1,21 @@
 use nix::{
-    libc::exit,
+    libc::{_exit, exit},
     unistd::{ForkResult, fork},
 };
 use rs_libreoffice_bindings::Office;
-use std::{borrow::Cow, fs::File, io::Write, str::FromStr, thread, time::Duration};
+use std::{borrow::Cow, fs::File, io::Write, thread, time::Duration};
 
 use anyhow::Context;
-use model::{convert::ConvertQueueMessage, document::FileType};
+use model::convert::ConvertQueueMessage;
 
 use crate::{
     config::{LOK_PATH, WEB_SOCKET_RESPONSE_LAMBDA},
     model::{BomPart, DocxUploadJobData, DocxUploadJobResult, DocxUploadJobSuccessDataInner},
-    utils::{cleanup_folder, get_lok_filter_from_file_types},
+    utils::{
+        cleanup_folder, conversion_timeout, get_lok_filter_from_file_types, resolve_file_type,
+    },
 };
 
-static MAX_WAIT_TIME_SECONDS: u64 = 30;
-
 pub(super) fn is_docx_key(key: &str) -> bool {
     key.to_ascii_lowercase().ends_with(".docx")
 }
@@ -135,19 +135,8 @@ pub async fn convert(
     req: &ConvertQueueMessage,
     s3_client: &s3_client::S3,
 ) -> anyhow::Result<()> {
-    let from_file_type: FileType = req
-        .from_key
-        .split('.')
-        .next_back()
-        .context("expected key to contain a file type")
-        .and_then(|s| Ok(FileType::from_str(s)?))?;
-
-    let to_file_type: FileType = req
-        .to_key
-        .split('.')
-        .next_back()
-        .context("expected key to contain a file type")
-        .and_then(|s| Ok(FileType::from_str(s)?))?;
+    let from_file_type = resolve_file_type(req.from_file_type, &req.from_key)?;
+    let to_file_type = resolve_file_type(req.to_file_type, &req.to_key)?;
 
     let filter = get_lok_filter_from_file_types(&from_file_type, &to_file_type)
         .context("unable to get lok filter")?;
@@ -170,7 +159,41 @@ pub async fn convert(
     file.write_all(&file_content)
         .context("unable to write to input file")?;
 
-    let office_path = &*LOK_PATH;
+    let max_wait = conversion_timeout(&from_file_type, &to_file_type);
+    run_lok_conversion(
+        job_id,
+        &LOK_PATH,
+        &in_file_path,
+        &out_file_path,
+        to_file_type.as_str(),
+        &filter,
+        max_wait,
+    )?;
+
+    let file_content = std::fs::read(out_file_path).context("unable to read result file")?;
+
+    s3_client
+        .put(&req.to_bucket, &req.to_key, &file_content)
+        .await
+        .context("unable to upload file")?;
+
+    Ok(())
+}
+
+/// Converts `in_file_path` to `out_file_path` with LibreOfficeKit in a forked
+/// child process, killing it after `max_wait`.
+///
+/// The child process keeps a LibreOffice crash or hang from taking down the
+/// worker.
+pub(crate) fn run_lok_conversion(
+    job_id: &str,
+    office_path: &str,
+    in_file_path: &str,
+    out_file_path: &str,
+    to_format: &str,
+    filter: &str,
+    max_wait: Duration,
+) -> anyhow::Result<()> {
     let mut child_pids = vec![];
     match unsafe { fork() } {
         Ok(ForkResult::Parent { child }) => {
@@ -187,25 +210,30 @@ pub async fn convert(
                 tracing::trace!("office initialized");
 
                 let document = office
-                    .load_document(&in_file_path)
+                    .load_document(in_file_path)
                     .map_err(|e| anyhow::anyhow!(e))
                     .context("unable to load document")?;
                 tracing::trace!("document loaded");
 
                 document
-                    .save_as(&out_file_path, to_file_type.as_str(), &filter)
+                    .save_as(out_file_path, to_format, filter)
                     .map_err(|e| anyhow::anyhow!(e))
                     .context("unable to save document")?;
                 tracing::trace!("document saved");
 
-                drop(document);
-                drop(office);
+                // The child exits right after this, so skip LibreOffice's
+                // teardown: Writer can crash while destroying a document it
+                // has already saved, which would fail a finished conversion.
+                std::mem::forget(document);
+                std::mem::forget(office);
 
                 Ok(())
             })();
 
             match result {
-                Ok(_) => exit(0),
+                // `_exit` skips LibreOffice's exit handlers, which can hang
+                // after the teardown skipped above.
+                Ok(_) => _exit(0),
                 Err(e) => {
                     tracing::error!(job_id=%job_id, error=?e, "unable to convert");
                     exit(1)
@@ -227,7 +255,7 @@ pub async fn convert(
         }
 
         // Check if we've exceeded the timeout
-        if start_time.elapsed().as_secs() > MAX_WAIT_TIME_SECONDS {
+        if start_time.elapsed() > max_wait {
             tracing::error!(job_id=%job_id, "conversion timed out");
             // Kill any remaining child processes
             for &pid in &child_pids {
@@ -272,12 +300,5 @@ pub async fn convert(
         anyhow::bail!("conversion failed");
     }
 
-    let file_content = std::fs::read(out_file_path).context("unable to read result file")?;
-
-    s3_client
-        .put(&req.to_bucket, &req.to_key, &file_content)
-        .await
-        .context("unable to upload file")?;
-
     Ok(())
 }
diff --git a/services/convert_service/src/process/test.rs b/services/convert_service/src/process/test.rs
index 41e9e51df75..16d49f1fa99 100644
--- a/services/convert_service/src/process/test.rs
+++ b/services/convert_service/src/process/test.rs
@@ -11,3 +11,358 @@ fn docx_detection_requires_the_final_extension() {
     assert!(!is_docx_key("uploads/report.docx.tmp"));
     assert!(!is_docx_key("uploads/docx"));
 }
+
+mod legacy_upgrade {
+    //! Real LibreOfficeKit conversions of legacy Office fixtures, checked by
+    //! opening the results in the engines that serve them.
+    //!
+    //! Needs LibreOffice (with Writer, Calc and Impress) on the host:
+    //! `LOK_PATH=/usr/lib/libreoffice/program cargo test -p convert_service -- --ignored`.
+
+    use std::io::Read;
+    use std::path::{Path, PathBuf};
+    use std::sync::Mutex;
+    use std::time::Duration;
+
+    use model::document::FileType;
+
+    use crate::config::LokPath;
+    use crate::process::convert::run_lok_conversion;
+    use crate::utils::{conversion_timeout, get_lok_filter_from_file_types};
+
+    fn fixture(name: &str) -> PathBuf {
+        Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("fixtures/legacy")
+            .join(name)
+    }
+
+    fn fonts() -> pptx_engine::font::FontDb {
+        let dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../crates/pptx_engine/fonts");
+        let mut db = pptx_engine::font::FontDb::new();
+        let mut files: Vec<_> = std::fs::read_dir(dir)
+            .expect("pptx_engine fonts")
+            .filter_map(|entry| entry.ok().map(|entry| entry.path()))
+            .filter(|path| {
+                path.extension()
+                    .is_some_and(|e| e.eq_ignore_ascii_case("ttf") || e.eq_ignore_ascii_case("otf"))
+            })
+            .collect();
+        files.sort();
+        for file in files {
+            db.register(std::fs::read(file).expect("font file"));
+        }
+        db
+    }
+
+    /// LibreOffice shares one user profile per host, so conversions run one
+    /// at a time, as the worker does.
+    static LOK: Mutex<()> = Mutex::new(());
+
+    /// Upgrades a fixture and returns the OpenXML bytes.
+    fn upgrade(name: &str, from: FileType, to: FileType) -> Vec<u8> {
+        convert_bytes(&std::fs::read(fixture(name)).unwrap(), from, to)
+    }
+
+    fn convert_bytes(input_bytes: &[u8], from: FileType, to: FileType) -> Vec<u8> {
+        let _lok = LOK.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
+        let lok_path = LokPath::new().expect("set LOK_PATH to LibreOffice's program directory");
+        let dir = tempfile::tempdir().unwrap();
+        let input = dir.path().join(format!("IN.{}", from.as_str()));
+        let output = dir.path().join(format!("OUT.{}", to.as_str()));
+        std::fs::write(&input, input_bytes).unwrap();
+
+        let filter = get_lok_filter_from_file_types(&from, &to).unwrap();
+        run_lok_conversion(
+            "legacy-upgrade-test",
+            lok_path.as_ref(),
+            input.to_str().unwrap(),
+            output.to_str().unwrap(),
+            to.as_str(),
+            &filter,
+            conversion_timeout(&from, &to),
+        )
+        .unwrap();
+        std::fs::read(output).unwrap()
+    }
+
+    fn zip_part(bytes: &[u8], name: &str) -> String {
+        let mut archive = zip::ZipArchive::new(std::io::Cursor::new(bytes)).unwrap();
+        let mut part = archive
+            .by_name(name)
+            .unwrap_or_else(|_| panic!("missing part {name}"));
+        let mut text = String::new();
+        part.read_to_string(&mut text).unwrap();
+        text
+    }
+
+    fn zip_names(bytes: &[u8]) -> Vec<String> {
+        let archive = zip::ZipArchive::new(std::io::Cursor::new(bytes)).unwrap();
+        archive.file_names().map(str::to_string).collect()
+    }
+
+    fn assert_main_content_type(bytes: &[u8], content_type: &str) {
+        let types = zip_part(bytes, "[Content_Types].xml");
+        assert!(types.contains(content_type), "{types}");
+    }
+
+    #[test]
+    #[ignore = "needs LibreOfficeKit; see module docs"]
+    fn doc_upgrades_to_a_docx_the_word_engine_lays_out() {
+        let docx = upgrade("memo.doc", FileType::Doc, FileType::Docx);
+
+        assert_main_content_type(
+            &docx,
+            "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml",
+        );
+        let xml = zip_part(&docx, "word/document.xml");
+        for text in [
+            "Quarterly Memo",
+            "twelve percent",
+            "Launched the new editor",
+            "Revenue",
+            "Margin",
+            "Café façade naïve",
+        ] {
+            assert!(xml.contains(text), "missing {text:?}");
+        }
+        // Bold run, table, page break, list numbering and the picture survive.
+        assert!(
+            xml.contains("<w:b/>") || xml.contains("<w:b "),
+            "bold run lost"
+        );
+        assert!(xml.contains("<w:tbl>"), "table lost");
+        assert!(xml.contains(r#"w:type="page""#), "page break lost");
+        assert!(xml.contains("<w:numPr>"), "list numbering lost");
+        assert!(
+            zip_names(&docx)
+                .iter()
+                .any(|name| name.starts_with("word/media/")),
+            "picture lost"
+        );
+
+        let document = docx_engine::Document::open(docx).expect("docx engine opens the upgrade");
+        let layout = document.layout(&fonts());
+        assert!(layout.pages.len() >= 2, "page break should give two pages");
+    }
+
+    #[test]
+    #[ignore = "needs LibreOfficeKit; see module docs"]
+    fn ppt_upgrades_to_a_pptx_the_presentation_engine_renders() {
+        let pptx = upgrade("deck.ppt", FileType::Ppt, FileType::Pptx);
+
+        assert_main_content_type(
+            &pptx,
+            "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml",
+        );
+        let names = zip_names(&pptx);
+        assert!(
+            names.iter().any(|name| name.starts_with("ppt/media/")),
+            "picture lost"
+        );
+        assert!(
+            names
+                .iter()
+                .any(|name| name.starts_with("ppt/notesSlides/")),
+            "speaker notes lost"
+        );
+
+        let mut presentation =
+            pptx_engine::Presentation::open(pptx.clone()).expect("pptx engine opens the upgrade");
+        assert_eq!(presentation.slides().len(), 4);
+        let fonts = fonts();
+        for index in 0..presentation.slides().len() {
+            presentation
+                .render_slide(index, 320, &fonts)
+                .unwrap_or_else(|e| panic!("slide {} failed to render: {e}", index + 1));
+        }
+
+        let slides: String = (1..=4)
+            .map(|n| zip_part(&pptx, &format!("ppt/slides/slide{n}.xml")))
+            .collect();
+        for text in [
+            "Board Update",
+            "October 2026",
+            "Revenue up 12%",
+            "Three new customers",
+            "Numbers",
+            "Margin",
+            "Shape text",
+        ] {
+            assert!(slides.contains(text), "missing {text:?}");
+        }
+        assert!(slides.contains("<a:tbl>"), "table lost");
+        let notes: String = names
+            .iter()
+            .filter(|name| name.starts_with("ppt/notesSlides/") && name.ends_with(".xml"))
+            .map(|name| zip_part(&pptx, name))
+            .collect();
+        assert!(notes.contains("Speaker notes survive"));
+    }
+
+    #[test]
+    #[ignore = "needs LibreOfficeKit; see module docs"]
+    fn xls_upgrades_to_an_xlsx_with_formulas_and_sheets() {
+        let xlsx = upgrade("budget.xls", FileType::Xls, FileType::Xlsx);
+
+        assert_main_content_type(
+            &xlsx,
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml",
+        );
+        let workbook = zip_part(&xlsx, "xl/workbook.xml");
+        assert!(workbook.contains(r#"name="Budget""#), "{workbook}");
+        assert!(workbook.contains(r#"name="Notes""#), "{workbook}");
+
+        let budget = zip_part(&xlsx, "xl/worksheets/sheet1.xml");
+        for formula in ["SUM(B2:B13)", "SUM(D2:D13)", "B2-C2", "B13-C13"] {
+            assert!(budget.contains(formula), "missing formula {formula}");
+        }
+        assert!(budget.contains(r#"<mergeCell ref="F1:H1""#), "merge lost");
+        // Cached results are written so a reader shows values before recalculating.
+        assert!(budget.contains("<v>15900</v>"), "total revenue cache lost");
+
+        let notes = zip_part(&xlsx, "xl/worksheets/sheet2.xml");
+        assert!(
+            notes.contains("Budget!D15/Budget!B15"),
+            "cross-sheet formula lost"
+        );
+
+        let strings = zip_part(&xlsx, "xl/sharedStrings.xml");
+        for text in ["Month", "Revenue", "Merged header", "Total", "Finance"] {
+            assert!(strings.contains(text), "missing {text:?}");
+        }
+        let styles = zip_part(&xlsx, "xl/styles.xml");
+        assert!(styles.contains("#,##0.00"), "number format lost");
+    }
+
+    #[test]
+    #[ignore = "needs LibreOfficeKit; see module docs"]
+    fn unreadable_input_fails_instead_of_hanging() {
+        let _lok = LOK.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
+        let lok_path = LokPath::new().expect("set LOK_PATH to LibreOffice's program directory");
+        let dir = tempfile::tempdir().unwrap();
+        let input = dir.path().join("IN.ppt");
+        std::fs::write(&input, b"not a powerpoint file").unwrap();
+
+        let result = run_lok_conversion(
+            "legacy-upgrade-garbage",
+            lok_path.as_ref(),
+            input.to_str().unwrap(),
+            dir.path().join("OUT.pptx").to_str().unwrap(),
+            "pptx",
+            "",
+            Duration::from_secs(60),
+        );
+
+        assert!(result.is_err());
+    }
+
+    #[test]
+    #[ignore = "needs LibreOfficeKit; see module docs"]
+    fn upgraded_docx_still_exports_to_pdf() {
+        // The DOCX pipeline converts every Word upload to PDF, including upgrades.
+        let docx = upgrade("memo.doc", FileType::Doc, FileType::Docx);
+
+        let pdf = convert_bytes(&docx, FileType::Docx, FileType::Pdf);
+
+        assert!(pdf.starts_with(b"%PDF-"));
+        assert!(pdf.len() > 1_000);
+    }
+
+    #[test]
+    #[ignore = "needs LibreOfficeKit; see module docs"]
+    fn upgraded_pptx_still_exports_to_pdf() {
+        let pptx = upgrade("deck.ppt", FileType::Ppt, FileType::Pptx);
+
+        let pdf = convert_bytes(&pptx, FileType::Pptx, FileType::Pdf);
+
+        assert!(pdf.starts_with(b"%PDF-"));
+    }
+}
+
+mod conversion_table {
+    use model::document::FileType;
+
+    use crate::utils::{conversion_timeout, get_lok_filter_from_file_types, resolve_file_type};
+
+    #[test]
+    fn legacy_upgrades_are_supported() {
+        for (from, to) in [
+            (FileType::Doc, FileType::Docx),
+            (FileType::Xls, FileType::Xlsx),
+            (FileType::Ppt, FileType::Pptx),
+        ] {
+            assert_eq!(get_lok_filter_from_file_types(&from, &to).unwrap(), "");
+            assert_eq!(conversion_timeout(&from, &to).as_secs(), 120);
+        }
+    }
+
+    #[test]
+    fn existing_exports_keep_their_filters() {
+        assert_eq!(
+            get_lok_filter_from_file_types(&FileType::Docx, &FileType::Pdf).unwrap(),
+            "writer_pdf_Export"
+        );
+        assert_eq!(
+            get_lok_filter_from_file_types(&FileType::Xlsx, &FileType::Html).unwrap(),
+            "calc_HTML_WebQuery"
+        );
+        assert_eq!(
+            get_lok_filter_from_file_types(&FileType::Pptx, &FileType::Pdf).unwrap(),
+            "impress_pdf_Export"
+        );
+        assert_eq!(
+            conversion_timeout(&FileType::Docx, &FileType::Pdf).as_secs(),
+            30
+        );
+    }
+
+    #[test]
+    fn unsupported_pairs_are_rejected() {
+        for (from, to) in [
+            (FileType::Doc, FileType::Pdf),
+            (FileType::Ppt, FileType::Docx),
+            (FileType::Docx, FileType::Doc),
+            (FileType::Xlsm, FileType::Xlsx),
+        ] {
+            assert!(
+                get_lok_filter_from_file_types(&from, &to).is_err(),
+                "{from}->{to}"
+            );
+        }
+    }
+
+    #[test]
+    fn explicit_types_win_over_key_extensions() {
+        assert_eq!(
+            resolve_file_type(Some(FileType::Ppt), "owner/doc/12").unwrap(),
+            FileType::Ppt
+        );
+        assert_eq!(
+            resolve_file_type(Some(FileType::Doc), "owner/doc/7.docx").unwrap(),
+            FileType::Doc
+        );
+    }
+
+    #[test]
+    fn key_extensions_are_used_without_explicit_types() {
+        assert_eq!(
+            resolve_file_type(None, "owner/doc/converted.pdf").unwrap(),
+            FileType::Pdf
+        );
+        assert_eq!(
+            resolve_file_type(None, "macro|a.b@c.com/doc/upgraded.PPTX").unwrap(),
+            FileType::Pptx
+        );
+        assert_eq!(
+            resolve_file_type(None, "owner/doc/7.docx").unwrap(),
+            FileType::Docx
+        );
+    }
+
+    #[test]
+    fn versioned_keys_need_explicit_types() {
+        assert!(resolve_file_type(None, "owner/doc/12").is_err());
+        // A dotted owner segment is not an extension.
+        assert!(resolve_file_type(None, "macro|first.last@macro.com/doc/12").is_err());
+    }
+}
diff --git a/services/convert_service/src/utils.rs b/services/convert_service/src/utils.rs
index d0de76b00b3..abd3b5ca31d 100644
--- a/services/convert_service/src/utils.rs
+++ b/services/convert_service/src/utils.rs
@@ -1,3 +1,6 @@
+use std::str::FromStr;
+use std::time::Duration;
+
 use anyhow::Context;
 use model::document::FileType;
 
@@ -12,31 +15,55 @@ pub fn cleanup_folder(job_id: &str) -> anyhow::Result<()> {
     Ok(())
 }
 
+/// LibreOfficeKit filter options for a supported conversion.
+///
+/// LOK picks the export filter from the target format (`save_as`'s format
+/// argument); this returns the options string passed alongside it.
 pub fn get_lok_filter_from_file_types(
     from_file_type: &FileType,
     to_file_type: &FileType,
 ) -> anyhow::Result<String> {
-    match from_file_type {
-        FileType::Docx => match to_file_type {
-            FileType::Pdf => Ok("writer_pdf_Export".to_string()),
-            _ => Err(anyhow::anyhow!(
-                "unsupported conversion of {from_file_type} to {to_file_type}"
-            )),
-        },
-        FileType::Xlsx => match to_file_type {
-            FileType::Html => Ok("calc_HTML_WebQuery".to_string()),
-            _ => Err(anyhow::anyhow!(
-                "unsupported conversion of {from_file_type} to {to_file_type}"
-            )),
-        },
-        FileType::Pptx => match to_file_type {
-            FileType::Pdf => Ok("impress_pdf_Export".to_string()),
-            _ => Err(anyhow::anyhow!(
-                "unsupported conversion of {from_file_type} to {to_file_type}"
-            )),
-        },
+    match (from_file_type, to_file_type) {
+        (FileType::Docx, FileType::Pdf) => Ok("writer_pdf_Export".to_string()),
+        (FileType::Xlsx, FileType::Html) => Ok("calc_HTML_WebQuery".to_string()),
+        (FileType::Pptx, FileType::Pdf) => Ok("impress_pdf_Export".to_string()),
+        // Legacy binary Office upgrades. The OOXML export filters
+        // ("MS Word 2007 XML", "Calc MS Excel 2007 XML",
+        // "Impress MS PowerPoint 2007 XML") need no options.
+        (FileType::Doc, FileType::Docx)
+        | (FileType::Xls, FileType::Xlsx)
+        | (FileType::Ppt, FileType::Pptx) => Ok(String::new()),
         _ => Err(anyhow::anyhow!(
-            "unsupported conversion of {from_file_type} for conversion"
+            "unsupported conversion of {from_file_type} to {to_file_type}"
         )),
     }
 }
+
+/// How long a conversion may run before its child process is killed.
+///
+/// Upgrading a legacy deck or workbook re-encodes every embedded image and
+/// sheet, so it gets more time than an export.
+pub fn conversion_timeout(from_file_type: &FileType, to_file_type: &FileType) -> Duration {
+    match (from_file_type, to_file_type) {
+        (FileType::Doc, FileType::Docx)
+        | (FileType::Xls, FileType::Xlsx)
+        | (FileType::Ppt, FileType::Pptx) => Duration::from_secs(120),
+        _ => Duration::from_secs(30),
+    }
+}
+
+/// The file type of a conversion side: the explicit type when the message
+/// carries one, else the key's extension.
+///
+/// Versioned document keys (`{owner}/{document_id}/{version_id}`) have no
+/// extension, so jobs reading them name the type explicitly.
+pub fn resolve_file_type(explicit: Option<FileType>, key: &str) -> anyhow::Result<FileType> {
+    if let Some(file_type) = explicit {
+        return Ok(file_type);
+    }
+    let file_name = key.rsplit('/').next().unwrap_or(key);
+    let (_, extension) = file_name
+        .rsplit_once('.')
+        .context("expected key to contain a file type")?;
+    Ok(FileType::from_str(extension)?)
+}
diff --git a/services/document_upload_finalizer_handler/Cargo.toml b/services/document_upload_finalizer_handler/Cargo.toml
index 01db4abe120..374416a8fb7 100644
--- a/services/document_upload_finalizer_handler/Cargo.toml
+++ b/services/document_upload_finalizer_handler/Cargo.toml
@@ -22,12 +22,17 @@ lexical_client = { path = "../../crates/lexical_client" }
 macro_aws_config = { path = "../../crates/macro_aws_config", features = ["s3"] }
 macro_entrypoint = { path = "../../crates/macro_entrypoint" }
 macro_env_var = { path = "../../crates/macro_env_var" }
+macro_queues = { path = "../../crates/macro_queues" }
+macro_uuid = { path = "../../crates/macro_uuid" }
 model = { path = "../../crates/model" }
+model_owner = { path = "../../crates/model_owner" }
 s3_key = { path = "../../crates/s3_key" }
 macro_service_urls = { path = "../../crates/macro_service_urls" }
 serde = { workspace = true }
 serde_json = { workspace = true }
+sha2 = { workspace = true }
 sqlx = { workspace = true, features = ["postgres", "runtime-tokio-rustls"] }
+sqs_client = { path = "../../crates/sqs_client" }
 sync_service_client = { path = "../../crates/sync_service_client" }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
 tracing = { workspace = true }
diff --git a/services/document_upload_finalizer_handler/src/app.rs b/services/document_upload_finalizer_handler/src/app.rs
index 662eca6c6cc..c1ff684c1b0 100644
--- a/services/document_upload_finalizer_handler/src/app.rs
+++ b/services/document_upload_finalizer_handler/src/app.rs
@@ -1,7 +1,10 @@
+use documents::domain::legacy_office_upgrade::{
+    LegacyOfficeUpgradeRepoPort, LegacyOfficeUpgradeStoragePort, LegacyOfficeUpgrader,
+};
 use documents::domain::ports::markdown::MarkdownInitializationPort;
 use documents::domain::upload_finalize::{UploadFinalizeDocumentPort, UploadedDocumentFinalizer};
 use model::document::FileType;
-use s3_key::DocumentKey;
+use s3_key::{DocumentKey, UpgradedOfficeFormat};
 
 use crate::ports::{DocumentObjectReader, DocumentUploadMetadataPort};
 
@@ -15,25 +18,36 @@ pub struct ObjectCreated {
 }
 
 /// Application use case for finalizing document uploads from object-created events.
-pub struct DocumentUploadFinalizer<P, O> {
+pub struct DocumentUploadFinalizer<P, O, U> {
     document_port: P,
     object_reader: O,
+    upgrade_storage: U,
 }
 
-impl<P, O> DocumentUploadFinalizer<P, O> {
+impl<P, O, U> DocumentUploadFinalizer<P, O, U> {
     /// Construct the upload finalization use case.
-    pub fn new(document_port: P, object_reader: O) -> Self {
+    pub fn new(document_port: P, object_reader: O, upgrade_storage: U) -> Self {
         Self {
             document_port,
             object_reader,
+            upgrade_storage,
         }
     }
 }
 
-impl<P, O> DocumentUploadFinalizer<P, O>
+fn upgraded_file_type(format: UpgradedOfficeFormat) -> FileType {
+    match format {
+        UpgradedOfficeFormat::Docx => FileType::Docx,
+        UpgradedOfficeFormat::Pptx => FileType::Pptx,
+        UpgradedOfficeFormat::Xlsx => FileType::Xlsx,
+    }
+}
+
+impl<P, O, U> DocumentUploadFinalizer<P, O, U>
 where
-    P: DocumentUploadMetadataPort + UploadFinalizeDocumentPort,
+    P: DocumentUploadMetadataPort + UploadFinalizeDocumentPort + LegacyOfficeUpgradeRepoPort,
     O: DocumentObjectReader,
+    U: LegacyOfficeUpgradeStoragePort,
 {
     /// Handle one object-created event.
     #[tracing::instrument(skip(self, markdown_initializer), err)]
@@ -55,7 +69,9 @@ where
 
         let is_finalizable_key = matches!(
             document_key,
-            DocumentKey::Versioned { .. } | DocumentKey::ConvertedPdf { .. }
+            DocumentKey::Versioned { .. }
+                | DocumentKey::ConvertedPdf { .. }
+                | DocumentKey::UpgradedOffice { .. }
         );
         if !is_finalizable_key {
             tracing::trace!(key=%event.key, ?document_key, "skipping non-finalizable document storage key");
@@ -86,17 +102,37 @@ where
         };
 
         let finalizer = UploadedDocumentFinalizer::new(&self.document_port, markdown_initializer);
+        let upgrader = LegacyOfficeUpgrader::new(&self.document_port, &self.upgrade_storage);
         let result = match document_key {
             DocumentKey::ConvertedPdf { .. } => {
                 finalizer
                     .finalize_converted_pdf_document(&document_context)
                     .await
             }
-            DocumentKey::Versioned { .. } => {
-                finalizer
+            DocumentKey::Versioned { version_id, .. } => {
+                // The legacy original stays ready (downloadable) while its
+                // OpenXML upgrade is produced.
+                match finalizer
                     .finalize_uploaded_document(&document_context, markdown.as_deref())
                     .await
+                {
+                    Ok(()) => upgrader
+                        .request_upgrade(&document_context, version_id)
+                        .await
+                        .map(|requested| {
+                            if requested {
+                                tracing::info!(%document_id, version_id, "requested legacy office upgrade");
+                            }
+                        }),
+                    Err(error) => Err(error),
+                }
             }
+            DocumentKey::UpgradedOffice { format, .. } => upgrader
+                .apply_upgrade(&document_context, upgraded_file_type(format))
+                .await
+                .map(|outcome| {
+                    tracing::info!(%document_id, ?outcome, "applied legacy office upgrade");
+                }),
             _ => unreachable!("non-finalizable keys returned earlier"),
         };
 
@@ -109,3 +145,6 @@ where
         }
     }
 }
+
+#[cfg(test)]
+mod tests;
diff --git a/services/document_upload_finalizer_handler/src/app/tests.rs b/services/document_upload_finalizer_handler/src/app/tests.rs
new file mode 100644
index 00000000000..7ad266550d3
--- /dev/null
+++ b/services/document_upload_finalizer_handler/src/app/tests.rs
@@ -0,0 +1,365 @@
+use std::str::FromStr;
+use std::sync::Mutex;
+
+use documents::domain::content::{DocumentContent, DocumentContentLocation, DocumentContentState};
+use documents::domain::legacy_office_upgrade::{
+    LegacyOfficeUpgradeRequest, UpgradedObjectDestination,
+};
+use documents::domain::models::DocumentError;
+use model::document::DocumentBasic;
+use model_owner::Owner;
+
+use super::*;
+
+const OWNER: &str = "macro|owner@macro.com";
+const DOCUMENT_ID: &str = "01a0914f-1fde-7873-80ba-6eef315d3b50";
+const BUCKET: &str = "document-storage";
+
+#[derive(Clone, Debug, PartialEq)]
+enum Call {
+    SetContent(DocumentContentState, Option<DocumentContentLocation>),
+    RequestUpgrade(LegacyOfficeUpgradeRequest),
+    Promote(FileType, UpgradedObjectDestination),
+    Swap(FileType, FileType),
+    CreateInstance,
+    CreateBom,
+}
+
+#[derive(Default)]
+struct Log(Mutex<Vec<Call>>);
+
+impl Log {
+    fn push(&self, call: Call) {
+        self.0.lock().unwrap().push(call);
+    }
+    fn calls(&self) -> Vec<Call> {
+        self.0.lock().unwrap().clone()
+    }
+}
+
+struct FakeDocuments<'a> {
+    log: &'a Log,
+    file_type: Mutex<Option<String>>,
+    content: DocumentContent,
+}
+
+impl FakeDocuments<'_> {
+    fn document(&self) -> DocumentBasic {
+        DocumentBasic {
+            document_id: DOCUMENT_ID.to_string(),
+            document_name: "Upload".to_string(),
+            owner: Owner::from_principal_str(OWNER).unwrap(),
+            file_type: self.file_type.lock().unwrap().clone(),
+            sub_type: None,
+            branched_from_id: None,
+            branched_from_version_id: None,
+            document_family_id: None,
+            project_id: None,
+            deleted_at: None,
+        }
+    }
+}
+
+impl DocumentUploadMetadataPort for FakeDocuments<'_> {
+    async fn get_basic_document(
+        &self,
+        document_id: &str,
+    ) -> Result<Option<DocumentBasic>, DocumentError> {
+        assert_eq!(document_id, DOCUMENT_ID);
+        Ok(Some(self.document()))
+    }
+}
+
+impl UploadFinalizeDocumentPort for FakeDocuments<'_> {
+    async fn get_document_content(
+        &self,
+        _document_context: &DocumentBasic,
+    ) -> Result<DocumentContent, DocumentError> {
+        Ok(self.content.clone())
+    }
+
+    async fn mark_document_uploaded(&self, _document_id: &str) -> Result<(), DocumentError> {
+        Ok(())
+    }
+
+    async fn set_document_content(
+        &self,
+        _document_id: &str,
+        content: DocumentContent,
+    ) -> Result<(), DocumentError> {
+        self.log
+            .push(Call::SetContent(content.state, content.location));
+        Ok(())
+    }
+}
+
+impl LegacyOfficeUpgradeRepoPort for FakeDocuments<'_> {
+    async fn create_document_instance(
+        &self,
+        _document_id: &str,
+        _sha: &str,
+    ) -> Result<i64, DocumentError> {
+        self.log.push(Call::CreateInstance);
+        Ok(99)
+    }
+
+    async fn delete_document_instance(&self, _version_id: i64) -> Result<(), DocumentError> {
+        Ok(())
+    }
+
+    async fn create_document_bom(&self, _document_id: &str) -> Result<i64, DocumentError> {
+        self.log.push(Call::CreateBom);
+        Ok(5)
+    }
+
+    async fn delete_document_bom(&self, _bom_id: i64) -> Result<(), DocumentError> {
+        Ok(())
+    }
+
+    async fn swap_document_file_type(
+        &self,
+        _document_id: &str,
+        from: FileType,
+        to: FileType,
+    ) -> Result<bool, DocumentError> {
+        self.log.push(Call::Swap(from, to));
+        let mut stored = self.file_type.lock().unwrap();
+        if stored.as_deref() != Some(from.as_str()) {
+            return Ok(false);
+        }
+        *stored = Some(to.as_str().to_string());
+        Ok(true)
+    }
+
+    async fn set_document_content(
+        &self,
+        _document_id: &str,
+        content: DocumentContent,
+    ) -> Result<(), DocumentError> {
+        self.log
+            .push(Call::SetContent(content.state, content.location));
+        Ok(())
+    }
+}
+
+struct FakeObjects;
+
+impl DocumentObjectReader for FakeObjects {
+    async fn read_utf8_object(&self, _bucket: &str, _key: &str) -> Result<String, anyhow::Error> {
+        Ok("# markdown".to_string())
+    }
+}
+
+struct FakeUpgradeStorage<'a> {
+    log: &'a Log,
+}
+
+impl LegacyOfficeUpgradeStoragePort for FakeUpgradeStorage<'_> {
+    async fn request_upgrade(
+        &self,
+        request: &LegacyOfficeUpgradeRequest,
+    ) -> Result<(), DocumentError> {
+        self.log.push(Call::RequestUpgrade(request.clone()));
+        Ok(())
+    }
+
+    async fn upgraded_object_sha(
+        &self,
+        _owner: &Owner,
+        _document_id: &str,
+        _target: FileType,
+    ) -> Result<String, DocumentError> {
+        Ok("sha".to_string())
+    }
+
+    async fn promote_upgraded_object(
+        &self,
+        _owner: &Owner,
+        _document_id: &str,
+        target: FileType,
+        destination: UpgradedObjectDestination,
+    ) -> Result<(), DocumentError> {
+        self.log.push(Call::Promote(target, destination));
+        Ok(())
+    }
+}
+
+struct NoMarkdown;
+
+impl MarkdownInitializationPort for NoMarkdown {
+    async fn initialize_existing_markdown(
+        &self,
+        _document_id: &str,
+        _markdown: &str,
+    ) -> Result<Vec<u8>, DocumentError> {
+        Ok(Vec::new())
+    }
+}
+
+async fn handle(file_type: Option<&str>, content: DocumentContent, key: String) -> Vec<Call> {
+    let log = Log::default();
+    let finalizer = DocumentUploadFinalizer::new(
+        FakeDocuments {
+            log: &log,
+            file_type: Mutex::new(file_type.map(str::to_string)),
+            content,
+        },
+        FakeObjects,
+        FakeUpgradeStorage { log: &log },
+    );
+    finalizer
+        .handle_object_created(
+            ObjectCreated {
+                bucket: BUCKET.to_string(),
+                key,
+            },
+            &NoMarkdown,
+        )
+        .await
+        .unwrap();
+    log.calls()
+}
+
+fn versioned_key(version_id: i64) -> String {
+    format!("{OWNER}/{DOCUMENT_ID}/{version_id}")
+}
+
+fn upgraded_key(extension: &str) -> String {
+    format!("{OWNER}/{DOCUMENT_ID}/upgraded.{extension}")
+}
+
+#[tokio::test]
+async fn legacy_upload_is_finalized_then_upgrade_requested() {
+    for (legacy, target) in [
+        ("ppt", FileType::Pptx),
+        ("doc", FileType::Docx),
+        ("xls", FileType::Xlsx),
+    ] {
+        let calls = handle(Some(legacy), DocumentContent::pending(), versioned_key(12)).await;
+
+        assert_eq!(
+            calls,
+            vec![
+                Call::SetContent(
+                    DocumentContentState::Ready,
+                    Some(DocumentContentLocation::ObjectStorage)
+                ),
+                Call::RequestUpgrade(LegacyOfficeUpgradeRequest {
+                    owner: Owner::from_principal_str(OWNER).unwrap(),
+                    document_id: DOCUMENT_ID.to_string(),
+                    source_version_id: 12,
+                    from: FileType::from_str(legacy).unwrap(),
+                    to: target,
+                }),
+            ],
+            "{legacy}"
+        );
+    }
+}
+
+#[tokio::test]
+async fn modern_uploads_request_no_upgrade() {
+    for file_type in ["pptx", "xlsx", "xlsm", "pdf"] {
+        let calls = handle(
+            Some(file_type),
+            DocumentContent::pending(),
+            versioned_key(3),
+        )
+        .await;
+
+        assert!(
+            !calls
+                .iter()
+                .any(|call| matches!(call, Call::RequestUpgrade(_))),
+            "{file_type}: {calls:?}"
+        );
+    }
+}
+
+#[tokio::test]
+async fn copied_upgrade_version_requests_nothing() {
+    // The copy into a versioned key fires after the type was swapped.
+    let calls = handle(
+        Some("pptx"),
+        DocumentContent::ready(DocumentContentLocation::ObjectStorage),
+        versioned_key(99),
+    )
+    .await;
+
+    assert!(calls.is_empty(), "{calls:?}");
+}
+
+#[tokio::test]
+async fn upgraded_presentation_becomes_the_current_version() {
+    let calls = handle(
+        Some("ppt"),
+        DocumentContent::ready(DocumentContentLocation::ObjectStorage),
+        upgraded_key("pptx"),
+    )
+    .await;
+
+    assert_eq!(
+        calls,
+        vec![
+            Call::CreateInstance,
+            Call::Swap(FileType::Ppt, FileType::Pptx),
+            Call::Promote(
+                FileType::Pptx,
+                UpgradedObjectDestination::DocumentVersion { version_id: 99 }
+            ),
+            Call::SetContent(
+                DocumentContentState::Ready,
+                Some(DocumentContentLocation::ObjectStorage)
+            ),
+        ]
+    );
+}
+
+#[tokio::test]
+async fn upgraded_word_document_is_staged_for_the_docx_pipeline() {
+    let calls = handle(
+        Some("doc"),
+        DocumentContent::ready(DocumentContentLocation::ObjectStorage),
+        upgraded_key("docx"),
+    )
+    .await;
+
+    assert_eq!(
+        calls,
+        vec![
+            Call::CreateBom,
+            Call::Swap(FileType::Doc, FileType::Docx),
+            Call::SetContent(
+                DocumentContentState::Pending,
+                Some(DocumentContentLocation::ConvertedPdf)
+            ),
+            Call::Promote(
+                FileType::Docx,
+                UpgradedObjectDestination::DocxStaging { bom_id: 5 }
+            ),
+        ]
+    );
+}
+
+#[tokio::test]
+async fn redelivered_upgrade_is_skipped() {
+    let calls = handle(
+        Some("xlsx"),
+        DocumentContent::ready(DocumentContentLocation::ObjectStorage),
+        upgraded_key("xlsx"),
+    )
+    .await;
+
+    assert!(calls.is_empty(), "{calls:?}");
+}
+
+#[tokio::test]
+async fn unparseable_keys_are_ignored() {
+    for key in [
+        format!("{OWNER}/{DOCUMENT_ID}/upgraded.doc"),
+        format!("{OWNER}/{DOCUMENT_ID}/notes.txt"),
+    ] {
+        let calls = handle(Some("doc"), DocumentContent::pending(), key.clone()).await;
+        assert!(calls.is_empty(), "{key}");
+    }
+}
diff --git a/services/document_upload_finalizer_handler/src/outbound.rs b/services/document_upload_finalizer_handler/src/outbound.rs
index fc24ecab8e4..6387d7c6cc1 100644
--- a/services/document_upload_finalizer_handler/src/outbound.rs
+++ b/services/document_upload_finalizer_handler/src/outbound.rs
@@ -1,10 +1,22 @@
 use documents::domain::content::DocumentContent;
+use documents::domain::legacy_office_upgrade::{
+    LegacyOfficeUpgradeRepoPort, LegacyOfficeUpgradeRequest, LegacyOfficeUpgradeStoragePort,
+    UpgradedObjectDestination,
+};
 use documents::domain::models::DocumentError;
 use documents::domain::upload_finalize::{RepoUploadFinalizePort, UploadFinalizeDocumentPort};
 use documents::outbound::pg_document_repo::PgDocumentRepo;
 use documents::outbound::s3_utf8_object_reader::S3Utf8ObjectReader;
 use entity_registry::BotFacts;
-use model::document::DocumentBasic;
+use model::convert::ConvertQueueMessage;
+use model::document::{DocumentBasic, FileType};
+use model_owner::Owner;
+use s3_key::{
+    UpgradedOfficeFormat, build_cloud_storage_bucket_document_key,
+    build_docx_staging_bucket_document_key, build_upgraded_office_document_key,
+    document_key_url_path,
+};
+use sha2::{Digest, Sha256};
 
 use crate::ports::{DocumentObjectReader, DocumentUploadMetadataPort};
 
@@ -88,3 +100,208 @@ impl<B: BotFacts + Clone + 'static> UploadFinalizeDocumentPort for PgDocumentUpl
             .await
     }
 }
+
+impl<B: BotFacts + Clone + 'static> LegacyOfficeUpgradeRepoPort for PgDocumentUploadPort<B> {
+    async fn create_document_instance(
+        &self,
+        document_id: &str,
+        sha: &str,
+    ) -> Result<i64, DocumentError> {
+        self.repo.create_document_instance(document_id, sha).await
+    }
+
+    async fn delete_document_instance(&self, version_id: i64) -> Result<(), DocumentError> {
+        self.repo.delete_document_instance(version_id).await
+    }
+
+    async fn create_document_bom(&self, document_id: &str) -> Result<i64, DocumentError> {
+        self.repo.create_document_bom(document_id).await
+    }
+
+    async fn delete_document_bom(&self, bom_id: i64) -> Result<(), DocumentError> {
+        self.repo.delete_document_bom(bom_id).await
+    }
+
+    async fn swap_document_file_type(
+        &self,
+        document_id: &str,
+        from: FileType,
+        to: FileType,
+    ) -> Result<bool, DocumentError> {
+        self.repo
+            .swap_document_file_type(document_id, from, to)
+            .await
+    }
+
+    async fn set_document_content(
+        &self,
+        document_id: &str,
+        content: DocumentContent,
+    ) -> Result<(), DocumentError> {
+        LegacyOfficeUpgradeRepoPort::set_document_content(&self.repo, document_id, content).await
+    }
+}
+
+/// S3 and convert-queue backed storage for legacy Office upgrades.
+#[derive(Clone)]
+pub struct S3LegacyOfficeUpgradeStorage {
+    s3_client: aws_sdk_s3::Client,
+    sqs_client: sqs_client::SQS,
+    document_storage_bucket: String,
+    docx_upload_bucket: String,
+}
+
+impl S3LegacyOfficeUpgradeStorage {
+    /// Construct the upgrade storage adapter.
+    pub fn new(
+        s3_client: aws_sdk_s3::Client,
+        sqs_client: sqs_client::SQS,
+        document_storage_bucket: String,
+        docx_upload_bucket: String,
+    ) -> Self {
+        Self {
+            s3_client,
+            sqs_client,
+            document_storage_bucket,
+            docx_upload_bucket,
+        }
+    }
+}
+
+fn upgraded_format(target: FileType) -> Result<UpgradedOfficeFormat, DocumentError> {
+    match target {
+        FileType::Docx => Ok(UpgradedOfficeFormat::Docx),
+        FileType::Pptx => Ok(UpgradedOfficeFormat::Pptx),
+        FileType::Xlsx => Ok(UpgradedOfficeFormat::Xlsx),
+        _ => Err(DocumentError::BadRequest(format!(
+            "{target} is not an upgrade target"
+        ))),
+    }
+}
+
+fn storage_error(context: &str, error: impl std::fmt::Debug) -> DocumentError {
+    DocumentError::Internal(anyhow::anyhow!("{context}: {error:?}"))
+}
+
+/// The convert-queue message that writes a legacy original's OpenXML upgrade.
+pub fn upgrade_convert_message(
+    request: &LegacyOfficeUpgradeRequest,
+    document_storage_bucket: &str,
+    job_id: String,
+) -> Result<ConvertQueueMessage, DocumentError> {
+    Ok(ConvertQueueMessage {
+        job_id,
+        from_bucket: document_storage_bucket.to_string(),
+        to_bucket: document_storage_bucket.to_string(),
+        from_key: build_cloud_storage_bucket_document_key(
+            &request.owner,
+            &request.document_id,
+            request.source_version_id,
+        ),
+        to_key: build_upgraded_office_document_key(
+            &request.owner,
+            &request.document_id,
+            upgraded_format(request.to)?,
+        ),
+        // Versioned keys have no extension, so the types travel explicitly.
+        from_file_type: Some(request.from),
+        to_file_type: Some(request.to),
+    })
+}
+
+/// The bucket and key an upgraded object is copied to.
+pub fn upgraded_object_destination(
+    owner: &Owner,
+    document_id: &str,
+    destination: UpgradedObjectDestination,
+    document_storage_bucket: &str,
+    docx_upload_bucket: &str,
+) -> (String, String) {
+    match destination {
+        UpgradedObjectDestination::DocumentVersion { version_id } => (
+            document_storage_bucket.to_string(),
+            build_cloud_storage_bucket_document_key(owner, document_id, version_id),
+        ),
+        UpgradedObjectDestination::DocxStaging { bom_id } => (
+            docx_upload_bucket.to_string(),
+            build_docx_staging_bucket_document_key(owner, document_id, bom_id),
+        ),
+    }
+}
+
+impl LegacyOfficeUpgradeStoragePort for S3LegacyOfficeUpgradeStorage {
+    async fn request_upgrade(
+        &self,
+        request: &LegacyOfficeUpgradeRequest,
+    ) -> Result<(), DocumentError> {
+        let message = upgrade_convert_message(
+            request,
+            &self.document_storage_bucket,
+            macro_uuid::generate_uuid_v7().to_string(),
+        )?;
+        self.sqs_client
+            .enqueue_convert_queue_message(message)
+            .await
+            .map_err(|error| storage_error("failed to enqueue legacy office upgrade", error))
+    }
+
+    async fn upgraded_object_sha(
+        &self,
+        owner: &Owner,
+        document_id: &str,
+        target: FileType,
+    ) -> Result<String, DocumentError> {
+        let key = build_upgraded_office_document_key(owner, document_id, upgraded_format(target)?);
+        let object = self
+            .s3_client
+            .get_object()
+            .bucket(&self.document_storage_bucket)
+            .key(&key)
+            .send()
+            .await
+            .map_err(|error| storage_error("failed to read upgraded office object", error))?;
+        let bytes = object
+            .body
+            .collect()
+            .await
+            .map_err(|error| storage_error("failed to read upgraded office object", error))?
+            .into_bytes();
+        Ok(format!("{:x}", Sha256::digest(&bytes)))
+    }
+
+    async fn promote_upgraded_object(
+        &self,
+        owner: &Owner,
+        document_id: &str,
+        target: FileType,
+        destination: UpgradedObjectDestination,
+    ) -> Result<(), DocumentError> {
+        let source_key =
+            build_upgraded_office_document_key(owner, document_id, upgraded_format(target)?);
+        let (bucket, key) = upgraded_object_destination(
+            owner,
+            document_id,
+            destination,
+            &self.document_storage_bucket,
+            &self.docx_upload_bucket,
+        );
+        self.s3_client
+            .copy_object()
+            .copy_source(format!(
+                "{}/{}",
+                self.document_storage_bucket,
+                document_key_url_path(&source_key)
+            ))
+            .bucket(bucket)
+            .key(key)
+            .content_type(target.mime_type())
+            .metadata_directive(aws_sdk_s3::types::MetadataDirective::Replace)
+            .send()
+            .await
+            .map_err(|error| storage_error("failed to copy upgraded office object", error))?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/services/document_upload_finalizer_handler/src/outbound/tests.rs b/services/document_upload_finalizer_handler/src/outbound/tests.rs
new file mode 100644
index 00000000000..f86bb638c12
--- /dev/null
+++ b/services/document_upload_finalizer_handler/src/outbound/tests.rs
@@ -0,0 +1,103 @@
+use super::*;
+
+const OWNER: &str = "macro|owner@macro.com";
+const DOCUMENT_ID: &str = "01a0914f-1fde-7873-80ba-6eef315d3b50";
+
+fn owner() -> Owner {
+    Owner::from_principal_str(OWNER).unwrap()
+}
+
+fn request(from: FileType, to: FileType) -> LegacyOfficeUpgradeRequest {
+    LegacyOfficeUpgradeRequest {
+        owner: owner(),
+        document_id: DOCUMENT_ID.to_string(),
+        source_version_id: 314,
+        from,
+        to,
+    }
+}
+
+#[test]
+fn convert_message_reads_the_version_and_writes_the_upgraded_key() {
+    for (from, to, extension) in [
+        (FileType::Ppt, FileType::Pptx, "pptx"),
+        (FileType::Doc, FileType::Docx, "docx"),
+        (FileType::Xls, FileType::Xlsx, "xlsx"),
+    ] {
+        let message =
+            upgrade_convert_message(&request(from, to), "doc-storage", "job".to_string()).unwrap();
+
+        assert_eq!(message.job_id, "job");
+        assert_eq!(message.from_bucket, "doc-storage");
+        assert_eq!(message.to_bucket, "doc-storage");
+        assert_eq!(message.from_key, format!("{OWNER}/{DOCUMENT_ID}/314"));
+        assert_eq!(
+            message.to_key,
+            format!("{OWNER}/{DOCUMENT_ID}/upgraded.{extension}")
+        );
+        assert_eq!(message.from_file_type, Some(from));
+        assert_eq!(message.to_file_type, Some(to));
+    }
+}
+
+#[test]
+fn convert_message_round_trips_through_json() {
+    let message = upgrade_convert_message(
+        &request(FileType::Doc, FileType::Docx),
+        "doc-storage",
+        "job".to_string(),
+    )
+    .unwrap();
+
+    let json = serde_json::to_value(&message).unwrap();
+    assert_eq!(json["from_file_type"], "doc");
+    assert_eq!(json["to_file_type"], "docx");
+    let parsed: ConvertQueueMessage = serde_json::from_value(json).unwrap();
+    assert_eq!(parsed.from_file_type, Some(FileType::Doc));
+}
+
+#[test]
+fn convert_message_rejects_non_upgrade_targets() {
+    assert!(
+        upgrade_convert_message(
+            &request(FileType::Pdf, FileType::Pdf),
+            "doc-storage",
+            "job".to_string()
+        )
+        .is_err()
+    );
+}
+
+#[test]
+fn versions_are_copied_into_document_storage() {
+    assert_eq!(
+        upgraded_object_destination(
+            &owner(),
+            DOCUMENT_ID,
+            UpgradedObjectDestination::DocumentVersion { version_id: 77 },
+            "doc-storage",
+            "docx-upload",
+        ),
+        (
+            "doc-storage".to_string(),
+            format!("{OWNER}/{DOCUMENT_ID}/77")
+        )
+    );
+}
+
+#[test]
+fn word_upgrades_are_staged_in_the_docx_bucket() {
+    assert_eq!(
+        upgraded_object_destination(
+            &owner(),
+            DOCUMENT_ID,
+            UpgradedObjectDestination::DocxStaging { bom_id: 8 },
+            "doc-storage",
+            "docx-upload",
+        ),
+        (
+            "docx-upload".to_string(),
+            format!("{OWNER}/{DOCUMENT_ID}/8.docx")
+        )
+    );
+}
diff --git a/services/document_upload_finalizer_handler/src/runtime.rs b/services/document_upload_finalizer_handler/src/runtime.rs
index 0ec0f074824..b89cbbec29b 100644
--- a/services/document_upload_finalizer_handler/src/runtime.rs
+++ b/services/document_upload_finalizer_handler/src/runtime.rs
@@ -11,17 +11,23 @@ use sqlx::postgres::PgPoolOptions;
 use sync_service_client::SyncServiceClient;
 
 use crate::app::{DocumentUploadFinalizer, ObjectCreated};
-use crate::outbound::{PgDocumentUploadPort, S3DocumentObjectReader};
+use crate::outbound::{PgDocumentUploadPort, S3DocumentObjectReader, S3LegacyOfficeUpgradeStorage};
 
 env_vars! {
     struct DatabaseUrl;
     struct InternalApiSecretKey;
     struct SyncServiceAuthKey;
+    struct DocumentStorageBucket;
+    struct DocxDocumentUploadBucket;
 }
 
 /// Concrete app context used by Lambda and local worker entrypoints.
 pub struct AppContext {
-    finalizer: DocumentUploadFinalizer<PgDocumentUploadPort<PgBotsRepo>, S3DocumentObjectReader>,
+    finalizer: DocumentUploadFinalizer<
+        PgDocumentUploadPort<PgBotsRepo>,
+        S3DocumentObjectReader,
+        S3LegacyOfficeUpgradeStorage,
+    >,
     lexical_client: LexicalClient,
     sync_service_client: SyncServiceClient,
 }
@@ -36,6 +42,12 @@ impl AppContext {
         let sync_service_auth_key = SyncServiceAuthKey::new()
             .context("SYNC_SERVICE_AUTH_KEY must be provided")?
             .to_string();
+        let document_storage_bucket = DocumentStorageBucket::new()
+            .context("DOCUMENT_STORAGE_BUCKET must be provided")?
+            .to_string();
+        let docx_upload_bucket = DocxDocumentUploadBucket::new()
+            .context("DOCX_DOCUMENT_UPLOAD_BUCKET must be provided")?
+            .to_string();
         let lexical_service_url = LexicalServiceUrl::new()?.to_string();
         let sync_service_url = SyncServiceUrl::new()?.to_string();
 
@@ -49,8 +61,20 @@ impl AppContext {
             OwnedEntityRegistrar::new(OwnerGrantPolicy::new(PgBotsRepo::new(db_pool.clone())));
         let repo = PgDocumentRepo::new(db_pool, registrar);
         let document_port = PgDocumentUploadPort::new(repo);
-        let object_reader = S3DocumentObjectReader::new(macro_aws_config::s3_client().await);
-        let finalizer = DocumentUploadFinalizer::new(document_port, object_reader);
+        let s3_client = macro_aws_config::s3_client().await;
+        let object_reader = S3DocumentObjectReader::new(s3_client.clone());
+        let convert_queue = macro_queues::ConvertQueue::new();
+        let sqs_client = sqs_client::SQS::new(aws_sdk_sqs::Client::new(
+            &macro_aws_config::get_macro_aws_config().await,
+        ))
+        .convert_queue(&convert_queue);
+        let upgrade_storage = S3LegacyOfficeUpgradeStorage::new(
+            s3_client,
+            sqs_client,
+            document_storage_bucket,
+            docx_upload_bucket,
+        );
+        let finalizer = DocumentUploadFinalizer::new(document_port, object_reader, upgrade_storage);
 
         Ok(Self {
             finalizer,
diff --git a/services/docx_unzip_handler/src/service/document/process_document.rs b/services/docx_unzip_handler/src/service/document/process_document.rs
index 09b1769dacd..d4fdd58c2ce 100644
--- a/services/docx_unzip_handler/src/service/document/process_document.rs
+++ b/services/docx_unzip_handler/src/service/document/process_document.rs
@@ -59,6 +59,8 @@ pub async fn process(
                 &document_key_parts.document_id,
             ),
             to_bucket: ctx.config.document_storage_bucket.clone(),
+            from_file_type: None,
+            to_file_type: None,
         })
         .await
     {
diff --git a/services/search_upload_handler/src/handler.rs b/services/search_upload_handler/src/handler.rs
index 89b660e8f27..ce9090cdee0 100644
--- a/services/search_upload_handler/src/handler.rs
+++ b/services/search_upload_handler/src/handler.rs
@@ -32,9 +32,12 @@ pub async fn handler(
         }
     };
 
+    // An upgraded legacy Office file is an intermediate: its copy into a
+    // versioned key relays the content upload.
     if document_key.is_temp()
         || document_key.is_bom_part()
         || document_key.is_sync_service_snapshot()
+        || document_key.is_upgraded_office()
     {
         tracing::trace!("skipping non-document key");
         return Ok(());