mixdog 0.9.65 → 0.9.67

package/src/session-runtime/channel-config-api.mjs

@@ -2,6 +2,7 @@ import {
   channelSetup,
   deleteSchedule,
   deleteWebhook,
+  getWebhookSecret,
   setChannelAsync,
   saveSchedule,
   saveWebhook,
@@ -68,6 +69,10 @@ export function createChannelConfigApi({ flushBackendSave, channels, reloadChann
       reloadChannelsSoon();
       return result;
     },
+    // Read-only secret fetch for the webhook editor; no worker reload.
+    async getWebhookSecret(name) {
+      return getWebhookSecret(name);
+    },
     async runScheduleNow(name) {
       const id = String(name || '').trim();
       const schedule = await getSchedule(id);

package/src/session-runtime/context-status.mjs

@@ -5,6 +5,7 @@ import {
   providerTokenCalibration,
   resolveSessionCompactPolicy,
   summarizeContextMessages,
+  summarizeContextMessagesAtRevision,
   toolSchemaSignature,
 } from '../runtime/agent/orchestrator/session/context-utils.mjs';
 import { SUMMARY_PREFIX } from '../runtime/agent/orchestrator/session/compact.mjs';
@@ -234,7 +235,7 @@ export function createContextStatus({
       return contextStatusCacheValue;
     }
 
-    const messageSummary = summarizeContextMessages(messages);
+    const messageSummary = summarizeContextMessagesAtRevision(messages, messagesRevision);
     const toolSchemaTokens = estimateToolSchemaTokens(requestTools);
     const toolSchemaBreakdown = estimateToolSchemaBreakdown(requestTools);
     const requestReserveTokens = estimateRequestReserveTokens(requestTools);

package/src/session-runtime/lifecycle-api.mjs

@@ -89,6 +89,11 @@ export function createLifecycleApi(deps) {
     return {
       id: s.id,
       updatedAt: s.updatedAt,
+      // Conversation-activity timestamp for Recent ordering. Without this the
+      // desktop falls back to updatedAt, which detach/resume bookkeeping
+      // bumps — clicking a session reshuffled the sidebar (the row just left
+      // jumped to the top).
+      lastUsedAt: Number(s.lastUsedAt) || 0,
       cwd: s.cwd || '',
       model: s.model,
       provider: s.provider,

package/src/session-runtime/prewarm.mjs

@@ -15,6 +15,7 @@ export function createPrewarmSchedulers({
   getSession,
   isRemoteEnabled,
   channelsEnabled,
+  hasActiveAutomation,
   getCodeGraphModule,
   createCurrentSession,
   channels,
@@ -111,25 +112,30 @@ export function createPrewarmSchedulers({
       bootProfile('channels:start-skipped');
       return;
     }
-    if (!channelsEnabled()) {
-      bootProfile('channels:start-disabled');
-      return;
-    }
     if (timers.channelStartTimer || state.channelStartPromise || isCloseRequested()) return;
     bootProfile('channels:start-scheduled', { delayMs });
-    timers.channelStartTimer = setTimeout(() => {
+    timers.channelStartTimer = setTimeout(() => void (async () => {
       timers.channelStartTimer = null;
       if (isCloseRequested()) return;
+      // Channels-module and remote toggles gate MESSAGING; automation
+      // (enabled schedules/webhooks) keeps the worker boot alive — its
+      // backend runs headless when messaging is off or unconfigured.
+      const automation = await hasActiveAutomation().catch(() => false);
+      if (!channelsEnabled() && !automation) {
+        bootProfile('channels:start-disabled');
+        return;
+      }
       // A deferred start may straddle a stopRemote(); re-check before booting so
       // a turned-off session neither starts channels nor keeps rescheduling.
-      if (!isRemoteEnabled()) return;
+      if (!isRemoteEnabled() && !automation) return;
+      if (isCloseRequested()) return;
       if (getActiveTurnCount() > 0 || getSessionCreatePromise()) {
         bootProfile('channels:start-deferred', { reason: getActiveTurnCount() > 0 ? 'turn-active' : 'session-create' });
         scheduleChannelStart(backgroundBusyRetryMs);
         return;
       }
       void invokeChannelStart();
-    }, delayMs);
+    })(), delayMs);
     timers.channelStartTimer.unref?.();
   }
 

package/src/session-runtime/provider-request-tools.mjs

@@ -2,6 +2,7 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 
 const requestToolScope = new AsyncLocalStorage();
 const NATIVE_PREFIX_COUNT = Symbol('mixdog.providerNativeToolPrefixCount');
+const finalizedProviderRequestTools = new WeakSet();
 let requestToolScopeGeneration = 0;
 
 function normalizedProvider(provider) {
@@ -15,6 +16,10 @@ export function providerNativeToolPrefixCount(requestTools, fallback = 0) {
   return Math.max(0, Math.min(Array.isArray(requestTools) ? requestTools.length : 0, Number(raw) || 0));
 }
 
+export function isFinalizedProviderRequestTools(requestTools) {
+  return Array.isArray(requestTools) && finalizedProviderRequestTools.has(requestTools);
+}
+
 export function finalizeProviderRequestTools(requestTools, nativePrefixCount = 0) {
   Object.defineProperty(requestTools, NATIVE_PREFIX_COUNT, {
     value: Math.max(0, Math.min(requestTools.length, Number(nativePrefixCount) || 0)),
@@ -22,6 +27,7 @@ export function finalizeProviderRequestTools(requestTools, nativePrefixCount = 0
     configurable: false,
     writable: false,
   });
+  finalizedProviderRequestTools.add(requestTools);
   return Object.freeze(requestTools);
 }
 

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

@@ -65,13 +65,12 @@ import {
   deleteWebhook,
   forgetDiscordToken,
   forgetTelegramToken,
-  forgetWebhookAuthtoken,
+  hasActiveAutomation,
   setChannel,
   saveDiscordToken,
   saveTelegramToken,
   saveSchedule,
   saveWebhook,
-  saveWebhookAuthtoken,
   setBackend,
   setBackendAsync,
   setScheduleEnabled,
@@ -1694,6 +1693,7 @@ export async function createMixdogSessionRuntime({
     getSession: () => session,
     isRemoteEnabled: () => remoteEnabled,
     channelsEnabled,
+    hasActiveAutomation,
     getCodeGraphModule,
     createCurrentSession,
     channels,
@@ -1884,10 +1884,6 @@ export async function createMixdogSessionRuntime({
       bootProfile('channels:start-skipped');
       return true;
     }
-    if (!channelsEnabled()) {
-      bootProfile('channels:start-disabled');
-      return true;
-    }
     if (closeRequested) return true;
     if (prewarmTimers.channelStartTimer) {
       clearTimeout(prewarmTimers.channelStartTimer);
@@ -1895,6 +1891,14 @@ export async function createMixdogSessionRuntime({
     }
     bootProfile('channels:start-scheduled', { delayMs: 0, immediate: true });
     void (async () => {
+      // Channels-module toggle gates MESSAGING only: automation (schedules/
+      // webhooks) still boots the worker — its backend runs headless when
+      // messaging is off or unconfigured (see channels/lib/config.mjs).
+      if (!channelsEnabled() && !(await hasActiveAutomation().catch(() => false))) {
+        bootProfile('channels:start-disabled');
+        remoteClaimPending = false;
+        return;
+      }
       // A backend switch may still be pending or writing asynchronously. Drain
       // it before the worker reads config; never race it with a sync lock wait.
       try { await flushBackendSave(); } catch {}
@@ -2035,9 +2039,9 @@ export async function createMixdogSessionRuntime({
   // early /remote (startRemote clears it), stopRemote(), and close() all
   // cancel it through the existing clearTimeout paths. Runtime /remote calls
   // still start immediately (user-initiated, UI already painted).
+  const remoteAutoStartDelayMs = envDelayMs('MIXDOG_REMOTE_AUTOSTART_DELAY_MS', 1_500, { min: 0, max: 60_000 });
   if (remoteEnabled || remoteAutoStartRequested) {
     const remoteStartIntent = remoteEnabled ? 'explicit' : 'auto';
-    const remoteAutoStartDelayMs = envDelayMs('MIXDOG_REMOTE_AUTOSTART_DELAY_MS', 1_500, { min: 0, max: 60_000 });
     bootProfile('channels:autostart-deferred', { delayMs: remoteAutoStartDelayMs, intent: remoteStartIntent });
     prewarmTimers.channelStartTimer = setTimeout(() => {
       prewarmTimers.channelStartTimer = null;
@@ -2048,6 +2052,23 @@ export async function createMixdogSessionRuntime({
       startRemote({ intent: remoteStartIntent });
     }, remoteAutoStartDelayMs);
     prewarmTimers.channelStartTimer.unref?.();
+  } else {
+    // Automation decoupling (user decision): enabled schedules/webhooks boot
+    // the worker on their own — no remote flag, no remote.autoStart, no
+    // messaging backend required. Claim-if-vacant auto intent reuses the
+    // exact autoStart semantics (a live owner elsewhere wins silently).
+    prewarmTimers.channelStartTimer = setTimeout(() => {
+      prewarmTimers.channelStartTimer = null;
+      if (closeRequested || remoteEnabled) return;
+      void hasActiveAutomation()
+        .then((active) => {
+          if (!active || closeRequested || remoteEnabled) return;
+          bootProfile('channels:automation-autostart');
+          startRemote({ intent: 'auto' });
+        })
+        .catch(() => { /* automation probe is best-effort */ });
+    }, remoteAutoStartDelayMs);
+    prewarmTimers.channelStartTimer.unref?.();
   }
 
   // Pure settings-delegate methods (onboarding status/skip, autoClear, profile,
@@ -2103,8 +2124,6 @@ export async function createMixdogSessionRuntime({
     forgetDiscordToken,
     saveTelegramToken,
     forgetTelegramToken,
-    saveWebhookAuthtoken,
-    forgetWebhookAuthtoken,
     setBackend,
   });
 

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

@@ -39,6 +39,12 @@ const SYNTHETIC_SESSION_TEXT_PATTERNS = Object.freeze([
   /^\[mixdog-runtime\]/i,
   /^\[(?:truncated|request interrupted by user)\]$/i,
   /^a previous model worked on this task and produced the compacted handoff summary below\b/i,
+  // Compact/auto-clear re-seed handoff variants: these lead the FIRST user
+  // message of every post-compaction session, so titling from them painted
+  // "Re-attached after compaction…" rows in Recent (user report). Skipping
+  // them titles the session from its first REAL user message instead.
+  /^re-attached after compaction\b/i,
+  /^reference files:\s/i,
   /^the async (?:agent|shell) task\b/i,
 ]);
 

package/src/session-runtime/settings-api.mjs

@@ -56,8 +56,6 @@ export function createSettingsApi({
   forgetDiscordToken,
   saveTelegramToken,
   forgetTelegramToken,
-  saveWebhookAuthtoken,
-  forgetWebhookAuthtoken,
   setBackend,
 }) {
   return {
@@ -378,15 +376,5 @@ export function createSettingsApi({
       scheduleBackendSave(value);
       return { ok: true, backend: value };
     },
-    saveWebhookAuthtoken(token) {
-      const result = saveWebhookAuthtoken(token);
-      reloadChannelsSoon();
-      return result;
-    },
-    forgetWebhookAuthtoken() {
-      const result = forgetWebhookAuthtoken();
-      reloadChannelsSoon();
-      return result;
-    },
   };
 }

package/src/session-runtime/tool-catalog-schema.mjs

@@ -13,6 +13,7 @@ import {
 } from '../runtime/agent/orchestrator/providers/custom-tool-wire.mjs';
 import {
   finalizeProviderRequestTools,
+  isFinalizedProviderRequestTools,
   providerNativeToolPrefixCount,
 } from './provider-request-tools.mjs';
 import {
@@ -101,7 +102,10 @@ export function toolSchemaBucket(tool) {
 export function estimateToolSchemaBreakdown(tools) {
   if (Array.isArray(tools)) {
     const cached = toolSchemaBreakdownMemo.get(tools);
-    if (sameToolSchemaEntries(cached, tools)) return cached.value;
+    if (cached && (
+      isFinalizedProviderRequestTools(tools)
+      || sameToolSchemaEntries(cached, tools)
+    )) return cached.value;
   }
   const out = {};
   const list = Array.isArray(tools) ? tools : [];

package/src/standalone/channel-admin.mjs

@@ -15,7 +15,6 @@ import {
   diagnoseDiscordTokenValue,
   getDiscordToken,
   getTelegramToken,
-  getWebhookAuthtoken,
   hasStoredSecret,
   readSection,
   saveSecret,
@@ -34,10 +33,12 @@ import {
 import {
   listEndpoints as dbListEndpoints,
   loadEndpointConfig as dbLoadEndpoint,
+  readEndpointSecret as dbReadEndpointSecret,
   upsertEndpoint as dbUpsertEndpoint,
   deleteEndpoint as dbDeleteEndpoint,
   setEndpointEnabled as dbSetEndpointEnabled,
 } from '../runtime/shared/webhooks-db.mjs';
+import { readHookPublicBase } from '../runtime/channels/lib/webhook/relay-tunnel.mjs';
 
 const NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
 const DEFAULT_CHANNELS = Object.freeze({
@@ -197,18 +198,6 @@ export function forgetTelegramToken() {
   return { ok: true };
 }
 
-export function saveWebhookAuthtoken(token) {
-  const value = String(token || '').trim();
-  if (!value) throw new Error('Webhook/ngrok authtoken is required');
-  saveSecret(SECRET_ACCOUNTS.webhookAuth, value);
-  return { ok: true, configured: Boolean(getWebhookAuthtoken()) };
-}
-
-export function forgetWebhookAuthtoken() {
-  deleteSecret(SECRET_ACCOUNTS.webhookAuth);
-  return { ok: true };
-}
-
 // Single-channel write: persists `cfg.channel`, keeping the per-backend id
 // fields (discordChannelId/telegramChatId) so a backend switch retains both
 // ids. `backend` selects which per-backend field the id updates; when omitted
@@ -254,7 +243,6 @@ export function setWebhookConfig(patch = {}) {
       ...(Object.prototype.hasOwnProperty.call(patch, 'enabled') ? { enabled: patch.enabled === true } : {}),
       ...(patch.port ? { port: Number(patch.port) || 3333 } : {}),
       ...(patch.domain ? { domain: String(patch.domain).trim() } : {}),
-      ...(patch.ngrokDomain ? { ngrokDomain: String(patch.ngrokDomain).trim() } : {}),
     },
   }));
 }
@@ -267,7 +255,6 @@ export async function setWebhookConfigAsync(patch = {}) {
       ...(Object.prototype.hasOwnProperty.call(patch, 'enabled') ? { enabled: patch.enabled === true } : {}),
       ...(patch.port ? { port: Number(patch.port) || 3333 } : {}),
       ...(patch.domain ? { domain: String(patch.domain).trim() } : {}),
-      ...(patch.ngrokDomain ? { ngrokDomain: String(patch.ngrokDomain).trim() } : {}),
     },
   }));
 }
@@ -486,7 +473,13 @@ export async function saveWebhook({
   if (overwrite !== true && (await dbLoadEndpoint(id))) {
     throw new Error(`webhook "${id}" already exists`);
   }
-  const secretValue = String(secret || randomBytes(24).toString('hex')).trim();
+  // Secret semantics: an explicit value always wins; an EMPTY value on an
+  // overwrite PRESERVES the stored secret (editing instructions must not
+  // silently rotate the key the external service was configured with); only
+  // a brand-new endpoint mints a random secret.
+  const secretValue = String(secret || '').trim()
+    || (overwrite === true ? String((await dbReadEndpointSecret(id)) || '').trim() : '')
+    || randomBytes(24).toString('hex');
   const saved = await dbUpsertEndpoint({
     name: id,
     description: String(description || '').trim(),
@@ -522,11 +515,32 @@ export async function setWebhookEnabled(name, enabled) {
   return { name: id, enabled: enabled !== false };
 }
 
+// Explicit single-purpose secret read for the editor's copy affordance (the
+// list path only ever exposes a presence flag). Local surfaces only — the
+// desktop blocks this capability over the remote bridge.
+export async function getWebhookSecret(name) {
+  const id = assertName(name, 'webhook name');
+  return { name: id, secret: (await dbReadEndpointSecret(id)) || '' };
+}
+
+// Automation presence: any enabled schedule or webhook endpoint. Drives the
+// worker boot decision independently of the messaging channels — schedules
+// and webhooks run sessions, so they must not require Discord/Telegram
+// tokens or an explicit remote toggle.
+export async function hasActiveAutomation() {
+  try {
+    const [schedules, webhooks] = await Promise.all([listSchedules(), listWebhooks()]);
+    return schedules.some((entry) => entry?.enabled !== false && entry?.status !== 'done')
+      || webhooks.some((entry) => entry?.enabled !== false);
+  } catch {
+    return false;
+  }
+}
+
 export async function channelSetup(config = null) {
   const cfg = normalizeChannelsConfig(config || readSection('channels'));
   const discordToken = getDiscordToken();
   const discordProblem = diagnoseDiscordTokenValue(discordToken, cfg);
-  const webhookAuth = getWebhookAuthtoken();
   const telegramToken = getTelegramToken();
   return {
     backend: cfg.backend || 'discord',
@@ -546,9 +560,9 @@ export async function channelSetup(config = null) {
     },
     webhook: {
       ...(cfg.webhook || {}),
-      authenticated: Boolean(webhookAuth),
-      stored: hasStoredSecret(SECRET_ACCOUNTS.webhookAuth),
-      status: webhookAuth ? 'Set' : 'Off',
+      // Relay-tunnel public base (null until the channel worker first
+      // connects and mints its hook identity).
+      publicUrl: readHookPublicBase(),
     },
     channel: getChannel(cfg),
     schedules: await listSchedules(),
@@ -560,7 +574,7 @@ async function renderChannelStatus(config = null) {
   const setup = await channelSetup(config);
   const lines = [];
   lines.push(`discord  ${setup.discord.status}${setup.discord.problem ? ` (${setup.discord.problem})` : ''}`);
-  lines.push(`webhook  ${setup.webhook.enabled === false ? 'disabled' : 'enabled'} · auth ${setup.webhook.status} · port ${setup.webhook.port || 3333}`);
+  lines.push(`webhook  ${setup.webhook.enabled === false ? 'disabled' : 'enabled'} · port ${setup.webhook.port || 3333}${setup.webhook.publicUrl ? ` · ${setup.webhook.publicUrl}` : ''}`);
   lines.push(`channel  ${setup.channel.channelId || '(unset)'}`);
   lines.push('schedules');
   if (setup.schedules.length === 0) lines.push('  (none)');

package/src/tui/App.jsx

@@ -1881,21 +1881,6 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
           resumeAfterChannelPrompt(channelPrompt);
           return true;
         }
-        if (channelPrompt.kind === 'webhook-token') {
-          if (!commandText) return false;
-          store.saveWebhookAuthtoken(commandText);
-          resumeAfterChannelPrompt(channelPrompt);
-          return true;
-        }
-        if (channelPrompt.kind === 'webhook-domain') {
-          if (!commandText) return false;
-          Promise.resolve(store.setWebhookConfig?.({ ngrokDomain: commandText }))
-            .then(() => resumeAfterChannelPrompt(channelPrompt))
-            .catch((e) => {
-              store.pushNotice(`webhook config update failed: ${e?.message || e}`, 'error');
-            });
-          return true;
-        }
         const parts = commandText.split('|').map((part) => part.trim());
         if (channelPrompt.kind === 'channel-add') {
           // Single-channel: the UI asks only for the channel id. Legacy

package/src/tui/app/channel-pickers.mjs

@@ -271,46 +271,30 @@ export function createChannelPickers({
       const returnTo = typeof options.returnTo === 'function'
         ? options.returnTo
         : () => setPicker(null);
-      const domain = setup.webhook?.ngrokDomain || setup.webhook?.domain || '';
+      const publicUrl = setup.webhook?.publicUrl || '';
       const items = [
         {
-          value: 'endpoint-domain',
-          label: 'ngrok domain',
-          description: domain ? domain : 'Not set · Enter ngrok domain',
-          _action: 'endpoint-domain',
-        },
-        {
-          value: 'endpoint-authtoken',
-          label: 'authtoken',
-          description: setup.webhook?.authenticated === true ? 'Set' : 'Not set · Enter authtoken',
-          _action: 'endpoint-authtoken',
+          value: 'endpoint-url',
+          label: 'Public URL',
+          description: publicUrl
+            ? `${publicUrl}/webhook/<name>`
+            : 'Assigned when the channel worker connects to the relay',
+          _action: 'endpoint-url',
         },
       ];
       setPicker({
         title: 'Webhook endpoint',
-        description: 'ngrok domain and authtoken. Toggle individual webhooks in /webhooks.',
+        description: 'Served through the Mixdog relay — no tunnel setup needed. Toggle individual webhooks in /webhooks.',
         help: '↑/↓ Select · Enter Edit · Esc Back',
         indexMode: 'always',
         labelWidth: 18,
         items,
         onSelect: (_value, item) => {
           try {
-            if (item._action === 'endpoint-domain') {
-              openChannelPrompt({
-                kind: 'webhook-domain',
-                label: 'ngrok domain',
-                hint: 'Paste the reserved ngrok domain (e.g. my-app.ngrok-free.app).',
-                afterSave: () => void openChannelSetupPicker('webhook-endpoint', options),
-              });
-              return;
-            }
-            if (item._action === 'endpoint-authtoken') {
-              openChannelPrompt({
-                kind: 'webhook-token',
-                label: 'Webhook/ngrok authtoken',
-                hint: 'Paste the webhook/ngrok authtoken. It is stored in the OS keychain.',
-                afterSave: () => void openChannelSetupPicker('webhook-endpoint', options),
-              });
+            if (item._action === 'endpoint-url') {
+              store.pushNotice(publicUrl
+                ? `Webhook base: ${publicUrl}/webhook/<name>`
+                : 'URL not assigned yet — start channels once and reopen.', 'info');
             }
           } catch (e) {
             store.pushNotice(`webhook endpoint failed: ${e?.message || e}`, 'error');
@@ -465,20 +449,12 @@ export function createChannelPickers({
       {
         value: 'webhook-endpoint',
         label: 'Webhook endpoint',
-        meta: (() => {
-          const hasDomain = Boolean(setup.webhook?.ngrokDomain || setup.webhook?.domain);
-          const hasAuth = setup.webhook?.authenticated === true;
-          return (hasDomain && hasAuth) ? 'On' : 'Off';
-        })(),
-        description: (() => {
-          const hasDomain = Boolean(setup.webhook?.ngrokDomain || setup.webhook?.domain);
-          const hasAuth = setup.webhook?.authenticated === true;
-          const needs = [
-            ...(hasDomain ? [] : ['domain']),
-            ...(hasAuth ? [] : ['authtoken']),
-          ];
-          return needs.length ? `Needs ${needs.join(' + ')}` : 'ngrok domain and authtoken set';
-        })(),
+        // Relay tunnel: public exposure is automatic, so the endpoint is
+        // "On" whenever the webhook server itself is enabled.
+        meta: setup.webhook?.enabled === false ? 'Off' : 'On',
+        description: setup.webhook?.publicUrl
+          ? setup.webhook.publicUrl
+          : 'Mixdog relay tunnel — URL assigned on first run',
         _action: 'webhook-endpoint',
       },
     ];

package/src/tui/app/doctor.mjs

@@ -165,7 +165,6 @@ export async function buildDoctorReport(runtime = {}, getState = () => ({})) {
     const tokens = [];
     if (setup.discord?.authenticated) tokens.push('discord');
     if (setup.telegram?.authenticated) tokens.push('telegram');
-    if (setup.webhook?.authenticated) tokens.push('webhook');
     const running = worker.running === true;
     const detail = `enabled · worker ${running ? 'running' : 'stopped'} · tokens: ${tokens.length ? tokens.join(', ') : 'none'}`;
     row(running ? 'ok' : 'warn', detail);

package/src/tui/app/transcript-window.mjs

@@ -303,6 +303,22 @@ export function hasStreamingRowStateToPrune() {
     || streamingTailEstimateById.size > 0;
 }
 
+export function transcriptHarvestInputsEqual(left, right) {
+  return !!left && !!right
+    && left.revision === right.revision
+    && left.settledItems === right.settledItems
+    && left.streamingTailItem === right.streamingTailItem
+    && left.startIndex === right.startIndex
+    && left.endIndex === right.endIndex
+    && left.frameColumns === right.frameColumns
+    && left.toolOutputExpanded === right.toolOutputExpanded
+    && left.transcriptContentHeight === right.transcriptContentHeight
+    && left.floatingPanelRows === right.floatingPanelRows
+    && left.overlayHintRequested === right.overlayHintRequested
+    && left.transcriptGuardRows === right.transcriptGuardRows
+    && left.themeEpoch === right.themeEpoch;
+}
+
 /** Drop streamingMeasuredRowsById entries for ids no longer mounted, so the
  * store does not grow unbounded over a long session (mirrors the id→item /
  * id→callback map pruning already done for the mounted set). */

package/src/tui/app/use-transcript-window.mjs

@@ -29,6 +29,7 @@ import {
   TRANSCRIPT_WINDOW_OVERSCAN_ROWS,
   upperBound,
   shiftSelectionRectY,
+  transcriptHarvestInputsEqual,
 } from './transcript-window.mjs';
 import { shouldSuppressFullyFailedToolItem } from '../transcript-tool-failures.mjs';
 
@@ -125,6 +126,11 @@ export function useTranscriptWindow({
   // overscan band).
   const transcriptItemElsRef = useRef(new Map());
   const transcriptMeasureRefCache = useRef(new Map());
+  const harvestGateRef = useRef({
+    inputs: null,
+    skippedForDrag: false,
+    forceNext: false,
+  });
   // id → latest item object for this render. The callback ref reads from here so
   // a reused (stable) callback never captures a stale item across patches.
   const transcriptMeasureItemsRef = useRef(new Map());
@@ -516,6 +522,20 @@ export function useTranscriptWindow({
     && floatingPanelRows <= 0
     && transcriptGuardRows > 0
     && !overlayHintOnLastItem;
+  const harvestInputs = {
+    revision,
+    settledItems,
+    streamingTailItem,
+    startIndex: transcriptWindow.startIndex,
+    endIndex: transcriptWindow.endIndex,
+    frameColumns,
+    toolOutputExpanded,
+    transcriptContentHeight,
+    floatingPanelRows,
+    overlayHintRequested,
+    transcriptGuardRows,
+    themeEpoch,
+  };
   // ── App-level measured height harvest ───────────────────────────────────
   // Runs after EVERY commit (no deps): Yoga has just laid out the mounted rows,
   // so each tracked item Box's getComputedHeight() is its REAL terminal height.
@@ -528,6 +548,7 @@ export function useTranscriptWindow({
   // follow path already keeps them visually stable.
   useLayoutEffect(() => {
     if (!TRANSCRIPT_MEASURED_ROWS) return;
+    const gate = harvestGateRef.current;
     // Skip the per-row Yoga harvest while a drag is in progress. Edge auto-
     // scroll commits setScrollOffset on every pointer motion, but the mounted
     // rows' real heights do not change during a drag — only their scroll
@@ -535,9 +556,18 @@ export function useTranscriptWindow({
     // variantKey check per row) for no height change, which is pure drag
     // overhead on a tall transcript. The cached measurements stay authoritative
     // for the row-index math; a single re-measure is forced on release below.
-    if (dragRef.current.active) return;
+    if (dragRef.current.active) {
+      gate.skippedForDrag = true;
+      return;
+    }
+    if (!gate.skippedForDrag
+      && !gate.forceNext
+      && transcriptHarvestInputsEqual(gate.inputs, harvestInputs)) return;
     const els = transcriptItemElsRef.current;
     if (!els || els.size === 0) return;
+    gate.inputs = harvestInputs;
+    gate.skippedForDrag = false;
+    gate.forceNext = false;
     const liveItems = transcriptMeasureItemsRef.current;
     const toolExpandedFlag = toolOutputExpanded ? 1 : 0;
     let changed = false;
@@ -655,6 +685,11 @@ export function useTranscriptWindow({
           }, 0);
           if (typeof streak.timer?.unref === 'function') streak.timer.unref();
         }
+        // Preserve the original convergence contract: a measurement-driven
+        // render gets one confirmation harvest even when no external layout
+        // input changed. Stable rows stop there; a real oscillation continues
+        // until the existing circuit breaker trips.
+        gate.forceNext = true;
         setMeasuredRowsVersion((v) => (v + 1) % 1000000);
       }
     }

package/src/tui/components/Markdown.jsx

@@ -80,6 +80,14 @@ export function Markdown({ children, themeEpoch = 0, trimPartialFences = false,
   );
 }
 
+const StableMarkdownChunk = React.memo(function StableMarkdownChunk({
+  text,
+  themeEpoch,
+  columns,
+}) {
+  return <Markdown themeEpoch={themeEpoch} columns={columns}>{text}</Markdown>;
+});
+
 export function StreamingMarkdown({ children, themeEpoch = 0, columns, streamKey }) {
   const parts = resolveStreamingMarkdownParts(children, streamKey);
   if (parts.plain) {
@@ -89,9 +97,15 @@ export function StreamingMarkdown({ children, themeEpoch = 0, columns, streamKey
     // identical visible text directly.
     return <Text color={theme.text} wrap="wrap">{parts.unstableForRender}</Text>;
   }
+  const stableChunks = parts.stableChunks?.length
+    ? parts.stableChunks
+    : parts.stablePrefix ? [parts.stablePrefix] : [];
   return (
     <Box flexDirection="column" gap={1}>
-      {parts.stablePrefix ? <Markdown themeEpoch={themeEpoch} columns={columns}>{parts.stablePrefix}</Markdown> : null}
+      {stableChunks.map((text, index) => (
+        <StableMarkdownChunk key={`stable-${index}`} text={text}
+          themeEpoch={themeEpoch} columns={columns} />
+      ))}
       {parts.unstableSuffix
         ? <Markdown themeEpoch={themeEpoch} columns={columns} trimPartialFences>{parts.unstableForRender}</Markdown>
         : null}

package/src/tui/components/Message.jsx

@@ -50,7 +50,7 @@ export const AssistantMessage = React.memo(function AssistantMessage({
 
   const bodyWidth = assistantBodyWidth(columns);
   const renderText = streaming && streamingWindowRows > 0
-    ? windowPlainStreamingText(text, bodyWidth, streamingWindowRows)
+    ? windowPlainStreamingText(text, bodyWidth, streamingWindowRows, assistantId)
     : text;
   return (
     <Box flexDirection="row" marginTop={1}>