mixdog 1.3.1 → 1.3.3

package/src/runtime/attachments/legacy-office.mjs

@@ -0,0 +1,110 @@
+// Legacy Office (.doc / .xls / .ppt, OLE compound) attachments. Text
+// extraction reads OOXML packages only, so a legacy file is saved as its
+// package by LibreOffice (convertLegacyOffice, the conversion `office open`
+// uses) in a private scratch folder, never beside the user's file.
+import { mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { basename, extname, join } from 'node:path';
+import { redactDirectories } from '../shared/redact-directories.mjs';
+import { removeDirectoryWithRetry } from '../shared/remove-directory.mjs';
+
+// The first eight bytes of every legacy Office (OLE compound) file.
+const OLE_COMPOUND_MAGIC = Buffer.from([0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1]);
+
+const PACKAGE_BY_LEGACY_EXTENSION = { doc: 'docx', xls: 'xlsx', ppt: 'pptx' };
+const PACKAGE_BY_LEGACY_MIME = {
+  'application/msword': 'docx',
+  'application/vnd.ms-excel': 'xlsx',
+  'application/vnd.ms-powerpoint': 'pptx',
+};
+const PACKAGE_BY_OOXML_EXTENSION = { docx: 'docx', xlsx: 'xlsx', xlsm: 'xlsx', pptx: 'pptx' };
+
+export const OOXML_MIME_BY_PACKAGE = {
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+};
+const PACKAGE_BY_OOXML_MIME = {
+  ...Object.fromEntries(Object.entries(OOXML_MIME_BY_PACKAGE).map(([kind, mime]) => [mime, kind])),
+  'application/vnd.ms-excel.sheet.macroenabled.12': 'xlsx',
+};
+
+export function isLegacyOfficeBuffer(buffer) {
+  return buffer.length >= 8 && buffer.subarray(0, 8).equals(OLE_COMPOUND_MAGIC);
+}
+
+/** The package extension (`docx`/`xlsx`/`pptx`) an attachment labelled legacy Office
+ *  (by MIME type or file extension) converts to, else ''. */
+export function legacyOfficeLabelPackage(mimeType, filename) {
+  const mime = String(mimeType || '')
+    .split(';', 1)[0]
+    .trim()
+    .toLowerCase();
+  const extension = extname(String(filename || ''))
+    .slice(1)
+    .toLowerCase();
+  return PACKAGE_BY_LEGACY_MIME[mime] || PACKAGE_BY_LEGACY_EXTENSION[extension] || '';
+}
+
+/** The package an OLE file labelled as an OOXML Office file (renamed, or sent
+ *  with the OOXML MIME type and no extension) converts to, else ''. */
+export function ooxmlLabelPackage(mimeType, filename) {
+  const mime = String(mimeType || '')
+    .split(';', 1)[0]
+    .trim()
+    .toLowerCase();
+  const extension = extname(String(filename || ''))
+    .slice(1)
+    .toLowerCase();
+  return PACKAGE_BY_OOXML_MIME[mime] || PACKAGE_BY_OOXML_EXTENSION[extension] || '';
+}
+
+async function defaultConvert(path, output, options) {
+  const { convertLegacyOffice } = await import('../office/portable/portable-soffice.mjs');
+  return convertLegacyOffice(path, output, options);
+}
+
+/**
+ * Saves the legacy Office `buffer` as the OOXML package `kind` and returns the
+ * package bytes and its file name. The scratch folder is always removed, once
+ * the converter has returned (it returns only after its process has closed;
+ * a removal that still meets a held file is retried, and a final failure is
+ * logged). A failure (LibreOffice missing, damaged or protected file, bytes
+ * that are not a legacy Office file) throws a message with the scratch path
+ * taken out; a cancellation rethrows the abort itself.
+ */
+export async function convertLegacyOfficeBuffer(
+  buffer,
+  filename,
+  kind,
+  { signal = null, convert = defaultConvert, remove = undefined, log = undefined, retryMs = undefined } = {}
+) {
+  signal?.throwIfAborted();
+  if (!isLegacyOfficeBuffer(buffer)) {
+    throw new Error(
+      `${filename || 'This attachment'} is labelled as a legacy Office file but its content is not one, so it cannot be converted. Open it in Microsoft Office and save it as .${kind}, then attach that copy.`
+    );
+  }
+  const stem = basename(String(filename || 'attachment'), extname(String(filename || ''))) || 'attachment';
+  const safeStem = stem.replace(/[^\w.-]+/g, '_').slice(0, 80) || 'attachment';
+  const legacyExtension = Object.keys(PACKAGE_BY_LEGACY_EXTENSION).find(
+    (ext) => PACKAGE_BY_LEGACY_EXTENSION[ext] === kind
+  );
+  const dir = await mkdtemp(join(tmpdir(), 'mixdog-attachment-'));
+  let converted;
+  try {
+    const source = join(dir, `${safeStem}.${legacyExtension}`);
+    const output = join(dir, `${safeStem}.${kind}`);
+    await writeFile(source, buffer);
+    await convert(source, output, { signal });
+    converted = { buffer: await readFile(output), filename: `${stem}.${kind}` };
+  } catch (error) {
+    signal?.throwIfAborted();
+    throw new Error(redactDirectories(error instanceof Error ? error.message : String(error), [dir]));
+  } finally {
+    await removeDirectoryWithRetry(dir, { remove, log, retryMs });
+  }
+  // A cancel that arrived while the folder was being removed still cancels.
+  signal?.throwIfAborted();
+  return converted;
+}

package/src/runtime/attachments/limits.mjs

@@ -16,5 +16,9 @@ const PDF_MAGIC = Buffer.from('%PDF-', 'latin1');
 
 /** True when the bytes start with the %PDF- header. */
 export function isPdfBuffer(buffer) {
-  return Buffer.isBuffer(buffer) && buffer.length >= PDF_MAGIC.length && buffer.subarray(0, PDF_MAGIC.length).equals(PDF_MAGIC);
+  return (
+    Buffer.isBuffer(buffer) &&
+    buffer.length >= PDF_MAGIC.length &&
+    buffer.subarray(0, PDF_MAGIC.length).equals(PDF_MAGIC)
+  );
 }

package/src/runtime/attachments/office-extract.mjs

@@ -6,6 +6,7 @@
 // No external dependencies.
 import { readFile, stat } from 'node:fs/promises';
 import { inflateRawSync } from 'node:zlib';
+import { stripTrailingReplacementChars } from '../shared/utf8-cut.mjs';
 
 // Longest run of attributes inside one tag that a pattern will cross. Bounded
 // so a tag with no closing bracket cannot make a pattern rescan the part.
@@ -675,12 +676,8 @@ function sheetFigures(buf, entries, sheetPart) {
 function capOutput(text, maxOutputBytes) {
   const buf = Buffer.from(text, 'utf8');
   if (buf.length <= maxOutputBytes) return text;
-  let cut = buf.subarray(0, maxOutputBytes).toString('utf8');
-  // Drop the replacement characters a split multi-byte sequence leaves (a loop:
-  // `/\uFFFD+$/` is quadratic on a long run of them).
-  let end = cut.length;
-  while (end > 0 && cut[end - 1] === '\uFFFD') end -= 1;
-  cut = cut.slice(0, end);
+  // Drop the replacement characters a split multi-byte sequence leaves.
+  const cut = stripTrailingReplacementChars(buf.subarray(0, maxOutputBytes).toString('utf8'));
   return `${cut}\n... [office text truncated at ${maxOutputBytes} bytes]`;
 }
 

package/src/runtime/attachments/pdf-extract.mjs

@@ -5,19 +5,18 @@
  * OpenAI-compatible providers without a document contract receive page-ordered
  * text extracted here, so they never see an unsupported inline Base64 block.
  */
+import { stripTrailingReplacementChars } from '../shared/utf8-cut.mjs';
 import { MAX_PDF_PAGES } from './limits.mjs';
 import { resolvedPdfJs } from './pdfjs-runtime.mjs';
 
 const DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024;
 
-function boundedUtf8(value, maxBytes) {
+/** `value` cut to at most `maxBytes` of UTF-8, never inside a multi-byte sequence. */
+export function boundedUtf8(value, maxBytes) {
   const buffer = Buffer.from(String(value || ''), 'utf8');
   if (buffer.length <= maxBytes) return { text: buffer.toString('utf8'), bytes: buffer.length, truncated: false };
   if (maxBytes <= 0) return { text: '', bytes: 0, truncated: true };
-  const text = buffer
-    .subarray(0, maxBytes)
-    .toString('utf8')
-    .replace(/\uFFFD+$/g, '');
+  const text = stripTrailingReplacementChars(buffer.subarray(0, maxBytes).toString('utf8'));
   return { text, bytes: Buffer.byteLength(text, 'utf8'), truncated: true };
 }
 
@@ -74,38 +73,90 @@ function pageBodyText(content) {
     .trim();
 }
 
-export async function inspectPdfBuffer(
+/** The deadline prompt intake passes: it runs inside a room's post queue, which
+ *  a document that never loads would otherwise hold forever. */
+export const PDF_INTAKE_TIMEOUT_MS = 60_000;
+
+// A page counts as carrying a text layer when its extracted text holds at
+// least this many non-whitespace characters. A scan often keeps a stamped page
+// number or a few stray glyphs; those alone do not make its content readable
+// as text, so such a page still needs its image (or OCR).
+export const PDF_TEXT_LAYER_MIN_CHARS = 16;
+
+/** Whether one page's extracted text is a real text layer (see above). */
+export function pageHasTextLayer(text) {
+  return String(text || '').replace(/\s+/g, '').length >= PDF_TEXT_LAYER_MIN_CHARS;
+}
+
+function timeoutError(timeoutMs) {
+  return Object.assign(new Error(`PDF inspection timed out after ${timeoutMs} ms`), {
+    code: 'PDF_INSPECTION_TIMEOUT',
+  });
+}
+
+/** Inspect a PDF. With `timeoutMs`, a document that has not finished by then
+ *  is destroyed and the call rejects (`code: 'PDF_INSPECTION_TIMEOUT'`);
+ *  without it there is no deadline. */
+export async function inspectPdfBuffer(buffer, { timeoutMs = null, ...options } = {}) {
+  if (!Buffer.isBuffer(buffer) || buffer.length === 0) throw new TypeError('PDF payload is empty');
+  const hold = { pdf: null, expired: false };
+  if (!(timeoutMs > 0)) return inspectLoaded(buffer, options, hold);
+  let timer;
+  const deadline = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      hold.expired = true;
+      // A document still loading is destroyed as soon as it arrives (below).
+      Promise.resolve(hold.pdf?.destroy?.()).catch(() => {});
+      reject(timeoutError(timeoutMs));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([inspectLoaded(buffer, options, hold), deadline]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function inspectLoaded(
   buffer,
   {
     extractText = false,
+    measureText = false,
     maxPages = MAX_PDF_PAGES,
     maxOutputBytes = DEFAULT_MAX_OUTPUT_BYTES,
     pageRange = null,
     password = '',
-  } = {}
+  },
+  hold
 ) {
-  if (!Buffer.isBuffer(buffer) || buffer.length === 0) throw new TypeError('PDF payload is empty');
   await resolvedPdfJs();
   const { getDocumentProxy } = await import('unpdf');
   const pdf = await getDocumentProxy(new Uint8Array(buffer), password ? { password: String(password) } : {});
+  hold.pdf = pdf;
   try {
+    if (hold.expired) throw timeoutError(0);
     const pageCount = Math.max(0, Number(pdf?.numPages) || 0);
     const pageLimit = Number.isFinite(Number(maxPages)) ? Math.max(1, Math.floor(Number(maxPages))) : Infinity;
     if (pageCount > pageLimit) {
       throw new RangeError(`PDF has ${pageCount} pages; maximum supported attachment is ${pageLimit} pages`);
     }
+    if (measureText) return { pageCount, ...(await measureTextLayer(pdf, pageCount, hold)) };
     if (!extractText) return { pageCount, text: '', truncated: false };
 
     const from = Math.max(1, Number(pageRange?.from) || 1);
     const to = Math.min(pageCount, Math.max(from, Number(pageRange?.to) || pageCount));
     const byteLimit = Math.max(1, Number(maxOutputBytes) || DEFAULT_MAX_OUTPUT_BYTES);
     const chunks = [];
+    // Each page's own text (before the output budget cuts it), so a caller can
+    // tell text pages from scanned ones.
+    const pages = [];
     let bytes = 0;
     let truncated = false;
     for (let pageNumber = from; pageNumber <= to; pageNumber += 1) {
       const page = await pdf.getPage(pageNumber);
       try {
         const body = pageBodyText(await page.getTextContent());
+        pages.push({ page: pageNumber, text: body });
         const block = `--- Page ${pageNumber} ---\n${body || '(no extractable text on this page)'}`;
         const separatorBytes = chunks.length ? 2 : 0;
         const remaining = byteLimit - bytes - separatorBytes;
@@ -134,12 +185,35 @@ export async function inspectPdfBuffer(
       const suffix = '\n\n... [PDF text truncated to the prompt input budget]';
       const room = Math.max(0, byteLimit - Buffer.byteLength(suffix, 'utf8'));
       const bounded = boundedUtf8(chunks.join(''), room);
-      return { pageCount, text: `${bounded.text}${suffix}`, truncated: true };
+      return { pageCount, text: `${bounded.text}${suffix}`, truncated: true, pages };
     }
-    return { pageCount, text: chunks.join(''), truncated: false };
+    return { pageCount, text: chunks.join(''), truncated: false, pages };
   } finally {
     try {
       await pdf.destroy?.();
     } catch {}
   }
 }
+
+// How much of the document reads as text: the pages that carry a text layer
+// and the characters they hold. Nothing is kept but the counts.
+async function measureTextLayer(pdf, pageCount, hold) {
+  let textPages = 0;
+  let textChars = 0;
+  for (let pageNumber = 1; pageNumber <= pageCount; pageNumber += 1) {
+    if (hold.expired) throw timeoutError(0);
+    const page = await pdf.getPage(pageNumber);
+    try {
+      const body = pageBodyText(await page.getTextContent());
+      if (pageHasTextLayer(body)) {
+        textPages += 1;
+        textChars += body.length;
+      }
+    } finally {
+      try {
+        page.cleanup?.();
+      } catch {}
+    }
+  }
+  return { textPages, textChars };
+}

package/src/runtime/attachments/prompt-restore.mjs

@@ -0,0 +1,70 @@
+// Rebuilds the composer's restore payload (`pastedTexts`, `pastedImages`) from a
+// stored, materialized user prompt. The model history holds the EXPANDED prompt:
+// each `[Pasted text #n …]` / `[File #n …]` token became a `textKind` reference
+// part, in token order, and each image an image reference part. The transcript
+// row's own text still spells the tokens, so the n-th reference part belongs to
+// the n-th token; the entries carry references only and are hydrated by the
+// caller (`hydratePastedAttachments`) exactly as the abort/queue restores are.
+import { isAttachmentReference } from './store.mjs';
+
+const TEXT_TOKEN_RE = /\[(Pasted text|File) #(\d+)(?:: ([^\]\r\n]+))?[^\]\r\n]*\]/g;
+const IMAGE_TOKEN_RE = /\[Image #(\d+)[^\]\r\n]*\]/g;
+
+export function restorableAttachmentsFromPrompt(content, rowText) {
+  const parts = Array.isArray(content) ? content : [];
+  const text = String(rowText ?? '');
+  const textRefs = parts.filter(
+    (part) =>
+      part?.type === 'text' && isAttachmentReference(part) && (part.textKind === 'paste' || part.textKind === 'file')
+  );
+  const imageRefs = parts.filter((part) => part?.type === 'image' && isAttachmentReference(part));
+
+  // A `[File #n: name]` token is also spelled for binary files (PDF/Office),
+  // which never became a text reference: a token takes the next text reference
+  // only when it is the same kind (and, for files, the same name).
+  const pastedTexts = {};
+  let next = 0;
+  for (const match of text.matchAll(TEXT_TOKEN_RE)) {
+    const part = textRefs[next];
+    if (!part) break;
+    const isFile = match[1] === 'File';
+    if (isFile ? part.textKind !== 'file' || match[3] !== part.filename : part.textKind !== 'paste') continue;
+    next += 1;
+    const id = Number(match[2]);
+    if (!id || pastedTexts[id]) continue;
+    pastedTexts[id] = {
+      id,
+      source: part.textKind === 'file' ? 'file' : 'paste',
+      attachmentRef: part.attachmentRef,
+      sizeBytes: part.sizeBytes,
+      ...(part.filename ? { filename: part.filename } : {}),
+      ...(part.mimeType ? { mimeType: part.mimeType } : {}),
+    };
+  }
+
+  const imageIds = [...text.matchAll(IMAGE_TOKEN_RE)].map((match) => Number(match[1]));
+  const usedIds = new Set([...Object.keys(pastedTexts).map(Number), ...imageIds]);
+  let nextId = 1;
+  const pastedImages = {};
+  imageRefs.forEach((part, index) => {
+    let id = Number(part.pasteId) || imageIds[index] || 0;
+    if (!id || pastedImages[id]) {
+      while (usedIds.has(nextId)) nextId += 1;
+      id = nextId;
+      usedIds.add(id);
+    }
+    pastedImages[id] = {
+      id,
+      type: 'image',
+      mediaType: String(part.mimeType || part.mediaType || 'image/png'),
+      attachmentRef: part.attachmentRef,
+      sizeBytes: part.sizeBytes,
+      ...(part.filename ? { filename: part.filename } : {}),
+    };
+  });
+
+  return {
+    pastedTexts: Object.keys(pastedTexts).length ? pastedTexts : null,
+    pastedImages: Object.keys(pastedImages).length ? pastedImages : null,
+  };
+}

package/src/runtime/attachments/store.mjs

@@ -6,7 +6,7 @@
  * snapshots carry only a sha256 reference plus byte-free metadata.
  * Provider lowering resolves the reference at the last possible boundary.
  */
-import { createHash, randomBytes } from 'node:crypto';
+import { createHash } from 'node:crypto';
 import {
   closeSync,
   existsSync,
@@ -15,18 +15,25 @@ import {
   openSync,
   readFileSync,
   readSync,
-  renameSync,
   statSync,
   unlinkSync,
   utimesSync,
   writeFileSync,
 } from 'node:fs';
-import { mkdir, readdir, readFile as readFileAsync, rename, stat, unlink, writeFile } from 'node:fs/promises';
+import { readdir, readFile as readFileAsync, stat, unlink } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 
+import { writeFileAtomicSync, writeJsonAtomicAsync } from '../shared/atomic-file.mjs';
 import { resolvePluginData } from '../shared/plugin-paths.mjs';
+import {
+  convertLegacyOfficeBuffer,
+  isLegacyOfficeBuffer,
+  legacyOfficeLabelPackage,
+  OOXML_MIME_BY_PACKAGE,
+  ooxmlLabelPackage,
+} from './legacy-office.mjs';
 import { MAX_ATTACHMENT_BLOB_BYTES, MAX_PDF_BYTES, MAX_PDF_PAGES, isPdfBuffer } from './limits.mjs';
-import { inspectPdfBuffer } from './pdf-extract.mjs';
+import { inspectPdfBuffer, PDF_INTAKE_TIMEOUT_MS } from './pdf-extract.mjs';
 
 const ATTACHMENT_REF_RE = /^[a-f0-9]{64}$/;
 const TEXT_TOKEN_RE = /\[(?:Pasted text|File) #(\d+)[^\]\r\n]*\]/g;
@@ -140,17 +147,13 @@ function saveBuffer(buffer) {
   }
   if (!existingValid) {
     mkdirSync(join(attachmentsDir(), attachmentRef.slice(0, 2)), { recursive: true, mode: 0o700 });
-    const temp = `${target}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`;
     try {
-      writeFileSync(temp, buffer, { mode: 0o600 });
-      renameSync(temp, target);
+      // Durable, so a crash cannot leave this content address holding NUL
+      // bytes (a read would then fail its digest check).
+      writeFileAtomicSync(target, buffer, { mode: 0o600 });
     } catch (error) {
       // A concurrent writer may have published the same content first.
       if (!storedMatches()) throw error;
-    } finally {
-      try {
-        unlinkSync(temp);
-      } catch {}
     }
   } else {
     // Reusing old content creates a fresh reference before its queue/session
@@ -172,10 +175,23 @@ export function storeAttachmentBuffer(buffer) {
   return saveBuffer(buffer);
 }
 
+/** Where the store keeps the bytes of `ref` on this machine (no extension:
+ *  the read tool recognizes PDFs and images there by their content). */
+export function attachmentFilePath(ref) {
+  return attachmentPath(ref);
+}
+
 export function isAttachmentReference(value) {
   return Boolean(value && typeof value === 'object' && ATTACHMENT_REF_RE.test(String(value.attachmentRef || '')));
 }
 
+// The bytes of a base64 string, or null when they are empty or would not
+// re-encode to the same string (a stored reference could not replay it exactly).
+function canonicalBase64Buffer(data) {
+  const buffer = Buffer.from(data, 'base64');
+  return buffer.length === 0 || buffer.toString('base64') !== data ? null : buffer;
+}
+
 /**
  * Stored-history form of an inline base64 image part (`{ type:'image', data }`
  * or `{ type:'image', source:{ type:'base64' } }`): the same part as a
@@ -200,8 +216,8 @@ export function storeInlineImagePart(part) {
   } else {
     return null;
   }
-  const buffer = Buffer.from(data, 'base64');
-  if (buffer.length === 0 || buffer.toString('base64') !== data) return null;
+  const buffer = canonicalBase64Buffer(data);
+  if (!buffer) return null;
   return { ...metadata, ...saveBuffer(buffer) };
 }
 
@@ -235,8 +251,8 @@ export function storeInlineDocumentPart(part) {
   } else {
     return null;
   }
-  const buffer = Buffer.from(data, 'base64');
-  if (buffer.length === 0 || buffer.toString('base64') !== data) return null;
+  const buffer = canonicalBase64Buffer(data);
+  if (!buffer) return null;
   // The magic header decides the kind before the label does (inlineFileKind),
   // so a mislabelled PDF is stored under its real type: the reloaded part then
   // estimates and lowers exactly like the live one.
@@ -380,7 +396,7 @@ function materializePastedTexts(pastedTexts) {
         type: 'text',
         attachmentRef: raw.attachmentRef,
         sizeBytes: attachmentBlobSize(raw, raw.sizeBytes),
-        ...(raw.source === 'file' ? { textKind: 'file' } : {}),
+        textKind: raw.source === 'file' ? 'file' : 'paste',
         ...(raw.filename ? { filename: raw.filename } : {}),
         ...(raw.mimeType ? { mimeType: raw.mimeType } : {}),
       };
@@ -621,6 +637,50 @@ export function providerTakesNativePdf(provider) {
   return provider?.nativePdf !== false;
 }
 
+/**
+ * A legacy Office attachment (.doc/.xls/.ppt: by label, or an OLE file renamed
+ * to an OOXML name) as the OOXML package LibreOffice saves it as, stored under
+ * its own reference, so text extraction and every later lowering see an
+ * ordinary package. A conversion that cannot run (LibreOffice missing, damaged
+ * file, or bytes that are not a legacy file under a legacy label) becomes a text
+ * part carrying the converter's message, so the model and the user are told
+ * instead of the file vanishing. A cancellation (`signal`) is rethrown, never
+ * turned into text. Any other part is returned as is.
+ */
+async function packageLegacyOfficePart(part, { convertLegacy, signal }) {
+  if (part?.type !== 'file' || !isAttachmentReference(part)) return part;
+  const mimeType = part.mimeType || part.mediaType;
+  const legacyKind = legacyOfficeLabelPackage(mimeType, part.filename);
+  const kind = legacyKind || ooxmlLabelPackage(mimeType, part.filename);
+  if (!kind) return part;
+  const buffer = readAttachmentBuffer(part);
+  // An OOXML-labelled part converts only when its bytes are legacy; a legacy
+  // label is always converted (or explained).
+  if (!legacyKind && !isLegacyOfficeBuffer(buffer)) return part;
+  const name = String(part.filename || '')
+    .split(/[\\/]/)
+    .pop();
+  try {
+    const converted = await convertLegacyOfficeBuffer(buffer, part.filename, kind, {
+      signal,
+      ...(convertLegacy ? { convert: convertLegacy } : {}),
+    });
+    const { mediaType: _mediaType, ...rest } = part;
+    return {
+      ...rest,
+      ...saveBuffer(converted.buffer),
+      mimeType: OOXML_MIME_BY_PACKAGE[kind],
+      filename: converted.filename,
+    };
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    return {
+      type: 'text',
+      text: `--- ${name || 'attachment'} ---\n${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
 /**
  * PDF intake validation. Every PDF keeps its content-addressed reference — the
  * one conversion to text happens at provider lowering — so this only checks what
@@ -629,13 +689,19 @@ export function providerTakesNativePdf(provider) {
  * PDF as text reads its first MAX_PDF_PAGES pages, so a longer PDF is accepted.
  * The page count is recorded on the part for estimates.
  */
-export async function preparePromptSubmissionForProvider(intake, provider) {
+export async function preparePromptSubmissionForProvider(
+  intake,
+  provider,
+  { convertLegacy = undefined, signal = null } = {}
+) {
   const prompt = intake?.prompt;
   if (!Array.isArray(prompt)) return intake;
   const nativePdf = providerTakesNativePdf(provider);
   let changed = false;
   const prepared = [];
-  for (const part of prompt) {
+  for (const candidate of prompt) {
+    const part = await packageLegacyOfficePart(candidate, { convertLegacy, signal });
+    if (part !== candidate) changed = true;
     const mimeType = String(part?.mimeType || part?.mediaType || '').toLowerCase();
     if (part?.type !== 'file' || mimeType !== 'application/pdf' || !isAttachmentReference(part)) {
       prepared.push(part);
@@ -645,11 +711,21 @@ export async function preparePromptSubmissionForProvider(intake, provider) {
     if (bytes > MAX_PDF_BYTES) {
       throw new RangeError(`PDF exceeds the ${MAX_PDF_BYTES / 1024 / 1024} MiB input limit`);
     }
+    // The text-layer counts price the PDF (a scanned page costs its page image,
+    // a text page its text as well) and tell the model, when the PDF is sent
+    // as a reference, which pages read as text.
     const inspected = await inspectPdfBuffer(readAttachmentBuffer(part), {
       maxPages: nativePdf ? MAX_PDF_PAGES : Infinity,
+      measureText: true,
+      timeoutMs: PDF_INTAKE_TIMEOUT_MS,
     });
     changed = true;
-    prepared.push({ ...part, pageCount: inspected.pageCount });
+    prepared.push({
+      ...part,
+      pageCount: inspected.pageCount,
+      textPages: inspected.textPages,
+      textChars: inspected.textChars,
+    });
   }
   if (!changed) return intake;
   return { ...intake, prompt: prepared };
@@ -739,8 +815,8 @@ function dropCachedAttachment(path) {
 async function persistedAttachmentReferencePaths() {
   const root = resolvePluginData();
   const paths = [];
-  for (const dirname of ['sessions', 'turn-checkpoints', 'session-pending']) {
-    const dir = join(root, dirname);
+  for (const subdir of ['sessions', 'turn-checkpoints', 'session-pending']) {
+    const dir = join(root, subdir);
     let entries;
     try {
       entries = await readdir(dir, { withFileTypes: true });
@@ -752,7 +828,7 @@ async function persistedAttachmentReferencePaths() {
       if (!entry.isFile()) continue;
       // The turn-checkpoint journal appends `<session>.jsonl` records that
       // carry attachment refs of in-flight turns.
-      if (entry.name.endsWith('.json') || (dirname === 'turn-checkpoints' && entry.name.endsWith('.jsonl'))) {
+      if (entry.name.endsWith('.json') || (subdir === 'turn-checkpoints' && entry.name.endsWith('.jsonl'))) {
         paths.push(join(dir, entry.name));
       }
     }
@@ -819,16 +895,14 @@ async function loadReferenceCache(root) {
 async function saveReferenceCache(root, files) {
   referenceCache = { root, files };
   const target = attachmentReferenceCachePath();
-  const temp = `${target}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`;
   try {
-    await mkdir(dirname(target), { recursive: true });
-    await writeFile(temp, JSON.stringify({ version: 1, files: Object.fromEntries(files) }));
-    await rename(temp, target);
-  } catch {
-    try {
-      await unlink(temp);
-    } catch {}
-  }
+    // An unusable cache only costs a full re-read (loadReferenceCache), so no fsync.
+    await writeJsonAtomicAsync(
+      target,
+      { version: 1, files: Object.fromEntries(files) },
+      { compact: true, fsync: false }
+    );
+  } catch {}
 }
 
 export async function collectPromptAttachments({ now = Date.now(), minAgeMs = ATTACHMENT_GC_MIN_AGE_MS } = {}) {
@@ -885,8 +959,10 @@ export async function collectPromptAttachments({ now = Date.now(), minAgeMs = AT
       continue;
     }
     for (const entry of entries) {
-      // A writer that died between create and rename leaves `<ref>.<pid>.<rand>.tmp`.
-      if (entry.isFile() && /^[a-f0-9]{64}\..+\.tmp$/.test(entry.name)) {
+      // A writer that died between create and rename leaves
+      // `<ref>.mixdog-tmp-<rand>` (atomic writer), or the older
+      // `.<ref>.<rand>.tmp` / `<ref>.<pid>.<rand>.tmp`.
+      if (entry.isFile() && /^(?:\.?[a-f0-9]{64}\..+\.tmp|[a-f0-9]{64}\.mixdog-tmp-[0-9a-f]+)$/.test(entry.name)) {
         const tempPath = join(dir, entry.name);
         try {
           if ((await stat(tempPath)).mtimeMs <= cutoff) await unlink(tempPath);