mixdog 1.1.0 → 1.1.2

package/src/session-runtime/resource-mcp-api.mjs

@@ -113,10 +113,14 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
     },
     async saveMcpServer(input = {}) {
       const servers = mcpServersOf(getConfig());
-      const originalName = clean(input.originalName) || clean(input.name);
-      if (originalName && !Object.hasOwn(servers, originalName)) {
-        throw new Error(`MCP server not configured: ${originalName}`);
+      // An explicit originalName must exist; a bare name edits a matching
+      // server and otherwise creates a new one.
+      const explicitOriginal = clean(input.originalName);
+      if (explicitOriginal && !Object.hasOwn(servers, explicitOriginal)) {
+        throw new Error(`MCP server not configured: ${explicitOriginal}`);
       }
+      const bareName = clean(input.name);
+      const originalName = explicitOriginal || (Object.hasOwn(servers, bareName) ? bareName : '');
       const existing = originalName ? servers[originalName] : {};
       const normalizedInput = normalizeMcpServerInput(mergedServerInput(input, existing, originalName));
       const name = originalName && clean(input.name) === originalName ? originalName : normalizedInput.name;

package/src/session-runtime/runtime-bootstrap.mjs

@@ -10,7 +10,6 @@ import {
   RUNTIME,
   WEB_SEARCH_TOOL_DEFS,
   MEMORY_TOOL_DEFS,
-  CHANNEL_TOOL_DEFS,
   CODE_GRAPH_TOOL_DEFS,
   STATUSLINE_SESSION_ROUTES,
   STANDALONE_ROOT,
@@ -49,7 +48,6 @@ export async function loadRuntimeModules() {
     statusRoutes,
     webSearchToolDefs,
     memoryToolDefs,
-    channelToolDefs,
     codeGraphToolDefs,
   ] = await Promise.all([
     profiledImport('config', `${RUNTIME}/config.mjs`),
@@ -62,7 +60,6 @@ export async function loadRuntimeModules() {
     profiledImport('status-routes', STATUSLINE_SESSION_ROUTES, { optional: true }),
     profiledImport('web-search-tool-defs', WEB_SEARCH_TOOL_DEFS, { optional: true }),
     profiledImport('memory-tool-defs', MEMORY_TOOL_DEFS, { optional: true }),
-    profiledImport('channel-tool-defs', CHANNEL_TOOL_DEFS, { optional: true }),
     profiledImport('code-graph-tool-defs', CODE_GRAPH_TOOL_DEFS, { optional: true }),
   ]);
   bootProfile('imports:ready', { ms: (performance.now() - startedAt).toFixed(1) });
@@ -88,7 +85,6 @@ export async function loadRuntimeModules() {
     statusRoutes,
     webSearchToolDefs,
     memoryToolDefs,
-    channelToolDefs,
     codeGraphToolDefs,
   };
 }

package/src/session-runtime/runtime-facade.mjs

@@ -1,3 +1,4 @@
+import { currentTurnEffort } from '../runtime/agent/orchestrator/session/turn-effort.mjs';
 import { SESSION_ID_PATTERN } from '../runtime/agent/orchestrator/runtime-core/session-id.mjs';
 import { SessionAddressError, bindSessionAddress } from './session-address.mjs';
 
@@ -79,6 +80,10 @@ export function createRuntimeFacade({
     get modelParameters() {
       return state.route.modelParameters || {};
     },
+    // The effort the runtime resolved for the turn in flight (Auto judge), or null.
+    get turnEffort() {
+      return currentTurnEffort(state.session);
+    },
     get effortOptions() {
       return state.route.effortOptions || [];
     },

package/src/session-runtime/runtime-paths.mjs

@@ -6,7 +6,6 @@ export const RUNTIME = '../runtime/agent/orchestrator';
 export const WEB_SEARCH_RUNTIME = '../runtime/web-search/index.mjs';
 export const WEB_SEARCH_TOOL_DEFS = '../runtime/web-search/tool-defs.mjs';
 export const MEMORY_TOOL_DEFS = '../runtime/memory/tool-defs.mjs';
-export const CHANNEL_TOOL_DEFS = '../runtime/channels/tool-defs.mjs';
 export const CODE_GRAPH_TOOL_DEFS = '../runtime/agent/orchestrator/tools/code-graph-tool-defs.mjs';
 export const CODE_GRAPH_RUNTIME = '../runtime/agent/orchestrator/tools/code-graph.mjs';
 export const STATUSLINE_SESSION_ROUTES = '../vendor/statusline/src/gateway/session-routes.mjs';

package/src/session-runtime/schedule-session-run.mjs

@@ -10,6 +10,7 @@ import { loadConfig } from '../runtime/agent/orchestrator/config.mjs';
 import { createSession } from '../runtime/agent/orchestrator/session/manager/session-lifecycle.mjs';
 import { askSession } from '../runtime/agent/orchestrator/session/manager/ask-session.mjs';
 import { modelRouteFields, parseScheduleModelRef } from '../runtime/shared/schedule-model-ref.mjs';
+import { migrateCodexRoute } from '../runtime/agent/orchestrator/providers/openai-oauth-catalog-store.mjs';
 import { automationWorkflowOpts } from './automation-workflow.mjs';
 import { runAutomationTurns } from './automation-agents.mjs';
 import { automationPromptContent } from '../runtime/shared/automation-attachments.mjs';
@@ -17,7 +18,8 @@ import { automationPromptContent } from '../runtime/shared/automation-attachment
 /** Resolve schedule.model into a {provider,model,effort?,fast?} route. */
 function scheduleRouteFromModelRef(modelRef, config = null) {
   const ref = parseScheduleModelRef(modelRef);
-  if (ref && typeof ref === 'object') return ref;
+  // A model the provider catalog superseded runs on its successor.
+  if (ref && typeof ref === 'object') return migrateCodexRoute(ref);
   const cfg = config || loadConfig({ secrets: false });
   const preset = cfg.presets?.find((p) => p.id === ref || p.name === ref);
   if (!preset) {

package/src/session-runtime/services/agent-tool/index-write-queue.mjs

@@ -10,6 +10,11 @@
 // the mutator: an async job replays those effects onto the fresh on-disk
 // document under the cross-process lock, so concurrent writers of other keys
 // are merged, never overwritten. Jobs run strictly one at a time in FIFO order.
+//
+// write(mutator, { rerun: true }) is the conditional-update form: the mutator
+// itself is queued and re-run against the locked fresh document, in order with
+// the recorded effects, so a field-level update re-checks its condition against
+// what is really on disk instead of replacing a whole value it once saw.
 import { updateJsonAtomic, updateJsonAtomicSync } from '../../../runtime/shared/atomic-file.mjs';
 import { registerJsonProjection } from '../../../runtime/shared/pending-json-projection.mjs';
 import { sleep } from '../../../runtime/shared/sleep.mjs';
@@ -85,21 +90,40 @@ function compactOps(batch) {
   });
 }
 
-function replayOps(ops, args) {
+function replayOps(ops, args, mergeSet) {
   args.forEach((arg, index) => {
     const op = ops[index];
     if (!op) return;
     if (arg instanceof Map) {
       for (const key of op.del) arg.delete(key);
-      for (const [key, json] of op.set) arg.set(key, JSON.parse(json));
+      for (const [key, json] of op.set) arg.set(key, mergeSet(index, arg.get(key), JSON.parse(json)));
     } else if (arg instanceof Set) {
       for (const value of op.add) arg.add(value);
     }
   });
 }
 
-function replayBatch(batch, args) {
-  replayOps(compactOps(batch), args);
+/** Entries are recorded op sets or re-run mutators; runs of op sets between
+ *  re-run mutators compact, and every entry keeps its place in the order. */
+function replayBatch(batch, args, mergeSet) {
+  let run = [];
+  const replayRun = () => {
+    if (run.length) replayOps(compactOps(run), args, mergeSet);
+    run = [];
+  };
+  for (const entry of batch) {
+    if (typeof entry !== 'function') {
+      run.push(entry);
+      continue;
+    }
+    replayRun();
+    entry(...args);
+  }
+  replayRun();
+}
+
+function reportFailure(file, what, error) {
+  process.stderr.write(`[index-write] ${file}: ${what}: ${error?.message || error}\n`);
 }
 
 /**
@@ -109,8 +133,17 @@ function replayBatch(batch, args) {
  *        builds the next document from a raw one; `mutator` receives the keyed collections
  * @param {() => any} options.readDoc      fresh raw document from disk (sync read)
  * @param {() => void} [options.onPersisted]  the file changed on disk
+ * @param {(index: number, prev: any, next: any) => any} [options.mergeSet]
+ *        value a recorded set leaves in Map argument `index`, given the locked
+ *        document's current value there; default: the recorded value
  */
-export function createIndexWriteQueue({ file, rewrite, readDoc, onPersisted = () => {} }) {
+export function createIndexWriteQueue({
+  file,
+  rewrite,
+  readDoc,
+  onPersisted = () => {},
+  mergeSet = (_index, _prev, next) => next,
+}) {
   let projection = null; // raw document including unpersisted ops, else null
   const self = { flush, flushSync: () => flushSync() };
   if (file) registerJsonProjection(file, () => projection);
@@ -134,10 +167,15 @@ export function createIndexWriteQueue({ file, rewrite, readDoc, onPersisted = ()
   async function persist(batch) {
     for (let attempt = 0; ; attempt += 1) {
       try {
-        await updateJsonAtomic(file, (cur) => rewrite(cur, (...args) => replayBatch(batch, args)), { lock: true });
+        await updateJsonAtomic(file, (cur) => rewrite(cur, (...args) => replayBatch(batch, args, mergeSet)), {
+          lock: true,
+        });
         return;
-      } catch {
-        if (attempt >= RETRY_DELAYS_MS.length) return; // dropped, like the sync writer's swallowed failure
+      } catch (error) {
+        if (attempt >= RETRY_DELAYS_MS.length) {
+          reportFailure(file, `dropped ${batch.length} unpersisted write(s)`, error);
+          return;
+        }
         await sleep(RETRY_DELAYS_MS[attempt]);
       }
     }
@@ -181,11 +219,12 @@ export function createIndexWriteQueue({ file, rewrite, readDoc, onPersisted = ()
     clearTimer();
     pending = [];
     try {
-      updateJsonAtomicSync(file, (cur) => rewrite(cur, (...args) => replayBatch(ops, args)), {
+      updateJsonAtomicSync(file, (cur) => rewrite(cur, (...args) => replayBatch(ops, args, mergeSet)), {
         lock: true,
         timeoutMs: EXIT_LOCK_TIMEOUT_MS,
       });
-    } catch {
+    } catch (error) {
+      reportFailure(file, `synchronous flush of ${ops.length} write(s) failed; kept queued`, error);
       pending = ops;
       return false;
     }
@@ -197,18 +236,20 @@ export function createIndexWriteQueue({ file, rewrite, readDoc, onPersisted = ()
   }
 
   return {
-    /** Run `mutator` now against the projection; persist its effect later.
+    /** Run `mutator` now against the projection; persist its effect later
+     *  (`rerun`: persist by re-running it on the locked document instead).
      *  Returns the projected document, or null (no file / mutator threw). */
-    write(mutator) {
+    write(mutator, { rerun = false } = {}) {
       if (!file || typeof mutator !== 'function') return null;
       try {
         let ops = null;
         const next = rewrite(projection ?? readDoc(), (...args) => {
-          ops = recordOps(args, () => mutator(...args));
+          if (rerun) mutator(...args);
+          else ops = recordOps(args, () => mutator(...args));
         });
         projection = next;
         version += 1;
-        pending.push(ops);
+        pending.push(rerun ? mutator : ops);
         unsettled.add(self);
         schedule();
         return next;

package/src/session-runtime/services/agent-tool/job-views/agent-list.mjs

@@ -19,12 +19,15 @@ export function isActiveWorkerRow(row = {}) {
   return !isTerminalWorkerStatus(effective);
 }
 
-function agentRow({ tag, session, runtime, progress, now }) {
+function agentRow({ tag, session, runtime, progress, now, indexRow = null }) {
   const status = session.closed === true ? 'closed' : session.status || 'idle';
   const stage =
     session.stage ||
     (status === 'idle' || status === 'error' || status === 'closed' ? status : runtime?.stage || status);
-  return {
+  // Additive: the current turn's start (worker index, stamped at dispatch) so
+  // surfaces time a continued worker from its turn, not from createdAt.
+  const turnStartedAt = indexRow?.turnStartedAt || session.turnStartedAt || null;
+  const row = {
     tag,
     sessionId: session.id,
     agent: session.agent || null,
@@ -33,8 +36,14 @@ function agentRow({ tag, session, runtime, progress, now }) {
     preset: session.presetName || null,
     effort: session.effort || null,
     fast: session.fast === true,
+    // Additive: route model parameters (e.g. Daybreak Blue) when the route has any.
+    ...(session.modelParameters && Object.keys(session.modelParameters).length
+      ? { modelParameters: { ...session.modelParameters } }
+      : {}),
     status,
     stage,
+    // Additive: present only while the worker's turn waits on a user approval.
+    ...(runtime?.awaitingUser ? { awaitingUser: runtime.awaitingUser } : {}),
     ...progress,
     createdAt: session.createdAt || null,
     updatedAt: session.updatedAt || null,
@@ -51,16 +60,19 @@ function agentRow({ tag, session, runtime, progress, now }) {
       : Math.max(0, Number(session.messageCount || 0)),
     tools: Array.isArray(session.tools) ? session.tools.length : Math.max(0, Number(session.toolCount || 0)),
   };
+  if (turnStartedAt && isActiveWorkerRow(row)) row.turnStartedAt = turnStartedAt;
+  return row;
 }
 
 export function createAgentList({ mgr, refreshTagsFromSessions, agentSessionEntries, progress }) {
   return function list({ scanSessions = false, context = {}, includeTerminal = false } = {}) {
     refreshTagsFromSessions({ scanSessions, context });
     const now = Date.now();
-    const rows = agentSessionEntries({ scanSessions, context }).map(({ tag, session }) =>
+    const rows = agentSessionEntries({ scanSessions, context }).map(({ tag, session, indexRow }) =>
       agentRow({
         tag,
         session,
+        indexRow,
         runtime: mgr.getSessionRuntime?.(session.id),
         progress: progress.sessionProgressExtras(session.id, session.agent || null, now),
         now,

package/src/session-runtime/services/agent-tool/job-views/session-progress.mjs

@@ -91,6 +91,8 @@ export function createSessionProgress({ mgr }) {
     return {
       workerStatus: status,
       stage: progress.worker_stage || runtime?.stage || status,
+      // Additive: present only while the worker's turn waits on a user approval.
+      ...(runtime?.awaitingUser ? { awaitingUser: runtime.awaitingUser } : {}),
       clientHostPid: session.clientHostPid || null,
       lastStreamDeltaAt: runtime?.lastStreamDeltaAt ? new Date(runtime.lastStreamDeltaAt).toISOString() : null,
       ...progress,

package/src/session-runtime/services/agent-tool/worker-index/approval-wait.mjs

@@ -0,0 +1,97 @@
+// worker-index/approval-wait.mjs
+// Persists a worker's approval wait (runtime begin/end transitions) into the
+// worker index, so processes that read only the stored index — the desktop
+// Agents pane — see it. One process can hold several worker-index instances
+// over the same file (every runtime's agent tool in the daemon); they share one
+// row store per file, and exactly one writer per file answers each transition,
+// so a wait costs one index write on begin and one on end.
+//
+// `awaitingUser` is a field of its own on the row: only conditional field
+// updates (applyAwaitingUser, re-run on the locked document) set or clear it,
+// fenced by session id and turn. Whole-row writes keep whatever the current
+// row holds and drop it once the row settles (settleAwaitingUser).
+import {
+  currentSessionApprovalWaits,
+  onSessionApprovalWaitChange,
+} from '../../../../runtime/shared/session-approval-wait.mjs';
+import { stampMs } from '../helpers.mjs';
+import { isTerminalWorkerStatus } from '../worker-rows.mjs';
+
+const writersByFile = new Map(); // file -> writer functions, first answers
+let unsubscribe = null;
+
+function withAwaitingUser(row, value) {
+  if (value ? row.awaitingUser === value : !('awaitingUser' in row)) return row;
+  const { awaitingUser: _prior, ...rest } = row;
+  return value ? { ...rest, awaitingUser: value } : rest;
+}
+
+/** `row` as a whole-row write may leave it: the flag `current` (the value the
+ *  row holds before the write) survives unless the row settled. Returns `row`
+ *  itself when nothing changes. */
+export function settleAwaitingUser(row, current) {
+  return withAwaitingUser(row, current === 'approval' && !isTerminalWorkerStatus(row.status) ? 'approval' : null);
+}
+
+/** The flag `fence` wants on `row`, or undefined when the update is not for
+ *  it: another session, or a turn that started after the transition's turn. */
+function fencedAwaitingUser(row, { sessionId, awaitingUser, turnAt }) {
+  if (row.sessionId !== sessionId) return undefined;
+  if (turnAt > 0 && stampMs(row.turnStartedAt) > turnAt) return undefined;
+  return awaitingUser === 'approval' && !isTerminalWorkerStatus(row.status) ? 'approval' : null;
+}
+
+/** Whether applyAwaitingUser(fence) would change any of `rows`. */
+export function awaitingUserWouldChange(rows, fence) {
+  return rows.some((row) => {
+    const wanted = fencedAwaitingUser(row, fence);
+    return wanted !== undefined && withAwaitingUser(row, wanted) !== row;
+  });
+}
+
+/** Field update: only `awaitingUser` of the fenced rows, nothing else. */
+export function applyAwaitingUser(byKey, fence) {
+  for (const [key, row] of byKey) {
+    const wanted = fencedAwaitingUser(row, fence);
+    if (wanted === undefined) continue;
+    const next = withAwaitingUser(row, wanted);
+    if (next !== row) byKey.set(key, next);
+  }
+}
+
+/** Field update: drop every flag `isStale(row)` holds for. */
+export function clearAwaitingUser(byKey, isStale) {
+  for (const [key, row] of byKey) {
+    if (row.awaitingUser && isStale(row)) byKey.set(key, withAwaitingUser(row, null));
+  }
+}
+
+function persistTransition(sessionId, awaitingUser, meta) {
+  for (const writers of writersByFile.values()) writers[0]?.(sessionId, awaitingUser, meta);
+}
+
+/** Register `writer(sessionId, awaitingUser, { turnAt })` for `file`; returns
+ *  the release. The first writer of a file also receives the waits already
+ *  open, so a wait that began before any index existed is not lost. */
+export function registerApprovalWaitWriter(file, writer) {
+  if (!file || typeof writer !== 'function') return () => {};
+  const writers = writersByFile.get(file) || [];
+  writers.push(writer);
+  writersByFile.set(file, writers);
+  unsubscribe ??= onSessionApprovalWaitChange(persistTransition);
+  if (writers.length === 1) {
+    for (const { sessionId, ...meta } of currentSessionApprovalWaits()) writer(sessionId, 'approval', meta);
+  }
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    const remaining = (writersByFile.get(file) || []).filter((entry) => entry !== writer);
+    if (remaining.length) writersByFile.set(file, remaining);
+    else writersByFile.delete(file);
+    if (writersByFile.size === 0 && unsubscribe) {
+      unsubscribe();
+      unsubscribe = null;
+    }
+  };
+}

package/src/session-runtime/services/agent-tool/worker-index/mutation-batch.mjs

@@ -1,7 +1,8 @@
 // worker-index/mutation-batch.mjs
 // Spawn-path writes are batched onto one immediate so a parallel fanout pays a
-// single locked rewrite instead of one per worker.
-export function createMutationBatch(write) {
+// single locked rewrite instead of one per worker. `afterFlush` runs once the
+// batch's rows are in the store.
+export function createMutationBatch(write, afterFlush = () => {}) {
   const pending = [];
   let timer = null;
 
@@ -21,6 +22,7 @@ export function createMutationBatch(write) {
         }
       }
     });
+    afterFlush();
   }
 
   function queue(mutator) {

package/src/session-runtime/services/agent-tool/worker-index/row-liveness.mjs

@@ -14,6 +14,10 @@ const WORKER_POOL_FRESH_MS = 2 * 60 * 1000;
 export const isActiveWorkerRow = (row) =>
   ACTIVE_WORKER_STATUS.test(clean(row?.status)) || ACTIVE_WORKER_STATUS.test(clean(row?.stage));
 
+/** A persisted approval wait whose runtime is gone: the in-memory wait died
+ *  with that process (daemon restart), so the flag must not stick. */
+export const isStaleApprovalWait = (row) => Boolean(row?.awaitingUser) && !runtimeAlive(row.runtimePid);
+
 export function createRowLiveness({ dataDir, cfgMod }) {
   function heartbeatFresh(sessionId, now) {
     const id = clean(sessionId);
@@ -47,11 +51,13 @@ export function createRowLiveness({ dataDir, cfgMod }) {
   }
 
   /** The row settled to idle. `touch` restamps it as finished now (this
-   *  process is giving up its own work); otherwise existing stamps win. */
+   *  process is giving up its own work); otherwise existing stamps win. An
+   *  idle worker waits on nobody, so a persisted approval wait drops too. */
   function idleRow(row, now, touch = false) {
     const stamp = new Date(now).toISOString();
+    const { awaitingUser: _awaitingUser, ...settled } = row;
     return {
-      ...row,
+      ...settled,
       status: 'idle',
       stage: 'idle',
       turnStartedAt: null,

package/src/session-runtime/services/agent-tool/worker-index/row-shape.mjs

@@ -55,6 +55,9 @@ export function normalizeWorkerRows(value) {
       toolPermission: clean(row.toolPermission) || null,
       messages: positiveInt(row.messages) || 0,
       tools: positiveInt(row.tools) || 0,
+      // Additive and transient: present only while the worker's turn waits on
+      // a user approval (worker-index setAwaitingUser).
+      ...(row.awaitingUser === 'approval' ? { awaitingUser: 'approval' } : {}),
     }))
     .filter((row) => !isLeadPoolAgent(row.agent) && keepWorkerRow(row));
 }

package/src/session-runtime/services/agent-tool/worker-index/row-store.mjs

@@ -1,12 +1,36 @@
 // worker-index/row-store.mjs
 // The on-disk worker index file: an mtime-keyed parse cache in front of it and
-// the single in-process writer queue that republishes rows + tombstones.
+// the single in-process writer queue that republishes rows + tombstones. Every
+// worker index of a process over one file shares one store (acquireWorkerRowStore),
+// so all of them serialize through the same projection and queue.
 import { readFileSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
 
 import { createIndexWriteQueue } from '../index-write-queue.mjs';
 import { normalizeTagTombstones, tagTombstoneKey, workerRowKey } from '../worker-rows.mjs';
+import { settleAwaitingUser } from './approval-wait.mjs';
 import { keepWorkerRow, normalizeWorkerRows } from './row-shape.mjs';
 
+const ROWS_ARG = 0; // the rows Map's position in the rewrite mutator's arguments
+const sharedStores = new Map(); // canonical file -> { store, refs }
+
+const canonicalFile = (file) => (process.platform === 'win32' ? resolve(file).toLowerCase() : resolve(file));
+
+/** A whole-row write never decides `awaitingUser`: every row it changed keeps
+ *  the flag the row held before (never a stale copy's), dropped once settled. */
+function keepingAwaitingUser(mutator) {
+  return (byKey, ...rest) => {
+    const before = new Map(byKey);
+    mutator(byKey, ...rest);
+    for (const [key, row] of byKey) {
+      const prior = before.get(key);
+      if (row === prior) continue;
+      const settled = settleAwaitingUser(row, prior?.awaitingUser);
+      if (settled !== row) byKey.set(key, settled);
+    }
+  };
+}
+
 /** One rewrite: the current document as keyed maps, the caller's mutator over
  *  them, then the v2 document to publish. */
 function rewriteIndexDocument(cur, mutator) {
@@ -61,6 +85,9 @@ export function createWorkerRowStore(file) {
     onPersisted: () => {
       dirty = true;
     },
+    // The same rule against the locked document: a replayed row keeps the
+    // flag that is on disk now, not the one the projection held.
+    mergeSet: (index, prev, next) => (index === ROWS_ARG ? settleAwaitingUser(next, prev?.awaitingUser) : next),
   });
 
   function projectedView() {
@@ -115,13 +142,17 @@ export function createWorkerRowStore(file) {
   // Single writer path: the mutator runs now over keyed maps against the
   // in-process projection (see index-write-queue.mjs); its effect is
   // republished as rows + tombstones by one async locked writer.
-  const write = (mutator) => queue.write(mutator);
+  const write = (mutator) => queue.write(typeof mutator === 'function' ? keepingAwaitingUser(mutator) : mutator);
 
   return {
     readAll,
     readSnapshot,
     readTombstones,
     write,
+    /** Conditional field update: `mutator` runs now on the projection and again
+     *  on the locked document when persisted, so its condition is re-checked
+     *  against what is on disk. The one writer of `awaitingUser`. */
+    update: (mutator) => queue.write(mutator, { rerun: true }),
     /** Resolves once every write so far is on disk. */
     flush: queue.flush,
     /** Exit path: persist what is still queued, synchronously. */
@@ -131,3 +162,28 @@ export function createWorkerRowStore(file) {
     },
   };
 }
+
+/** The process's one store for `file` (a fresh no-op store for null), and its
+ *  idempotent release; the store is dropped once its last holder releases. */
+export function acquireWorkerRowStore(file) {
+  if (!file) return { store: createWorkerRowStore(null), release: () => {} };
+  const key = canonicalFile(file);
+  let entry = sharedStores.get(key);
+  if (!entry) {
+    entry = { store: createWorkerRowStore(file), refs: 0 };
+    sharedStores.set(key, entry);
+  }
+  entry.refs += 1;
+  // A new holder re-reads the file, as a store of its own would.
+  entry.store.invalidate();
+  let released = false;
+  return {
+    store: entry.store,
+    release: () => {
+      if (released) return;
+      released = true;
+      entry.refs -= 1;
+      if (entry.refs === 0 && sharedStores.get(key) === entry) sharedStores.delete(key);
+    },
+  };
+}