@vellumai/assistant 0.11.8 → 0.11.9-staging.2

package/src/daemon/conversation-store.ts

@@ -6,9 +6,9 @@
  * decoupling route handlers and IPC callbacks from the DaemonServer
  * class.
  *
- * The {@link getOrCreateConversation} function owns the full
- * creation/reuse lifecycle — provider wiring, rate limiting, system
- * prompt assembly, and DB hydration. Idle eviction lives in
+ * {@link getOrCreateConversation} and {@link getConversationIfExists} share
+ * one body that owns the full creation/reuse lifecycle: provider wiring, rate
+ * limiting, system prompt assembly, and DB hydration. Idle eviction lives in
  * `conversation-evictor`.
  */
 
@@ -128,8 +128,8 @@ function clearConversationOptions(): void {
 
 // ── Conversation lifecycle ─────────────────────────────────────────
 
-/** Dedup guard: in-flight creation promises keyed by conversation ID. */
-const conversationCreating = new Map<string, Promise<Conversation>>();
+/** Dedup guard: in-flight acquisitions keyed by conversation ID. */
+const conversationCreating = new Map<string, Promise<Conversation | null>>();
 
 function applyTransportMetadata(
   conversation: Conversation,
@@ -163,6 +163,88 @@ export async function getOrCreateConversation(
   conversationId: string,
   options?: ConversationCreateOptions,
 ): Promise<Conversation> {
+  // Null is the non-creating acquire's answer and nobody else's.
+  return (await acquireConversation(conversationId, options, true))!;
+}
+
+/**
+ * Acquire an active conversation, or null when the one asked about is gone.
+ *
+ * For a caller whose work is only meaningful inside a conversation that still
+ * exists: a queued job whose conversation can be deleted between the moment it
+ * was accepted and the moment it runs. {@link getOrCreateConversation} would
+ * write the row back for it, which resurrects a conversation the user deleted.
+ *
+ * The question it answers is about one incarnation, not about an id. A row
+ * deleted and written back under the same id is a different conversation, and
+ * this reports it as gone rather than persisting into a stranger that inherited
+ * the name.
+ *
+ * Distinct from the two cheaper reads it sits above:
+ * `findConversation` returns only an instance already in memory, and the
+ * persistence layer's `getConversation` returns only the row. This builds and
+ * hydrates the instance the way the creating acquire does, and answers null
+ * exactly where that one would insert.
+ */
+export function getConversationIfExists(
+  conversationId: string,
+  options?: ConversationCreateOptions,
+): Promise<Conversation | null> {
+  return acquireConversation(conversationId, options, false);
+}
+
+/**
+ * Whether the conversation is still the incarnation the caller was asked about.
+ *
+ * `created_at` is stamped at insert and nothing else rewrites it, so a row
+ * deleted and written back under the same id carries a different one.
+ * `createConversation` issues that stamp monotonically per process, which is
+ * what makes the two distinguishable even when they land in the same
+ * millisecond. Bare existence cannot answer this: a caller sharing flight with
+ * a creating acquire can find a row that acquire wrote moments ago and read it
+ * as the one it was asked about, and so can one that held an instance across a
+ * wait.
+ *
+ * A conversation restored from its on-disk view (the recovery migration, the
+ * `db repair` backfill) is written back with the stamp its meta file records,
+ * so it answers as the incarnation it is rather than as a new one. Both
+ * restores skip an id whose row is present, so neither can displace a live
+ * conversation this way.
+ *
+ * Exported for callers that keep working after their acquire returns: holding
+ * the instance says nothing about the row still being the one behind it.
+ */
+export function isSameIncarnation(
+  conversationId: string,
+  createdAt: number | null,
+): boolean {
+  return (
+    createdAt !== null &&
+    getConversation(conversationId)?.createdAt === createdAt
+  );
+}
+
+/**
+ * The body both acquires share. `createIfMissing` decides one thing: whether a
+ * missing row is written or reported.
+ */
+async function acquireConversation(
+  conversationId: string,
+  options: ConversationCreateOptions | undefined,
+  createIfMissing: boolean,
+): Promise<Conversation | null> {
+  // A caller that will not create wants nothing to do with a conversation
+  // whose row is gone, resident instance or not. Also spares an already-gone
+  // conversation the provider and tool setup below. The row it finds is the
+  // incarnation every later acceptance point below answers for.
+  let incarnation: number | null = null;
+  if (!createIfMissing) {
+    incarnation = getConversation(conversationId)?.createdAt ?? null;
+    if (incarnation === null) {
+      return null;
+    }
+  }
+
   let conversation = findConversation(conversationId);
 
   // `taskRunId` and `ephemeral` are per-call scopes, not durable conversation
@@ -200,10 +282,54 @@ export async function getOrCreateConversation(
       conversation.dispose();
     }
 
-    const pending = conversationCreating.get(conversationId);
-    if (pending) {
-      conversation = await pending;
-      return conversation;
+    // Joining is a loop rather than a single look because a flight can decline
+    // to create, and a caller that was asked to create must then re-consult
+    // the map instead of building unconditionally: two creating callers that
+    // fell through together would each build an instance for one id, the
+    // second overwriting the first in the registry and leaving the first to
+    // run outside the shared processing and queue state. A non-creating caller
+    // re-consults for the mirrored reason: a flight that declined answered for
+    // the incarnation IT was asked about, which a delete and recreate can have
+    // made a different one from this caller's.
+    //
+    // It terminates. The owner of a flight attaches its own continuation in
+    // the same synchronous run that publishes the flight, so its `finally`
+    // has already removed the entry by the time any joiner resumes, and a
+    // joiner therefore never re-joins the flight it just awaited. What it
+    // finds instead is a newer flight or nothing, and a creating flight only
+    // ever resolves non-null, so joining one returns. A non-creating caller
+    // passes again only while the row it was asked about is still there, so
+    // the delete that a declining flight reports ends its loop as well.
+    for (;;) {
+      const pending = conversationCreating.get(conversationId);
+      if (!pending) {
+        break;
+      }
+      const joined = await pending;
+      if (!createIfMissing) {
+        // A non-creating acquire answers for the incarnation it was asked
+        // about, never for what an acquire it happened to share flight with
+        // decided to write. The shared flight can belong to a creating caller,
+        // whose own contract is to build the conversation whatever became of
+        // the row, and a delete during that caller's setup is answered by
+        // writing a fresh row under the same id. Present is therefore not the
+        // question: that row is a different conversation, and this caller was
+        // never asked to persist into it.
+        if (joined) {
+          return isSameIncarnation(conversationId, incarnation) ? joined : null;
+        }
+        // A declining flight reports its own incarnation gone, which says
+        // nothing about a later one this caller may hold. Taking that null
+        // would refuse work the id can still accept, so this reconsults, and
+        // only its own row being gone ends it.
+        if (!isSameIncarnation(conversationId, incarnation)) {
+          return null;
+        }
+        continue;
+      }
+      if (joined) {
+        return joined;
+      }
     }
 
     const storedOptions = conversationOptions.get(conversationId);
@@ -238,6 +364,14 @@ export async function getOrCreateConversation(
       const { initializeTools } = await import("../tools/registry.js");
       await initializeTools();
 
+      // Provider resolution, the system prompt, and tool setup all await, and
+      // a delete can land in any of them. This is the last instant before the
+      // row insert below and nothing between the two awaits, so a non-creating
+      // acquire that finds its incarnation gone here never writes it back.
+      if (!createIfMissing && !isSameIncarnation(conversationId, incarnation)) {
+        return null;
+      }
+
       const newConversation = new Conversation(
         conversationId,
         provider,
@@ -310,16 +444,30 @@ export async function getOrCreateConversation(
       if (options?.transport) {
         newConversation.applyVisibleAppFromTransport(options.transport);
       }
+      // Hydration awaits, so a delete can land between the check that let this
+      // build and the registry write. Registering then leaves an active
+      // conversation with no row behind it, which later session work finds and
+      // reuses. The creating path keeps its own window: it cannot answer null,
+      // and a caller that was asked to build owns what it built.
+      if (!createIfMissing && !isSameIncarnation(conversationId, incarnation)) {
+        newConversation.dispose();
+        return null;
+      }
       setConversation(conversationId, newConversation);
       return newConversation;
     })();
 
     conversationCreating.set(conversationId, createPromise);
+    let acquired: Conversation | null;
     try {
-      conversation = await createPromise;
+      acquired = await createPromise;
     } finally {
       conversationCreating.delete(conversationId);
     }
+    if (!acquired) {
+      return null;
+    }
+    conversation = acquired;
     touchConversation(conversationId);
   } else {
     if (!conversation.isProcessing()) {
@@ -330,7 +478,7 @@ export async function getOrCreateConversation(
     }
     touchConversation(conversationId);
   }
-  return conversation;
+  return conversation ?? null;
 }
 
 /**

package/src/daemon/conversation-tool-setup.ts

@@ -729,7 +729,9 @@ function resolveTurnClientOs(ctx: Conversation): {
   const clientOs = pin
     ? pin.clientOs
     : (parseClientOs(ctx.currentTurnClientOs ?? ctx.clientOs) ??
-      (transportInterface === "macos" || transportInterface === "windows"
+      (transportInterface === "macos" ||
+      transportInterface === "windows" ||
+      transportInterface === "linux"
         ? transportInterface
         : undefined));
   return { clientOs, transportInterface };
@@ -900,7 +902,12 @@ export function isToolActiveForContext(
     // Check the *client's* platform, not the daemon's process.platform.
     // In Docker the daemon runs on Linux but the connected client may be macOS.
     const { clientOs } = resolveTurnClientOs(ctx);
-    return (clientOs === "macos" || clientOs === "windows") && !hasNoClient;
+    return (
+      (clientOs === "macos" ||
+        clientOs === "windows" ||
+        clientOs === "linux") &&
+      !hasNoClient
+    );
   }
   if (SUBAGENT_ONLY_TOOL_NAMES.has(name)) {
     return ctx.isSubagent === true;

package/src/daemon/conversation.ts

@@ -78,6 +78,7 @@ import {
   MEMORY_V3_INJECTED_BLOCK_METADATA_KEY,
 } from "../plugins/defaults/memory/v3/ever-injected-store.js";
 import { filterPrunedCardSections } from "../plugins/defaults/memory/v3/prune.js";
+import { MEMORY_V3_SPOTLIGHT_BLOCK_METADATA_KEY } from "../plugins/defaults/memory/v3/types.js";
 import {
   applyBootstrapTemplate,
   buildSystemPrompt,
@@ -306,12 +307,37 @@ function abortReasonOf(signal?: AbortSignal): unknown {
   );
 }
 
+/**
+ * Thrown by the processing fence when the claim it was asked about is no
+ * longer the live one, which is the conversation having moved on to another
+ * holder rather than anything failing.
+ */
+export class ProcessingClaimLostError extends Error {
+  constructor(conversationId: string) {
+    super(`Processing claim lost for conversation ${conversationId}`);
+    this.name = "ProcessingClaimLostError";
+  }
+}
+
 export class Conversation {
   public readonly conversationId: string;
   /** @internal */ provider: Provider;
   /** @internal */ messages: Message[] = [];
   /** @internal */ agentLoop: AgentLoop;
   private _processing = false;
+  /**
+   * Which claim on the processing flag is the live one, as a value that changes
+   * every time the flag is taken. Zero while it is free.
+   *
+   * The flag itself is a boolean and cannot say who holds it, so a release has
+   * no way to tell its own hold from one taken since. This is what lets
+   * {@link releaseProcessing} refuse to release someone else's.
+   */
+  private processingOwner = 0;
+  private nextProcessingOwner = 0;
+  /** The live claim's marker write, awaited through the fence below. */
+  private processingMarker: { owner: number; landed: Promise<void> } | null =
+    null;
   /**
    * Pending {@link waitForIdle} resolvers, notified from the committed
    * `processing → false` transition inside {@link setProcessing}. Every
@@ -535,7 +561,7 @@ export class Conversation {
    * @internal
    */
   currentTurnCronRunId?: string | null;
-  /** @internal */ currentTurnIsNonInteractive?: boolean;
+  /** @internal */   currentTurnIsNonInteractive?: boolean;
   /** @internal */ currentTurnModelProfileNoticeKey?: string;
   /** @internal */ currentTurnRequestOrigin?: string;
   /** @internal */ authContext?: AuthContext;
@@ -1191,12 +1217,17 @@ export class Conversation {
             const text = extractTextFromStoredMessageContent(row.content);
             if (text) {
               // A split reply posts several provider messages from one row;
-              // a reaction may name any of them.
+              // a reaction may name any of them. A post deleted on its own
+              // (partial deletion of a split reply) stops being quotable
+              // while its siblings remain.
               for (const id of [
                 rowMeta.messageId,
                 ...(rowMeta.additionalMessageIds ?? []),
               ]) {
-                if (!reactionTargetIndexMemo.has(id)) {
+                if (
+                  !reactionTargetIndexMemo.has(id) &&
+                  !rowMeta.deletedMessageIds?.includes(id)
+                ) {
                   reactionTargetIndexMemo.set(id, text);
                 }
               }
@@ -1242,6 +1273,23 @@ export class Conversation {
           // Neutral marker, no actor: Discord deletes can be authorless
           // (`actorUnattributed`), so the marker never claims who deleted.
           content = [{ type: "text", text: "[This message was deleted]" }];
+        } else if (
+          role === "assistant" &&
+          providerMeta?.deletedAt !== undefined
+        ) {
+          // The assistant's own deleted post keeps its content: erasure is
+          // how a retracted USER message is honored, but rewriting what the
+          // assistant said would falsify its memory of its own output. The
+          // rendered fact is visibility: the message no longer exists on the
+          // channel, so the assistant should not refer to it as something
+          // participants can see.
+          content = [
+            ...content,
+            {
+              type: "text",
+              text: "[This message was deleted from the channel and is no longer visible to participants]",
+            },
+          ];
         }
       }
 
@@ -1274,7 +1322,8 @@ export class Conversation {
           // at the memory boundary after the `<info>` block but before
           // now-md's earlier splice):
           //   [<workspace>, <turn_context>, <memory>dynamic</memory>,
-          //    <info>v2static</info>, <memory>v3cards</memory>, <NOW.md>,
+          //    <info>v2static</info>, <memory>v3cards</memory>,
+          //    <memory_spotlight>, <NOW.md>,
           //    <system_reminder>, <knowledge_base>, ...original]
           // The v2 static block is replayed verbatim from stored metadata,
           // so rows may carry either `<info>…</info>` or `<memory>…</memory>`
@@ -1304,6 +1353,28 @@ export class Conversation {
             ];
           }
 
+          // The memory-v3 per-turn `<memory_spotlight>` persists under its
+          // own key as the wrapped block that was sent. Rehydrated on ALL
+          // rows (tail included), matching frozen cards: after a reload the
+          // last completed turn is the tail, and the next user message is
+          // appended without re-running loadFromDb. Prepended here, after
+          // now-md and before the v3 card block, so the inverted prepends
+          // land as [cards, spotlight, now-md, ...]. Trust-gated on
+          // `personalMemoryAllowed` like the cards: the spotlight carries
+          // matched personal-memory sections.
+          if (
+            personalMemoryAllowed &&
+            typeof meta[MEMORY_V3_SPOTLIGHT_BLOCK_METADATA_KEY] === "string"
+          ) {
+            content = [
+              {
+                type: "text" as const,
+                text: meta[MEMORY_V3_SPOTLIGHT_BLOCK_METADATA_KEY] as string,
+              },
+              ...content,
+            ];
+          }
+
           // The memory-v3 frozen card block (net-new compact cards) persists
           // under its own key, stored UNWRAPPED like v2's dynamic block below.
           // Rehydrated on ALL rows (tail included): the next turn injects only
@@ -1606,27 +1677,56 @@ export class Conversation {
     }
   }
 
-  async ensureActorScopedHistory(): Promise<void> {
-    const currentTrustClass = this.trustContext?.trustClass;
-    // Tracked alongside the trust class because `loadFromDb` gates
-    // personal-memory rehydration on `isPersonalMemoryAllowed`, which folds in
-    // the disabled-auth elevation of an unbound actor: two contexts can share a
-    // trust class and still differ here. A reuse that changes the answer has to
-    // reload, or stale personal-memory blocks persist into a turn that must not
-    // see them, or stay stripped from one that should.
-    const currentPersonalMemoryAllowed = isPersonalMemoryAllowed(
-      this.trustContext,
-    );
-    if (
+  /**
+   * Whether the resident history is the one an actor carrying `trustContext`
+   * would be given.
+   *
+   * Personal memory is asked alongside the trust class because `loadFromDb`
+   * gates personal-memory rehydration on `isPersonalMemoryAllowed`, which folds
+   * in the disabled-auth elevation of an unbound actor: two contexts can share
+   * a trust class and still differ here. A reuse that changes the answer has to
+   * reload, or stale personal-memory blocks persist into a turn that must not
+   * see them, or stay stripped from one that should.
+   */
+  private historyMatchesScope(trustContext: TrustContext | undefined): boolean {
+    return (
       !this.loadedHistoryStale &&
-      this.loadedHistoryTrustClass === currentTrustClass &&
-      this.loadedHistoryPersonalMemoryAllowed === currentPersonalMemoryAllowed
-    ) {
+      this.loadedHistoryTrustClass === trustContext?.trustClass &&
+      this.loadedHistoryPersonalMemoryAllowed ===
+        isPersonalMemoryAllowed(trustContext)
+    );
+  }
+
+  async ensureActorScopedHistory(): Promise<void> {
+    if (this.historyMatchesScope(this.trustContext)) {
       return;
     }
     await this.loadFromDb();
   }
 
+  /**
+   * Mark stale when a row has been appended to the resident history under an
+   * actor this history is not scoped for.
+   *
+   * A persist that runs outside any turn has nothing ensuring the history for
+   * its sender first, so its row joins `this.messages` as it is. Left alone,
+   * the next turn under the resident scope reuses that array rather than
+   * reloading, and sends the model a row a reload would have filtered out.
+   *
+   * `trustContext` is the actor the row was attributed to, which for a caller
+   * that resolved none is the conversation's own, matching what the persist
+   * stamps. A scope that already matches is left alone: rows can arrive on a
+   * camera's cadence, and a reload apiece is a cost worth the comparison.
+   */
+  markHistoryStaleForForeignScope(
+    trustContext: TrustContext | undefined,
+  ): void {
+    if (this.historyMatchesScope(trustContext ?? this.trustContext)) {
+      return;
+    }
+    this.markHistoryStale();
+  }
+
   /**
    * Mark the resident history stale: a channel event (a reaction, edit, or
    * delete) was persisted straight to the store while this conversation was
@@ -1799,7 +1899,12 @@ export class Conversation {
    */
   setProcessing(value: boolean): void {
     const wasProcessing = this._processing;
+    const wasOwner = this.processingOwner;
     this._processing = value;
+    // Every set is a claim, including one over a flag another holder already
+    // has: a caller setting it unconditionally is asserting the hold is now
+    // theirs, and the previous holder's release must not undo that.
+    this.processingOwner = value ? ++this.nextProcessingOwner : 0;
     // Persist the cross-process source of truth so out-of-process callers
     // (retrospective CLI, future detached workers) can detect mid-turn state
     // by reading the conversations row directly.
@@ -1808,6 +1913,7 @@ export class Conversation {
         setConversationProcessingStartedAt(this.conversationId, Date.now());
       } catch (err) {
         this._processing = wasProcessing;
+        this.processingOwner = wasOwner;
         throw err;
       }
     } else {
@@ -1830,6 +1936,171 @@ export class Conversation {
     }
   }
 
+  /**
+   * Take the processing flag if it is free, reporting the claim a later release
+   * has to name. Null means someone already holds it.
+   *
+   * The read and the take are one synchronous step, so no second acquirer can
+   * land between them, and the flag stays held while the marker write below
+   * retries: reverting it because that write lost a race would publish an idle
+   * conversation for as long as the retry sleeps, and anything polling for idle
+   * takes the flag in that window while this caller believes its turn is
+   * starting.
+   *
+   * The marker is a fence, not a hope. `processing_started_at` is what a
+   * reconnecting client and the out-of-process retrospective worker read to
+   * decide whether a turn is live, so a turn that proceeds while the column is
+   * null lets a client stop waiting mid-turn and lets the worker fork partial
+   * history. Every caller therefore awaits {@link ensureProcessingMarker}
+   * before doing anything with the hold, and gives the hold back when it does
+   * not land.
+   */
+  acquireProcessing(): number | null {
+    if (this._processing) {
+      return null;
+    }
+    this._processing = true;
+    const owner = ++this.nextProcessingOwner;
+    this.processingOwner = owner;
+    this.processingMarker = {
+      owner,
+      landed: this.mirrorProcessingStarted(owner, Date.now()),
+    };
+    return owner;
+  }
+
+  /**
+   * Resolve once this claim's processing marker is durable. Reject when the
+   * retry budget runs out without it landing, and reject when the claim is not
+   * the live one.
+   *
+   * Lost ownership is a failure here, not a pass. The caller does its work
+   * between this fence and its release, so answering "fine" for a hold that
+   * Stop or a teardown has already cleared would let that work run under a
+   * dead claim while a new turn acquires and writes alongside it.
+   *
+   * Asked again after the await because both can happen in one window: the
+   * write lands, and the hold is claimed away before this resumes. The fence
+   * has to describe the present, not the moment it started waiting.
+   */
+  async ensureProcessingMarker(owner: number): Promise<void> {
+    const marker = this.processingMarker;
+    if (!marker || marker.owner !== owner || this.processingOwner !== owner) {
+      throw new ProcessingClaimLostError(this.conversationId);
+    }
+    await marker.landed;
+    if (this.processingOwner !== owner) {
+      throw new ProcessingClaimLostError(this.conversationId);
+    }
+  }
+
+  /**
+   * Take the flag and wait out its marker, giving the claim back rather than
+   * ever leaving a live one unreleased.
+   *
+   * Null is "this conversation is someone else's", by either route: the flag
+   * was already held, or the hold was claimed away while the marker was still
+   * landing. Callers answer both with the busy behaviour they already owe.
+   *
+   * A throw is the marker itself refusing to persist, which is a real failure
+   * rather than a busy conversation, and the claim is already released before
+   * it is raised. Every acquire goes through here, so no call site can get the
+   * ordering wrong: there is no window where a claim exists and its release is
+   * not yet guaranteed.
+   */
+  async acquireProcessingFenced(): Promise<number | null> {
+    const owner = this.acquireProcessing();
+    if (owner === null) {
+      return null;
+    }
+    try {
+      await this.ensureProcessingMarker(owner);
+    } catch (err) {
+      // A no-op when the claim is already gone, which is exactly the case
+      // this is here to make harmless.
+      this.releaseProcessing(owner);
+      if (err instanceof ProcessingClaimLostError) {
+        return null;
+      }
+      throw err;
+    }
+    return owner;
+  }
+
+  /**
+   * Whether this claim is still the live hold on the conversation.
+   *
+   * For work that runs across awaits under a claim it took earlier. A Stop on
+   * a hold with no live turn behind it force-clears the flag, and the next
+   * request acquires, so a claim can go stale while its holder is mid-write.
+   * Asking here is a plain field read, which is what lets a write fence ask it
+   * in the same tick as the statement it guards.
+   */
+  holdsProcessingClaim(owner: number): boolean {
+    return this.processingOwner === owner;
+  }
+
+  /**
+   * Release a hold taken by {@link acquireProcessing}, and only that hold.
+   * Reports whether it released.
+   *
+   * A hold can be claimed away by any unconditional `setProcessing(true)`,
+   * which is how a turn starts. The earlier holder's release then has to do
+   * nothing: clearing there would release a turn that is still running and let
+   * the next one interleave into the rows it is still writing.
+   */
+  releaseProcessing(owner: number): boolean {
+    if (this.processingOwner !== owner) {
+      log.debug(
+        {
+          conversationId: this.conversationId,
+          owner,
+          holder: this.processingOwner,
+        },
+        "Not releasing the processing flag: another holder claimed it",
+      );
+      return false;
+    }
+    this.setProcessing(false);
+    return true;
+  }
+
+  /**
+   * Write a taken processing lock into the `processing_started_at` column,
+   * reporting through the promise {@link ensureProcessingMarker} hands back.
+   *
+   * The retry runs while the flag stays held, so the lock has no gap for
+   * another acquirer, and it re-checks ownership rather than the flag: a hold
+   * claimed since has written its own timestamp, and a late write from this one
+   * would describe the wrong turn.
+   */
+  private mirrorProcessingStarted(
+    owner: number,
+    startedAt: number,
+  ): Promise<void> {
+    const landed = withSqliteRetry(
+      () => {
+        if (this.processingOwner !== owner) {
+          return;
+        }
+        setConversationProcessingStartedAt(this.conversationId, startedAt);
+      },
+      {
+        op: "conversation:acquireProcessing",
+        context: { conversationId: this.conversationId },
+      },
+    );
+    // The caller awaits this, but only on its own next tick, so subscribe now
+    // rather than let a rejection land with nothing attached to it.
+    landed.catch((err: unknown) => {
+      log.error(
+        { err, conversationId: this.conversationId },
+        "Failed to persist the processing marker; the claim holding this conversation is given back",
+      );
+    });
+    return landed;
+  }
+
   /**
    * Mirror a released processing lock into the advisory `processing_started_at`
    * column, without ever reporting failure back to the release.

package/src/daemon/dictation-text-processing.ts

@@ -10,11 +10,6 @@ import type {
   DictationSnippet,
 } from "./dictation-profile-store.js";
 
-/** Escape a string for safe use inside a RegExp. */
-function escapeRegExp(s: string): string {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
 /**
  * Wrap an escaped pattern with word boundaries.
  *
@@ -65,7 +60,7 @@ export function expandSnippets(
 
   // Build a single alternation pattern for single-pass replacement
   const alternatives = sorted.map((s) =>
-    wrapWordBoundary(escapeRegExp(s.trigger), s.trigger),
+    wrapWordBoundary(RegExp.escape(s.trigger), s.trigger),
   );
   const pattern = new RegExp(`(?:${alternatives.join("|")})`, "gi");
 
@@ -116,7 +111,7 @@ export function applyDictionary(
   }
 
   const entries: EntryWithPattern[] = sorted.map((entry) => {
-    const escaped = escapeRegExp(entry.spoken);
+    const escaped = RegExp.escape(entry.spoken);
     const wholeWord = entry.wholeWord !== false; // default true
     const pat = wholeWord ? wrapWordBoundary(escaped, entry.spoken) : escaped;
     return { pattern: pat, entry };