mixdog 0.9.65 → 0.9.66

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

@@ -36,25 +36,67 @@ function _isPreviewNoise(text) {
     return isSessionPreviewNoise(text);
 }
 
-function _sessionPreview(session) {
-    const messages = Array.isArray(session?.messages) ? session.messages : [];
-    for (const m of messages) {
-        if (m?.role !== 'user') continue;
-        const raw = _messageText(m.content);
-        if (_isPreviewNoise(raw)) continue;
-        const text = _cleanPreview(raw);
-        if (text) return text;
-    }
-    return '';
+const sessionMessageProjectionMemo = new WeakMap();
+
+function _previewFromMessage(message) {
+    if (message?.role !== 'user') return '';
+    const raw = _messageText(message.content);
+    if (_isPreviewNoise(raw)) return '';
+    return _cleanPreview(raw);
 }
 
-function _sessionMessageCount(session) {
+function _sessionMessageProjection(session) {
     const messages = Array.isArray(session?.messages) ? session.messages : [];
+    const cached = session && typeof session === 'object'
+        ? sessionMessageProjectionMemo.get(session)
+        : null;
+    let start = 0;
     let count = 0;
-    for (const m of messages) {
-        if (m && (m.role === 'user' || m.role === 'assistant')) count++;
+    let preview = '';
+    let previewMessage = null;
+    const canAppend = cached
+        && messages.length >= cached.length
+        && (cached.length === 0 || messages[cached.length - 1] === cached.lastMessage);
+    if (canAppend) {
+        start = cached.length;
+        count = cached.count;
+        preview = cached.preview;
+        previewMessage = cached.previewMessage;
+        // The first real user message is stable in normal append-only session
+        // flow, but refresh it cheaply so an in-place content scrub still
+        // invalidates the cached title source without rescanning the transcript.
+        if (previewMessage) {
+            const refreshed = _previewFromMessage(previewMessage);
+            if (refreshed) preview = refreshed;
+            else {
+                start = 0;
+                count = 0;
+                preview = '';
+                previewMessage = null;
+            }
+        }
     }
-    return count;
+    for (let index = start; index < messages.length; index += 1) {
+        const message = messages[index];
+        if (message && (message.role === 'user' || message.role === 'assistant')) count += 1;
+        if (!preview) {
+            const candidate = _previewFromMessage(message);
+            if (candidate) {
+                preview = candidate;
+                previewMessage = message;
+            }
+        }
+    }
+    if (session && typeof session === 'object') {
+        sessionMessageProjectionMemo.set(session, {
+            length: messages.length,
+            lastMessage: messages[messages.length - 1] || null,
+            count,
+            preview,
+            previewMessage,
+        });
+    }
+    return { count, preview };
 }
 
 function _positiveNumber(value, fallback = 0) {
@@ -79,9 +121,14 @@ function _desktopSessionSummary(value, cwd = null) {
 
 export function _sessionSummary(session) {
     if (!session?.id) return null;
+    const messageProjection = _sessionMessageProjection(session);
     return {
         id: String(session.id),
         updatedAt: _positiveNumber(session.updatedAt, Date.now()),
+        // Conversation activity is intentionally separate from lifecycle
+        // bookkeeping. Resume/detach saves can advance updatedAt without a
+        // user-visible turn and must not reshuffle Recent session lists.
+        lastUsedAt: _positiveNumber(session.lastUsedAt, 0),
         createdAt: _positiveNumber(session.createdAt, 0),
         lastHeartbeatAt: _positiveNumber(session.lastHeartbeatAt, 0),
         closed: session.closed === true,
@@ -101,8 +148,8 @@ export function _sessionSummary(session) {
         task_id: session.task_id || session.taskId || null,
         permission: session.permission || null,
         toolPermission: session.toolPermission || null,
-        messageCount: _sessionMessageCount(session),
-        preview: _sessionPreview(session),
+        messageCount: messageProjection.count,
+        preview: messageProjection.preview,
         generation: typeof session.generation === 'number' ? session.generation : 0,
         implicitBashSessionId: session.implicitBashSessionId || null,
     };
@@ -113,6 +160,7 @@ function _normalizeSummaryRow(row) {
     return {
         id: row.id,
         updatedAt: _positiveNumber(row.updatedAt, 0),
+        lastUsedAt: _positiveNumber(row.lastUsedAt, 0),
         createdAt: _positiveNumber(row.createdAt, 0),
         lastHeartbeatAt: _positiveNumber(row.lastHeartbeatAt, 0),
         closed: row.closed === true,
@@ -173,6 +221,12 @@ const _pendingUpserts = new Map(); // id → summary row (latest wins)
 const _pendingRemovals = new Set(); // ids to drop (upsert/removal are mutually exclusive per id)
 let _summaryRetryTimer = null;
 let _summaryFlushScheduled = false;
+let _summaryFlushInflight = 0;
+
+export function _hasUnsettledSummaryOps() {
+    return _pendingUpserts.size > 0 || _pendingRemovals.size > 0
+        || _summaryFlushScheduled || _summaryFlushInflight > 0;
+}
 
 function _scheduleSummaryRetry() {
     if (_summaryRetryTimer) return;
@@ -206,6 +260,7 @@ export function _flushPendingSummaryOps({ sync = false } = {}) {
     _pendingRemovals.clear();
     const mutate = (cur) => {
             const index = _normalizeSummaryIndex(cur);
+            const existingById = new Map(index.rows.map((row) => [row.id, row]));
             let changed = false;
             const rows = index.rows.filter((r) => {
                 if (removals.has(r.id) || upserts.has(r.id)) { changed = true; return false; }
@@ -214,7 +269,7 @@ export function _flushPendingSummaryOps({ sync = false } = {}) {
             for (const row of upserts.values()) {
                 const cleanRow = _normalizeSummaryRow(row);
                 if (!cleanRow) continue;
-                const existing = index.rows.find((r) => r.id === cleanRow.id) || null;
+                const existing = existingById.get(cleanRow.id) || null;
                 if (existing && JSON.stringify(existing) === JSON.stringify(cleanRow)) {
                     rows.push(existing);
                     continue;
@@ -248,12 +303,18 @@ export function _flushPendingSummaryOps({ sync = false } = {}) {
         } catch { requeue(); }
         return;
     }
+    _summaryFlushInflight++;
     updateJsonAtomic(summaryIndexPath(), mutate, { compact: true, lock: true, timeoutMs: SUMMARY_LOCK_TIMEOUT_MS })
-        .catch(() => { requeue(); });
+        .catch(() => { requeue(); })
+        .finally(() => { _summaryFlushInflight--; });
 }
 
 export function _upsertSessionSummary(session) {
     const row = _sessionSummary(session);
+    _upsertSessionSummaryRow(row);
+}
+
+export function _upsertSessionSummaryRow(row) {
     if (!row) return;
     _pendingRemovals.delete(row.id);
     _pendingUpserts.set(row.id, row);

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

@@ -20,6 +20,10 @@ const LEAD_OWNERS = new Set(['cli', 'user', 'mixdog', 'legacy']);
 function isLeadVisibleRow(row) {
     const owner = String(row.owner || 'user').trim().toLowerCase();
     if (owner && !LEAD_OWNERS.has(owner)) return false;
+    // Mirror listLeadSessions: a previewless zero-message row is an unusable
+    // scratch (desktop boot leftovers, crashed first turns) — resuming it
+    // shows an empty conversation, so the catalog hides it.
+    if (!row.preview && row.messageCount === 0) return false;
     const sourceType = String(row.sourceType || '').trim().toLowerCase();
     const sourceName = String(row.sourceName || '').trim().toLowerCase();
     const agent = String(row.agent || '').trim().toLowerCase();

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

@@ -34,6 +34,7 @@ import {
     _removeSessionSummary,
     _pruneSummaryIndexIds,
     _flushPendingSummaryOps,
+    _hasUnsettledSummaryOps,
 } from './store-summary-index.mjs';
 // Facade re-export: summary-index API moved to store-summary-index.mjs; keep
 // prior importers of store.mjs unchanged.
@@ -68,6 +69,9 @@ export { saveSessionAsync, saveSessionAsyncDeferred } from './store/save-worker.
 
 /** Module-level map tracking in-flight saves per session ID to prevent concurrent write corruption. */
 const _savePending = new Map();
+// Disk mtime of the summary index at the last time it was read into (or
+// refreshed as) the in-memory cache base — cross-process staleness detector.
+let _summaryIndexMtimeSeen = 0;
 
 
 /**
@@ -836,7 +840,12 @@ function _overlayUnpersistedSummaryRows(rows, invalidStorageIds = new Set()) {
 function rebuildSessionSummaryIndex() {
     _ensureSummaryCacheDataDir();
     const { rows } = _scanStoredSessionSummaryRows();
-    return _setSummaryRowsCache(_writeSummaryIndex(rows));
+    const indexedRows = _writeSummaryIndex(rows);
+    // This process just authored the new cache base. Remember its mtime so the
+    // next local save cannot mistake the rebuild for a cross-process update
+    // and replace a newer in-memory row with the just-obsoleted sidecar.
+    try { _summaryIndexMtimeSeen = statSync(summaryIndexPath()).mtimeMs || 0; } catch { /* stat only */ }
+    return _setSummaryRowsCache(indexedRows);
 }
 
 export function listStoredSessionSummaries(options = {}) {
@@ -867,7 +876,30 @@ export function listStoredSessionSummaries(options = {}) {
             return [];
         }
     }
-    if (_summaryRowsCache !== null) return _cachedSummaryRows().slice();
+    if (_summaryRowsCache !== null) {
+        // A local session save has already updated the in-memory cache but its
+        // non-blocking sidecar merge may still be queued/in flight. Re-reading
+        // the older sidecar in that window would temporarily erase the new row.
+        if (_hasUnsettledSummaryOps()) return _cachedSummaryRows().slice();
+        // Cross-process freshness: another live process (terminal CLI owning a
+        // session this surface only views) advances messageCount/updatedAt by
+        // rewriting the summary index FILE — an in-memory cache that never
+        // looks back at disk serves frozen rows forever (user: the unread dot
+        // never fired for terminal-owned growth). One stat per call; when the
+        // index advanced, re-read the cheap index JSON as the new cache base
+        // (local optimistic overlays stay applied on top).
+        let diskMtime = 0;
+        try { diskMtime = statSync(summaryIndexPath()).mtimeMs || 0; } catch { /* no index yet */ }
+        if (diskMtime <= _summaryIndexMtimeSeen) return _cachedSummaryRows().slice();
+        try {
+            const raw = JSON.parse(readFileSync(summaryIndexPath(), 'utf-8'));
+            if (Number(raw?.version) === SESSION_SUMMARY_INDEX_VERSION) {
+                _summaryIndexMtimeSeen = diskMtime;
+                return _setSummaryRowsCache(_normalizeSummaryIndex(raw).rows).slice();
+            }
+        } catch { /* torn concurrent write — keep serving the cache; retry next call */ }
+        return _cachedSummaryRows().slice();
+    }
 
     let indexedRows = [];
     let p;
@@ -879,6 +911,9 @@ export function listStoredSessionSummaries(options = {}) {
             const raw = JSON.parse(readFileSync(p, 'utf-8'));
             hasIndex = Number(raw?.version) === SESSION_SUMMARY_INDEX_VERSION;
             if (hasIndex) indexedRows = _normalizeSummaryIndex(raw).rows;
+            if (hasIndex) {
+                try { _summaryIndexMtimeSeen = statSync(p).mtimeMs || 0; } catch { /* stat only */ }
+            }
         }
     } catch { /* unreadable/malformed sidecar falls through to rebuild */ }
 

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/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/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/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}>

package/src/tui/components/PromptInput.jsx

@@ -126,6 +126,7 @@ export function PromptInput({
   // that node's REAL laid-out position + our caret col/row — no external
   // absolute-coordinate guessing, so it never drifts).
   const boxRef = useRef(null);
+  const inkRootRef = useRef(null);
   const cursorEnabledRef = useRef(false); // latest enabled state, read by the anchor fn at render time
   const contentWidthRef = useRef(80);
   const preferredColumnRef = useRef(null);
@@ -154,9 +155,15 @@ export function PromptInput({
   // (slower) rendering, never a crash.
   const flushThrottleRef = useRef({ lastAt: 0, timer: null });
   const flushImmediate = () => {
+    const cachedRoot = inkRootRef.current;
+    if (typeof cachedRoot?.onImmediateRender === 'function') {
+      cachedRoot.onImmediateRender();
+      return;
+    }
     let node = boxRef.current;
     for (let i = 0; node && i < 64; i++) {
       if (node.nodeName === 'ink-root') {
+        inkRootRef.current = node;
         if (typeof node.onImmediateRender === 'function') node.onImmediateRender();
         return;
       }