ocuclaw 1.2.4 → 1.3.1

package/dist/domain/message-emoji-filter.js

@@ -1,60 +1,15 @@
-const MESSAGE_EMOJI_ALLOWLIST = [
-  "😂",
-  "❤️",
-  "🤣",
-  "👍",
-  "😭",
-  "🙏",
-  "😘",
-  "🥰",
-  "😍",
-  "😊",
-  "🎉",
-  "😁",
-  "💕",
-  "🥺",
-  "😅",
-  "🔥",
-  "☺️",
-  "🤦",
-  "🤷",
-  "🙄",
-  "😆",
-  "🤗",
-  "😉",
-  "🎂",
-  "🤔",
-  "👏",
-  "🙂",
-  "😳",
-  "🥳",
-  "😎",
-  "👌",
-  "😔",
-  "💪",
-  "✨",
-  "💖",
-  "💞",
-  "👀",
-  "😋",
-  "😏",
-  "😢",
-  "👉",
-  "💗",
-  "😩",
-  "💯",
-  "🌹",
-  "🎈",
-  "😚",
-  "😐",
-  "😒",
-  "😀",
-];
-
-const MESSAGE_EMOJI_ALLOWLIST_SET = new Set(MESSAGE_EMOJI_ALLOWLIST);
+import {
+  MESSAGE_EMOJI_ALLOWLIST,
+  MESSAGE_EMOJI_ALLOWLIST_SET,
+} from "./message-emoji-allowlist.js";
+
 const EMOJI_CLUSTER_SEGMENTER = new Intl.Segmenter(undefined, {
   granularity: "grapheme",
 });
+// All emoji codepoints live above U+007F, so pure-ASCII text cannot contain
+// any emoji and the segmenter walk is pure overhead. This regex is the
+// gatekeeper for the fast path below.
+const NON_ASCII_RE = /[^\x00-\x7F]/;
 const RGI_EMOJI_SEQUENCE_RE = createOptionalRegex("^\\p{RGI_Emoji}$", "v");
 const EMOJI_CLUSTER_FALLBACK_RE =
   /(?:\p{Extended_Pictographic}|[\u{1F1E6}-\u{1F1FF}\u{1F3FB}-\u{1F3FF}\u20E3\u{E0020}-\u{E007F}])/u;
@@ -147,10 +102,33 @@ function emitGapForTextEnd(mode, beforeRemoved, afterRemoved, removedEmojiInGap)
   return beforeRemoved + afterRemoved;
 }
 
