mixdog 0.9.83 → 0.9.85

package/src/standalone/memory-runtime-proxy.mjs

@@ -103,10 +103,52 @@ function isMemoryReadOnlyToolCall(name, args = {}) {
   return false;
 }
 
-function requestJson({ port, method = 'GET', path = '/', body = null, timeoutMs = 10_000, headers = {} }) {
-  return new Promise((resolvePromise, reject) => {
+function memoryAbortError(reason) {
+  if (reason instanceof Error) return reason;
+  const error = new Error(typeof reason === 'string' && reason ? reason : 'memory proxy request aborted');
+  error.name = 'AbortError';
+  error.code = 'ABORT_ERR';
+  return error;
+}
+
+export function requestJson({
+  port,
+  method = 'GET',
+  path = '/',
+  body = null,
+  timeoutMs = 10_000,
+  headers = {},
+  signal = null,
+}) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    let settled = false;
+    let req = null;
+    const cleanup = () => {
+      try { signal?.removeEventListener?.('abort', onAbort); } catch {}
+    };
+    const resolve = (value) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolvePromise(value);
+    };
+    const reject = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      rejectPromise(error);
+    };
+    const onAbort = () => {
+      const error = memoryAbortError(signal?.reason);
+      if (req) req.destroy(error);
+      else reject(error);
+    };
+    if (signal?.aborted) {
+      reject(memoryAbortError(signal.reason));
+      return;
+    }
     const payload = body == null ? null : JSON.stringify(body);
-    const req = http.request({
+    req = http.request({
       hostname: '127.0.0.1',
       port,
       path,
@@ -135,14 +177,19 @@ function requestJson({ port, method = 'GET', path = '/', body = null, timeoutMs
           reject(error);
           return;
         }
-        resolvePromise(parsed ?? { raw: data });
+        resolve(parsed ?? { raw: data });
       });
+      res.on('error', reject);
     });
     req.on('error', reject);
     req.on('timeout', () => {
-      req.destroy();
-      reject(new Error(`memory proxy request timed out: ${method} ${path}`));
+      req.destroy(new Error(`memory proxy request timed out: ${method} ${path}`));
     });
+    try { signal?.addEventListener?.('abort', onAbort, { once: true }); } catch {}
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
     if (payload) req.write(payload);
     req.end();
   });
