mixdog 0.9.64 → 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/runtime/shared/turn-snapshot.mjs

@@ -0,0 +1,184 @@
+// Turn-scoped worktree snapshots over a SHADOW git repository.
+//
+// A per-worktree bare repo lives under <data>/turn-snapshots/<hash>; `git
+// --git-dir <shadow> --work-tree <project>` add/write-tree captures the whole
+// worktree as a tree object WITHOUT touching the project's own git state (or
+// requiring the project to be a git repo at all). Diffing the turn-start tree
+// against the current tree therefore reports EVERYTHING a turn changed —
+// lead edits, subagent edits, background shell jobs, even external editors —
+// which transcript-parsed patches structurally cannot see.
+//
+// Costs: the first track() of a project hashes the worktree once (mitigated
+// by reusing the project's own .git objects via alternates); every later
+// track() is an index stat-scan. All entry points are best-effort and never
+// throw into the turn path. MIXDOG_TURN_SNAPSHOT=0 disables the feature.
+import { execFile } from 'child_process';
+import { createHash } from 'crypto';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { resolvePluginData } from './plugin-paths.mjs';
+
+const DISABLED = /^(0|false|off)$/i.test(String(process.env.MIXDOG_TURN_SNAPSHOT || ''));
+const GIT_TIMEOUT_MS = 120_000;
+const BEGIN_WAIT_CAP_MS = 1_500;
+const MAX_PATCH_BYTES = 2_000_000;
+const BASE_CACHE_MAX = 32;
+const FAILURE_BACKOFF_MS = 5 * 60_000;
+
+const _queues = new Map();        // gitdir → tail promise (serialize per repo)
+const _baseBySession = new Map(); // sessionId → { worktree, tree, at }
+const _failedUntil = new Map();   // gitdir → timestamp
+
+function _worktreeKey(worktree) {
+  const raw = String(worktree || '').trim();
+  if (!raw) return '';
+  const full = resolve(raw);
+  return process.platform === 'win32' ? full.toLowerCase() : full;
+}
+
+function _gitDirFor(worktreeKey) {
+  const hash = createHash('sha1').update(worktreeKey).digest('hex').slice(0, 20);
+  return join(resolvePluginData(), 'turn-snapshots', hash);
+}
+
+function _git(args, { cwd } = {}) {
+  return new Promise((resolveExec) => {
+    execFile('git', args, {
+      cwd: cwd || undefined,
+      windowsHide: true,
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: 64 * 1024 * 1024,
+    }, (error, stdout, stderr) => {
+      resolveExec({ code: error ? (error.code ?? 1) : 0, stdout: String(stdout || ''), stderr: String(stderr || '') });
+    });
+  });
+}
+
+// Serialize all git operations per shadow repo: concurrent index writes would
+// corrupt each other, and turn-start/track/diff can overlap freely otherwise.
+function _enqueue(gitdir, task) {
+  const tail = (_queues.get(gitdir) || Promise.resolve()).then(task, task);
+  _queues.set(gitdir, tail.catch(() => {}));
+  return tail;
+}
+
+async function _ensureRepo(worktree, gitdir) {
+  if (existsSync(join(gitdir, 'HEAD'))) return true;
+  mkdirSync(gitdir, { recursive: true });
+  const init = await _git(['init', '--bare', '--quiet', gitdir]);
+  if (init.code !== 0) return false;
+  // The shadow repo indexes the project via --work-tree; never let it descend
+  // into the project's real .git, and keep bytes stable/gc quiet.
+  await _git(['--git-dir', gitdir, 'config', 'core.bare', 'false']);
+  await _git(['--git-dir', gitdir, 'config', 'core.autocrlf', 'false']);
+  await _git(['--git-dir', gitdir, 'config', 'gc.auto', '0']);
+  try {
+    mkdirSync(join(gitdir, 'info'), { recursive: true });
+    writeFileSync(join(gitdir, 'info', 'exclude'), '.git/\n');
+    // First-snapshot cost: reuse the project's own git objects so unchanged
+    // blobs need no re-hash/store (the opencode chromium lesson).
+    const projectObjects = join(worktree, '.git', 'objects');
+    if (existsSync(projectObjects)) {
+      mkdirSync(join(gitdir, 'objects', 'info'), { recursive: true });
+      writeFileSync(join(gitdir, 'objects', 'info', 'alternates'), `${projectObjects}\n`);
+    }
+  } catch { /* exclusions/alternates are optimizations, not requirements */ }
+  return true;
+}
+
+// Capture the current worktree as a tree object; null on any failure.
+async function _trackTree(worktree) {
+  const key = _worktreeKey(worktree);
+  if (!key || !existsSync(key)) return null;
+  const gitdir = _gitDirFor(key);
+  const failedUntil = _failedUntil.get(gitdir) || 0;
+  if (Date.now() < failedUntil) return null;
+  return _enqueue(gitdir, async () => {
+    if (!(await _ensureRepo(key, gitdir))) {
+      _failedUntil.set(gitdir, Date.now() + FAILURE_BACKOFF_MS);
+      return null;
+    }
+    const base = ['--git-dir', gitdir, '--work-tree', key];
+    const add = await _git([...base, 'add', '-A', '--', '.'], { cwd: key });
+    if (add.code !== 0) {
+      _failedUntil.set(gitdir, Date.now() + FAILURE_BACKOFF_MS);
+      return null;
+    }
+    const tree = await _git([...base, 'write-tree'], { cwd: key });
+    if (tree.code !== 0) return null;
+    const hash = tree.stdout.trim();
+    return /^[0-9a-f]{40,64}$/.test(hash) ? hash : null;
+  });
+}
+
+/** Fire-and-forget shadow-repo warmup so a project's first turn never pays
+ *  the initial full snapshot inline. */
+export function prewarmTurnSnapshot(worktree) {
+  if (DISABLED || !worktree) return;
+  void _trackTree(worktree).catch(() => {});
+}
+
+/** Capture the turn base tree for a session. Waits at most BEGIN_WAIT_CAP_MS
+ *  so a cold first snapshot cannot stall the turn; a slower capture still
+ *  lands through the shared promise and applies to this turn retroactively. */
+export async function beginTurnSnapshot(worktree, sessionId) {
+  if (DISABLED || !worktree || !sessionId) return;
+  const key = _worktreeKey(worktree);
+  const capture = _trackTree(worktree).then((tree) => {
+    if (!tree) return;
+    _baseBySession.delete(sessionId);
+    _baseBySession.set(sessionId, { worktree: key, tree, at: Date.now() });
+    while (_baseBySession.size > BASE_CACHE_MAX) {
+      const oldest = _baseBySession.keys().next().value;
+      if (oldest === undefined) break;
+      _baseBySession.delete(oldest);
+    }
+  }).catch(() => {});
+  await Promise.race([capture, new Promise((r) => { const t = setTimeout(r, BEGIN_WAIT_CAP_MS); t.unref?.(); })]);
+}
+
+/** Diff the session's turn-start tree against the CURRENT worktree state.
+ *  Returns { supported, files:[{name, additions, deletions}], patch }. */
+export async function getTurnReviewDiff(worktree, sessionId) {
+  if (DISABLED) return { supported: false, files: [], patch: '' };
+  const key = _worktreeKey(worktree);
+  const base = sessionId ? _baseBySession.get(sessionId) : null;
+  if (!key) return { supported: false, files: [], patch: '' };
+  if (!base || base.worktree !== key) {
+    return { supported: true, files: [], patch: '', reason: 'no-base' };
+  }
+  const head = await _trackTree(worktree);
+  if (!head) return { supported: false, files: [], patch: '' };
+  if (head === base.tree) return { supported: true, files: [], patch: '', baseTree: base.tree, headTree: head };
+  const gitdir = _gitDirFor(key);
+  const argsBase = ['--git-dir', gitdir];
+  const [numstat, patch] = await Promise.all([
+    _git([...argsBase, 'diff-tree', '-r', '--numstat', '-z', base.tree, head]),
+    _git([...argsBase, 'diff-tree', '-r', '-p', '--no-color', base.tree, head]),
+  ]);
+  if (numstat.code !== 0) return { supported: false, files: [], patch: '' };
+  const files = [];
+  const fields = numstat.stdout.split('\0').filter(Boolean);
+  for (const row of fields) {
+    const match = row.match(/^(\d+|-)\t(\d+|-)\t([\s\S]+)$/);
+    if (!match) continue;
+    files.push({
+      name: match[3],
+      additions: match[1] === '-' ? 0 : Number(match[1]),
+      deletions: match[2] === '-' ? 0 : Number(match[2]),
+    });
+  }
+  let patchText = patch.code === 0 ? patch.stdout : '';
+  if (patchText.length > MAX_PATCH_BYTES) {
+    patchText = patchText.slice(0, MAX_PATCH_BYTES);
+    const cut = patchText.lastIndexOf('\ndiff --git ');
+    if (cut > 0) patchText = patchText.slice(0, cut + 1);
+  }
+  return { supported: true, files, patch: patchText, baseTree: base.tree, headTree: head };
+}
+
+export function _resetTurnSnapshotForTest() {
+  _queues.clear();
+  _baseBySession.clear();
+  _failedUntil.clear();
+}

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/runtime-core.mjs