+function filterAsciiDisplayFast(text) {
+  // Mirrors the segmenter walk for pure-ASCII display mode:
+  //   - whitespace immediately before a newline is dropped
+  //   - other [ \t]+ runs collapse to a single space
+  //   - trailing horizontal whitespace at end-of-text is stripped
+  return text
+    .replace(/[ \t]+(\r\n|\r|\n)/g, "$1")
+    .replace(/[ \t]+/g, " ")
+    .replace(/[ \t]+$/g, "");
+}
+
+function filterAsciiRawFast(text) {
+  // Raw mode preserves inline whitespace; only the post-loop trailing-trim
+  // remains for pure-ASCII input.
+  return text.replace(/[ \t]+$/g, "");
+}
+
 function filterEmojiText(text, mode) {
   if (!text) return "";
 
   const selectedMode = mode === "display" ? "display" : "raw";
+
+  if (!NON_ASCII_RE.test(text)) {
+    return selectedMode === "display"
+      ? filterAsciiDisplayFast(text)
+      : filterAsciiRawFast(text);
+  }
   const out = [];
   let pendingWhitespaceBeforeRemoved = "";
   let pendingWhitespaceAfterRemoved = "";
@@ -246,4 +224,4 @@ export function filterRawEmojiText(text) {
   return filterEmojiText(text, "raw");
 }
 
-export { MESSAGE_EMOJI_ALLOWLIST };
+export { MESSAGE_EMOJI_ALLOWLIST, MESSAGE_EMOJI_ALLOWLIST_SET };

package/dist/domain/neural-emoji-reactor-system-prompt.js

@@ -0,0 +1,43 @@
+import { MESSAGE_EMOJI_ALLOWLIST } from "./message-emoji-allowlist.js";
+
+const DISABLED_NOTICE = `<neural_emoji_reactor>
+The Neural Emoji Reactor has been turned off for the remainder of
+this session. Do not use <emoji:X>...</emoji> spans in your replies,
+even if earlier messages in this conversation used them.
+</neural_emoji_reactor>`;
+
+const ALLOWLIST_LINES = (() => {
+  const rows = [];
+  for (let i = 0; i < MESSAGE_EMOJI_ALLOWLIST.length; i += 20) {
+    rows.push(MESSAGE_EMOJI_ALLOWLIST.slice(i, i + 20).join(" "));
+  }
+  return rows.map((r) => `  ${r}`).join("\n");
+})();
+
+const ACTIVE_BLOCK = `<neural_emoji_reactor>
+You can briefly change a small status emoji shown above your message
+on the user's display by wrapping a short phrase in your reply with:
+
+  <emoji:X>your phrase</emoji>
+
+The tags themselves are invisible — only the wrapped words are shown
+in the message body.
+
+Use this sparingly. Most messages should have NO span. Use one only
+at moments where it adds real warmth, surprise, care, or playfulness
+for a single short phrase. Do not tag every sentence. Do not nest
+spans. Always close a span you open.
+
+Allowed emoji (use exactly one per span, copied verbatim from this
+list):
+${ALLOWLIST_LINES}
+
+Do not use off-list emoji; they will be ignored.
+</neural_emoji_reactor>`;
+
+export function composeNeuralEmojiReactorSystemPrompt(opts) {
+  const state = opts && opts.state;
+  if (state === "active") return ACTIVE_BLOCK;
+  if (state === "recently-disabled") return DISABLED_NOTICE;
+  return "";
+}

package/dist/domain/neural-emoji-reactor-tag-config.js

@@ -0,0 +1,56 @@
+import { MESSAGE_EMOJI_ALLOWLIST_SET } from "./message-emoji-allowlist.js";
+
+const OPEN_PREFIX = "<emoji:";
+const CLOSE_TAG = "</emoji>";
+const CLOSE_LITERALS = Object.freeze(["</emoji>"]);
+
+export const EMOJI_TAG_FAMILY_CONFIG = {
+  name: "emoji",
+  closeLiterals: CLOSE_LITERALS,
+
+  matchOpen(input, at) {
+    if (!input.startsWith(OPEN_PREFIX, at)) return null;
+    const closeIdx = input.indexOf(">", at + OPEN_PREFIX.length);
+    if (closeIdx === -1) return null;
+    const rawEmoji = input.slice(at + OPEN_PREFIX.length, closeIdx);
+    if (/\s/.test(rawEmoji)) return null;
+    return {
+      consumed: closeIdx - at + 1,
+      spanInit: { emoji: rawEmoji },
+    };
+  },
+
+  matchClose(input, at) {
+    if (!input.startsWith(CLOSE_TAG, at)) return null;
+    return { consumed: CLOSE_TAG.length, closeKind: "emoji" };
+  },
+
+  closeMatches(_activeOpen, _closeKind) {
+    return true;
+  },
+
+  validateOpen(spanInit) {
+    return MESSAGE_EMOJI_ALLOWLIST_SET.has(spanInit.emoji);
+  },
+
+  matchTrailingPartial(input, _suffixStart) {
+    const n = input.length;
+    // 1) Trailing prefix of OPEN_PREFIX
+    for (let len = Math.min(n, OPEN_PREFIX.length - 1); len > 0; len--) {
+      const tail = input.slice(n - len);
+      if (OPEN_PREFIX.startsWith(tail)) return len;
+    }
+    // 2) Trailing OPEN_PREFIX + bytes not yet terminated by `>`
+    const lastOpen = input.lastIndexOf(OPEN_PREFIX);
+    if (lastOpen !== -1) {
+      const after = input.indexOf(">", lastOpen + OPEN_PREFIX.length);
+      if (after === -1) return n - lastOpen;
+    }
+    // 3) Trailing prefix of CLOSE_TAG
+    for (let len = Math.min(n, CLOSE_TAG.length - 1); len > 0; len--) {
+      const tail = input.slice(n - len);
+      if (CLOSE_TAG.startsWith(tail)) return len;
+    }
+    return 0;
+  },
+};

package/dist/domain/neural-pace-modulator-system-prompt.js

@@ -0,0 +1,32 @@
+const ACTIVE_BLOCK = `<neural_pace_modulator>
+You can shape how quickly a short phrase reveals on the user's display
+by wrapping it with one of:
+
+  <dwell>your phrase</dwell>    — reveals slower, lets the line land
+  <skim>your phrase</skim>      — reveals faster, rushes past a recap
+
+The tags themselves are invisible — only the wrapped words are shown
+in the message body.
+
+Use this sparingly. Most messages have NO pace tag. Use one only at a
+moment that genuinely benefits from it: a beat where the user should
+sit with what was just said, or a recap that doesn't need to breathe.
+Keep spans short (a few words). Do not tag every sentence. Do not nest
+the same tag inside itself. Always close a tag you open.
+
+You may combine pace tags with <emoji:X>...</emoji> if both apply to
+the same phrase. They don't interfere.
+</neural_pace_modulator>`;
+
+const DISABLED_NOTICE = `<neural_pace_modulator>
+The Neural Pace Modulator has been turned off for the remainder of
+this session. Do not use <dwell>...</dwell> or <skim>...</skim>
+spans in your replies, even if earlier messages used them.
+</neural_pace_modulator>`;
+
+export function composeNeuralPaceModulatorSystemPrompt(opts) {
+  const state = opts && opts.state;
+  if (state === "active") return ACTIVE_BLOCK;
+  if (state === "recently-disabled") return DISABLED_NOTICE;
+  return "";
+}

package/dist/domain/neural-pace-modulator-tag-config.js

@@ -0,0 +1,51 @@
+const OPEN_DWELL = "<dwell>";
+const OPEN_SKIM = "<skim>";
+const CLOSE_DWELL = "</dwell>";
+const CLOSE_SKIM = "</skim>";
+const OPEN_LITERALS = Object.freeze([OPEN_DWELL, OPEN_SKIM]);
+const CLOSE_LITERALS = Object.freeze([CLOSE_DWELL, CLOSE_SKIM]);
+const ALL_LITERALS = Object.freeze([...OPEN_LITERALS, ...CLOSE_LITERALS]);
+
+export const PACE_TAG_FAMILY_CONFIG = {
+  name: "pace",
+  closeLiterals: CLOSE_LITERALS,
+
+  matchOpen(input, at) {
+    if (input.startsWith(OPEN_DWELL, at)) {
+      return { consumed: OPEN_DWELL.length, spanInit: { mode: "dwell" } };
+    }
+    if (input.startsWith(OPEN_SKIM, at)) {
+      return { consumed: OPEN_SKIM.length, spanInit: { mode: "skim" } };
+    }
+    return null;
+  },
+
+  matchClose(input, at) {
+    if (input.startsWith(CLOSE_DWELL, at)) {
+      return { consumed: CLOSE_DWELL.length, closeKind: "dwell" };
+    }
+    if (input.startsWith(CLOSE_SKIM, at)) {
+      return { consumed: CLOSE_SKIM.length, closeKind: "skim" };
+    }
+    return null;
+  },
+
+  closeMatches(activeOpen, closeKind) {
+    return activeOpen.mode === closeKind;
+  },
+
+  matchTrailingPartial(input, _suffixStart) {
+    const n = input.length;
+    let best = 0;
+    for (const lit of ALL_LITERALS) {
+      for (let len = Math.min(n, lit.length - 1); len > best; len--) {
+        const tail = input.slice(n - len);
+        if (lit.startsWith(tail)) {
+          best = len;
+          break;
+        }
+      }
+    }
+    return best;
+  },
+};

package/dist/domain/tagged-span-parser.js

@@ -0,0 +1,121 @@
+import { computeCodeSpanRegions } from "./code-span-regions.js";
+
+/**
+ * @typedef {Object} TagFamilyConfig
+ * @property {string} name
+ * @property {ReadonlyArray<string>} closeLiterals
+ * @property {(input: string, atOffset: number) => { consumed: number, spanInit: object } | null} matchOpen
+ * @property {(input: string, atOffset: number) => { consumed: number, closeKind: any } | null} matchClose
+ * @property {(activeOpen: object, closeKind: any) => boolean} closeMatches
+ * @property {(input: string, suffixStart: number) => number} matchTrailingPartial
+ * @property {(spanInit: object) => boolean} [validateOpen]
+ * @property {(spanInit: object) => void} [onRejected]
+ */
+
+/**
+ * @param {string} accumulatedText
+ * @param {ReadonlyArray<TagFamilyConfig>} families
+ * @returns {{ cleanText: string, spansByFamily: Record<string, object[]>, trailingPartialTag: boolean }}
+ */
+export function parseTaggedSpans(accumulatedText, families) {
+  const spansByFamily = {};
+  const activeOpens = new Map();
+  for (const fam of families) spansByFamily[fam.name] = [];
+
+  // Compute holdback once: each family declares how many trailing bytes look
+  // like the start of one of its tags; max wins. Held-back bytes are kept
+  // out of the parse loop so they neither become spans nor leak verbatim.
+  let holdback = 0;
+  for (const fam of families) {
+    const vote = fam.matchTrailingPartial(accumulatedText, 0);
+    if (vote > holdback) holdback = vote;
+  }
+  const scanEnd = accumulatedText.length - holdback;
+
+  // Tags quoted inside markdown code (inline backticks / fenced blocks) are
+  // literal text, not live tags — copy those regions through verbatim.
+  const codeRegions = computeCodeSpanRegions(accumulatedText);
+  let codeRegionIdx = 0;
+
+  let cleanText = "";
+  let i = 0;
+  const n = scanEnd;
+
+  outer: while (i < n) {
+    while (
+      codeRegionIdx < codeRegions.length &&
+      i >= codeRegions[codeRegionIdx][1]
+    ) {
+      codeRegionIdx += 1;
+    }
+    if (
+      codeRegionIdx < codeRegions.length &&
+      i >= codeRegions[codeRegionIdx][0] &&
+      i < codeRegions[codeRegionIdx][1]
+    ) {
+      cleanText += accumulatedText[i];
+      i += 1;
+      continue;
+    }
+    if (accumulatedText[i] === "<") {
+      // Try each family's matchClose, then matchOpen, in registration order.
+      for (const fam of families) {
+        const close = fam.matchClose(accumulatedText, i);
+        if (close) {
+          const active = activeOpens.get(fam.name);
+          if (active && fam.closeMatches(active.init, close.closeKind)) {
+            spansByFamily[fam.name].push({
+              ...active.init,
+              start: active.start,
+              end: cleanText.length,
+            });
+            activeOpens.delete(fam.name);
+          }
+          // mismatched or dangling close → drop silently
+          i += close.consumed;
+          continue outer;
+        }
+      }
+      for (const fam of families) {
+        const open = fam.matchOpen(accumulatedText, i);
+        if (open) {
+          // Latest-wins same-family: close any active span at current offset.
+          const prior = activeOpens.get(fam.name);
+          if (prior) {
+            spansByFamily[fam.name].push({
+              ...prior.init,
+              start: prior.start,
+              end: cleanText.length,
+            });
+            activeOpens.delete(fam.name);
+          }
+          const accepted = fam.validateOpen ? fam.validateOpen(open.spanInit) : true;
+          if (accepted) {
+            activeOpens.set(fam.name, { start: cleanText.length, init: open.spanInit });
+          } else if (fam.onRejected) {
+            fam.onRejected(open.spanInit);
+          }
+          i += open.consumed;
+          continue outer;
+        }
+      }
+    }
+    cleanText += accumulatedText[i];
+    i += 1;
+  }
+
+  // Unclosed spans → run to cleanText end.
+  for (const fam of families) {
+    const active = activeOpens.get(fam.name);
+    if (active) {
+      spansByFamily[fam.name].push({
+        ...active.init,
+        start: active.start,
+        end: cleanText.length,
+      });
+      activeOpens.delete(fam.name);
+    }
+  }
+
+  return { cleanText, spansByFamily, trailingPartialTag: holdback > 0 };
+}

package/dist/domain/tagged-span-strip.js

@@ -0,0 +1,38 @@
+// Syntactic strip for all tagged-span grammar families.
+// Removes well-formed openers and closers; keeps wrapped content.
+// Removes orphan halves of either. Idempotent. No allowlist enforcement.
+// Tags quoted inside markdown code (inline backticks / fenced blocks) are
+// preserved verbatim so agents can talk about the tag grammar literally.
+import { computeCodeSpanRegions } from "./code-span-regions.js";
+
+const EMOJI_OPEN_RE = /<emoji:[^<>\s]+?>/g;
+const EMOJI_CLOSE_RE = /<\/emoji>/g;
+const PACE_OPEN_RE = /<(?:dwell|skim)>/g;
+const PACE_CLOSE_RE = /<\/(?:dwell|skim)>/g;
+
+// Single alternation so one pass over the original string keeps match
+// offsets valid for the code-region exemption check.
+const ALL_TAGS_RE = new RegExp(
+  [
+    EMOJI_OPEN_RE.source,
+    EMOJI_CLOSE_RE.source,
+    PACE_OPEN_RE.source,
+    PACE_CLOSE_RE.source,
+  ].join("|"),
+  "g",
+);
+
+export function stripAllTaggedSpans(text) {
+  if (typeof text !== "string") return "";
+  if (!text) return "";
+  const codeRegions = computeCodeSpanRegions(text);
+  if (codeRegions.length === 0) {
+    return text.replace(ALL_TAGS_RE, "");
+  }
+  return text.replace(ALL_TAGS_RE, (match, offset) => {
+    for (const [start, end] of codeRegions) {
+      if (offset >= start && offset < end) return match;
+    }
+    return "";
+  });
+}

package/dist/even-ai/even-ai-endpoint.js

@@ -257,6 +257,10 @@ export function createEvenAiEndpoint(opts = {}) {
     typeof opts.emitListenInterceptRecovery === "function"
       ? opts.emitListenInterceptRecovery
       : null;
+  const emitListenInterceptBroadcast =
+    typeof opts.emitListenInterceptBroadcast === "function"
+      ? opts.emitListenInterceptBroadcast
+      : null;
   const isUpstreamConnected =
     typeof opts.isUpstreamConnected === "function"
       ? opts.isUpstreamConnected
@@ -269,6 +273,10 @@ export function createEvenAiEndpoint(opts = {}) {
     typeof opts.shouldSeedThinkingForRoute === "function"
       ? opts.shouldSeedThinkingForRoute
       : async () => false;
+  const seedFastModeForRoute =
+    typeof opts.seedFastModeForRoute === "function"
+      ? opts.seedFastModeForRoute
+      : null;
   const now =
     typeof opts.now === "function" ? opts.now : () => Date.now();
   const requestTimeoutMs = normalizePositiveInt(
@@ -599,8 +607,18 @@ export function createEvenAiEndpoint(opts = {}) {
               id: requestId,
               text: userText,
               sessionKey,
+              source: "hybrid_voice_endpoint",
             }),
           );
+          if (emitListenInterceptBroadcast) {
+            try {
+              emitListenInterceptBroadcast({ sessionKey });
+            } catch (broadcastErr) {
+              logger.warn(
+                `[evenai] listen intercept broadcast callback failed: ${broadcastErr && broadcastErr.message ? broadcastErr.message : broadcastErr}`,
+              );
+            }
+          }
           emitDebug(
             "evenai",
             "listen_intercept_dispatch_succeeded",
@@ -771,6 +789,47 @@ export function createEvenAiEndpoint(opts = {}) {
       startedAtMs,
     };
 
+    // Track the upstream runId so the disconnect handler can cancel the
+    // pending wait without having to wait for the full request timeout.
+    // `clientDisconnected` covers the pre-ack window: if the socket closes
+    // before sendMessage() resolves, activeRunId is still null so cancelRun
+    // is unreachable; we record the flag and short-circuit waitForRun once
+    // the ack arrives.
+    let activeRunId = null;
+    let clientDisconnected = false;
+    const onClientDisconnect = () => {
+      if (res.writableEnded) return;
+      clientDisconnected = true;
+      if (inFlight && inFlight.requestId === requestId) {
+        inFlight = null;
+        emitDebug(
+          "evenai",
+          "request_client_disconnect",
+          "info",
+          { sessionKey: sessionKey || undefined, runId: activeRunId },
+          () => ({
+            requestId,
+            elapsedMs: now() - startedAtMs,
+            preAck: activeRunId == null,
+          }),
+        );
+      }
+      if (activeRunId && typeof runWaiter.cancelRun === "function") {
+        try {
+          runWaiter.cancelRun(activeRunId, "client_disconnect");
+        } catch (_err) {
+          // Cancellation is best-effort: the upstream run still completes
+          // server-side because no gateway abort RPC exists.
+        }
+      }
+    };
+    // `res` emits 'close' both when the response finishes normally and when
+    // the client disconnects mid-flight. We discriminate via
+    // res.writableEnded inside the handler. (req's own 'close' is not
+    // reliable for premature client aborts in Node 22 — the socket-level
+    // close is what fires.)
+    res.once("close", onClientDisconnect);
+
     emitDebug(
       "evenai",
       "request_accepted",
@@ -802,6 +861,20 @@ export function createEvenAiEndpoint(opts = {}) {
       ) {
         sendOptions.thinking = configuredDefaultThinking;
       }
+      if (seedFastModeForRoute) {
+        try {
+          await Promise.resolve(
+            seedFastModeForRoute({ route, sessionKey, routingMode }),
+          );
+        } catch (err) {
+          // Seed failure must never block the send — the turn just runs
+          // without fast mode.
+          emitDebug("evenai", "fast_mode_seed_failed", "warn", { sessionKey }, () => ({
+            requestId,
+            message: err && err.message ? err.message : String(err),
+          }));
+        }
+      }
       const ack = await promiseWithTimeout(
         gatewayBridge.sendMessage(
           userText,
@@ -815,6 +888,7 @@ export function createEvenAiEndpoint(opts = {}) {
       if (!runId) {
         throw new Error("Even AI upstream ack was missing a runId.");
       }
+      activeRunId = runId;
       if (trimString(ack && ack.status) && trimString(ack.status) !== "accepted") {
         throw new Error(
           trimString(ack && ack.error) || `Even AI upstream returned ${ack.status}.`,
@@ -832,6 +906,20 @@ export function createEvenAiEndpoint(opts = {}) {
         }),
       );
 
+      if (clientDisconnected) {
+        emitDebug(
+          "evenai",
+          "request_wait_skipped_after_disconnect",
+          "info",
+          { sessionKey, runId },
+          () => ({
+            requestId,
+            elapsedMs: now() - startedAtMs,
+          }),
+        );
+        return true;
+      }
+
       const remainingTimeoutMs = Math.max(1, requestTimeoutMs - (now() - startedAtMs));
       const assistantText = await runWaiter.waitForRun({
         runId,
@@ -889,6 +977,9 @@ export function createEvenAiEndpoint(opts = {}) {
       if (inFlight && inFlight.requestId === requestId) {
         inFlight = null;
       }
+      if (typeof res.removeListener === "function") {
+        res.removeListener("close", onClientDisconnect);
+      }
     }
   }
 

package/dist/even-ai/even-ai-run-waiter.js

@@ -242,6 +242,20 @@ export function createEvenAiRunWaiter(opts = {}) {
       });
     },
 
+    cancelRun(runId, reason) {
+      const normalized = normalizeRunId(runId);
+      if (!normalized) return false;
+      const message =
+        typeof reason === "string" && reason.length > 0
+          ? `Even AI run cancelled: ${reason}.`
+          : "Even AI run cancelled.";
+      return rejectRun(
+        normalized,
+        createRunWaiterError("evenai_cancelled", message, { reason: reason || null }),
+        "run_wait_cancelled",
+      );
+    },
+
     close() {
       if (typeof offMessage === "function") offMessage();
       if (typeof offActivity === "function") offActivity();

package/dist/even-ai/even-ai-settings-store.js

@@ -134,12 +134,19 @@ function isStoredSnapshotCanonical(value, snapshot) {
   if (normalizeEvenAiListenEnabled(value.listenEnabled) !== snapshot.listenEnabled) {
     return false;
   }
+  if (normalizeEvenAiDefaultFastMode(value.defaultFastMode) !== snapshot.defaultFastMode) {
+    return false;
+  }
   if (!Array.isArray(value.trackedThrowawayKeys)) {
     return snapshot.trackedThrowawayKeys.length === 0;
   }
   return arraysEqual(value.trackedThrowawayKeys, snapshot.trackedThrowawayKeys);
 }
 
+export function normalizeEvenAiDefaultFastMode(value) {
+  return value === true;
+}
+
 export function normalizeEvenAiSettingsSnapshot(value = {}) {
   return {
     routingMode: normalizeEvenAiRoutingMode(value.routingMode),
@@ -147,6 +154,7 @@ export function normalizeEvenAiSettingsSnapshot(value = {}) {
     defaultModel: normalizeEvenAiDefaultModel(value.defaultModel),
     defaultThinking: normalizeEvenAiDefaultThinking(value.defaultThinking),
     listenEnabled: normalizeEvenAiListenEnabled(value.listenEnabled),
+    defaultFastMode: normalizeEvenAiDefaultFastMode(value.defaultFastMode),
     trackedThrowawayKeys: normalizeTrackedThrowawayKeys(value.trackedThrowawayKeys),
   };
 }
@@ -180,6 +188,7 @@ export function createEvenAiSettingsStore(opts = {}) {
           systemPromptChars: snapshot.systemPrompt.length,
           defaultModel: snapshot.defaultModel,
           defaultThinking: snapshot.defaultThinking,
+          defaultFastMode: snapshot.defaultFastMode,
           listenEnabled: snapshot.listenEnabled,
           trackedThrowawayKeyCount: snapshot.trackedThrowawayKeys.length,
         }),
@@ -213,6 +222,7 @@ export function createEvenAiSettingsStore(opts = {}) {
           systemPromptChars: snapshot.systemPrompt.length,
           defaultModel: snapshot.defaultModel,
           defaultThinking: snapshot.defaultThinking,
+          defaultFastMode: snapshot.defaultFastMode,
           listenEnabled: snapshot.listenEnabled,
           trackedThrowawayKeyCount: snapshot.trackedThrowawayKeys.length,
         }),
@@ -266,6 +276,7 @@ export function createEvenAiSettingsStore(opts = {}) {
           systemPromptChars: loaded.systemPrompt.length,
           defaultModel: loaded.defaultModel,
           defaultThinking: loaded.defaultThinking,
+          defaultFastMode: loaded.defaultFastMode,
           listenEnabled: loaded.listenEnabled,
           trackedThrowawayKeyCount: loaded.trackedThrowawayKeys.length,
         }),
@@ -350,6 +361,9 @@ export function createEvenAiSettingsStore(opts = {}) {
         listenEnabled: hasOwn(patch, "listenEnabled")
           ? normalizeEvenAiListenEnabled(patch.listenEnabled)
           : snapshot.listenEnabled,
+        defaultFastMode: hasOwn(patch, "defaultFastMode")
+          ? normalizeEvenAiDefaultFastMode(patch.defaultFastMode)
+          : snapshot.defaultFastMode,
         trackedThrowawayKeys: [...snapshot.trackedThrowawayKeys],
       };
       snapshot = next;