mixdog 1.3.4 → 1.3.5

package/src/runtime/agent/orchestrator/session/transcript-restore/restore.mjs

@@ -37,7 +37,11 @@ import {
   isTranscriptCancelledStatusText,
 } from '../../../../shared/tool-execution-contract.mjs';
 import { toolResultTerminalStatus } from '../../../../shared/tool-status.mjs';
-import { transcriptAttachmentFields, transcriptRouteMetadataFields } from '../../../../shared/transcript-metadata.mjs';
+import {
+  transcriptAttachmentFields,
+  transcriptReactionsField,
+  transcriptRouteMetadataFields,
+} from '../../../../shared/transcript-metadata.mjs';
 import { routineTriggerField } from '../../../../shared/routine-trigger.mjs';
 import { isImportedMessage } from '../imported-message.mjs';
 import { isContextAckMessage } from '../compact/user-message-kind.mjs';
@@ -91,6 +95,8 @@ function restoredTranscriptMetadata(message) {
     // The attachments this prompt carried, by content hash: a restored row
     // opens/downloads them by id from the attachment store.
     ...transcriptAttachmentFields(value),
+    // The bots' emoji reactions on a user message (message-reactions.mjs).
+    ...transcriptReactionsField(value),
     // A routine fire this turn delivered: painted as its marker row.
     ...routineTriggerField(value),
     // Skills this user turn explicitly loaded (header selection or `$name`).

package/src/runtime/channels/lib/schedule-errors.mjs

@@ -0,0 +1,51 @@
+// Structured reasons a schedule rename is refused or ends unsure. The app
+// decides on the `code` and the `name` detail (the desktop's
+// shared/schedule-error-codes.ts mirrors these codes), never on the English
+// message, which is for the model and the logs.
+
+/** Another schedule already has the name (detail: `name`, the name asked for). */
+export const SCHEDULE_NAME_TAKEN = 'SCHEDULE_NAME_TAKEN';
+/** A run of the schedule is in flight, or another rename of it (detail: `name`). */
+export const SCHEDULE_RENAME_RUNNING = 'SCHEDULE_RENAME_RUNNING';
+/** The row moved but the scheduler did not reload (detail: `name`, the new name). */
+export const SCHEDULE_RENAME_RELOAD_FAILED = 'SCHEDULE_RENAME_RELOAD_FAILED';
+/** The scheduler never answered, so the rename may or may not have applied. */
+export const SCHEDULE_RENAME_UNCERTAIN = 'SCHEDULE_RENAME_UNCERTAIN';
+
+const NAMED_CODES = new Set([SCHEDULE_NAME_TAKEN, SCHEDULE_RENAME_RUNNING, SCHEDULE_RENAME_RELOAD_FAILED]);
+const CODES = new Set([...NAMED_CODES, SCHEDULE_RENAME_UNCERTAIN]);
+
+/** The fields of `error` a reply may carry across the worker boundary: a
+ *  schedule code and, for the codes that name a schedule, that public `name`.
+ *  Any other code or detail stays on this side. */
+export function scheduleErrorFields(error) {
+  const code = error?.code;
+  if (typeof code !== 'string' || !CODES.has(code)) return {};
+  const name = error.details?.name;
+  return {
+    code,
+    ...(NAMED_CODES.has(code) && typeof name === 'string' && name ? { details: { name } } : {}),
+  };
+}
+
+const coded = (message, code, details = null) =>
+  Object.assign(new Error(message), { code }, details ? { details } : {});
+
+export const scheduleNameTakenError = (name) =>
+  coded(`A schedule named "${name}" already exists.`, SCHEDULE_NAME_TAKEN, { name });
+
+export const scheduleRenameRunningError = (name) =>
+  coded(`Schedule "${name}" is running. Rename it after the run finishes.`, SCHEDULE_RENAME_RUNNING, { name });
+
+export const scheduleRenameReloadError = (name, cause) =>
+  coded(
+    `Renamed to "${name}", but reloading the scheduler failed (${cause}); it is armed on the next reload.`,
+    SCHEDULE_RENAME_RELOAD_FAILED,
+    { name }
+  );
+
+export const scheduleRenameUncertainError = (cause) =>
+  coded(
+    `The rename may or may not have applied (the scheduler did not answer: ${cause}). Check the schedule list.`,
+    SCHEDULE_RENAME_UNCERTAIN
+  );

package/src/runtime/channels/lib/scheduler.mjs

@@ -18,6 +18,7 @@ import {
   setNextFire,
   setSkippedUntil,
 } from './schedules-db.mjs';
+import { scheduleRenameReloadError, scheduleRenameRunningError } from './schedule-errors.mjs';
 import { appendBuffered } from '../../shared/buffered-appender.mjs';
 import { tryRead } from './settings.mjs';
 
@@ -121,6 +122,8 @@ class Scheduler {
   lastFired = /* @__PURE__ */ new Map();
   // name -> "YYYY-MM-DDTHH:MM"
   running = /* @__PURE__ */ new Set();
+  // Names whose row is being renamed: no fire starts under them meanwhile.
+  renaming = /* @__PURE__ */ new Set();
   injectFn = null;
   injectReadyFn = null;
   pendingCheck = null;
@@ -415,6 +418,12 @@ ${prompt}`;
       }
       return;
     }
+    // The name is held in `running` from before the claim until the completion
+    // stamps are written, so a rename can neither complete meanwhile nor leave
+    // this fire to run under the old name. A fire refused here still claims its
+    // slot and is recorded as a skip, never run.
+    const refusal = this.fireRefusal(schedule.name);
+    if (!refusal) this.running.add(schedule.name);
     try {
       const claimed = await claimScheduleRun(schedule.name, scheduledAt, startedAt, nextFireAt);
       if (!claimed) {
@@ -425,7 +434,11 @@ ${prompt}`;
       schedule.lastStartedAt = startedAt.toISOString();
       schedule.lastFiredAt = startedAt.toISOString();
       this.lastFired.set(schedule.name, startedAt.toISOString());
-      const fired = await this.fireTimed(schedule, type, { awaitDispatch: true });
+      if (refusal) {
+        this.recordRefusal(schedule, refusal);
+        return;
+      }
+      const fired = await this.fireTimed(schedule, type, { awaitDispatch: true, reserved: true });
       // An overlap skip is recorded as a skip, never as a failed run.
       if (!fired && skippedSince(schedule, startedAt)) return;
       if (!fired) {
@@ -443,6 +456,8 @@ ${prompt}`;
       } catch {}
       process.stderr.write(`mixdog scheduler: ${schedule.name} failed: ${err}\n`);
       this.notifyFailure(schedule, `run failed: ${err?.message || err}`);
+    } finally {
+      if (!refusal) this.running.delete(schedule.name);
     }
   }
   stop() {
@@ -521,12 +536,17 @@ ${prompt}`;
     // Mark done ONLY after a successful fire. A false/throwing fireTimed
     // (missing prompt, running guard, paused owner, dispatch error) must leave the
     // one-shot pending so a reload/restart can retry it — never retire it.
+    // The name stays in `running` until the fired/done stamps are written, so
+    // a rename cannot move the row before they land (onCronFire). A refused
+    // fire is left to fireTimedPrompt, which records the skip.
+    const reserved = !this.fireRefusal(schedule.name);
+    if (reserved) this.running.add(schedule.name);
     try {
       // awaitDispatch: for a one-shot we must wait for the actual LLM/relay
       // dispatch outcome — a truthy fireTimed alone (cron's fire-and-forget
       // contract) would retire the entry even when schedulerLlm() later
       // rejects. Only a resolved dispatch counts as a real fire here.
-      const fired = await this.fireTimed(schedule, type, { awaitDispatch: true });
+      const fired = await this.fireTimed(schedule, type, { awaitDispatch: true, reserved });
       if (!fired && skippedSince(schedule, now)) {
         logSchedule(`one-shot "${schedule.name}" skipped (previous run in progress) — leaving pending for retry\n`);
         return;
@@ -542,6 +562,8 @@ ${prompt}`;
       await markOneShotFailed(schedule);
       process.stderr.write(`mixdog scheduler: ${schedule.name} one-shot failed: ${err} — leaving pending for retry\n`);
       this.notifyFailure(schedule, `one-shot failed: ${err?.message || err} — left pending for retry`);
+    } finally {
+      if (reserved) this.running.delete(schedule.name);
     }
   }
   /** when_at one-shots must honor deferred_until / skipped_until just like
@@ -577,10 +599,60 @@ ${prompt}`;
     releaseSchedulerRuntime(this);
     this.start();
   }
+  /** Run `rename` (which moves schedule `name`'s row) while no run of `name`
+   *  can start or be in flight. The check and the reservation are one
+   *  synchronous step, and a fire checks for the reservation (fireRefusal)
+   *  in the same step that adds the name to `running`, which it holds until
+   *  its completion stamps are written, so a fire either is already in
+   *  `running` (refused here) or finds the reservation (not fired). */
+  async renameLocked(name, rename, { newName = name, reload = async () => {} } = {}) {
+    if (this.running.has(name) || this.renaming.has(name)) throw scheduleRenameRunningError(name);
+    this.renaming.add(name);
+    this.renameBlocked?.delete(name);
+    try {
+      const saved = await rename();
+      if (!saved) return saved;
+      try {
+        await reload();
+      } catch (error) {
+        // The row has moved but the reload that arms the new name failed:
+        // nothing may keep running under the old one, and the call reports it.
+        this.dropSchedule(name);
+        throw scheduleRenameReloadError(newName, error?.message || error);
+      }
+      return saved;
+    } catch (error) {
+      // A one-shot whose timer a blocked fire consumed is armed again from the
+      // loaded schedules, so it fires once (after a failed rename the old
+      // entry is still loaded; after a dropped one only the others re-arm).
+      if (this.renameBlocked?.has(name) && this.tickTimer) this.restart();
+      throw error;
+    } finally {
+      this.renaming.delete(name);
+      this.renameBlocked?.delete(name);
+    }
+  }
+  /** Forget `name` entirely: its cron job, one-shot timer, stamps and loaded
+   *  entries. Used when its row moved but the reload that re-arms it failed. */
+  dropSchedule(name) {
+    try {
+      this.cronJobs.get(name)?.destroy();
+    } catch {}
+    this.cronJobs.delete(name);
+    clearTimeout(this.oneShotTimers.get(name));
+    this.oneShotTimers.delete(name);
+    this.lastFired.delete(name);
+    this.deferred.delete(name);
+    this.nonInteractive = this.nonInteractive.filter((s) => s.name !== name);
+    this.interactive = this.interactive.filter((s) => s.name !== name);
+  }
   reloadConfig(nonInteractive, interactive, options = {}) {
     this.nonInteractive = nonInteractive.filter((s) => s.enabled !== false);
     this.interactive = interactive.filter((s) => s.enabled !== false);
     this.promptsDir = join(DATA_DIR, 'prompts');
+    // A name that no longer exists must not keep (or later regain) a stamp.
+    const live = new Set([...this.nonInteractive, ...this.interactive].map((s) => s.name));
+    for (const name of this.lastFired.keys()) if (!live.has(name)) this.lastFired.delete(name);
     // Defer/skip state is persisted (deferred_until / skipped_until) and
     // re-read from the reloaded rows, so a reload no longer drops it.
     this.refreshSkipCache();
@@ -646,20 +718,42 @@ ${prompt}`;
     }
     return await this.fireTimedPrompt(schedule, type, prompt, opts);
   }
-  /** Fire a timed schedule with the given prompt content */
-  async fireTimedPrompt(schedule, type, prompt, { awaitDispatch = false } = {}) {
-    logSchedule(`firing ${schedule.name} (${type})\n`);
-    if (this.running.has(schedule.name)) {
+  /** Why a fire of `name` may not start now: 'renaming', 'running' or null. */
+  fireRefusal(name) {
+    if (this.renaming.has(name)) return 'renaming';
+    return this.running.has(name) ? 'running' : null;
+  }
+  /** Record a fire refused for `reason` (fireRefusal) as a skip. */
+  recordRefusal(schedule, reason) {
+    if (reason === 'running') {
       this.recordSkip(schedule);
+      return;
+    }
+    logSchedule(`${schedule.name}: not fired — being renamed\n`);
+    // A skip, not a failure: a one-shot stays pending (fireOneShot) and
+    // renameLocked re-arms it if the rename does not go through.
+    schedule.lastSkippedAt = new Date().toISOString();
+    // Per name: another rename settling meanwhile must not hide this one.
+    this.renameBlocked ??= new Set();
+    this.renameBlocked.add(schedule.name);
+  }
+  /** Fire a timed schedule with the given prompt content. `reserved`: the
+   *  caller already holds the name in `running` and releases it itself. */
+  async fireTimedPrompt(schedule, type, prompt, { awaitDispatch = false, reserved = false } = {}) {
+    logSchedule(`firing ${schedule.name} (${type})\n`);
+    const refusal = reserved ? null : this.fireRefusal(schedule.name);
+    if (refusal) {
+      this.recordRefusal(schedule, refusal);
       return false;
     }
     if (type === 'interactive' && this.injectIntoLead(schedule, type, prompt)) return true;
-    this.running.add(schedule.name);
+    if (!reserved) this.running.add(schedule.name);
     // Cron (recurring) keeps the fire-and-forget contract: return truthy now
     // and swallow async failures. A one-shot (awaitDispatch) instead awaits
     // the dispatch so a rejected run propagates and the caller leaves the
     // entry pending for retry instead of retiring it.
-    const dispatch = this.dispatchScheduleRun(schedule, prompt, awaitDispatch);
+    const run = this.dispatchScheduleRun(schedule, prompt, awaitDispatch);
+    const dispatch = reserved ? run : run.finally(() => this.running.delete(schedule.name));
     if (awaitDispatch) return await dispatch;
     return true;
   }
@@ -688,12 +782,14 @@ ${prompt}`;
    *  callers and resolves false (after a logged notice) for fire-and-forget
    *  cron fires. */
   dispatchScheduleRun(schedule, prompt, awaitDispatch) {
-    const run = this.scheduleRunner
-      ? this.scheduleRunner(schedule, { prompt })
-      : Promise.reject(new Error('schedule runner not configured'));
-    return run
+    // Called inside a then, so a runner that throws synchronously rejects
+    // like one that rejects, and the caller's cleanup still runs.
+    return Promise.resolve()
+      .then(() => {
+        if (!this.scheduleRunner) throw new Error('schedule runner not configured');
+        return this.scheduleRunner(schedule, { prompt });
+      })
       .then((outcome) => {
-        this.running.delete(schedule.name);
         // The run path found this schedule's previous run still going (a
         // "run now" from the app) or backing off after failures in a row; it
         // already persisted the skip.
@@ -706,7 +802,6 @@ ${prompt}`;
         return true;
       })
       .catch((err) => {
-        this.running.delete(schedule.name);
         logSchedule(`${schedule.name} LLM error: ${err.message}\n`);
         // The cron fire-and-forget contract swallowed failures entirely;
         // log them so a failed scheduled run is never

package/src/runtime/channels/lib/schedules-db.mjs

@@ -15,6 +15,7 @@ import { ensurePgInstance, withSchemaBootstrapLock } from '../../memory/lib/pg/a
 import { createPgSchemaDb } from '../../shared/pg-schema-db.mjs';
 import { resolvePluginData } from '../../shared/plugin-paths.mjs';
 import { ROUTINE_LIMITS } from '../../shared/routine-limits.mjs';
+import { scheduleNameTakenError } from './schedule-errors.mjs';
 
 const SCHEMA = 'scheduler';
 
@@ -195,6 +196,54 @@ export async function upsertSchedule(def, { dataDir } = {}) {
   return rowToDef(rows[0]);
 }
 
+/**
+ * Rename schedule `oldName` to `def.name` in one UPDATE of the primary key,
+ * applying the edited settings. Run history (last_* stamps, failure streak,
+ * undelivered results), status and the next_fire_at cursor (a deferral, or
+ * none for a finished one-shot) stay on the row. When `timingChanged`, the row
+ * is re-armed the way `upsertSchedule` re-arms a redefinition: a one-shot's
+ * cursor becomes its `when_at`, a recurring one's is cleared for the scheduler
+ * to compute. Resolves null when `oldName` is gone; an occupied `def.name`
+ * rejects and changes nothing.
+ */
+export async function renameSchedule(oldName, def, { timingChanged = false, dataDir } = {}) {
+  const db = await getDb(dataDir);
+  try {
+    const { rows } = await db.query(
+      `UPDATE scheduler.schedules SET
+         name = $2, description = $3, when_at = $4, when_cron = $5, timezone = $6, cwd = $7,
+         attachments = $8, prompt = $9, enabled = $10, owner_agent_id = $11,
+         next_fire_at = CASE WHEN $12::boolean THEN $4::timestamptz ELSE next_fire_at END,
+         status = CASE WHEN $12::boolean THEN 'active' ELSE status END,
+         deferred_until = CASE WHEN $12::boolean THEN NULL ELSE deferred_until END,
+         skipped_until = CASE WHEN $12::boolean THEN NULL ELSE skipped_until END,
+         last_fired_at = CASE WHEN $12::boolean THEN NULL ELSE last_fired_at END,
+         last_scheduled_at = CASE WHEN $12::boolean THEN NULL ELSE last_scheduled_at END,
+         updated_at = now()
+       WHERE name = $1
+       RETURNING ${COLS}`,
+      [
+        oldName,
+        def.name,
+        def.description ?? '',
+        def.whenAt ?? null,
+        def.whenCron ?? null,
+        def.timezone ?? null,
+        def.cwd ?? null,
+        def.attachments ? JSON.stringify(def.attachments) : null,
+        def.prompt,
+        def.enabled ?? true,
+        def.ownerAgentId || 'lead',
+        timingChanged === true,
+      ]
+    );
+    return rowToDef(rows[0]);
+  } catch (error) {
+    if (error?.code === '23505') throw scheduleNameTakenError(def.name);
+    throw error;
+  }
+}
+
 export async function deleteSchedule(name, { dataDir } = {}) {
   const db = await getDb(dataDir);
   const { rowCount } = await db.query(`DELETE FROM scheduler.schedules WHERE name = $1`, [name]);

package/src/runtime/channels/lib/tool-dispatch.mjs

@@ -3,6 +3,8 @@
 // is deleted with Discord/Telegram; only the automation lifecycle remains.
 // Lifecycle functions are threaded in as a bag of lazy getters so the module
 // reads the live file-level references at call time.
+import { scheduleErrorFields } from './schedule-errors.mjs';
+
 function createToolDispatch({ isChannelsDegraded, lifecycle }) {
   const {
     getChannelBridgeActive,
@@ -13,6 +15,7 @@ function createToolDispatch({ isChannelsDegraded, lifecycle }) {
     startChannelBridge,
     stopOwnedRuntime,
     reloadRuntimeConfig,
+    renameSchedule,
   } = lifecycle;
 
   async function handleToolCall(name, args, _signal) {
@@ -82,6 +85,14 @@ function createToolDispatch({ isChannelsDegraded, lifecycle }) {
           };
           break;
         }
+        // The scheduler's owner moves a schedule row only while no run of it
+        // can start or be in flight (Scheduler.renameLocked). Resolves the
+        // renamed row as JSON text; a refusal is an isError result.
+        case 'rename_schedule': {
+          const saved = await renameSchedule(args.name, args.def, { timingChanged: args.timingChanged === true });
+          result = { content: [{ type: 'text', text: JSON.stringify(saved) }] };
+          break;
+        }
         // memory — handled by memory-service.mjs MCP
         default:
           result = {
@@ -94,6 +105,8 @@ function createToolDispatch({ isChannelsDegraded, lifecycle }) {
       result = {
         content: [{ type: 'text', text: `${name} failed: ${msg}` }],
         isError: true,
+        // A schedule refusal keeps its code and public name; nothing else crosses.
+        ...scheduleErrorFields(err),
       };
     }
     return result;

package/src/runtime/channels/lib/worker-main.mjs

@@ -7,6 +7,7 @@ import { whisperThreadCount } from './voice-transcription.mjs';
 import { ensureReady, stopVoiceWhisperServer } from './whisper-server.mjs';
 import { ensurePrivateRuntimeRoot, resolveRuntimeRoot } from '../../shared/runtime-root.mjs';
 import { Scheduler } from './scheduler.mjs';
+import { renameSchedule as renameScheduleRow } from './schedules-db.mjs';
 import { hasPending as dispatchHasPending } from '../../agent/orchestrator/dispatch-persist.mjs';
 import { stripSoftWarns } from '../../agent/orchestrator/tool-loop-guard.mjs';
 import { JsonStateFile } from './state-file.mjs';
@@ -264,6 +265,14 @@ const { handleToolCall } = createToolDispatch({
     startChannelBridge: () => start({ messaging: true }),
     stopOwnedRuntime,
     reloadRuntimeConfig,
+    // Rename and re-arm under one reservation: the scheduler is reloaded from
+    // the renamed row (timers and one-shots of the old name cleared) before
+    // the name is released for fires.
+    renameSchedule: (name, def, opts) =>
+      scheduler.renameLocked(name, () => renameScheduleRow(name, def, opts), {
+        newName: def.name,
+        reload: reloadRuntimeConfig,
+      }),
   },
 });
 function ensureConfigWatcher() {

package/src/runtime/office/com/com-adapter.mjs

@@ -39,6 +39,15 @@ function spawnPowerShell(script) {
   );
 }
 
+// Resolves once the host process is gone. A signal-terminated child has exitCode null but signalCode set,
+// and its 'close' may already have been emitted, so both are checked before waiting for the event.
+export function hostExitSignal(child) {
+  return new Promise((done) => {
+    if (child.exitCode !== null || child.signalCode !== null) done();
+    else child.once('close', () => done());
+  });
+}
+
 async function callMicrosoftOfficeOnce(payload, { timeoutMs = DEFAULT_TIMEOUT_MS, signal = null } = {}) {
   return await new Promise((resolve) => {
     const child = spawnPowerShell(HOST_SCRIPT);
@@ -65,13 +74,20 @@ async function callMicrosoftOfficeOnce(payload, { timeoutMs = DEFAULT_TIMEOUT_MS
         },
       };
       void drainSessionClient(client, error).then((cleanup) => {
-        finish({
+        const result = {
           ok: false,
           cancelled,
           error: officeCleanupError(error, cleanup),
           operationMayHaveCompleted: true,
           cleanup,
+        };
+        // Settles when the host process is gone, which may be after this result when the
+        // grace period lapsed: callers that own files the host holds open wait on it.
+        // Non-enumerable so the result still serializes unchanged.
+        Object.defineProperty(result, 'hostExit', {
+          value: hostExitSignal(child),
         });
+        finish(result);
       });
     };
     const onAbort = () => beginCleanup('Microsoft Office operation was cancelled', true);

package/src/runtime/office/com/office-com-host.ps1

@@ -7545,6 +7545,52 @@ function Open-ValidationDocument($app, [string]$format, [string]$path) {
     }
 }
 
+$script:PreviewPasswordMessage = 'This file is password-protected. (OFFICE_PREVIEW_PASSWORD_PROTECTED)'
+
+# An encrypted Office Open XML package is an OLE container (D0 CF 11 E0), not a ZIP. Office would stop to ask
+# for the password, and a hidden application cannot show the question, so the request is refused up front.
+function Assert-PreviewNotEncrypted([string]$path) {
+    $extension = [System.IO.Path]::GetExtension($path).TrimStart('.').ToLowerInvariant()
+    if (@('docx', 'docm', 'dotx', 'xlsx', 'xlsm', 'pptx', 'pptm') -notcontains $extension) { return }
+    $header = New-Object byte[] 4
+    $stream = [System.IO.File]::Open($path, 'Open', 'Read', 'ReadWrite')
+    try { $read = $stream.Read($header, 0, 4) } finally { $stream.Dispose() }
+    if ($read -eq 4 -and $header[0] -eq 0xD0 -and $header[1] -eq 0xCF -and $header[2] -eq 0x11 -and $header[3] -eq 0xE0) {
+        throw $script:PreviewPasswordMessage
+    }
+}
+
+$script:PreviewWrongPasswordMessage = "That password didn't work. (OFFICE_PREVIEW_WRONG_PASSWORD)"
+
+# The read-only open of the file preview. Word and Excel get the user's password when the request carries one
+# (Documents.Open PasswordDocument, Workbooks.Open Password), else a placeholder, so a protected legacy file fails
+# at once instead of waiting on a prompt nobody can see. Word's "password is incorrect" (0x800A1520) becomes the
+# plain message: the protected one without a password, the wrong-password one with it. Presentations.Open takes no
+# password, so PowerPoint never gets one. Links are not updated, macros stay off and DisplayAlerts is off
+# (New-HiddenApplication). Automation opens do not go through Protected View.
+function Open-PreviewDocument($app, [string]$format, [string]$path, [string]$password) {
+    $placeholder = 'mixdog-preview-no-password'
+    $openPassword = if ($password) { $password } else { $placeholder }
+    try {
+        switch ($format) {
+            'docx' { return $app.Documents.Open($path, $false, $true, $false, $openPassword, $placeholder, $false, $placeholder, $placeholder) }
+            # No WriteResPassword: Excel rejects one for a workbook without write reservation (0x800A03EC), and a
+            # read-only open never asks for it.
+            'xlsx' { return $app.Workbooks.Open($path, 0, $true, [Type]::Missing, $openPassword, [Type]::Missing, $true) }
+            'pptx' { return $app.Presentations.Open($path, $true, $true, $false) }
+        }
+    }
+    catch {
+        $inner = $_.Exception
+        while ($null -ne $inner.InnerException) { $inner = $inner.InnerException }
+        if ($format -eq 'docx' -and $inner.HResult -eq 0x800A1520) {
+            if ($password) { throw $script:PreviewWrongPasswordMessage }
+            throw $script:PreviewPasswordMessage
+        }
+        throw
+    }
+}
+
 function Validate-NativeDocument([string]$path, [string]$format) {
     $validationApp = $null
     $validationDocument = $null
@@ -7757,9 +7803,13 @@ try {
         $live = $true
     }
     else {
+        if ($payload.readOnly -eq $true) { Assert-PreviewNotEncrypted $path }
         $app = New-HiddenApplication $format $progId
         $createdApp = $true
-        $document = Open-BackgroundDocument $app $format $path
+        # A read-only request (the file preview) opens the document read-only, with no link updates and no
+        # recalculation, and never waits on a password prompt. The close below discards, so nothing can be
+        # written back.
+        $document = if ($payload.readOnly -eq $true) { Open-PreviewDocument $app $format $path ([string]$payload.password) } else { Open-BackgroundDocument $app $format $path }
     }
 
     switch ([string]$payload.action) {