@@ -231,6 +231,7 @@ import { attachSessionHooks } from './session-hooks.mjs';
 import { createQuickModelRows } from './quick-model-rows.mjs';
 import { createWarmupSchedulers } from './warmup-schedulers.mjs';
 import { createPrewarmSchedulers } from './prewarm.mjs';
+import { getTurnReviewDiff as getTurnSnapshotReviewDiff } from '../runtime/shared/turn-snapshot.mjs';
 import { createMcpGlue } from './mcp-glue.mjs';
 import { createCwdPlugins } from './cwd-plugins.mjs';
 import { createSettingsApi } from './settings-api.mjs';
@@ -2303,6 +2304,9 @@ export async function createMixdogSessionRuntime({
     ...settingsApi,
     ...channelConfigApi,
     ...providerAuthApi,
+    // Turn-scoped worktree diff (shadow snapshot): everything changed since
+    // the current turn's base tree, regardless of which agent/process wrote it.
+    getTurnReviewDiff: () => getTurnSnapshotReviewDiff(currentCwd, session?.id),
     get id() {
       return session?.id || null;
     },

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

@@ -10,6 +10,7 @@ import {
   refreshInitialDeferredMcpSurface,
 } from './tool-catalog.mjs';
 import { getMcpTools } from '../runtime/agent/orchestrator/mcp/client.mjs';
+import { beginTurnSnapshot } from '../runtime/shared/turn-snapshot.mjs';
 
 export function splitToolStatusCounts(rows) {
   const list = Array.isArray(rows) ? rows : [];
@@ -107,6 +108,12 @@ export function createSessionTurnApi(deps) {
           }
         }
         const session0 = getSession();
+        // Turn-review base: capture the pre-turn worktree tree in the shadow
+        // snapshot repo so the desktop review bar can diff EVERYTHING this
+        // turn changes — subagent and background-job edits included. The wait
+        // is capped so a cold first snapshot never stalls the turn; a late
+        // base still lands through the shared promise.
+        try { await beginTurnSnapshot(getCurrentCwd(), session0?.id); } catch { /* never blocks a turn */ }
         if (session0.deferredInitialRefreshPending) {
           // FIRST TURN of a FRESH session (session-local gate, NOT the
           // process-wide firstTurnCompleted): an MCP server may have finished its

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.jsx

@@ -3508,7 +3508,7 @@ export function App({ store, initialStatusLine = '', forceOnboarding = false })
         ) : null}
         <StatusLine
           sessionId={state.sessionId}
-          clientHostPid={state.clientHostPid}
+          clientHostPid={state.ownerClientHostPid || state.clientHostPid}
           provider={state.provider}
           model={state.model}
           effort={state.effort}

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);
       }
     }