mixdog 1.3.5 → 1.4.1

package/src/runtime/agent/orchestrator/session/side-question.mjs

@@ -98,6 +98,24 @@ function nextMainRequest(sessionId) {
   });
 }
 
+/**
+ * The session's last provider request as its next turn would rebuild it from
+ * the record (a runtime restart lost the in-memory one): the next request
+ * without the reply that last request produced, stamped with the session's
+ * last send time. Null when the transcript does not end in that reply or the
+ * session has no rebuildable request (nextMainRequest).
+ */
+export function lastSentMainRequest(sessionId) {
+  const request = nextMainRequest(sessionId);
+  if (!request) return null;
+  let end = request.messages.length;
+  while (end > 0 && request.messages[end - 1]?.role === 'assistant') end -= 1;
+  if (end === 0 || end === request.messages.length) return null;
+  const sentAt = Number(request.opts.session?.lastProviderSendAt);
+  if (!(sentAt > 0)) return null;
+  return { ...request, messages: request.messages.slice(0, end), sentAt };
+}
+
 function answerText(response) {
   if (response?.toolCalls?.length) return SIDE_QUESTION_TOOL_ATTEMPT;
   const text = typeof response?.content === 'string' ? response.content.trim() : '';

package/src/runtime/agent/orchestrator/session/skill-update-notice.mjs

@@ -0,0 +1,60 @@
+// A thread can live for days while its loaded skills change underneath it (an
+// app update ships a new SKILL.md, the user edits or switches one off). Compact
+// restores every skill from its current source; between Compacts, each turn
+// tells the model once that a skill it holds instructions for changed, as a
+// new runtime message after the history, never by rewriting what was sent.
+import { createHash } from 'node:crypto';
+import { loadConfig } from '../config.mjs';
+import { collectSkillsCached, currentSkillDelivery } from '../context/collect.mjs';
+import { latestSkillBodies, skillMessageText } from '../context/skill-state.mjs';
+
+export const SKILL_UPDATE_SOURCE = 'skill-update-notice';
+
+const UNAVAILABLE = 'unavailable';
+// The loaded body is what the Skill tool delivers again (after an
+// unavailable notice): its instructions are back in force.
+const CURRENT = 'current';
+
+function skillUpdateNotice(name, version) {
+  let text = `[mixdog-runtime] Skill "${name}" was updated since it was loaded. Reload it with the Skill tool before relying on it.`;
+  if (version === UNAVAILABLE) {
+    text = `[mixdog-runtime] Skill "${name}" is no longer available in this session (switched off, removed, or outside this project's scope). Do not rely on its instructions.`;
+  } else if (version === CURRENT) {
+    text = `[mixdog-runtime] Skill "${name}" is available again, unchanged; its loaded instructions apply again.`;
+  }
+  return { role: 'user', content: text, meta: { source: SKILL_UPDATE_SOURCE, synthetic: true, skill: name, version } };
+}
+
+/**
+ * For every skill whose latest body is in `messages`, compare it with what the
+ * Skill tool would deliver at `cwd` now. Its state — the loaded body still
+ * current, a changed version, or unavailable — is announced whenever it
+ * differs from the last state told after that body (none told: current).
+ * So each transition notifies once: changed, switched off, and back again
+ * unchanged. A reload replaces the body and starts over. Returns the
+ * appended notices.
+ */
+export function appendSkillUpdateNotices(messages, cwd) {
+  const bodies = latestSkillBodies(messages);
+  if (!bodies.length) return [];
+  const config = loadConfig({ secrets: false });
+  const skills = collectSkillsCached(cwd);
+  const notices = [];
+  for (const { name, message } of bodies) {
+    const delivery = currentSkillDelivery(name, cwd, config, skills);
+    let version = UNAVAILABLE;
+    if (delivery) {
+      version =
+        skillMessageText(message.content).trimStart() === delivery.body
+          ? CURRENT
+          : createHash('sha256').update(delivery.body).digest('hex').slice(0, 16);
+    }
+    const told =
+      messages
+        .slice(messages.lastIndexOf(message) + 1)
+        .findLast((m) => m?.meta?.source === SKILL_UPDATE_SOURCE && m.meta.skill === name)?.meta.version || CURRENT;
+    if (told !== version) notices.push(skillUpdateNotice(name, version));
+  }
+  messages.push(...notices);
+  return notices;
+}

package/src/runtime/agent/orchestrator/session/store/live-state.mjs

@@ -1,4 +1,5 @@
 import { contentCarriesLiveMedia } from '../../providers/media-normalization.mjs';
+import { publishSessionPersistence } from './session-persistence-events.mjs';
 
 const _lastSaveError = new Map(); // id -> { message, at }
 
@@ -287,9 +288,11 @@ export function _recordSaveDrop(id, epoch = null) {
 export function _clearSaveStateIfCurrent(id, epoch = null) {
   if (!id) return false;
   const marked = _failureEpochs.get(id);
-  if (marked !== undefined && Number.isFinite(epoch) && epoch < marked) return false;
-  _clearSessionSaveState(id);
-  return true;
+  const cleared = !(marked !== undefined && Number.isFinite(epoch) && epoch < marked);
+  if (cleared) _clearSessionSaveState(id);
+  // A landed write put the record on disk whether or not it clears the markers.
+  publishSessionPersistence(id, 'landed');
+  return cleared;
 }
 
 /** True while this process's last save attempt for `id` failed. */

package/src/runtime/agent/orchestrator/session/store/save-delta.mjs

@@ -1,5 +1,6 @@
 import { hash } from 'node:crypto';
 import { _messagesForDisk, _sessionForDisk } from './serialize.mjs';
+import { sensitiveValuesVersion } from '../sensitive-values.mjs';
 
 // ── Delta handoff to the save worker ─────────────────────────────────────────
 // Worker.postMessage structured-clones on the CALLER's thread, so a full-
@@ -93,7 +94,7 @@ function _attemptRecord(header, refs, prints) {
  */
 export function _attemptEvidence(attempt) {
   if (!attempt) return null;
-  const messages = _messagesForDisk(attempt.refs);
+  const messages = _messagesForDisk(attempt.refs, attempt.header.id);
   for (let index = 0; index < messages.length; index += 1) {
     const print = attempt.prints[index];
     if (print === null || _messagePrint(messages[index]) !== print) return null;
@@ -112,14 +113,17 @@ function _isPureAppend(refs, live) {
 export function _buildWirePayload(id, session, forceFull = false) {
   const live = Array.isArray(session.messages) ? session.messages : [];
   const base = forceFull ? null : _deltaBaseline.get(id);
-  const resyncDue = !base || base.deltasSinceFull >= DELTA_FULL_RESYNC_EVERY;
+  // A value marked sensitive since the baseline was sent must leave the
+  // messages the worker already holds too: write the whole transcript again.
+  const sensitive = sensitiveValuesVersion(id);
+  const resyncDue = !base || base.deltasSinceFull >= DELTA_FULL_RESYNC_EVERY || base.sensitive !== sensitive;
   if (!resyncDue && _isPureAppend(base.refs, live)) {
     // Header: full disk projection with an empty message list (strips
     // transient aliases); tail: per-message projection of the appended
     // suffix only. Both use the same idempotent per-message projection
     // as a full send, so worker-side reconstruction is byte-identical.
     const header = _sessionForDisk({ ...session, messages: [] });
-    const tailMessages = _messagesForDisk(live.slice(base.refs.length));
+    const tailMessages = _messagesForDisk(live.slice(base.refs.length), id);
     // The EXACT payload the worker will reconstruct and write is the sent
     // baseline + this delta. Its evidence is fingerprint-checked against
     // what was sent, never a fresh projection of the mutable live session
@@ -127,7 +131,7 @@ export function _buildWirePayload(id, session, forceFull = false) {
     // reference-identity delta). Only the tail is fingerprinted.
     const prints = base.prints ? base.prints.concat(tailMessages.map(_messagePrint)) : null;
     const refs = live.slice();
-    _deltaBaseline.set(id, { refs, deltasSinceFull: base.deltasSinceFull + 1, prints });
+    _deltaBaseline.set(id, { refs, deltasSinceFull: base.deltasSinceFull + 1, prints, sensitive });
     return {
       delta: { baseCount: base.refs.length, header, tailMessages },
       attempt: _attemptRecord(header, refs, prints),
@@ -142,7 +146,7 @@ export function _buildWirePayload(id, session, forceFull = false) {
   // DELTA_FULL_RESYNC_EVERY saves.
   const refs = live.slice();
   const prints = _printMessages(live, diskMessages, resyncDue ? null : base);
-  _deltaBaseline.set(id, { refs, deltasSinceFull: 0, prints });
+  _deltaBaseline.set(id, { refs, deltasSinceFull: 0, prints, sensitive });
   // (saveSessionAsync normalizes `messages` to an array before any post.)
   return { session: full, attempt: _attemptRecord(full, refs, prints) };
 }

package/src/runtime/agent/orchestrator/session/store/serialize.mjs

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { renameWithRetrySync } from '../../../../shared/atomic-file.mjs';
 import { sanitizeContentForStoredHistory } from '../../providers/media-normalization.mjs';
 import { readTopLevelLifecycleRecord, isLifecycleUnreadable } from '../lifecycle-scan.mjs';
+import { redactSensitiveMessage } from '../sensitive-projection.mjs';
 
 // Inline base64 images (tool screenshots included) are written as
 // content-addressed refs, like prompt media, so session JSON stays small while
@@ -13,17 +14,17 @@ import { readTopLevelLifecycleRecord, isLifecycleUnreadable } from '../lifecycle
 // Per-message disk projection shared by _sessionForDisk and the save-worker
 // delta path (tail-only projection). Returns the SAME array reference when no
 // message changed. Idempotent: already-sanitized content passes through
-// unchanged, so projecting a projected message is a no-op.
-export function _messagesForDisk(messages) {
+// unchanged, so projecting a projected message is a no-op. A value session
+// `sessionId` marked sensitive (sensitive-values.mjs) is stored as a marker in
+// the message's text (sensitive-projection.mjs).
+export function _messagesForDisk(messages, sessionId) {
   let changed = false;
   const out = messages.map((m) => {
     if (!m || typeof m !== 'object') return m;
     const content = sanitizeContentForStoredHistory(m.content);
-    if (content !== m.content) {
-      changed = true;
-      return { ...m, content };
-    }
-    return m;
+    const projected = redactSensitiveMessage(sessionId, content === m.content ? m : { ...m, content });
+    if (projected !== m) changed = true;
+    return projected;
   });
   return changed ? out : messages;
 }
@@ -46,7 +47,7 @@ export function _sessionForDisk(session) {
       Object.hasOwn(session, 'toolApprovalHook') ||
       Object.hasOwn(session, '_providerPrefixGuardState'));
   const messages = Array.isArray(session?.messages) ? session.messages : null;
-  const out = messages?.length ? _messagesForDisk(messages) : messages;
+  const out = messages?.length ? _messagesForDisk(messages, session.id) : messages;
   if (out === messages) {
     if (!hasTransient) return session;
     return _withMidTurnContextAnchor(_withoutTransientFields(session), session);

package/src/runtime/agent/orchestrator/session/store/session-delete.mjs

@@ -36,6 +36,7 @@ import { _savePending, _clearDebounce, _releasePendingSlot } from './pending-sav
 import { _runtimeLivenessVeto } from './liveness-veto.mjs';
 import { _runSessionPurgeHooks } from './session-observers.mjs';
 import { deleteCompactionArchive } from '../compaction-archive.mjs';
+import { removeSessionScratchDir } from '../../../../shared/session-scratch.mjs';
 
 /** Child-agent session ids linked to one visible parent. Candidates come from
  * metadata only (the summary rows and the agent-worker links — no folder
@@ -154,6 +155,12 @@ export function deleteSession(id, options = {}) {
     _runSessionPurgeHooks(id, { cwds: knownSessionCwds(id) });
     // The display-only compaction archive has no meaning without its session.
     deleteCompactionArchive(getStoreDir(), id);
+    // The session's scratch directory (shell TEMP/TMP/TMPDIR) goes with it.
+    try {
+      removeSessionScratchDir(id);
+    } catch {
+      /* a locked scratch file never fails the delete */
+    }
     _clearLiveSession(id);
     // The file is gone: every marker of the retired incarnation goes with it
     // (save error + failed-snapshot evidence, split-brain drop flag, lifecycle

package/src/runtime/agent/orchestrator/session/store/session-persistence-events.mjs

@@ -0,0 +1,29 @@
+/**
+ * Read-only notifications about a session's persistence lifecycle, for owners
+ * of derived sidecars (the compaction archive) that must wait for the session
+ * record instead of polling for it. A pure registry: it persists nothing and
+ * imports no write path.
+ *
+ *   'landed' — a save of the session reached disk (its record exists);
+ *   'closed' — the session was closed (no further save is to be expected).
+ *
+ * A hard delete is announced through the existing purge hooks
+ * (session-observers.mjs registerSessionPurgeHook).
+ */
+const listeners = new Set();
+
+export function subscribeSessionPersistence(listener) {
+  if (typeof listener !== 'function') return () => {};
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+export function publishSessionPersistence(id, event) {
+  for (const listener of [...listeners]) {
+    try {
+      listener(id, event);
+    } catch {
+      /* observers never affect persistence */
+    }
+  }
+}

package/src/runtime/agent/orchestrator/session/store-agent-worker-rows.mjs

@@ -161,12 +161,12 @@ function cancelState(source) {
 function effectiveCancel(row, session) {
   const rowCancel = cancelState(row);
   const sessionCancel = cancelState(session);
-  const cancel =
-    rowCancel && sessionCancel && CANCEL_UNCONFIRMED_AGENT_STATUS.test(sessionCancel.status)
-      ? CANCEL_UNCONFIRMED_AGENT_STATUS.test(rowCancel.status)
-        ? rowCancel
-        : sessionCancel
-      : rowCancel || sessionCancel;
+  let cancel;
+  if (rowCancel && sessionCancel && CANCEL_UNCONFIRMED_AGENT_STATUS.test(sessionCancel.status)) {
+    cancel = CANCEL_UNCONFIRMED_AGENT_STATUS.test(rowCancel.status) ? rowCancel : sessionCancel;
+  } else {
+    cancel = rowCancel || sessionCancel;
+  }
   if (!cancel) return null;
   const newerWork = cancel.at > 0 && Math.max(workStampMs(row), workStampMs(session)) > cancel.at;
   return newerWork ? null : cancel;
@@ -633,6 +633,8 @@ function projectChildWorkerRow(row, context) {
     // A live turn blocked on the user's approval (persisted by the agent
     // tool's worker index); never carried by a row that is no longer working.
     ...(working && row.awaitingUser === 'approval' ? { awaitingUser: 'approval' } : {}),
+    // The owner closed this agent (status unchanged); reused work clears it.
+    ...(!working && row.released === true ? { released: true } : {}),
     // Why a settled failed row failed; a row working again has no failure.
     ...(!working && failedAgentWorker(row) && cleanValue(row.failureReason)
       ? { failureReason: cleanValue(row.failureReason) }

package/src/runtime/agent/orchestrator/session/store-summary-catalog.mjs

@@ -30,6 +30,7 @@ import {
   inheritedFromSessionId,
   isStoredSessionId,
   positiveNumber,
+  compactCountField,
   realTurnCount,
   workspaceSummary,
 } from './store-summary-fields.mjs';
@@ -131,8 +132,9 @@ export function isLeadVisibleRow(row) {
   if (!agentSession && !isRootLeadSession(row) && owner && !LEAD_OWNERS.has(owner)) return false;
   // Mirror listLeadSessions: a previewless zero-message row is an unusable
   // scratch (desktop boot leftovers, crashed first turns) — resuming it
-  // shows an empty conversation, so the catalog hides it.
-  if (!row.preview && row.messageCount === 0) return false;
+  // shows an empty conversation, so the catalog hides it. A titled one is a
+  // real conversation whose prompts were rewound away: it stays listed.
+  if (!row.preview && row.messageCount === 0 && !row.title) return false;
   const sourceType = String(row.sourceType || '')
     .trim()
     .toLowerCase();
@@ -215,6 +217,9 @@ export function normalizedRow(row) {
     // Absent from a row read off a session file: its assistant text is not
     // decoded there, so the unread count falls back until the next save.
     ...(Array.isArray(row.incomingTail) ? { incomingTail: normalizedIncomingTail(row.incomingTail) } : {}),
+    // Absent from a row read off a session file (its compaction record is not
+    // decoded there) until the next save.
+    ...compactCountField(row),
     realTurnCount: realTurnCount(row),
     title: cleanText(row.title, 100),
     preview: cleanText(row.preview),
@@ -282,6 +287,15 @@ function rowFromSession(session) {
   });
 }
 
+/** The catalog row of one session read off `<directory>/<sessionId>.json` by
+ *  id — the same strict, stamp-cached derivation a listing uses — or null
+ *  when it is absent, unreadable, foreign or not one the catalog lists. */
+export function storedSessionCatalogRow(directory, sessionId) {
+  if (!isStoredSessionId(sessionId)) return null;
+  const entry = reconcileSessionFile(directory, sessionId, null, false);
+  return entry?.kind === 'row' && isLeadVisibleRow(entry.row) ? entry.row : null;
+}
+
 // ── Session file reconcile ──────────────────────────────────────────────────
 // What one `sessions/<id>.json` name contributes to the catalog, with the full
 // stamp { dev, ino, size, mtimeNs, ctimeNs } it was judged at (and the

package/src/runtime/agent/orchestrator/session/store-summary-fields.mjs

@@ -63,6 +63,21 @@ export function realTurnCount(value) {
   return typeof count === 'number' && Number.isFinite(count) && count >= 0 ? Math.floor(count) : null;
 }
 
+/** How many compactions a session has had (`compaction.compactCount`): each
+ *  one trims the live messages and so restarts their numbering (the unread
+ *  cursors count them). Null for a value without it, e.g. a row written
+ *  before the field existed. */
+export function compactCount(value) {
+  const count = value?.compactCount;
+  return typeof count === 'number' && Number.isSafeInteger(count) && count >= 0 ? count : null;
+}
+
+/** `{ compactCount }` for a row that carries one, else nothing. */
+export function compactCountField(value) {
+  const count = compactCount(value);
+  return count === null ? {} : { compactCount: count };
+}
+
 export function importKey(value) {
   const key = typeof value?.importKey === 'string' ? value.importKey : value?.importOrigin?.key;
   return typeof key === 'string' && key.trim() ? key : null;

package/src/runtime/agent/orchestrator/session/store-summary-index.mjs

@@ -24,6 +24,8 @@ import {
   inheritedFromSessionId,
   isStoredSessionId,
   positiveNumber as _positiveNumber,
+  compactCount,
+  compactCountField,
   realTurnCount,
   workspaceSummary,
 } from './store-summary-fields.mjs';
@@ -54,26 +56,50 @@ const _computeCleanPreview = cleanSummaryPreview;
 // cleaning runs a chain of regex replaces that each allocate a copy. Those
 // short strings repeat from flush to flush, so the pure result is memoized per
 // (max, text). Long raw message text is not kept here (see _previewFromMessage).
+// Every new message's raw text (up to the text limit) also passes through, so
+// the memo is bounded by the characters it holds, least recently used first
+// out: at 8192 entries alone it kept ~16–32 MB of message text per `max`.
 const CLEAN_PREVIEW_MEMO_TEXT_LIMIT = 2048;
 const CLEAN_PREVIEW_MEMO_ENTRIES = 8192;
-const cleanPreviewMemo = new Map(); // max → Map<text, cleaned>
+const CLEAN_PREVIEW_MEMO_MAX_CHARS = 512 * 1024;
+const cleanPreviewMemo = new Map(); // max → { byText: Map<text, cleaned>, chars }
 
 function _cleanPreview(text, max = 240) {
   if (typeof text !== 'string' || text.length > CLEAN_PREVIEW_MEMO_TEXT_LIMIT) return _computeCleanPreview(text, max);
-  let byText = cleanPreviewMemo.get(max);
-  if (!byText) {
-    byText = new Map();
-    cleanPreviewMemo.set(max, byText);
+  let memo = cleanPreviewMemo.get(max);
+  if (!memo) {
+    memo = { byText: new Map(), chars: 0 };
+    cleanPreviewMemo.set(max, memo);
   }
+  const { byText } = memo;
   let cleaned = byText.get(text);
-  if (cleaned === undefined) {
-    cleaned = _computeCleanPreview(text, max);
-    if (byText.size >= CLEAN_PREVIEW_MEMO_ENTRIES) byText.clear();
+  if (cleaned !== undefined) {
+    byText.delete(text);
     byText.set(text, cleaned);
+    return cleaned;
+  }
+  cleaned = _computeCleanPreview(text, max);
+  byText.set(text, cleaned);
+  memo.chars += text.length + cleaned.length;
+  for (const [oldText, oldCleaned] of byText) {
+    if (byText.size <= CLEAN_PREVIEW_MEMO_ENTRIES && memo.chars <= CLEAN_PREVIEW_MEMO_MAX_CHARS) break;
+    byText.delete(oldText);
+    memo.chars -= oldText.length + oldCleaned.length;
   }
   return cleaned;
 }
 
+/** Entries and characters the preview memo holds, summed over every `max` (tests). */
+export function _cleanPreviewMemoStatsForTest() {
+  let entries = 0;
+  let chars = 0;
+  for (const memo of cleanPreviewMemo.values()) {
+    entries += memo.byText.size;
+    chars += memo.chars;
+  }
+  return { entries, chars };
+}
+
 const sessionMessageProjectionMemo = new WeakMap();
 // message → { raw, preview }. A session's first real user message is
 // re-checked on every save; its text is re-derived (cheap) and the preview is
@@ -265,6 +291,8 @@ export function _sessionSummary(session) {
     taskType: session.taskType || null,
     messageCount: messageProjection.count,
     ...(messageProjection.incoming ? { incomingTail: messageProjection.incoming.slice() } : {}),
+    // The numbering epoch of messageCount: a compaction restarts it.
+    compactCount: compactCount(session.compaction) ?? 0,
     realTurnCount: messageProjection.real,
     title: _cleanPreview(session.title || '', 100),
     preview: messageProjection.preview,
@@ -324,6 +352,7 @@ function _normalizeSummaryRow(row) {
     taskType: row.taskType || null,
     messageCount: Math.max(0, Math.floor(Number(row.messageCount) || 0)),
     ...(Array.isArray(row.incomingTail) ? { incomingTail: normalizedIncomingTail(row.incomingTail) } : {}),
+    ...compactCountField(row),
     realTurnCount: realTurnCount(row),
     title: _cleanPreview(row.title || '', 100),
     preview: _cleanPreview(row.preview || ''),
@@ -391,31 +420,58 @@ const _pendingRemovals = new Set(); // ids to drop (upsert/removal are mutually
 let _summaryRetryTimer = null;
 let _summaryFlushScheduled = false;
 let _summaryFlushInflight = 0;
-const _summarySettleWaiters = new Set();
+// Ids whose ops the async flush in flight took (they are requeued if it fails).
+const _inflightSummaryIds = new Set();
+const _summarySettleWaiters = new Set(); // { ids: string[]|null, resolve }
 
 export function _hasUnsettledSummaryOps() {
   return _pendingUpserts.size > 0 || _pendingRemovals.size > 0 || _summaryFlushScheduled || _summaryFlushInflight > 0;
 }
 
+/** The ids among `ids` whose summary ops are queued or being written. */
+export function pendingSummaryIndexIds(ids) {
+  return ids.filter((id) => _pendingUpserts.has(id) || _pendingRemovals.has(id) || _inflightSummaryIds.has(id));
+}
+
+function _waiterSettled({ ids }) {
+  return ids ? pendingSummaryIndexIds(ids).length === 0 : !_hasUnsettledSummaryOps();
+}
+
 function _notifySummarySettled() {
-  if (_hasUnsettledSummaryOps()) return;
-  for (const resolve of _summarySettleWaiters) resolve();
-  _summarySettleWaiters.clear();
+  for (const waiter of _summarySettleWaiters) {
+    if (_waiterSettled(waiter)) waiter.settle(true);
+  }
 }
 
 /**
- * Resolves once every queued summary-index mutation has landed and no flush
- * is scheduled or in flight — from then on this process no longer touches
- * the index, its lock or its temp files. Callers are told a save/sweep is
- * done before its deferred index flush runs, so an owner that removes or
- * switches the data dir awaits this first. A flush refused by a held lock
- * (an overlapping flush of this process, or another process) stays queued
- * and settles when its retry lands.
+ * Resolves true once the queued summary-index mutations have landed — of
+ * `ids` only when given, else every one with no flush scheduled or in flight;
+ * from then on this process no longer touches the index for them. Callers
+ * are told a save/sweep is done before its deferred index flush runs, so an
+ * owner that removes or switches the data dir awaits this first. A flush
+ * refused by a held lock (an overlapping flush of this process, or another
+ * process) stays queued and settles when its retry lands. When `signal`
+ * aborts first it resolves false and stops waiting; the ops stay queued.
  */
-export function settleSummaryIndexWrites() {
-  if (!_hasUnsettledSummaryOps()) return Promise.resolve();
+export function settleSummaryIndexWrites({ ids = null, signal = null } = {}) {
+  const waiter = { ids, settle: null };
+  if (_waiterSettled(waiter)) return Promise.resolve(true);
+  if (signal?.aborted) return Promise.resolve(false);
   _summaryRetryTimer?.ref?.();
-  return new Promise((resolve) => _summarySettleWaiters.add(resolve));
+  return new Promise((resolve) => {
+    const onAbort = () => waiter.settle(false);
+    // The one exit, landed or abandoned: the waiter and its abort listener
+    // both go, so a long-lived signal collects nothing per settle.
+    waiter.settle = (landed) => {
+      if (!_summarySettleWaiters.delete(waiter)) return;
+      signal?.removeEventListener('abort', onAbort);
+      // Only an awaited settlement keeps the process alive for the retry.
+      if (_summarySettleWaiters.size === 0) _summaryRetryTimer?.unref?.();
+      resolve(landed);
+    };
+    _summarySettleWaiters.add(waiter);
+    signal?.addEventListener('abort', onAbort, { once: true });
+  });
 }
 
 function _scheduleSummaryRetry() {
@@ -498,11 +554,14 @@ export function _flushPendingSummaryOps({ sync = false } = {}) {
     return;
   }
   _summaryFlushInflight++;
+  const taken = [...upserts.keys(), ...removals];
+  for (const id of taken) _inflightSummaryIds.add(id);
   withFileLock(`${path}.lock`, () => _appendSummaryOpsLocked(path, text), { timeoutMs: SUMMARY_LOCK_TIMEOUT_MS })
     .then(() => _sweepStaleSummaryTempOnce(path))
     .catch(requeue)
     .finally(() => {
       _summaryFlushInflight--;
+      for (const id of taken) _inflightSummaryIds.delete(id);
       if (_pendingUpserts.size > 0 || _pendingRemovals.size > 0) _scheduleSummaryFlush();
       _notifySummarySettled();
     });