@@ -496,26 +543,54 @@ export function createStandaloneMemoryRuntime({
     return { running: true, port, mode: 'http-proxy' };
   }
 
-  async function handleToolCall(name, args = {}) {
+  async function handleToolCall(name, args = {}, signalOrOptions = null) {
+    const signal = signalOrOptions?.signal || signalOrOptions || null;
     const readOnlyRpc = isMemoryReadOnlyToolCall(name, args);
     const callId = `mem_${process.pid}_${nextCallId++}`;
-    return await withTransientMemoryRpcRetry(async () => {
-      await start();
-      let port = portCache || await findLivePort({ allowStarting: true });
-      if (!port) throw new Error('memory runtime is not available');
-      // ensureClientRegistered may respawn onto a fresh daemon/port; target the
-      // port it hands back so the RPC and registration always hit the same one.
-      port = await ensureClientRegistered(port);
-      if (!port) throw new Error('memory runtime is not available');
-      return await requestJson({
-        port,
+    let activePort = null;
+    let rpcStarted = false;
+    const throwIfAborted = () => {
+      if (signal?.aborted) throw memoryAbortError(signal.reason);
+    };
+    const cancelRemote = () => {
+      if (!activePort || !rpcStarted) return;
+      void requestJson({
+        port: activePort,
         method: 'POST',
-        path: '/api/tool',
-        body: { name, arguments: args || {} },
-        timeoutMs: Math.max(1000, Number(process.env.MIXDOG_MEMORY_TOOL_TIMEOUT_MS) || 180_000),
-        headers: { 'X-Mixdog-Call-Id': callId },
-      });
-    }, { readOnlyRpc });
+        path: '/api/cancel',
+        body: { callId },
+        timeoutMs: 1500,
+      }).catch(() => {});
+    };
+    throwIfAborted();
+    try { signal?.addEventListener?.('abort', cancelRemote, { once: true }); } catch {}
+    try {
+      return await withTransientMemoryRpcRetry(async () => {
+        throwIfAborted();
+        await start();
+        throwIfAborted();
+        let port = portCache || await findLivePort({ allowStarting: true });
+        if (!port) throw new Error('memory runtime is not available');
+        // ensureClientRegistered may respawn onto a fresh daemon/port; target the
+        // port it hands back so the RPC and registration always hit the same one.
+        port = await ensureClientRegistered(port);
+        if (!port) throw new Error('memory runtime is not available');
+        activePort = port;
+        throwIfAborted();
+        rpcStarted = true;
+        return await requestJson({
+          port,
+          method: 'POST',
+          path: '/api/tool',
+          body: { name, arguments: args || {} },
+          timeoutMs: Math.max(1000, Number(process.env.MIXDOG_MEMORY_TOOL_TIMEOUT_MS) || 180_000),
+          headers: { 'X-Mixdog-Call-Id': callId },
+          signal,
+        });
+      }, { readOnlyRpc });
+    } finally {
+      try { signal?.removeEventListener?.('abort', cancelRemote); } catch {}
+    }
   }
 
   async function buildSessionCoreMemoryPayload(sessionCwd) {

package/src/tui/app/slash-dispatch.mjs

@@ -9,6 +9,15 @@
  * defined later in the App factory zone are passed as lazy getters so their
  * live binding is used at call time.
  */
+import { presentErrorText } from '../../runtime/shared/err-text.mjs';
+
+export function compactFailureNotice(error) {
+  if (error == null || String(error).trim() === '') return 'Compact failed.';
+  const reason = presentErrorText(error, { surface: 'compact', max: 320 });
+  if (!reason || reason === 'Unknown error') return 'Compact failed.';
+  return /^compact(?:ion)? failed\b/i.test(reason) ? reason : `Compact failed: ${reason}`;
+}
+
 export function createSlashDispatch({
   state,
   store,
@@ -179,24 +188,21 @@ export function createSlashDispatch({
         }
         return true;
       }
-      case 'effort':
-        if (state.busy) {
-          store.pushNotice('wait for the current turn to finish before /effort', 'warn');
-          return false;
-        }
+      case 'effort': {
+        // A running turn no longer blocks the switch: the in-flight turn keeps
+        // the effort it started with, and the new level applies from the next
+        // turn. Same for /fast below.
+        const pendingTurn = state.busy ? ' (applies from the next turn)' : '';
         if (!arg) {
           openEffortPicker();
           return true;
         }
         void store.setEffort(arg)
-          .then(result => store.pushNotice(result ? `Effort set to ${result}` : 'Effort switch is already running.', result ? 'info' : 'warn'))
+          .then(result => store.pushNotice(result ? `Effort set to ${result}${pendingTurn}` : 'Effort switch is already running.', result ? 'info' : 'warn'))
           .catch((e) => store.pushNotice(`Couldn’t switch effort: ${e?.message || e}`, 'error'));
         return true;
+      }
       case 'fast': {
-        if (state.busy) {
-          store.pushNotice('wait for the current turn to finish before /fast', 'warn');
-          return false;
-        }
         const value = String(arg || '').trim().toLowerCase();
         const setTo = value
           ? ['1', 'true', 'yes', 'on', 'enable', 'enabled'].includes(value)
@@ -216,7 +222,11 @@ export function createSlashDispatch({
               store.pushNotice('Fast mode switch is already running.', 'warn');
               return;
             }
-            store.pushNotice(`Fast mode ${enabled ? 'on' : 'off'} for ${state.provider}/${state.model}`, 'info');
+            store.pushNotice(
+              `Fast mode ${enabled ? 'on' : 'off'} for ${state.provider}/${state.model}`
+              + (state.busy ? ' (applies from the next turn)' : ''),
+              'info',
+            );
           })
           .catch((e) => store.pushNotice(`Couldn’t update fast mode: ${e?.message || e}`, 'error'));
         return true;
@@ -345,7 +355,7 @@ export function createSlashDispatch({
               return;
             }
             if (r.error) {
-              store.pushNotice('Compact failed.', 'error');
+              store.pushNotice(compactFailureNotice(r.error), 'error');
               return;
             }
             if (r.changed === false && r.reason) {
@@ -358,7 +368,7 @@ export function createSlashDispatch({
             }
             store.pushNotice('Compact done.', 'info');
           })
-          .catch(() => store.pushNotice('Compact failed.', 'error'));
+          .catch((error) => store.pushNotice(compactFailureNotice(error), 'error'));
         return true;
       case 'resume':
         if (state.busy) {

package/src/tui/app/theme-effort-pickers.mjs

@@ -140,8 +140,10 @@ export function createThemeEffortPickers({
       items: pickerItems,
       onSelect: (value) => {
         setPicker(null);
+        // Mid-turn picks are allowed; the running turn keeps its own effort.
+        const pendingTurn = state.busy ? ' (applies from the next turn)' : '';
         void store.setEffort(value)
-          .then(result => store.pushNotice(result ? `Effort set to ${result}` : 'Effort switch is already running.', result ? 'info' : 'warn'))
+          .then(result => store.pushNotice(result ? `Effort set to ${result}${pendingTurn}` : 'Effort switch is already running.', result ? 'info' : 'warn'))
           .catch((e) => store.pushNotice(`Couldn’t switch effort: ${e?.message || e}`, 'error'));
       },
       onCancel: () => {

package/src/tui/dist/index.mjs

@@ -454,6 +454,15 @@ import {
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync3
 } from "fs";
+import {
+  link as linkAsync,
+  mkdir as mkdirAsync,
+  open as openAsync,
+  readFile as readFileAsync2,
+  rename as renameAsync,
+  unlink as unlinkAsync,
+  writeFile as writeFileAsync
+} from "node:fs/promises";
 import { dirname as dirname4, basename as basename4, join as join4 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 import { execFile as execFile2, execFileSync } from "child_process";
@@ -496,6 +505,22 @@ function renameWithRetrySync(src, dst, opts = {}) {
   }
   throw lastErr;
 }
+async function renameWithRetry(src, dst, opts = {}) {
+  const backoffs = Array.isArray(opts.backoffs) && opts.backoffs.length > 0 ? opts.backoffs : DEFAULT_BACKOFFS_MS;
+  let lastErr = null;
+  for (let attempt = 0; attempt <= backoffs.length; attempt++) {
+    try {
+      await renameAsync(src, dst);
+      return true;
+    } catch (err) {
+      lastErr = err;
+      if (!RETRY_CODES.has(err?.code) || attempt >= backoffs.length) break;
+      const jitter = Math.floor(Math.random() * Math.min(50, Math.max(1, backoffs[attempt])));
+      await _asyncSleep(backoffs[attempt] + jitter);
+    }
+  }
+  throw lastErr;
+}
 function withFileLockSync(lockPath, fn, opts = {}) {
   const timeoutMs = Number.isFinite(opts.timeoutMs) ? opts.timeoutMs : DEFAULT_LOCK_TIMEOUT_MS;
   const staleMs = Number.isFinite(opts.staleMs) ? opts.staleMs : 3e4;
@@ -893,55 +918,55 @@ function writeJsonAtomicSync(filePath, value, opts = {}) {
 async function writeFileAtomicAsync(filePath, data, opts = {}) {
   const run = async () => {
     const dir = dirname4(filePath);
-    mkdirSync3(dir, { recursive: true });
+    await mkdirAsync(dir, { recursive: true });
     const tmp = join4(dir, `.${basename4(filePath)}.${randomBytes2(12).toString("hex")}.tmp`);
     try {
       const writeOpts = { encoding: opts.encoding || "utf8", flag: "wx", mode: opts.mode !== void 0 ? opts.mode : 384 };
-      writeFileSync3(tmp, data, writeOpts);
+      await writeFileAsync(tmp, data, writeOpts);
       if (opts.secret === true) await _enforceOwnerOnlyAclWin32Async(tmp);
       if (opts.fsync !== false) {
         let fd = null;
         try {
-          fd = openSync(tmp, "r");
-          fsyncSync(fd);
+          fd = await openAsync(tmp, "r");
+          await fd.sync();
         } catch (err) {
           if (!["EPERM", "ENOTSUP", "EINVAL"].includes(err?.code)) throw err;
         } finally {
           try {
-            if (fd !== null) closeSync(fd);
+            if (fd !== null) await fd.close();
           } catch {
           }
         }
       }
       if (opts.createOnly === true) {
         try {
-          linkSync(tmp, filePath);
+          await linkAsync(tmp, filePath);
         } catch (err) {
           try {
-            unlinkSync2(tmp);
+            await unlinkAsync(tmp);
           } catch {
           }
           if (err?.code === "EEXIST") return false;
           throw err;
         }
         try {
-          unlinkSync2(tmp);
+          await unlinkAsync(tmp);
         } catch {
         }
       } else {
-        renameWithRetrySync(tmp, filePath, opts);
+        await renameWithRetry(tmp, filePath, opts);
       }
       if (opts.secret === true) await _enforceOwnerOnlyAclWin32Async(filePath);
       if (opts.fsyncDir === true) {
         let dfd = null;
         try {
-          dfd = openSync(dir, "r");
-          fsyncSync(dfd);
+          dfd = await openAsync(dir, "r");
+          await dfd.sync();
         } catch (err) {
           if (!["EPERM", "ENOTSUP", "EINVAL", "EACCES"].includes(err?.code)) throw err;
         } finally {
           try {
-            if (dfd !== null) closeSync(dfd);
+            if (dfd !== null) await dfd.close();
           } catch {
           }
         }
@@ -949,7 +974,7 @@ async function writeFileAtomicAsync(filePath, data, opts = {}) {
       return true;
     } catch (err) {
       try {
-        if (existsSync4(tmp)) unlinkSync2(tmp);
+        await unlinkAsync(tmp);
       } catch {
       }
       throw err;
@@ -965,16 +990,16 @@ function writeJsonAtomicAsync(filePath, value, opts = {}) {
 }
 async function updateJsonAtomic(filePath, mutator, opts = {}) {
   const { lock: _lock, ...writeOpts } = opts;
-  return withFileLock(`${filePath}.lock`, () => {
+  return withFileLock(`${filePath}.lock`, async () => {
     let cur = null;
     try {
-      cur = JSON.parse(readFileSync3(filePath, "utf8"));
+      cur = JSON.parse(await readFileAsync2(filePath, "utf8"));
     } catch {
       cur = null;
     }
     const next = mutator(cur);
     if (next === void 0) return cur;
-    writeJsonAtomicSync(filePath, next, { ...writeOpts, lock: false });
+    await writeJsonAtomicAsync(filePath, next, { ...writeOpts, lock: false });
     return next;
   }, opts);
 }
@@ -11989,6 +12014,7 @@ function presentErrorText(error, options = {}) {
     return "Context too large.";
   }
   if (/\bcompact(?:ion)?\b.*\b(?:failed|error|overflow)\b|\b(?:failed|error)\b.*\bcompact(?:ion)?\b/i.test(text)) {
+    if (String(surface).toLowerCase().includes("compact")) return capText(text, max);
     return "Compact failed.";
   }
   const quotaRetry = /retryAfter=([^\s:]+)/i.exec(text);
@@ -15657,7 +15683,8 @@ function createThemeEffortPickers({
       items: pickerItems,
       onSelect: (value) => {
         setPicker(null);
-        void store.setEffort(value).then((result) => store.pushNotice(result ? `Effort set to ${result}` : "Effort switch is already running.", result ? "info" : "warn")).catch((e) => store.pushNotice(`Couldn\u2019t switch effort: ${e?.message || e}`, "error"));
+        const pendingTurn = state.busy ? " (applies from the next turn)" : "";
+        void store.setEffort(value).then((result) => store.pushNotice(result ? `Effort set to ${result}${pendingTurn}` : "Effort switch is already running.", result ? "info" : "warn")).catch((e) => store.pushNotice(`Couldn\u2019t switch effort: ${e?.message || e}`, "error"));
       },
       onCancel: () => {
         setPicker(null);
@@ -19206,6 +19233,12 @@ function createSettingsPicker({
 }
 
 // src/tui/app/slash-dispatch.mjs
+function compactFailureNotice(error) {
+  if (error == null || String(error).trim() === "") return "Compact failed.";
+  const reason = presentErrorText(error, { surface: "compact", max: 320 });
+  if (!reason || reason === "Unknown error") return "Compact failed.";
+  return /^compact(?:ion)? failed\b/i.test(reason) ? reason : `Compact failed: ${reason}`;
+}
 function createSlashDispatch({
   state,
   store,
@@ -19365,22 +19398,16 @@ function createSlashDispatch({
         }
         return true;
       }
-      case "effort":
-        if (state.busy) {
-          store.pushNotice("wait for the current turn to finish before /effort", "warn");
-          return false;
-        }
+      case "effort": {
+        const pendingTurn = state.busy ? " (applies from the next turn)" : "";
         if (!arg) {
           openEffortPicker();
           return true;
         }
-        void store.setEffort(arg).then((result) => store.pushNotice(result ? `Effort set to ${result}` : "Effort switch is already running.", result ? "info" : "warn")).catch((e) => store.pushNotice(`Couldn\u2019t switch effort: ${e?.message || e}`, "error"));
+        void store.setEffort(arg).then((result) => store.pushNotice(result ? `Effort set to ${result}${pendingTurn}` : "Effort switch is already running.", result ? "info" : "warn")).catch((e) => store.pushNotice(`Couldn\u2019t switch effort: ${e?.message || e}`, "error"));
         return true;
+      }
       case "fast": {
-        if (state.busy) {
-          store.pushNotice("wait for the current turn to finish before /fast", "warn");
-          return false;
-        }
         const value = String(arg || "").trim().toLowerCase();
         const setTo = value ? ["1", "true", "yes", "on", "enable", "enabled"].includes(value) ? true : ["0", "false", "no", "off", "disable", "disabled"].includes(value) ? false : null : void 0;
         if (setTo === null) {
@@ -19393,7 +19420,10 @@ function createSlashDispatch({
             store.pushNotice("Fast mode switch is already running.", "warn");
             return;
           }
-          store.pushNotice(`Fast mode ${enabled ? "on" : "off"} for ${state.provider}/${state.model}`, "info");
+          store.pushNotice(
+            `Fast mode ${enabled ? "on" : "off"} for ${state.provider}/${state.model}` + (state.busy ? " (applies from the next turn)" : ""),
+            "info"
+          );
         }).catch((e) => store.pushNotice(`Couldn\u2019t update fast mode: ${e?.message || e}`, "error"));
         return true;
       }
@@ -19516,7 +19546,7 @@ function createSlashDispatch({
             return;
           }
           if (r.error) {
-            store.pushNotice("Compact failed.", "error");
+            store.pushNotice(compactFailureNotice(r.error), "error");
             return;
           }
           if (r.changed === false && r.reason) {
@@ -19528,7 +19558,7 @@ function createSlashDispatch({
             return;
           }
           store.pushNotice("Compact done.", "info");
-        }).catch(() => store.pushNotice("Compact failed.", "error"));
+        }).catch((error) => store.pushNotice(compactFailureNotice(error), "error"));
         return true;
       case "resume":
         if (state.busy) {
@@ -26155,8 +26185,10 @@ function createSessionFlow(bag) {
     const mode = options.mode || "prompt";
     const priority = options.priority || defaultQueuePriority(mode);
     const displayText = promptDisplayText(text, options);
+    const submittedAt = Number(options.submittedAt);
     return {
       id: options.id || nextId2(),
+      submittedAt: Number.isFinite(submittedAt) && submittedAt > 0 ? Math.round(submittedAt) : Date.now(),
       text: displayText,
       content: text,
       pastedImages: options.pastedImages && typeof options.pastedImages === "object" ? options.pastedImages : null,
@@ -26350,6 +26382,8 @@ function createSessionFlow(bag) {
       set({ queued: [...getState().queued, entry] });
       if (isQueuedEntryEditable(entry)) flushEmitImmediate?.();
     }
+    const queueAgeMs = Math.max(0, Date.now() - Number(entry.submittedAt || Date.now()));
+    tuiDebug2(`prompt-queued id=${String(entry.id)} busy=${getState().busy ? 1 : 0} ageMs=${queueAgeMs}`);
     if (getState().busy) tuiDebug2(`busy-queue enqueue mode=${entry.mode} pending=${pending.length}`);
     void drain();
     return true;
@@ -26368,19 +26402,25 @@ function createSessionFlow(bag) {
       if (batch.length === 0) break;
       for (const entry of batch) {
         const content = entry.content;
+        const steeringMeta = {
+          id: entry.id,
+          submittedAt: entry.submittedAt,
+          ...Array.isArray(entry.images) && entry.images.length ? { images: entry.images } : {}
+        };
         if (entry.suppressDisplay) {
           if (Array.isArray(content) ? content.length > 0 : String(content ?? "").trim().length > 0) {
-            out.push({ text: STEERING_SUPPRESSED_DISPLAY, content });
+            out.push({ ...steeringMeta, text: STEERING_SUPPRESSED_DISPLAY, content });
           }
           continue;
         }
-        const value = typeof content === "string" ? content.trim() : { text: String(entry.text || "").trim(), content };
-        if (typeof value === "string") {
-          if (value.length > 0) out.push(value);
-        } else if (Array.isArray(value.content)) {
-          if (value.content.length > 0) out.push(value);
-        } else if (String(value.content ?? "").trim().length > 0) {
-          out.push(value);
+        const displayText = String(entry.text || "").trim();
+        if (typeof content === "string") {
+          const value = content.trim();
+          if (value.length > 0) out.push({ ...steeringMeta, text: displayText || value, content: value });
+        } else if (Array.isArray(content)) {
+          if (content.length > 0) out.push({ ...steeringMeta, text: displayText, content });
+        } else if (String(content ?? "").trim().length > 0) {
+          out.push({ ...steeringMeta, text: displayText, content });
         }
       }
       commitSteeringQueueEntries(batch);
@@ -26779,8 +26819,11 @@ function createRunTurn(bag) {
     drain,
     drainPendingSteering
   } = bag;
-  const updateStreamingTail = updateStreamingTailFromStore || ((id, patch = {}) => {
-    set({ streamingTail: { ...getState().streamingTail || {}, ...patch, kind: "assistant", id, streaming: true } });
+  const updateStreamingTail = updateStreamingTailFromStore || ((id, patch = {}, extra = {}) => {
+    set({
+      streamingTail: { ...getState().streamingTail || {}, ...patch, kind: "assistant", id, streaming: true },
+      ...extra
+    });
     return true;
   });
   const settleStreamingTail = settleStreamingTailFromStore || ((id, patch = {}) => {
@@ -27293,7 +27336,12 @@ function createRunTurn(bag) {
           patch.spinner = { ...getState().spinner, responseLength: responseLengthVal, thinking: false, thinkingLastEndedAt: _pendingThinkingLastEndedAt || getState().spinner.thinkingLastEndedAt, mode: compactingActive ? "compacting" : "responding" };
           _publishedThinkingActive = false;
         }
-        if (Object.keys(patch).length > 0) set(patch);
+        if (patch.streamingTail) {
+          const { streamingTail, ...extra } = patch;
+          updateStreamingTail(streamingTail.id, streamingTail, extra);
+        } else if (Object.keys(patch).length > 0) {
+          set(patch);
+        }
         _pendingThinkingLastEndedAt = 0;
       }
       if (_pendingThinkFlush) {
@@ -27384,7 +27432,7 @@ function createRunTurn(bag) {
         onStreamDelta: () => {
           markTurnProgress("stream-delta");
         },
-        onSteerMessage: (text) => {
+        onSteerMessage: (text, steeringMeta = {}) => {
           if (!markTurnProgress("steer-message")) return;
           if (text === STEERING_SUPPRESSED_DISPLAY) return;
           flushStreamBatch();
@@ -27393,7 +27441,13 @@ function createRunTurn(bag) {
           const value = String(text || "").trim();
           if (value) {
             clearAggregateContinuation();
-            pushUserOrSyntheticItem(value, void 0, "injected");
+            const steeringIds = Array.isArray(steeringMeta?.ids) ? steeringMeta.ids.filter((id) => id !== void 0 && id !== null) : [];
+            pushUserOrSyntheticItem(
+              value,
+              steeringIds[0],
+              "injected",
+              Array.isArray(steeringMeta?.images) && steeringMeta.images.length ? { images: steeringMeta.images } : null
+            );
           }
         },
         onToolCall: async (_iter, calls) => {
@@ -27593,17 +27647,11 @@ function createRunTurn(bag) {
           _emittedVisibleText = "";
           if (currentAssistantId) {
             if (currentAssistantText) {
-              set({
-                streamingTail: {
-                  ...getState().streamingTail || {},
-                  kind: "assistant",
-                  id: currentAssistantId,
-                  text: currentAssistantText,
-                  streaming: true,
-                  at: getState().streamingTail?.at || Date.now(),
-                  ...turnRouteMeta
-                }
-              });
+              updateStreamingTail(currentAssistantId, {
+                text: currentAssistantText,
+                at: getState().streamingTail?.at || Date.now(),
+                ...turnRouteMeta
+              }, {}, { resetText: true });
             } else {
               clearStreamingTail(currentAssistantId);
               currentAssistantId = null;
@@ -29992,7 +30040,7 @@ function createLiveShare({
   const applyViewerFrame = (frame, socket) => {
     if (frame.t === "full") {
       viewerApply.replaceItems(Array.isArray(frame.items) ? frame.items : []);
-      if (frame.tail) viewerApply.updateStreamingTail(frame.tail.id, frame.tail);
+      if (frame.tail) viewerApply.updateStreamingTail(frame.tail.id, frame.tail, {}, { resetText: true });
       viewerApply.set({ spinner: frame.spinner || null });
       applyLiveState(frame.live);
       return;
@@ -30016,7 +30064,7 @@ function createLiveShare({
         requestSync(socket);
       }
     } else if ("tail" in frame) {
-      if (frame.tail) viewerApply.updateStreamingTail(frame.tail.id, frame.tail);
+      if (frame.tail) viewerApply.updateStreamingTail(frame.tail.id, frame.tail, {}, { resetText: true });
       else viewerApply.clearStreamingTail();
     }
     if ("spinner" in frame) viewerApply.set({ spinner: frame.spinner || null });
@@ -30937,10 +30985,20 @@ async function createEngineSession({
       ...extra
     });
   };
-  const updateStreamingTail = (id, patch = {}, extra = {}) => {
+  const streamingTailTextEpochKey = /* @__PURE__ */ Symbol.for("mixdog.streaming-tail-text-epoch");
+  let streamingTailTextEpoch = 0;
+  const updateStreamingTail = (id, patch = {}, extra = {}, { resetText = false } = {}) => {
     if (id == null) return false;
     const current = state.streamingTail?.id === id ? state.streamingTail : { kind: "assistant", id, text: "", streaming: true };
     const next = { ...current, ...patch, kind: "assistant", id, streaming: true };
+    const currentTextEpoch = current[streamingTailTextEpochKey];
+    const textEpoch = !resetText && Number.isSafeInteger(currentTextEpoch) ? currentTextEpoch : ++streamingTailTextEpoch;
+    Object.defineProperty(next, streamingTailTextEpochKey, {
+      value: textEpoch,
+      enumerable: false,
+      configurable: false,
+      writable: false
+    });
     let changed = state.streamingTail !== current;
     if (!changed) {
       for (const [key, value] of Object.entries(next)) {

package/src/tui/engine/live-share.mjs

@@ -446,7 +446,7 @@ export function createLiveShare({
   const applyViewerFrame = (frame, socket) => {
     if (frame.t === 'full') {
       viewerApply.replaceItems(Array.isArray(frame.items) ? frame.items : []);
-      if (frame.tail) viewerApply.updateStreamingTail(frame.tail.id, frame.tail);
+      if (frame.tail) viewerApply.updateStreamingTail(frame.tail.id, frame.tail, {}, { resetText: true });
       viewerApply.set({ spinner: frame.spinner || null });
       applyLiveState(frame.live);
       return;
@@ -472,7 +472,7 @@ export function createLiveShare({
         requestSync(socket);
       }
     } else if ('tail' in frame) {
-      if (frame.tail) viewerApply.updateStreamingTail(frame.tail.id, frame.tail);
+      if (frame.tail) viewerApply.updateStreamingTail(frame.tail.id, frame.tail, {}, { resetText: true });
       else viewerApply.clearStreamingTail();
     }
     if ('spinner' in frame) viewerApply.set({ spinner: frame.spinner || null });